username
stringlengths 1
36
| repo
stringlengths 1
82
| path
stringlengths 4
161
| function
stringlengths 0
328
| code
stringlengths 15
240k
| func_defs
stringlengths 0
313k
| llvm
stringclasses 1
value | hash
stringlengths 64
64
| memory
int64 15
240k
|
|---|---|---|---|---|---|---|---|---|
AlwinEsch | kodi-agile | xbmc/utils/Screenshot.cpp | CScreenShot::TakeScreenshot |
void CScreenShot::TakeScreenshot(const std::string &filename, bool sync)
{
CScreenshotSurface surface;
if (!surface.capture())
{
CLog::Log(LOGERROR, "Screenshot %s failed", CURL::GetRedacted(filename).c_str());
return;
}
CLog::Log(LOGDEBUG, "Saving screenshot %s", CURL::GetRedacted(filename).c_str());
for (int y = 0; y < surface.m_height; y++)
{
unsigned char* alphaptr = surface.m_buffer - 1 + y * surface.m_stride;
for (int x = 0; x < surface.m_width; x++)
*(alphaptr += 4) = 0xFF;
}
if (sync)
{
if (!CPicture::CreateThumbnailFromSurface(surface.m_buffer, surface.m_width, surface.m_height, surface.m_stride, filename))
CLog::Log(LOGERROR, "Unable to write screenshot %s", CURL::GetRedacted(filename).c_str());
delete [] surface.m_buffer;
surface.m_buffer = NULL;
}
else
{
FILE* fp = fopen(filename.c_str(), "w");
if (fp)
fclose(fp);
else
CLog::Log(LOGERROR, "Unable to create file %s", CURL::GetRedacted(filename).c_str());
CThumbnailWriter* thumbnailwriter = new CThumbnailWriter(surface.m_buffer, surface.m_width, surface.m_height, surface.m_stride, filename);
CJobManager::GetInstance().AddJob(thumbnailwriter, NULL);
surface.m_buffer = NULL;
}
} |
CScreenshotSurface::CScreenshotSurface();
CScreenshotSurface::~CScreenshotSurface();
bool CScreenshotSurface::capture();
void CScreenShot::TakeScreenshot();
| 50b31c9366004beefc0ac8a08730fbb371c9622af6ab6ad173fc8bceeb031bfc | 1,291 |
|
Ultis | simulationcraft | engine/sc_warlock.cpp | ready | virtual bool ready()
{
warlock_t* p = player -> cast_warlock();
if ( ! p -> active_pet )
return false;
return warlock_spell_t::ready();
} | warlock_t( sim_t* sim, const std::string& name, race_type r = RACE_NONE );
int affliction_effects();
int active_dots();
double get_attribute_base( int level, int stat_type, pet_type_t pet_type );
double get_weapon( int level, pet_type_t pet_type, int n );
warlock_pet_t( sim_t* sim, player_t* owner, const std::string& pet_name, pet_type_t pt, bool guardian = false );
virtual void init_base();
virtual void init_resources( bool force );
virtual void schedule_ready( double delta_time=0,
bool waiting=false );
virtual void summon( double duration=0 );
virtual void dismiss();
virtual double composite_spell_haste();
virtual double composite_attack_haste();
virtual double composite_spell_power( const school_type school );
virtual double composite_attack_power();
virtual double composite_attack_crit();
virtual double composite_spell_crit();
warlock_main_pet_t( sim_t* sim, player_t* owner, const std::string& pet_name, pet_type_t pt );
virtual void summon( double duration=0 );
virtual void dismiss();
virtual double composite_attack_expertise();
virtual double composite_player_multiplier( const school_type school, action_t* a );
virtual double composite_mp5();
warlock_guardian_pet_t( sim_t* sim, player_t* owner, const std::string& pet_name, pet_type_t pt );
virtual void summon( double duration=0 );
virtual double composite_attack_crit();
virtual double composite_attack_expertise();
virtual double composite_attack_haste();
virtual double composite_attack_hit();
virtual double composite_attack_power();
virtual double composite_spell_crit();
virtual double composite_spell_haste();
virtual double composite_spell_power( const school_type school );
virtual double composite_spell_power_multiplier();
warlock_heal_t( const char* n, warlock_t* p, const uint32_t id );
virtual void player_buff();
void _init_warlock_spell_t();
warlock_spell_t( const char* n, warlock_t* p, const school_type s, int t );
warlock_spell_t( const active_spell_t& s, int t = TREE_NONE );
warlock_spell_t( const char* n, warlock_t* p, const char* sname, int t = TREE_NONE );
warlock_spell_t( const char* n, warlock_t* p, const uint32_t id, int t = TREE_NONE );
virtual double haste();
virtual void player_buff();
virtual void target_debuff( player_t* t, int dmg_type );
virtual void tick( dot_t* d );
virtual double total_td_multiplier();
static void trigger_impending_doom ( spell_t* s );
static void trigger_soul_leech( spell_t* s );
static void trigger_decimation( warlock_spell_t* s, int result );
static double trigger_deaths_embrace( spell_t* s );
static void trigger_everlasting_affliction( spell_t* s );
static void trigger_fiery_imp( spell_t* s );
static void trigger_tier12_4pc_caster( spell_t* s );
warlock_pet_melee_t( warlock_pet_t* p, const char* name );
warlock_pet_attack_t( const char* n, warlock_pet_t* p, int r=RESOURCE_MANA, const school_type s=SCHOOL_PHYSICAL );
warlock_pet_attack_t( const char* n, player_t* player, const char* sname, int t = TREE_NONE );
warlock_pet_attack_t( const char* n, const uint32_t id, player_t* player, int t = TREE_NONE );
virtual void player_buff();
void trigger_mana_feed( action_t* s, double impact_result );
warlock_pet_spell_t( const char* n, warlock_pet_t* p, int r=RESOURCE_MANA, const school_type s=SCHOOL_SHADOW );
warlock_pet_spell_t( const active_spell_t& s, int t = TREE_NONE );
warlock_pet_spell_t( const char* n, warlock_pet_t* p, const char* sname, int t = TREE_NONE );
warlock_pet_spell_t( const char* n, const uint32_t id, warlock_pet_t* p, int t = TREE_NONE );
virtual void player_buff();
firebolt_t( imp_pet_t* p );
virtual void player_buff();
imp_pet_t( sim_t* sim, player_t* owner );
virtual void init_base();
virtual action_t* create_action( const std::string& name,
const std::string& options_str );
legion_strike_t( felguard_pet_t* p );
virtual void execute();
virtual void player_buff();
felstorm_tick_t( felguard_pet_t* p );
felstorm_t( felguard_pet_t* p );
virtual void tick( dot_t* d );
melee_t( felguard_pet_t* p );
felguard_pet_t( sim_t* sim, player_t* owner );
virtual void init_base();
virtual action_t* create_action( const std::string& name,
const std::string& options_str );
shadow_bite_t( felhunter_pet_t* p );
virtual void player_buff();
virtual void impact( player_t* t, int impact_result, double travel_dmg );
felhunter_pet_t( sim_t* sim, player_t* owner );
virtual void init_base();
virtual action_t* create_action( const std::string& name,
const std::string& options_str );
virtual void summon( double duration=0 );
virtual void dismiss();
lash_of_pain_t( succubus_pet_t* p );
virtual void impact( player_t* t, int impact_result, double travel_dmg );
virtual void player_buff();
succubus_pet_t( sim_t* sim, player_t* owner );
virtual action_t* create_action( const std::string& name,
const std::string& options_str );
torment_t( voidwalker_pet_t* p );
virtual void impact( player_t* t, int impact_result, double travel_dmg );
voidwalker_pet_t( sim_t* sim, player_t* owner );
virtual void init_base();
virtual action_t* create_action( const std::string& name,
const std::string& options_str );
immolation_damage_t( infernal_pet_t* p );
infernal_immolation_t( infernal_pet_t* p, const std::string& options_str );
virtual void tick( dot_t* d );
infernal_pet_t( sim_t* sim, player_t* owner );
virtual void init_base();
virtual action_t* create_action( const std::string& name,
const std::string& options_str );
doom_bolt_t( doomguard_pet_t* p );
doomguard_pet_t( sim_t* sim, player_t* owner );
virtual void init_base();
virtual action_t* create_action( const std::string& name,
const std::string& options_str );
virtual double composite_player_multiplier( const school_type school, action_t* a );
ebon_imp_pet_t( sim_t* sim, player_t* owner );
virtual double composite_attack_power();
virtual void init_base();
fiery_imp_pet_t( sim_t* sim, player_t* owner );
virtual void summon( double duration=0 );
virtual double composite_spell_crit();
virtual double composite_spell_haste();
flame_blast_t( fiery_imp_pet_t* p );
virtual action_t* create_action( const std::string& name,
const std::string& options_str );
virtual void expire();
curse_of_elements_t( warlock_t* p, const std::string& options_str );
virtual void execute();
virtual bool ready();
bane_of_agony_t( warlock_t* p, const std::string& options_str );
virtual void execute();
bane_of_doom_t( warlock_t* p, const std::string& options_str );
virtual void execute();
virtual void tick( dot_t* d );
bane_of_havoc_t( warlock_t* p, const std::string& options_str );
virtual void execute();
virtual bool ready();
shadow_bolt_t( warlock_t* p, const std::string& options_str, bool dtr=false );
virtual double execute_time();
virtual void schedule_execute();
virtual void execute();
virtual void player_buff();
virtual void impact( player_t* t, int impact_result, double travel_dmg );
virtual bool ready();
void trigger_burning_embers ( spell_t* s, double dmg );
chaos_bolt_t( warlock_t* p, const std::string& options_str, bool dtr=false );
virtual double execute_time();
virtual void execute();
virtual void player_buff();
virtual void impact( player_t* t, int impact_result, double travel_dmg );
death_coil_t( warlock_t* p, const std::string& options_str );
virtual void impact( player_t* t, int impact_result, double travel_dmg );
shadowburn_t( warlock_t* p, const std::string& options_str, bool dtr=false );
virtual void impact( player_t* t, int impact_result, double travel_dmg );
virtual void update_ready();
virtual bool ready();
shadowfury_t( warlock_t* p, const std::string& options_str );
corruption_t( warlock_t* p, const std::string& options_str );
virtual void player_buff();
virtual void tick( dot_t* d );
drain_life_heal_t( warlock_t* p );
virtual void execute();
virtual void player_buff();
drain_life_t( warlock_t* p, const std::string& options_str );
virtual void last_tick( dot_t* d);
virtual void impact( player_t* t, int impact_result, double travel_dmg );
virtual double tick_time();
virtual void player_buff();
virtual void tick( dot_t* d );
drain_soul_t( warlock_t* p, const std::string& options_str );
virtual void execute();
virtual void tick( dot_t* d );
virtual void player_buff();
unstable_affliction_t( warlock_t* p, const std::string& options_str );
virtual void execute();
virtual void tick( dot_t* d );
haunt_t( warlock_t* p, const std::string& options_str, bool dtr=false );
virtual void impact( player_t* t, int impact_result, double travel_dmg );
immolate_t( warlock_t* p, const std::string& options_str, bool dtr=false );
virtual void player_buff();
virtual void execute();
virtual void tick( dot_t* d );
shadowflame_dot_t( warlock_t* p );
shadowflame_t( warlock_t* p, const std::string& options_str, bool dtr=false );
virtual void execute();
conflagrate_t( warlock_t* p, const std::string& options_str, bool dtr=false );
virtual void execute();
virtual void impact( player_t* t, int impact_result, double travel_dmg );
virtual bool ready();
incinerate_t( warlock_t* p, const std::string& options_str, bool dtr=false );
virtual void execute();
virtual void impact( player_t* t, int impact_result, double travel_dmg );
virtual void player_buff();
virtual double execute_time();
searing_pain_t( warlock_t* p, const std::string& options_str, bool dtr=false );
virtual void player_buff();
virtual void execute();
soul_fire_t( warlock_t* p, const std::string& options_str, bool dtr=false );
virtual void execute();
virtual double execute_time();
virtual void impact( player_t* t, int impact_result, double travel_dmg );
life_tap_t( warlock_t* p, const std::string& options_str );
virtual void execute();
virtual bool ready();
demon_armor_t( warlock_t* p, const std::string& options_str );
virtual void execute();
virtual bool ready();
fel_armor_t( warlock_t* p, const std::string& options_str );
virtual void execute();
virtual void tick( dot_t* d );
virtual bool ready();
void _init_summon_pet_t( const std::string& options_str, const char* pet_name );
summon_pet_t( const char* n, warlock_t* p, const char* sname, const std::string& options_str="" );
summon_pet_t( const char* n, warlock_t* p, int id, const std::string& options_str="" );
virtual void execute();
summon_main_pet_t( const char* n, warlock_t* p, const char* sname, const std::string& options_str );
virtual void schedule_execute();
virtual bool ready();
virtual double execute_time();
virtual void execute();
summon_felhunter_t( warlock_t* p, const std::string& options_str );
summon_felguard_t( warlock_t* p, const std::string& options_str );
summon_succubus_t( warlock_t* p, const std::string& options_str );
summon_imp_t( warlock_t* p, const std::string& options_str );
summon_voidwalker_t( warlock_t* p, const std::string& options_str );
infernal_awakening_t( warlock_t* p );
summon_infernal_t( warlock_t* p, const std::string& options_str );
virtual void execute();
summon_doomguard2_t( warlock_t* p );
virtual void execute();
summon_doomguard_t( warlock_t* p, const std::string& options_str );
virtual void execute();
immolation_damage_t( warlock_t* p );
immolation_aura_t( warlock_t* p, const std::string& options_str );
virtual void tick( dot_t* d );
virtual bool ready();
metamorphosis_t( warlock_t* p, const std::string& options_str );
virtual void execute();
demonic_empowerment_t( warlock_t* p, const std::string& options_str );
virtual void execute();
virtual bool ready();
hand_of_guldan_t( warlock_t* p, const std::string& options_str, bool dtr=false );
virtual void impact( player_t* t, int impact_result, double travel_dmg );
virtual double travel_time();
fel_flame_t( warlock_t* p, const std::string& options_str, bool dtr=false );
virtual void execute();
virtual void impact( player_t* t, int impact_result, double travel_dmg );
virtual void player_buff();
dark_intent_t( warlock_t* p, const std::string& options_str );
virtual void execute();
virtual bool ready();
soulburn_t( warlock_t* p, const std::string& options_str );
virtual void execute();
demon_soul_t( warlock_t* p, const std::string& options_str );
virtual void execute();
hellfire_tick_t( warlock_t* p );
hellfire_t( warlock_t* p, const std::string& options_str );
virtual bool usable_moving();
virtual void tick( dot_t* /* d */ );
seed_of_corruption_aoe_t( warlock_t* p );
virtual void execute();
seed_of_corruption_t( warlock_t* p, const std::string& options_str );
virtual void impact( player_t* t, int impact_result, double travel_dmg );
virtual void tick( dot_t* d );
rain_of_fire_tick_t( warlock_t* p );
rain_of_fire_t( warlock_t* p, const std::string& options_str );
virtual void tick( dot_t* d );
void imp_pet_t::firebolt_t::impact( player_t* t, int impact_result, double travel_dmg );
double warlock_t::composite_armor();
double warlock_t::composite_spell_power( const school_type school );
double warlock_t::composite_spell_power_multiplier();
double warlock_t::composite_player_multiplier( const school_type school, action_t* a );
double warlock_t::composite_player_td_multiplier( const school_type school, action_t* a );
double warlock_t::matching_gear_multiplier( const attribute_type attr );
void warlock_t::create_pets();
void warlock_t::init_talents();
void warlock_t::init_spells();
void warlock_t::init_base();
void warlock_t::init_scaling();
void warlock_t::init_buffs();
void warlock_t::init_values();
void warlock_t::init_gains();
void warlock_t::init_benefits();
void warlock_t::init_procs();
void warlock_t::init_rng();
void warlock_t::init_actions();
void warlock_t::init_resources( bool force );
void warlock_t::reset();
action_expr_t* warlock_t::create_expression( action_t* a, const std::string& name_str );
void warlock_t::create_options();
bool warlock_t::create_profile( std::string& profile_str, int save_type, bool save_html );
void warlock_t::copy_from( player_t* source );
int warlock_t::decode_set( item_t& item );
player_t* player_t::create_warlock( sim_t* sim, const std::string& name, race_type r );
void player_t::warlock_init( sim_t* sim );
void player_t::warlock_combat_begin( sim_t* sim );
| bf25acaffe1791119cd69c4d3f187437c0096efea75a07d276e5c0840bf9c915 | 163 |
|
dtcxzyw | TFL | Deps/GamePlay/lua/lua_Vector3.cpp | lua_Vector3_static_unitY |
static int lua_Vector3_static_unitY(lua_State* state)
{
int paramCount = lua_gettop(state);
switch (paramCount)
{
case 0:
{
void* returnPtr = (void*)&(Vector3::unitY());
if (returnPtr)
{
gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject));
object->instance = returnPtr;
object->owns = false;
luaL_getmetatable(state, "Vector3");
lua_setmetatable(state, -2);
}
else
{
lua_pushnil(state);
}
return 1;
break;
}
default:
{
lua_pushstring(state, "Invalid number of parameters (expected 0).");
lua_error(state);
break;
}
}
return 0;
} |
static Vector3* getInstance(lua_State* state);
static int lua_Vector3__gc(lua_State* state);
static int lua_Vector3__init(lua_State* state);
static int lua_Vector3_add(lua_State* state);
static int lua_Vector3_clamp(lua_State* state);
static int lua_Vector3_cross(lua_State* state);
static int lua_Vector3_distance(lua_State* state);
static int lua_Vector3_distanceSquared(lua_State* state);
static int lua_Vector3_dot(lua_State* state);
static int lua_Vector3_isOne(lua_State* state);
static int lua_Vector3_isZero(lua_State* state);
static int lua_Vector3_length(lua_State* state);
static int lua_Vector3_lengthSquared(lua_State* state);
static int lua_Vector3_negate(lua_State* state);
static int lua_Vector3_normalize(lua_State* state);
static int lua_Vector3_scale(lua_State* state);
static int lua_Vector3_set(lua_State* state);
static int lua_Vector3_smooth(lua_State* state);
static int lua_Vector3_static_add(lua_State* state);
static int lua_Vector3_static_angle(lua_State* state);
static int lua_Vector3_static_clamp(lua_State* state);
static int lua_Vector3_static_cross(lua_State* state);
static int lua_Vector3_static_dot(lua_State* state);
static int lua_Vector3_static_fromColor(lua_State* state);
static int lua_Vector3_static_one(lua_State* state);
static int lua_Vector3_static_subtract(lua_State* state);
static int lua_Vector3_static_unitX(lua_State* state);
static int lua_Vector3_static_unitZ(lua_State* state);
static int lua_Vector3_static_zero(lua_State* state);
static int lua_Vector3_subtract(lua_State* state);
static int lua_Vector3_x(lua_State* state);
static int lua_Vector3_y(lua_State* state);
static int lua_Vector3_z(lua_State* state);
void luaRegister_Vector3();
| 65839916f207fdad1593c6e3b665fe981eb2d9c2b33ab35bceaf0234a1f872fe | 939 |
|
Hodes | godot | scene/gui/button_array.cpp | ButtonArray::_bind_methods |
void ButtonArray::_bind_methods() {
ObjectTypeDB::bind_method(_MD("add_button","text"),&ButtonArray::add_button);
ObjectTypeDB::bind_method(_MD("add_icon_button","icon:Texture","text"),&ButtonArray::add_icon_button,DEFVAL(""));
ObjectTypeDB::bind_method(_MD("set_button_text","button_idx","text"),&ButtonArray::set_button_text);
ObjectTypeDB::bind_method(_MD("set_button_icon","button_idx","icon:Texture"),&ButtonArray::set_button_icon);
ObjectTypeDB::bind_method(_MD("get_button_text","button_idx"),&ButtonArray::get_button_text);
ObjectTypeDB::bind_method(_MD("get_button_icon:Texture","button_idx"),&ButtonArray::get_button_icon);
ObjectTypeDB::bind_method(_MD("get_button_count"),&ButtonArray::get_button_count);
ObjectTypeDB::bind_method(_MD("get_selected"),&ButtonArray::get_selected);
ObjectTypeDB::bind_method(_MD("get_hovered"),&ButtonArray::get_hovered);
ObjectTypeDB::bind_method(_MD("set_selected","button_idx"),&ButtonArray::set_selected);
ObjectTypeDB::bind_method(_MD("erase_button","button_idx"),&ButtonArray::erase_button);
ObjectTypeDB::bind_method(_MD("clear"),&ButtonArray::clear);
ObjectTypeDB::bind_method(_MD("_input_event"),&ButtonArray::_input_event);
BIND_CONSTANT( ALIGN_BEGIN );
BIND_CONSTANT( ALIGN_CENTER );
BIND_CONSTANT( ALIGN_END );
BIND_CONSTANT( ALIGN_FILL );
BIND_CONSTANT( ALIGN_EXPAND_FILL );
ADD_SIGNAL( MethodInfo("button_selected",PropertyInfo(Variant::INT,"button_idx")));
} |
bool ButtonArray::_set(const StringName& p_name, const Variant& p_value);
bool ButtonArray::_get(const StringName& p_name,Variant &r_ret);
void ButtonArray::_get_property_list( List<PropertyInfo> *p_list);
Size2 ButtonArray::get_minimum_size();
void ButtonArray::_notification(int p_what);
void ButtonArray::_input_event(const InputEvent& p_event);
void ButtonArray::set_align(Align p_align);
ButtonArray::Align ButtonArray::get_align();
void ButtonArray::add_button(const String& p_text);
void ButtonArray::add_icon_button(const Ref<Texture>& p_icon,const String& p_text);
void ButtonArray::set_button_text(int p_button, const String& p_text);
void ButtonArray::set_button_icon(int p_button, const Ref<Texture>& p_icon);
String ButtonArray::get_button_text(int p_button);
Ref<Texture> ButtonArray::get_button_icon(int p_button);
int ButtonArray::get_selected();
int ButtonArray::get_hovered();
void ButtonArray::set_selected(int p_selected);
void ButtonArray::erase_button(int p_button);
void ButtonArray::clear();
int ButtonArray::get_button_count();
void ButtonArray::get_translatable_strings(List<String> *p_strings);
ButtonArray::ButtonArray(Orientation p_orientation);
| 0ee5ba3a2e104716c62d27b238ed5b978f8d4562c747d4dbb85c6a0120a897dd | 1,441 |
|
mcodegeeks | OpenKODE-Framework | 03_Tutorial/T02_XMCocos2D/Source/Test/TestLayer.cpp | LayerTestCascadingOpacityC::onEnter |
KDvoid LayerTestCascadingOpacityC::onEnter ( KDvoid )
{
TestLayer::onEnter();
CCSize s = this->getContentSize ( );
CCLayerColor* layer1 = CCLayerColor::create(ccc4(192, 0, 0, 255), s.cx, s.cy/2);
layer1->setCascadeColorEnabled(KD_FALSE);
layer1->setCascadeOpacityEnabled(KD_FALSE);
layer1->setPosition( ccp(0, s.cy/2));
CCSprite *sister1 = CCSprite::create("Images/grossinis_sister1.png");
CCSprite *sister2 = CCSprite::create("Images/grossinis_sister2.png");
CCLabelBMFont *label = CCLabelBMFont::create("Test", "fonts/bitmapFontTest.fnt");
layer1->addChild(sister1);
layer1->addChild(sister2);
layer1->addChild(label);
this->addChild( layer1, 0, kTagLayer);
sister1->setPosition( ccp( s.cx*1/3, 0));
sister2->setPosition( ccp( s.cx*2/3, 0));
label->setPosition( ccp( s.cx/2, 0));
layer1->runAction(
CCRepeatForever::create(
CCSequence::create(
CCFadeTo::create(4, 0),
CCFadeTo::create(4, 255),
CCDelayTime::create(1),
NULL)));
sister1->runAction(
CCRepeatForever::create(
CCSequence::create(
CCFadeTo::create(2, 0),
CCFadeTo::create(2, 255),
CCFadeTo::create(2, 0),
CCFadeTo::create(2, 255),
CCDelayTime::create(1),
NULL)));
} |
TestLayer* TestLayer::create ( KDvoid );
KDuint TestLayer::count ( KDvoid );
static KDvoid setEnableRecursiveCascading ( CCNode* pNode, KDbool bEnable );
KDvoid LayerTestCascadingOpacityA::onEnter ( KDvoid );
const KDchar* LayerTestCascadingOpacityA::title ( KDvoid );
KDvoid LayerTestCascadingOpacityB::onEnter ( KDvoid );
const KDchar* LayerTestCascadingOpacityB::title ( KDvoid );
const KDchar* LayerTestCascadingOpacityC::title ( KDvoid );
KDvoid LayerTestCascadingColorA::onEnter ( KDvoid );
const KDchar* LayerTestCascadingColorA::title ( KDvoid );
KDvoid LayerTestCascadingColorB::onEnter ( KDvoid );
const KDchar* LayerTestCascadingColorB::title ( KDvoid );
KDvoid LayerTestCascadingColorC::onEnter ( KDvoid );
const KDchar* LayerTestCascadingColorC::title ( KDvoid );
KDbool LayerTest1::init ( KDvoid );
const KDchar* LayerTest1::title ( KDvoid );
const KDchar* LayerTest1::subtitle ( KDvoid );
KDvoid LayerTest1::updateSize ( const CCPoint& tLocation );
KDvoid LayerTest1::ccTouchesBegan ( CCSet* pTouches, CCEvent* pEvent );
KDvoid LayerTest1::ccTouchesMoved ( CCSet* pTouches, CCEvent* pEvent );
KDvoid LayerTest1::ccTouchesEnded ( CCSet* pTouches, CCEvent* pEvent );
KDbool LayerTest2::init ( KDvoid );
const KDchar* LayerTest2::title ( KDvoid );
KDbool LayerTestBlend::init ( KDvoid );
KDvoid LayerTestBlend::newBlend ( KDfloat dt );
const KDchar* LayerTestBlend::title ( KDvoid );
KDbool LayerGradient::init ( KDvoid );
KDvoid LayerGradient::ccTouchesMoved ( CCSet* pTouches, CCEvent* pEvent );
const KDchar* LayerGradient::title ( KDvoid );
const KDchar* LayerGradient::subtitle ( KDvoid );
KDvoid LayerGradient::toggleItem ( CCObject* sender );
KDbool LayerIgnoreAnchorPointPos::init ( KDvoid );
const KDchar* LayerIgnoreAnchorPointPos::title ( KDvoid );
const KDchar* LayerIgnoreAnchorPointPos::subtitle ( KDvoid );
KDvoid LayerIgnoreAnchorPointPos::onToggle ( CCObject* sender );
KDbool LayerIgnoreAnchorPointRot::init ( KDvoid );
const KDchar* LayerIgnoreAnchorPointRot::title ( KDvoid );
const KDchar* LayerIgnoreAnchorPointRot::subtitle ( KDvoid );
KDvoid LayerIgnoreAnchorPointRot::onToggle ( CCObject* sender );
KDbool LayerIgnoreAnchorPointScale::init ( KDvoid );
const KDchar* LayerIgnoreAnchorPointScale::title ( KDvoid );
const KDchar* LayerIgnoreAnchorPointScale::subtitle ( KDvoid );
KDvoid LayerIgnoreAnchorPointScale::onToggle ( CCObject* sender );
KDbool LayerExtendedBlendOpacityTest::init ( KDvoid );
const KDchar* LayerExtendedBlendOpacityTest::title ( KDvoid );
const KDchar* LayerExtendedBlendOpacityTest::subtitle ( KDvoid );
| 6b956fadfd64838cb2bb294c5c953d1e4c09c4c6b661382b44dfa483dbcf4b01 | 1,328 |
|
johnparker007 | mame | src/mame/drivers/kncljoe.cpp | kncljoe_state::kncljoe |
void kncljoe_state::kncljoe(machine_config &config)
{
Z80(config, m_maincpu, XTAL(6'000'000));
m_maincpu->set_addrmap(AS_PROGRAM, &kncljoe_state::main_map);
m_maincpu->set_vblank_int("screen", FUNC(kncljoe_state::irq0_line_hold));
m6803_cpu_device &soundcpu(M6803(config, "soundcpu", XTAL(3'579'545)));
soundcpu.set_addrmap(AS_PROGRAM, &kncljoe_state::sound_map);
soundcpu.in_p1_cb().set(FUNC(kncljoe_state::m6803_port1_r));
soundcpu.out_p1_cb().set(FUNC(kncljoe_state::m6803_port1_w));
soundcpu.in_p2_cb().set(FUNC(kncljoe_state::m6803_port2_r));
soundcpu.out_p2_cb().set(FUNC(kncljoe_state::m6803_port2_w));
soundcpu.set_periodic_int(FUNC(kncljoe_state::sound_nmi), attotime::from_hz((double)3970));
SCREEN(config, m_screen, SCREEN_TYPE_RASTER);
m_screen->set_video_attributes(VIDEO_UPDATE_AFTER_VBLANK);
m_screen->set_refresh_hz(60);
m_screen->set_vblank_time(ATTOSECONDS_IN_USEC(1500));
m_screen->set_size(32*8, 32*8);
m_screen->set_visarea(1*8, 31*8-1, 0*8, 32*8-1);
m_screen->set_screen_update(FUNC(kncljoe_state::screen_update_kncljoe));
m_screen->set_palette(m_palette);
GFXDECODE(config, m_gfxdecode, m_palette, gfx_kncljoe);
PALETTE(config, m_palette, FUNC(kncljoe_state::kncljoe_palette), 16*8+16*8, 128+16);
SPEAKER(config, "mono").front_center();
GENERIC_LATCH_8(config, m_soundlatch);
AY8910(config, m_ay8910, XTAL(3'579'545)/4);
m_ay8910->port_a_read_callback().set(m_soundlatch, FUNC(generic_latch_8_device::read));
m_ay8910->port_b_write_callback().set(FUNC(kncljoe_state::unused_w));
m_ay8910->add_route(ALL_OUTPUTS, "mono", 0.30);
SN76489(config, "sn1", XTAL(3'579'545)).add_route(ALL_OUTPUTS, "mono", 0.30);
SN76489(config, "sn2", XTAL(3'579'545)).add_route(ALL_OUTPUTS, "mono", 0.30);
} |
void kncljoe_state::sound_cmd_w(uint8_t data);
void kncljoe_state::main_map(address_map &map);
void kncljoe_state::m6803_port1_w(uint8_t data);
void kncljoe_state::m6803_port2_w(uint8_t data);
uint8_t kncljoe_state::m6803_port1_r();
uint8_t kncljoe_state::m6803_port2_r();
void kncljoe_state::sound_irq_ack_w(uint8_t data);
void kncljoe_state::unused_w(uint8_t data);
void kncljoe_state::sound_map(address_map &map);
void kncljoe_state::machine_start();
void kncljoe_state::machine_reset();
| 6e0aae6cbdd6033be22c4579efb01d97cf098930f7e680026692a9ae047c3ba4 | 1,766 |
|
LVPlayground | zone-manager-plugin | src/zone_manager.cpp | ZoneManager::DestroyZone |
void ZoneManager::DestroyZone(unsigned int layer_id, unsigned int zone_id) {
auto scoped_zone_layer_map_ref = zone_data_storage_.ZoneLayerMap();
auto& zone_layer_map = scoped_zone_layer_map_ref.get();
auto zone_layer_iter = zone_layer_map.find(layer_id);
if (zone_layer_iter == zone_layer_map.end())
return;
return zone_layer_iter->second->DestroyZone(zone_id);
} |
ZoneManager::ZoneManager();
unsigned int ZoneManager::CreateLayer(Script* script, unsigned int layer_id);
void ZoneManager::DestroyLayer(unsigned int layer_id);
void ZoneManager::DestroyLayersForScript(Script* script);
unsigned int ZoneManager::CreateZone(unsigned int layer_id, Rectangle& area, float max_height);
bool ZoneManager::ZoneInfo(unsigned int layer_id, unsigned int zone_id, Rectangle* area, float* max_height);
void ZoneManager::StartTrackingPlayer(unsigned int player_id);
void ZoneManager::StopTrackingPlayer(unsigned int player_id);
void ZoneManager::ResetPlayers();
void ZoneManager::ProcessUpdates();
| 25f117b94d39cf09343d00ab360cf4c8481eb928381ff768c38c9f9ab7ec0aa9 | 380 |
|
kraj | gcc | libsanitizer/lsan/lsan_interceptors.cpp |
INTERCEPTOR |
INTERCEPTOR(void, _lwp_exit) {
ENSURE_LSAN_INITED;
ThreadFinish();
REAL(_lwp_exit)();
} | static void OnAllocate(const void *ptr, uptr size);
static void OnFree(const void *ptr, uptr size);
INTERCEPTOR(void*, malloc, uptr size);
INTERCEPTOR(void, free, void *p);
INTERCEPTOR(void*, calloc, uptr nmemb, uptr size);
INTERCEPTOR(void *, realloc, void *ptr, uptr size);
INTERCEPTOR(void*, reallocarray, void *q, uptr nmemb, uptr size);
INTERCEPTOR(int, posix_memalign, void **memptr, uptr alignment, uptr size);
INTERCEPTOR(void*, valloc, uptr size);
INTERCEPTOR(void*, memalign, uptr alignment, uptr size);
INTERCEPTOR(void *, __libc_memalign, uptr alignment, uptr size);
INTERCEPTOR(void*, aligned_alloc, uptr alignment, uptr size);
INTERCEPTOR(uptr, malloc_usable_size, void *ptr);
INTERCEPTOR(struct fake_mallinfo, mallinfo, void);
INTERCEPTOR(int, mallopt, int cmd, int value);
INTERCEPTOR(void*, pvalloc, uptr size);
INTERCEPTOR(int, mcheck, void (*abortfunc);
INTERCEPTOR(int, mcheck_pedantic, void (*abortfunc);
INTERCEPTOR(int, mprobe, void *ptr);
INTERCEPTOR(void *, _Znwm, size_t size);
INTERCEPTOR(void *, _Znam, size_t size);
INTERCEPTOR(void *, _ZnwmRKSt9nothrow_t, size_t size, std::nothrow_t const&);
INTERCEPTOR(void *, _ZnamRKSt9nothrow_t, size_t size, std::nothrow_t const&);
INTERCEPTOR(void, _ZdlPv, void *ptr);
INTERCEPTOR(void, _ZdaPv, void *ptr);
INTERCEPTOR(void, _ZdlPvRKSt9nothrow_t, void *ptr, std::nothrow_t const&);
INTERCEPTOR(void, _ZdaPvRKSt9nothrow_t, void *ptr, std::nothrow_t const&);
static void thread_finalize(void *v);
INTERCEPTOR(void, thr_exit, tid_t *state);
INTERCEPTOR(int, __cxa_atexit, void (*func);
INTERCEPTOR(int, atexit, void (*f);
INTERCEPTOR(int, pthread_atfork, void (*prepare);
INTERCEPTOR(char *, strerror, int errnum);
void *__lsan_thread_start_func(void *arg);
INTERCEPTOR(int, pthread_join, void *t, void **arg);
void InitializeInterceptors();
| 27af4ead765281d692412adca0e5eb12ba70474d33ba128d709b0ecd2170f629 | 94 |
|
neikeq | godot | editor/plugins/sprite_editor_plugin.cpp | SpriteEditor::_bind_methods |
void SpriteEditor::_bind_methods() {
ClassDB::bind_method("_menu_option", &SpriteEditor::_menu_option);
ClassDB::bind_method("_debug_uv_draw", &SpriteEditor::_debug_uv_draw);
ClassDB::bind_method("_update_mesh_data", &SpriteEditor::_update_mesh_data);
ClassDB::bind_method("_create_node", &SpriteEditor::_create_node);
ClassDB::bind_method("_add_as_sibling_or_child", &SpriteEditor::_add_as_sibling_or_child);
} |
void SpriteEditor::_node_removed(Node *p_node);
void SpriteEditor::edit(Sprite *p_sprite);
Vector<Vector2> expand(const Vector<Vector2> &points, const Rect2i &rect, float epsilon = 2.0);
void SpriteEditor::_menu_option(int p_option);
void SpriteEditor::_update_mesh_data();
void SpriteEditor::_create_node();
void SpriteEditor::_convert_to_mesh_2d_node();
void SpriteEditor::_convert_to_polygon_2d_node();
void SpriteEditor::_create_collision_polygon_2d_node();
void SpriteEditor::_create_light_occluder_2d_node();
void SpriteEditor::_add_as_sibling_or_child(Node *p_own_node, Node *p_new_node);
void SpriteEditor::_create_uv_lines();
void SpriteEditor::_debug_uv_draw();
SpriteEditor::SpriteEditor();
void SpriteEditorPlugin::edit(Object *p_object);
bool SpriteEditorPlugin::handles(Object *p_object);
void SpriteEditorPlugin::make_visible(bool p_visible);
SpriteEditorPlugin::SpriteEditorPlugin(EditorNode *p_node);
SpriteEditorPlugin::~SpriteEditorPlugin();
| b7b1e40d505c346ff2829e33b48361e0c9d38f6bdd1650c52d4607b22266ae60 | 418 |
|
Junction-2016-Aalto-Helsinki-Fitness | PTSI | ChatScript-6.9/SRC/textUtilities.cpp | ReadInt |
char* ReadInt(char* ptr, int &value)
{
ptr = SkipWhitespace(ptr);
value = 0;
if (!ptr || !*ptr ) return ptr;
if (*ptr == '0' && (ptr[1]== 'x' || ptr[1] == 'X'))
{
uint64 val;
ptr = ReadHex(ptr,val);
value = (int)val;
return ptr;
}
char* original = ptr;
int sign = 1;
if (*ptr == '-')
{
sign = -1;
++ptr;
}
--ptr;
while (!IsWhiteSpace(*++ptr) && *ptr)
{
if (*ptr == ',') continue;
value *= 10;
if (IsDigit(*ptr)) value += *ptr - '0';
else
{
ReportBug((char*)"bad number %s\r\n",original)
while (*++ptr && *ptr != ' ');
value = 0;
return ptr;
}
}
value *= sign;
if (*ptr) ++ptr;
return ptr;
} |
void InitTextUtilities();
void CloseTextUtilities();
char* RemoveEscapesWeAdded(char* at);
char* CopyRemoveEscapes(char* to, char* at,int limit,bool all);
char* AddEscapes(char* to, char* from, bool normal);
void AcquireDefines(char* fileName);
void AcquirePosMeanings();
uint64 FindValueByName(char* name);
char* FindNameByValue(uint64 val);
uint64 FindSystemValueByName(char* name);
char* FindSystemNameByValue(uint64 val);
char* FindParseNameByValue(uint64 val);
uint64 FindParseValueByName(char* name);
uint64 FindMiscValueByName(char* name);
bool IsArithmeticOperator(char* word);
static char* IsUTF8(char* buffer);
char GetTemperatureLetter(char* ptr);
unsigned char* GetCurrency(unsigned char* ptr,char* &number);
bool IsLegalName(char* name);
bool IsDigitWithNumberSuffix(char* number);
bool IsDigitWord(char* ptr,bool comma);
bool IsRomanNumeral(char* word, uint64& val);
unsigned int IsNumber(char* num,bool placeAllowed);
bool IsPlaceNumber(char* word);
bool IsFloat(char* word, char* end);
bool IsNumericDate(char* word,char* end);
bool IsUrl(char* word, char* end);
unsigned int IsMadeOfInitials(char * word,char* end);
char* ReadFlags(char* ptr,uint64& flags,bool &bad, bool &response);
int64 atoi64(char* ptr );
char* ReadInt64(char* ptr, int64 &spot);
char* ReadHex(char* ptr, uint64 & value);
void BOMAccess(int &BOMvalue, char &oldc, int &oldCurrentLine);
int ReadALine(char* buffer,FILE* in,unsigned int limit,bool returnEmptyLines);
char* ReadQuote(char* ptr, char* buffer,bool backslash,bool noblank);
char* ReadCompiledWordOrCall(char* ptr, char* word,bool noquote,bool var);
char* ReadCompiledWord(char* ptr, char* word,bool noquote,bool var);
char* BalanceParen(char* ptr,bool within,bool wildcards);
char* SkipWhitespace(char* ptr);
char* Purify(char* msg);
size_t OutputLimit(unsigned char* data);
char* UTF2ExtendedAscii(char* bufferfrom);
void ForceUnderscores(char* ptr);
void Convert2Blanks(char* ptr);
void Convert2Underscores(char* output,bool alternewline, bool removeBlanks);
void RemoveTilde(char* output);
int64 NumberPower(char* number);
int64 Convert2Integer(char* number);
void MakeLowerCase(char* ptr);
void MakeUpperCase(char* ptr);
char* MakeLowerCopy(char* to,char* from);
char* MakeUpperCopy(char* to,char* from);
char* TrimSpaces(char* msg,bool start);
void UpcaseStarters(char* ptr);
bool ReadDocument(char* inBuffer,FILE* sourceFile);
| 38652835329a5869e68f436e65481e60e1ceed8463fb039c67d1e1599c364450 | 831 |
|
hxim | Stockfish | src/tt.cpp | TranspositionTable::resize |
void TranspositionTable::resize(size_t mbSize) {
clusterCount = mbSize * 1024 * 1024 / sizeof(Cluster);
free(mem);
mem = malloc(clusterCount * sizeof(Cluster) + CacheLineSize - 1);
if (!mem)
{
std::cerr << "Failed to allocate " << mbSize
<< "MB for transposition table." << std::endl;
exit(EXIT_FAILURE);
}
table = (Cluster*)((uintptr_t(mem) + CacheLineSize - 1) & ~(CacheLineSize - 1));
clear();
} |
void TTEntry::save(Key k, Value v, Bound b, Depth d, Move m, Value ev);
void TranspositionTable::clear();
TTEntry* TranspositionTable::probe(const Key key, bool& found);
int TranspositionTable::hashfull();
| c12b9c2e08f0db2536f1761069d9b7b8f14fcb6f85f6b2a9550f0017eed23084 | 447 |
|
ytxhao | ytxplayer | YtxPlayer/app/src/main/cpp/gl-engine/src/gl_engine.cpp | Engine | Engine(env, obj)->addRendererFrame(img, y, u, v, videoWidth, videoHeight);
sVm->DetachCurrentThread();
}
void resetRendererVideoFrame(jobject obj) {
JNIEnv *env = NULL;
sVm->AttachCurrentThread(&env, NULL | ngine();
Engine();
::printGLString(const char *name, GLenum s);
::checkGlError(const char *op);
ne::loadShader(GLenum shaderType, const char *pSource);
ne::createProgram(const char *pVertexSource, const char *pFragmentSource);
::setupGraphics();
::setVideoWidthAndHeight(int videoWidth, int videoHeight);
::buildTextures();
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glEnableVertexAttribArray(gvPositionHandle);
image_t *img = (image_t *);
har *);
int videoHeight);
t);
ze_t);
sizeof(char);
;
checkGlError("glViewport");
t);
*);
har *v, int videoWidth,
int videoHeight);
LOGI("rendererCanStart OUT ret=%d\n", ret);
_1init_1opengl IN");
GraphicRenderer_obj);
Env *env, jobject obj, jint width, jint height);
id_media_player_GraphicRenderer_native_init_opengl},
{"native_resize_opengl", "(II);
t(env != NULL);
;
| ad9667a0d565b822a4717508c300b67bb68a875d2997242f7b269636852511fe | 221 |
|
ortogonal | orbital | src/client/services/hardware/clibackend.cpp | CliDevice::mount |
bool CliDevice::mount()
{
if (type() != Type::Storage) {
return false;
}
QProcess *proc = start(QString("udisksctl mount -b %1").arg(udi()));
QObject::connect(proc, (void (QProcess::*)(int))&QProcess::finished, [this, proc](int exitCode) {
if (exitCode == 0) {
emit this->mountedChanged();
}
delete proc;
});
return true;
} |
static int run(const QString &cmd, QString *out = nullptr);
static QProcess *start(const QString &cmd);
CliDevice::CliDevice(const QString &udi);
bool CliDevice::umount();
bool CliDevice::isMounted();
CliBackend::CliBackend(HardwareManager *hw);
CliBackend *CliBackend::create(HardwareManager *hw);
| 0449be038610c8cac4948358262fab46e05aecfb40c016a29c2758bc8732d0fc | 396 |
|
pdebuyl | lammps | src/USER-OMP/pair_born_coul_wolf_omp.cpp | PairBornCoulWolfOMP::eval |
void PairBornCoulWolfOMP::eval(int iifrom, int iito, ThrData * const thr)
{
int i,j,ii,jj,jnum,itype,jtype;
double qtmp,xtmp,ytmp,ztmp,delx,dely,delz,evdwl,ecoul,fpair;
double rsq,r2inv,r6inv,forcecoul,forceborn,factor_coul,factor_lj;
double prefactor;
double r,rexp;
int *ilist,*jlist,*numneigh,**firstneigh;
double erfcc,erfcd,v_sh,dvdrr,e_self,e_shift,f_shift,qisq;
evdwl = ecoul = 0.0;
const dbl3_t * _noalias const x = (dbl3_t *) atom->x[0];
dbl3_t * _noalias const f = (dbl3_t *) thr->get_f()[0];
const double * _noalias const q = atom->q;
const int * _noalias const type = atom->type;
int nlocal = atom->nlocal;
double *special_coul = force->special_coul;
double *special_lj = force->special_lj;
double qqrd2e = force->qqrd2e;
double fxtmp,fytmp,fztmp;
e_self = v_sh = 0.0;
e_shift = erfc(alf*cut_coul)/cut_coul;
f_shift = -(e_shift+ 2.0*alf/MY_PIS * exp(-alf*alf*cut_coul*cut_coul)) /
cut_coul;
ilist = list->ilist;
numneigh = list->numneigh;
firstneigh = list->firstneigh;
for (ii = iifrom; ii < iito; ++ii) {
i = ilist[ii];
qtmp = q[i];
xtmp = x[i].x;
ytmp = x[i].y;
ztmp = x[i].z;
itype = type[i];
jlist = firstneigh[i];
jnum = numneigh[i];
fxtmp=fytmp=fztmp=0.0;
qisq = qtmp*qtmp;
e_self = -(e_shift/2.0 + alf/MY_PIS) * qisq*qqrd2e;
if (EFLAG) ev_tally_thr(this,i,i,nlocal,0,0.0,e_self,0.0,0.0,0.0,0.0,thr);
for (jj = 0; jj < jnum; jj++) {
j = jlist[jj];
factor_lj = special_lj[sbmask(j)];
factor_coul = special_coul[sbmask(j)];
j &= NEIGHMASK;
delx = xtmp - x[j].x;
dely = ytmp - x[j].y;
delz = ztmp - x[j].z;
rsq = delx*delx + dely*dely + delz*delz;
jtype = type[j];
if (rsq < cutsq[itype][jtype]) {
r2inv = 1.0/rsq;
r = sqrt(rsq);
if (rsq < cut_coulsq) {
prefactor = qqrd2e*qtmp*q[j]/r;
erfcc = erfc(alf*r);
erfcd = exp(-alf*alf*r*r);
v_sh = (erfcc - e_shift*r) * prefactor;
dvdrr = (erfcc/rsq + 2.0*alf/MY_PIS * erfcd/r) + f_shift;
forcecoul = dvdrr*rsq*prefactor;
if (factor_coul < 1.0) forcecoul -= (1.0-factor_coul)*prefactor;
} else forcecoul = 0.0;
if (rsq < cut_ljsq[itype][jtype]) {
r6inv = r2inv*r2inv*r2inv;
rexp = exp((sigma[itype][jtype]-r)*rhoinv[itype][jtype]);
forceborn = born1[itype][jtype]*r*rexp - born2[itype][jtype]*r6inv
+ born3[itype][jtype]*r2inv*r6inv;
} else forceborn = 0.0;
fpair = (forcecoul + factor_lj*forceborn)*r2inv;
fxtmp += delx*fpair;
fytmp += dely*fpair;
fztmp += delz*fpair;
if (NEWTON_PAIR || j < nlocal) {
f[j].x -= delx*fpair;
f[j].y -= dely*fpair;
f[j].z -= delz*fpair;
}
if (EFLAG) {
if (rsq < cut_coulsq) {
ecoul = v_sh;
if (factor_coul < 1.0) ecoul -= (1.0-factor_coul)*prefactor;
} else ecoul = 0.0;
if (rsq < cut_ljsq[itype][jtype]) {
evdwl = a[itype][jtype]*rexp - c[itype][jtype]*r6inv +
d[itype][jtype]*r6inv*r2inv - offset[itype][jtype];
evdwl *= factor_lj;
} else evdwl = 0.0;
}
if (EVFLAG) ev_tally_thr(this,i,j,nlocal,NEWTON_PAIR,
evdwl,ecoul,fpair,delx,dely,delz,thr);
}
}
f[i].x += fxtmp;
f[i].y += fytmp;
f[i].z += fztmp;
}
} |
PairBornCoulWolfOMP::PairBornCoulWolfOMP(LAMMPS *lmp);
void PairBornCoulWolfOMP::compute(int eflag, int vflag);
double PairBornCoulWolfOMP::memory_usage();
| 795fc36cdf990630b1156496f4d9baa138a655cf5735d33312fa78c929288a3e | 3,510 |
|
PanDaemonAeon | ReanEmu | src/server/game/Server/Protocol/Handlers/MovementHandler.cpp | FlagsToStr |
std::string FlagsToStr(const uint32 Flags)
{
std::string Ret="";
if(Flags==0)
{
Ret="None";
return Ret;
}
if(Flags & MOVEMENTFLAG_FORWARD)
{ Ret+="FW "; }
if(Flags & MOVEMENTFLAG_BACKWARD)
{ Ret+="BW "; }
if(Flags & MOVEMENTFLAG_STRAFE_LEFT)
{ Ret+="STL "; }
if(Flags & MOVEMENTFLAG_STRAFE_RIGHT)
{ Ret+="STR "; }
if(Flags & MOVEMENTFLAG_LEFT)
{ Ret+="LF "; }
if(Flags & MOVEMENTFLAG_RIGHT)
{ Ret+="RI "; }
if(Flags & MOVEMENTFLAG_PITCH_UP)
{ Ret+="PTUP "; }
if(Flags & MOVEMENTFLAG_PITCH_DOWN)
{ Ret+="PTDW "; }
if(Flags & MOVEMENTFLAG_WALKING)
{ Ret+="WALK "; }
if(Flags & MOVEMENTFLAG_ONTRANSPORT)
{ Ret+="TRANS "; }
if(Flags & MOVEMENTFLAG_LEVITATING)
{ Ret+="LEVI "; }
if(Flags & MOVEMENTFLAG_ROOT)
{ Ret+="ROOT "; }
if(Flags & MOVEMENTFLAG_JUMPING)
{ Ret+="JUMP "; }
if(Flags & MOVEMENTFLAG_FALLING)
{ Ret+="FALL "; }
if(Flags & MOVEMENTFLAG_PENDING_STOP)
{ Ret+="PENDING_STOP "; }
if(Flags & MOVEMENTFLAG_PENDING_STRAFE_STOP)
{ Ret+="PENDING_STRAFE_STOP "; }
if(Flags & MOVEMENTFLAG_PENDING_FORWARD)
{ Ret+="PENDING_FORWARD "; }
if(Flags & MOVEMENTFLAG_PENDING_BACKWARD)
{ Ret+="PENDING_BACKWARD "; }
if(Flags & MOVEMENTFLAG_PENDING_STRAFE_LEFT)
{ Ret+="PENDING_STRAFE_LEFT "; }
if(Flags & MOVEMENTFLAG_PENDING_STRAFE_RIGHT)
{ Ret+="PENDING_STRAFE_RIGHT "; }
if(Flags & MOVEMENTFLAG_PENDING_ROOT)
{ Ret+="PENDING_ROOT "; }
if(Flags & MOVEMENTFLAG_SWIMMING)
{ Ret+="SWIM "; }
if(Flags & MOVEMENTFLAG_ASCENDING)
{ Ret+="ASC "; }
if(Flags & MOVEMENTFLAG_DESCENDING)
{ Ret+="DESC "; }
if(Flags & MOVEMENTFLAG_CAN_FLY)
{ Ret+="CFLY "; }
if(Flags & MOVEMENTFLAG_FLYING)
{ Ret+="FLY "; }
if(Flags & MOVEMENTFLAG_SPLINE_ELEVATION)
{ Ret+="SPLINE_ELEVATION "; }
if(Flags & MOVEMENTFLAG_SPLINE_ENABLED)
{ Ret+="SPLINE_ENABLED "; }
if(Flags & MOVEMENTFLAG_WATERWALKING)
{ Ret+="WTWALK "; }
if(Flags & MOVEMENTFLAG_FALLING_SLOW)
{ Ret+="FALLING_SLOW "; }
if(Flags & MOVEMENTFLAG_HOVER)
{ Ret+="HOVER "; }
return Ret;
} |
void WorldSession::HandleMoveWorldportAckOpcode(WorldPacket & /*recv_data*/);
void WorldSession::HandleMoveWorldportAckOpcode();
void WorldSession::HandleMoveTeleportAck(WorldPacket& recv_data);
void WorldSession::HandleMovementOpcodes(WorldPacket & recv_data);
void WorldSession::HandleForceSpeedChangeAck(WorldPacket &recv_data);
void WorldSession::HandleSetActiveMoverOpcode(WorldPacket &recv_data);
void WorldSession::HandleMoveNotActiveMover(WorldPacket &recv_data);
void WorldSession::HandleMountSpecialAnimOpcode(WorldPacket& /*recv_data*/);
void WorldSession::HandleMoveKnockBackAck(WorldPacket & recv_data);
void WorldSession::HandleMoveHoverAck(WorldPacket& recv_data);
void WorldSession::HandleMoveWaterWalkAck(WorldPacket& recv_data);
void WorldSession::HandleSummonResponseOpcode(WorldPacket& recv_data);
| 380f058d0feedf51083dcc3acb9831b08c0817fc7126d8ba26e159abc0393bfb | 2,319 |
|
DavadDi | CC | platform/agentproxy/src/apserver/ApServer.cpp | ApServer::SignIn |
AcdResultT ApServer::SignIn(
const std::string& agentId,
const std::string& agentDn,
const std::string& agentPwd,
const StatusChangeT& statusChangetype,
bool autoAnswer,
bool fcSignin,
const std::string& skills,
int64_t& handle, const std::map<std::string, std::string>& ctx) {
BGCC_TRACE("ap",
"SignIn AgentId = %s,AgentDn = %s,AgentPwd = %s,statusChangetype = %d,autoAnswer = %d,fcSignin = %d,skill = %s.",
agentId.c_str(), agentDn.c_str(), agentPwd.c_str(), statusChangetype.get_value(), autoAnswer,
fcSignin, skills.c_str());
uint64_t time_rcv = TimeUtil::get_timestamp_ms();
AgentProxy* agentProxy = AgentProxy::Instance();
AcdResultT ret;
ret = agentProxy->SignIn(agentId, agentDn, agentPwd, statusChangetype, autoAnswer, fcSignin, skills,
handle, ctx, time_rcv);
return ret;
} |
bool ApServer::InitApServer(std::string ApListenIp, int32_t ApListenPort, int32_t threadPoolNum);
| 01a271f06e3fa5ee8d4301f43512564f3f918d24850729285c6195f5f8fe4f62 | 915 |
|
Lipen | LipenDev | Azeroth/Northrend/RF/main.cpp | saver |
void saver() {
while (RUNNING) {
write_control("control");
std::this_thread::sleep_for(duration<double, std::milli>(DT_SAVER));
}
} |
double get_dist_squared(double x1, double y1, double x2, double y2);
/double get_dist(double x1, double y1, double x2, double y2);
double get_dist_to_line(double x, double y, double x1, double y1, double x2, double y2);
int map2scrX(double x);
int map2scrY(double y);
double scr2mapX(int i);
double scr2mapY(int j);
int random(int a, int b);
double logistic_linear(double x, double intersect_left, double threshold_right, double threshold_left/* = 0.0*/);
double logistic_sigmoid(double x, double slope, double shift/* = 0.0*/);
void draw_circle(double x, double y, double r);
void normalize_angle(double &angle, double center/* = 0.0*/);
double normalized_angle(double angle, double center/* = 0.0*/);
void calc_gradient_at(double x, double y, double x1, double y1, double* Fx_, double* Fy_, double* U_);
void read_data(const char* filename);
void write_control(const char* filename);
void detect_collisions();
int initialize_sdl();
void release_sdl();
int load_media();
void strategier();
void drawer();
void modeller();
void loader();
void grapher();
int main(int argc, char* argv[]);
| a8ce9d0da405f25e18afc1c576e3ac058246ea7fafb73e9387bac1e9cc1b1f7c | 139 |
|
BlazesRus | niflib | src/obj/NiWireframeProperty.cpp | NiWireframeProperty::GetRefs |
std::list<NiObjectRef> NiWireframeProperty::GetRefs() const
{
list<Ref<NiObject> > refs;
refs = NiProperty::GetRefs();
return refs;
} |
NiWireframeProperty::NiWireframeProperty();
NiWireframeProperty::~NiWireframeProperty();
const Type & NiWireframeProperty::GetType();
NiObject * NiWireframeProperty::Create();
void NiWireframeProperty::Read(istream& in, list<unsigned int> & link_stack, const NifInfo & info);
void NiWireframeProperty::Write(ostream& out, const map<NiObjectRef, unsigned int> & link_map, list<NiObject *> & missing_link_stack, const NifInfo & info);
std::string NiWireframeProperty::asString(bool verbose);
void NiWireframeProperty::FixLinks(const map<unsigned int, NiObjectRef> & objects, list<unsigned int> & link_stack, list<NiObjectRef> & missing_link_stack, const NifInfo & info);
std::list<NiObject *> NiWireframeProperty::GetPtrs();
unsigned short NiWireframeProperty::GetFlags();
void NiWireframeProperty::SetFlags(unsigned short value);
| 39402aaa87f273ca0b255745a9d0e3ef2abbc7d35f43c0f872a68bc3c9950369 | 137 |
|
pranavrc | example-gluon | audio/sound.cpp | Sound::load |
bool Sound::load( const QString& fileName, bool toStream )
{
if( fileName.isEmpty() )
{
d->isValid = false;
return false;
}
if( !d->path.isEmpty() )
{
d->_k_deleteSource();
}
d->path = fileName;
if( !d->setupSource() )
return false;
d->isStreamed = toStream;
if( d->isStreamed )
{
alureStreamSizeIsMicroSec( true );
d->stream = alureCreateStreamFromFile( d->path.toLocal8Bit().constData(), Engine::instance()->bufferLength(), 0, 0 );
}
else
{
ALuint buffer = Engine::instance()->genBuffer( d->path );
if( d->newError( "Loading " + d->path + " failed" ) )
{
d->isValid = false;
return false;
}
alSourcei( d->source, AL_BUFFER, buffer );
}
d->isValid = !d->newError( "Loading " + d->path + " failed" );
return d->isValid;
} | SoundPrivate();
~SoundPrivate();
bool newError( const QString& str );
void init();
bool setupSource();
void _k_deleteSource();
Sound::Sound();
Sound::Sound( const QString& fileName );
Sound::Sound( const QString& fileName, bool toStream );
Sound::~Sound();
bool Sound::isValid();
bool Sound::load( const QString& fileName );
ALfloat Sound::elapsedTime();
ALint Sound::status();
bool Sound::isLooping();
bool Sound::isPlaying();
void Sound::setLoop( bool enabled );
void Sound::clear();
QVector3D Sound::position();
ALfloat Sound::x();
ALfloat Sound::y();
ALfloat Sound::z();
ALfloat Sound::volume();
ALfloat Sound::pitch();
ALfloat Sound::radius();
void Sound::setPosition( ALfloat x, ALfloat y, ALfloat z );
void Sound::setPosition( QVector3D position );
void Sound::setVolume( ALfloat volume );
void Sound::setPitch( ALfloat pitch );
void Sound::setRadius( ALfloat radius );
void Sound::callbackStopped( void* object, ALuint source );
void Sound::cbStop();
void Sound::play();
void Sound::pause();
void Sound::stop();
void Sound::rewind();
void Sound::setMinVolume( ALfloat min );
void Sound::setMaxVolume( ALfloat max );
void Sound::setVelocity( ALfloat vx, ALfloat vy, ALfloat vz );
void Sound::setDirection( ALfloat dx, ALfloat dy, ALfloat dz );
void Sound::setTimePosition( ALfloat time );
double Sound::duration();
| 33e2119b844cd0b3a6d63bf33011378e350dae3313849db5d4050cc104f89b41 | 906 |
|
apache | activemq-cpp | activemq-cpp/src/main/decaf/lang/AbstractStringBuilder.cpp |
AbstractStringBuilder::AbstractStringBuilder |
AbstractStringBuilder::AbstractStringBuilder() :
impl(new AbstractStringBuilderImpl(INITIAL_CAPACITY)) {
} | void enlargeBuffer(int min);
int capacity();
void ensureCapacity(int newLength);
void move(int size, int index);
void fixReversedMultibyte(char* string DECAF_UNUSED, int length DECAF_UNUSED);
AbstractStringBuilder::AbstractStringBuilder(int capacity);
AbstractStringBuilder::AbstractStringBuilder(const String& source);
AbstractStringBuilder::AbstractStringBuilder(const std::string& source);
AbstractStringBuilder::AbstractStringBuilder(const CharSequence* source);
AbstractStringBuilder::~AbstractStringBuilder();
void AbstractStringBuilder::doAppendNull();
void AbstractStringBuilder::doAppend(const char value);
void AbstractStringBuilder::doAppend(const char* value);
void AbstractStringBuilder::doAppend(const char* value, int offset, int length);
void AbstractStringBuilder::doAppend(const CharSequence* value);
void AbstractStringBuilder::doAppend(const CharSequence* value, int start, int end);
void AbstractStringBuilder::doAppend(const std::string& value);
void AbstractStringBuilder::doAppend(const String& value);
void AbstractStringBuilder::doAppend(const AbstractStringBuilder& value);
void AbstractStringBuilder::doDeleteRange(int start, int end);
void AbstractStringBuilder::doDeleteCharAt(int index);
void AbstractStringBuilder::doInsert(int index, char value);
void AbstractStringBuilder::doInsert(int index, const char* value);
void AbstractStringBuilder::doInsert(int index, const String& value);
void AbstractStringBuilder::doInsert(int index, const std::string& value);
void AbstractStringBuilder::doInsert(int index, const char* value, int offset, int length);
void AbstractStringBuilder::doInsert(int index, const CharSequence* value);
void AbstractStringBuilder::doInsert(int index, const CharSequence* value, int start, int end);
void AbstractStringBuilder::doReplace(int start, int end, const String& value);
void AbstractStringBuilder::doReverse();
int AbstractStringBuilder::capacity();
char AbstractStringBuilder::charAt(int index);
void AbstractStringBuilder::ensureCapacity(int minCapacity);
void AbstractStringBuilder::getChars(int start, int end, char* dest, int destSize, int destStart);
int AbstractStringBuilder::indexOf(const String& value);
int AbstractStringBuilder::indexOf(const String& value, int start);
int AbstractStringBuilder::lastIndexOf(const String& value);
int AbstractStringBuilder::lastIndexOf(const String& value, int start);
int AbstractStringBuilder::length();
void AbstractStringBuilder::setCharAt(int index, char value);
void AbstractStringBuilder::setLength(int length);
String AbstractStringBuilder::substring(int start);
String AbstractStringBuilder::substring(int start, int end);
CharSequence* AbstractStringBuilder::subSequence(int start, int end);
String AbstractStringBuilder::toString();
void AbstractStringBuilder::trimToSize();
| d6d471c45893020b6f7d3fae042e73c31a712bcf51934fa3b3120a5eb78b78d6 | 111 |
|
smogpill | dataspace | src/simt_cl/simtProgram_cl.cpp | simtLoadDependencies |
coResult simtLoadDependencies (coVector<coString>& _list, coVector<coString>& _pragmaOnceDependencies, const coExternConstString& _includeDir, const coExternConstString& _path)
{
coTODO("Optimize simtLoadDependencies()");
for (const coString& s : _pragmaOnceDependencies)
{
if (s == _path)
return coSUCCESS;
}
coString source;
coTRY_RESULT_SILENT(simtHackReadSourceFromPath(source, _path));
const coBool hasPragmaOnce = coString_f::replace(source, "#pragma once", "") != 0;
if (hasPragmaOnce)
_pragmaOnceDependencies.pushBack(coString(_path));
coExternConstString window(source);
coString includePath;
coString fullIncludePath;
const coExternConstString include("#include");
do
{
const coUint includePos = coString_f::findFirstPattern(window, include);
if (includePos == coString_f::getLength(window))
break;
coExternConstString sub;
coString_f::getSubStringFromPos(sub, window, includePos + coString_f::getLength(include));
coExternConstString pathToken;
coString_f::findFirstToken(pathToken, sub, " \n\t");
coString_f::getSubStringFromPos(window, sub, coString_f::getLength(pathToken));
includePath = pathToken;
coPath_f::normalize(includePath);
coPath_f::join(fullIncludePath, _includeDir, includePath);
coTRY_RESULT_SILENT(simtLoadDependencies(_list, _pragmaOnceDependencies, _includeDir, fullIncludePath));
}
while (!coString_f::isEmpty(window));
coString_f::replace(source, "#include", "
_list.pushBack(source);
return coSUCCESS;
} |
coDEFINE_CLASS(simtProgram_cl);
coResult simtHackReadSourceFromPath(coString& _source, const coExternConstString& _path);
simtProgram_cl::simtProgram_cl();
coResult simtProgram_cl::initFromPath (const coExternConstString& _path);
coResult simtProgram_cl::onShutdown();
simtManager_cl* simtProgram_cl::getManager_cl ();
| ae5e6441a1875b7ab2cf170b8eb7d54d7f90a643be569442bc36deccdf97d5a1 | 1,506 |
|
JeremiasE | KFormula | kspread/tests/TestFinancialFunctions.cpp | TestFinancialFunctions::testDISC |
void TestFinancialFunctions::testDISC()
{
CHECK_EVAL_SHORT( "DISC( DATE(2004;02;29); date(2009;01;01); 95000; 100000; 0)", Value ( 0.010339 ) );
CHECK_EVAL_SHORT( "DISC( DATE(2004;02;29); date(2009;01;01); 95000; 100000; 1)", Value ( 0.010333 ) );
CHECK_EVAL_SHORT( "DISC( DATE(2004;02;29); date(2009;01;01); 95000; 100000; 2)", Value ( 0.010181 ) );
CHECK_EVAL_SHORT( "DISC( DATE(2004;02;29); date(2009;01;01); 95000; 100000; 3)", Value ( 0.010322 ) );
CHECK_EVAL_SHORT( "DISC( DATE(2004;02;29); date(2009;01;01); 95000; 100000; 4)", Value ( 0.010333 ) );
CHECK_EVAL_SHORT( "DISC( DATE(2006;01;01); date(2008;01;01); 200; 100; 3)", Value ( -0.500000 ) );
CHECK_EVAL_SHORT( "DISC( DATE(2006;01;01); date(2005;07;01); 95000; 100000; 4)", Value ( false ) );
} |
void TestFinancialFunctions::initTestCase();
static Value TestDouble(const QString& formula, const Value& v2, int accuracy);
void TestFinancialFunctions::testACCRINT();
void TestFinancialFunctions::testACCRINTM();
void TestFinancialFunctions::testAMORDEGRC();
void TestFinancialFunctions::testAMORLINC();
void TestFinancialFunctions::testCOMPOUND();
void TestFinancialFunctions::testCONTINUOUS();
void TestFinancialFunctions::testCOUPNUM();
void TestFinancialFunctions::testCUMIPMT();
void TestFinancialFunctions::testCUMPRINC();
void TestFinancialFunctions::testDB();
void TestFinancialFunctions::testDDB();
void TestFinancialFunctions::testDOLLARDE();
void TestFinancialFunctions::testDOLLARFR();
void TestFinancialFunctions::testDURATION();
void TestFinancialFunctions::testDURATION_ADD();
void TestFinancialFunctions::testEFFECT();
void TestFinancialFunctions::testEURO();
void TestFinancialFunctions::testEUROCONVERT();
void TestFinancialFunctions::testFV();
void TestFinancialFunctions::testFVSCHEDULE();
void TestFinancialFunctions::testINTRATE();
void TestFinancialFunctions::testIPMT();
void TestFinancialFunctions::testISPMT();
void TestFinancialFunctions::testLEVELCOUPON();
void TestFinancialFunctions::testMDURATION();
void TestFinancialFunctions::testMIRR();
void TestFinancialFunctions::testNOMINAL();
void TestFinancialFunctions::testNPER();
void TestFinancialFunctions::testNPV();
void TestFinancialFunctions::testODDLPRICE();
void TestFinancialFunctions::testODDLYIELD();
void TestFinancialFunctions::testPDURATION();
void TestFinancialFunctions::testPMT();
void TestFinancialFunctions::testPPMT();
void TestFinancialFunctions::testPRICEMAT();
void TestFinancialFunctions::testPV();
void TestFinancialFunctions::testPV_ANNUITY();
void TestFinancialFunctions::testRECEIVED();
void TestFinancialFunctions::testRRI();
void TestFinancialFunctions::testSLN();
void TestFinancialFunctions::testSYD();
void TestFinancialFunctions::testTBILLEQ();
void TestFinancialFunctions::testTBILLPRICE();
void TestFinancialFunctions::testTBILLYIELD();
void TestFinancialFunctions::testVDB();
void TestFinancialFunctions::testXIRR();
void TestFinancialFunctions::testXNPV();
void TestFinancialFunctions::testYIELDDISC();
void TestFinancialFunctions::testYIELDMAT();
void TestFinancialFunctions::testZEROCOUPON();
| 9a01d8a021ec822332ebae00b775082818017895a68be35a7ac991d734d933e8 | 818 |
|
gregorburger | SAGA-GIS | src/modules/grid/grid_filter/Filter_Multi_Dir_Lee.cpp | CFilter_Multi_Dir_Lee::Get_Filter |
bool CFilter_Multi_Dir_Lee::Get_Filter(bool bWeighted, bool bAbsolute)
{
int x, y, ix, iy, k, kx, ky, Best_Direction;
double Count, Mean, StdDev, Variance, Best_Mean, Best_StdDev, Noise, Noise2;
if( bAbsolute )
{
Noise = Parameters("NOISE_ABS")->asDouble();
Noise2 = Noise*Noise;
}
else if( m_pStdDev == NULL )
{
Parameters("STDDEV")->Set_Value(m_pStdDev = SG_Create_Grid(*Get_System(), SG_DATATYPE_Float));
}
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
if( m_pInput->is_NoData(x, y) )
{
m_pFiltered ->Set_NoData(x, y);
if( m_pStdDev ) m_pStdDev ->Set_NoData(x, y);
if( m_pDirection ) m_pDirection ->Set_NoData(x, y);
}
else
{
for(k=0; k<16; k++)
{
Variance = Mean = Count = 0;
for(ky=0, iy=y-4; ky<9; iy++, ky++)
{
for(kx=0, ix=x-4; kx<9; ix++, kx++)
{
if( m_pInput->is_InGrid(ix, iy) && Filter_Directions[k][ky][kx] > 0.0 )
{
double w = bWeighted ? Filter_Directions[k][ky][kx] : 1.0;
double z = m_pInput->asDouble(ix, iy);
Mean += w * z;
Variance += w * z*z;
Count += w;
}
}
}
Mean = Mean / Count;
Variance = Variance / Count - Mean*Mean;
StdDev = sqrt(Variance);
if( k == 0 || StdDev < Best_StdDev )
{
Best_StdDev = StdDev;
Best_Mean = Mean;
Best_Direction = k;
}
}
if( bAbsolute && Best_StdDev > Noise )
{
double b = Best_StdDev*Best_StdDev;
b = (b - Noise2) / b;
m_pFiltered->Set_Value(x, y, m_pInput->asDouble(x, y) * b + (1.0 - b) * Best_Mean);
}
else if( Best_StdDev > 0.0 )
{
m_pFiltered->Set_Value(x, y, Best_Mean);
}
else
{
m_pFiltered->Set_Value(x, y, m_pInput->asDouble(x, y));
}
if( m_pStdDev ) m_pStdDev ->Set_Value(x, y, Best_StdDev);
if( m_pDirection ) m_pDirection ->Set_Value(x, y, Best_Direction);
}
}
}
if( !bAbsolute )
{
Noise = Parameters("NOISE_REL")->asDouble() * m_pStdDev->Get_ArithMean();
Noise2 = Noise*Noise;
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
if( !m_pInput->is_NoData(x, y) && (Best_StdDev = m_pStdDev->asDouble(x, y)) > Noise )
{
double b = Best_StdDev*Best_StdDev;
b = (b - Noise2) / b;
m_pFiltered->Set_Value(x, y, m_pInput->asDouble(x, y) * b + (1.0 - b) * m_pFiltered->asDouble(x, y));
}
}
}
}
return( true );
} |
CFilter_Multi_Dir_Lee::CFilter_Multi_Dir_Lee(void);
bool CFilter_Multi_Dir_Lee::On_Execute(void);
bool CFilter_Multi_Dir_Lee::Get_Filter_Ringeler(void);
| 796591792e802630998732603d6c3ea120f92084e5041692cadb9632c8e71be9 | 2,501 |
|
rogerheykoop | RailsParallelDomainChecker | vendor/cache/ruby/2.1.0/gems/eventmachine-1.0.6/ext/em.cpp | EventMachine_t::_RunKqueueOnce |
void EventMachine_t::_RunKqueueOnce()
{
#ifdef HAVE_KQUEUE
assert (kqfd != -1);
int k;
timeval tv = _TimeTilNextEvent();
struct timespec ts;
ts.tv_sec = tv.tv_sec;
ts.tv_nsec = tv.tv_usec * 1000;
#ifdef BUILD_FOR_RUBY
int ret = 0;
#ifdef HAVE_RB_WAIT_FOR_SINGLE_FD
if ((ret = rb_wait_for_single_fd(kqfd, RB_WAITFD_IN|RB_WAITFD_PRI, &tv)) < 1) {
#else
rb_fdset_t fdreads;
rb_fd_init(&fdreads);
rb_fd_set(kqfd, &fdreads);
if ((ret = rb_thread_fd_select(kqfd + 1, &fdreads, NULL, NULL, &tv)) < 1) {
#endif
if (ret == -1) {
assert(errno != EINVAL);
assert(errno != EBADF);
}
return;
}
TRAP_BEG;
ts.tv_sec = ts.tv_nsec = 0;
k = kevent (kqfd, NULL, 0, Karray, MaxEvents, &ts);
TRAP_END;
#else
k = kevent (kqfd, NULL, 0, Karray, MaxEvents, &ts);
#endif
struct kevent *ke = Karray;
while (k > 0) {
switch (ke->filter)
{
case EVFILT_VNODE:
_HandleKqueueFileEvent (ke);
break;
case EVFILT_PROC:
_HandleKqueuePidEvent (ke);
break;
case EVFILT_READ:
case EVFILT_WRITE:
EventableDescriptor *ed = (EventableDescriptor*) (ke->udata);
assert (ed);
if (ed->IsWatchOnly() && ed->GetSocket() == INVALID_SOCKET)
break;
if (ke->filter == EVFILT_READ)
ed->Read();
else if (ke->filter == EVFILT_WRITE)
ed->Write();
else
cerr << "Discarding unknown kqueue event " << ke->filter << endl;
break;
}
--k;
++ke;
}
#ifdef BUILD_FOR_RUBY
if (!rb_thread_alone()) {
rb_thread_schedule();
}
#endif
#else
throw std::runtime_error ("kqueue is not implemented on this platform");
#endif
} |
int EventMachine_t::GetMaxTimerCount();
void EventMachine_t::SetMaxTimerCount (int count);
EventMachine_t::EventMachine_t (EMCallback event_callback);
EventMachine_t::~EventMachine_t();
void EventMachine_t::_UseEpoll();
void EventMachine_t::_UseKqueue();
void EventMachine_t::ScheduleHalt();
void EventMachine_t::SetTimerQuantum (int interval);
void EventMachine_t::SetuidString (const char *username);
int EventMachine_t::SetRlimitNofile (int nofiles);
void EventMachine_t::SignalLoopBreaker();
void EventMachine_t::_InitializeLoopBreaker();
void EventMachine_t::_UpdateTime();
uint64_t EventMachine_t::GetRealTime();
void EventMachine_t::_DispatchHeartbeats();
void EventMachine_t::QueueHeartbeat(EventableDescriptor *ed);
void EventMachine_t::ClearHeartbeat(uint64_t key, EventableDescriptor* ed);
void EventMachine_t::Run();
void EventMachine_t::_RunOnce();
void EventMachine_t::_RunEpollOnce();
timeval EventMachine_t::_TimeTilNextEvent();
void EventMachine_t::_CleanupSockets();
void EventMachine_t::_ModifyEpollEvent (EventableDescriptor *ed);
SelectData_t::SelectData_t();
static VALUE _SelectDataSelect (void *v);
int SelectData_t::_Select();
void EventMachine_t::_RunSelectOnce();
void EventMachine_t::_CleanBadDescriptors();
void EventMachine_t::_ReadLoopBreaker();
void EventMachine_t::_RunTimers();
const unsigned long EventMachine_t::InstallOneshotTimer (int milliseconds);
const unsigned long EventMachine_t::ConnectToServer (const char *bind_addr, int bind_port, const char *server, int port);
const unsigned long EventMachine_t::ConnectToUnixServer (const char *server);
const unsigned long EventMachine_t::AttachFD (int fd, bool watch_mode);
int EventMachine_t::DetachFD (EventableDescriptor *ed);
struct sockaddr *name2address (const char *server, int port, int *family, int *bind_size);
const unsigned long EventMachine_t::CreateTcpServer (const char *server, int port);
const unsigned long EventMachine_t::OpenDatagramSocket (const char *address, int port);
void EventMachine_t::Add (EventableDescriptor *ed);
void EventMachine_t::ArmKqueueWriter (EventableDescriptor *ed);
void EventMachine_t::ArmKqueueReader (EventableDescriptor *ed);
void EventMachine_t::_AddNewDescriptors();
void EventMachine_t::_ModifyDescriptors();
void EventMachine_t::Modify (EventableDescriptor *ed);
void EventMachine_t::Deregister (EventableDescriptor *ed);
const unsigned long EventMachine_t::CreateUnixDomainServer (const char *filename);
const unsigned long EventMachine_t::AttachSD (int sd_accept);
const unsigned long EventMachine_t::Socketpair (char * const*cmd_strings);
const unsigned long EventMachine_t::OpenKeyboard();
int EventMachine_t::GetConnectionCount ();
const unsigned long EventMachine_t::WatchPid (int pid);
void EventMachine_t::UnwatchPid (int pid);
void EventMachine_t::UnwatchPid (const unsigned long sig);
const unsigned long EventMachine_t::WatchFile (const char *fpath);
void EventMachine_t::UnwatchFile (int wd);
void EventMachine_t::UnwatchFile (const unsigned long sig);
void EventMachine_t::_ReadInotifyEvents();
void EventMachine_t::_HandleKqueuePidEvent(struct kevent *event);
void EventMachine_t::_HandleKqueueFileEvent(struct kevent *event);
void EventMachine_t::_RegisterKqueueFileEvent(int fd);
float EventMachine_t::GetHeartbeatInterval();
int EventMachine_t::SetHeartbeatInterval(float interval);
| a3abd842fdf2f90b3d37c4ddd113cba9b9b6d1d569e73bc860940ce039b5dd68 | 1,605 |
|
jefferis | neura | AxonDataProcessing/command_line_parser.cpp | command_line_parser::parse_entities |
void command_line_parser::parse_entities(int argc, char* argv[]) {
unsigned c_option = 0, c_filename = 0;
for(int i = 0; i < argc; i++) {
if(option::is_option(argv[i])) {
options[c_option++].parse_option(argv[i]);
}
else {
strcpy(filenames[c_filename++], argv[i]);
}
}
} |
void option::parse_option(char* string);
void command_line_parser::count_entities(int argc, char* argv[]);
command_line_parser::~command_line_parser();
ostream& operator<< (ostream& out, command_line_parser& c);
| aaffbcd0002cc716727b72f27684daa46b9c6206cfba084309695f06ae45b18d | 304 |
|
Rohde-Schwarz-Cybersecurity | botan | extlibs/botan/src/lib/x509/datastor.cpp | create_alt_name |
AlternativeName create_alt_name(const Data_Store& info)
{
auto names = info.search_for(
[](const std::string& key, const std::string&)
{
return (key == "RFC822" ||
key == "DNS" ||
key == "URI" ||
key == "IP");
});
AlternativeName alt_name;
for(auto i = names.begin(); i != names.end(); ++i)
alt_name.add_attribute(i->first, i->second);
return alt_name;
} |
bool Data_Store::operator==(const Data_Store& other);
bool Data_Store::has_value(const std::string& key);
std::vector<std::string> Data_Store::get(const std::string& looking_for);
std::string Data_Store::get1(const std::string& key);
void Data_Store::add(const std::string& key, const std::string& val);
void Data_Store::add(const std::string& key, uint32_t val);
void Data_Store::add(const std::string& key, const secure_vector<uint8_t>& val);
void Data_Store::add(const std::string& key, const std::vector<uint8_t>& val);
void Data_Store::add(const std::multimap<std::string, std::string>& in);
X509_DN create_dn(const Data_Store& info);
| 65cdafebd23fdabee207087b8e078b5ce239b9302af6f19f6e0e46e8c174360a | 460 |
|
MeridianOXC | OpenXcom | src/Engine/Surface.cpp | Surface::copy |
void Surface::copy(Surface *surface)
{
const int from_x = getX() - surface->getX();
const int from_y = getY() - surface->getY();
lock();
ShaderDrawFunc(
[](Uint8& dest, const Uint8& src)
{
dest = src;
},
ShaderMove<Uint8>(_surface.get(), from_x, from_y),
ShaderMove<Uint8>(surface, 0, 0)
);
unlock();
} |
inline int GetPitch(int bpp, int width);
inline void RawCopySurf(const Surface::UniqueSurfacePtr& dest, const Surface::UniqueSurfacePtr& src);
inline void FixTransparent(const Surface::UniqueSurfacePtr& dest, int currentTransColor);
Surface::UniqueBufferPtr Surface::NewAlignedBuffer(int bpp, int width, int height);
Surface::UniqueSurfacePtr Surface::NewSdlSurface(SDL_Surface* surface);
Surface::UniqueSurfacePtr Surface::NewSdlSurface(const Surface::UniqueBufferPtr& buffer, int bpp, int width, int height);
void Surface::CleanSdlSurface(SDL_Surface* surface);
void Surface::UniqueBufferDeleter::operator ();
void Surface::UniqueSurfaceDeleter::operator ();
Surface::Surface();
Surface::Surface(int width, int height, int x, int y);
Surface::Surface(const Surface& other);
Surface::~Surface();
void Surface::rawCopy(const std::vector<T> &src);
void Surface::loadRaw(const std::vector<unsigned char> &bytes);
void Surface::loadRaw(const std::vector<char> &bytes);
void Surface::loadScr(const std::string& filename);
void Surface::loadImage(const std::string &filename);
void Surface::loadSpk(const std::string& filename);
void Surface::loadBdy(const std::string &filename);
void Surface::clear();
void Surface::offset(int off, int min, int max, int mul);
void Surface::offsetBlock(int off, int blk, int mul);
void Surface::invert(Uint8 mid);
void Surface::think();
void Surface::draw();
void Surface::blit(SDL_Surface *surface);
void Surface::drawRect(SDL_Rect *rect, Uint8 color);
void Surface::drawRect(Sint16 x, Sint16 y, Sint16 w, Sint16 h, Uint8 color);
void Surface::drawLine(Sint16 x1, Sint16 y1, Sint16 x2, Sint16 y2, Uint8 color);
void Surface::drawCircle(Sint16 x, Sint16 y, Sint16 r, Uint8 color);
void Surface::drawPolygon(Sint16 *x, Sint16 *y, int n, Uint8 color);
void Surface::drawTexturedPolygon(Sint16 *x, Sint16 *y, int n, Surface *texture, int dx, int dy);
void Surface::drawString(Sint16 x, Sint16 y, const char *s, Uint8 color);
void Surface::setX(int x);
void Surface::setY(int y);
void Surface::setVisible(bool visible);
bool Surface::getVisible();
SurfaceCrop Surface::getCrop();
void Surface::setPalette(const SDL_Color *colors, int firstcolor, int ncolors);
void Surface::setHidden(bool hidden);
void Surface::lock();
void Surface::unlock();
void Surface::blitRaw(SurfaceRaw<Uint8> destSurf, SurfaceRaw<const Uint8> srcSurf, int x, int y, int shade, bool half, int newBaseColor);
void Surface::blitNShade(SurfaceRaw<Uint8> surface, int x, int y, int shade, bool half, int newBaseColor);
void Surface::blitNShade(SurfaceRaw<Uint8> surface, int x, int y, int shade, GraphSubset range);
void Surface::invalidate(bool valid);
void Surface::resize(int width, int height);
void Surface::setWidth(int width);
void Surface::setHeight(int height);
void SurfaceCrop::blit(Surface* dest);
| 9e3632260969f8dcde7f0f1c3319bb5ab1d019effa792aa9fb0d6b94f842d2dc | 328 |
|
yixu34 | Mastrix | client.cpp | Client::setRectangles |
void Client::setRectangles(RecvMessage &msg)
{
int numEdges = msg.getInt();
rectpool.resize(numEdges);
for(int ii=0; ii<numEdges; ii++)
{
rectpool[ii].name = msg.getString();
rectpool[ii].min_x = msg.getFloat();
rectpool[ii].max_x = msg.getFloat();
rectpool[ii].min_y = msg.getFloat();
rectpool[ii].max_y = msg.getFloat();
}
} |
CLIENT_CONSOLE_COMMAND(instant_zoom);
Client::Client(int index);
Client::~Client();
void Client::connect(void);
void Client::timepass(void);
void Client::redraw(void);
CLIENT_CONSOLE_COMMAND(fade_out);
CLIENT_CONSOLE_COMMAND(fade_in);
void Client::runCommand(RecvMessage &msg);
void Client::addEntity(RecvMessage &msg);
void Client::updateEntity(RecvMessage &msg);
void Client::dropEntity(RecvMessage &msg);
void Client::centerCamera(RecvMessage &msg);
void Client::print(RecvMessage &msg);
void Client::playSoundAt(RecvMessage &msg);
void Client::playSound(RecvMessage &msg);
void Client::setEngines(RecvMessage &msg);
void Client::explodeAt(RecvMessage &msg);
void Client::updateUI(RecvMessage &msg);
void Client::changeColor(RecvMessage &msg);
void Client::restoreColor(RecvMessage &msg);
void Client::updateScoreboard(RecvMessage &msg);
void Client::addEdge(RecvMessage &msg);
void Client::dropEdge(RecvMessage &msg);
void Client::showAllEdges();
void Client::hideAllEdges();
void Client::clearEdges();
void Client::drawLightning(RecvMessage &msg);
void Client::setDrawShield(RecvMessage &msg);
void Client::markAsAlly(RecvMessage &msg);
void Client::updateDrawEffect(RecvMessage &msg);
void Client::drawShield(int entID, float radius, float &time, int type);
void Client::convertToDrawCoords(float &x, float &y);
CLIENT_INVERSE_CONSOLE_COMMAND(show_scores);
CLIENT_CONSOLE_COMMAND(echo);
CLIENT_CONSOLE_COMMAND(change_resolution);
CLIENT_CONSOLE_COMMAND(exit);
CLIENT_CONSOLE_COMMAND(quit);
void changeFullScreen(bool fullscreen);
CLIENT_CONSOLE_COMMAND(toggle_fullscreen);
void playerize(int argc, const char **argv, int mode);
CLIENT_CONSOLE_COMMAND(player);
CLIENT_INVERTIBLE_CONSOLE_COMMAND(player);
CLIENT_INVERSE_CONSOLE_COMMAND(player);
static void changeName(std::string newname);
static void changeMusicStatus(bool playing);
CLIENT_CONSOLE_COMMAND(soundtrack);
| 1a363a910d9026a3dc776ae00b18a1ba2155d7121512d62dfbcf19057bcb9de7 | 343 |
|
mafiya69 | software-design-patterns | Interpreter/HandmadeInterpreter/HandmadeInterpreter/HandmadeInterpreter.cpp | Integer | explicit Integer(int value)
: value(value)
{
} | Token(Type type, const string& text);
std::ostream& operator<<(std::ostream& os, const Token& obj);
int eval();
vector<Token> lex(const string& input);
shared_ptr<Element> parse(const vector<Token>& tokens);
int main();
| e0d95443abb3e8c74dbc84ba18510c1079109649e2486a7aa712b6805d5e604c | 54 |
|
lilac | iASP | libgringo/src/output/plainoutput_impl.cpp | AvgAggrLitPrinter::weight | void AvgAggrLitPrinter::weight(const Val &v)
{
aggr_ << "=" << v.number();
} | void DisplayPrinter::print(PredLitRep *l);
void ExternalPrinter::print(PredLitRep *l);
void RulePrinter::begin();
void RulePrinter::endHead();
void RulePrinter::print(PredLitRep *l);
void RulePrinter::end();
void SumAggrLitPrinter::begin(bool head, bool sign, bool count);
void SumAggrLitPrinter::weight(const Val &v);
void SumAggrLitPrinter::lower(int32_t l);
void SumAggrLitPrinter::upper(int32_t u);
void SumAggrLitPrinter::print(PredLitRep *l);
void SumAggrLitPrinter::end();
void AvgAggrLitPrinter::begin(bool head, bool sign);
void AvgAggrLitPrinter::lower(int32_t l);
void AvgAggrLitPrinter::upper(int32_t u);
void AvgAggrLitPrinter::print(PredLitRep *l);
void AvgAggrLitPrinter::end();
void MinMaxAggrLitPrinter::begin(bool head, bool sign, bool max);
void MinMaxAggrLitPrinter::weight(const Val &v);
void MinMaxAggrLitPrinter::lower(const Val &l);
void MinMaxAggrLitPrinter::upper(const Val &u);
void MinMaxAggrLitPrinter::print(PredLitRep *l);
void MinMaxAggrLitPrinter::end();
void ParityAggrLitPrinter::begin(bool head, bool sign, bool even, bool set);
void ParityAggrLitPrinter::print(PredLitRep *l);
void ParityAggrLitPrinter::weight(const Val &v);
void ParityAggrLitPrinter::end();
void JunctionAggrLitPrinter::begin(bool);
void JunctionAggrLitPrinter::print(PredLitRep *l);
void OptimizePrinter::begin(bool maximize, bool set);
void OptimizePrinter::print(PredLitRep *l, int32_t weight, int32_t prio);
void OptimizePrinter::end();
void ComputePrinter::begin();
void ComputePrinter::print(PredLitRep *l);
void ComputePrinter::end();
| 33059e23253b05479006fb016cab562a9e15ca4959982ed0f0147385a7f8e409 | 81 |
|
JanMarvin | rstudio | src/cpp/shared_core/json/Json.cpp | toJsonArray<Object> |
Array toJsonArray<Object>(const std::vector<Object>& vector)
{
Array results;
for (const Object& val : vector)
{
results.push_back(val);
}
return results;
} |
inline boost::system::error_code make_error_code(ParseErrorCode e);
inline boost::system::error_condition make_error_condition(ParseErrorCode e);
inline boost::system::error_code make_error_code(PointerParseErrorCode e);
inline boost::system::error_condition make_error_condition(PointerParseErrorCode e);
const boost::system::error_category& jsonParseCategory();
const boost::system::error_category& jsonPointerParseCategory();
const char* JsonParseErrorCategory::name();
std::string JsonParseErrorCategory::message(int ev);
const char* JsonPointerParseErrorCategory::name();
std::string JsonPointerParseErrorCategory::message(int /*ev*/);
Object getSchemaDefaults(const Object& schema);
Impl();
explicit Impl(const std::shared_ptr<JsonDocument>& in_jsonDocument);
void copy(const Impl& in_other);
Value::Value();
Value::Value(ValueImplPtr in_valueImpl);
Value::Value(const Value& in_other);
Value::Value(Value&& in_other);
Value::Value(bool in_value);
Value::Value(double in_value);
Value::Value(float in_value);
Value::Value(int in_value);
Value::Value(int64_t in_value);
Value::Value(const char* in_value);
Value::Value(const std::string& in_value);
Value::Value(unsigned int in_value);
Value::Value(uint64_t in_value);
Value& Value::operator=(const Value& in_other);
Value& Value::operator=(Value&& in_other);
Value& Value::operator=(bool in_value);
Value& Value::operator=(double in_value);
Value& Value::operator=(float in_value);
Value& Value::operator=(int in_value);
Value& Value::operator=(int64_t in_value);
Value& Value::operator=(const char* in_value);
Value& Value::operator=(const std::string& in_value);
Value& Value::operator=(unsigned int in_value);
Value& Value::operator=(uint64_t in_value);
bool Value::operator==(const Value& in_other);
bool Value::operator!=(const Value& in_other);
Value Value::clone();
Array Value::getArray();
bool Value::getBool();
double Value::getDouble();
float Value::getFloat();
int Value::getInt();
int64_t Value::getInt64();
Object Value::getObject();
std::string Value::getString();
Type Value::getType();
unsigned int Value::getUInt();
uint64_t Value::getUInt64();
Array Value::getValue<Array>();
bool Value::getValue<bool>();
double Value::getValue<double>();
float Value::getValue<float>();
int Value::getValue<int>();
int64_t Value::getValue<int64_t>();
Object Value::getValue<Object>();
std::string Value::getValue<std::string>();
unsigned int Value::getValue<unsigned int>();
uint64_t Value::getValue<uint64_t>();
bool Value::isArray();
bool Value::isBool();
bool Value::isDouble();
bool Value::isFloat();
bool Value::isInt();
bool Value::isInt64();
bool Value::isObject();
bool Value::isString();
bool Value::isNull();
bool Value::isUInt();
bool Value::isUInt64();
Error Value::parse(const char* in_jsonStr);
Error Value::parse(const std::string& in_jsonStr);
Error Value::parseAndValidate(const std::string& in_jsonStr, const std::string& in_schema);
Error Value::setValueAtPointerPath(const std::string& in_pointerPath, const json::Value& in_value);
Error Value::setValueAtPointerPath(const std::string& in_pointerPath, bool in_value);
Error Value::setValueAtPointerPath(const std::string& in_pointerPath, double in_value);
Error Value::setValueAtPointerPath(const std::string& in_pointerPath, float in_value);
Error Value::setValueAtPointerPath(const std::string& in_pointerPath, int in_value);
Error Value::setValueAtPointerPath(const std::string& in_pointerPath, int64_t in_value);
Error Value::setValueAtPointerPath(const std::string& in_pointerPath, const char* in_value);
Error Value::setValueAtPointerPath(const std::string& in_pointerPath, const std::string& in_value);
Error Value::setValueAtPointerPath(const std::string& in_pointerPath, unsigned int in_value);
Error Value::setValueAtPointerPath(const std::string& in_pointerPath, uint64_t in_value);
Error Value::setValueAtPointerPath(const std::string& in_pointerPath, const Array& in_value);
Error Value::setValueAtPointerPath(const std::string& in_pointerPath, const Object& in_value);
Error Value::validate(const std::string& in_schema);
std::string Value::write();
void Value::write(std::ostream& os);
std::string Value::writeFormatted();
void Value::writeFormatted(std::ostream& os);
void Value::move(Value&& in_other);
Impl(const std::string& in_name, const std::shared_ptr<JsonDocument>& in_document);
Object::Member::Member(const std::shared_ptr<Object::Member::Impl>& in_impl);
const std::string& Object::Member::getName();
Value Object::Member::getValue();
Object::Iterator::Iterator(const Object* in_parent, std::ptrdiff_t in_startPos);
Object::Iterator& Object::Iterator::operator=(const Object::Iterator& in_other);
Object::Iterator& Object::Iterator::operator++();
Object::Iterator Object::Iterator::operator++(int);
Object::Iterator& Object::Iterator::operator--();
Object::Iterator Object::Iterator::operator--(int);
bool Object::Iterator::operator==(const Object::Iterator& in_other);
bool Object::Iterator::operator!=(const Object::Iterator& in_other);
Object::Iterator::reference Object::Iterator::operator*();
Object::Object();
Object::Object(const StringPairList& in_strPairs);
Object::Object(const Object& in_other);
Object::Object(Object&& in_other);
Error Object::getSchemaDefaults(const std::string& in_schema, Object& out_schemaDefaults);
Object Object::mergeObjects(const Object& in_base, const Object& in_overlay);
Object& Object::operator=(const Object& in_other);
Object& Object::operator=(Object&& in_other);
Value Object::operator[](const char* in_name);
Value Object::operator[](const std::string& in_name);
Object::Iterator Object::find(const char* in_name);
Object::Iterator Object::find(const std::string& in_name);
Object::Iterator Object::begin();
Object::Iterator Object::end();
Object::ReverseIterator Object::rbegin();
Object::ReverseIterator Object::rend();
void Object::clear();
bool Object::erase(const char* in_name);
bool Object::erase(const std::string& in_name);
Object::Iterator Object::erase(const Object::Iterator& in_itr);
size_t Object::getSize();
bool Object::hasMember(const char* in_name);
bool Object::hasMember(const std::string& in_name);
void Object::insert(const std::string& in_name, const Value& in_value);
void Object::insert(const std::string& in_name, bool in_value);
void Object::insert(const std::string& in_name, double in_value);
void Object::insert(const std::string& in_name, float in_value);
void Object::insert(const std::string& in_name, int in_value);
void Object::insert(const std::string& in_name, int64_t in_value);
void Object::insert(const std::string& in_name, const char* in_value);
void Object::insert(const std::string& in_name, const std::string& in_value);
void Object::insert(const std::string& in_name, unsigned int in_value);
void Object::insert(const std::string& in_name, uint64_t in_value);
void Object::insert(const std::string& in_name, const Array& in_value);
void Object::insert(const std::string& in_name, const Object& in_value);
void Object::insert(const Member& in_member);
bool Object::isEmpty();
Error Object::parse(const char* in_jsonStr);
Error Object::parse(const std::string& in_jsonStr);
bool Object::toStringMap(StringListMap& out_map);
StringPairList Object::toStringPairList();
Object::Object(ValueImplPtr in_value);
Array::Iterator::Iterator(const Array* in_parent, std::ptrdiff_t in_startPos);
Array::Iterator& Array::Iterator::operator=(const Array::Iterator& in_other);
Array::Iterator& Array::Iterator::operator++();
Array::Iterator& Array::Iterator::operator--();
Array::Iterator Array::Iterator::operator++(int);
Array::Iterator Array::Iterator::operator--(int);
bool Array::Iterator::operator==(const Array::Iterator& in_other);
bool Array::Iterator::operator!=(const Array::Iterator& in_other);
Array::Iterator::reference Array::Iterator::operator*();
Array::Array();
Array::Array(const StringPairList& in_strPairs);
Array::Array(const Array& in_other);
Array::Array(Array&& in_other);
Array& Array::operator=(const Array& in_other);
Array& Array::operator=(Array&& in_other);
Value Array::operator[](size_t in_index);
Array::Iterator Array::begin();
Array::Iterator Array::end();
Array::ReverseIterator Array::rbegin();
Array::ReverseIterator Array::rend();
void Array::clear();
Array::Iterator Array::erase(const Array::Iterator& in_itr);
Array::Iterator Array::erase(const Array::Iterator& in_first, const Array::Iterator& in_last);
Value Array::getBack();
Value Array::getFront();
Value Array::getValueAt(size_t in_index);
size_t Array::getSize();
bool Array::isEmpty();
Error Array::parse(const char* in_jsonStr);
Error Array::parse(const std::string& in_jsonStr);
void Array::push_back(const Value& in_value);
void Array::push_back(bool in_value);
void Array::push_back(double in_value);
void Array::push_back(float in_value);
void Array::push_back(int in_value);
void Array::push_back(int64_t in_value);
void Array::push_back(const char* in_value);
void Array::push_back(const std::string& in_value);
void Array::push_back(unsigned int in_value);
void Array::push_back(uint64_t in_value);
void Array::push_back(const json::Array& in_value);
void Array::push_back(const json::Object& in_value);
bool Array::toSetString(std::set<std::string>& out_set);
StringPairList Array::toStringPairList();
bool Array::toVectorInt(std::vector<int>& out_vector);
bool Array::toVectorString(std::vector<std::string>& out_vector);
Array::Array(ValueImplPtr in_value);
std::string typeAsString(Type in_type);
std::ostream& operator<<(std::ostream& io_ostream, Type in_type);
Array toJsonArray<Value>(const std::vector<Value>& vector);
Array toJsonArray<Array>(const std::vector<Array>& vector);
Array toJsonArray<Value>(const std::set<Value>& set);
Array toJsonArray<Object>(const std::set<Object>& set);
Array toJsonArray<Array>(const std::set<Array>& set);
Error jsonReadError(JsonReadError in_errorCode, const std::string& in_message, const ErrorLocation& in_errorLocation);
bool isMissingMemberError(const Error& in_error);
| b9a6c0f0f639034aba0ddcacd04c441a95a71029b6dde22fdf903fdfd8684c44 | 178 |
|
bretthall | Wyatt-STM | testing/unit-tests/stm_test.cpp |
BOOST_AUTO_TEST_CASE |
BOOST_AUTO_TEST_CASE (StmVarTests_test_retry_before)
{
WRetryWaitData::Ptr waitData_p(new WRetryWaitData("test_retry_before", 10));
waitData_p->sleepTime = 30;
WRetryIncData::Ptr incData_p(new WRetryIncData(waitData_p, 1, 10));
std::thread t1(boost::bind(RetryWait, waitData_p));
std::thread t2(boost::bind(RetryInc, incData_p));
waitData_p->finishBarrier_p->wait();
BOOST_CHECK(!waitData_p->gotMaxRetries);
BOOST_CHECK_EQUAL(static_cast<unsigned int>(0), waitData_p->timeouts);
BOOST_CHECK_EQUAL(static_cast<unsigned int>(1), waitData_p->retries);
BOOST_CHECK_EQUAL(static_cast<unsigned int>(10), waitData_p->var_p->GetReadOnly());
BOOST_CHECK (!waitData_p->m_wasInAtomicAfterTrans);
BOOST_CHECK (!incData_p->m_wasInAtomicAfterTrans);
t1.join ();
t2.join ();
} | WVarPtr(WSTM::WVar<Type_t>* var_p);
BOOST_AUTO_TEST_CASE (version);
BOOST_AUTO_TEST_CASE (ExceptionTests_test_cantContinueException);
BOOST_AUTO_TEST_CASE (ExceptionTests_test_MaxRetriesException);
BOOST_AUTO_TEST_CASE (ExceptionTests_test_MaxConflictsException);
WVarDtorTester (const int val);
WVarDtorTester (const WVarDtorTester& t);
WVarDtorTester& operator= (const WVarDtorTester& t);
WVarDtorTester::~WVarDtorTester ();
BOOST_AUTO_TEST_CASE (StmVarTests_DtorCalled);
void Wait(std::shared_ptr<boost::barrier>& barrier_p);
int IncrementInt(WSTM::WVar<int>& v, const int inc, WSTM::WAtomic& at);
BOOST_AUTO_TEST_CASE (StmVarTests_test_int_increment);
static Ptr create(int x);
int IncrementTestClass(WTest::Var& v, const int inc, WSTM::WAtomic& at);
BOOST_AUTO_TEST_CASE (StmVarTests_test_class_increment);
BOOST_AUTO_TEST_CASE (StmVarTests_test_conflict);
void SetVarValueAndThrow (WSTM::WVar<int>& var, const int value, WSTM::WAtomic& at);
BOOST_AUTO_TEST_CASE (StmVarTests_test_exception_thrown);
WRetryWaitData(const std::string& name_, const unsigned int desiredVarVal_);
void NoRetryBarrier();
void RetryWaitAtomic(WRetryWaitData::Ptr data_p, WSTM::WAtomic& at);
void RetryWait(WRetryWaitData::Ptr data_p);
void RetryIncAtomic(WRetryIncData::Ptr data_p, WSTM::WAtomic& at);
void RetryInc(WRetryIncData::Ptr data_p);
BOOST_AUTO_TEST_CASE (StmVarTests_test_retry_after);
void DoRetyTimeout (WSTM::WAtomic& at);
BOOST_AUTO_TEST_CASE (StmVarTests_test_retryTimeoutSimple);
BOOST_AUTO_TEST_CASE (StmVarTests_test_retryTimeout);
BOOST_AUTO_TEST_CASE (StmVarTests_test_retry_max_timeout);
BOOST_AUTO_TEST_CASE (StmVarTests_test_retry_limit);
BOOST_AUTO_TEST_CASE (StmVarTests_test_max_conflict_throw);
BOOST_AUTO_TEST_CASE (StmVarTests_test_max_conflict_lock);
BOOST_AUTO_TEST_CASE (StmVarTests_test_max_conflict_lock_with_sub_trans);
void DoThrowTest(WSTM::WVar<int>& var, WSTM::WAtomic& at);
BOOST_AUTO_TEST_CASE (StmVarTests_test_op_throws);
void Nested(WSTM::WVar<int>& var, bool& sawGoodValue, WSTM::WAtomic& at);
bool Toplevel(WSTM::WVar<int>& var, bool& sawGoodValue, WSTM::WAtomic& at);
BOOST_AUTO_TEST_CASE (StmVarTests_test_nested_transaction_rollback);
void TestDisappearingVarAtomic(WSTM::WAtomic& at);
BOOST_AUTO_TEST_CASE (StmVarTests_test_disappearing_var);
int& GetRefVal(WSTM::WAtomic& /*at*/);
BOOST_AUTO_TEST_CASE (StmVarTests_test_ref_return);
void child(WSTM::WAtomic& at);
void parent(WSTM::WAtomic& at);
BOOST_AUTO_TEST_CASE (StmVarTests_test_nested_get);
void child(WSTM::WAtomic& at);
void parent(WSTM::WAtomic& at);
BOOST_AUTO_TEST_CASE (StmVarTests_test_nested_set);
std::pair<int, int> TestInternalConstReturnAtomic(WSTM::WAtomic&);
BOOST_AUTO_TEST_CASE (StmVarTests_test_internal_const_return);
void operator();
void TestCommitHookAtomic(WSTM::WAtomic& at);
BOOST_AUTO_TEST_CASE (StmVarTests_test_commit_hook);
void TestCommitHookNestedAtomic(WSTM::WAtomic& at, bool topHook, bool childHook);
BOOST_AUTO_TEST_CASE (StmVarTests_test_commit_hook_nested);
void Conflicter(WSTM::WAtomic& at);
void ConflicterThread();
void Conflictee(WSTM::WAtomic& at, bool topHook, bool childHook);
BOOST_AUTO_TEST_CASE (StmVarTests_test_commit_hook_conflict);
void operator();
void PostCommit();
void RunAtomic(WSTM::WAtomic& /*at*/);
BOOST_AUTO_TEST_CASE (StmVarTests_test_commit_hook_uses_atomic);
BOOST_AUTO_TEST_CASE (StmVarTests_test_nested_transaction_retry);
BOOST_AUTO_TEST_CASE (StmVarTests_test_nested_transaction_parent_retry);
BOOST_AUTO_TEST_CASE (StmVarTests_test_inconsistent);
BOOST_AUTO_TEST_CASE (StmVarTests_test_inconsistentInAtomic);
BOOST_AUTO_TEST_CASE (StmVarTests_test_inconsistentConflict);
BOOST_AUTO_TEST_CASE (StmVarTests_test_ReadLockAtomic);
BOOST_AUTO_TEST_CASE (StmVarTests_test_ReadLockInconsistent);
BOOST_AUTO_TEST_CASE (StmVarTests_test_ReadLockRetry);
BOOST_AUTO_TEST_CASE (StmVarTests_test_ReadLockIsLocked);
BOOST_AUTO_TEST_CASE (StmVarTests_test_get_split_transaction_levels);
BOOST_AUTO_TEST_CASE (StmVarTests_test_set_split_transaction_levels);
BOOST_AUTO_TEST_CASE (StmVarTests_test_nested_validation_fail);
WAtomicallyInDtor::WAtomicallyInDtor ();
WAtomicallyInDtor::WAtomicallyInDtor (const WAtomicallyInDtor& other);
WAtomicallyInDtor& WAtomicallyInDtor::operator=(const WAtomicallyInDtor& other);
void UpdateValue (WSTM::WVar<WAtomicallyInDtor>& var, WSTM::WAtomic& at);
WAtomicallyInDtor::~WAtomicallyInDtor ();
BOOST_AUTO_TEST_CASE (StmVarTests_AtomicallyInValueDtor);
BOOST_AUTO_TEST_CASE (StmVarTests_AtomicallyDuringThreadExit);
BOOST_AUTO_TEST_CASE (single_var_validation);
void NoFailTrans (bool& flag1, WSTM::WVar<bool>& flag2_v, WSTM::WAtomic& at);
BOOST_AUTO_TEST_CASE (StmVarTests_OnFailed_no_failure);
void AbortTrans (bool& flag1, WSTM::WVar<bool>& flag2_v, WSTM::WAtomic& at);
BOOST_AUTO_TEST_CASE (StmVarTests_OnFailed_abort);
void ConflicterThread (const std::shared_ptr<WSTM::WVar<int>>& var_p,
const std::shared_ptr<boost::barrier>& bar_p);
BOOST_AUTO_TEST_CASE (StmVarTests_OnFailed_conflict);
void RetryUpdateThread (const std::shared_ptr<WSTM::WVar<int>>& var_p,
const std::shared_ptr<boost::barrier>& bar_p);
BOOST_AUTO_TEST_CASE (StmVarTests_OnFailed_retry);
NestTrans (boost::function<void (WSTM::WAtomic&);
void operator();
BOOST_AUTO_TEST_CASE (StmVarTests_OnFailed_nested_no_failure);
BOOST_AUTO_TEST_CASE (StmVarTests_OnFailed_nested_abort);
BOOST_AUTO_TEST_CASE (StmVarTests_OnFailed_nested_conflict);
BOOST_AUTO_TEST_CASE (StmVarTests_OnFailed_nested_retry);
BOOST_AUTO_TEST_CASE (StmVarTests_lambda_atomic);
BOOST_AUTO_TEST_CASE (StmVarTests_lambda_inconsistent);
WTransInDtor (WSTM::WVar<int>& v, const int i);
~WTransInDtor ();
BOOST_AUTO_TEST_CASE (StmVarTests_dtor_trans_during_restart);
BOOST_AUTO_TEST_CASE (test_RunAtomically);
BOOST_AUTO_TEST_CASE (test_RunAtomically_void_return);
WMoveOnly (WMoveOnly&& m);
WMoveOnly& operator=(WMoveOnly&& m);
BOOST_AUTO_TEST_CASE (move_result);
WCopyOnly (const WCopyOnly& m);
WCopyOnly& operator=(const WCopyOnly& m);
BOOST_AUTO_TEST_CASE (copy_result);
BOOST_AUTO_TEST_CASE(BeforeCommitTests_test_run);
BOOST_AUTO_TEST_CASE(BeforeCommitTests_test_child_reg);
BOOST_AUTO_TEST_CASE(BeforeCommitTests_test_parent_reg);
BOOST_AUTO_TEST_CASE(BeforeCommitTests_exception_thrown);
BOOST_AUTO_TEST_CASE (set_get);
MoveOnly (int value);
MoveOnly (MoveOnly&& m);
MoveOnly& operator=(MoveOnly&& m);
BOOST_AUTO_TEST_CASE (set_get_move_only);
BOOST_AUTO_TEST_CASE (no_thread_sharing);
BOOST_AUTO_TEST_CASE (multiple_vars);
BOOST_AUTO_TEST_CASE (child_transaction);
BOOST_AUTO_TEST_CASE (flag);
| fc9f29eb7a5075f3a5678f8460feb9e284debaa0f4bef97cbeedf6d2cb578325 | 787 |
|
YeRuFi | PasswordManager | miosix/stdlib_integration/libstdcpp_integration.cpp | new[] |
void *operator new[](size_t size) throw()
{
return malloc(size);
} |
void *operator new(size_t size);
void operator delete(void *p);
void operator delete[](void *p);
void __cxxabiv1::__cxa_pure_virtual(void);
void __cxxabiv1::__cxa_deleted_virtual(void);
static __cxxabiv1::__cxa_eh_globals *getEhGlobals();
static void *getSjljPtr();
static void setSjljPtr(void *ptr);
__cxa_eh_globals* __cxa_get_globals_fast();
__cxa_eh_globals* __cxa_get_globals();
void _Miosix_set_sjlj_ptr(void* ptr);
void *_Miosix_get_sjlj_ptr();
void __verbose_terminate_handler();
int __cxa_guard_acquire(__guard *g);
void __cxa_guard_release(__guard *g);
void __cxa_guard_abort(__guard *g);
| c25260970dc2e56329b7ab29c60c9f184dffeb14c9cdb1b395d752ae2f020ee4 | 71 |
|
lbryio | lbrycrd | src/test/claimtriehashfork_tests.cpp |
BOOST_AUTO_TEST_CASE |
BOOST_AUTO_TEST_CASE(value_proof_test)
{
ClaimTrieChainFixture fixture;
std::string sName1("a");
std::string sValue1("testa");
std::string sName2("abc");
std::string sValue2("testabc");
std::string sName3("abd");
std::string sValue3("testabd");
std::string sName4("zyx");
std::string sValue4("testzyx");
std::string sName5("zyxa");
std::string sName6("omg");
std::string sName7("");
CMutableTransaction tx1 = fixture.MakeClaim(fixture.GetCoinbase(), sName1, sValue1);
COutPoint tx1OutPoint(tx1.GetHash(), 0);
CMutableTransaction tx2 = fixture.MakeClaim(fixture.GetCoinbase(), sName2, sValue2);
COutPoint tx2OutPoint(tx2.GetHash(), 0);
CMutableTransaction tx3 = fixture.MakeClaim(fixture.GetCoinbase(), sName3, sValue3);
COutPoint tx3OutPoint(tx3.GetHash(), 0);
CMutableTransaction tx4 = fixture.MakeClaim(fixture.GetCoinbase(), sName4, sValue4);
COutPoint tx4OutPoint(tx4.GetHash(), 0);
CClaimValue val;
fixture.IncrementBlocks(5, true);
BOOST_CHECK(!pclaimTrie->empty());
BOOST_CHECK(fixture.queueEmpty());
BOOST_CHECK(fixture.getInfoForName(sName1, val));
BOOST_CHECK_EQUAL(val.outPoint, tx1OutPoint);
BOOST_CHECK(fixture.getInfoForName(sName2, val));
BOOST_CHECK_EQUAL(val.outPoint, tx2OutPoint);
BOOST_CHECK(fixture.getInfoForName(sName3, val));
BOOST_CHECK_EQUAL(val.outPoint, tx3OutPoint);
BOOST_CHECK(fixture.getInfoForName(sName4, val));
BOOST_CHECK_EQUAL(val.outPoint, tx4OutPoint);
CClaimTrieProof proof;
BOOST_CHECK(fixture.getProofForName(sName1, proof));
BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName1));
BOOST_CHECK_EQUAL(proof.outPoint, tx1OutPoint);
BOOST_CHECK(fixture.getProofForName(sName2, proof));
BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName2));
BOOST_CHECK_EQUAL(proof.outPoint, tx2OutPoint);
BOOST_CHECK(fixture.getProofForName(sName3, proof));
BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName3));
BOOST_CHECK_EQUAL(proof.outPoint, tx3OutPoint);
BOOST_CHECK(fixture.getProofForName(sName4, proof));
BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName4));
BOOST_CHECK_EQUAL(proof.outPoint, tx4OutPoint);
BOOST_CHECK(fixture.getProofForName(sName5, proof));
BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName5));
BOOST_CHECK_EQUAL(proof.hasValue, false);
BOOST_CHECK(fixture.getProofForName(sName6, proof));
BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName6));
BOOST_CHECK_EQUAL(proof.hasValue, false);
BOOST_CHECK(fixture.getProofForName(sName7, proof));
BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName7));
BOOST_CHECK_EQUAL(proof.hasValue, false);
CMutableTransaction tx5 = fixture.MakeClaim(fixture.GetCoinbase(), sName7, sValue4);
COutPoint tx5OutPoint(tx5.GetHash(), 0);
fixture.IncrementBlocks(1);
BOOST_CHECK(fixture.getInfoForName(sName7, val));
BOOST_CHECK_EQUAL(val.outPoint, tx5OutPoint);
BOOST_CHECK(fixture.getProofForName(sName1, proof));
BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName1));
BOOST_CHECK_EQUAL(proof.outPoint, tx1OutPoint);
BOOST_CHECK(fixture.getProofForName(sName2, proof));
BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName2));
BOOST_CHECK_EQUAL(proof.outPoint, tx2OutPoint);
BOOST_CHECK(fixture.getProofForName(sName3, proof));
BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName3));
BOOST_CHECK_EQUAL(proof.outPoint, tx3OutPoint);
BOOST_CHECK(fixture.getProofForName(sName4, proof));
BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName4));
BOOST_CHECK_EQUAL(proof.outPoint, tx4OutPoint);
BOOST_CHECK(fixture.getProofForName(sName5, proof));
BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName5));
BOOST_CHECK_EQUAL(proof.hasValue, false);
BOOST_CHECK(fixture.getProofForName(sName6, proof));
BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName6));
BOOST_CHECK_EQUAL(proof.hasValue, false);
BOOST_CHECK(fixture.getProofForName(sName7, proof));
BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName7));
BOOST_CHECK_EQUAL(proof.outPoint, tx5OutPoint);
fixture.DecrementBlocks();
BOOST_CHECK(pclaimTrie->empty());
BOOST_CHECK(fixture.queueEmpty());
} |
void ValidatePairs(CClaimTrieCache& cache, const std::vector<std::pair<bool, uint256>>& pairs, uint256 claimHash);
BOOST_AUTO_TEST_CASE(hash_includes_all_claims_rollback_test);
BOOST_AUTO_TEST_CASE(hash_includes_all_claims_single_test);
BOOST_AUTO_TEST_CASE(hash_includes_all_claims_triple_test);
BOOST_AUTO_TEST_CASE(hash_includes_all_claims_branched_test);
BOOST_AUTO_TEST_CASE(hash_claims_children_fuzzer_test);
bool verify_proof(const CClaimTrieProof proof, uint256 rootHash, const std::string& name);
BOOST_AUTO_TEST_CASE(bogus_claimtrie_hash_test);
| bc4b1318cc543ffd54288c26a45dca9079eda9303e944ee281bd50f0235ab2b3 | 4,579 |
|
KeckCAVES | Vrui | Math/Matrix.cpp | Matrix::divideFullPivot |
Matrix& Matrix::divideFullPivot(const Matrix& other)
{
double* ext=new double[numRows*(numRows+numColumns)];
double* extPtr=ext;
const double* mPtr=m;
const double* oPtr=other.m;
for(unsigned int i=0;i<numRows;++i)
{
for(unsigned int j=0;j<numRows;++j,++extPtr,++oPtr)
*extPtr=*oPtr;
for(unsigned int j=0;j<numColumns;++j,++extPtr,++mPtr)
*extPtr=*mPtr;
}
unsigned int* columnIndices=new unsigned int[numRows];
for(unsigned int i=0;i<numRows;++i)
columnIndices[i]=i;
int swapSign;
if(gaussFullPivoting(numRows,numRows+numColumns,ext,numRows,columnIndices,swapSign)<numRows)
{
delete[] ext;
delete[] columnIndices;
throw RankDeficientError();
}
makePrivate();
double* extRowPtr=ext+(numRows-1)*(numRows+numColumns);
for(unsigned int i1=numRows;i1>0;--i1,extRowPtr-=numRows+numColumns)
{
double* mRowPtr=m+columnIndices[i1-1]*numColumns;
double* bsPtr1=extRowPtr+(i1-1);
double* bsPtr2=extRowPtr+numRows;
for(unsigned int j=0;j<numColumns;++j,++bsPtr2)
{
double sum=*bsPtr2;
double* p1=bsPtr1+1;
double* p2=bsPtr2+(numRows+numColumns);
for(unsigned int k=i1;k<numRows;++k,++p1,p2+=numRows+numColumns)
sum-=(*p1)*(*p2);
mRowPtr[j]=*bsPtr2=sum/(*bsPtr1);
}
}
delete[] ext;
delete[] columnIndices;
return *this;
} |
bool gaussColumnPivoting(unsigned int numRows,unsigned int numColumns,double* m);
unsigned int gaussFullPivoting(unsigned int numRows,unsigned int numColumns,double* m,unsigned int maxPivotColumn,unsigned int columnIndices[],int& swapSign);
void Matrix::share(double* newM);
void Matrix::release(void);
Matrix::Matrix(unsigned int sNumRows,unsigned int sNumColumns,double* sElements);
Matrix::Matrix(unsigned int sNumRows,unsigned int sNumColumns,double sDiag);
Matrix Matrix::getRow(unsigned int rowIndex);
Matrix Matrix::getColumn(unsigned int columnIndex);
bool Matrix::operator==(const Matrix& other);
bool Matrix::operator!=(const Matrix& other);
void Matrix::makePrivate(void);
void Matrix::setRow(unsigned int rowIndex,const Matrix& row);
void Matrix::setColumn(unsigned int columnIndex,const Matrix& column);
void Matrix::swapRows(unsigned int rowIndex1,unsigned int rowIndex2);
void Matrix::swapColumns(unsigned int columnIndex1,unsigned int columnIndex2);
void Matrix::scaleRow(unsigned int rowIndex,double factor);
void Matrix::scaleColumn(unsigned int columnIndex,double factor);
void Matrix::combineRows(unsigned int rowIndex1,double factor,unsigned int rowIndex2);
Matrix Matrix::operator-(void);
Matrix& Matrix::operator+=(const Matrix& other);
Matrix& Matrix::operator-=(const Matrix& other);
Matrix Matrix::inverse(void);
Matrix Matrix::inverseFullPivot(void);
Matrix& Matrix::operator*=(const Matrix& other);
Matrix& Matrix::operator/=(const Matrix& other);
Matrix& Matrix::operator*=(double factor);
Matrix& Matrix::operator/=(double divisor);
double Matrix::mag(void);
Matrix Matrix::transpose(void);
double Matrix::determinant(void);
unsigned int Matrix::rank(void);
Matrix Matrix::kernel(void);
std::pair<Matrix,Matrix> Matrix::solveLinearSystem(const Matrix& coefficients,double zeroFudge);
Matrix Matrix::choleskyDecomposition(void);
std::pair<Matrix,Matrix> Matrix::qrDecomposition(void);
inline unsigned int findRowPivot(unsigned int i,unsigned int numColumns,const double* m);
std::pair<Matrix,Matrix> Matrix::jacobiIteration(void);
SVD Matrix::svd(bool calcU,bool calcV);
| 01f071007477aa9daf18ec534908e32f429148216e1d6184a52896805dbc72bb | 1,331 |
|
kuba1 | qtcreator | src/plugins/git/giteditor.cpp | GitEditorWidget::commandFinishedGotoLine |
void GitEditorWidget::commandFinishedGotoLine(bool ok, int exitCode, const QVariant &v)
{
reportCommandFinished(ok, exitCode, v);
if (ok && v.type() == QVariant::Int) {
const int line = v.toInt();
if (line >= 0)
gotoLine(line);
}
} |
GitEditorWidget::GitEditorWidget();
QSet<QString> GitEditorWidget::annotationChanges();
QString GitEditorWidget::changeUnderCursor(const QTextCursor &c);
BaseAnnotationHighlighter *GitEditorWidget::createAnnotationHighlighter(const QSet<QString> &changes);
static QString removeAnnotationDate(const QString &b);
void GitEditorWidget::setPlainTextFiltered(const QString &text);
void GitEditorWidget::checkoutChange();
void GitEditorWidget::resetChange();
void GitEditorWidget::cherryPickChange();
void GitEditorWidget::revertChange();
void GitEditorWidget::stageDiffChunk();
void GitEditorWidget::unstageDiffChunk();
void GitEditorWidget::applyDiffChunk(const DiffChunk& chunk, bool revert);
void GitEditorWidget::init();
void GitEditorWidget::addDiffActions(QMenu *menu, const DiffChunk &chunk);
bool GitEditorWidget::open(QString *errorString, const QString &fileName, const QString &realFileName);
QString GitEditorWidget::decorateVersion(const QString &revision);
QStringList GitEditorWidget::annotationPreviousVersions(const QString &revision);
bool GitEditorWidget::isValidRevision(const QString &revision);
void GitEditorWidget::addChangeActions(QMenu *menu, const QString &change);
QString GitEditorWidget::revisionSubject(const QTextBlock &inBlock);
bool GitEditorWidget::supportChangeLinks();
QString GitEditorWidget::fileNameForLine(int line);
QString GitEditorWidget::sourceWorkingDirectory();
| b1dd3deebf48c540737fb0a3f83856e4761bcde21ddda64e82442750155fcfbf | 272 |
|
PlayFab | PlayFab-Samples | Samples/Win32/ThunderRumble/PlayFabCPPSDK/source/playfab/PlayFabAdminApi.cpp | PlayFabAdminAPI::OnUpdateCloudScriptResult | void PlayFabAdminAPI::OnUpdateCloudScriptResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer)
{
CallRequestContainer& container = static_cast<CallRequestContainer&>(reqContainer);
UpdateCloudScriptResult outResult;
if (ValidateResult(outResult, container))
{
const auto internalPtr = container.successCallback.get();
if (internalPtr != nullptr)
{
const auto callback = (*static_cast<ProcessApiCallback<UpdateCloudScriptResult> *>(internalPtr));
callback(outResult, container.GetCustomData());
}
}
delete &container;
} | size_t PlayFabAdminAPI::Update();
void PlayFabAdminAPI::ForgetAllCredentials();
void PlayFabAdminAPI::OnAbortTaskInstanceResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnAddNewsResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnAddPlayerTagResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnAddServerBuildResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnAddUserVirtualCurrencyResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnAddVirtualCurrencyTypesResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnBanUsersResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnCheckLimitedEditionItemAvailabilityResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnCreateActionsOnPlayersInSegmentTaskResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnCreateCloudScriptTaskResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnCreatePlayerSharedSecretResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnCreatePlayerStatisticDefinitionResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnDeleteContentResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnDeleteMasterPlayerAccountResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnDeletePlayerResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnDeletePlayerSharedSecretResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnDeleteStoreResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnDeleteTaskResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnDeleteTitleResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnExportMasterPlayerDataResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetActionsOnPlayersInSegmentTaskInstanceResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetAllSegmentsResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetCatalogItemsResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetCloudScriptRevisionResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetCloudScriptTaskInstanceResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetCloudScriptVersionsResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetContentListResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetContentUploadUrlResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetDataReportResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetMatchmakerGameInfoResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetMatchmakerGameModesResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetPlayedTitleListResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetPlayerIdFromAuthTokenResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetPlayerProfileResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetPlayerSegmentsResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetPlayerSharedSecretsResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetPlayersInSegmentResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetPlayerStatisticDefinitionsResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetPlayerStatisticVersionsResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetPlayerTagsResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetPolicyResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetPublisherDataResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetRandomResultTablesResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetServerBuildInfoResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetServerBuildUploadUrlResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetStoreItemsResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetTaskInstancesResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetTasksResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetTitleDataResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetTitleInternalDataResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetUserAccountInfoResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetUserBansResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetUserDataResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetUserInternalDataResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetUserInventoryResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetUserPublisherDataResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetUserPublisherInternalDataResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetUserPublisherReadOnlyDataResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGetUserReadOnlyDataResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnGrantItemsToUsersResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnIncrementLimitedEditionItemAvailabilityResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnIncrementPlayerStatisticVersionResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnListServerBuildsResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnListVirtualCurrencyTypesResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnModifyMatchmakerGameModesResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnModifyServerBuildResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnRefundPurchaseResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnRemovePlayerTagResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnRemoveServerBuildResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnRemoveVirtualCurrencyTypesResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnResetCharacterStatisticsResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnResetPasswordResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnResetUserStatisticsResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnResolvePurchaseDisputeResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnRevokeAllBansForUserResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnRevokeBansResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnRevokeInventoryItemResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnRevokeInventoryItemsResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnRunTaskResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnSendAccountRecoveryEmailResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnSetCatalogItemsResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnSetPlayerSecretResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnSetPublishedRevisionResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnSetPublisherDataResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnSetStoreItemsResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnSetTitleDataResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnSetTitleInternalDataResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnSetupPushNotificationResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnSubtractUserVirtualCurrencyResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnUpdateBansResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnUpdateCatalogItemsResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnUpdatePlayerSharedSecretResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnUpdatePlayerStatisticDefinitionResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnUpdatePolicyResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnUpdateRandomResultTablesResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnUpdateStoreItemsResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnUpdateTaskResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnUpdateUserDataResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnUpdateUserInternalDataResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnUpdateUserPublisherDataResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnUpdateUserPublisherInternalDataResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnUpdateUserPublisherReadOnlyDataResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnUpdateUserReadOnlyDataResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
void PlayFabAdminAPI::OnUpdateUserTitleDisplayNameResult(int httpCode, std::string result, CallRequestContainerBase& reqContainer);
bool PlayFabAdminAPI::ValidateResult(PlayFabResultCommon& resultCommon, CallRequestContainer& container);
| 964e2355247189a20b0bca929ae4cbe197ca4be4da8954d822f7e38801b7ad73 | 685 |
|
VoxMaro | aieBootstrap-Bradan-Project | MathsLib/Matrix2.cpp | Matrix2::set |
void Matrix2::set(float a_m1, float a_m2, float a_m3, float a_m4)
{
m1 = a_m1;
m2 = a_m2;
m3 = a_m3;
m4 = a_m4;
} |
Matrix2::Matrix2();
Matrix2::Matrix2(float a_m1, float a_m2, float a_m3, float a_m4);
Matrix2::Matrix2(Matrix2 &other);
Matrix2::Matrix2(float * a_array);
Matrix2 Matrix2::operator * (const Matrix2 &a_rhs);
Vector2 Matrix2::operator*(Vector2 & other);
Matrix2& Matrix2::operator*= (const Matrix2 &a_rhs);
Matrix2& Matrix2::operator=(Matrix2 & other);
Vector2& Matrix2::operator[](unsigned int index);
void Matrix2::setRotate(float a_rot);
| 5c7dc0fcc4d622c549a89bbde9453c5e80ab64a5c7e24666176f0c9cf766bb02 | 121 |
|
systembugtj | playasa | src/lib/lyriclib/db_lrcdb.cpp | db_lrcdb::DownloadLyrics |
void db_lrcdb::DownloadLyrics(window_config *wcfg, lyric_data* data)
{
data->Text = _T("");
if (!ReadInternetTextFromUrl(data->Text, _T("FOO_UIE_LYRICS2"), data->Source, wcfg->cfg_timeout, wcfg))
return ;
data->Text = ReplaceString(_T("\r"), _T(""), data->Text);
data->Text = ReplaceString(_T("\n"), _T("\r\n"), data->Text);
data->IsLoaded = true;
if (data->Text.find(_T("[")) != tstring::npos)
data->IsTimestamped = true;
else
data->IsTimestamped = false;
} |
void db_lrcdb::GetResults(window_config *wcfg, std::vector<lyric_data>* results, tstring title, tstring artist, tstring album);
tchar* db_lrcdb::GetName();
LYRICS_DATABASES db_lrcdb::GetID();
| 2b3ce845d2ebf76c4b81ded0ab9bf10229ae5a4cf1bc5116d24704fe925ac5da | 491 |
|
chriseth | solidity | libsolidity/ast/Types.cpp | EnumType::storageBytes |
unsigned EnumType::storageBytes() const
{
size_t elements = m_enum.members().size();
if (elements <= 1)
return 1;
else
return dev::bytesRequired(elements - 1);
} |
void StorageOffsets::computeOffsets(TypePointers const& _types);
pair<u256, unsigned> const* StorageOffsets::offset(size_t _index);
MemberList& MemberList::operator=(MemberList&& _other);
void MemberList::combine(MemberList const & _other);
std::pair<u256, unsigned> const* MemberList::memberStorageOffset(string const& _name);
u256 const& MemberList::storageSize();
TypePointer Type::fromElementaryTypeName(Token::Value _typeToken);
TypePointer Type::fromElementaryTypeName(string const& _name);
TypePointer Type::forLiteral(Literal const& _literal);
TypePointer Type::commonType(TypePointer const& _a, TypePointer const& _b);
MemberList const& Type::members(ContractDefinition const* _currentScope);
MemberList::MemberMap Type::boundFunctions(Type const& _type, ContractDefinition const& _scope);
IntegerType::IntegerType(int _bits, IntegerType::Modifier _modifier);
bool IntegerType::isImplicitlyConvertibleTo(Type const& _convertTo);
bool IntegerType::isExplicitlyConvertibleTo(Type const& _convertTo);
TypePointer IntegerType::unaryOperatorResult(Token::Value _operator);
bool IntegerType::operator==(Type const& _other);
string IntegerType::toString(bool);
TypePointer IntegerType::binaryOperatorResult(Token::Value _operator, TypePointer const& _other);
MemberList::MemberMap IntegerType::nativeMembers(ContractDefinition const*);
bool IntegerConstantType::isValidLiteral(const Literal& _literal);
IntegerConstantType::IntegerConstantType(Literal const& _literal);
bool IntegerConstantType::isImplicitlyConvertibleTo(Type const& _convertTo);
bool IntegerConstantType::isExplicitlyConvertibleTo(Type const& _convertTo);
TypePointer IntegerConstantType::unaryOperatorResult(Token::Value _operator);
TypePointer IntegerConstantType::binaryOperatorResult(Token::Value _operator, TypePointer const& _other);
bool IntegerConstantType::operator==(Type const& _other);
string IntegerConstantType::toString(bool);
u256 IntegerConstantType::literalValue(Literal const*);
TypePointer IntegerConstantType::mobileType();
shared_ptr<IntegerType const> IntegerConstantType::integerType();
StringLiteralType::StringLiteralType(Literal const& _literal);
bool StringLiteralType::isImplicitlyConvertibleTo(Type const& _convertTo);
bool StringLiteralType::operator==(const Type& _other);
TypePointer StringLiteralType::mobileType();
shared_ptr<FixedBytesType> FixedBytesType::smallestTypeForLiteral(string const& _literal);
FixedBytesType::FixedBytesType(int _bytes);
bool FixedBytesType::isImplicitlyConvertibleTo(Type const& _convertTo);
bool FixedBytesType::isExplicitlyConvertibleTo(Type const& _convertTo);
TypePointer FixedBytesType::unaryOperatorResult(Token::Value _operator);
TypePointer FixedBytesType::binaryOperatorResult(Token::Value _operator, TypePointer const& _other);
bool FixedBytesType::operator==(Type const& _other);
bool BoolType::isExplicitlyConvertibleTo(Type const& _convertTo);
u256 BoolType::literalValue(Literal const* _literal);
TypePointer BoolType::unaryOperatorResult(Token::Value _operator);
TypePointer BoolType::binaryOperatorResult(Token::Value _operator, TypePointer const& _other);
bool ContractType::isImplicitlyConvertibleTo(Type const& _convertTo);
bool ContractType::isExplicitlyConvertibleTo(Type const& _convertTo);
TypePointer ContractType::unaryOperatorResult(Token::Value _operator);
TypePointer ReferenceType::unaryOperatorResult(Token::Value _operator);
TypePointer ReferenceType::copyForLocationIfReference(DataLocation _location, TypePointer const& _type);
TypePointer ReferenceType::copyForLocationIfReference(TypePointer const& _type);
string ReferenceType::stringForReferencePart();
bool ArrayType::isImplicitlyConvertibleTo(const Type& _convertTo);
bool ArrayType::isExplicitlyConvertibleTo(const Type& _convertTo);
bool ArrayType::operator==(Type const& _other);
unsigned ArrayType::calldataEncodedSize(bool _padded);
u256 ArrayType::storageSize();
unsigned ArrayType::sizeOnStack();
string ArrayType::toString(bool _short);
string ArrayType::canonicalName(bool _addDataLocation);
MemberList::MemberMap ArrayType::nativeMembers(ContractDefinition const*);
TypePointer ArrayType::encodingType();
TypePointer ArrayType::decodingType();
TypePointer ArrayType::interfaceType(bool _inLibrary);
u256 ArrayType::memorySize();
TypePointer ArrayType::copyForLocation(DataLocation _location, bool _isPointer);
bool ContractType::operator==(Type const& _other);
string ContractType::toString(bool);
string ContractType::canonicalName(bool);
MemberList::MemberMap ContractType::nativeMembers(ContractDefinition const*);
shared_ptr<FunctionType const> const& ContractType::constructorType();
vector<tuple<VariableDeclaration const*, u256, unsigned>> ContractType::stateVariables();
bool StructType::isImplicitlyConvertibleTo(const Type& _convertTo);
bool StructType::operator==(Type const& _other);
unsigned StructType::calldataEncodedSize(bool _padded);
u256 StructType::memorySize();
u256 StructType::storageSize();
string StructType::toString(bool _short);
MemberList::MemberMap StructType::nativeMembers(ContractDefinition const*);
TypePointer StructType::interfaceType(bool _inLibrary);
TypePointer StructType::copyForLocation(DataLocation _location, bool _isPointer);
string StructType::canonicalName(bool _addDataLocation);
FunctionTypePointer StructType::constructorType();
pair<u256, unsigned> const& StructType::storageOffsetsOfMember(string const& _name);
u256 StructType::memoryOffsetOfMember(string const& _name);
set<string> StructType::membersMissingInMemory();
TypePointer EnumType::unaryOperatorResult(Token::Value _operator);
bool EnumType::operator==(Type const& _other);
string EnumType::toString(bool);
string EnumType::canonicalName(bool);
bool EnumType::isExplicitlyConvertibleTo(Type const& _convertTo);
unsigned int EnumType::memberValue(ASTString const& _member);
bool TupleType::isImplicitlyConvertibleTo(Type const& _other);
bool TupleType::operator==(Type const& _other);
string TupleType::toString(bool _short);
u256 TupleType::storageSize();
unsigned TupleType::sizeOnStack();
TypePointer TupleType::mobileType();
TypePointer TupleType::closestTemporaryType(TypePointer const& _targetType);
FunctionType::FunctionType(FunctionDefinition const& _function, bool _isInternal);
FunctionType::FunctionType(VariableDeclaration const& _varDecl);
FunctionType::FunctionType(const EventDefinition& _event);
std::vector<string> FunctionType::parameterNames();
TypePointers FunctionType::parameterTypes();
bool FunctionType::operator==(Type const& _other);
string FunctionType::toString(bool _short);
u256 FunctionType::storageSize();
unsigned FunctionType::sizeOnStack();
FunctionTypePointer FunctionType::interfaceFunctionType();
MemberList::MemberMap FunctionType::nativeMembers(ContractDefinition const*);
bool FunctionType::canTakeArguments(TypePointers const& _argumentTypes, TypePointer const& _selfType);
bool FunctionType::hasEqualArgumentTypes(FunctionType const& _other);
bool FunctionType::isBareCall();
string FunctionType::externalSignature();
u256 FunctionType::externalIdentifier();
TypePointers FunctionType::parseElementaryTypeVector(strings const& _types);
TypePointer FunctionType::copyAndSetGasOrValue(bool _setGas, bool _setValue);
FunctionTypePointer FunctionType::asMemberFunction(bool _inLibrary, bool _bound);
vector<string> const FunctionType::parameterTypeNames(bool _addDataLocation);
vector<string> const FunctionType::returnParameterTypeNames(bool _addDataLocation);
TypePointer FunctionType::selfType();
ASTPointer<ASTString> FunctionType::documentation();
bool MappingType::operator==(Type const& _other);
string MappingType::toString(bool _short);
string MappingType::canonicalName(bool);
bool TypeType::operator==(Type const& _other);
u256 TypeType::storageSize();
unsigned TypeType::sizeOnStack();
MemberList::MemberMap TypeType::nativeMembers(ContractDefinition const* _currentScope);
ModifierType::ModifierType(const ModifierDefinition& _modifier);
u256 ModifierType::storageSize();
bool ModifierType::operator==(Type const& _other);
string ModifierType::toString(bool _short);
MagicType::MagicType(MagicType::Kind _kind);
bool MagicType::operator==(Type const& _other);
MemberList::MemberMap MagicType::nativeMembers(ContractDefinition const*);
string MagicType::toString(bool);
| 032b82b913c0d0efefb008114b36de9e68a0923e22d2c92304e91599b47a8557 | 169 |
|
damiannz | VegaFEM | libraries/sparseSolver/SPOOLESSolver.cpp |
SPOOLESSolver::SPOOLESSolver |
SPOOLESSolver::SPOOLESSolver(const SparseMatrix * A, int verbose)
{
n = A->Getn();
this->verbose = verbose;
msgFile = fopen("SPOOLES.message","w");
if (verbose >= 1)
printf("Converting matrix to SPOOLES format...\n");
InpMtx * mtxA = InpMtx_new();
InpMtx_init(mtxA, INPMTX_BY_ROWS, SPOOLES_REAL, A->GetNumEntries(), n);
for(int row=0; row<n; row++)
{
int rowLength = A->GetRowLength(row);
for(int j=0; j< rowLength; j++)
{
if (A->GetColumnIndex(row,j) >= row)
InpMtx_inputRealEntry(mtxA, row, A->GetColumnIndex(row, j), A->GetEntry(row, j) );
}
}
InpMtx_changeStorageMode(mtxA, INPMTX_BY_VECTORS);
if (verbose >= 1)
printf("Factoring the %d x %d matrix...\n",n,n);
Bridge * bridge = Bridge_new();
Bridge_setMatrixParams(bridge, n, SPOOLES_REAL, SPOOLES_SYMMETRIC);
Bridge_setMessageInfo(bridge, 1, msgFile);
int rc = Bridge_setup(bridge, mtxA);
if (rc != 1)
{
printf("Error: Bridge setup returned exit code %d.\n", rc);
throw 1;
}
int permuteFlag = 1;
int error;
rc = Bridge_factor(bridge, mtxA, permuteFlag, &error);
if (rc != 1)
{
printf("Error: matrix factorization failed. Bridge_factor exit code: %d. Error code: %d\n", rc, error);
throw 1;
}
DenseMtx *mtx_rhs = DenseMtx_new();
DenseMtx_init(mtx_rhs, SPOOLES_REAL, 0, 0, n, 1, 1, n);
mtx_rhsPointer = (void*) mtx_rhs;
DenseMtx *mtx_x = DenseMtx_new();
DenseMtx_init(mtx_x, SPOOLES_REAL, 0, 0, n, 1, 1, n);
mtx_xPointer = (void*) mtx_x;
bridgePointer = (void*) bridge;
APointer = (void*) mtxA;
if (verbose >= 1)
printf("Factorization completed.\n");
} |
SPOOLESSolver::~SPOOLESSolver();
int SPOOLESSolver::SolveLinearSystem(double * x, const double * rhs);
SPOOLESSolver::SPOOLESSolver(const SparseMatrix * A, int verbose);
SPOOLESSolver::~SPOOLESSolver();
void SPOOLESSolver::DisabledSolverError();
int SPOOLESSolver::SolveLinearSystem(double * x, const double * rhs);
| 879960dcab6105ac1f8f8be0c43b74301377fb45d5ef2e63b0d2336c717618fa | 1,661 |
|
OpenInkpot-archive | iplinux-djvulibre | libdjvu/GPixmap.cpp | void
compute_clip |
static void
compute_clip()
{
clipok = true;
for (unsigned int i=0; i<sizeof(clip); i++)
clip[i] = (i<256 ? i : 255);
} |
static GMonitor &pixmap_monitor();
GPixmap::~GPixmap();
GPixmap::GPixmap();
GPixmap::GPixmap(int nrows, int ncolumns, const GPixel *filler);
GPixmap::GPixmap(ByteStream &bs);
GPixmap::GPixmap(const GBitmap &ref);
GPixmap::GPixmap(const GBitmap &ref, const GRect &rect);
GPixmap::GPixmap(const GPixmap &ref);
GPixmap::GPixmap(const GPixmap &ref, const GRect &rect);
GP<GPixmap> GPixmap::rotate(int count);
| 2386c906ded97e56652039ad7002df8ea7e8d2f05d622a9eb53302f92dd08f36 | 127 |
|
unrealcv | unrealcv | Source/UnrealCV/Private/Commands/CameraHandler.cpp | FCameraCommandHandler::GetNpyBinaryUint8Data |
TArray<uint8> FCameraCommandHandler::GetNpyBinaryUint8Data(const TArray<FString>& Args, const FString& ViewMode, int32 Channels)
{
int32 CameraId = FCString::Atoi(*Args[0]);
UGTCaptureComponent* GTCapturer = FCaptureManager::Get().GetCamera(CameraId);
if (GTCapturer == nullptr)
{
UE_LOG(LogUnrealCV, Error, TEXT("Invalid camera id %d"), CameraId);
return TArray<uint8>();
}
TArray<uint8> ImgData = GTCapturer->CaptureNpyUint8(ViewMode, Channels);
return ImgData;
} |
FString GetDiskFilename(FString Filename);
FString GenerateSeqFilename();
void FCameraCommandHandler::RegisterCommands();
FExecStatus FCameraCommandHandler::GetCameraProjMatrix(const TArray<FString>& Args);
FExecStatus FCameraCommandHandler::MoveTo(const TArray<FString>& Args);
FExecStatus FCameraCommandHandler::SetCameraLocation(const TArray<FString>& Args);
FExecStatus FCameraCommandHandler::SetCameraRotation(const TArray<FString>& Args);
FExecStatus FCameraCommandHandler::GetCameraRotation(const TArray<FString>& Args);
FExecStatus FCameraCommandHandler::SetCameraPose(const TArray<FString>& Args);
FExecStatus FCameraCommandHandler::GetCameraPose(const TArray<FString>& Args);
FExecStatus FCameraCommandHandler::SetCameraHorizontalFieldOfView(const TArray<FString>& Args);
FExecStatus FCameraCommandHandler::GetCameraHorizontalFieldOfView(const TArray<FString>& Args);
FExecStatus FCameraCommandHandler::GetCameraLocation(const TArray<FString>& Args);
FExecStatus FCameraCommandHandler::GetObjectInstanceMask(const TArray<FString>& Args);
FExecStatus FCameraCommandHandler::GetLitViewMode(const TArray<FString>& Args);
FExecStatus FCameraCommandHandler::GetCameraViewMode(const TArray<FString>& Args);
FExecStatus FCameraCommandHandler::GetScreenshot(const TArray<FString>& Args);
FExecStatus FCameraCommandHandler::GetActorRotation(const TArray<FString>& Args);
FExecStatus FCameraCommandHandler::GetActorLocation(const TArray<FString>& Args);
FExecStatus FCameraCommandHandler::GetPngBinary(const TArray<FString>& Args, const FString& ViewMode);
FExecStatus FCameraCommandHandler::GetNpyBinaryUint8(const TArray<FString>& Args, const FString& ViewMode, int32 Channels);
TArray<uint8> FCameraCommandHandler::GetNpyBinaryFloat16Data(const TArray<FString>& Args, const FString& ViewMode, int32 Channels);
FExecStatus FCameraCommandHandler::GetNpyBinaryFloat16(const TArray<FString>& Args, const FString& ViewMode, int32 Channels);
| 51191d344c1cc7c89da3b45fd13760b0dbfcebce6972bd38eb296bd714c9e255 | 479 |
|
KnightSwarm | WebKitTi | Source/WebCore/loader/DocumentLoader.cpp | DocumentLoader::handleSubstituteDataLoadNow |
void DocumentLoader::handleSubstituteDataLoadNow(DocumentLoaderTimer*)
{
KURL url = m_substituteData.responseURL();
if (url.isEmpty())
url = m_request.url();
ResourceResponse response(url, m_substituteData.mimeType(), m_substituteData.content()->size(), m_substituteData.textEncoding(), "");
responseReceived(0, response);
} |
static void cancelAll(const ResourceLoaderSet& loaders);
static void setAllDefersLoading(const ResourceLoaderSet& loaders, bool defers);
DocumentLoader::DocumentLoader(const ResourceRequest& req, const SubstituteData& substituteData);
FrameLoader* DocumentLoader::frameLoader();
ResourceLoader* DocumentLoader::mainResourceLoader();
DocumentLoader::~DocumentLoader();
PassRefPtr<ResourceBuffer> DocumentLoader::mainResourceData();
Document* DocumentLoader::document();
const ResourceRequest& DocumentLoader::originalRequest();
const ResourceRequest& DocumentLoader::originalRequestCopy();
const ResourceRequest& DocumentLoader::request();
ResourceRequest& DocumentLoader::request();
const KURL& DocumentLoader::url();
void DocumentLoader::replaceRequestURLForSameDocumentNavigation(const KURL& url);
void DocumentLoader::setRequest(const ResourceRequest& req);
void DocumentLoader::setMainDocumentError(const ResourceError& error);
void DocumentLoader::mainReceivedError(const ResourceError& error);
void DocumentLoader::stopLoading();
void DocumentLoader::commitIfReady();
bool DocumentLoader::isLoading();
void DocumentLoader::notifyFinished(CachedResource* resource);
void DocumentLoader::finishedLoading(double finishTime);
bool DocumentLoader::isPostOrRedirectAfterPost(const ResourceRequest& newRequest, const ResourceResponse& redirectResponse);
void DocumentLoader::startDataLoadTimer();
void DocumentLoader::handleSubstituteDataLoadSoon();
void DocumentLoader::redirectReceived(CachedResource* resource, ResourceRequest& request, const ResourceResponse& redirectResponse);
void DocumentLoader::willSendRequest(ResourceRequest& newRequest, const ResourceResponse& redirectResponse);
void DocumentLoader::callContinueAfterNavigationPolicy(void* argument, const ResourceRequest& request, PassRefPtr<FormState>, bool shouldContinue);
void DocumentLoader::continueAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
void DocumentLoader::responseReceived(CachedResource* resource, const ResourceResponse& response);
void DocumentLoader::callContinueAfterContentPolicy(void* argument, PolicyAction policy);
void DocumentLoader::continueAfterContentPolicy(PolicyAction policy);
void DocumentLoader::commitLoad(const char* data, int length);
ResourceError DocumentLoader::interruptedForPolicyChangeError();
void DocumentLoader::stopLoadingForPolicyChange();
void DocumentLoader::commitData(const char* bytes, size_t length);
void DocumentLoader::dataReceived(CachedResource* resource, const char* data, int length);
void DocumentLoader::setupForReplace();
void DocumentLoader::checkLoadComplete();
void DocumentLoader::setFrame(Frame* frame);
void DocumentLoader::attachToFrame();
void DocumentLoader::detachFromFrame();
void DocumentLoader::clearMainResourceLoader();
bool DocumentLoader::isLoadingInAPISense();
bool DocumentLoader::maybeCreateArchive();
void DocumentLoader::setArchive(PassRefPtr<Archive> archive);
void DocumentLoader::addAllArchiveResources(Archive* archive);
void DocumentLoader::addArchiveResource(PassRefPtr<ArchiveResource> resource);
PassRefPtr<Archive> DocumentLoader::popArchiveForSubframe(const String& frameName, const KURL& url);
void DocumentLoader::clearArchiveResources();
SharedBuffer* DocumentLoader::parsedArchiveData();
ArchiveResource* DocumentLoader::archiveResourceForURL(const KURL& url);
PassRefPtr<ArchiveResource> DocumentLoader::mainResource();
PassRefPtr<ArchiveResource> DocumentLoader::subresource(const KURL& url);
void DocumentLoader::getSubresources(Vector<PassRefPtr<ArchiveResource> >& subresources);
void DocumentLoader::deliverSubstituteResourcesAfterDelay();
void DocumentLoader::substituteResourceDeliveryTimerFired(Timer<DocumentLoader>*);
bool DocumentLoader::isSubstituteLoadPending(ResourceLoader* loader);
void DocumentLoader::cancelPendingSubstituteLoad(ResourceLoader* loader);
bool DocumentLoader::scheduleArchiveLoad(ResourceLoader* loader, const ResourceRequest& request);
void DocumentLoader::addResponse(const ResourceResponse& r);
void DocumentLoader::stopRecordingResponses();
void DocumentLoader::setTitle(const StringWithDirection& title);
KURL DocumentLoader::urlForHistory();
bool DocumentLoader::urlForHistoryReflectsFailure();
const KURL& DocumentLoader::originalURL();
const KURL& DocumentLoader::requestURL();
const KURL& DocumentLoader::responseURL();
KURL DocumentLoader::documentURL();
const String& DocumentLoader::responseMIMEType();
const KURL& DocumentLoader::unreachableURL();
void DocumentLoader::setDefersLoading(bool defers);
void DocumentLoader::setMainResourceDataBufferingPolicy(DataBufferingPolicy dataBufferingPolicy);
void DocumentLoader::stopLoadingPlugIns();
void DocumentLoader::stopLoadingSubresources();
void DocumentLoader::addSubresourceLoader(ResourceLoader* loader);
void DocumentLoader::removeSubresourceLoader(ResourceLoader* loader);
void DocumentLoader::addPlugInStreamLoader(ResourceLoader* loader);
void DocumentLoader::removePlugInStreamLoader(ResourceLoader* loader);
bool DocumentLoader::isMultipartReplacingLoad();
bool DocumentLoader::maybeLoadEmpty();
void DocumentLoader::startLoadingMainResource();
void DocumentLoader::cancelMainResourceLoad(const ResourceError& resourceError);
void DocumentLoader::clearMainResource();
void DocumentLoader::subresourceLoaderFinishedLoadingOnePart(ResourceLoader* loader);
void DocumentLoader::maybeFinishLoadingMultipartContent();
void DocumentLoader::iconLoadDecisionAvailable();
static void iconLoadDecisionCallback(IconLoadDecision decision, void* context);
void DocumentLoader::getIconLoadDecisionForIconURL(const String& urlString);
void DocumentLoader::continueIconLoadWithDecision(IconLoadDecision decision);
static void iconDataCallback(SharedBuffer*, void*);
void DocumentLoader::getIconDataForIconURL(const String& urlString);
void DocumentLoader::handledOnloadEvents();
| c5747835db9ab7c6b5e3b97d9a43eb527cbe9469b78c044c5a8dab18cec35a3e | 349 |
|
Inviuz | rpcs3 | rpcs3/Emu/Cell/Modules/cellDtcpIpUtility.cpp | cellDtcpIpSetEncryptedData |
s32 cellDtcpIpSetEncryptedData()
{
UNIMPLEMENTED_FUNC(cellDtcpIpUtility);
return CELL_OK;
} |
s32 cellDtcpIpRead();
s32 cellDtcpIpFinalize();
s32 cellDtcpIpActivate();
s32 cellDtcpIpOpen();
s32 cellDtcpIpCheckActivation();
s32 cellDtcpIpInitialize();
s32 cellDtcpIpGetDecryptedData();
s32 cellDtcpIpStopSequence();
s32 cellDtcpIpSeek();
s32 cellDtcpIpStartSequence();
s32 cellDtcpIpClose();
s32 cellDtcpIpSuspendActivationForDebug();
| ca22e044be7cda2f6f9a29ba5c049080cd8cbc702d6ce408038de4cf8eae8d32 | 94 |
|
china20 | MPFUI | trunk/Controldemo/ThreadDemon/src/MainWindow.cpp | ctedDateChanged | ctedDateChanged(suic::Element* sender, suic::RoutedEventArg* e)
{
suic::DatePicker* datePick = suic::DynamicCast<suic::DatePicker>(sender);
if (NULL != datePick)
{
suic::DateTime dt = datePick->GetDate();
}
}
void MainWindow::OnThr |
MainWindow::MainWindow();
MainWindow::~MainWindow();
bool MainWindow::OnBuild(suic::IXamlNode* pNode, suic::ObjectPtr& obj);
void MainWindow::OnConnect(suic::IXamlNode* pNode, suic::Object* target);
void MainWindow::OnInitialized(suic::EventArg* e);
void MainWindow::OnLoaded(suic::LoadedEventArg* e);
adButtonClick(suic::Element* sender, suic::RoutedEventArg* e);
tButtonClick(suic::Element* sender, suic::RoutedEventArg* e);
erButtonEvent();
| 80b77e345a51cc48a5b5ceea43bf43a449f967489dcb22e983beb225f769a802 | 256 |
|
Ramagonibharath | Coffee | iProlog/IP/src/Engine.cpp | Engine::ppSpines | void Engine::ppSpines()
{
} | Engine::Engine(const string &fname);
int Engine::tag(int const t, int const w);
int Engine::detag(int const w);
int Engine::tagOf(int const w);
int Engine::addSym(const string &sym);
string Engine::getSym(int const w);
void Engine::makeHeap();
void Engine::makeHeap(int const size);
int Engine::getTop();
int Engine::setTop(int const top);
void Engine::clear();
void Engine::push(int const i);
int Engine::size();
void Engine::expand();
void Engine::ensureSize(int const more);
vector<vector<string> > Engine::maybeExpand(const vector<string> &Ws);
vector<vector<string> > Engine::mapExpand(const vector<vector<string> > &Wss);
vector<Clause*> Engine::dload(const string &s);
vector<int> Engine::toNums(vector<Clause*> &clauses);
int Engine::encode(int const t, const string &s);
bool Engine::isVAR(int const x);
int Engine::getRef(int const x);
void Engine::setRef(int const w, int const r);
void Engine::unwindTrail(int const savedTop);
int Engine::deref(int x);
string Engine::showTerm(int const x);
string Engine::showTerm(TermObject const &O);
void Engine::ppTrail();
TermObject Engine::exportTerm(int x);
vector<int> Engine::getSpine(vector<int> &cs);
string Engine::showCell(int const w);
string Engine::showCells(int const base, int const len);
string Engine::showCells(vector<int> &cs);
void Engine::ppc(Spine *const C);
void Engine::ppGoals(IntList *const gs);
bool Engine::unify(int const base);
bool Engine::unify_args(int const w1, int const w2);
Clause *Engine::putClause(vector<int> cs, vector<int> &gs, int const neck);
int Engine::relocate(int const b, int const cell);
void Engine::pushCells(int const b, int const from, int const to, int const base);
void Engine::pushCells(int const b, int const from, int const to, vector<int> &cs);
int Engine::pushHead(int const b, Clause *const C);
vector<int> Engine::pushBody(int const b, int const head, Clause *const C);
void Engine::makeIndexArgs(Spine *const G, int const goal);
vector<int> Engine::getIndexables(int const ref);
int Engine::cell2index(int const cell);
bool Engine::match(vector<int> &xs, Clause *const C0);
Spine *Engine::unfold(Spine *const G);
Clause *Engine::getQuery();
Spine *Engine::init();
Spine *Engine::answer(int const ttop);
bool Engine::hasClauses(Spine *const S);
bool Engine::hasGoals(Spine *const S);
void Engine::popSpine();
Spine *Engine::yield();
TermObject Engine::ask();
void Engine::run();
vector<IntMap*> Engine::vcreate(int const l);
void Engine::put(vector<IMap<int>*> &imaps, vector<IntMap*> &vss, vector<int> const &keys, int const val);
vector<IMap<int>*> Engine::index(vector<Clause*> &clauses, vector<IntMap*> &vmaps);
void Engine::InitializeInstanceFields();
| 51b6f97137b03b263c41df1e08381f6ca463fea48ab46b6c03fb7b3457107967 | 46 |
|
endlessm | chromium-browser | third_party/angle/third_party/VK-GL-CTS/src/external/openglcts/modules/common/glcSingleConfigTestPackage.cpp | TestCaseWrapper::init |
void TestCaseWrapper::init(tcu::TestCase* testCase, const std::string& path)
{
if (m_waiverMechanism->isOnWaiverList(path))
throw tcu::TestException("Waived test", QP_TEST_RESULT_WAIVER);
testCase->init();
} |
TestCaseWrapper::TestCaseWrapper(SingleConfigTestPackage& package, de::SharedPtr<tcu::WaiverUtil> waiverMechanism);
TestCaseWrapper::~TestCaseWrapper(void);
void TestCaseWrapper::deinit(tcu::TestCase* testCase);
tcu::TestNode::IterateResult TestCaseWrapper::iterate(tcu::TestCase* testCase);
SingleConfigTestPackage::~SingleConfigTestPackage(void);
void SingleConfigTestPackage::init(void);
tcu::TestCaseExecutor* SingleConfigTestPackage::createExecutor(void);
| 49598bfb629ca828ec2ac72bc6a3030502c1efaa878172d55c34b018823f8a80 | 213 |
|
rbtying | Balance-Bot | src/imu/IMU.cpp | IMU::acquire_accel_compass_angle |
Vector IMU::acquire_accel_compass_angle() {
Vector a, m, angles;
Vector p = { 0, -1, 0 };
float heading;
m_mag.read();
a = m_mag.a;
m = m_mag.m;
heading = m_mag.heading(p);
convert_accel_to_g(&a);
angles = calculate_accel_angle(a);
angles.z = heading;
return angles;
} |
IMU::IMU();
Vector IMU::getAngles();
Vector IMU::getAccel();
Vector IMU::getGyro();
void IMU::update(double dt);
void IMU::initializeSensors();
IMU::~IMU();
void IMU::kalman_filter();
Vector IMU::acquire_accel_angle();
Vector IMU::acquire_gyro_angle(double dt);
Vector IMU::calculate_gyro_variance();
Vector IMU::calculate_accel_variance();
Vector IMU::calculate_accel_angle(Vector a);
Vector IMU::calculate_gyro_angle(Vector g, double dt);
void IMU::convert_accel_to_g(Vector * a);
void IMU::convert_gyro_to_dps(Vector * g);
| 11febe366d7c277b0379d0623dc5316ccedc09452ef5b655595d8bd7342b85c7 | 289 |
|
rfarley3 | CodeXt-ugly | EditedS2ESrcFiles/klee-Executor.cpp | Executor::getAddressInfo |
std::string Executor::getAddressInfo(ExecutionState &state,
ref<Expr> address) const{
std::ostringstream info;
uint64_t example;
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(address)) {
example = CE->getZExtValue();
info << "\taddress: 0x" << std::hex << example << std::dec << "\n";
} else {
info << "\taddress: " << address << "\n";
ref<ConstantExpr> value;
bool success = solver->getValue(state, address, value);
assert(success && "FIXME: Unhandled solver failure");
(void) success;
example = value->getZExtValue();
info << "\texample: 0x" << std::hex << example << std::dec << "\n";
std::pair< ref<Expr>, ref<Expr> > res = solver->getRange(state, address);
info << "\trange: [0x" << std::hex << res.first << ", 0x"
<< res.second << std::dec << "]\n";
}
MemoryObject hack((unsigned) example);
MemoryMap::iterator lower = state.addressSpace.objects.upper_bound(&hack);
info << "\tnext: ";
if (lower==state.addressSpace.objects.end()) {
info << "none\n";
} else {
const MemoryObject *mo = lower->first;
std::string alloc_info;
mo->getAllocInfo(alloc_info);
info << "object at 0x" << std::hex << mo->address
<< " of size 0x" << mo->size << std::dec << "\n"
<< "\t\t" << alloc_info << std::dec << "\n";
}
if (lower!=state.addressSpace.objects.begin()) {
--lower;
info << "\tprev: ";
if (lower==state.addressSpace.objects.end()) {
info << "none\n";
} else {
const MemoryObject *mo = lower->first;
std::string alloc_info;
mo->getAllocInfo(alloc_info);
info << "object at 0x" << std::hex << mo->address
<< " of size 0x" << mo->size << std::dec << "\n"
<< "\t\t" << alloc_info << std::dec << "\n";
}
}
return info.str();
} |
void Executor::initializeSolver();
Executor::~Executor();
ref<Expr> Executor::simplifyExpr(const ExecutionState &s, ref<Expr> e);
void Executor::initializeGlobals(ExecutionState &state);
void Executor::notifyFork(ExecutionState &originalState, ref<Expr> &condition, Executor::StatePair &targets);
bool Executor::merge(ExecutionState &base, ExecutionState &other);
void Executor::addConstraint(ExecutionState &state, ref<Expr> condition);
ref<klee::ConstantExpr> Executor::evalConstant(Constant *c);
void Executor::stepInstruction(ExecutionState &state);
void Executor::printFileLine(ExecutionState &state, KInstruction *ki);
Function* Executor::getCalledFunction(CallSite &cs, ExecutionState &state);
static bool isDebugIntrinsic(const Function *f, KModule *KM);
void Executor::executeInstruction(ExecutionState &state, KInstruction *ki);
void Executor::updateStates(ExecutionState *current);
void Executor::bindInstructionConstants(KInstruction *KI);
void Executor::bindModuleConstants();
void Executor::run(ExecutionState &initialState);
void Executor::deleteState(ExecutionState *state);
void Executor::terminateState(ExecutionState &state);
void Executor::terminateStateOnExit(ExecutionState &state);
unsigned Executor::getPathStreamID(const ExecutionState &state);
unsigned Executor::getSymbolicPathStreamID(const ExecutionState &state);
void Executor::copyOutConcretes(ExecutionState &state);
bool Executor::copyInConcretes(ExecutionState &state);
Solver *Executor::getSolver();
| 6d4e0ecda34911e3d7a42b651cef980323bc58a41618529d6c5497aa3c24f625 | 1,856 |
|
hoxton22 | CriseHearth | src/server/game/Entities/Player/Player.cpp | Player::SendInitialPacketsAfterAddToMap |
void Player::SendInitialPacketsAfterAddToMap()
{
UpdateVisibilityForPlayer();
uint32 newzone, newarea;
GetZoneAndAreaId(newzone, newarea);
UpdateZone(newzone, newarea);
ResetTimeSync();
SendTimeSync();
GetSession()->SendLoadCUFProfiles();
CastSpell(this, 836, true);
static const AuraType auratypes[] =
{
SPELL_AURA_MOD_FEAR, SPELL_AURA_TRANSFORM, SPELL_AURA_WATER_WALK,
SPELL_AURA_FEATHER_FALL, SPELL_AURA_HOVER, SPELL_AURA_SAFE_FALL,
SPELL_AURA_FLY, SPELL_AURA_MOD_INCREASE_MOUNTED_FLIGHT_SPEED, SPELL_AURA_NONE
};
for (AuraType const* itr = &auratypes[0]; itr && itr[0] != SPELL_AURA_NONE; ++itr)
{
Unit::AuraEffectList const& auraList = GetAuraEffectsByType(*itr);
if (!auraList.empty())
auraList.front()->HandleEffect(this, AURA_EFFECT_HANDLE_SEND_FOR_CLIENT, true);
}
if (HasAuraType(SPELL_AURA_MOD_STUN))
SetRooted(true);
if (HasAuraType(SPELL_AURA_MOD_ROOT))
SetRooted(true, true);
SendAurasForTarget(this);
SendEnchantmentDurations();
SendItemDurations();
if (GetMap()->IsRaid())
{
m_prevMapDifficulty = GetMap()->GetDifficultyID();
DifficultyEntry const* difficulty = sDifficultyStore.AssertEntry(m_prevMapDifficulty);
SendRaidDifficulty((difficulty->Flags & DIFFICULTY_FLAG_LEGACY) != 0, m_prevMapDifficulty);
}
else if (GetMap()->IsNonRaidDungeon())
{
m_prevMapDifficulty = GetMap()->GetDifficultyID();
SendDungeonDifficulty(m_prevMapDifficulty);
}
else if (!GetMap()->Instanceable())
{
DifficultyEntry const* difficulty = sDifficultyStore.AssertEntry(m_prevMapDifficulty);
SendRaidDifficulty((difficulty->Flags & DIFFICULTY_FLAG_LEGACY) != 0);
}
if (_garrison)
_garrison->SendRemoteInfo();
} |
Player::Player(WorldSession* session);
Player::~Player();
void Player::CleanupsBeforeDelete(bool finalCleanup);
bool Player::Create(ObjectGuid::LowType guidlow, WorldPackets::Character::CharacterCreateInfo const* createInfo);
bool Player::StoreNewItemInBestSlots(uint32 titem_id, uint32 titem_amount);
void Player::SendMirrorTimer(MirrorTimerType Type, uint32 MaxValue, uint32 CurrentValue, int32 Regen);
void Player::StopMirrorTimer(MirrorTimerType Type);
bool Player::IsImmuneToEnvironmentalDamage();
uint32 Player::EnvironmentalDamage(EnviromentalDamage type, uint32 damage);
int32 Player::getMaxTimer(MirrorTimerType timer);
void Player::UpdateMirrorTimers();
void Player::StopMirrorTimers();
bool Player::IsMirrorTimerActive(MirrorTimerType type);
void Player::HandleDrowning(uint32 time_diff);
void Player::HandleSobering();
DrunkenState Player::GetDrunkenstateByValue(uint8 value);
void Player::SetDrunkValue(uint8 newDrunkValue, uint32 itemId /*= 0*/);
void Player::Update(uint32 p_time);
void Player::setDeathState(DeathState s);
void Player::ToggleAFK();
void Player::ToggleDND();
uint8 Player::GetChatFlags();
bool Player::TeleportTo(uint32 mapid, float x, float y, float z, float orientation, uint32 options);
bool Player::TeleportTo(WorldLocation const &loc, uint32 options /*= 0*/);
bool Player::TeleportToBGEntryPoint();
void Player::ProcessDelayedOperations();
void Player::AddToWorld();
void Player::RemoveFromWorld();
bool Player::IsImmunedToSpellEffect(SpellInfo const* spellInfo, uint32 index);
void Player::RegenerateAll();
void Player::Regenerate(Powers power);
void Player::RegenerateHealth();
void Player::ResetAllPowers();
bool Player::CanInteractWithQuestGiver(Object* questGiver);
Creature* Player::GetNPCIfCanInteractWith(ObjectGuid const& guid, uint64 npcflagmask);
GameObject* Player::GetGameObjectIfCanInteractWith(ObjectGuid const& guid);
GameObject* Player::GetGameObjectIfCanInteractWith(ObjectGuid const& guid, GameobjectTypes type);
bool Player::IsUnderWater();
void Player::SetInWater(bool apply);
bool Player::IsInAreaTriggerRadius(const AreaTriggerEntry* trigger);
void Player::SetGameMaster(bool on);
bool Player::CanBeGameMaster();
void Player::SetGMVisible(bool on);
bool Player::IsGroupVisibleFor(Player const* p);
bool Player::IsInSameGroupWith(Player const* p);
bool Player::IsInSameRaidWith(Player const* p);
void Player::UninviteFromGroup();
void Player::RemoveFromGroup(Group* group, ObjectGuid guid, RemoveMethod method /* = GROUP_REMOVEMETHOD_DEFAULT*/, ObjectGuid kicker /* = ObjectGuid::Empty */, const char* reason /* = NULL */);
void Player::GiveXP(uint32 xp, Unit* victim, float group_rate);
void Player::GiveLevel(uint8 level);
void Player::InitTalentForLevel();
void Player::InitStatsForLevel(bool reapplyMods);
void Player::SendKnownSpells();
void Player::RemoveMail(uint32 id);
void Player::SendMailResult(uint32 mailId, MailResponseType mailAction, MailResponseResult mailError, uint32 equipError, ObjectGuid::LowType item_guid, uint32 item_count);
void Player::SendNewMail();
void Player::UpdateNextMailTimeAndUnreads();
void Player::AddNewMailDeliverTime(time_t deliver_time);
void DeleteSpellFromAllPlayers(uint32 spellId);
bool Player::AddTalent(TalentEntry const* talent, uint8 spec, bool learning);
void Player::RemoveTalent(TalentEntry const* talent);
bool Player::AddSpell(uint32 spellId, bool active, bool learning, bool dependent, bool disabled, bool loading /*= false*/, uint32 fromSkill /*= 0*/);
void Player::AddTemporarySpell(uint32 spellId);
void Player::RemoveTemporarySpell(uint32 spellId);
bool Player::IsNeedCastPassiveSpellAtLearn(SpellInfo const* spellInfo);
bool Player::IsCurrentSpecMasterySpell(SpellInfo const* spellInfo);
void Player::LearnSpell(uint32 spell_id, bool dependent, uint32 fromSkill /*= 0*/);
void Player::RemoveSpell(uint32 spell_id, bool disabled, bool learn_low_rank);
void Player::RemoveArenaSpellCooldowns(bool removeActivePetCooldowns);
uint32 Player::GetNextResetTalentsCost();
bool Player::ResetTalents(bool noCost);
Mail* Player::GetMail(uint32 id);
void Player::BuildCreateUpdateBlockForPlayer(UpdateData* data, Player* target);
void Player::DestroyForPlayer(Player* target);
bool Player::HasSpell(uint32 spell);
bool Player::HasTalent(uint32 talentId, uint8 group);
bool Player::HasActiveSpell(uint32 spell);
TrainerSpellState Player::GetTrainerSpellState(TrainerSpell const* trainer_spell);
void Player::DeleteFromDB(ObjectGuid playerguid, uint32 accountId, bool updateRealmChars, bool deleteFinally);
void Player::DeleteOldCharacters();
void Player::DeleteOldCharacters(uint32 keepDays);
void Player::BuildPlayerRepop();
void Player::ResurrectPlayer(float restore_percent, bool applySickness);
void Player::KillPlayer();
void Player::OfflineResurrect(ObjectGuid const& guid, SQLTransaction& trans);
Corpse* Player::CreateCorpse();
void Player::SpawnCorpseBones(bool triggerSave /*= true*/);
Corpse* Player::GetCorpse();
void Player::DurabilityLossAll(double percent, bool inventory);
void Player::DurabilityLoss(Item* item, double percent);
void Player::DurabilityPointsLossAll(int32 points, bool inventory);
void Player::DurabilityPointsLoss(Item* item, int32 points);
void Player::DurabilityPointLossForEquipSlot(EquipmentSlots slot);
uint32 Player::DurabilityRepairAll(bool cost, float discountMod, bool guildBank);
uint32 Player::DurabilityRepair(uint16 pos, bool cost, float discountMod, bool guildBank);
void Player::RepopAtGraveyard();
bool Player::CanJoinConstantChannelInZone(ChatChannelsEntry const* channel, AreaTableEntry const* zone);
void Player::JoinedChannel(Channel* c);
void Player::LeftChannel(Channel* c);
void Player::CleanupChannels();
void Player::UpdateLocalChannels(uint32 newZone);
void Player::LeaveLFGChannel();
void Player::HandleBaseModValue(BaseModGroup modGroup, BaseModType modType, float amount, bool apply);
float Player::GetBaseModValue(BaseModGroup modGroup, BaseModType modType);
float Player::GetTotalBaseModValue(BaseModGroup modGroup);
float Player::GetMeleeCritFromAgility();
void Player::GetDodgeFromAgility(float &diminishing, float &nondiminishing);
float Player::GetSpellCritFromIntellect();
float Player::GetRatingMultiplier(CombatRating cr);
float Player::GetRatingBonusValue(CombatRating cr);
float Player::GetExpertiseDodgeOrParryReduction(WeaponAttackType attType);
float Player::OCTRegenMPPerSpirit();
void Player::ApplyRatingMod(CombatRating combatRating, int32 value, bool apply);
void Player::UpdateRating(CombatRating cr);
void Player::UpdateAllRatings();
void Player::SetRegularAttackTime();
bool Player::UpdateSkill(uint32 skill_id, uint32 step);
inline int SkillGainChance(uint32 SkillValue, uint32 GrayLevel, uint32 GreenLevel, uint32 YellowLevel);
bool Player::UpdateCraftSkill(uint32 spellid);
bool Player::UpdateGatherSkill(uint32 SkillId, uint32 SkillValue, uint32 RedLevel, uint32 Multiplicator);
bool Player::UpdateFishingSkill();
bool Player::UpdateSkillPro(uint16 skillId, int32 chance, uint32 step);
void Player::ModifySkillBonus(uint32 skillid, int32 val, bool talent);
void Player::UpdateSkillsForLevel();
void Player::UpdateSkillsToMaxSkillsForLevel();
void Player::SetSkill(uint16 id, uint16 step, uint16 newVal, uint16 maxVal);
bool Player::HasSkill(uint32 skill);
uint16 Player::GetSkillStep(uint16 skill);
uint16 Player::GetSkillValue(uint32 skill);
uint16 Player::GetMaxSkillValue(uint32 skill);
uint16 Player::GetPureMaxSkillValue(uint32 skill);
uint16 Player::GetBaseSkillValue(uint32 skill);
uint16 Player::GetPureSkillValue(uint32 skill);
int16 Player::GetSkillPermBonusValue(uint32 skill);
int16 Player::GetSkillTempBonusValue(uint32 skill);
void Player::SendActionButtons(uint32 state);
bool Player::IsActionButtonDataValid(uint8 button, uint32 action, uint8 type);
ActionButton* Player::AddActionButton(uint8 button, uint32 action, uint8 type);
void Player::RemoveActionButton(uint8 button);
ActionButton const* Player::GetActionButton(uint8 button);
bool Player::UpdatePosition(float x, float y, float z, float orientation, bool teleport);
void Player::SaveRecallPosition();
void Player::SendMessageToSetInRange(WorldPacket const* data, float dist, bool self);
void Player::SendMessageToSetInRange(WorldPacket const* data, float dist, bool self, bool own_team_only);
void Player::SendMessageToSet(WorldPacket const* data, Player const* skipped_rcvr);
void Player::SendDirectMessage(WorldPacket const* data);
void Player::SendCinematicStart(uint32 CinematicSequenceId);
void Player::SendMovieStart(uint32 MovieId);
void Player::CheckAreaExploreAndOutdoor();
uint32 Player::TeamForRace(uint8 race);
TeamId Player::TeamIdForRace(uint8 race);
void Player::setFactionForRace(uint8 race);
ReputationRank Player::GetReputationRank(uint32 faction);
int32 Player::CalculateReputationGain(ReputationSource source, uint32 creatureOrQuestLevel, int32 rep, int32 faction, bool noQuestBonus);
void Player::RewardReputation(Unit* victim, float rate);
void Player::RewardReputation(Quest const* quest);
void Player::UpdateHonorFields();
bool Player::RewardHonor(Unit* victim, uint32 groupsize, int32 honor, bool pvptoken);
void Player::_LoadCurrency(PreparedQueryResult result);
void Player::_SaveCurrency(SQLTransaction& trans);
void Player::SendNewCurrency(uint32 id);
void Player::SendCurrencies();
void Player::SendPvpRewards();
uint32 Player::GetCurrency(uint32 id);
uint32 Player::GetCurrencyOnWeek(uint32 id);
bool Player::HasCurrency(uint32 id, uint32 count);
void Player::ModifyCurrency(uint32 id, int32 count, bool printLog/* = true*/, bool ignoreMultipliers/* = false*/);
void Player::SetCurrency(uint32 id, uint32 count, bool /*printLog*/ /*= true*/);
uint32 Player::GetCurrencyWeekCap(uint32 id);
void Player::ResetCurrencyWeekCap();
uint32 Player::GetCurrencyWeekCap(CurrencyTypesEntry const* currency);
uint32 Player::GetCurrencyTotalCap(CurrencyTypesEntry const* currency);
void Player::UpdateConquestCurrencyCap(uint32 currency);
void Player::SetInGuild(ObjectGuid::LowType guildId);
ObjectGuid::LowType Player::GetGuildIdFromDB(ObjectGuid guid);
uint8 Player::GetRankFromDB(ObjectGuid guid);
void Player::SetArenaTeamInfoField(uint8 slot, ArenaTeamInfoType type, uint32 value);
void Player::SetInArenaTeam(uint32 ArenaTeamId, uint8 slot, uint8 type);
uint32 Player::GetArenaTeamIdFromDB(ObjectGuid guid, uint8 type);
uint32 Player::GetZoneIdFromDB(ObjectGuid guid);
uint32 Player::GetLevelFromDB(ObjectGuid guid);
void Player::UpdateArea(uint32 newArea);
void Player::UpdateZone(uint32 newZone, uint32 newArea);
void Player::CheckDuelDistance(time_t currTime);
bool Player::IsOutdoorPvPActive();
void Player::DuelComplete(DuelCompleteType type);
void Player::_ApplyItemMods(Item* item, uint8 slot, bool apply);
void Player::_ApplyItemBonuses(Item* item, uint8 slot, bool apply);
void Player::_ApplyWeaponDamage(uint8 slot, Item* item, bool apply);
void Player::_ApplyWeaponDependentAuraMods(Item* item, WeaponAttackType attackType, bool apply);
void Player::_ApplyWeaponDependentAuraCritMod(Item* item, WeaponAttackType attackType, AuraEffect const* aura, bool apply);
void Player::_ApplyWeaponDependentAuraDamageMod(Item* item, WeaponAttackType attackType, AuraEffect const* aura, bool apply);
void Player::ApplyItemEquipSpell(Item* item, bool apply, bool formChange /*= false*/);
void Player::ApplyEquipSpell(SpellInfo const* spellInfo, Item* item, bool apply, bool formChange /*= false*/);
void Player::UpdateEquipSpellsAtFormChange();
void Player::UpdateItemSetAuras(bool formChange /*= false*/);
void Player::CastItemCombatSpell(Unit* target, WeaponAttackType attType, uint32 procVictim, uint32 procEx);
void Player::CastItemCombatSpell(Unit* target, WeaponAttackType attType, uint32 procVictim, uint32 procEx, Item* item, ItemTemplate const* proto);
void Player::CastItemUseSpell(Item* item, SpellCastTargets const& targets, uint8 castCount, int32* misc);
void Player::_RemoveAllItemMods();
void Player::_ApplyAllItemMods();
void Player::_ApplyAllLevelScaleItemMods(bool apply);
void Player::RemovedInsignia(Player* looterPlr);
void Player::SendLootRelease(ObjectGuid guid);
void Player::SendLoot(ObjectGuid guid, LootType loot_type);
void Player::SendLootError(ObjectGuid guid, LootError error);
void Player::SendNotifyLootMoneyRemoved(ObjectGuid lootObj);
void Player::SendNotifyLootItemRemoved(ObjectGuid owner, ObjectGuid lootObj, uint8 lootSlot);
void Player::SendUpdateWorldState(uint32 variable, uint32 value, bool hidden /*= false*/);
void Player::SendInitWorldStates(uint32 zoneid, uint32 areaid);
void Player::SendBGWeekendWorldStates();
void Player::SendBattlefieldWorldStates();
uint32 Player::GetXPRestBonus(uint32 xp);
void Player::SetBindPoint(ObjectGuid guid);
void Player::SendRespecWipeConfirm(ObjectGuid const& guid, uint32 cost);
void Player::ResetPetTalents();
void Player::SetVirtualItemSlot(uint8 i, Item* item);
void Player::SetSheath(SheathState sheathed);
uint8 Player::FindEquipSlot(ItemTemplate const* proto, uint32 slot, bool swap);
InventoryResult Player::CanUnequipItems(uint32 item, uint32 count);
uint32 Player::GetItemCount(uint32 item, bool inBankAlso, Item* skipItem);
uint32 Player::GetItemCountWithLimitCategory(uint32 limitCategory, Item* skipItem);
Item* Player::GetItemByGuid(ObjectGuid guid);
Item* Player::GetItemByPos(uint16 pos);
Item* Player::GetItemByPos(uint8 bag, uint8 slot);
Item* Player::GetUseableItemByPos(uint8 bag, uint8 slot);
Bag* Player::GetBagByPos(uint8 bag);
Item* Player::GetWeaponForAttack(WeaponAttackType attackType, bool useable /*= false*/);
Item* Player::GetShield(bool useable);
uint8 Player::GetAttackBySlot(uint8 slot, InventoryType inventoryType);
bool Player::IsInventoryPos(uint8 bag, uint8 slot);
bool Player::IsEquipmentPos(uint8 bag, uint8 slot);
bool Player::IsBankPos(uint8 bag, uint8 slot);
bool Player::IsBagPos(uint16 pos);
bool Player::IsValidPos(uint8 bag, uint8 slot, bool explicit_pos);
bool Player::HasItemCount(uint32 item, uint32 count, bool inBankAlso);
bool Player::HasItemOrGemWithIdEquipped(uint32 item, uint32 count, uint8 except_slot);
bool Player::HasItemOrGemWithLimitCategoryEquipped(uint32 limitCategory, uint32 count, uint8 except_slot);
InventoryResult Player::CanTakeMoreSimilarItems(uint32 entry, uint32 count, Item* pItem, uint32* no_space_count /*= nullptr*/, uint32* offendingItemId /*= nullptr*/);
InventoryResult Player::CanStoreNewItem(uint8 bag, uint8 slot, ItemPosCountVec& dest, uint32 item, uint32 count, uint32* no_space_count /*= NULL*/);
InventoryResult Player::CanStoreItem(uint8 bag, uint8 slot, ItemPosCountVec& dest, Item* pItem, bool swap /*= false*/);
bool Player::HasItemTotemCategory(uint32 TotemCategory);
InventoryResult Player::CanStoreItem_InSpecificSlot(uint8 bag, uint8 slot, ItemPosCountVec &dest, ItemTemplate const* pProto, uint32& count, bool swap, Item* pSrcItem);
InventoryResult Player::CanStoreItem_InBag(uint8 bag, ItemPosCountVec &dest, ItemTemplate const* pProto, uint32& count, bool merge, bool non_specialized, Item* pSrcItem, uint8 skip_bag, uint8 skip_slot);
InventoryResult Player::CanStoreItem_InInventorySlots(uint8 slot_begin, uint8 slot_end, ItemPosCountVec &dest, ItemTemplate const* pProto, uint32& count, bool merge, Item* pSrcItem, uint8 skip_bag, uint8 skip_slot);
InventoryResult Player::CanStoreItem(uint8 bag, uint8 slot, ItemPosCountVec &dest, uint32 entry, uint32 count, Item* pItem, bool swap, uint32* no_space_count);
InventoryResult Player::CanStoreItems(Item** items, int count, uint32* offendingItemId);
InventoryResult Player::CanEquipNewItem(uint8 slot, uint16 &dest, uint32 item, bool swap);
InventoryResult Player::CanEquipItem(uint8 slot, uint16 &dest, Item* pItem, bool swap, bool not_loading);
InventoryResult Player::CanUnequipItem(uint16 pos, bool swap);
InventoryResult Player::CanBankItem(uint8 bag, uint8 slot, ItemPosCountVec &dest, Item* pItem, bool swap, bool not_loading);
InventoryResult Player::CanUseItem(Item* pItem, bool not_loading);
InventoryResult Player::CanUseItem(ItemTemplate const* proto);
InventoryResult Player::CanRollForItemInLFG(ItemTemplate const* proto, WorldObject const* lootedObject);
Item* Player::StoreNewItem(ItemPosCountVec const& pos, uint32 itemId, bool update, int32 randomPropertyId /*= 0*/, GuidSet const& allowedLooters /*= GuidSet();
Item* Player::StoreItem(ItemPosCountVec const& dest, Item* pItem, bool update);
Item* Player::_StoreItem(uint16 pos, Item* pItem, uint32 count, bool clone, bool update);
Item* Player::EquipNewItem(uint16 pos, uint32 item, bool update);
Item* Player::EquipItem(uint16 pos, Item* pItem, bool update);
void Player::QuickEquipItem(uint16 pos, Item* pItem);
void Player::SetVisibleItemSlot(uint8 slot, Item* pItem);
void Player::VisualizeItem(uint8 slot, Item* pItem);
Item* Player::BankItem(ItemPosCountVec const& dest, Item* pItem, bool update);
void Player::RemoveItem(uint8 bag, uint8 slot, bool update);
void Player::MoveItemFromInventory(uint8 bag, uint8 slot, bool update);
void Player::MoveItemToInventory(ItemPosCountVec const& dest, Item* pItem, bool update, bool in_characterInventoryDB);
void Player::DestroyItem(uint8 bag, uint8 slot, bool update);
void Player::DestroyItemCount(uint32 itemEntry, uint32 count, bool update, bool unequip_check);
void Player::DestroyZoneLimitedItem(bool update, uint32 new_zone);
void Player::DestroyConjuredItems(bool update);
Item* Player::GetItemByEntry(uint32 entry);
std::vector<Item*> Player::GetItemListByEntry(uint32 entry, bool inBankAlso);
void Player::DestroyItemCount(Item* pItem, uint32 &count, bool update);
void Player::SplitItem(uint16 src, uint16 dst, uint32 count);
void Player::SwapItem(uint16 src, uint16 dst);
void Player::AddItemToBuyBackSlot(Item* pItem);
Item* Player::GetItemFromBuyBackSlot(uint32 slot);
void Player::RemoveItemFromBuyBackSlot(uint32 slot, bool del);
void Player::SendEquipError(InventoryResult msg, Item* item1 /*= nullptr*/, Item* item2 /*= nullptr*/, uint32 itemId /*= 0*/);
void Player::SendBuyError(BuyResult msg, Creature* creature, uint32 item, uint32 /*param*/);
void Player::SendSellError(SellResult msg, Creature* creature, ObjectGuid guid);
bool Player::IsUseEquipedWeapon(bool mainhand);
bool Player::IsTwoHandUsed();
void Player::TradeCancel(bool sendback);
void Player::UpdateSoulboundTradeItems();
void Player::AddTradeableItem(Item* item);
void Player::RemoveTradeableItem(Item* item);
void Player::UpdateItemDuration(uint32 time, bool realtimeonly);
void Player::UpdateEnchantTime(uint32 time);
void Player::AddEnchantmentDurations(Item* item);
void Player::RemoveEnchantmentDurations(Item* item);
void Player::RemoveArenaEnchantments(EnchantmentSlot slot);
void Player::AddEnchantmentDuration(Item* item, EnchantmentSlot slot, uint32 duration);
void Player::ApplyEnchantment(Item* item, bool apply);
void Player::ApplyEnchantment(Item* item, EnchantmentSlot slot, bool apply, bool apply_dur, bool ignore_condition);
void Player::UpdateSkillEnchantments(uint16 skill_id, uint16 curr_value, uint16 new_value);
void Player::SendEnchantmentDurations();
void Player::SendItemDurations();
void Player::SendNewItem(Item* item, uint32 quantity, bool pushed, bool created, bool broadcast);
void Player::PrepareGossipMenu(WorldObject* source, uint32 menuId /*= 0*/, bool showQuests /*= false*/);
void Player::SendPreparedGossip(WorldObject* source);
void Player::OnGossipSelect(WorldObject* source, uint32 gossipListId, uint32 menuId);
uint32 Player::GetGossipTextId(WorldObject* source);
uint32 Player::GetGossipTextId(uint32 menuId, WorldObject* source);
uint32 Player::GetDefaultGossipMenuForSource(WorldObject* source);
void Player::PrepareQuestMenu(ObjectGuid guid);
void Player::SendPreparedQuest(ObjectGuid guid);
bool Player::IsActiveQuest(uint32 quest_id);
Quest const* Player::GetNextQuest(ObjectGuid guid, Quest const* quest);
bool Player::CanSeeStartQuest(Quest const* quest);
bool Player::CanTakeQuest(Quest const* quest, bool msg);
bool Player::CanAddQuest(Quest const* quest, bool msg);
bool Player::CanCompleteQuest(uint32 quest_id);
bool Player::CanCompleteRepeatableQuest(Quest const* quest);
bool Player::CanRewardQuest(Quest const* quest, bool msg);
void Player::AddQuestAndCheckCompletion(Quest const* quest, Object* questGiver);
bool Player::CanRewardQuest(Quest const* quest, uint32 reward, bool msg);
void Player::AddQuest(Quest const* quest, Object* questGiver);
void Player::CompleteQuest(uint32 quest_id);
void Player::IncompleteQuest(uint32 quest_id);
uint32 Player::GetQuestMoneyReward(Quest const* quest);
uint32 Player::GetQuestXPReward(Quest const* quest);
void Player::RewardQuest(Quest const* quest, uint32 reward, Object* questGiver, bool announce);
void Player::FailQuest(uint32 questId);
bool Player::SatisfyQuestSkill(Quest const* qInfo, bool msg);
bool Player::SatisfyQuestLevel(Quest const* qInfo, bool msg);
bool Player::SatisfyQuestLog(bool msg);
bool Player::SatisfyQuestPreviousQuest(Quest const* qInfo, bool msg);
bool Player::SatisfyQuestClass(Quest const* qInfo, bool msg);
bool Player::SatisfyQuestRace(Quest const* qInfo, bool msg);
bool Player::SatisfyQuestReputation(Quest const* qInfo, bool msg);
bool Player::SatisfyQuestStatus(Quest const* qInfo, bool msg);
bool Player::SatisfyQuestConditions(Quest const* qInfo, bool msg);
bool Player::SatisfyQuestTimed(Quest const* qInfo, bool msg);
bool Player::SatisfyQuestExclusiveGroup(Quest const* qInfo, bool msg);
bool Player::SatisfyQuestNextChain(Quest const* qInfo, bool msg);
bool Player::SatisfyQuestPrevChain(Quest const* qInfo, bool msg);
bool Player::SatisfyQuestDay(Quest const* qInfo, bool /*msg*/);
bool Player::SatisfyQuestWeek(Quest const* qInfo, bool /*msg*/);
bool Player::SatisfyQuestSeasonal(Quest const* qInfo, bool /*msg*/);
bool Player::SatisfyQuestMonth(Quest const* qInfo, bool /*msg*/);
bool Player::GiveQuestSourceItem(Quest const* quest);
bool Player::TakeQuestSourceItem(uint32 questId, bool msg);
bool Player::GetQuestRewardStatus(uint32 quest_id);
QuestStatus Player::GetQuestStatus(uint32 quest_id);
bool Player::CanShareQuest(uint32 quest_id);
void Player::SetQuestStatus(uint32 questId, QuestStatus status, bool update /*= true*/);
void Player::RemoveActiveQuest(uint32 questId, bool update /*= true*/);
void Player::RemoveRewardedQuest(uint32 questId, bool update /*= true*/);
void Player::SendQuestUpdate(uint32 questId);
QuestGiverStatus Player::GetQuestDialogStatus(Object* questgiver);
uint16 Player::GetReqKillOrCastCurrentCount(uint32 quest_id, int32 entry);
void Player::AdjustQuestReqItemCount(Quest const* quest);
uint16 Player::FindQuestSlot(uint32 quest_id);
uint32 Player::GetQuestSlotQuestId(uint16 slot);
uint32 Player::GetQuestSlotState(uint16 slot);
uint16 Player::GetQuestSlotCounter(uint16 slot, uint8 counter);
uint32 Player::GetQuestSlotTime(uint16 slot);
void Player::SetQuestSlot(uint16 slot, uint32 quest_id, uint32 timer /*= 0*/);
void Player::SetQuestSlotCounter(uint16 slot, uint8 counter, uint16 count);
void Player::SetQuestSlotState(uint16 slot, uint32 state);
void Player::RemoveQuestSlotState(uint16 slot, uint32 state);
void Player::SetQuestSlotTimer(uint16 slot, uint32 timer);
void Player::SetQuestCompletedBit(uint32 questBit, bool completed);
void Player::AreaExploredOrEventHappens(uint32 questId);
void Player::GroupEventHappens(uint32 questId, WorldObject const* pEventObject);
void Player::ItemAddedQuestCheck(uint32 entry, uint32 count);
void Player::ItemRemovedQuestCheck(uint32 entry, uint32 count);
void Player::KilledMonster(CreatureTemplate const* cInfo, ObjectGuid guid);
void Player::KilledMonsterCredit(uint32 entry, ObjectGuid guid /*= ObjectGuid::Empty*/);
void Player::KilledPlayerCredit();
void Player::KillCreditGO(uint32 entry, ObjectGuid guid);
void Player::TalkedToCreature(uint32 entry, ObjectGuid guid);
void Player::MoneyChanged(uint64 value);
void Player::ReputationChanged(FactionEntry const* factionEntry);
void Player::CurrencyChanged(uint32 currencyId, int32 change);
bool Player::HasQuestForItem(uint32 itemid);
int32 Player::GetQuestObjectiveData(Quest const* quest, int8 storageIndex);
void Player::SetQuestObjectiveData(Quest const* quest, int8 storageIndex, int32 data);
void Player::SendQuestComplete(Quest const* quest);
void Player::SendQuestReward(Quest const* quest, uint32 XP);
void Player::SendQuestFailed(uint32 questID, InventoryResult reason);
void Player::SendQuestTimerFailed(uint32 questID);
void Player::SendCanTakeQuestResponse(QuestFailedReason reason, bool sendErrorMessage /*= true*/, std::string reasonText /*= ""*/);
void Player::SendQuestConfirmAccept(Quest const* quest, Player* receiver);
void Player::SendPushToPartyResponse(Player* player, QuestPushReason reason);
void Player::SendQuestUpdateAddCredit(Quest const* quest, ObjectGuid guid, QuestObjective const& obj, uint16 count);
void Player::SendQuestUpdateAddPlayer(Quest const* quest, uint16 newCount, uint32 required);
bool Player::HasPvPForcingQuest();
void Player::_LoadDeclinedNames(PreparedQueryResult result);
void Player::_LoadArenaTeamInfo(PreparedQueryResult result);
void Player::_LoadEquipmentSets(PreparedQueryResult result);
void Player::_LoadBGData(PreparedQueryResult result);
bool Player::LoadPositionFromDB(uint32& mapid, float& x, float& y, float& z, float& o, bool& in_flight, ObjectGuid guid);
void Player::SetHomebind(WorldLocation const& loc, uint32 areaId);
void Player::SendBindPointUpdate();
uint32 Player::GetUInt32ValueFromArray(Tokenizer const& data, uint16 index);
float Player::GetFloatValueFromArray(Tokenizer const& data, uint16 index);
bool Player::IsLoading();
bool Player::LoadFromDB(ObjectGuid guid, SQLQueryHolder *holder);
void Player::_LoadCUFProfiles(PreparedQueryResult result);
bool Player::isAllowedToLoot(const Creature* creature);
void Player::_LoadActions(PreparedQueryResult result);
void Player::_LoadAuras(PreparedQueryResult auraResult, PreparedQueryResult effectResult, uint32 timediff);
void Player::_LoadGlyphAuras();
void Player::LoadCorpse(PreparedQueryResult result);
void Player::_LoadInventory(PreparedQueryResult result, uint32 timeDiff);
void Player::_LoadVoidStorage(PreparedQueryResult result);
Item* Player::_LoadItem(SQLTransaction& trans, uint32 zoneId, uint32 timeDiff, Field* fields);
void Player::_LoadMailedItems(Mail* mail);
void Player::_LoadMailInit(PreparedQueryResult resultUnread, PreparedQueryResult resultDelivery);
void Player::_LoadMail();
void Player::LoadPet();
void Player::_LoadQuestStatus(PreparedQueryResult result);
void Player::_LoadQuestStatusObjectives(PreparedQueryResult result);
void Player::_LoadQuestStatusRewarded(PreparedQueryResult result);
void Player::_LoadDailyQuestStatus(PreparedQueryResult result);
void Player::_LoadWeeklyQuestStatus(PreparedQueryResult result);
void Player::_LoadSeasonalQuestStatus(PreparedQueryResult result);
void Player::_LoadMonthlyQuestStatus(PreparedQueryResult result);
void Player::_LoadSpells(PreparedQueryResult result);
void Player::_LoadGroup(PreparedQueryResult result);
void Player::_LoadBoundInstances(PreparedQueryResult result);
InstancePlayerBind* Player::GetBoundInstance(uint32 mapid, Difficulty difficulty);
InstancePlayerBind const* Player::GetBoundInstance(uint32 mapid, Difficulty difficulty);
InstanceSave* Player::GetInstanceSave(uint32 mapid);
void Player::UnbindInstance(uint32 mapid, Difficulty difficulty, bool unload);
void Player::UnbindInstance(BoundInstancesMap::iterator &itr, Difficulty difficulty, bool unload);
InstancePlayerBind* Player::BindToInstance(InstanceSave* save, bool permanent, bool load);
void Player::BindToInstance();
void Player::SetPendingBind(uint32 instanceId, uint32 bindTimer);
void Player::SendRaidInfo();
void Player::ConvertInstancesToGroup(Player* player, Group* group, bool switchLeader);
bool Player::Satisfy(AccessRequirement const* ar, uint32 target_map, bool report);
bool Player::CheckInstanceLoginValid(Map* map);
bool Player::IsInstanceLoginGameMasterException();
bool Player::CheckInstanceCount(uint32 instanceId);
void Player::AddInstanceEnterTime(uint32 instanceId, time_t enterTime);
bool Player::_LoadHomeBind(PreparedQueryResult result);
void Player::SaveToDB(bool create /*=false*/);
void Player::SaveInventoryAndGoldToDB(SQLTransaction& trans);
void Player::SaveGoldToDB(SQLTransaction& trans);
void Player::_SaveActions(SQLTransaction& trans);
void Player::_SaveAuras(SQLTransaction& trans);
void Player::_SaveInventory(SQLTransaction& trans);
void Player::_SaveVoidStorage(SQLTransaction& trans);
void Player::_SaveCUFProfiles(SQLTransaction& trans);
void Player::_SaveMail(SQLTransaction& trans);
void Player::_SaveQuestStatus(SQLTransaction& trans);
void Player::_SaveDailyQuestStatus(SQLTransaction& trans);
void Player::_SaveWeeklyQuestStatus(SQLTransaction& trans);
void Player::_SaveSeasonalQuestStatus(SQLTransaction& trans);
void Player::_SaveMonthlyQuestStatus(SQLTransaction& trans);
void Player::_SaveSkills(SQLTransaction& trans);
void Player::_SaveSpells(SQLTransaction& trans);
void Player::_SaveStats(SQLTransaction& trans);
void Player::outDebugValues();
void Player::UpdateSpeakTime();
bool Player::CanSpeak();
void Player::SavePositionInDB(WorldLocation const& loc, uint16 zoneId, ObjectGuid guid, SQLTransaction& trans);
void Player::SetUInt32ValueInArray(Tokenizer& Tokenizer, uint16 index, uint32 value);
void Player::SendAttackSwingDeadTarget();
void Player::SendAttackSwingCantAttack();
void Player::SendAttackSwingNotInRange();
void Player::SendAttackSwingBadFacingAttack();
void Player::SendAttackSwingCancelAttack();
void Player::SendAutoRepeatCancel(Unit* target);
void Player::SendExplorationExperience(uint32 Area, uint32 Experience);
void Player::SendDungeonDifficulty(int32 forcedDifficulty /*= -1*/);
void Player::SendRaidDifficulty(bool legacy, int32 forcedDifficulty /*= -1*/);
void Player::SendResetFailedNotify(uint32 /*mapid*/);
void Player::ResetInstances(uint8 method, bool isRaid, bool isLegacy);
void Player::SendResetInstanceSuccess(uint32 MapId);
void Player::SendResetInstanceFailed(ResetFailedReason reason, uint32 mapID);
void Player::UpdateAfkReport(time_t currTime);
void Player::UpdateContestedPvP(uint32 diff);
void Player::ResetContestedPvP();
void Player::UpdatePvPFlag(time_t currTime);
void Player::UpdateDuelFlag(time_t currTime);
Pet* Player::GetPet();
void Player::RemovePet(Pet* pet, PetSaveMode mode, bool returnreagent);
void Player::StopCastingCharm();
void Player::Say(std::string const& text, Language language, WorldObject const* /*= nullptr*/);
void Player::Yell(std::string const& text, Language language, WorldObject const* /*= nullptr*/);
void Player::TextEmote(std::string const& text, WorldObject const* /*= nullptr*/, bool /*= false*/);
void Player::WhisperAddon(std::string const& text, const std::string& prefix, Player* receiver);
void Player::Whisper(std::string const& text, Language language, Player* target, bool /*= false*/);
Item* Player::GetMItem(ObjectGuid::LowType id);
void Player::AddMItem(Item* it);
bool Player::RemoveMItem(ObjectGuid::LowType id);
void Player::SendOnCancelExpectedVehicleRideAura();
void Player::PetSpellInitialize();
void Player::PossessSpellInitialize();
void Player::VehicleSpellInitialize();
void Player::CharmSpellInitialize();
void Player::SendRemoveControlBar();
bool Player::IsAffectedBySpellmod(SpellInfo const* spellInfo, SpellModifier* mod, Spell* spell);
void Player::AddSpellMod(SpellModifier* mod, bool apply);
void Player::RestoreSpellMods(Spell* spell, uint32 ownerAuraId, Aura* aura);
void Player::RestoreAllSpellMods(uint32 ownerAuraId, Aura* aura);
void Player::RemoveSpellMods(Spell* spell);
void Player::DropModCharge(SpellModifier* mod, Spell* spell);
void Player::SetSpellModTakingSpell(Spell* spell, bool apply);
void Player::SendProficiency(ItemClass itemClass, uint32 itemSubclassMask);
void Player::RemovePetitionsAndSigns(ObjectGuid guid);
void Player::LeaveAllArenaTeams(ObjectGuid guid);
void Player::SetRestBonus(float rest_bonus_new);
bool Player::ActivateTaxiPathTo(std::vector<uint32> const& nodes, Creature* npc /*= NULL*/, uint32 spellid /*= 0*/);
bool Player::ActivateTaxiPathTo(uint32 taxi_path_id, uint32 spellid /*= 0*/);
void Player::CleanupAfterTaxiFlight();
void Player::ContinueTaxiFlight();
void Player::InitDataForForm(bool reapplyMods);
void Player::InitDisplayIds();
inline bool Player::_StoreOrEquipNewItem(uint32 vendorslot, uint32 item, uint8 count, uint8 bag, uint8 slot, int32 price, ItemTemplate const* pProto, Creature* pVendor, VendorItem const* crItem, bool bStore);
bool Player::BuyCurrencyFromVendorSlot(ObjectGuid vendorGuid, uint32 vendorSlot, uint32 currency, uint32 count);
bool Player::BuyItemFromVendorSlot(ObjectGuid vendorguid, uint32 vendorslot, uint32 item, uint8 count, uint8 bag, uint8 slot);
uint32 Player::GetMaxPersonalArenaRatingRequirement(uint32 minarenaslot);
void Player::UpdateHomebindTime(uint32 time);
void Player::UpdatePvPState(bool onlyFFA);
void Player::SetPvP(bool state);
void Player::UpdatePvP(bool state, bool _override);
void Player::UpdatePotionCooldown(Spell* spell);
void Player::SetResurrectRequestData(Unit* caster, uint32 health, uint32 mana, uint32 appliedAura);
bool Player::EnchantmentFitsRequirements(uint32 enchantmentcondition, int8 slot);
void Player::CorrectMetaGemEnchants(uint8 exceptslot, bool apply);
void Player::ToggleMetaGemsActive(uint8 exceptslot, bool apply);
void Player::SetBattlegroundEntryPoint();
void Player::SetBGTeam(uint32 team);
uint32 Player::GetBGTeam();
void Player::LeaveBattleground(bool teleportToEntryPoint);
bool Player::CanJoinToBattleground(Battleground const* bg);
bool Player::CanReportAfkDueToLimit();
void Player::ReportedAfkBy(Player* reporter);
WorldLocation Player::GetStartPosition();
bool Player::HaveAtClient(WorldObject const* u);
bool Player::IsNeverVisible();
bool Player::CanAlwaysSee(WorldObject const* obj);
bool Player::IsAlwaysDetectableFor(WorldObject const* seer);
bool Player::IsVisibleGloballyFor(Player const* u);
inline void UpdateVisibilityOf_helper(GuidUnorderedSet& s64, T* target, std::set<Unit*>& /*v*/);
inline void UpdateVisibilityOf_helper(GuidUnorderedSet& s64, GameObject* target, std::set<Unit*>& /*v*/);
inline void UpdateVisibilityOf_helper(GuidUnorderedSet& s64, Creature* target, std::set<Unit*>& v);
inline void UpdateVisibilityOf_helper(GuidUnorderedSet& s64, Player* target, std::set<Unit*>& v);
inline void BeforeVisibilityDestroy<Creature>(Creature* t, Player* p);
void Player::UpdateVisibilityOf(WorldObject* target);
void Player::UpdateTriggerVisibility();
void Player::SendInitialVisiblePackets(Unit* target);
void Player::UpdateVisibilityOf(T* target, UpdateData& data, std::set<Unit*>& visibleNow);
void Player::UpdateObjectVisibility(bool forced);
void Player::UpdateVisibilityForPlayer();
void Player::InitPrimaryProfessions();
bool Player::ModifyMoney(int64 amount, bool sendError /*= true*/);
bool Player::HasEnoughMoney(int64 amount);
void Player::SetMoney(uint64 value);
bool Player::IsQuestRewarded(uint32 quest_id);
Unit* Player::GetSelectedUnit();
Player* Player::GetSelectedPlayer();
void Player::AddComboPoints(int8 count, Spell* spell);
void Player::GainSpellComboPoints(int8 count);
void Player::ClearComboPoints();
void Player::SetGroup(Group* group, int8 subgroup);
void Player::SendInitialPacketsBeforeAddToMap();
void Player::SendUpdateToOutOfRangeGroupMembers();
void Player::SendTransferAborted(uint32 mapid, TransferAbortReason reason, uint8 arg);
void Player::SendInstanceResetWarning(uint32 mapid, Difficulty difficulty, uint32 time, bool welcome);
void Player::ApplyEquipCooldown(Item* pItem);
void Player::ResetSpells(bool myClassOnly);
void Player::LearnCustomSpells();
void Player::LearnDefaultSkills();
void Player::LearnDefaultSkill(SkillRaceClassInfoEntry const* rcInfo);
void Player::LearnQuestRewardedSpells(Quest const* quest);
void Player::LearnQuestRewardedSpells();
void Player::LearnSkillRewardedSpells(uint32 skillId, uint32 skillValue);
void Player::SendAurasForTarget(Unit* target);
void Player::SetDailyQuestStatus(uint32 quest_id);
void Player::SetWeeklyQuestStatus(uint32 quest_id);
void Player::SetSeasonalQuestStatus(uint32 quest_id);
void Player::SetMonthlyQuestStatus(uint32 quest_id);
void Player::DailyReset();
void Player::ResetWeeklyQuestStatus();
void Player::ResetSeasonalQuestStatus(uint16 event_id);
void Player::ResetMonthlyQuestStatus();
Battleground* Player::GetBattleground();
uint32 Player::GetBattlegroundQueueJoinTime(BattlegroundQueueTypeId bgQueueTypeId);
bool Player::InBattlegroundQueue();
BattlegroundQueueTypeId Player::GetBattlegroundQueueTypeId(uint32 index);
uint32 Player::GetBattlegroundQueueIndex(BattlegroundQueueTypeId bgQueueTypeId);
bool Player::IsInvitedForBattlegroundQueueType(BattlegroundQueueTypeId bgQueueTypeId);
bool Player::InBattlegroundQueueForBattlegroundQueueType(BattlegroundQueueTypeId bgQueueTypeId);
void Player::SetBattlegroundId(uint32 val, BattlegroundTypeId bgTypeId);
uint32 Player::AddBattlegroundQueueId(BattlegroundQueueTypeId val);
bool Player::HasFreeBattlegroundQueueId();
void Player::RemoveBattlegroundQueueId(BattlegroundQueueTypeId val);
void Player::SetInviteForBattlegroundQueueType(BattlegroundQueueTypeId bgQueueTypeId, uint32 instanceId);
bool Player::IsInvitedForBattlegroundInstance(uint32 instanceId);
bool Player::InArena();
bool Player::GetBGAccessByLevel(BattlegroundTypeId bgTypeId);
float Player::GetReputationPriceDiscount(Creature const* creature);
bool Player::IsSpellFitByClassAndRace(uint32 spell_id);
bool Player::HasQuestForGO(int32 GOId);
void Player::UpdateForQuestWorldObjects();
void Player::SetSummonPoint(uint32 mapid, float x, float y, float z);
void Player::SummonIfPossible(bool agree);
void Player::RemoveItemDurations(Item* item);
void Player::AddItemDurations(Item* item);
void Player::AutoUnequipOffhandIfNeed(bool force /*= false*/);
OutdoorPvP* Player::GetOutdoorPvP();
bool Player::HasItemFitToSpellRequirements(SpellInfo const* spellInfo, Item const* ignoreItem);
bool Player::CanNoReagentCast(SpellInfo const* spellInfo);
void Player::RemoveItemDependentAurasAndCasts(Item* pItem);
uint32 Player::GetResurrectionSpellId();
bool Player::isHonorOrXPTarget(Unit const* victim);
bool Player::GetsRecruitAFriendBonus(bool forXP);
void Player::RewardPlayerAndGroupAtKill(Unit* victim, bool isBattleGround);
void Player::RewardPlayerAndGroupAtEvent(uint32 creature_id, WorldObject* pRewardSource);
bool Player::IsAtGroupRewardDistance(WorldObject const* pRewardSource);
bool Player::IsAtRecruitAFriendDistance(WorldObject const* pOther);
void Player::ResurrectUsingRequestData();
void Player::SetClientControl(Unit* target, bool allowMove);
void Player::SetMover(Unit* target);
void Player::UpdateZoneDependentAuras(uint32 newZone);
void Player::UpdateAreaDependentAuras(uint32 newArea);
uint32 Player::GetCorpseReclaimDelay(bool pvp);
void Player::UpdateCorpseReclaimDelay();
int32 Player::CalculateCorpseReclaimDelay(bool load);
void Player::SendCorpseReclaimDelay(uint32 delay);
Player* Player::GetNextRandomRaidMember(float radius);
PartyResult Player::CanUninviteFromGroup(ObjectGuid guidMember);
bool Player::isUsingLfg();
bool Player::inRandomLfgDungeon();
void Player::SetBattlegroundOrBattlefieldRaid(Group* group, int8 subgroup);
void Player::RemoveFromBattlegroundOrBattlefieldRaid();
void Player::SetOriginalGroup(Group* group, int8 subgroup);
void Player::UpdateUnderwaterState(Map* m, float x, float y, float z);
void Player::SetCanParry(bool value);
void Player::SetCanBlock(bool value);
bool ItemPosCount::isContainedIn(std::vector<ItemPosCount> const& vec);
void Player::StopCastingBindSight();
void Player::SetViewpoint(WorldObject* target, bool apply);
WorldObject* Player::GetViewpoint();
bool Player::CanUseBattlegroundObject(GameObject* gameobject);
bool Player::CanCaptureTowerPoint();
uint32 Player::GetBarberShopCost(BarberShopStyleEntry const* newHairStyle, uint8 newHairColor, BarberShopStyleEntry const* newFacialHair, BarberShopStyleEntry const* newSkin /*= nullptr*/, BarberShopStyleEntry const* newFace /*= nullptr*/);
void Player::InitGlyphsForLevel();
void Player::SetGlyph(uint8 slot, uint32 glyph);
bool Player::isTotalImmune();
bool Player::HasTitle(uint32 bitIndex);
void Player::SetTitle(CharTitlesEntry const* title, bool lost);
bool Player::isTotalImmunity();
void Player::UpdateCharmedAI();
uint32 Player::GetRuneTypeBaseCooldown(RuneType runeType);
void Player::SetRuneCooldown(uint8 index, uint32 cooldown, bool casted /*= false*/);
void Player::SetRuneConvertAura(uint8 index, AuraEffect const* aura);
void Player::AddRuneByAuraEffect(uint8 index, RuneType newType, AuraEffect const* aura);
void Player::RemoveRunesByAuraEffect(AuraEffect const* aura);
void Player::RestoreBaseRune(uint8 index);
void Player::ConvertRune(uint8 index, RuneType newType);
void Player::ResyncRunes(uint8 count);
void Player::AddRunePower(uint8 index);
void Player::InitRunes();
bool Player::IsBaseRuneSlotsOnCooldown(RuneType runeType);
void Player::AutoStoreLoot(uint8 bag, uint8 slot, uint32 loot_id, LootStore const& store, bool broadcast);
void Player::StoreLootItem(uint8 lootSlot, Loot* loot);
bool Player::CanFlyInZone(uint32 mapid, uint32 zone);
void Player::LearnSpellHighestRank(uint32 spellid);
void Player::_LoadSkills(PreparedQueryResult result);
InventoryResult Player::CanEquipUniqueItem(Item* pItem, uint8 eslot, uint32 limit_count);
InventoryResult Player::CanEquipUniqueItem(ItemTemplate const* itemProto, uint8 except_slot, uint32 limit_count);
void Player::SetFallInformation(uint32 time, float z);
void Player::HandleFall(MovementInfo const& movementInfo);
void Player::ResetAchievements();
void Player::SendRespondInspectAchievements(Player* player);
uint32 Player::GetAchievementPoints();
bool Player::HasAchieved(uint32 achievementId);
void Player::StartTimedAchievement(AchievementCriteriaTimedTypes type, uint32 entry, uint32 timeLost/* = 0*/);
void Player::RemoveTimedAchievement(AchievementCriteriaTimedTypes type, uint32 entry);
void Player::ResetAchievementCriteria(AchievementCriteriaTypes type, uint64 miscValue1 /*= 0*/, uint64 miscValue2 /*= 0*/, bool evenIfCriteriaComplete /* = false*/);
void Player::UpdateAchievementCriteria(AchievementCriteriaTypes type, uint64 miscValue1 /*= 0*/, uint64 miscValue2 /*= 0*/, uint64 miscValue3 /*= 0*/, Unit* unit /*= NULL*/);
void Player::CompletedAchievement(AchievementEntry const* entry);
bool Player::LearnTalent(uint32 talentId);
void Player::LearnTalentSpecialization(uint32 talentSpec);
void Player::ResetTalentSpecialization();
void Player::UpdateFallInformationIfNeed(MovementInfo const& minfo, uint16 opcode);
void Player::UnsummonPetTemporaryIfAny();
void Player::ResummonPetTemporaryUnSummonedIfAny();
bool Player::IsPetNeedBeTemporaryUnsummoned();
bool Player::CanSeeSpellClickOn(Creature const* c);
void Player::SendTalentsInfoData();
void Player::SendEquipmentSetList();
void Player::SetEquipmentSet(EquipmentSetInfo::EquipmentSetData&& newEqSet);
void Player::_SaveEquipmentSets(SQLTransaction& trans);
void Player::_SaveBGData(SQLTransaction& trans);
void Player::DeleteEquipmentSet(uint64 id);
void Player::RemoveAtLoginFlag(AtLoginFlags flags, bool persist /*= false*/);
void Player::ResetMap();
void Player::SetMap(Map* map);
void Player::_LoadGlyphs(PreparedQueryResult result);
void Player::_SaveGlyphs(SQLTransaction& trans);
void Player::_LoadTalents(PreparedQueryResult result);
void Player::_SaveTalents(SQLTransaction& trans);
void Player::UpdateTalentGroupCount(uint8 count);
void Player::ActivateTalentGroup(uint8 spec);
void Player::ResetTimeSync();
void Player::SendTimeSync();
void Player::SetReputation(uint32 factionentry, uint32 value);
uint32 Player::GetReputation(uint32 factionentry);
std::string Player::GetGuildName();
void Player::AddRefundReference(ObjectGuid it);
void Player::DeleteRefundReference(ObjectGuid it);
void Player::SendRefundInfo(Item* item);
bool Player::AddItem(uint32 itemId, uint32 count);
void Player::SendItemRefundResult(Item* item, ItemExtendedCostEntry const* iece, uint8 error);
void Player::RefundItem(Item* item);
void Player::SendItemRetrievalMail(uint32 itemEntry, uint32 count);
void Player::SetRandomWinner(bool isWinner);
void Player::_LoadRandomBGStatus(PreparedQueryResult result);
float Player::GetAverageItemLevel();
void Player::_LoadInstanceTimeRestrictions(PreparedQueryResult result);
void Player::_SaveInstanceTimeRestrictions(SQLTransaction& trans);
bool Player::IsInWhisperWhiteList(ObjectGuid guid);
uint8 Player::GetNextVoidStorageFreeSlot();
uint8 Player::GetNumOfVoidStorageFreeSlots();
uint8 Player::AddVoidStorageItem(VoidStorageItem&& item);
void Player::DeleteVoidStorageItem(uint8 slot);
bool Player::SwapVoidStorageItem(uint8 oldSlot, uint8 newSlot);
VoidStorageItem* Player::GetVoidStorageItem(uint8 slot);
VoidStorageItem* Player::GetVoidStorageItem(uint64 id, uint8& slot);
void Player::OnCombatExit();
void Player::CreateGarrison(uint32 garrSiteId);
void Player::DeleteGarrison();
void Player::SendMovementSetCanTransitionBetweenSwimAndFly(bool apply);
void Player::SendMovementSetCollisionHeight(float height);
float Player::GetCollisionHeight(bool mounted);
std::string Player::GetMapAreaAndZoneString();
std::string Player::GetCoordsMapAreaAndZoneString();
Guild* Player::GetGuild();
Guild const* Player::GetGuild();
Pet* Player::SummonPet(uint32 entry, float x, float y, float z, float ang, PetType petType, uint32 duration);
bool Player::CanUseMastery();
void Player::ValidateMovementInfo(MovementInfo* mi);
void Player::SendUpdatePhasing();
void Player::SendSupercededSpell(uint32 oldSpell, uint32 newSpell);
uint32 Player::CalculateTalentsTiers();
Difficulty Player::GetDifficultyID(MapEntry const* mapEntry);
Difficulty Player::CheckLoadedDungeonDifficultyID(Difficulty difficulty);
Difficulty Player::CheckLoadedRaidDifficultyID(Difficulty difficulty);
Difficulty Player::CheckLoadedLegacyRaidDifficultyID(Difficulty difficulty);
SpellInfo const* Player::GetCastSpellInfo(SpellInfo const* spellInfo);
void Player::AddOverrideSpell(uint32 overridenSpellId, uint32 newSpellId);
void Player::RemoveOverrideSpell(uint32 overridenSpellId, uint32 newSpellId);
void Player::LearnSpecializationSpells();
void Player::RemoveSpecializationSpells();
void Player::RemoveSocial();
bool Player::ValidateAppearance(uint8 race, uint8 class_, uint8 gender, uint8 hairID, uint8 hairColor, uint8 faceID, uint8 facialHair, uint8 skinColor, bool create /*=false*/);
uint32 Player::GetDefaultSpecId();
void Player::SendSpellCategoryCooldowns();
void Player::SendRaidGroupOnlyMessage(RaidGroupReason reason, int32 delay);
void Player::SetRestFlag(RestFlag restFlag, uint32 triggerId /*= 0*/);
void Player::RemoveRestFlag(RestFlag restFlag);
| 93535a19c3685212f1ed09f03a0c060cd1d0e1d5a493c2d469e075c13a9dec6c | 1,818 |
|
motoschifo | mame | src/mame/drivers/m24.cpp |
WRITE_LINE_MEMBER |
WRITE_LINE_MEMBER(m24_state::int87_w)
{
m_87int = state;
update_nmi();
} | m24_state(const machine_config &mconfig, device_type type, const char *tag);
void m24_state::machine_start();
void m24_state::machine_reset();
void m24_state::dma_segment_w(offs_t offset, u8 data);
WRITE_LINE_MEMBER(m24_state::dma_hrq_w);
u8 m24_state::dma_memory_read(offs_t offset);
void m24_state::dma_memory_write(offs_t offset, u8 data);
u8 m24_state::dma_io_read(offs_t offset);
void m24_state::dma_io_write(offs_t offset, u8 data);
WRITE_LINE_MEMBER(m24_state::dma_dack_w);
WRITE_LINE_MEMBER(m24_state::dma_tc_w);
WRITE_LINE_MEMBER(m24_state::dreq0_ck_w);
WRITE_LINE_MEMBER(m24_state::speaker_ck_w);
void m24_state::update_speaker();
u8 m24_state::keyboard_data_r();
u8 m24_state::keyboard_status_r();
void m24_state::keyboard_data_w(u8 data);
void m24_state::ctrlport_a_w(u8 data);
u8 m24_state::ctrlport_a_r();
u8 m24_state::ctrlport_b_r();
void m24_state::alt_w(u8 data);
WRITE_LINE_MEMBER(m24_state::chck_w);
void m24_state::nmi_enable_w(u8 data);
void m24_state::update_nmi();
u8 m24_state::pa_r();
void m24_state::pb_w(u8 data);
u8 m24_state::kbcdata_r();
void m24_state::kbcdata_w(u8 data);
WRITE_LINE_MEMBER(m24_state::kbcin_w);
WRITE_LINE_MEMBER(m24_state::int_w);
WRITE_LINE_MEMBER(m24_state::halt_i86_w);
void m24_state::m24_map(address_map &map);
void m24_state::m24_io(address_map &map);
void m24_state::kbc_map(address_map &map);
void m24_state::cfg_m20_format(device_t *device);
void m24_state::olivetti(machine_config &config);
| ac0283a9b21f10cf0fe90170200e3959624811898a1a75630ae9a32d282f2db1 | 75 |
|
Iv | FlyHigh | src/common/utils/Vector.cpp | - |
Vector2 operator - (const Vector2 &w, const Vector2 &v)
{
return Vector2(w) -= v;
} |
Vector2::Vector2(double x, double y);
Vector2::Vector2(const Vector2 &v);
void Vector2::set(double a, double b);
void Vector2::setCircle(double r, double rad);
void Vector2::normalize();
double Vector2::norm();
double Vector2::length();
double Vector2::arc();
void Vector2::rot(double rad);
double Vector2::x();
double Vector2::y();
Vector2& Vector2::operator = (const Vector2 &v);
bool Vector2::operator == (const Vector2 &v);
Vector2& Vector2::operator += (const Vector2 &v);
Vector2& Vector2::operator -= (const Vector2 &v);
Vector2& Vector2::operator *= (double f);
Vector2 operator + (const Vector2 &w, const Vector2 &v);
Vector2 operator * (const Vector2 &v, double f);
Vector2 operator * (double f, const Vector2 &v);
double operator * (const Vector2 &a, const Vector2 &b);
| cbadb9f44aa3a99afecd36d6b0d41d69596e9d7588a656af907852c12f7df79f | 85 |
|
hippich | recorditnow | src/libs/keylogger/abstractkeylogger.cpp |
AbstractKeyloggerPrivate::~AbstractKeyloggerPrivate |
AbstractKeyloggerPrivate::~AbstractKeyloggerPrivate()
{
} |
AbstractKeyloggerPrivate::AbstractKeyloggerPrivate(AbstractKeylogger *parent);
AbstractKeylogger::AbstractKeylogger(QObject *parent);
AbstractKeylogger::~AbstractKeylogger();
| c6de641484e79059669607936b212f947fc8a593309540184de3952455c9d9de | 60 |
|
the-nic | halmd | halmd/observables/utility/accumulator.cpp | accumulator_type::value_type | tatic std::function<typename accumulator_type::value_type ()>
wrap_error_of_mean(std::shared_ptr<accumulator_type> self)
{
return [=]() {
return self->error_of_mean();
};
}
| tatic std::function<void ();
tatic std::function<void ();
tatic std::function<typename accumulator_type::value_type ();
tatic std::function<typename accumulator_type::value_type ();
tatic std::function<typename accumulator_type::value_type ();
tatic std::function<typename accumulator_type::accumulator_type::size_type ();
oid accumulator<sample_type>::luaopen(lua_State* L);
ALMD_LUA_API int luaopen_libhalmd_observables_utility_accumulator(lua_State* L);
| ec33bd62d85f83aeb1944251500d19051ae66632417bf4503ab4c09af01af94c | 190 |
|
MicroBahner | MobaTools | src/avr/MoToAVR.cpp | seizeTimerAS | void seizeTimerAS() {
static bool timerInitialized = false;
if ( !timerInitialized ) {
uint8_t oldSREG = SREG;
cli();
TCCRxA =0;
TCCRxB = _BV(WGMx3) | _BV(WGMx2)
| _BV(CS11)
;
ICRx = TIMERPERIODE * TICS_PER_MICROSECOND;
OCRxA = FIRST_PULSE;
OCRxB = 400;
SREG = oldSREG;
timerInitialized = true;
MODE_TP1;
MODE_TP2;
MODE_TP3;
MODE_TP4;
DB_PRINT("Testpins initialisiert");
}
}
|
ISR ( TIMERx_COMPB_vect);
ISR ( SPI_STC_vect );
void enableSoftLedIsrAS();
| b1bfe5f1ec6e6d14595c235f52373a1813606cde63734b1b20923e93be875a0c | 548 |
|
facebook | redex | service/type-analysis/TypeAnalysisTransform.cpp | Transform::remove_redundant_type_checks |
void Transform::remove_redundant_type_checks(const DexTypeEnvironment& env,
IRList::iterator& it,
Stats& stats) {
auto insn = it->insn;
auto move_res = (++it)->insn;
always_assert(insn->opcode() == OPCODE_INSTANCE_OF);
always_assert(opcode::is_move_result_any(move_res->opcode()));
auto val = env.get(insn->src(0));
if (val.is_top() || val.is_bottom()) {
return;
}
auto val_type = val.get_dex_type();
if (val.is_null()) {
auto eval_val = new IRInstruction(OPCODE_CONST);
eval_val->set_literal(0)->set_dest(move_res->dest());
m_replacements.push_back({insn, eval_val});
stats.type_check_removed++;
} else if (val.is_not_null() && val_type) {
DexType* src_type = const_cast<DexType*>(*val_type);
auto eval_res = type::evaluate_type_check(src_type, insn->get_type());
if (!eval_res) {
return;
}
auto eval_val = new IRInstruction(OPCODE_CONST);
eval_val->set_literal(*eval_res)->set_dest(move_res->dest());
m_replacements.push_back({insn, eval_val});
stats.type_check_removed++;
} else if (val.is_nullable() && val_type) {
DexType* src_type = const_cast<DexType*>(*val_type);
auto eval_res = type::evaluate_type_check(src_type, insn->get_type());
if (eval_res) {
stats.null_check_only_type_checks++;
}
}
} |
BranchResult evaluate_branch(IROpcode op, Nullness operand_nullness);
bool is_supported_branch_type(IROpcode op);
void Transform::apply_changes(DexMethod* method);
| 575fc00e8d49e9b99747a16542909488dde3f121c4c7b728594e221689340d2c | 1,415 |
|
3dct | open_iA | modules/GEMSe/dlg_GEMSe.cpp | dlg_GEMSe::ClusterNodeClicked | d dlg_GEMSe::ClusterNodeClicked(QSharedPointer<iAImageTreeNode> node)
{
if (node->GetFilteredSize() == 0)
{
return;
}
bool wasSelectedBefore = (m_selectedCluster == node);
m_treeView->UpdateAutoShrink(node.data(), wasSelectedBefore);
if (!wasSelectedBefore)
{
SelectCluster(node);
}
}
vo | d dlg_GEMSe::CreateMapper();
d dlg_GEMSe::ClusterNodeImageClicked(QSharedPointer<iAImageTreeNode> node);
d dlg_GEMSe::SelectCluster(QSharedPointer<iAImageTreeNode> node);
d dlg_GEMSe::ClusterLeafSelected(iAImageTreeLeaf * node);
d dlg_GEMSe::CompareAlternateSelected(iAImageTreeNode * node);
d dlg_GEMSe::StoreClustering(QString const & fileName);
d dlg_GEMSe::UpdateClusterChartData();
d dlg_GEMSe::HistogramSelectionUpdated();
d dlg_GEMSe::UpdateClusterFilteredChartData();
d dlg_GEMSe::UpdateFilteredChartData();
d dlg_GEMSe::UpdateFilteredData();
d dlg_GEMSe::FilterChanged(int chartID, double min, double max);
d dlg_GEMSe::ResetFilters();
d dlg_GEMSe::selectHistograms();
d dlg_GEMSe::ToggleHate();
d dlg_GEMSe::ToggleLike();
d dlg_GEMSe::ExportAttributeRangeRanking(QString const & fileName);
d dlg_GEMSe::UpdateAttributeRangeAttitude();
d dlg_GEMSe::ExportRankings(QString const & fileName);
d dlg_GEMSe::ImportRankings(QString const & fileName);
d dlg_GEMSe::GetSelection(QVector<QSharedPointer<iASingleResult> > & result);
aredPointer<iAImageTreeNode> dlg_GEMSe::GetSelectedCluster();
d dlg_GEMSe::AddConsensusImage(iAITKIO::ImagePointer imgData, QString const & name);
d dlg_GEMSe::AddConsensusNumbersImage(iAITKIO::ImagePointer imgData, QString const & name);
d dlg_GEMSe::JumpToNode(iAImageTreeNode * node, int stepLimit);
d dlg_GEMSe::FavoriteClicked(iAImageTreeNode * node);
d dlg_GEMSe::GoToCluster();
d dlg_GEMSe::SliceNumberChanged(int sliceNr);
d dlg_GEMSe::SlicerModeChanged(iASlicerMode mode, int sliceNr);
d dlg_GEMSe::UpdateViews();
d dlg_GEMSe::ShowImage(vtkSmartPointer<vtkImageData> imgData);
aredPointer<iAImageTreeNode> dlg_GEMSe::GetCurrentCluster();
aredPointer<iAImageTreeNode> dlg_GEMSe::GetRoot();
d dlg_GEMSe::ChartDblClicked(int chartID);
d dlg_GEMSe::CalculateRefImgComp(QSharedPointer<iAImageTreeNode> node, LabelImagePointer refImg,
int labelCount);
d dlg_GEMSe::CalcRefImgComp(LabelImagePointer refImg);
d dlg_GEMSe::setColorTheme(iAColorTheme const * colorTheme, iALabelInfo const * labelInfo);
d dlg_GEMSe::ToggleAutoShrink();
d dlg_GEMSe::SetIconSize(int iconSize);
l dlg_GEMSe::SetRepresentativeType(int type, LabelImagePointer refImg);
d dlg_GEMSe::SetCorrectnessUncertaintyOverlay(bool enabled);
dlg_GEMSe::GetRepresentativeType();
ring dlg_GEMSe::GetSerializedHiddenCharts();
d dlg_GEMSe::SetSerializedHiddenCharts(QString const & hiddenCharts);
aredPointer<QVector<QSharedPointer<iASamplingResults> > > dlg_GEMSe::GetSamplings();
d dlg_GEMSe::setMagicLensCount(int count);
d dlg_GEMSe::freeMemory();
d dlg_GEMSe::SetProbabilityProbing(bool enabled);
d dlg_GEMSe::DataTFChanged();
ring dlg_GEMSe::GetLabelNames();
d dlg_GEMSe::UpdateResultFilter();
| 15ab83bd5466b5025bcd0e787cf1f7ca42d6ed7cecfc6abeae1f52717093e181 | 300 |
|
abergmeier | jedi_academy | codemp/win32/win_qgl_dx8.cpp | dllVertex4s |
static void dllVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
{
assert(0);
} |
void BeginSkinTextures( void );
void EndSkinTextures( void );
static int getTexMemSize(IDirect3DTexture8* mipmap);
static void _d3d_check(HRESULT err, const char* func);
static bool surfaceToBMP(LPDIRECT3DDEVICE8 pd3dDevice, LPDIRECT3DSURFACE8 lpSurface, const char *fname);
static void _fixupScreenCoords(GLint& x, GLint& y, GLsizei& width, GLsizei& height);
static D3DCMPFUNC _convertCompare(GLenum func);
static D3DBLEND _convertBlendFactor(GLenum factor);
static D3DPRIMITIVETYPE _convertPrimMode(GLenum mode);
static void _updateDrawStride(GLint normal, GLint tex0, GLint tex1);
static void _updateShader(bool normal, bool tex0, bool tex1);
static glwstate_t::TextureInfo* _getCurrentTexture(int stage);
static void _updateTextures(void);
static void _updateMatrices(void);
static int _getMaxVerts(void);
static int _getMaxIndices(void);
inline static DWORD* _restartDrawPacket(DWORD* packet, int verts);
inline static DWORD* _terminateDrawPacket(DWORD* packet);
inline static DWORD* _restartIndexPacket(DWORD* packet, int numIndices);
inline static DWORD* _terminateIndexPacket(DWORD* packet);
static void _handleDrawOverflow(void);
_XBOX
inline static DWORD* _restartDrawPacket(DWORD* packet, int verts);
inline static DWORD* _terminateDrawPacket(DWORD* packet);
static void _handleDrawOverflow(void);
static void _drawElementsV(GLsizei count, const GLushort* indices);
static void _drawElementsVN(GLsizei count, const GLushort* indices);
static void _drawElementsVC(GLsizei count, const GLushort* indices);
static void _drawElementsVCN(GLsizei count, const GLushort* indices);
static void _drawElementsVCT(GLsizei count, const GLushort* indices);
static void _drawElementsVCNT(GLsizei count, const GLushort* indices);
static void _drawElementsVCTT(GLsizei count, const GLushort* indices);
static void _drawElementsVCNTT(GLsizei count, const GLushort* indices);
static void _drawElementsVT(GLsizei count, const GLushort* indices);
static void _drawElementsVNT(GLsizei count, const GLushort* indices);
static void _drawElementsVTT(GLsizei count, const GLushort* indices);
static void _drawElementsVNTT(GLsizei count, const GLushort* indices);
static void _drawElementsLightShader(GLsizei count, const GLushort* indices);
static void _drawElementsBumpShader(GLsizei count, const GLushort* indices);
static void _drawElementsEnvShader(GLsizei count, const GLushort* indices);
static void _drawArraysV(GLsizei first, GLsizei last);
static void _drawArraysVN(GLsizei first, GLsizei last);
static void _drawArraysVC(GLsizei first, GLsizei last);
static void _drawArraysVCN(GLsizei first, GLsizei last);
static void _drawArraysVCT(GLsizei first, GLsizei last);
static void _drawArraysVCNT(GLsizei first, GLsizei last);
static void _drawArraysVCTT(GLsizei first, GLsizei last);
static void _drawArraysVCNTT(GLsizei first, GLsizei last);
static void _drawArraysVT(GLsizei first, GLsizei last);
static void _drawArraysVNT(GLsizei first, GLsizei last);
static void _drawArraysVTT(GLsizei first, GLsizei last);
static void _drawArraysVNTT(GLsizei first, GLsizei last);
static int _getDrawFunc(void);
static void dllAccum(GLenum op, GLfloat value);
static void dllAlphaFunc(GLenum func, GLclampf ref);
GLboolean dllAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences);
static void dllArrayElement(GLint i);
static void dllBeginEXT(GLenum mode, GLint verts, GLint colors, GLint normals, GLint tex0, GLint tex1);
static void dllBegin(GLenum mode);
GLboolean dllBeginFrame(void);
static void dllBeginShadow(void);
static void dllBindTexture(GLenum target, GLuint texture);
static void dllBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
static void dllBlendFunc(GLenum sfactor, GLenum dfactor);
static void dllCallList(GLuint lnum);
static void dllCallLists(GLsizei n, GLenum type, const GLvoid *lists);
static void dllClear(GLbitfield mask);
static void dllClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
static void dllClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
static void dllClearDepth(GLclampd depth);
static void dllClearIndex(GLfloat c);
static void dllClearStencil(GLint s);
static void dllClipPlane(GLenum plane, const GLdouble *equation);
static void setIntColor(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
static void setFloatColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
static void dllColor3b(GLbyte red, GLbyte green, GLbyte blue);
static void dllColor3bv(const GLbyte *v);
static void dllColor3d(GLdouble red, GLdouble green, GLdouble blue);
static void dllColor3dv(const GLdouble *v);
static void dllColor3f(GLfloat red, GLfloat green, GLfloat blue);
static void dllColor3fv(const GLfloat *v);
static void dllColor3i(GLint red, GLint green, GLint blue);
static void dllColor3iv(const GLint *v);
static void dllColor3s(GLshort red, GLshort green, GLshort blue);
static void dllColor3sv(const GLshort *v);
static void dllColor3ub(GLubyte red, GLubyte green, GLubyte blue);
static void dllColor3ubv(const GLubyte *v);
static void dllColor3ui(GLuint red, GLuint green, GLuint blue);
static void dllColor3uiv(const GLuint *v);
static void dllColor3us(GLushort red, GLushort green, GLushort blue);
static void dllColor3usv(const GLushort *v);
static void dllColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
static void dllColor4bv(const GLbyte *v);
static void dllColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
static void dllColor4dv(const GLdouble *v);
static void dllColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
static void dllColor4fv(const GLfloat *v);
static void dllColor4i(GLint red, GLint green, GLint blue, GLint alpha);
static void dllColor4iv(const GLint *v);
static void dllColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
static void dllColor4sv(const GLshort *v);
static void dllColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
static void dllColor4ubv(const GLubyte *v);
static void dllColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
static void dllColor4uiv(const GLuint *v);
static void dllColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
static void dllColor4usv(const GLushort *v);
static void dllColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
static void dllColorMaterial(GLenum face, GLenum mode);
static void dllColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
static void dllCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
static void dllCopyTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
static void dllCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
static void dllCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
static void dllCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
static void dllCullFace(GLenum mode);
static void dllDeleteLists(GLuint lnum, GLsizei range);
static void dllDeleteTextures(GLsizei n, const GLuint *textures);
static void dllDepthFunc(GLenum func);
static void dllDepthMask(GLboolean flag);
static void dllDepthRange(GLclampd zNear, GLclampd zFar);
static void setPresent(bool vsync);
static void setCap(GLenum cap, bool flag);
static void dllDisable(GLenum cap);
static void setArrayState(GLenum cap, bool state);
static void dllDisableClientState(GLenum array);
static void _convertQuadsToTris(GLint first, GLsizei count);
static void _cleanupQuadsToTris(void);
static void dllDrawArrays(GLenum mode, GLint first, GLsizei count);
static void dllDrawBuffer(GLenum mode);
static void PushIndices(GLsizei count, const GLushort *indices);
static void dllDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
static void dllDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
static void dllEdgeFlag(GLboolean flag);
static void dllEdgeFlagPointer(GLsizei stride, const GLvoid *pointer);
static void dllEdgeFlagv(const GLboolean *flag);
static void dllEnable(GLenum cap);
static void dllEnableClientState(GLenum array);
static void dllEnd(void);
static void dllEndFrame(void);
static void dllEndShadow(void);
static void dllEndList(void);
static void dllEvalCoord1d(GLdouble u);
static void dllEvalCoord1dv(const GLdouble *u);
static void dllEvalCoord1f(GLfloat u);
static void dllEvalCoord1fv(const GLfloat *u);
static void dllEvalCoord2d(GLdouble u, GLdouble v);
static void dllEvalCoord2dv(const GLdouble *u);
static void dllEvalCoord2f(GLfloat u, GLfloat v);
static void dllEvalCoord2fv(const GLfloat *u);
static void dllEvalMesh1(GLenum mode, GLint i1, GLint i2);
static void dllEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
static void dllEvalPoint1(GLint i);
static void dllEvalPoint2(GLint i, GLint j);
static void dllFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);
static void dllFinish(void);
static void dllFlush(void);
static void dllFlushShadow(void);
static D3DFOGMODE _convertFogMode(GLint param);
static void dllFogf(GLenum pname, GLfloat param);
static void dllFogfv(GLenum pname, const GLfloat *params);
static void dllFogi(GLenum pname, GLint param);
static void dllFogiv(GLenum pname, const GLint *params);
static void dllFrontFace(GLenum mode);
static void dllFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
GLuint dllGenLists(GLsizei range);
static void dllGenTextures(GLsizei n, GLuint *textures);
static void _getState(GLenum pname, T *params);
static void dllGetBooleanv(GLenum pname, GLboolean *params);
static void dllGetClipPlane(GLenum plane, GLdouble *equation);
static void dllGetDoublev(GLenum pname, GLdouble *params);
GLenum dllGetError(void);
static void dllGetFloatv(GLenum pname, GLfloat *params);
static void dllGetIntegerv(GLenum pname, GLint *params);
static void dllGetLightfv(GLenum light, GLenum pname, GLfloat *params);
static void dllGetLightiv(GLenum light, GLenum pname, GLint *params);
static void dllGetMapdv(GLenum target, GLenum query, GLdouble *v);
static void dllGetMapfv(GLenum target, GLenum query, GLfloat *v);
static void dllGetMapiv(GLenum target, GLenum query, GLint *v);
static void dllGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
static void dllGetMaterialiv(GLenum face, GLenum pname, GLint *params);
static void dllGetPixelMapfv(GLenum map, GLfloat *values);
static void dllGetPixelMapuiv(GLenum map, GLuint *values);
static void dllGetPixelMapusv(GLenum map, GLushort *values);
static void dllGetPointerv(GLenum pname, GLvoid* *params);
static void dllGetPolygonStipple(GLubyte *mask);
const GLubyte * dllGetString(GLenum name);
static void dllGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);
static void dllGetTexEnviv(GLenum target, GLenum pname, GLint *params);
static void dllGetTexGendv(GLenum coord, GLenum pname, GLdouble *params);
static void dllGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params);
static void dllGetTexGeniv(GLenum coord, GLenum pname, GLint *params);
static void dllGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
static void dllGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);
static void dllGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);
static void dllGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
static void dllGetTexParameteriv(GLenum target, GLenum pname, GLint *params);
static void dllHint(GLenum target, GLenum mode);
static void buildStrips(GLuint* len, GLsizei* num_lens, GLushort* dest, GLsizei* num_indices, const GLushort* src);
void renderObject_Light( int numIndexes, const glIndex_t *indexes );
void renderObject_Bump();
void renderObject_Env();
static void dllIndexedTriToStrip(GLsizei count, const GLushort *indices);
static void dllIndexMask(GLuint mask);
static void dllIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
static void dllIndexd(GLdouble c);
static void dllIndexdv(const GLdouble *c);
static void dllIndexf(GLfloat c);
static void dllIndexfv(const GLfloat *c);
static void dllIndexi(GLint c);
static void dllIndexiv(const GLint *c);
static void dllIndexs(GLshort c);
static void dllIndexsv(const GLshort *c);
static void dllIndexub(GLubyte c);
static void dllIndexubv(const GLubyte *c);
static void dllInitNames(void);
static void dllInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer);
GLboolean dllIsEnabled(GLenum cap);
GLboolean dllIsList(GLuint lnum);
GLboolean dllIsTexture(GLuint texture);
static void dllLightModelf(GLenum pname, GLfloat param);
static void dllLightModelfv(GLenum pname, const GLfloat *params);
static void dllLightModeli(GLenum pname, GLint param);
static void dllLightModeliv(GLenum pname, const GLint *params);
static void dllLightf(GLenum light, GLenum pname, GLfloat param);
static void dllLightfv(GLenum light, GLenum pname, const GLfloat *params);
static void dllLighti(GLenum light, GLenum pname, GLint param);
static void dllLightiv(GLenum light, GLenum pname, const GLint *params);
static void dllLineStipple(GLint factor, GLushort pattern);
static void dllLineWidth(GLfloat width);
static void dllListBase(GLuint base);
static void dllLoadIdentity(void);
static void dllLoadMatrixd(const GLdouble *m);
static void dllLoadMatrixf(const GLfloat *m);
static void dllLoadName(GLuint name);
static void dllLogicOp(GLenum opcode);
static void dllMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
static void dllMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
static void dllMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
static void dllMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
static void dllMapGrid1d(GLint un, GLdouble u1, GLdouble u2);
static void dllMapGrid1f(GLint un, GLfloat u1, GLfloat u2);
static void dllMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
static void dllMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
static void dllMaterialf(GLenum face, GLenum pname, GLfloat param);
static void dllMaterialfv(GLenum face, GLenum pname, const GLfloat *params);
static void dllMateriali(GLenum face, GLenum pname, GLint param);
static void dllMaterialiv(GLenum face, GLenum pname, const GLint *params);
static void dllMatrixMode(GLenum mode);
static void dllMultMatrixd(const GLdouble *m);
static void dllMultMatrixf(const GLfloat *m);
static void dllNewList(GLuint lnum, GLenum mode);
static void setNormal(float x, float y, float z);
static void dllNormal3b(GLbyte nx, GLbyte ny, GLbyte nz);
static void dllNormal3bv(const GLbyte *v);
static void dllNormal3d(GLdouble nx, GLdouble ny, GLdouble nz);
static void dllNormal3dv(const GLdouble *v);
static void dllNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
static void dllNormal3fv(const GLfloat *v);
static void dllNormal3i(GLint nx, GLint ny, GLint nz);
static void dllNormal3iv(const GLint *v);
static void dllNormal3s(GLshort nx, GLshort ny, GLshort nz);
static void dllNormal3sv(const GLshort *v);
static void dllNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
static void dllOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
static void dllPassThrough(GLfloat token);
static void dllPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values);
static void dllPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values);
static void dllPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values);
static void dllPixelStoref(GLenum pname, GLfloat param);
static void dllPixelStorei(GLenum pname, GLint param);
static void dllPixelTransferf(GLenum pname, GLfloat param);
static void dllPixelTransferi(GLenum pname, GLint param);
static void dllPixelZoom(GLfloat xfactor, GLfloat yfactor);
static void dllPointSize(GLfloat size);
static void dllPolygonMode(GLenum face, GLenum mode);
static void dllPolygonOffset(GLfloat factor, GLfloat units);
static void dllPolygonStipple(const GLubyte *mask);
static void dllPopAttrib(void);
static void dllPopClientAttrib(void);
static void dllPopMatrix(void);
static void dllPopName(void);
static void dllPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities);
static void dllPushAttrib(GLbitfield mask);
static void dllPushClientAttrib(GLbitfield mask);
static void dllPushMatrix(void);
static void dllPushName(GLuint name);
static void dllRasterPos2d(GLdouble x, GLdouble y);
static void dllRasterPos2dv(const GLdouble *v);
static void dllRasterPos2f(GLfloat x, GLfloat y);
static void dllRasterPos2fv(const GLfloat *v);
static void dllRasterPos2i(GLint x, GLint y);
static void dllRasterPos2iv(const GLint *v);
static void dllRasterPos2s(GLshort x, GLshort y);
static void dllRasterPos2sv(const GLshort *v);
static void dllRasterPos3d(GLdouble x, GLdouble y, GLdouble z);
static void dllRasterPos3dv(const GLdouble *v);
static void dllRasterPos3f(GLfloat x, GLfloat y, GLfloat z);
static void dllRasterPos3fv(const GLfloat *v);
static void dllRasterPos3i(GLint x, GLint y, GLint z);
static void dllRasterPos3iv(const GLint *v);
static void dllRasterPos3s(GLshort x, GLshort y, GLshort z);
static void dllRasterPos3sv(const GLshort *v);
static void dllRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
static void dllRasterPos4dv(const GLdouble *v);
static void dllRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
static void dllRasterPos4fv(const GLfloat *v);
static void dllRasterPos4i(GLint x, GLint y, GLint z, GLint w);
static void dllRasterPos4iv(const GLint *v);
static void dllRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);
static void dllRasterPos4sv(const GLshort *v);
static void dllReadBuffer(GLenum mode);
static void dllReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei twidth, GLsizei theight, GLvoid *pixels);
static void dllCopyBackBufferToTex();
static void dllCopyBackBufferToTexEXT(float width, float height, float u1, float v1, float u2, float v2);
static void dllRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
static void dllRectdv(const GLdouble *v1, const GLdouble *v2);
static void dllRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
static void dllRectfv(const GLfloat *v1, const GLfloat *v2);
static void dllRecti(GLint x1, GLint y1, GLint x2, GLint y2);
static void dllRectiv(const GLint *v1, const GLint *v2);
static void dllRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
static void dllRectsv(const GLshort *v1, const GLshort *v2);
GLint dllRenderMode(GLenum mode);
static void dllRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
static void dllRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
static void dllScaled(GLdouble x, GLdouble y, GLdouble z);
static void dllScalef(GLfloat x, GLfloat y, GLfloat z);
static void dllScissor(GLint x, GLint y, GLsizei width, GLsizei height);
static void dllSelectBuffer(GLsizei size, GLuint *buffer);
static void dllShadeModel(GLenum mode);
static void dllStencilFunc(GLenum func, GLint ref, GLuint mask);
static void dllStencilMask(GLuint mask);
static D3DSTENCILOP _convertStencilOp(GLenum op);
static void dllStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
static void dllTexCoord1d(GLdouble s);
static void dllTexCoord1dv(const GLdouble *v);
static void dllTexCoord1f(GLfloat s);
static void dllTexCoord1fv(const GLfloat *v);
static void dllTexCoord1i(GLint s);
static void dllTexCoord1iv(const GLint *v);
static void dllTexCoord1s(GLshort s);
static void dllTexCoord1sv(const GLshort *v);
static void setTexCoord(float s, float t);
static void dllTexCoord2d(GLdouble s, GLdouble t);
static void dllTexCoord2dv(const GLdouble *v);
static void dllTexCoord2f(GLfloat s, GLfloat t);
static void dllTexCoord2fv(const GLfloat *v);
static void dllTexCoord2i(GLint s, GLint t);
static void dllTexCoord2iv(const GLint *v);
static void dllTexCoord2s(GLshort s, GLshort t);
static void dllTexCoord2sv(const GLshort *v);
static void dllTexCoord3d(GLdouble s, GLdouble t, GLdouble r);
static void dllTexCoord3dv(const GLdouble *v);
static void dllTexCoord3f(GLfloat s, GLfloat t, GLfloat r);
static void dllTexCoord3fv(const GLfloat *v);
static void dllTexCoord3i(GLint s, GLint t, GLint r);
static void dllTexCoord3iv(const GLint *v);
static void dllTexCoord3s(GLshort s, GLshort t, GLshort r);
static void dllTexCoord3sv(const GLshort *v);
static void dllTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
static void dllTexCoord4dv(const GLdouble *v);
static void dllTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
static void dllTexCoord4fv(const GLfloat *v);
static void dllTexCoord4i(GLint s, GLint t, GLint r, GLint q);
static void dllTexCoord4iv(const GLint *v);
static void dllTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
static void dllTexCoord4sv(const GLshort *v);
static void dllTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
static void dllTexEnvf(GLenum target, GLenum pname, GLfloat param);
static void dllTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);
static void dllTexEnvi(GLenum target, GLenum pname, GLint param);
static void dllTexEnviv(GLenum target, GLenum pname, const GLint *params);
static void dllTexGend(GLenum coord, GLenum pname, GLdouble param);
static void dllTexGendv(GLenum coord, GLenum pname, const GLdouble *params);
static void dllTexGenf(GLenum coord, GLenum pname, GLfloat param);
static void dllTexGenfv(GLenum coord, GLenum pname, const GLfloat *params);
static void dllTexGeni(GLenum coord, GLenum pname, GLint param);
static void dllTexGeniv(GLenum coord, GLenum pname, const GLint *params);
static void dllTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
static void _texImageDDS(glwstate_t::TextureInfo* info, GLint numlevels, GLsizei width, GLsizei height, GLenum format, const GLvoid *pixels);
static void _texImageRGBA(glwstate_t::TextureInfo* info, GLint numlevels, GLint internalformat, GLsizei width, GLsizei height, GLenum format, const GLvoid *pixels);
static void dllTexImage2DEXT(GLenum target, GLint level, GLint numlevels, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
static void dllTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
static void dllTexParameteri(GLenum target, GLenum pname, GLint param);
static void dllTexParameterf(GLenum target, GLenum pname, GLfloat param);
static void dllTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
static void dllTexParameteriv(GLenum target, GLenum pname, const GLint *params);
static void dllTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
static void dllTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
static void dllTranslated(GLdouble x, GLdouble y, GLdouble z);
static void dllTranslatef(GLfloat x, GLfloat y, GLfloat z);
static void setVertex(float x, float y, float z);
static void dllVertex2d(GLdouble x, GLdouble y);
static void dllVertex2dv(const GLdouble *v);
static void dllVertex2f(GLfloat x, GLfloat y);
static void dllVertex2fv(const GLfloat *v);
static void dllVertex2i(GLint x, GLint y);
static void dllVertex2iv(const GLint *v);
static void dllVertex2s(GLshort x, GLshort y);
static void dllVertex2sv(const GLshort *v);
static void dllVertex3d(GLdouble x, GLdouble y, GLdouble z);
static void dllVertex3dv(const GLdouble *v);
static void dllVertex3f(GLfloat x, GLfloat y, GLfloat z);
static void dllVertex3fv(const GLfloat *v);
static void dllVertex3i(GLint x, GLint y, GLint z);
static void dllVertex3iv(const GLint *v);
static void dllVertex3s(GLshort x, GLshort y, GLshort z);
static void dllVertex3sv(const GLshort *v);
static void dllVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
static void dllVertex4dv(const GLdouble *v);
static void dllVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
static void dllVertex4fv(const GLfloat *v);
static void dllVertex4i(GLint x, GLint y, GLint z, GLint w);
static void dllVertex4iv(const GLint *v);
static void dllVertex4sv(const GLshort *v);
static void dllVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
static void dllViewport(GLint x, GLint y, GLsizei width, GLsizei height);
static void dllMultiTexCoord2fARB(GLenum texture, GLfloat s, GLfloat t);
static void dllActiveTextureARB(GLenum texture);
static void dllClientActiveTextureARB(GLenum texture);
void QGL_Shutdown( void );
qboolean QGL_Init( const char *dllname );
void QGL_EnableLogging( qboolean enable );
static void D3D_AutoPerfData_f( void );
static void _createWindow(int width, int height, int colorbits, qboolean cdsFullscreen);
static LightEffects *getLightEffects( void );
void GLW_Init(int width, int height, int colorbits, qboolean cdsFullscreen);
void GLW_Shutdown(void);
bool CreateVertexShader( const CHAR* strFilename, const DWORD* pdwVertexDecl, DWORD* pdwVertexShader );
bool CreatePixelShader( const CHAR* strFilename, DWORD* pdwPixelShader );
| 1893716aa750024aa14e40e7344410f8b8b219de91ab75080d99769e907ff8f6 | 84 |
|
AzureZhao | DsbyLiteExample | QFtpSeriesDown/qftp.cpp | QFtpDTP::clearError | nline void QFtpDTP::clearError()
{
err.clear();
}
| ool sendCommand(const QString &cmd);
String currentCommand();
FtpCommand::QFtpCommand(QFtp::Command cmd, QStringList raw, const QByteArray &ba);
FtpCommand::QFtpCommand(QFtp::Command cmd, QStringList raw, QIODevice *dev);
FtpCommand::~QFtpCommand();
FtpDTP::QFtpDTP(QFtpPI *p, QObject *parent);
oid QFtpDTP::setData(QByteArray *ba);
oid QFtpDTP::setDevice(QIODevice *dev);
oid QFtpDTP::setBytesTotal(qint64 bytes);
oid QFtpDTP::connectToHost(const QString & host, quint16 port);
nt QFtpDTP::setupListener(const QHostAddress &address);
oid QFtpDTP::waitForConnection();
TcpSocket::SocketState QFtpDTP::state();
int64 QFtpDTP::bytesAvailable();
int64 QFtpDTP::read(char *data, qint64 maxlen);
ByteArray QFtpDTP::readAll();
oid QFtpDTP::writeData();
oid QFtpDTP::dataReadyRead();
nline bool QFtpDTP::hasError();
nline QString QFtpDTP::errorMessage();
oid QFtpDTP::abortConnection();
tatic void _q_fixupDateTime(QDateTime *dateTime);
tatic void _q_parseUnixDir(const QStringList &tokens, const QString &userName, QUrlInfo *info);
tatic void _q_parseDosDir(const QStringList &tokens, const QString &userName, QUrlInfo *info);
ool QFtpDTP::parseDir(const QByteArray &buffer, const QString &userName, QUrlInfo *info);
oid QFtpDTP::socketConnected();
oid QFtpDTP::socketReadyRead();
oid QFtpDTP::socketError(QAbstractSocket::SocketError e);
oid QFtpDTP::socketConnectionClosed();
oid QFtpDTP::socketBytesWritten(qint64 bytes);
oid QFtpDTP::setupSocket();
oid QFtpDTP::clearData();
FtpPI::QFtpPI(QObject *parent);
oid QFtpPI::connectToHost(const QString &host, quint16 port);
ool QFtpPI::sendCommands(const QStringList &cmds);
oid QFtpPI::clearPendingCommands();
oid QFtpPI::abort();
oid QFtpPI::hostFound();
oid QFtpPI::connected();
oid QFtpPI::connectionClosed();
oid QFtpPI::delayedCloseFinished();
oid QFtpPI::error(QAbstractSocket::SocketError e);
oid QFtpPI::readyRead();
ool QFtpPI::processReply();
ool QFtpPI::startNextCmd();
oid QFtpPI::dtpConnectState(int s);
nline QFtpPrivate(QFtp *owner);
nt QFtpPrivate::addCommand(QFtpCommand *cmd);
Ftp::QFtp(QObject *parent);
nt QFtp::connectToHost(const QString &host, quint16 port);
nt QFtp::login(const QString &user, const QString &password);
nt QFtp::close();
nt QFtp::setTransferMode(TransferMode mode);
nt QFtp::setProxy(const QString &host, quint16 port);
nt QFtp::list(const QString &dir);
nt QFtp::cd(const QString &dir);
nt QFtp::get(const QString &file, QIODevice *dev, qulonglong size, TransferType type);
nt QFtp::put(const QByteArray &data, const QString &file, TransferType type);
nt QFtp::put(QIODevice *dev, const QString &file, TransferType type);
nt QFtp::remove(const QString &file);
nt QFtp::mkdir(const QString &dir);
nt QFtp::rmdir(const QString &dir);
nt QFtp::rename(const QString &oldname, const QString &newname);
nt QFtp::rawCommand(const QString &command);
int64 QFtp::bytesAvailable();
int64 QFtp::read(char *data, qint64 maxlen);
ByteArray QFtp::readAll();
oid QFtp::abort();
nt QFtp::currentId();
Ftp::Command QFtp::currentCommand();
IODevice* QFtp::currentDevice();
ool QFtp::hasPendingCommands();
oid QFtp::clearPendingCommands();
Ftp::State QFtp::state();
Ftp::Error QFtp::error();
String QFtp::errorString();
oid QFtpPrivate::_q_startNextCommand();
oid QFtpPrivate::_q_piFinished(const QString&);
oid QFtpPrivate::_q_piError(int errorCode, const QString &text);
oid QFtpPrivate::_q_piConnectState(int connectState);
oid QFtpPrivate::_q_piFtpReply(int code, const QString &text);
Ftp::~QFtp();
| 9b3362728c40db123b57dc8994a5483a7681188ff8a28c1bf17958b6cdf9af9f | 58 |
|
Entropy-Soldier | ges-legacy-code | game/sdk/server/colorcorrection.cpp | CColorCorrection::FadeOut | void CColorCorrection::FadeOut ( void )
{
m_bEnabled = false;
m_flTimeStartFadeOut = gpGlobals->curtime;
m_flStartFadeOutWeight = m_flCurWeight;
SetNextThink ( gpGlobals->curtime + COLOR_CORRECTION_ENT_THINK_RATE, s_pFadeOutContextThink );
}
| int CColorCorrection::UpdateTransmitState();
void CColorCorrection::Spawn( void );
void CColorCorrection::Activate( void );
void CColorCorrection::FadeIn ( void );
void CColorCorrection::FadeInThink( void );
void CColorCorrection::FadeOutThink( void );
void CColorCorrection::InputEnable( inputdata_t &inputdata );
void CColorCorrection::InputDisable( inputdata_t &inputdata );
void CColorCorrection::InputSetFadeInDuration( inputdata_t& inputdata );
void CColorCorrection::InputSetFadeOutDuration( inputdata_t& inputdata );
| 84fc6979ad509951f2605341f181239a7033e4332956a67da435aca1ad6f1f50 | 246 |
|
fhchina | soui | controls.extend/SChromeTabCtrl.cpp | SChromeTabCtrl::~SChromeTabCtrl | SChromeTabCtrl::~SChromeTabCtrl(void)
{
} | SChromeTab::SChromeTab(SChromeTabCtrl* pHost);
void SChromeTab::MoveTo( const CRect & rcEnd );
void SChromeTab::OnAnimatorState( int percent );
void SChromeTab::OnMouseMove(UINT nFlags,CPoint pt);
void SChromeTab::OnLButtonUp(UINT nFlags,CPoint pt);
void SChromeTab::OnLButtonDown(UINT nFlags,CPoint pt);
virtual void OnFinalRelease();
SChromeTabCtrl::SChromeTabCtrl(void);
int SChromeTabCtrl::ChangeTabPos(SChromeTab* pCurMove,CPoint ptCur);
BOOL SChromeTabCtrl::CreateChildren( pugi::xml_node xmlNode );
ildrenPosition();
Click( EventArgs *pEvt );
b(int iTab);
b(SChromeTab *pTab);
seTabClick( EventArgs *pEvt );
ck( EventArgs *pEvt );
b( LPCTSTR pszTitle,int iPos );
for(UINT i=0; i< m_lstTabOrder.GetCount();
{
int nRet = __super::OnCreate(NULL);
GetContainer();
l bSendNotify);
;
dex );
| 3c05e05e49369e410921501af8a56689c48f7e6e5d4f4fb1810cc2ec1804a3e6 | 50 |
|
OpenBoard-org | OpenBoard | src/domain/UBGraphicsStrokesGroup.cpp | UBGraphicsStrokesGroup::mouseReleaseEvent | d UBGraphicsStrokesGroup::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
Delegate()->commitUndoStep();
event->accept();
Delegate()->mouseReleaseEvent(event);
QGraphicsItemGroup::mouseReleaseEvent(event);
}
UB | raphicsStrokesGroup::UBGraphicsStrokesGroup(QGraphicsItem *parent);
raphicsStrokesGroup::~UBGraphicsStrokesGroup();
d UBGraphicsStrokesGroup::setUuid(const QUuid &pUuid);
d UBGraphicsStrokesGroup::setColor(const QColor &color, colorType pColorType);
lor UBGraphicsStrokesGroup::color(colorType pColorType);
d UBGraphicsStrokesGroup::mousePressEvent(QGraphicsSceneMouseEvent *event);
d UBGraphicsStrokesGroup::mouseMoveEvent(QGraphicsSceneMouseEvent *event);
tem* UBGraphicsStrokesGroup::deepCopy();
d UBGraphicsStrokesGroup::copyItemParameters(UBItem *copy);
d UBGraphicsStrokesGroup::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
riant UBGraphicsStrokesGroup::itemChange(GraphicsItemChange change, const QVariant &value);
interPath UBGraphicsStrokesGroup::shape();
| d203e66a2f82a04fb910c5688df221c4977b058e1589c504b9217a9b6a90d570 | 232 |
|
ellio167 | lammps | unittest/cplusplus/test_lammps_class.cpp | LAMMPS_kokkos | LAMMPS_kokkos() : lmp(nullptr)
{
const char *args[] = {"LAMMPS_test"};
char **argv = (char **)args;
int argc = sizeof(args) / sizeof(char *);
int flag;
MPI_Initialized(&flag);
if (!flag) MPI_Init(&argc, &argv);
} | LAMMPS_plain();
void SetUp();
void TearDown();
TEST_F(LAMMPS_plain, InitMembers);
TEST_F(LAMMPS_plain, TestStyles);
LAMMPS_omp();
void SetUp();
TEST_F(LAMMPS_omp, InitMembers);
void SetUp();
TEST_F(LAMMPS_kokkos, InitMembers);
TEST(LAMMPS_init, OpenMP);
TEST(LAMMPS_init, NoOpenMP);
| 2cbf910b1e5196d76502954dafb49cbd3b8f6c282c2af6e3a3bcb716d76679a0 | 287 |
|
h0tw1r3 | mame | src/mame/machine/bebox.cpp |
WRITE64_MEMBER |
WRITE64_MEMBER(bebox_state::scsi53c810_w )
{
int reg = offset*8;
if (!(mem_mask & U64(0xff00000000000000))) {
m_lsi53c810->lsi53c810_reg_w(reg+0, data >> 56);
}
if (!(mem_mask & U64(0x00ff000000000000))) {
m_lsi53c810->lsi53c810_reg_w(reg+1, data >> 48);
}
if (!(mem_mask & U64(0x0000ff0000000000))) {
m_lsi53c810->lsi53c810_reg_w(reg+2, data >> 40);
}
if (!(mem_mask & U64(0x000000ff00000000))) {
m_lsi53c810->lsi53c810_reg_w(reg+3, data >> 32);
}
if (!(mem_mask & U64(0x00000000ff000000))) {
m_lsi53c810->lsi53c810_reg_w(reg+4, data >> 24);
}
if (!(mem_mask & U64(0x0000000000ff0000))) {
m_lsi53c810->lsi53c810_reg_w(reg+5, data >> 16);
}
if (!(mem_mask & U64(0x000000000000ff00))) {
m_lsi53c810->lsi53c810_reg_w(reg+6, data >> 8);
}
if (!(mem_mask & U64(0x00000000000000ff))) {
m_lsi53c810->lsi53c810_reg_w(reg+7, data >> 0);
}
} |
static void bebox_mbreg32_w(UINT32 *target, UINT64 data, UINT64 mem_mask);
READ64_MEMBER(bebox_state::bebox_cpu0_imask_r );
READ64_MEMBER(bebox_state::bebox_cpu1_imask_r );
READ64_MEMBER(bebox_state::bebox_interrupt_sources_r );
WRITE64_MEMBER(bebox_state::bebox_cpu0_imask_w );
WRITE64_MEMBER(bebox_state::bebox_cpu1_imask_w );
READ64_MEMBER(bebox_state::bebox_crossproc_interrupts_r );
WRITE64_MEMBER(bebox_state::bebox_crossproc_interrupts_w );
WRITE64_MEMBER(bebox_state::bebox_processor_resets_w );
void bebox_state::bebox_update_interrupts();
void bebox_state::bebox_set_irq_bit(unsigned int interrupt_bit, int val);
WRITE_LINE_MEMBER( bebox_state::fdc_interrupt );
READ64_MEMBER(bebox_state::bebox_interrupt_ack_r );
WRITE_LINE_MEMBER(bebox_state::bebox_pic8259_master_set_int_line);
WRITE_LINE_MEMBER(bebox_state::bebox_pic8259_slave_set_int_line);
READ8_MEMBER(bebox_state::get_slave_ack);
WRITE_LINE_MEMBER(bebox_state::bebox_ide_interrupt);
READ8_MEMBER(bebox_state::bebox_page_r);
WRITE8_MEMBER(bebox_state::bebox_page_w);
WRITE8_MEMBER(bebox_state::bebox_80000480_w);
READ8_MEMBER(bebox_state::bebox_80000480_r);
WRITE_LINE_MEMBER(bebox_state::bebox_dma_hrq_changed);
READ8_MEMBER(bebox_state::bebox_dma_read_byte );
WRITE8_MEMBER(bebox_state::bebox_dma_write_byte );
READ8_MEMBER(bebox_state::bebox_dma8237_fdc_dack_r);
WRITE8_MEMBER(bebox_state::bebox_dma8237_fdc_dack_w);
WRITE_LINE_MEMBER(bebox_state::bebox_dma8237_out_eop);
static void set_dma_channel(running_machine &machine, int channel, int state);
WRITE_LINE_MEMBER(bebox_state::bebox_timer0_w);
READ8_MEMBER(bebox_state::bebox_flash_r );
WRITE8_MEMBER(bebox_state::bebox_flash_w );
READ64_MEMBER(bebox_state::scsi53c810_r );
UINT32 scsi53c810_pci_read(device_t *busdevice, device_t *device, int function, int offset, UINT32 mem_mask);
void scsi53c810_pci_write(device_t *busdevice, device_t *device, int function, int offset, UINT32 data, UINT32 mem_mask);
void bebox_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
void bebox_state::machine_reset();
void bebox_state::machine_start();
DRIVER_INIT_MEMBER(bebox_state,bebox);
| fca4c48c443aa57788eefde1a337d15352660dbfeb270dd2f458ad7a21bea31e | 866 |
|
freneticmonkey | epsilonc | source/render/gizmos/GizmoManager.cpp | GizmoManager::DrawSphere | void GizmoManager::DrawSphere(Vector3 position, float radius)
{
GizmoOperation::Ptr newSphere = GizmoOperation::Create();
newSphere->colour = GizmoManager::GetInstance().gizmoColour;
newSphere->SetLife(GizmoManager::GetInstance().gizmoLife);
newSphere->vector[0] = position;
newSphere->value[0] = radius;
GizmoManager::GetInstance().gizmoSphere->QueueOperation(newSphere);
} | GizmoManager::GizmoManager();
GizmoManager::~GizmoManager(void);
void GizmoManager::Setup(void);
GizmoManager & GizmoManager::AddGizmo(GizmoType * newGizmo);
void GizmoManager::Draw();
void GizmoManager::Destroy();
void GizmoManager::OnUpdate(float el);
void GizmoManager::SetColour(Colour newColour);
void GizmoManager::SetLife(float newLife);
void GizmoManager::DrawCube(Vector3 position, Vector3 size);
void GizmoManager::DrawLine(Vector3 from, Vector3 to);
void GizmoManager::DrawAxisMatrix(Matrix4 mat);
void GizmoManager::DrawAxisVectors(Vector3 pos, Vector3 right, Vector3 up, Vector3 forward);
| ac36febac5e4e7a5172bd6d3c493fcf7a8a1d54b57c806616cf83bb1d3cfbdf3 | 391 |
|
Andrey-Pavlov | robomongo | src/third-party/mongodb/src/mongo/dbtests/documentsourcetests.cpp | run | void run() {
ASSERT_THROWS( createGroup( spec() ), UserException );
} | BSONObj toBson( const intrusive_ptr<DocumentSource>& source );
~CollectionBase();
set<string> arrayToSet(const char* (&array);
void run();
Base();
void createSource();
void run();
void assertNumClientCursors( unsigned int expected );
void run();
void run();
void run();
PendingValue( int initialValue );
void set( int newValue );
void await( int expectedValue );
WriterClientScope();
~WriterClientScope();
void runDummyWriter();
void run();
void createLimit( int limit );
void run();
void run();
void run();
void createGroup( const BSONObj &spec, bool inShard = false );
void assertExhausted( const intrusive_ptr<DocumentSource> &source );
void assertRoundTrips( const intrusive_ptr<DocumentSource>& group );
void run();
virtual BSONObj expected();
void run();
BSONObj spec();
BSONObj spec();
BSONObj spec();
BSONObj spec();
bool operator();
void run();
void runSharded( bool sharded );
virtual BSONObj expectedResultSet();
intrusive_ptr<DocumentSource> createMerger();
void checkResultSet( const intrusive_ptr<DocumentSource> &sink );
void run();
void run();
void run();
void populateData();
virtual BSONObj groupSpec();
void populateData();
virtual BSONObj groupSpec();
void populateData();
virtual BSONObj groupSpec();
void populateData();
virtual BSONObj groupSpec();
void populateData();
virtual BSONObj groupSpec();
virtual string expectedResultSetString();
void populateData();
virtual BSONObj groupSpec();
void populateData();
virtual BSONObj groupSpec();
void populateData();
virtual BSONObj groupSpec();
void run();
string expectedResultSetString();
void run();
BSONObj groupSpec();
void run();
BSONObj groupSpec();
void createProject( const BSONObj& projection = BSON( "a" << true );
void assertExhausted();
void checkBsonRepresentation( const BSONObj& spec );
void run();
void run();
void run();
void run();
void run();
void run();
void run();
void run();
void run();
void run();
void createSort( const BSONObj& sortKey = BSON( "a" << 1 );
void assertExhausted();
void checkBsonRepresentation( const BSONObj& spec );
void run();
void run();
void run();
intrusive_ptr<DocumentSource> mkLimit(int limit);
void run();
virtual BSONObj expectedResultSet();
void run();
void run();
void exhaust();
void populateData();
void populateData();
void run();
void populateData();
void populateData();
void populateData();
string expectedResultSetString();
void populateData();
string expectedResultSetString();
void populateData();
string expectedResultSetString();
void populateData();
string expectedResultSetString();
void populateData();
string expectedResultSetString();
void populateData();
string expectedResultSetString();
void populateData();
string expectedResultSetString();
void populateData();
string expectedResultSetString();
void populateData();
string expectedResultSetString();
void run();
void createUnwind( const string& unwindFieldPath = "$a" );
void assertExhausted();
void checkBsonRepresentation( const BSONObj& spec );
void run();
void run();
void run();
virtual BSONObj expectedResultSet();
void run();
void iterateAll();
void populateData();
void populateData();
void populateData();
void populateData();
void populateData();
void populateData();
void populateData();
void populateData();
void populateData();
void populateData();
void populateData();
string expectedResultSetString();
void populateData();
string expectedResultSetString();
void populateData();
void populateData();
string expectedResultSetString();
void populateData();
string expectedResultSetString();
void populateData();
string expectedResultSetString();
void run();
void run();
void setupTests();
| c2c24c9996ec19bea069b001fea3853311ec9647b3f1fce4f982e6e7a869e6c7 | 98 |
|
NETMF | llilum | Zelig/Zelig/CompileTime/Llvm.NET/LibLLVM/LlvmDebugInfo.cpp | LLVMDIBuilderCreateClassType | LLVMValueRef LLVMDIBuilderCreateClassType( LLVMDIBuilderRef Builder
, LLVMValueRef Scope
, const char* Name
, LLVMValueRef File
, unsigned LineNumber
, uint64_t SizeInBits
, uint64_t AlignInBits
, uint64_t OffsetInBits
, unsigned Flags
, LLVMValueRef DerivedFrom
, LLVMValueRef Elements
, LLVMValueRef VTableHolder
, LLVMValueRef TemplateParms
, const char *UniqueId
)
{
auto bldr = unwrap( Builder );
auto unwrapped = bldr->createClassType( unwrapDI<DIDescriptor>( Scope )
, Name
, unwrapDI<DIFile>( File )
, LineNumber
, SizeInBits
, AlignInBits
, OffsetInBits
, Flags
, unwrapDI<DIType>( DerivedFrom )
, unwrapDI<DIArray>( Elements )
, unwrapDI<DIType>( VTableHolder )
, unwrapDI<MDNode*>( TemplateParms )
, UniqueId
);
return wrap( unwrapped );
} | LLVMDIBuilderRef LLVMDIBuilderCreate( LLVMModuleRef M );
void LLVMDIBuilderDispose( LLVMDIBuilderRef Builder );
void LLVMDIBuilderFinalize( LLVMDIBuilderRef Builder );
LLVMValueRef LLVMDIBuilderCreateOpDeref( LLVMTypeRef IntTy );
LLVMValueRef LLVMDIBuilderCreateOpPlus( LLVMTypeRef IntTy );
| 1088d74c000cd8fd89276ff3d83dbd06188b042e0938f6595f9fa4dcfcd4e72b | 2,037 |
|
Astroua | CARTAvis | carta/cpp/core/Plot2D/Plot2DGenerator.cpp | Plot2DGenerator::setCurveName |
void Plot2DGenerator::setCurveName( const QString& oldName, const QString& newName ){
std::shared_ptr<Plot2D> plotData = _findData( oldName );
if ( plotData ){
plotData->setId( newName );
}
} |
Plot2DGenerator::Plot2DGenerator( PlotType plotType );
void Plot2DGenerator::clearData();
void Plot2DGenerator::clearSelection();
void Plot2DGenerator::clearSelectionColor();
QString Plot2DGenerator::getAxisUnitsY();
std::pair<double,double> Plot2DGenerator::getPlotBoundsY( const QString& id, bool* valid );
QString Plot2DGenerator::getPlotTitle();
std::pair<double,double> Plot2DGenerator::getRange( bool* valid );
std::pair<double,double> Plot2DGenerator::getRangeColor(bool* valid );
bool Plot2DGenerator::isSelectionOnCanvas( int xPos );
std::shared_ptr<Plot2D> Plot2DGenerator::_findData( const QString& id );
double Plot2DGenerator::getVLinePosition( bool* valid );
std::pair<double,double> Plot2DGenerator::getWorldPt(int x, int y, int width, int height );
void Plot2DGenerator::removeData( const QString& dataName );
void Plot2DGenerator::setAxisXRange( double min, double max );
void Plot2DGenerator::setColor( QColor color, const QString& id );
void Plot2DGenerator::setColored( bool colored, const QString& id );
void Plot2DGenerator::setGridLines( bool showGrid );
void Plot2DGenerator::setLegendExternal( bool externalLegend );
void Plot2DGenerator::setLegendLocation( const QString& position );
void Plot2DGenerator::setLegendLine( bool showLegendLine );
void Plot2DGenerator::setLegendVisible( bool visible );
void Plot2DGenerator::setLogScale(bool logScale);
void Plot2DGenerator::setMarkerLine( double xPos );
void Plot2DGenerator::setPipeline( std::shared_ptr<Carta::Lib::PixelPipeline::CustomizablePixelPipeline> pipeline);
void Plot2DGenerator::setRange(double min, double max);
void Plot2DGenerator::setRangeColor(double min, double max);
void Plot2DGenerator::setRangePixels(double min, double max);
void Plot2DGenerator::setRangePixelsColor(double min, double max);
void Plot2DGenerator::setSelectionMode(bool selection);
void Plot2DGenerator::setSelectionModeColor( bool selection );
bool Plot2DGenerator::setSize( int width, int height );
void Plot2DGenerator::setLineStyle( const QString& style, const QString& id );
void Plot2DGenerator::setStyle( const QString& style, const QString& id );
void Plot2DGenerator::setTitleAxisX( const QString& title);
void Plot2DGenerator::setTitleAxisY( const QString& title);
QImage Plot2DGenerator::toImage( int width, int height );
void Plot2DGenerator::_updateLegend();
void Plot2DGenerator::_updateScales();
Plot2DGenerator::~Plot2DGenerator();
| fa3dc6c928e3cde9ac1010435d571325c751205485d56597ca15df5eb429990b | 212 |
|
PopCap | GameIdea | Engine/Source/ThirdParty/PhysX/APEX-1.3/module/clothing/src/ClothingAssetAuthoring.cpp | ClothingAssetAuthoring::generateTetraMap |
bool ClothingAssetAuthoring::generateTetraMap(const NxAbstractMeshDescription* targetMeshes, PxU32 numTargetMeshes,
ClothingPhysicalMeshParametersNS::PhysicalMesh_Type& physicalMesh, PxU32*
,
NxParamArray<ClothingGraphicalLodParametersNS::TetraLink_Type>& result, IProgressListener* progress) const
{
PxU32 numGraphicalVertices = 0;
bool haveAllBuffers = true;
for (PxU32 submeshIndex = 0; submeshIndex < numTargetMeshes; submeshIndex++)
{
numGraphicalVertices += targetMeshes[submeshIndex].numVertices;
bool hasAllBuffers = true;
hasAllBuffers &= targetMeshes[submeshIndex].pPosition != NULL;
hasAllBuffers &= targetMeshes[submeshIndex].pNormal != NULL;
haveAllBuffers &= hasAllBuffers;
if (!hasAllBuffers)
{
APEX_INTERNAL_ERROR("Render mesh asset does not have either position or normal for submesh %d!", submeshIndex);
}
}
if (!haveAllBuffers)
{
return false;
}
result.resize(numGraphicalVertices);
memset(result.begin(), 0, sizeof(ClothingGraphicalLodParametersNS::TetraLink_Type) * numGraphicalVertices);
PxU32 submeshVertexOffset = 0;
const PxU32* physicalIndices = physicalMesh.indices.buf;
const PxVec3* physicalPositions = physicalMesh.vertices.buf;
for (PxU32 targetIndex = 0; targetIndex < numTargetMeshes; targetIndex++)
{
const PxU32 numVertices = targetMeshes[targetIndex].numVertices;
const PxVec3* positions = targetMeshes[targetIndex].pPosition;
const PxVec3* normals = targetMeshes[targetIndex].pNormal;
for (PxU32 vertexIndex = 0; vertexIndex < numVertices; vertexIndex++)
{
const PxU32 index = vertexIndex + submeshVertexOffset;
if (progress != NULL && (index & 0x3f) == 0)
{
const PxI32 percent = PxI32(100 * index / numGraphicalVertices);
progress->setProgress(percent);
}
const PxVec3 position = positions[vertexIndex];
PxF32 bestWorstBary = FLT_MAX;
PxI32 bestTet = -1;
PxVec3 bestBary(0.0f, 0.0f, 0.0f);
for (PxU32 j = 0; j < physicalMesh.numIndices; j += 4)
{
PxVec3 p[4];
for (PxU32 k = 0; k < 4; k++)
{
p[k] = physicalPositions[physicalIndices[j + k]];
}
PxVec3 bary;
generateBarycentricCoordinatesTet(p[0], p[1], p[2], p[3], position, bary);
PxF32 baryU = 1 - bary.x - bary.y - bary.z;
PxF32 worstBary = 0.0f;
worstBary = PxMax(worstBary, -bary.x);
worstBary = PxMax(worstBary, -bary.y);
worstBary = PxMax(worstBary, -bary.z);
worstBary = PxMax(worstBary, -baryU);
worstBary = PxMax(worstBary, bary.x - 1);
worstBary = PxMax(worstBary, bary.y - 1);
worstBary = PxMax(worstBary, bary.z - 1);
worstBary = PxMax(worstBary, baryU - 1);
if (worstBary < bestWorstBary)
{
bestWorstBary = worstBary;
bestTet = (physx::PxI32)j;
bestBary = bary;
}
}
PX_ASSERT(result[index].tetraIndex0 == 0);
result[index].vertexBary = bestBary;
result[index].tetraIndex0 = (physx::PxU32)bestTet;
PxVec3 normal(1.0f, 0.0f, 0.0f);
if (normals != NULL)
{
normal = normals[vertexIndex];
normal.normalize();
}
const PxVec3& pa = physicalPositions[physicalIndices[bestTet + 0]];
const PxVec3& pb = physicalPositions[physicalIndices[bestTet + 1]];
const PxVec3& pc = physicalPositions[physicalIndices[bestTet + 2]];
const PxVec3& pd = physicalPositions[physicalIndices[bestTet + 3]];
PxBounds3 bounds;
bounds.setEmpty();
bounds.include(pa);
bounds.include(pb);
bounds.include(pc);
bounds.include(pd);
const PxF32 offset = (bounds.minimum - bounds.maximum).magnitude() * 0.01f;
generateBarycentricCoordinatesTet(pa, pb, pc, pd, position + normal * offset, result[index].normalBary);
}
submeshVertexOffset += numVertices;
}
return true;
} | TriangleGreater_3(PxU32* deformableIndices, NxClothingConstrainCoefficients* constrainCoeffs);
inline bool operator();
TriangleGreater_4(PxU32* deformableIndices, NxClothingConstrainCoefficients* constrainCoeffs);
inline bool operator();
bool operator();
bool operator();
ClothingAssetAuthoring::ClothingAssetAuthoring(ModuleClothing* module, NxResourceList& list);
ClothingAssetAuthoring::ClothingAssetAuthoring(ModuleClothing* module, NxResourceList& list, const char* name);
ClothingAssetAuthoring::ClothingAssetAuthoring(ModuleClothing* module, NxResourceList& list, NxParameterized::Interface* params, const char* name);
void ClothingAssetAuthoring::release();
bool ClothingAssetAuthoring::checkSetMeshesInput(PxU32 lod, NxClothingPhysicalMesh* nxPhysicalMesh, PxU32& graphicalLodIndex);
void ClothingAssetAuthoring::sortPhysicalMeshes();
bool ClothingAssetAuthoring::addPlatformToGraphicalLod(PxU32 lod, NxPlatformTag platform);
bool ClothingAssetAuthoring::removePlatform(PxU32 lod, NxPlatformTag platform);
PxU32 ClothingAssetAuthoring::getNumPlatforms(PxU32 lod);
NxPlatformTag ClothingAssetAuthoring::getPlatform(PxU32 lod, PxU32 i);
bool ClothingAssetAuthoring::prepareForPlatform(NxPlatformTag platform);
PxU32 ClothingAssetAuthoring::getNumLods();
PxI32 ClothingAssetAuthoring::getLodValue(PxU32 lod);
void ClothingAssetAuthoring::clearMeshes();
NxClothingPhysicalMesh* ClothingAssetAuthoring::getClothingPhysicalMesh(PxU32 graphicalLod);
bool ClothingAssetAuthoring::getBoneBindPose(PxU32 boneIndex, PxMat44& bindPose);
bool ClothingAssetAuthoring::setBoneBindPose(PxU32 boneIndex, const PxMat44& bindPose);
void ClothingAssetAuthoring::setBoneInfo(PxU32 boneIndex, const char* boneName, const PxMat44& bindPose, PxI32 parentIndex);
void ClothingAssetAuthoring::setRootBone(const char* boneName);
PxU32 ClothingAssetAuthoring::addBoneConvex(const char* boneName, const PxVec3* positions, PxU32 numPositions);
PxU32 ClothingAssetAuthoring::addBoneConvex(PxU32 boneIndex, const PxVec3* positions, PxU32 numPositions);
void ClothingAssetAuthoring::addBoneCapsule(const char* boneName, PxF32 capsuleRadius, PxF32 capsuleHeight, const PxMat44& localPose);
void ClothingAssetAuthoring::addBoneCapsule(PxU32 boneIndex, PxF32 capsuleRadius, PxF32 capsuleHeight, const PxMat44& localPose);
void ClothingAssetAuthoring::clearBoneActors(const char* boneName);
void ClothingAssetAuthoring::clearBoneActors(PxU32 boneIndex);
void ClothingAssetAuthoring::clearAllBoneActors();
void ClothingAssetAuthoring::setCollision(const char** boneNames, PxF32* radii, PxVec3* localPositions, PxU32 numSpheres, PxU16* pairs, PxU32 numPairs);
void ClothingAssetAuthoring::setCollision(PxU32* boneIndices, PxF32* radii, PxVec3* localPositions, PxU32 numSpheres, PxU16* pairs, PxU32 numPairs);
void ClothingAssetAuthoring::clearCollision();
NxParameterized::Interface* ClothingAssetAuthoring::getMaterialLibrary();
bool ClothingAssetAuthoring::setMaterialLibrary(NxParameterized::Interface* materialLibrary, PxU32 materialIndex, bool transferOwnership);
NxParameterized::Interface* ClothingAssetAuthoring::getRenderMeshAssetAuthoring(PxU32 lodLevel);
NxParameterized::Interface* ClothingAssetAuthoring::releaseAndReturnNxParameterizedInterface();
void ClothingAssetAuthoring::preSerialize(void* userData);
void ClothingAssetAuthoring::setToolString(const char* toolString);
void ClothingAssetAuthoring::applyTransformation(const PxMat44& transformation, PxF32 scale, bool applyToGraphics, bool applyToPhysics);
void ClothingAssetAuthoring::updateBindPoses(const PxMat44* newBindPoses, PxU32 newBindPosesCount, bool isInternalOrder, bool collisionMaintainWorldPose);
void ClothingAssetAuthoring::destroy();
PxU32 ClothingAssetAuthoring::addBoneConvexInternal(PxU32 boneIndex, const PxVec3* positions, PxU32 numPositions);
void ClothingAssetAuthoring::addBoneCapsuleInternal(PxU32 boneIndex, PxF32 capsuleRadius, PxF32 capsuleHeight, const PxMat44& localPose);
void ClothingAssetAuthoring::clearBoneActorsInternal(PxI32 internalBoneIndex);
void ClothingAssetAuthoring::compressBones();
void ClothingAssetAuthoring::compressBoneCollision();
void ClothingAssetAuthoring::collectBoneIndices(PxU32 numVertices, const PxU16* boneIndices, const PxF32* boneWeights, PxU32 numBonesPerVertex);
bool ClothingAssetAuthoring::hasTangents(const NiApexRenderMeshAsset& rma);
PxU32 ClothingAssetAuthoring::getMaxNumGraphicalVertsActive(const ClothingGraphicalLodParameters& graphicalLod, PxU32 submeshIndex);
bool ClothingAssetAuthoring::isMostlyImmediateSkinned(const NiApexRenderMeshAsset& rma, const ClothingGraphicalLodParameters& graphicalLod);
bool ClothingAssetAuthoring::conditionalMergeMapping(const NiApexRenderMeshAsset& rma, ClothingGraphicalLodParameters& graphicalLod);
bool operator();
void ClothingAssetAuthoring::sortSkinMapB(SkinClothMapB* skinClothMap, PxU32 skinClothMapSize, PxU32* immediateClothMap, PxU32 immediateClothMapSize);
PX_INLINE bool operator();
void ClothingAssetAuthoring::setupPhysicalLods(ClothingPhysicalMeshParameters& physicalMesh, PxU32 numMaxDistReductions, PxF32* maxDistReductions);
void ClothingAssetAuthoring::distributeSolverIterations();
void ClothingAssetAuthoring::sortDeformableIndices(ClothingPhysicalMesh& physicalMesh);
bool ClothingAssetAuthoring::getGraphicalLodIndex(PxU32 lod, PxU32& graphicalLodIndex);
PxU32 ClothingAssetAuthoring::addGraphicalLod(PxU32 lod);
void ClothingAssetAuthoring::clearCooked();
bool ClothingAssetAuthoring::addGraphicalMesh(NxRenderMeshAssetAuthoring* renderMesh, PxU32 graphicalLodIndex);
void ClothingAssetAuthoring::initParams();
bool operator();
void ClothingAssetAuthoring::removeMaxDistance0Mapping(ClothingGraphicalLodParameters& graphicalLod, NiApexRenderMeshAsset* renderMeshAsset);
PxF32 ClothingAssetAuthoring::computeBaryError(PxF32 baryX, PxF32 baryY);
PxF32 ClothingAssetAuthoring::computeTriangleError(const TriangleWithNormals& triangle, const PxVec3& normal);
| 399656777bac9be30d7007749342b475d8a1b0740c878ecf8972248df90adc52 | 3,736 |
|
DDuarte | IntWars2 | gamed/Unit.cpp |
CMovable::~CMovable |
CMovable::~CMovable() {
} |
bool IsValidModel(char *szModel);
CIniBin CUnit::GetIniBin();
void CUnit::SetName(const char *szName);
bool CUnit::SetType(const char *szType);
bool CUnit::SetModel(const char *szModel);
void CUnit::moveTo(Vector2f pos);
void CUnit::moveTo(Vector2f pos, Vector2f target, float range);
std::string CUnit::GetVar(const char *szSection, const char *szVar);
const char *CUnit::GetModel();
const char *CUnit::GetType();
const char *CUnit::GetName();
CUnit *CUnit::GetActor(WORD wIndex /*= 0*/);
CUnit::CUnit(WORD index, char *szName, char *szType /*= NULL*/, Team tTeam /*= NEUTRAL*/, float x /*= 0*/, float y /*= 0*/);
CUnit::CUnit();
float CUnit::GetY();
float CUnit::GetX();
void CObject::SetPos(float fX, float fY, float fZ /*= 0*/);
DWORD CObject::GetNetworkID();
CObject::CObject(WORD index, float x, float y);
CObject::CObject();
bool CObject::operator==(const CObject &cmp);
double CMovable::GetTimeDelta();
std::vector<Vector2f> CMovable::GetAllWaypoints();
void CMovable::Resume();
void CMovable::Stop();
void CMovable::Pause();
void CMovable::SetSpeed(float speed);
float CMovable::GetSpeed();
void CMovable::SetPos(float x, float y, float z);
std::vector<Vector2f> CMovable::GetWaypoints();
void CMovable::SetWaypoints(std::vector<Vector2f> waypoints);
float CMovable::GetRotation();
Vector2f CMovable::GetPos();
CMovable::CMovable();
void CMovable::RotateTo(Vector2f fTarget);
float CMovable::GetDistanceOf(std::vector<Vector2f> points);
float CMovable::GetRotationSpeed();
void CMovable::SetRotationSpeed(float rotationSpeed);
double CMovable::GetRotationTimeDelta();
| 3ffc73902a2614b45da728b712a0b67628ad028cac2773daf8812ef61ec21507 | 26 |
|
kknox | clFFT | src/library/generator.stockham.cpp | SweepRegsRC | void SweepRegsRC( size_t flag, bool fwd, bool interleaved, size_t stride, size_t component,
double scale, bool setZero, bool batch2, bool oddt,
const std::string &bufferRe, const std::string &bufferIm, const std::string &offset,
std::string &passStr) const
{
assert( (flag == SR_READ ) ||
(flag == SR_WRITE) );
size_t cStart, cEnd;
switch(component)
{
case SR_COMP_REAL: cStart = 0; cEnd = 1; break;
case SR_COMP_IMAG: cStart = 1; cEnd = 2; break;
case SR_COMP_BOTH: cStart = 0; cEnd = 2; break;
default: assert(false);
}
std::string rType = RegBaseType<PR>(1);
assert(r2c || c2r);
assert(linearRegs);
bool singlePass = ((position == 0) && (nextPass == NULL));
size_t numCR = numButterfly * radix;
if(!(numCR%2)) assert(!oddt);
size_t rStart = 0;
size_t rEnd = numCR;
bool oddp = ((numCR%2) && (numCR > 1) && !setZero);
if(oddp)
{
if(oddt) { rStart = numCR-1; rEnd = numCR+1; }
else { rStart = 0; rEnd = numCR-1; }
}
if(!oddp) assert(!oddt);
for(size_t r=rStart; r<rEnd; r++)
{
std::string val1StrExt;
for(size_t c=cStart; c<cEnd; c++)
{
if(flag == SR_READ)
{
std::string tail, tail2;
std::string regIndex = "(*R";
std::string buffer;
RegBaseAndCountAndPos("", r, regIndex);
if (fft_doPreCallback && c2r)
{
regIndex += ")";
if (interleaved)
{
buffer = (c == 0) ? bufferRe : bufferIm;
}
else
{
buffer += bufferRe; buffer += ", "; buffer += bufferIm;
}
}
else
{
if(c == 0)
{
regIndex += ").x";
buffer = bufferRe;
tail = interleaved ? ".x;" : ";";
tail2 = interleaved ? ".y;" : ";";
}
else
{
regIndex += ").y";
buffer = bufferIm;
tail = interleaved ? ".y;" : ";";
tail2 = interleaved ? ".x;" : ";";
}
}
size_t bid = numCR/2;
bid = bid ? bid : 1;
size_t cid, lid;
if(oddt)
{
cid = r%2;
lid = 1 + (numCR/2);
}
else
{
cid = r/bid;
lid = 1 + r%bid;
}
std::string oddpadd = oddp ? " (me/2) + " : " ";
std::string idxStr, idxStrRev;
if((length <= 2) || ((length & (length - 1)) != 0))
{
idxStr += SztToStr(bid); idxStr += "*me +"; idxStr += oddpadd; idxStr += SztToStr(lid);
}
else
{
idxStr += "me + "; idxStr += SztToStr(1 + length*(r%bid)/numCR); idxStr += oddpadd;
}
idxStrRev += SztToStr(length); idxStrRev += " - ("; idxStrRev += idxStr; idxStrRev += " )";
bool act = ( fwd || ((cid == 0) && (!batch2)) || ((cid != 0) && batch2) );
if(act)
{
passStr += "\n\t";
passStr += regIndex;
passStr += " = ";
}
if(setZero)
{
if(act) passStr += "0;";
}
else
{
if(act)
{
if (fft_doPreCallback)
{
passStr += fft_preCallback.funcname; passStr += "(";
passStr += buffer; passStr += ", ";
}
else
{
passStr += buffer;
passStr += "[";
}
passStr += offset; passStr += " + ( ";
}
if(fwd)
{
if(cid == 0) passStr += idxStr;
else passStr += idxStrRev;
}
else
{
if(cid == 0) { if(!batch2) passStr += idxStr; }
else { if(batch2) passStr += idxStr; }
}
if(act)
{
passStr += " )*"; passStr += SztToStr(stride);
if (fft_doPreCallback)
{
passStr += ", pre_userdata";
passStr += (fft_preCallback.localMemSize > 0) ? ", localmem);" : ");";
}
else
{
passStr += "]";
if(fwd) { passStr += tail; }
else { if(!batch2) passStr += tail; else passStr += tail2; }
}
}
}
}
else
{
std::string tail;
std::string regIndex = "(*R";
std::string regIndexPair = "(*R";
std::string buffer;
if(interleaved && (component == SR_COMP_BOTH))
{
assert(bufferRe.compare(bufferIm) == 0);
buffer = bufferRe;
}
else
{
if(c == 0)
{
buffer = bufferRe;
tail = interleaved ? ".x" : "";
}
else
{
buffer = bufferIm;
tail = interleaved ? ".y" : "";
}
}
size_t bid, cid, lid;
if(singlePass && fwd)
{
bid = 1 + radix/2;
lid = r;
cid = r/bid;
RegBaseAndCountAndPos("", r, regIndex); regIndex += ")";
RegBaseAndCountAndPos("", (radix - r)%radix , regIndexPair); regIndexPair += ")";
}
else
{
bid = numCR/2;
if(oddt)
{
cid = r%2;
lid = 1 + (numCR/2);
RegBaseAndCountAndPos("", r, regIndex); regIndex += ")";
RegBaseAndCountAndPos("", r + 1, regIndexPair); regIndexPair += ")";
}
else
{
cid = r/bid;
lid = 1 + r%bid;
RegBaseAndCountAndPos("", r, regIndex); regIndex += ")";
RegBaseAndCountAndPos("", r + bid, regIndexPair); regIndexPair += ")";
}
}
if(!cid)
{
std::string oddpadd = oddp ? " (me/2) + " : " ";
std::string sclStr = "";
if(scale != 1.0f) { sclStr += " * "; sclStr += FloatToStr(scale); sclStr += FloatSuffix<PR>(); }
if(fwd)
{
std::string idxStr, idxStrRev;
if((length <= 2) || ((length & (length - 1)) != 0))
{
idxStr += SztToStr(length/(2*workGroupSize)); idxStr += "*me +"; idxStr += oddpadd; idxStr += SztToStr(lid);
}
else
{
idxStr += "me + "; idxStr += SztToStr(1 + length*(r%bid)/numCR); idxStr += oddpadd;
}
idxStrRev += SztToStr(length); idxStrRev += " - ("; idxStrRev += idxStr; idxStrRev += " )";
std::string val1Str, val2Str;
if (fft_doPostCallback && !rcFull)
{
if (interleaved)
{
val1Str += "\n\t";
val1Str += fft_postCallback.funcname; val1Str += "("; val1Str += buffer; val1Str += ", ";
val1Str += offset; val1Str += " + ( "; val1Str += idxStr; val1Str += " )*"; val1Str += SztToStr(stride);
val1Str += ", post_userdata, ";
}
else if (c == 0)
{
val1StrExt += "\n\t";
val1StrExt += fft_postCallback.funcname; val1StrExt += "("; val1StrExt += bufferRe; val1StrExt += ", ";
val1StrExt += bufferIm; val1StrExt += ", "; val1StrExt += offset; val1StrExt += " + ( "; val1StrExt += idxStr;
val1StrExt += " )*"; val1StrExt += SztToStr(stride); val1StrExt += ", post_userdata, ";
}
}
else
{
val1Str += "\n\t";
val1Str += buffer; val1Str += "["; val1Str += offset; val1Str += " + ( ";
val1Str += idxStr; val1Str += " )*"; val1Str += SztToStr(stride); val1Str += "]";
val1Str += tail; val1Str += " = ";
}
val2Str += "\n\t";
val2Str += buffer; val2Str += "["; val2Str += offset; val2Str += " + ( ";
val2Str += idxStrRev; val2Str += " )*"; val2Str += SztToStr(stride); val2Str += "]";
val2Str += tail; val2Str += " = ";
std::string real1, imag1, real2, imag2;
real1 += "("; real1 += regIndex; real1 += ".x + "; real1 += regIndexPair; real1 += ".x)*0.5";
imag1 += "("; imag1 += regIndex; imag1 += ".y - "; imag1 += regIndexPair; imag1 += ".y)*0.5";
real2 += "("; real2 += regIndex; real2 += ".y + "; real2 += regIndexPair; real2 += ".y)*0.5";
imag2 += "(-"; imag2 += regIndex; imag2 += ".x + "; imag2 += regIndexPair; imag2 += ".x)*0.5";
if(interleaved && (component == SR_COMP_BOTH))
{
val1Str += "("; val1Str += RegBaseType<PR>(2); val1Str += ")( ";
val2Str += "("; val2Str += RegBaseType<PR>(2); val2Str += ")( ";
if(!batch2) { val1Str += real1; val1Str += ", "; val1Str += "+"; val1Str += imag1;
val2Str += real1; val2Str += ", "; val2Str += "-"; val2Str += imag1; }
else { val1Str += real2; val1Str += ", "; val1Str += "+"; val1Str += imag2;
val2Str += real2; val2Str += ", "; val2Str += "-"; val2Str += imag2; }
val1Str += " )";
val2Str += " )";
}
else
{
val1Str += " (";
val2Str += " (";
if(c == 0)
{
if(!batch2) { val1Str += real1;
val2Str += real1; }
else { val1Str += real2;
val2Str += real2; }
}
else
{
if(!batch2) { val1Str += "+"; val1Str += imag1;
val2Str += "-"; val2Str += imag1; }
else { val1Str += "+"; val1Str += imag2;
val2Str += "-"; val2Str += imag2; }
}
val1Str += " )";
val2Str += " )";
}
val1Str += sclStr;
val2Str += sclStr;
if (fft_doPostCallback && !rcFull)
{
if (!interleaved)
{
val1StrExt += val1Str;
val1Str.clear();
if(c == 0) val1StrExt += ", ";
else val1Str += val1StrExt;
}
if (interleaved || c == (cEnd - 1))
{
if (fft_postCallback.localMemSize > 0) val1Str += ", localmem";
val1Str += ");";
}
}
else
{
val1Str += ";";
}
passStr += val1Str;
if(rcFull) { passStr += val2Str; passStr += ";"; }
}
else
{
std::string idxStr, idxStrRev;
if((length <= 2) || ((length & (length - 1)) != 0))
{
idxStr += SztToStr(bid); idxStr += "*me +"; idxStr += oddpadd; idxStr += SztToStr(lid);
}
else
{
idxStr += "me + "; idxStr += SztToStr(1 + length*(r%bid)/numCR); idxStr += oddpadd;
}
idxStrRev += SztToStr(length); idxStrRev += " - ("; idxStrRev += idxStr; idxStrRev += " )";
passStr += "\n\t";
passStr += buffer; passStr += "["; passStr += offset; passStr += " + ( ";
if(!batch2) passStr += idxStr;
else passStr += idxStrRev;
passStr += " )*"; passStr += SztToStr(stride); passStr += "]";
passStr += tail; passStr += " = ";
passStr += "( ";
if(c == 0)
{
regIndex += ".x";
regIndexPair += fft_doPreCallback ? ".y" : ".x";
if(!batch2) { passStr += regIndex; passStr += " - "; passStr += regIndexPair; }
else { passStr += regIndex; passStr += " + "; passStr += regIndexPair; }
}
else
{
regIndex += ".y"; regIndexPair += (fft_doPreCallback && oddt) ? ".x" : ".y";
if(!batch2) { passStr += regIndex; passStr += " + "; passStr += regIndexPair; }
else { passStr += " - "; passStr += regIndex; passStr += " + "; passStr += regIndexPair; }
}
passStr += " )";
passStr += sclStr;
passStr += ";";
}
if(interleaved && (component == SR_COMP_BOTH))
break;
}
}
}
}
} |
FFTGeneratedStockhamAction::FFTGeneratedStockhamAction(clfftPlanHandle plHandle, FFTPlan * plan, cl_command_queue queue, clfftStatus & err);
bool FFTGeneratedStockhamAction::buildForwardKernel();
bool FFTGeneratedStockhamAction::buildBackwardKernel();
void ReadParameterFile(ParamRead &readParam);
void ReadKernelFromFile(std::string &str);
KernelCoreSpecs();
void GetRadices(size_t length, size_t &numPasses, const size_t * &pRadices);
void GetWGSAndNT(size_t length, size_t &workGroupSize, size_t &numTransforms);
void DetermineSizes(const size_t &MAX_WGS, const size_t &length, size_t &workGroupSize, size_t &numTrans, Precision &pr);
TwiddleTable(size_t length);
~TwiddleTable();
void GenerateTwiddleTable(const std::vector<size_t> &radices, std::string &twStr);
inline void RegBase(size_t regC, std::string &str);
inline void RegBaseAndCount(size_t num, std::string &str);
inline void RegBaseAndCountAndPos(const std::string &RealImag, size_t radPos, std::string &str);
void RegIndex(size_t regC, size_t num, const std::string &RealImag, size_t radPos, std::string &str);
void DeclareRegs(const std::string ®Type, size_t regC, size_t numB, std::string &passStr);
inline std::string IterRegArgs();
void CallButterfly(const std::string &bflyName, size_t regC, size_t numB, std::string &passStr);
void SetPrecallback(bool hasPrecallback, clfftCallbackParam precallbackParam);
void SetPostcallback(bool hasPostcallback, clfftCallbackParam postcallbackParam);
inline std::string IterRegs(const std::string &pfx, bool initComma = true);
inline bool IsGroupedReadWritePossible();
inline std::string OffsetCalcBlock(const std::string &off, bool input = true);
inline std::string OffsetCalc(const std::string &off, bool input = true, bool rc_second_index = false);
Kernel( const FFTKernelGenKeyParams ¶msVal);
static size_t GetValue(size_t N, ValType vt);
void GenerateKernel(std::string &str, cl_device_id Dev_ID);
clfftStatus FFTGeneratedStockhamAction::initParams ();
clfftStatus FFTGeneratedStockhamAction::getWorkSizes (std::vector<size_t> & globalWS, std::vector<size_t> & localWS);
clfftStatus FFTPlan::GetMax1DLengthStockham (size_t * longest);
clfftStatus FFTGeneratedStockhamAction::generateKernel(FFTRepo& fftRepo, const cl_command_queue commQueueFFT );
| e0dd6c75754f8c5b8d3c7c038c0584bf55343e4290f3b027d3d92b80988eaec6 | 11,307 |
|
bahmdev | ray_tracer | ray_tracer/main.cpp | ~Scene | ~Scene(){
for (std::vector<LightSource*>::iterator iLightSource = lightSources.begin();
iLightSource != lightSources.end(); ++iLightSource) delete *iLightSource;
for (std::vector<Material*>::iterator iMaterial = materials.begin();
iMaterial != materials.end(); ++iMaterial) delete *iMaterial;
for (std::vector<Intersectable*>::iterator iObject = objects.begin();
iObject != objects.end(); ++iObject) delete *iObject;
} | Scene();
void snowman(float x, float y, float z, float scale, Material* material);
Hit firstTraverse(const Ray &ray);
vector3d trace(const Ray& ray, int depth);
bool computeImage();
void onDisplay();
void onIdle();
void onKeyboard(unsigned char key, int x, int y);
void onKeyboardUp(unsigned char key, int x, int y);
void onMouse(int button, int state, int x, int y);
void onMouseMotion(int x, int y);
void onReshape(int winWidth, int winHeight);
int main(int argc, char * argv[]);
| 384fe44e78f47de773cb2ad9c46743fe1a997ac3069a5ab0caee9a47a4d70974 | 438 |
|
bluzDK | bluzDK-firmware | platform/MCU/NRF51/SPARK_Firmware_Driver/src/info_data_service.cpp | InfoDataService::registerCallback |
void InfoDataService::registerCallback(void (*ec)(uint8_t event, uint8_t *data, uint16_t length))
{
event_callback = ec;
} |
InfoDataService* InfoDataService::instance();
int32_t InfoDataService::getServiceID();
int32_t InfoDataService::DataCallback(uint8_t *data, int16_t length);
void infoDataServiceRegisterCallback(void (*event_callback);
| d6c8754a7508e8af47e1ed4d01334fa20e8653b2f136f68cc0b047fdcec7691d | 127 |
|
hal7df | iash | iash.cpp | iash::runInteractive |
int iash::runInteractive ()
{
run(cin, true);
return 0;
} |
iash::iash (const string &appName);
Environment* iash::getEnv ();
const Directory* iash::getCwd ();
void iash::addCommand (Command *cmd);
int iash::runScript (const char *fname);
inline int iash::exec (string &cmd);
inline int iash::exec (UserCommand *cmd);
int iash::run (istream &cmdin, bool showPrompt);
void iash::exitShell();
| e3924a74e44ba8938235ae4ce358a0126ab1c61bd10b5b39c8cd323a26e4259f | 60 |
|
1blockologist | boolberry | src/rpc/core_rpc_server.cpp | core_rpc_server::on_get_connections | bool core_rpc_server::on_get_connections(const COMMAND_RPC_GET_CONNECTIONS::request& req, COMMAND_RPC_GET_CONNECTIONS::response& res, epee::json_rpc::error& error_resp, connection_context& cntx)
{
if(!check_core_ready())
{
error_resp.code = CORE_RPC_ERROR_CODE_CORE_BUSY;
error_resp.message = "Core is busy.";
return false;
}
res.connections = m_p2p.get_payload_object().get_connections();
res.status = CORE_RPC_STATUS_OK;
return true;
} | void core_rpc_server::init_options(boost::program_options::options_description& desc);
bool core_rpc_server::handle_command_line(const boost::program_options::variables_map& vm);
bool core_rpc_server::init(const boost::program_options::variables_map& vm);
bool core_rpc_server::check_core_ready();
bool core_rpc_server::on_get_height(const COMMAND_RPC_GET_HEIGHT::request& req, COMMAND_RPC_GET_HEIGHT::response& res, connection_context& cntx);
bool core_rpc_server::on_get_info(const COMMAND_RPC_GET_INFO::request& req, COMMAND_RPC_GET_INFO::response& res, connection_context& cntx);
bool core_rpc_server::on_get_peerlists(const COMMAND_RPC_GET_PEERLISTS::request& req, COMMAND_RPC_GET_PEERLISTS::response& res, connection_context& cntx);
bool core_rpc_server::on_stop_daemon(const COMMAND_RPC_STOP_DAEMON::request& req, COMMAND_RPC_STOP_DAEMON::response& res, connection_context& cntx);
bool core_rpc_server::on_get_blocks(const COMMAND_RPC_GET_BLOCKS_FAST::request& req, COMMAND_RPC_GET_BLOCKS_FAST::response& res, connection_context& cntx);
bool core_rpc_server::on_get_block(const COMMAND_RPC_GET_BLOCK::request& req, COMMAND_RPC_GET_BLOCK::response& res, epee::json_rpc::error& error_resp, connection_context& cntx);
bool core_rpc_server::on_get_random_outs(const COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::request& req, COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::response& res, connection_context& cntx);
bool core_rpc_server::on_get_indexes(const COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES::request& req, COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES::response& res, connection_context& cntx);
bool core_rpc_server::on_set_maintainers_info(const COMMAND_RPC_SET_MAINTAINERS_INFO::request& req, COMMAND_RPC_SET_MAINTAINERS_INFO::response& res, connection_context& cntx);
bool core_rpc_server::on_get_tx_pool(const COMMAND_RPC_GET_TX_POOL::request& req, COMMAND_RPC_GET_TX_POOL::response& res, connection_context& cntx);
bool core_rpc_server::on_check_keyimages(const COMMAND_RPC_CHECK_KEYIMAGES::request& req, COMMAND_RPC_CHECK_KEYIMAGES::response& res, connection_context& cntx);
bool core_rpc_server::on_check_keyimages_nonbinary(const COMMAND_RPC_CHECK_KEYIMAGES_NONBINARY::request& req, COMMAND_RPC_CHECK_KEYIMAGES_NONBINARY::response& res, connection_context& cntx);
bool core_rpc_server::on_get_transactions(const COMMAND_RPC_GET_TRANSACTIONS::request& req, COMMAND_RPC_GET_TRANSACTIONS::response& res, connection_context& cntx);
bool core_rpc_server::on_send_raw_tx(const COMMAND_RPC_SEND_RAW_TX::request& req, COMMAND_RPC_SEND_RAW_TX::response& res, connection_context& cntx);
bool core_rpc_server::on_start_mining(const COMMAND_RPC_START_MINING::request& req, COMMAND_RPC_START_MINING::response& res, connection_context& cntx);
bool core_rpc_server::on_stop_mining(const COMMAND_RPC_STOP_MINING::request& req, COMMAND_RPC_STOP_MINING::response& res, connection_context& cntx);
bool core_rpc_server::on_getblockcount(const COMMAND_RPC_GETBLOCKCOUNT::request& req, COMMAND_RPC_GETBLOCKCOUNT::response& res, connection_context& cntx);
bool core_rpc_server::on_getblockhash(const COMMAND_RPC_GETBLOCKHASH::request& req, COMMAND_RPC_GETBLOCKHASH::response& res, epee::json_rpc::error& error_resp, connection_context& cntx);
uint64_t slow_memmem(void* start_buff, size_t buflen,void* pat,size_t patlen);
bool core_rpc_server::on_getblocktemplate(const COMMAND_RPC_GETBLOCKTEMPLATE::request& req, COMMAND_RPC_GETBLOCKTEMPLATE::response& res, epee::json_rpc::error& error_resp, connection_context& cntx);
bool core_rpc_server::on_submitblock(const COMMAND_RPC_SUBMITBLOCK::request& req, COMMAND_RPC_SUBMITBLOCK::response& res, epee::json_rpc::error& error_resp, connection_context& cntx);
uint64_t core_rpc_server::get_block_reward(const block& blk);
bool core_rpc_server::fill_block_header_response(const block& blk, bool orphan_status, block_header_response& responce);
bool core_rpc_server::on_get_last_block_header(const COMMAND_RPC_GET_LAST_BLOCK_HEADER::request& req, COMMAND_RPC_GET_LAST_BLOCK_HEADER::response& res, epee::json_rpc::error& error_resp, connection_context& cntx);
bool core_rpc_server::on_get_block_header_by_hash(const COMMAND_RPC_GET_BLOCK_HEADER_BY_HASH::request& req, COMMAND_RPC_GET_BLOCK_HEADER_BY_HASH::response& res, epee::json_rpc::error& error_resp, connection_context& cntx);
bool core_rpc_server::on_get_block_header_by_height(const COMMAND_RPC_GET_BLOCK_HEADER_BY_HEIGHT::request& req, COMMAND_RPC_GET_BLOCK_HEADER_BY_HEIGHT::response& res, epee::json_rpc::error& error_resp, connection_context& cntx);
bool core_rpc_server::on_get_alias_details(const COMMAND_RPC_GET_ALIAS_DETAILS::request& req, COMMAND_RPC_GET_ALIAS_DETAILS::response& res, epee::json_rpc::error& error_resp, connection_context& cntx);
bool core_rpc_server::on_get_all_aliases(const COMMAND_RPC_GET_ALL_ALIASES::request& req, COMMAND_RPC_GET_ALL_ALIASES::response& res, epee::json_rpc::error& error_resp, connection_context& cntx);
bool core_rpc_server::get_addendum_for_hi(const mining::height_info& hi, std::list<mining::addendum>& res);
bool core_rpc_server::get_current_hi(mining::height_info& hi);
void core_rpc_server::set_session_blob(const std::string& session_id, const currency::block& blob);
bool core_rpc_server::get_session_blob(const std::string& session_id, currency::block& blob);
bool core_rpc_server::get_job(const std::string& job_id, mining::job_details& job, epee::json_rpc::error& err, connection_context& cntx);
bool core_rpc_server::on_login(const mining::COMMAND_RPC_LOGIN::request& req, mining::COMMAND_RPC_LOGIN::response& res, connection_context& cntx);
bool core_rpc_server::on_getjob(const mining::COMMAND_RPC_GETJOB::request& req, mining::COMMAND_RPC_GETJOB::response& res, connection_context& cntx);
bool core_rpc_server::on_getscratchpad(const mining::COMMAND_RPC_GET_FULLSCRATCHPAD::request& req, mining::COMMAND_RPC_GET_FULLSCRATCHPAD::response& res, connection_context& cntx);
bool core_rpc_server::on_alias_by_address(const COMMAND_RPC_GET_ALIASES_BY_ADDRESS::request& req, COMMAND_RPC_GET_ALIASES_BY_ADDRESS::response& res, epee::json_rpc::error& error_resp, connection_context& cntx);
bool core_rpc_server::on_submit(const mining::COMMAND_RPC_SUBMITSHARE::request& req, mining::COMMAND_RPC_SUBMITSHARE::response& res, connection_context& cntx);
bool core_rpc_server::on_store_scratchpad(const mining::COMMAND_RPC_STORE_SCRATCHPAD::request& req, mining::COMMAND_RPC_STORE_SCRATCHPAD::response& res, connection_context& cntx);
bool core_rpc_server::on_getfullscratchpad2(const epee::net_utils::http::http_request_info& query_info, epee::net_utils::http::http_response_info& response_info, connection_context& cntx);
bool core_rpc_server::on_get_addendums(const COMMAND_RPC_GET_ADDENDUMS::request& req, COMMAND_RPC_GET_ADDENDUMS::response& res, epee::json_rpc::error& error_resp, connection_context& cntx);
bool core_rpc_server::on_reset_transaction_pool(const COMMAND_RPC_RESET_TX_POOL::request& req, COMMAND_RPC_RESET_TX_POOL::response& res, connection_context& cntx);
| 341fe22abf38ebf25080c28f0f2e3f69e2b93025d88ec9ca37ac0eca81b25c8b | 454 |
|
kaltsi | qt-mobility | src/publishsubscribe/sharedmemorylayer.cpp | operator!= |
bool operator!=(const NodeWatch &lhs, const NodeWatch &rhs)
{
return 0 != ::memcmp(&lhs, &rhs, sizeof(NodeWatch));
} |
static inline QDataStream& operator<<(QDataStream& stream, unsigned long v);
static inline QDataStream& operator>>(QDataStream& stream, unsigned long& v);
static int vsmemcmp(const char * s1, int l1, const char * s2, int l2);
bool valid();
unsigned int dataBlockSize();
unsigned int watchBlockSize();
unsigned int size();
void * dataBegin();
void * watchBegin();
bool operator==(const NodeOwner &lhs, const NodeOwner &rhs);
bool operator!=(const NodeOwner &lhs, const NodeOwner &rhs);
bool operator==(const NodeWatch &lhs, const NodeWatch &rhs);
NodeDatum * FixedMemoryTree::data(unsigned short node);
bool FixedMemoryTree::addWatch(const char * path, NodeWatch owner);
bool FixedMemoryTree::remWatch(const char * path, NodeWatch owner);
bool FixedMemoryTree::remove(const char * path, NodeOwner owner);
unsigned int FixedMemoryTree::growListSize(unsigned int currentSize);
bool FixedMemoryTree::remWatch(unsigned short node, NodeWatch owner);
bool FixedMemoryTree::setWatch(unsigned short node, NodeWatch owner);
VersionTable * FixedMemoryTree::versionTable();
void * FixedMemoryTree::fromPtr(unsigned int ptr);
void FixedMemoryTree::setNodeChangeFunction(NodeChangeFunction func, void *ctxt);
unsigned int FixedMemoryTree::ptr(void * mem);
void FixedMemoryTree::bump(unsigned short node);
Node * FixedMemoryTree::node(unsigned int entry);
Node * FixedMemoryTree::getNode(unsigned int entry);
Node * FixedMemoryTree::subNode(unsigned int node, unsigned short sub);
unsigned int FixedMemoryTree::version(unsigned int entry);
ALServerImpl::~ALServerImpl();
ReadHandle(const QByteArray &_path);
ReadHandle * rh(QAbstractValueSpaceLayer::Handle handle);
unsigned int newPackId();
SharedMemoryLayer::SharedMemoryLayer();
SharedMemoryLayer::~SharedMemoryLayer();
QString SharedMemoryLayer::name();
bool SharedMemoryLayer::startup(Type type);
void ALServerImpl::incomingConnection(quintptr socketDescriptor);
void SharedMemoryLayer::timerEvent(QTimerEvent *);
void SharedMemoryLayer::doServerTransmit();
void SharedMemoryLayer::doClientTransmit();
void SharedMemoryLayer::disconnected();
static void ShmLayerNodeChanged(unsigned short node, void *ctxt);
void SharedMemoryLayer::nodeChanged(unsigned short node);
void SharedMemoryLayer::readyRead();
void SharedMemoryLayer::closeConnections();
void SharedMemoryLayer::doClientEmit();
QUuid SharedMemoryLayer::id();
unsigned int SharedMemoryLayer::order();
bool SharedMemoryLayer::value(Handle handle, QVariant *data);
QSet<QString> SharedMemoryLayer::children(Handle handle);
QValueSpace::LayerOptions SharedMemoryLayer::layerOptions();
SharedMemoryLayer::Handle SharedMemoryLayer::item(Handle parent, const QString &key);
bool SharedMemoryLayer::refreshHandle(ReadHandle * handle);
void SharedMemoryLayer::clearHandle(ReadHandle *handle);
void SharedMemoryLayer::triggerTodo();
void SharedMemoryLayer::setProperty(Handle, Properties);
void SharedMemoryLayer::removeHandle(Handle h);
void SharedMemoryLayer::updateStats();
QList<NodeWatch> SharedMemoryLayer::watchers(const QByteArray &path);
void SharedMemoryLayer::doNotifyObject(unsigned long own, unsigned long protocol);
bool SharedMemoryLayer::setWatch(NodeWatch watch, const QByteArray &path);
bool SharedMemoryLayer::doSetWatch(NodeWatch watch, const QByteArray &path);
bool SharedMemoryLayer::remWatch(NodeWatch watch, const QByteArray &path);
bool SharedMemoryLayer::doRemWatch(NodeWatch watch, const QByteArray &path);
bool SharedMemoryLayer::remItems(NodeOwner owner, const QByteArray &path);
bool SharedMemoryLayer::doRemItems(NodeOwner owner, const QByteArray &path);
QString SharedMemoryLayer::socket();
void SharedMemoryLayer::sync();
void SharedMemoryLayer::doClientSync();
QVariant SharedMemoryLayer::fromDatum(const NodeDatum * data);
void SharedMemoryLayer::incNode(unsigned short node);
void SharedMemoryLayer::decNode(unsigned short node);
SharedMemoryLayer * SharedMemoryLayer::instance();
bool SharedMemoryLayer::supportsInterestNotification();
bool SharedMemoryLayer::notifyInterest(Handle handle, bool interested);
bool SharedMemoryLayer::removeSubTree(QValueSpacePublisher *creator, Handle handle);
void SharedMemoryLayer::addWatch(QValueSpacePublisher *creator, Handle handle);
void SharedMemoryLayer::removeWatches(QValueSpacePublisher *creator, Handle parent);
| 23fedc0883f982c5c5217153bab040358c9cfdf959945ec3d995dc31975667ef | 121 |
|
carmark | vbox | src/VBox/ValidationKit/utils/cpu/cidet-app.cpp | DECLCALLBACK |
static DECLCALLBACK(bool) CidetAppCbSetupCodeBuf(PCIDETCORE pThis, PCIDETBUF pBuf, void const *pvInstr)
{
PCIDETAPP pThisApp = (PCIDETAPP)pThis;
PCIDETAPPBUF pAppBuf =&pThisApp->aCodeBuffers[pBuf->idxCfg];
Assert(CIDETBUF_IS_CODE(pBuf->pCfg->fFlags));
Assert(pAppBuf->fUsingNormal);
Assert(!pAppBuf->fArmed);
uint8_t *pbDst = pAppBuf->pbNormal + pBuf->offActive - pBuf->cbPrologue;
Assert(pbDst == &pAppBuf->pbNormal[pBuf->offActive]);
memcpy(pbDst, pvInstr, pBuf->cbActive);
pbDst += pBuf->cbActive;
if (!pThis->InCtx.fTrickyStack)
{
uint8_t * const pbStartEpilogue = pbDst;
*pbDst++ = 0xeb;
*pbDst++ = 0x06;
*pbDst++ = 0xcc;
*pbDst++ = 0xcc;
*pbDst++ = 0xcc;
*pbDst++ = 0xcc;
*pbDst++ = 0xcc;
*pbDst++ = 0xcc;
*pbDst++ = 0xe8;
*pbDst++ = 0x00;
*pbDst++ = 0x00;
*pbDst++ = 0x00;
*pbDst++ = 0x00;
uint8_t offRipAdjust = (uint8_t)(uintptr_t)(pbStartEpilogue - pbDst);
*pbDst++ = 0x51;
*pbDst++ = 0x48;
*pbDst++ = 0x8b;
*pbDst++ = 0x4c;
*pbDst++ = 0x24;
*pbDst++ = sizeof(uintptr_t);
*pbDst++ = 0x48;
*pbDst++ = 0x8d;
*pbDst++ = 0x49;
*pbDst++ = offRipAdjust;
*pbDst++ = 0x48;
*pbDst++ = 0x89;
*pbDst++ = 0x4c;
*pbDst++ = 0x24;
*pbDst++ = sizeof(uintptr_t);
#ifdef RT_ARCH_AMD64
*pbDst++ = 0x48;
#endif
*pbDst++ = 0xb9;
*(uintptr_t *)pbDst = (uintptr_t)&pThisApp->Core.ActualCtx;
pbDst += sizeof(uintptr_t);
*pbDst++ = 0x36;
*pbDst++ = 0x8f;
*pbDst++ = 0x41;
*pbDst++ = RT_OFFSETOF(CIDETCPUCTX, aGRegs[X86_GREG_xCX]);
Assert(RT_OFFSETOF(CIDETCPUCTX, aGRegs[X86_GREG_xCX]) < 0x7f);
*pbDst++ = 0x36;
#ifdef RT_ARCH_AMD64
*pbDst++ = 0x48;
#endif
*pbDst++ = 0x89;
*pbDst++ = 0x51;
*pbDst++ = RT_OFFSETOF(CIDETCPUCTX, aGRegs[X86_GREG_xDX]);
Assert(RT_OFFSETOF(CIDETCPUCTX, aGRegs[X86_GREG_xDX]) < 0x7f);
*pbDst++ = 0x36;
*pbDst++ = 0x8c;
*pbDst++ = 0x99;
*(uint32_t *)pbDst = RT_OFFSETOF(CIDETCPUCTX, aSRegs[X86_SREG_DS]);
pbDst += sizeof(uint32_t);
*pbDst++ = 0xba;
*(uint32_t *)pbDst = pThisApp->Core.InTemplateCtx.aSRegs[X86_SREG_DS];
pbDst += sizeof(uint32_t);
*pbDst++ = 0x8e;
*pbDst++ = 0xda;
#ifdef RT_ARCH_AMD64
*pbDst++ = 0x48;
#endif
*pbDst++ = 0xba;
*(uintptr_t *)pbDst = (uintptr_t)&pThisApp->ExecuteCtx;
pbDst += sizeof(uintptr_t);
#ifdef RT_ARCH_AMD64
*pbDst++ = 0xff;
*pbDst++ = 0x25;
*(uint32_t *)pbDst = 0;
pbDst += sizeof(uint32_t);
#else
*pbDst++ = 0xb9;
#endif
*(uintptr_t *)pbDst = (uintptr_t)CidetAppSaveAndRestoreCtx;
pbDst += sizeof(uintptr_t);
*pbDst++ = 0xcc;
pThisApp->fUsingLockedInt3 = false;
}
else
{
*pbDst++ = 0xf0;
memset(pbDst, 0xcc, 15);
pbDst += 15;
pThisApp->fUsingLockedInt3 = true;
}
AssertMsg(pbDst == &pAppBuf->pbNormal[pBuf->offActive + pBuf->cb + pBuf->cbEpilogue],
("cbEpilogue=%#x, actual %#x\n", pBuf->cbEpilogue, pbDst - &pAppBuf->pbNormal[pBuf->offActive + pBuf->cb]));
return CidetAppArmBuf(pThisApp, pAppBuf);
} |
static int CidetAppXcptFilter(EXCEPTION_POINTERS *pXcptPtrs);
static LONG CALLBACK CidetAppVectoredXcptHandler(EXCEPTION_POINTERS *pXcptPtrs);
static LONG CALLBACK CidetAppUnhandledXcptFilter(EXCEPTION_POINTERS *pXcptPtrs);
static void CidetAppSigHandler(int iSignal, siginfo_t *pSigInfo, void *pvCtx);
static void CidetAppDeleteBuffer(PCIDETAPPBUF pBuf);
static bool CidetAppArmBuf(PCIDETAPP pThis, PCIDETAPPBUF pAppBuf);
static bool CidetAppDearmBuf(PCIDETAPP pThis, PCIDETAPPBUF pAppBuf);
static DECLCALLBACK(bool);
static DECLCALLBACK(bool);
static DECLCALLBACK(bool);
static DECLCALLBACK(bool);
static DECLCALLBACK(bool);
static DECLCALLBACK(void);
static int cidetAppAllocateAndConfigureBuffers(PCIDETAPP pThis);
static int CidetAppCreate(PPCIDETAPP ppThis);
static void CidetAppDestroy(PCIDETAPP pThis);
static void CidetAppTestBunch(PCIDETAPP pThis, PCCIDETINSTR paInstructions, uint32_t cInstructions, const char *pszBunchName);
int main(int argc, char **argv);
| ecd06bc4d2dac6d399faae3d395f3d36d6002e0ff9d8dae1597b3584745a446a | 3,683 |
|
KDE | krita | libs/ui/input/kis_pan_action.cpp | KisPanAction::inputActionGroup |
KisInputActionGroup KisPanAction::inputActionGroup(int shortcut) const
{
Q_UNUSED(shortcut);
return ViewTransformActionGroup;
} |
KisPanAction::KisPanAction();
KisPanAction::~KisPanAction();
int KisPanAction::priority();
void KisPanAction::activate(int shortcut);
void KisPanAction::deactivate(int shortcut);
void KisPanAction::begin(int shortcut, QEvent *event);
void KisPanAction::end(QEvent *event);
void KisPanAction::inputEvent(QEvent *event);
void KisPanAction::cursorMovedAbsolute(const QPointF &startPos, const QPointF &pos);
QPointF KisPanAction::Private::averagePoint( QTouchEvent* event, int *outCount );
bool KisPanAction::isShortcutRequired(int shortcut);
bool KisPanAction::supportsHiResInputEvents(int shortcut);
| 902c91acbf9343f8e92256ae02d1ddfba56354e7e8274f0804292b650d7f6a13 | 136 |
|
nanshusu | nanshusu.github.cn | uware/src/wingui/lib/upl/src/container.cpp | CContainer::OnSetCursor | BOOL CContainer::OnSetCursor(HWND hWnd, UINT nHitTest, UINT message)
{
CPoint ptCurPos;
GetCursorPos(&ptCurPos);
ScreenToClient(&ptCurPos);
{
SetCursor(LoadCursor(NULL, IDC_ARROW));
return TRUE;
}
Default();
return TRUE;
}
|
CTab::CTab(CWin *mpParent, LPCTSTR lpMsgs, UINT_PTR nMenu);
CTab::~CTab();
CContainer::CContainer();
CContainer::~CContainer();
BOOL CContainer::PreTranslateMessage(MSG *pMsg);
void CContainer::SetTypeTab(TypeTab Type);
BOOL CContainer::OnEraseBkgnd(HDC hDC);
void CContainer::SetActualTitle(BOOL bActual);
void CContainer::SetALingTabs(AlingTab alnTab);
BOOL CContainer::OnPaint(HDC hDC);
BOOL CContainer::Create(DWORD dwStyle, const RECT &rect, CWin *pParentWnd, UINT nID);
INT CContainer::OnCreate(LPCREATESTRUCT lpCreateStruct);
BOOL CContainer::OnNcCalcSize(BOOL /*bCalcValidRects*/, LPNCCALCSIZE_PARAMS lpncsp);
void CContainer::OnNcPaint(HRGN hRgn);
void CContainer::DrawGripper(CGDI *dc, CRect rcWin);
BOOL CContainer::OnLButtonUp(UINT nFlags, CPoint point);
void CContainer::OnNcMouseMove(UINT nHitTest, CPoint point);
void CContainer::OnNcLButtonDown(UINT nHitTest, CPoint point);
void CContainer::ShowPane(BOOL bShow);
BOOL CContainer::IsClosePane();
void CContainer::OnNcLButtonUp(UINT nHitTest, CPoint point);
UINT CContainer::OnNcHitTest(CPoint cp);
void CContainer::OnTimer(UINT nIDEvent);
void CContainer::RecalLayout();
void CContainer::AjustTabs();
void CContainer::Drawtabs(CGDI *dc);
CWin *CContainer::GetActiveWnd();
INT CContainer::FindItem(HWND hWnd);
CTab *CContainer::GetTab(INT nTab);
CWin *CContainer::GetNumWnd(INT m_numtab);
void CContainer::UpdateCaption(CWin *pWnd, LPCTSTR m_Title);
void CContainer::ShowTitle(LPCTSTR m_Caption);
void CContainer::Addtab(CWin *pParent, LPCTSTR lpMsg, UINT uHmenu);
void CContainer::DeleteTab(INT m_numtab);
BOOL CContainer::OnSize(UINT nType, INT cx, INT cy);
void CContainer::SetCurtab(INT m_numtab);
INT CContainer::GetCurtab();
void CContainer::OnMouseMove(UINT nHitTest, CPoint point);
BOOL CContainer::OnLButtonDown(UINT nFlags, CPoint point);
void CContainer::OnNcRButtonDown(UINT nHitTest, CPoint point);
void CContainer::ShowMenu(CPoint point);
BOOL CContainer::OnRButtonDown(UINT nFlags, CPoint point);
void CContainer::SetStyle(Style estyle);
INT CContainer::OnDestroy();
void CContainer::SetTabMenu(LPCTSTR lpszMenuName);
BOOL CContainer::OnNotify(WPARAM wParam, LPARAM lParam, LRESULT *pResult);
| c804317ffa3fb505fca65b35ec9463799125992600a98617a7663f7780df74ed | 290 |
|
simonowen | samdisk | src/Driver.cpp | GetDriverVersion |
DWORD GetDriverVersion()
{
DWORD version = 0, ret;
HANDLE h = CreateFile(R"(\\.\fdrawcmd)", GENERIC_READ | GENERIC_WRITE, 0, nullptr, OPEN_EXISTING, 0, nullptr);
if (h != INVALID_HANDLE_VALUE)
{
DeviceIoControl(h, IOCTL_FDRAWCMD_GET_VERSION, nullptr, 0, &version, sizeof(version), &ret, nullptr);
CloseHandle(h);
}
return version;
} |
bool CheckDriver();
bool IsFdcDriverRunning();
bool ReportDriverVersion();
| 7c7b86ef56c1c8283445f08d8f34a48a3c05490f3d2ed6066e0771d2008bb54b | 375 |
|
jam3sward | gxbase | glext_gen/win32/glexfp.cpp | stub_glMultiTexCoordPointerEXT |
GLAPI void APIENTRY stub_glMultiTexCoordPointerEXT (GLenum texunit, GLint size, GLenum type, GLsizei stride, const void *pointer) {
} |
glexfp::glexfp();
long glexfp::Count();
long glexfp::Known();
GLAPI void APIENTRY stub_glDrawRangeElements (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices);
GLAPI void APIENTRY stub_glTexImage3D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels);
GLAPI void APIENTRY stub_glTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);
GLAPI void APIENTRY stub_glCopyTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glActiveTexture (GLenum texture);
GLAPI void APIENTRY stub_glSampleCoverage (GLfloat value, GLboolean invert);
GLAPI void APIENTRY stub_glCompressedTexImage3D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data);
GLAPI void APIENTRY stub_glCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data);
GLAPI void APIENTRY stub_glCompressedTexImage1D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data);
GLAPI void APIENTRY stub_glCompressedTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data);
GLAPI void APIENTRY stub_glCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data);
GLAPI void APIENTRY stub_glCompressedTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data);
GLAPI void APIENTRY stub_glGetCompressedTexImage (GLenum target, GLint level, void *img);
GLAPI void APIENTRY stub_glClientActiveTexture (GLenum texture);
GLAPI void APIENTRY stub_glMultiTexCoord1d (GLenum target, GLdouble s);
GLAPI void APIENTRY stub_glMultiTexCoord1dv (GLenum target, const GLdouble *v);
GLAPI void APIENTRY stub_glMultiTexCoord1f (GLenum target, GLfloat s);
GLAPI void APIENTRY stub_glMultiTexCoord1fv (GLenum target, const GLfloat *v);
GLAPI void APIENTRY stub_glMultiTexCoord1i (GLenum target, GLint s);
GLAPI void APIENTRY stub_glMultiTexCoord1iv (GLenum target, const GLint *v);
GLAPI void APIENTRY stub_glMultiTexCoord1s (GLenum target, GLshort s);
GLAPI void APIENTRY stub_glMultiTexCoord1sv (GLenum target, const GLshort *v);
GLAPI void APIENTRY stub_glMultiTexCoord2d (GLenum target, GLdouble s, GLdouble t);
GLAPI void APIENTRY stub_glMultiTexCoord2dv (GLenum target, const GLdouble *v);
GLAPI void APIENTRY stub_glMultiTexCoord2f (GLenum target, GLfloat s, GLfloat t);
GLAPI void APIENTRY stub_glMultiTexCoord2fv (GLenum target, const GLfloat *v);
GLAPI void APIENTRY stub_glMultiTexCoord2i (GLenum target, GLint s, GLint t);
GLAPI void APIENTRY stub_glMultiTexCoord2iv (GLenum target, const GLint *v);
GLAPI void APIENTRY stub_glMultiTexCoord2s (GLenum target, GLshort s, GLshort t);
GLAPI void APIENTRY stub_glMultiTexCoord2sv (GLenum target, const GLshort *v);
GLAPI void APIENTRY stub_glMultiTexCoord3d (GLenum target, GLdouble s, GLdouble t, GLdouble r);
GLAPI void APIENTRY stub_glMultiTexCoord3dv (GLenum target, const GLdouble *v);
GLAPI void APIENTRY stub_glMultiTexCoord3f (GLenum target, GLfloat s, GLfloat t, GLfloat r);
GLAPI void APIENTRY stub_glMultiTexCoord3fv (GLenum target, const GLfloat *v);
GLAPI void APIENTRY stub_glMultiTexCoord3i (GLenum target, GLint s, GLint t, GLint r);
GLAPI void APIENTRY stub_glMultiTexCoord3iv (GLenum target, const GLint *v);
GLAPI void APIENTRY stub_glMultiTexCoord3s (GLenum target, GLshort s, GLshort t, GLshort r);
GLAPI void APIENTRY stub_glMultiTexCoord3sv (GLenum target, const GLshort *v);
GLAPI void APIENTRY stub_glMultiTexCoord4d (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
GLAPI void APIENTRY stub_glMultiTexCoord4dv (GLenum target, const GLdouble *v);
GLAPI void APIENTRY stub_glMultiTexCoord4f (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
GLAPI void APIENTRY stub_glMultiTexCoord4fv (GLenum target, const GLfloat *v);
GLAPI void APIENTRY stub_glMultiTexCoord4i (GLenum target, GLint s, GLint t, GLint r, GLint q);
GLAPI void APIENTRY stub_glMultiTexCoord4iv (GLenum target, const GLint *v);
GLAPI void APIENTRY stub_glMultiTexCoord4s (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
GLAPI void APIENTRY stub_glMultiTexCoord4sv (GLenum target, const GLshort *v);
GLAPI void APIENTRY stub_glLoadTransposeMatrixf (const GLfloat *m);
GLAPI void APIENTRY stub_glLoadTransposeMatrixd (const GLdouble *m);
GLAPI void APIENTRY stub_glMultTransposeMatrixf (const GLfloat *m);
GLAPI void APIENTRY stub_glMultTransposeMatrixd (const GLdouble *m);
GLAPI void APIENTRY stub_glBlendFuncSeparate (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
GLAPI void APIENTRY stub_glMultiDrawArrays (GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
GLAPI void APIENTRY stub_glMultiDrawElements (GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount);
GLAPI void APIENTRY stub_glPointParameterf (GLenum pname, GLfloat param);
GLAPI void APIENTRY stub_glPointParameterfv (GLenum pname, const GLfloat *params);
GLAPI void APIENTRY stub_glPointParameteri (GLenum pname, GLint param);
GLAPI void APIENTRY stub_glPointParameteriv (GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glFogCoordf (GLfloat coord);
GLAPI void APIENTRY stub_glFogCoordfv (const GLfloat *coord);
GLAPI void APIENTRY stub_glFogCoordd (GLdouble coord);
GLAPI void APIENTRY stub_glFogCoorddv (const GLdouble *coord);
GLAPI void APIENTRY stub_glFogCoordPointer (GLenum type, GLsizei stride, const void *pointer);
GLAPI void APIENTRY stub_glSecondaryColor3b (GLbyte red, GLbyte green, GLbyte blue);
GLAPI void APIENTRY stub_glSecondaryColor3bv (const GLbyte *v);
GLAPI void APIENTRY stub_glSecondaryColor3d (GLdouble red, GLdouble green, GLdouble blue);
GLAPI void APIENTRY stub_glSecondaryColor3dv (const GLdouble *v);
GLAPI void APIENTRY stub_glSecondaryColor3f (GLfloat red, GLfloat green, GLfloat blue);
GLAPI void APIENTRY stub_glSecondaryColor3fv (const GLfloat *v);
GLAPI void APIENTRY stub_glSecondaryColor3i (GLint red, GLint green, GLint blue);
GLAPI void APIENTRY stub_glSecondaryColor3iv (const GLint *v);
GLAPI void APIENTRY stub_glSecondaryColor3s (GLshort red, GLshort green, GLshort blue);
GLAPI void APIENTRY stub_glSecondaryColor3sv (const GLshort *v);
GLAPI void APIENTRY stub_glSecondaryColor3ub (GLubyte red, GLubyte green, GLubyte blue);
GLAPI void APIENTRY stub_glSecondaryColor3ubv (const GLubyte *v);
GLAPI void APIENTRY stub_glSecondaryColor3ui (GLuint red, GLuint green, GLuint blue);
GLAPI void APIENTRY stub_glSecondaryColor3uiv (const GLuint *v);
GLAPI void APIENTRY stub_glSecondaryColor3us (GLushort red, GLushort green, GLushort blue);
GLAPI void APIENTRY stub_glSecondaryColor3usv (const GLushort *v);
GLAPI void APIENTRY stub_glSecondaryColorPointer (GLint size, GLenum type, GLsizei stride, const void *pointer);
GLAPI void APIENTRY stub_glWindowPos2d (GLdouble x, GLdouble y);
GLAPI void APIENTRY stub_glWindowPos2dv (const GLdouble *v);
GLAPI void APIENTRY stub_glWindowPos2f (GLfloat x, GLfloat y);
GLAPI void APIENTRY stub_glWindowPos2fv (const GLfloat *v);
GLAPI void APIENTRY stub_glWindowPos2i (GLint x, GLint y);
GLAPI void APIENTRY stub_glWindowPos2iv (const GLint *v);
GLAPI void APIENTRY stub_glWindowPos2s (GLshort x, GLshort y);
GLAPI void APIENTRY stub_glWindowPos2sv (const GLshort *v);
GLAPI void APIENTRY stub_glWindowPos3d (GLdouble x, GLdouble y, GLdouble z);
GLAPI void APIENTRY stub_glWindowPos3dv (const GLdouble *v);
GLAPI void APIENTRY stub_glWindowPos3f (GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glWindowPos3fv (const GLfloat *v);
GLAPI void APIENTRY stub_glWindowPos3i (GLint x, GLint y, GLint z);
GLAPI void APIENTRY stub_glWindowPos3iv (const GLint *v);
GLAPI void APIENTRY stub_glWindowPos3s (GLshort x, GLshort y, GLshort z);
GLAPI void APIENTRY stub_glWindowPos3sv (const GLshort *v);
GLAPI void APIENTRY stub_glBlendColor (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
GLAPI void APIENTRY stub_glBlendEquation (GLenum mode);
GLAPI void APIENTRY stub_glGenQueries (GLsizei n, GLuint *ids);
GLAPI void APIENTRY stub_glDeleteQueries (GLsizei n, const GLuint *ids);
GLAPI GLboolean APIENTRY stub_glIsQuery (GLuint id);
GLAPI void APIENTRY stub_glBeginQuery (GLenum target, GLuint id);
GLAPI void APIENTRY stub_glEndQuery (GLenum target);
GLAPI void APIENTRY stub_glGetQueryiv (GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetQueryObjectiv (GLuint id, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetQueryObjectuiv (GLuint id, GLenum pname, GLuint *params);
GLAPI void APIENTRY stub_glBindBuffer (GLenum target, GLuint buffer);
GLAPI void APIENTRY stub_glDeleteBuffers (GLsizei n, const GLuint *buffers);
GLAPI void APIENTRY stub_glGenBuffers (GLsizei n, GLuint *buffers);
GLAPI GLboolean APIENTRY stub_glIsBuffer (GLuint buffer);
GLAPI void APIENTRY stub_glBufferData (GLenum target, GLsizeiptr size, const void *data, GLenum usage);
GLAPI void APIENTRY stub_glBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const void *data);
GLAPI void APIENTRY stub_glGetBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, void *data);
GLAPI void *APIENTRY stub_glMapBuffer (GLenum target, GLenum access);
GLAPI GLboolean APIENTRY stub_glUnmapBuffer (GLenum target);
GLAPI void APIENTRY stub_glGetBufferParameteriv (GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetBufferPointerv (GLenum target, GLenum pname, void **params);
GLAPI void APIENTRY stub_glBlendEquationSeparate (GLenum modeRGB, GLenum modeAlpha);
GLAPI void APIENTRY stub_glDrawBuffers (GLsizei n, const GLenum *bufs);
GLAPI void APIENTRY stub_glStencilOpSeparate (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
GLAPI void APIENTRY stub_glStencilFuncSeparate (GLenum face, GLenum func, GLint ref, GLuint mask);
GLAPI void APIENTRY stub_glStencilMaskSeparate (GLenum face, GLuint mask);
GLAPI void APIENTRY stub_glAttachShader (GLuint program, GLuint shader);
GLAPI void APIENTRY stub_glBindAttribLocation (GLuint program, GLuint index, const GLchar *name);
GLAPI void APIENTRY stub_glCompileShader (GLuint shader);
GLAPI GLuint APIENTRY stub_glCreateProgram (void);
GLAPI GLuint APIENTRY stub_glCreateShader (GLenum type);
GLAPI void APIENTRY stub_glDeleteProgram (GLuint program);
GLAPI void APIENTRY stub_glDeleteShader (GLuint shader);
GLAPI void APIENTRY stub_glDetachShader (GLuint program, GLuint shader);
GLAPI void APIENTRY stub_glDisableVertexAttribArray (GLuint index);
GLAPI void APIENTRY stub_glEnableVertexAttribArray (GLuint index);
GLAPI void APIENTRY stub_glGetActiveAttrib (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
GLAPI void APIENTRY stub_glGetActiveUniform (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
GLAPI void APIENTRY stub_glGetAttachedShaders (GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders);
GLAPI GLint APIENTRY stub_glGetAttribLocation (GLuint program, const GLchar *name);
GLAPI void APIENTRY stub_glGetProgramiv (GLuint program, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetProgramInfoLog (GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
GLAPI void APIENTRY stub_glGetShaderiv (GLuint shader, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetShaderInfoLog (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
GLAPI void APIENTRY stub_glGetShaderSource (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
GLAPI GLint APIENTRY stub_glGetUniformLocation (GLuint program, const GLchar *name);
GLAPI void APIENTRY stub_glGetUniformfv (GLuint program, GLint location, GLfloat *params);
GLAPI void APIENTRY stub_glGetUniformiv (GLuint program, GLint location, GLint *params);
GLAPI void APIENTRY stub_glGetVertexAttribdv (GLuint index, GLenum pname, GLdouble *params);
GLAPI void APIENTRY stub_glGetVertexAttribfv (GLuint index, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetVertexAttribiv (GLuint index, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetVertexAttribPointerv (GLuint index, GLenum pname, void **pointer);
GLAPI GLboolean APIENTRY stub_glIsProgram (GLuint program);
GLAPI GLboolean APIENTRY stub_glIsShader (GLuint shader);
GLAPI void APIENTRY stub_glLinkProgram (GLuint program);
GLAPI void APIENTRY stub_glShaderSource (GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length);
GLAPI void APIENTRY stub_glUseProgram (GLuint program);
GLAPI void APIENTRY stub_glUniform1f (GLint location, GLfloat v0);
GLAPI void APIENTRY stub_glUniform2f (GLint location, GLfloat v0, GLfloat v1);
GLAPI void APIENTRY stub_glUniform3f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
GLAPI void APIENTRY stub_glUniform4f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
GLAPI void APIENTRY stub_glUniform1i (GLint location, GLint v0);
GLAPI void APIENTRY stub_glUniform2i (GLint location, GLint v0, GLint v1);
GLAPI void APIENTRY stub_glUniform3i (GLint location, GLint v0, GLint v1, GLint v2);
GLAPI void APIENTRY stub_glUniform4i (GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
GLAPI void APIENTRY stub_glUniform1fv (GLint location, GLsizei count, const GLfloat *value);
GLAPI void APIENTRY stub_glUniform2fv (GLint location, GLsizei count, const GLfloat *value);
GLAPI void APIENTRY stub_glUniform3fv (GLint location, GLsizei count, const GLfloat *value);
GLAPI void APIENTRY stub_glUniform4fv (GLint location, GLsizei count, const GLfloat *value);
GLAPI void APIENTRY stub_glUniform1iv (GLint location, GLsizei count, const GLint *value);
GLAPI void APIENTRY stub_glUniform2iv (GLint location, GLsizei count, const GLint *value);
GLAPI void APIENTRY stub_glUniform3iv (GLint location, GLsizei count, const GLint *value);
GLAPI void APIENTRY stub_glUniform4iv (GLint location, GLsizei count, const GLint *value);
GLAPI void APIENTRY stub_glUniformMatrix2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glUniformMatrix3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glUniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glValidateProgram (GLuint program);
GLAPI void APIENTRY stub_glVertexAttrib1d (GLuint index, GLdouble x);
GLAPI void APIENTRY stub_glVertexAttrib1dv (GLuint index, const GLdouble *v);
GLAPI void APIENTRY stub_glVertexAttrib1f (GLuint index, GLfloat x);
GLAPI void APIENTRY stub_glVertexAttrib1fv (GLuint index, const GLfloat *v);
GLAPI void APIENTRY stub_glVertexAttrib1s (GLuint index, GLshort x);
GLAPI void APIENTRY stub_glVertexAttrib1sv (GLuint index, const GLshort *v);
GLAPI void APIENTRY stub_glVertexAttrib2d (GLuint index, GLdouble x, GLdouble y);
GLAPI void APIENTRY stub_glVertexAttrib2dv (GLuint index, const GLdouble *v);
GLAPI void APIENTRY stub_glVertexAttrib2f (GLuint index, GLfloat x, GLfloat y);
GLAPI void APIENTRY stub_glVertexAttrib2fv (GLuint index, const GLfloat *v);
GLAPI void APIENTRY stub_glVertexAttrib2s (GLuint index, GLshort x, GLshort y);
GLAPI void APIENTRY stub_glVertexAttrib2sv (GLuint index, const GLshort *v);
GLAPI void APIENTRY stub_glVertexAttrib3d (GLuint index, GLdouble x, GLdouble y, GLdouble z);
GLAPI void APIENTRY stub_glVertexAttrib3dv (GLuint index, const GLdouble *v);
GLAPI void APIENTRY stub_glVertexAttrib3f (GLuint index, GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glVertexAttrib3fv (GLuint index, const GLfloat *v);
GLAPI void APIENTRY stub_glVertexAttrib3s (GLuint index, GLshort x, GLshort y, GLshort z);
GLAPI void APIENTRY stub_glVertexAttrib3sv (GLuint index, const GLshort *v);
GLAPI void APIENTRY stub_glVertexAttrib4Nbv (GLuint index, const GLbyte *v);
GLAPI void APIENTRY stub_glVertexAttrib4Niv (GLuint index, const GLint *v);
GLAPI void APIENTRY stub_glVertexAttrib4Nsv (GLuint index, const GLshort *v);
GLAPI void APIENTRY stub_glVertexAttrib4Nub (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
GLAPI void APIENTRY stub_glVertexAttrib4Nubv (GLuint index, const GLubyte *v);
GLAPI void APIENTRY stub_glVertexAttrib4Nuiv (GLuint index, const GLuint *v);
GLAPI void APIENTRY stub_glVertexAttrib4Nusv (GLuint index, const GLushort *v);
GLAPI void APIENTRY stub_glVertexAttrib4bv (GLuint index, const GLbyte *v);
GLAPI void APIENTRY stub_glVertexAttrib4d (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
GLAPI void APIENTRY stub_glVertexAttrib4dv (GLuint index, const GLdouble *v);
GLAPI void APIENTRY stub_glVertexAttrib4f (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
GLAPI void APIENTRY stub_glVertexAttrib4fv (GLuint index, const GLfloat *v);
GLAPI void APIENTRY stub_glVertexAttrib4iv (GLuint index, const GLint *v);
GLAPI void APIENTRY stub_glVertexAttrib4s (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
GLAPI void APIENTRY stub_glVertexAttrib4sv (GLuint index, const GLshort *v);
GLAPI void APIENTRY stub_glVertexAttrib4ubv (GLuint index, const GLubyte *v);
GLAPI void APIENTRY stub_glVertexAttrib4uiv (GLuint index, const GLuint *v);
GLAPI void APIENTRY stub_glVertexAttrib4usv (GLuint index, const GLushort *v);
GLAPI void APIENTRY stub_glVertexAttribPointer (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer);
GLAPI void APIENTRY stub_glUniformMatrix2x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glUniformMatrix3x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glUniformMatrix2x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glUniformMatrix4x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glUniformMatrix3x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glUniformMatrix4x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glColorMaski (GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
GLAPI void APIENTRY stub_glGetBooleani_v (GLenum target, GLuint index, GLboolean *data);
GLAPI void APIENTRY stub_glGetIntegeri_v (GLenum target, GLuint index, GLint *data);
GLAPI void APIENTRY stub_glEnablei (GLenum target, GLuint index);
GLAPI void APIENTRY stub_glDisablei (GLenum target, GLuint index);
GLAPI GLboolean APIENTRY stub_glIsEnabledi (GLenum target, GLuint index);
GLAPI void APIENTRY stub_glBeginTransformFeedback (GLenum primitiveMode);
GLAPI void APIENTRY stub_glEndTransformFeedback (void);
GLAPI void APIENTRY stub_glBindBufferRange (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
GLAPI void APIENTRY stub_glBindBufferBase (GLenum target, GLuint index, GLuint buffer);
GLAPI void APIENTRY stub_glTransformFeedbackVaryings (GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode);
GLAPI void APIENTRY stub_glGetTransformFeedbackVarying (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
GLAPI void APIENTRY stub_glClampColor (GLenum target, GLenum clamp);
GLAPI void APIENTRY stub_glBeginConditionalRender (GLuint id, GLenum mode);
GLAPI void APIENTRY stub_glEndConditionalRender (void);
GLAPI void APIENTRY stub_glVertexAttribIPointer (GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer);
GLAPI void APIENTRY stub_glGetVertexAttribIiv (GLuint index, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetVertexAttribIuiv (GLuint index, GLenum pname, GLuint *params);
GLAPI void APIENTRY stub_glVertexAttribI1i (GLuint index, GLint x);
GLAPI void APIENTRY stub_glVertexAttribI2i (GLuint index, GLint x, GLint y);
GLAPI void APIENTRY stub_glVertexAttribI3i (GLuint index, GLint x, GLint y, GLint z);
GLAPI void APIENTRY stub_glVertexAttribI4i (GLuint index, GLint x, GLint y, GLint z, GLint w);
GLAPI void APIENTRY stub_glVertexAttribI1ui (GLuint index, GLuint x);
GLAPI void APIENTRY stub_glVertexAttribI2ui (GLuint index, GLuint x, GLuint y);
GLAPI void APIENTRY stub_glVertexAttribI3ui (GLuint index, GLuint x, GLuint y, GLuint z);
GLAPI void APIENTRY stub_glVertexAttribI4ui (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
GLAPI void APIENTRY stub_glVertexAttribI1iv (GLuint index, const GLint *v);
GLAPI void APIENTRY stub_glVertexAttribI2iv (GLuint index, const GLint *v);
GLAPI void APIENTRY stub_glVertexAttribI3iv (GLuint index, const GLint *v);
GLAPI void APIENTRY stub_glVertexAttribI4iv (GLuint index, const GLint *v);
GLAPI void APIENTRY stub_glVertexAttribI1uiv (GLuint index, const GLuint *v);
GLAPI void APIENTRY stub_glVertexAttribI2uiv (GLuint index, const GLuint *v);
GLAPI void APIENTRY stub_glVertexAttribI3uiv (GLuint index, const GLuint *v);
GLAPI void APIENTRY stub_glVertexAttribI4uiv (GLuint index, const GLuint *v);
GLAPI void APIENTRY stub_glVertexAttribI4bv (GLuint index, const GLbyte *v);
GLAPI void APIENTRY stub_glVertexAttribI4sv (GLuint index, const GLshort *v);
GLAPI void APIENTRY stub_glVertexAttribI4ubv (GLuint index, const GLubyte *v);
GLAPI void APIENTRY stub_glVertexAttribI4usv (GLuint index, const GLushort *v);
GLAPI void APIENTRY stub_glGetUniformuiv (GLuint program, GLint location, GLuint *params);
GLAPI void APIENTRY stub_glBindFragDataLocation (GLuint program, GLuint color, const GLchar *name);
GLAPI GLint APIENTRY stub_glGetFragDataLocation (GLuint program, const GLchar *name);
GLAPI void APIENTRY stub_glUniform1ui (GLint location, GLuint v0);
GLAPI void APIENTRY stub_glUniform2ui (GLint location, GLuint v0, GLuint v1);
GLAPI void APIENTRY stub_glUniform3ui (GLint location, GLuint v0, GLuint v1, GLuint v2);
GLAPI void APIENTRY stub_glUniform4ui (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
GLAPI void APIENTRY stub_glUniform1uiv (GLint location, GLsizei count, const GLuint *value);
GLAPI void APIENTRY stub_glUniform2uiv (GLint location, GLsizei count, const GLuint *value);
GLAPI void APIENTRY stub_glUniform3uiv (GLint location, GLsizei count, const GLuint *value);
GLAPI void APIENTRY stub_glUniform4uiv (GLint location, GLsizei count, const GLuint *value);
GLAPI void APIENTRY stub_glTexParameterIiv (GLenum target, GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glTexParameterIuiv (GLenum target, GLenum pname, const GLuint *params);
GLAPI void APIENTRY stub_glGetTexParameterIiv (GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetTexParameterIuiv (GLenum target, GLenum pname, GLuint *params);
GLAPI void APIENTRY stub_glClearBufferiv (GLenum buffer, GLint drawbuffer, const GLint *value);
GLAPI void APIENTRY stub_glClearBufferuiv (GLenum buffer, GLint drawbuffer, const GLuint *value);
GLAPI void APIENTRY stub_glClearBufferfv (GLenum buffer, GLint drawbuffer, const GLfloat *value);
GLAPI void APIENTRY stub_glClearBufferfi (GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
GLAPI const GLubyte *APIENTRY stub_glGetStringi (GLenum name, GLuint index);
GLAPI GLboolean APIENTRY stub_glIsRenderbuffer (GLuint renderbuffer);
GLAPI void APIENTRY stub_glBindRenderbuffer (GLenum target, GLuint renderbuffer);
GLAPI void APIENTRY stub_glDeleteRenderbuffers (GLsizei n, const GLuint *renderbuffers);
GLAPI void APIENTRY stub_glGenRenderbuffers (GLsizei n, GLuint *renderbuffers);
GLAPI void APIENTRY stub_glRenderbufferStorage (GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glGetRenderbufferParameteriv (GLenum target, GLenum pname, GLint *params);
GLAPI GLboolean APIENTRY stub_glIsFramebuffer (GLuint framebuffer);
GLAPI void APIENTRY stub_glBindFramebuffer (GLenum target, GLuint framebuffer);
GLAPI void APIENTRY stub_glDeleteFramebuffers (GLsizei n, const GLuint *framebuffers);
GLAPI void APIENTRY stub_glGenFramebuffers (GLsizei n, GLuint *framebuffers);
GLAPI GLenum APIENTRY stub_glCheckFramebufferStatus (GLenum target);
GLAPI void APIENTRY stub_glFramebufferTexture1D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
GLAPI void APIENTRY stub_glFramebufferTexture2D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
GLAPI void APIENTRY stub_glFramebufferTexture3D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
GLAPI void APIENTRY stub_glFramebufferRenderbuffer (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
GLAPI void APIENTRY stub_glGetFramebufferAttachmentParameteriv (GLenum target, GLenum attachment, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGenerateMipmap (GLenum target);
GLAPI void APIENTRY stub_glBlitFramebuffer (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
GLAPI void APIENTRY stub_glRenderbufferStorageMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glFramebufferTextureLayer (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
GLAPI void *APIENTRY stub_glMapBufferRange (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
GLAPI void APIENTRY stub_glFlushMappedBufferRange (GLenum target, GLintptr offset, GLsizeiptr length);
GLAPI void APIENTRY stub_glBindVertexArray (GLuint array);
GLAPI void APIENTRY stub_glDeleteVertexArrays (GLsizei n, const GLuint *arrays);
GLAPI void APIENTRY stub_glGenVertexArrays (GLsizei n, GLuint *arrays);
GLAPI GLboolean APIENTRY stub_glIsVertexArray (GLuint array);
GLAPI void APIENTRY stub_glDrawArraysInstanced (GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
GLAPI void APIENTRY stub_glDrawElementsInstanced (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount);
GLAPI void APIENTRY stub_glTexBuffer (GLenum target, GLenum internalformat, GLuint buffer);
GLAPI void APIENTRY stub_glPrimitiveRestartIndex (GLuint index);
GLAPI void APIENTRY stub_glCopyBufferSubData (GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
GLAPI void APIENTRY stub_glGetUniformIndices (GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices);
GLAPI void APIENTRY stub_glGetActiveUniformsiv (GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetActiveUniformName (GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
GLAPI GLuint APIENTRY stub_glGetUniformBlockIndex (GLuint program, const GLchar *uniformBlockName);
GLAPI void APIENTRY stub_glGetActiveUniformBlockiv (GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetActiveUniformBlockName (GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
GLAPI void APIENTRY stub_glUniformBlockBinding (GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
GLAPI void APIENTRY stub_glDrawElementsBaseVertex (GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex);
GLAPI void APIENTRY stub_glDrawRangeElementsBaseVertex (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex);
GLAPI void APIENTRY stub_glDrawElementsInstancedBaseVertex (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex);
GLAPI void APIENTRY stub_glMultiDrawElementsBaseVertex (GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex);
GLAPI void APIENTRY stub_glProvokingVertex (GLenum mode);
GLAPI GLsync APIENTRY stub_glFenceSync (GLenum condition, GLbitfield flags);
GLAPI GLboolean APIENTRY stub_glIsSync (GLsync sync);
GLAPI void APIENTRY stub_glDeleteSync (GLsync sync);
GLAPI GLenum APIENTRY stub_glClientWaitSync (GLsync sync, GLbitfield flags, GLuint64 timeout);
GLAPI void APIENTRY stub_glWaitSync (GLsync sync, GLbitfield flags, GLuint64 timeout);
GLAPI void APIENTRY stub_glGetInteger64v (GLenum pname, GLint64 *data);
GLAPI void APIENTRY stub_glGetSynciv (GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
GLAPI void APIENTRY stub_glGetInteger64i_v (GLenum target, GLuint index, GLint64 *data);
GLAPI void APIENTRY stub_glGetBufferParameteri64v (GLenum target, GLenum pname, GLint64 *params);
GLAPI void APIENTRY stub_glFramebufferTexture (GLenum target, GLenum attachment, GLuint texture, GLint level);
GLAPI void APIENTRY stub_glTexImage2DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
GLAPI void APIENTRY stub_glTexImage3DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
GLAPI void APIENTRY stub_glGetMultisamplefv (GLenum pname, GLuint index, GLfloat *val);
GLAPI void APIENTRY stub_glSampleMaski (GLuint maskNumber, GLbitfield mask);
GLAPI void APIENTRY stub_glBindFragDataLocationIndexed (GLuint program, GLuint colorNumber, GLuint index, const GLchar *name);
GLAPI GLint APIENTRY stub_glGetFragDataIndex (GLuint program, const GLchar *name);
GLAPI void APIENTRY stub_glGenSamplers (GLsizei count, GLuint *samplers);
GLAPI void APIENTRY stub_glDeleteSamplers (GLsizei count, const GLuint *samplers);
GLAPI GLboolean APIENTRY stub_glIsSampler (GLuint sampler);
GLAPI void APIENTRY stub_glBindSampler (GLuint unit, GLuint sampler);
GLAPI void APIENTRY stub_glSamplerParameteri (GLuint sampler, GLenum pname, GLint param);
GLAPI void APIENTRY stub_glSamplerParameteriv (GLuint sampler, GLenum pname, const GLint *param);
GLAPI void APIENTRY stub_glSamplerParameterf (GLuint sampler, GLenum pname, GLfloat param);
GLAPI void APIENTRY stub_glSamplerParameterfv (GLuint sampler, GLenum pname, const GLfloat *param);
GLAPI void APIENTRY stub_glSamplerParameterIiv (GLuint sampler, GLenum pname, const GLint *param);
GLAPI void APIENTRY stub_glSamplerParameterIuiv (GLuint sampler, GLenum pname, const GLuint *param);
GLAPI void APIENTRY stub_glGetSamplerParameteriv (GLuint sampler, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetSamplerParameterIiv (GLuint sampler, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetSamplerParameterfv (GLuint sampler, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetSamplerParameterIuiv (GLuint sampler, GLenum pname, GLuint *params);
GLAPI void APIENTRY stub_glQueryCounter (GLuint id, GLenum target);
GLAPI void APIENTRY stub_glGetQueryObjecti64v (GLuint id, GLenum pname, GLint64 *params);
GLAPI void APIENTRY stub_glGetQueryObjectui64v (GLuint id, GLenum pname, GLuint64 *params);
GLAPI void APIENTRY stub_glVertexAttribDivisor (GLuint index, GLuint divisor);
GLAPI void APIENTRY stub_glVertexAttribP1ui (GLuint index, GLenum type, GLboolean normalized, GLuint value);
GLAPI void APIENTRY stub_glVertexAttribP1uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
GLAPI void APIENTRY stub_glVertexAttribP2ui (GLuint index, GLenum type, GLboolean normalized, GLuint value);
GLAPI void APIENTRY stub_glVertexAttribP2uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
GLAPI void APIENTRY stub_glVertexAttribP3ui (GLuint index, GLenum type, GLboolean normalized, GLuint value);
GLAPI void APIENTRY stub_glVertexAttribP3uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
GLAPI void APIENTRY stub_glVertexAttribP4ui (GLuint index, GLenum type, GLboolean normalized, GLuint value);
GLAPI void APIENTRY stub_glVertexAttribP4uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
GLAPI void APIENTRY stub_glVertexP2ui (GLenum type, GLuint value);
GLAPI void APIENTRY stub_glVertexP2uiv (GLenum type, const GLuint *value);
GLAPI void APIENTRY stub_glVertexP3ui (GLenum type, GLuint value);
GLAPI void APIENTRY stub_glVertexP3uiv (GLenum type, const GLuint *value);
GLAPI void APIENTRY stub_glVertexP4ui (GLenum type, GLuint value);
GLAPI void APIENTRY stub_glVertexP4uiv (GLenum type, const GLuint *value);
GLAPI void APIENTRY stub_glTexCoordP1ui (GLenum type, GLuint coords);
GLAPI void APIENTRY stub_glTexCoordP1uiv (GLenum type, const GLuint *coords);
GLAPI void APIENTRY stub_glTexCoordP2ui (GLenum type, GLuint coords);
GLAPI void APIENTRY stub_glTexCoordP2uiv (GLenum type, const GLuint *coords);
GLAPI void APIENTRY stub_glTexCoordP3ui (GLenum type, GLuint coords);
GLAPI void APIENTRY stub_glTexCoordP3uiv (GLenum type, const GLuint *coords);
GLAPI void APIENTRY stub_glTexCoordP4ui (GLenum type, GLuint coords);
GLAPI void APIENTRY stub_glTexCoordP4uiv (GLenum type, const GLuint *coords);
GLAPI void APIENTRY stub_glMultiTexCoordP1ui (GLenum texture, GLenum type, GLuint coords);
GLAPI void APIENTRY stub_glMultiTexCoordP1uiv (GLenum texture, GLenum type, const GLuint *coords);
GLAPI void APIENTRY stub_glMultiTexCoordP2ui (GLenum texture, GLenum type, GLuint coords);
GLAPI void APIENTRY stub_glMultiTexCoordP2uiv (GLenum texture, GLenum type, const GLuint *coords);
GLAPI void APIENTRY stub_glMultiTexCoordP3ui (GLenum texture, GLenum type, GLuint coords);
GLAPI void APIENTRY stub_glMultiTexCoordP3uiv (GLenum texture, GLenum type, const GLuint *coords);
GLAPI void APIENTRY stub_glMultiTexCoordP4ui (GLenum texture, GLenum type, GLuint coords);
GLAPI void APIENTRY stub_glMultiTexCoordP4uiv (GLenum texture, GLenum type, const GLuint *coords);
GLAPI void APIENTRY stub_glNormalP3ui (GLenum type, GLuint coords);
GLAPI void APIENTRY stub_glNormalP3uiv (GLenum type, const GLuint *coords);
GLAPI void APIENTRY stub_glColorP3ui (GLenum type, GLuint color);
GLAPI void APIENTRY stub_glColorP3uiv (GLenum type, const GLuint *color);
GLAPI void APIENTRY stub_glColorP4ui (GLenum type, GLuint color);
GLAPI void APIENTRY stub_glColorP4uiv (GLenum type, const GLuint *color);
GLAPI void APIENTRY stub_glSecondaryColorP3ui (GLenum type, GLuint color);
GLAPI void APIENTRY stub_glSecondaryColorP3uiv (GLenum type, const GLuint *color);
GLAPI void APIENTRY stub_glMinSampleShading (GLfloat value);
GLAPI void APIENTRY stub_glBlendEquationi (GLuint buf, GLenum mode);
GLAPI void APIENTRY stub_glBlendEquationSeparatei (GLuint buf, GLenum modeRGB, GLenum modeAlpha);
GLAPI void APIENTRY stub_glBlendFunci (GLuint buf, GLenum src, GLenum dst);
GLAPI void APIENTRY stub_glBlendFuncSeparatei (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
GLAPI void APIENTRY stub_glDrawArraysIndirect (GLenum mode, const void *indirect);
GLAPI void APIENTRY stub_glDrawElementsIndirect (GLenum mode, GLenum type, const void *indirect);
GLAPI void APIENTRY stub_glUniform1d (GLint location, GLdouble x);
GLAPI void APIENTRY stub_glUniform2d (GLint location, GLdouble x, GLdouble y);
GLAPI void APIENTRY stub_glUniform3d (GLint location, GLdouble x, GLdouble y, GLdouble z);
GLAPI void APIENTRY stub_glUniform4d (GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
GLAPI void APIENTRY stub_glUniform1dv (GLint location, GLsizei count, const GLdouble *value);
GLAPI void APIENTRY stub_glUniform2dv (GLint location, GLsizei count, const GLdouble *value);
GLAPI void APIENTRY stub_glUniform3dv (GLint location, GLsizei count, const GLdouble *value);
GLAPI void APIENTRY stub_glUniform4dv (GLint location, GLsizei count, const GLdouble *value);
GLAPI void APIENTRY stub_glUniformMatrix2dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glUniformMatrix3dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glUniformMatrix4dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glUniformMatrix2x3dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glUniformMatrix2x4dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glUniformMatrix3x2dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glUniformMatrix3x4dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glUniformMatrix4x2dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glUniformMatrix4x3dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glGetUniformdv (GLuint program, GLint location, GLdouble *params);
GLAPI GLint APIENTRY stub_glGetSubroutineUniformLocation (GLuint program, GLenum shadertype, const GLchar *name);
GLAPI GLuint APIENTRY stub_glGetSubroutineIndex (GLuint program, GLenum shadertype, const GLchar *name);
GLAPI void APIENTRY stub_glGetActiveSubroutineUniformiv (GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values);
GLAPI void APIENTRY stub_glGetActiveSubroutineUniformName (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
GLAPI void APIENTRY stub_glGetActiveSubroutineName (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
GLAPI void APIENTRY stub_glUniformSubroutinesuiv (GLenum shadertype, GLsizei count, const GLuint *indices);
GLAPI void APIENTRY stub_glGetUniformSubroutineuiv (GLenum shadertype, GLint location, GLuint *params);
GLAPI void APIENTRY stub_glGetProgramStageiv (GLuint program, GLenum shadertype, GLenum pname, GLint *values);
GLAPI void APIENTRY stub_glPatchParameteri (GLenum pname, GLint value);
GLAPI void APIENTRY stub_glPatchParameterfv (GLenum pname, const GLfloat *values);
GLAPI void APIENTRY stub_glBindTransformFeedback (GLenum target, GLuint id);
GLAPI void APIENTRY stub_glDeleteTransformFeedbacks (GLsizei n, const GLuint *ids);
GLAPI void APIENTRY stub_glGenTransformFeedbacks (GLsizei n, GLuint *ids);
GLAPI GLboolean APIENTRY stub_glIsTransformFeedback (GLuint id);
GLAPI void APIENTRY stub_glPauseTransformFeedback (void);
GLAPI void APIENTRY stub_glResumeTransformFeedback (void);
GLAPI void APIENTRY stub_glDrawTransformFeedback (GLenum mode, GLuint id);
GLAPI void APIENTRY stub_glDrawTransformFeedbackStream (GLenum mode, GLuint id, GLuint stream);
GLAPI void APIENTRY stub_glBeginQueryIndexed (GLenum target, GLuint index, GLuint id);
GLAPI void APIENTRY stub_glEndQueryIndexed (GLenum target, GLuint index);
GLAPI void APIENTRY stub_glGetQueryIndexediv (GLenum target, GLuint index, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glReleaseShaderCompiler (void);
GLAPI void APIENTRY stub_glShaderBinary (GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length);
GLAPI void APIENTRY stub_glGetShaderPrecisionFormat (GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision);
GLAPI void APIENTRY stub_glDepthRangef (GLfloat n, GLfloat f);
GLAPI void APIENTRY stub_glClearDepthf (GLfloat d);
GLAPI void APIENTRY stub_glGetProgramBinary (GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary);
GLAPI void APIENTRY stub_glProgramBinary (GLuint program, GLenum binaryFormat, const void *binary, GLsizei length);
GLAPI void APIENTRY stub_glProgramParameteri (GLuint program, GLenum pname, GLint value);
GLAPI void APIENTRY stub_glUseProgramStages (GLuint pipeline, GLbitfield stages, GLuint program);
GLAPI void APIENTRY stub_glActiveShaderProgram (GLuint pipeline, GLuint program);
GLAPI GLuint APIENTRY stub_glCreateShaderProgramv (GLenum type, GLsizei count, const GLchar *const*strings);
GLAPI void APIENTRY stub_glBindProgramPipeline (GLuint pipeline);
GLAPI void APIENTRY stub_glDeleteProgramPipelines (GLsizei n, const GLuint *pipelines);
GLAPI void APIENTRY stub_glGenProgramPipelines (GLsizei n, GLuint *pipelines);
GLAPI GLboolean APIENTRY stub_glIsProgramPipeline (GLuint pipeline);
GLAPI void APIENTRY stub_glGetProgramPipelineiv (GLuint pipeline, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glProgramUniform1i (GLuint program, GLint location, GLint v0);
GLAPI void APIENTRY stub_glProgramUniform1iv (GLuint program, GLint location, GLsizei count, const GLint *value);
GLAPI void APIENTRY stub_glProgramUniform1f (GLuint program, GLint location, GLfloat v0);
GLAPI void APIENTRY stub_glProgramUniform1fv (GLuint program, GLint location, GLsizei count, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniform1d (GLuint program, GLint location, GLdouble v0);
GLAPI void APIENTRY stub_glProgramUniform1dv (GLuint program, GLint location, GLsizei count, const GLdouble *value);
GLAPI void APIENTRY stub_glProgramUniform1ui (GLuint program, GLint location, GLuint v0);
GLAPI void APIENTRY stub_glProgramUniform1uiv (GLuint program, GLint location, GLsizei count, const GLuint *value);
GLAPI void APIENTRY stub_glProgramUniform2i (GLuint program, GLint location, GLint v0, GLint v1);
GLAPI void APIENTRY stub_glProgramUniform2iv (GLuint program, GLint location, GLsizei count, const GLint *value);
GLAPI void APIENTRY stub_glProgramUniform2f (GLuint program, GLint location, GLfloat v0, GLfloat v1);
GLAPI void APIENTRY stub_glProgramUniform2fv (GLuint program, GLint location, GLsizei count, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniform2d (GLuint program, GLint location, GLdouble v0, GLdouble v1);
GLAPI void APIENTRY stub_glProgramUniform2dv (GLuint program, GLint location, GLsizei count, const GLdouble *value);
GLAPI void APIENTRY stub_glProgramUniform2ui (GLuint program, GLint location, GLuint v0, GLuint v1);
GLAPI void APIENTRY stub_glProgramUniform2uiv (GLuint program, GLint location, GLsizei count, const GLuint *value);
GLAPI void APIENTRY stub_glProgramUniform3i (GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
GLAPI void APIENTRY stub_glProgramUniform3iv (GLuint program, GLint location, GLsizei count, const GLint *value);
GLAPI void APIENTRY stub_glProgramUniform3f (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
GLAPI void APIENTRY stub_glProgramUniform3fv (GLuint program, GLint location, GLsizei count, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniform3d (GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2);
GLAPI void APIENTRY stub_glProgramUniform3dv (GLuint program, GLint location, GLsizei count, const GLdouble *value);
GLAPI void APIENTRY stub_glProgramUniform3ui (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
GLAPI void APIENTRY stub_glProgramUniform3uiv (GLuint program, GLint location, GLsizei count, const GLuint *value);
GLAPI void APIENTRY stub_glProgramUniform4i (GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
GLAPI void APIENTRY stub_glProgramUniform4iv (GLuint program, GLint location, GLsizei count, const GLint *value);
GLAPI void APIENTRY stub_glProgramUniform4f (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
GLAPI void APIENTRY stub_glProgramUniform4fv (GLuint program, GLint location, GLsizei count, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniform4d (GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3);
GLAPI void APIENTRY stub_glProgramUniform4dv (GLuint program, GLint location, GLsizei count, const GLdouble *value);
GLAPI void APIENTRY stub_glProgramUniform4ui (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
GLAPI void APIENTRY stub_glProgramUniform4uiv (GLuint program, GLint location, GLsizei count, const GLuint *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix2fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix3fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix4fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix2dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix3dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix4dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix2x3fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix3x2fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix2x4fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix4x2fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix3x4fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix4x3fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix2x3dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix3x2dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix2x4dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix4x2dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix3x4dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix4x3dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glValidateProgramPipeline (GLuint pipeline);
GLAPI void APIENTRY stub_glGetProgramPipelineInfoLog (GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
GLAPI void APIENTRY stub_glVertexAttribL1d (GLuint index, GLdouble x);
GLAPI void APIENTRY stub_glVertexAttribL2d (GLuint index, GLdouble x, GLdouble y);
GLAPI void APIENTRY stub_glVertexAttribL3d (GLuint index, GLdouble x, GLdouble y, GLdouble z);
GLAPI void APIENTRY stub_glVertexAttribL4d (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
GLAPI void APIENTRY stub_glVertexAttribL1dv (GLuint index, const GLdouble *v);
GLAPI void APIENTRY stub_glVertexAttribL2dv (GLuint index, const GLdouble *v);
GLAPI void APIENTRY stub_glVertexAttribL3dv (GLuint index, const GLdouble *v);
GLAPI void APIENTRY stub_glVertexAttribL4dv (GLuint index, const GLdouble *v);
GLAPI void APIENTRY stub_glVertexAttribLPointer (GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer);
GLAPI void APIENTRY stub_glGetVertexAttribLdv (GLuint index, GLenum pname, GLdouble *params);
GLAPI void APIENTRY stub_glViewportArrayv (GLuint first, GLsizei count, const GLfloat *v);
GLAPI void APIENTRY stub_glViewportIndexedf (GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
GLAPI void APIENTRY stub_glViewportIndexedfv (GLuint index, const GLfloat *v);
GLAPI void APIENTRY stub_glScissorArrayv (GLuint first, GLsizei count, const GLint *v);
GLAPI void APIENTRY stub_glScissorIndexed (GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glScissorIndexedv (GLuint index, const GLint *v);
GLAPI void APIENTRY stub_glDepthRangeArrayv (GLuint first, GLsizei count, const GLdouble *v);
GLAPI void APIENTRY stub_glDepthRangeIndexed (GLuint index, GLdouble n, GLdouble f);
GLAPI void APIENTRY stub_glGetFloati_v (GLenum target, GLuint index, GLfloat *data);
GLAPI void APIENTRY stub_glGetDoublei_v (GLenum target, GLuint index, GLdouble *data);
GLAPI void APIENTRY stub_glDrawArraysInstancedBaseInstance (GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance);
GLAPI void APIENTRY stub_glDrawElementsInstancedBaseInstance (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance);
GLAPI void APIENTRY stub_glDrawElementsInstancedBaseVertexBaseInstance (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance);
GLAPI void APIENTRY stub_glGetInternalformativ (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params);
GLAPI void APIENTRY stub_glGetActiveAtomicCounterBufferiv (GLuint program, GLuint bufferIndex, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glBindImageTexture (GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format);
GLAPI void APIENTRY stub_glMemoryBarrier (GLbitfield barriers);
GLAPI void APIENTRY stub_glTexStorage1D (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
GLAPI void APIENTRY stub_glTexStorage2D (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glTexStorage3D (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
GLAPI void APIENTRY stub_glDrawTransformFeedbackInstanced (GLenum mode, GLuint id, GLsizei instancecount);
GLAPI void APIENTRY stub_glDrawTransformFeedbackStreamInstanced (GLenum mode, GLuint id, GLuint stream, GLsizei instancecount);
GLAPI void APIENTRY stub_glClearBufferData (GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data);
GLAPI void APIENTRY stub_glClearBufferSubData (GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data);
GLAPI void APIENTRY stub_glDispatchCompute (GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z);
GLAPI void APIENTRY stub_glDispatchComputeIndirect (GLintptr indirect);
GLAPI void APIENTRY stub_glCopyImageSubData (GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth);
GLAPI void APIENTRY stub_glFramebufferParameteri (GLenum target, GLenum pname, GLint param);
GLAPI void APIENTRY stub_glGetFramebufferParameteriv (GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetInternalformati64v (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params);
GLAPI void APIENTRY stub_glInvalidateTexSubImage (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth);
GLAPI void APIENTRY stub_glInvalidateTexImage (GLuint texture, GLint level);
GLAPI void APIENTRY stub_glInvalidateBufferSubData (GLuint buffer, GLintptr offset, GLsizeiptr length);
GLAPI void APIENTRY stub_glInvalidateBufferData (GLuint buffer);
GLAPI void APIENTRY stub_glInvalidateFramebuffer (GLenum target, GLsizei numAttachments, const GLenum *attachments);
GLAPI void APIENTRY stub_glInvalidateSubFramebuffer (GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glMultiDrawArraysIndirect (GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride);
GLAPI void APIENTRY stub_glMultiDrawElementsIndirect (GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride);
GLAPI void APIENTRY stub_glGetProgramInterfaceiv (GLuint program, GLenum programInterface, GLenum pname, GLint *params);
GLAPI GLuint APIENTRY stub_glGetProgramResourceIndex (GLuint program, GLenum programInterface, const GLchar *name);
GLAPI void APIENTRY stub_glGetProgramResourceName (GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name);
GLAPI void APIENTRY stub_glGetProgramResourceiv (GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params);
GLAPI GLint APIENTRY stub_glGetProgramResourceLocation (GLuint program, GLenum programInterface, const GLchar *name);
GLAPI GLint APIENTRY stub_glGetProgramResourceLocationIndex (GLuint program, GLenum programInterface, const GLchar *name);
GLAPI void APIENTRY stub_glShaderStorageBlockBinding (GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding);
GLAPI void APIENTRY stub_glTexBufferRange (GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size);
GLAPI void APIENTRY stub_glTexStorage2DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
GLAPI void APIENTRY stub_glTexStorage3DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
GLAPI void APIENTRY stub_glTextureView (GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers);
GLAPI void APIENTRY stub_glBindVertexBuffer (GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
GLAPI void APIENTRY stub_glVertexAttribFormat (GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
GLAPI void APIENTRY stub_glVertexAttribIFormat (GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
GLAPI void APIENTRY stub_glVertexAttribLFormat (GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
GLAPI void APIENTRY stub_glVertexAttribBinding (GLuint attribindex, GLuint bindingindex);
GLAPI void APIENTRY stub_glVertexBindingDivisor (GLuint bindingindex, GLuint divisor);
GLAPI void APIENTRY stub_glDebugMessageControl (GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled);
GLAPI void APIENTRY stub_glDebugMessageInsert (GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf);
GLAPI void APIENTRY stub_glDebugMessageCallback (GLDEBUGPROC callback, const void *userParam);
GLAPI GLuint APIENTRY stub_glGetDebugMessageLog (GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog);
GLAPI void APIENTRY stub_glPushDebugGroup (GLenum source, GLuint id, GLsizei length, const GLchar *message);
GLAPI void APIENTRY stub_glPopDebugGroup (void);
GLAPI void APIENTRY stub_glObjectLabel (GLenum identifier, GLuint name, GLsizei length, const GLchar *label);
GLAPI void APIENTRY stub_glGetObjectLabel (GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label);
GLAPI void APIENTRY stub_glObjectPtrLabel (const void *ptr, GLsizei length, const GLchar *label);
GLAPI void APIENTRY stub_glGetObjectPtrLabel (const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label);
GLAPI void APIENTRY stub_glBufferStorage (GLenum target, GLsizeiptr size, const void *data, GLbitfield flags);
GLAPI void APIENTRY stub_glClearTexImage (GLuint texture, GLint level, GLenum format, GLenum type, const void *data);
GLAPI void APIENTRY stub_glClearTexSubImage (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data);
GLAPI void APIENTRY stub_glBindBuffersBase (GLenum target, GLuint first, GLsizei count, const GLuint *buffers);
GLAPI void APIENTRY stub_glBindBuffersRange (GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes);
GLAPI void APIENTRY stub_glBindTextures (GLuint first, GLsizei count, const GLuint *textures);
GLAPI void APIENTRY stub_glBindSamplers (GLuint first, GLsizei count, const GLuint *samplers);
GLAPI void APIENTRY stub_glBindImageTextures (GLuint first, GLsizei count, const GLuint *textures);
GLAPI void APIENTRY stub_glBindVertexBuffers (GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides);
GLAPI void APIENTRY stub_glClipControl (GLenum origin, GLenum depth);
GLAPI void APIENTRY stub_glCreateTransformFeedbacks (GLsizei n, GLuint *ids);
GLAPI void APIENTRY stub_glTransformFeedbackBufferBase (GLuint xfb, GLuint index, GLuint buffer);
GLAPI void APIENTRY stub_glTransformFeedbackBufferRange (GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
GLAPI void APIENTRY stub_glGetTransformFeedbackiv (GLuint xfb, GLenum pname, GLint *param);
GLAPI void APIENTRY stub_glGetTransformFeedbacki_v (GLuint xfb, GLenum pname, GLuint index, GLint *param);
GLAPI void APIENTRY stub_glGetTransformFeedbacki64_v (GLuint xfb, GLenum pname, GLuint index, GLint64 *param);
GLAPI void APIENTRY stub_glCreateBuffers (GLsizei n, GLuint *buffers);
GLAPI void APIENTRY stub_glNamedBufferStorage (GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags);
GLAPI void APIENTRY stub_glNamedBufferData (GLuint buffer, GLsizeiptr size, const void *data, GLenum usage);
GLAPI void APIENTRY stub_glNamedBufferSubData (GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data);
GLAPI void APIENTRY stub_glCopyNamedBufferSubData (GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
GLAPI void APIENTRY stub_glClearNamedBufferData (GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data);
GLAPI void APIENTRY stub_glClearNamedBufferSubData (GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data);
GLAPI void *APIENTRY stub_glMapNamedBuffer (GLuint buffer, GLenum access);
GLAPI void *APIENTRY stub_glMapNamedBufferRange (GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access);
GLAPI GLboolean APIENTRY stub_glUnmapNamedBuffer (GLuint buffer);
GLAPI void APIENTRY stub_glFlushMappedNamedBufferRange (GLuint buffer, GLintptr offset, GLsizeiptr length);
GLAPI void APIENTRY stub_glGetNamedBufferParameteriv (GLuint buffer, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetNamedBufferParameteri64v (GLuint buffer, GLenum pname, GLint64 *params);
GLAPI void APIENTRY stub_glGetNamedBufferPointerv (GLuint buffer, GLenum pname, void **params);
GLAPI void APIENTRY stub_glGetNamedBufferSubData (GLuint buffer, GLintptr offset, GLsizeiptr size, void *data);
GLAPI void APIENTRY stub_glCreateFramebuffers (GLsizei n, GLuint *framebuffers);
GLAPI void APIENTRY stub_glNamedFramebufferRenderbuffer (GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
GLAPI void APIENTRY stub_glNamedFramebufferParameteri (GLuint framebuffer, GLenum pname, GLint param);
GLAPI void APIENTRY stub_glNamedFramebufferTexture (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level);
GLAPI void APIENTRY stub_glNamedFramebufferTextureLayer (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer);
GLAPI void APIENTRY stub_glNamedFramebufferDrawBuffer (GLuint framebuffer, GLenum buf);
GLAPI void APIENTRY stub_glNamedFramebufferDrawBuffers (GLuint framebuffer, GLsizei n, const GLenum *bufs);
GLAPI void APIENTRY stub_glNamedFramebufferReadBuffer (GLuint framebuffer, GLenum src);
GLAPI void APIENTRY stub_glInvalidateNamedFramebufferData (GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments);
GLAPI void APIENTRY stub_glInvalidateNamedFramebufferSubData (GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glClearNamedFramebufferiv (GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint *value);
GLAPI void APIENTRY stub_glClearNamedFramebufferuiv (GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint *value);
GLAPI void APIENTRY stub_glClearNamedFramebufferfv (GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat *value);
GLAPI void APIENTRY stub_glClearNamedFramebufferfi (GLuint framebuffer, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
GLAPI void APIENTRY stub_glBlitNamedFramebuffer (GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
GLAPI GLenum APIENTRY stub_glCheckNamedFramebufferStatus (GLuint framebuffer, GLenum target);
GLAPI void APIENTRY stub_glGetNamedFramebufferParameteriv (GLuint framebuffer, GLenum pname, GLint *param);
GLAPI void APIENTRY stub_glGetNamedFramebufferAttachmentParameteriv (GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glCreateRenderbuffers (GLsizei n, GLuint *renderbuffers);
GLAPI void APIENTRY stub_glNamedRenderbufferStorage (GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glNamedRenderbufferStorageMultisample (GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glGetNamedRenderbufferParameteriv (GLuint renderbuffer, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glCreateTextures (GLenum target, GLsizei n, GLuint *textures);
GLAPI void APIENTRY stub_glTextureBuffer (GLuint texture, GLenum internalformat, GLuint buffer);
GLAPI void APIENTRY stub_glTextureBufferRange (GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size);
GLAPI void APIENTRY stub_glTextureStorage1D (GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width);
GLAPI void APIENTRY stub_glTextureStorage2D (GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glTextureStorage3D (GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
GLAPI void APIENTRY stub_glTextureStorage2DMultisample (GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
GLAPI void APIENTRY stub_glTextureStorage3DMultisample (GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
GLAPI void APIENTRY stub_glTextureSubImage1D (GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels);
GLAPI void APIENTRY stub_glTextureSubImage2D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
GLAPI void APIENTRY stub_glTextureSubImage3D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);
GLAPI void APIENTRY stub_glCompressedTextureSubImage1D (GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data);
GLAPI void APIENTRY stub_glCompressedTextureSubImage2D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data);
GLAPI void APIENTRY stub_glCompressedTextureSubImage3D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data);
GLAPI void APIENTRY stub_glCopyTextureSubImage1D (GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
GLAPI void APIENTRY stub_glCopyTextureSubImage2D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glCopyTextureSubImage3D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glTextureParameterf (GLuint texture, GLenum pname, GLfloat param);
GLAPI void APIENTRY stub_glTextureParameterfv (GLuint texture, GLenum pname, const GLfloat *param);
GLAPI void APIENTRY stub_glTextureParameteri (GLuint texture, GLenum pname, GLint param);
GLAPI void APIENTRY stub_glTextureParameterIiv (GLuint texture, GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glTextureParameterIuiv (GLuint texture, GLenum pname, const GLuint *params);
GLAPI void APIENTRY stub_glTextureParameteriv (GLuint texture, GLenum pname, const GLint *param);
GLAPI void APIENTRY stub_glGenerateTextureMipmap (GLuint texture);
GLAPI void APIENTRY stub_glBindTextureUnit (GLuint unit, GLuint texture);
GLAPI void APIENTRY stub_glGetTextureImage (GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels);
GLAPI void APIENTRY stub_glGetCompressedTextureImage (GLuint texture, GLint level, GLsizei bufSize, void *pixels);
GLAPI void APIENTRY stub_glGetTextureLevelParameterfv (GLuint texture, GLint level, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetTextureLevelParameteriv (GLuint texture, GLint level, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetTextureParameterfv (GLuint texture, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetTextureParameterIiv (GLuint texture, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetTextureParameterIuiv (GLuint texture, GLenum pname, GLuint *params);
GLAPI void APIENTRY stub_glGetTextureParameteriv (GLuint texture, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glCreateVertexArrays (GLsizei n, GLuint *arrays);
GLAPI void APIENTRY stub_glDisableVertexArrayAttrib (GLuint vaobj, GLuint index);
GLAPI void APIENTRY stub_glEnableVertexArrayAttrib (GLuint vaobj, GLuint index);
GLAPI void APIENTRY stub_glVertexArrayElementBuffer (GLuint vaobj, GLuint buffer);
GLAPI void APIENTRY stub_glVertexArrayVertexBuffer (GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
GLAPI void APIENTRY stub_glVertexArrayVertexBuffers (GLuint vaobj, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides);
GLAPI void APIENTRY stub_glVertexArrayAttribBinding (GLuint vaobj, GLuint attribindex, GLuint bindingindex);
GLAPI void APIENTRY stub_glVertexArrayAttribFormat (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
GLAPI void APIENTRY stub_glVertexArrayAttribIFormat (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
GLAPI void APIENTRY stub_glVertexArrayAttribLFormat (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
GLAPI void APIENTRY stub_glVertexArrayBindingDivisor (GLuint vaobj, GLuint bindingindex, GLuint divisor);
GLAPI void APIENTRY stub_glGetVertexArrayiv (GLuint vaobj, GLenum pname, GLint *param);
GLAPI void APIENTRY stub_glGetVertexArrayIndexediv (GLuint vaobj, GLuint index, GLenum pname, GLint *param);
GLAPI void APIENTRY stub_glGetVertexArrayIndexed64iv (GLuint vaobj, GLuint index, GLenum pname, GLint64 *param);
GLAPI void APIENTRY stub_glCreateSamplers (GLsizei n, GLuint *samplers);
GLAPI void APIENTRY stub_glCreateProgramPipelines (GLsizei n, GLuint *pipelines);
GLAPI void APIENTRY stub_glCreateQueries (GLenum target, GLsizei n, GLuint *ids);
GLAPI void APIENTRY stub_glGetQueryBufferObjecti64v (GLuint id, GLuint buffer, GLenum pname, GLintptr offset);
GLAPI void APIENTRY stub_glGetQueryBufferObjectiv (GLuint id, GLuint buffer, GLenum pname, GLintptr offset);
GLAPI void APIENTRY stub_glGetQueryBufferObjectui64v (GLuint id, GLuint buffer, GLenum pname, GLintptr offset);
GLAPI void APIENTRY stub_glGetQueryBufferObjectuiv (GLuint id, GLuint buffer, GLenum pname, GLintptr offset);
GLAPI void APIENTRY stub_glMemoryBarrierByRegion (GLbitfield barriers);
GLAPI void APIENTRY stub_glGetTextureSubImage (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void *pixels);
GLAPI void APIENTRY stub_glGetCompressedTextureSubImage (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void *pixels);
GLAPI GLenum APIENTRY stub_glGetGraphicsResetStatus (void);
GLAPI void APIENTRY stub_glGetnCompressedTexImage (GLenum target, GLint lod, GLsizei bufSize, void *pixels);
GLAPI void APIENTRY stub_glGetnTexImage (GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels);
GLAPI void APIENTRY stub_glGetnUniformdv (GLuint program, GLint location, GLsizei bufSize, GLdouble *params);
GLAPI void APIENTRY stub_glGetnUniformfv (GLuint program, GLint location, GLsizei bufSize, GLfloat *params);
GLAPI void APIENTRY stub_glGetnUniformiv (GLuint program, GLint location, GLsizei bufSize, GLint *params);
GLAPI void APIENTRY stub_glGetnUniformuiv (GLuint program, GLint location, GLsizei bufSize, GLuint *params);
GLAPI void APIENTRY stub_glReadnPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data);
GLAPI void APIENTRY stub_glGetnMapdv (GLenum target, GLenum query, GLsizei bufSize, GLdouble *v);
GLAPI void APIENTRY stub_glGetnMapfv (GLenum target, GLenum query, GLsizei bufSize, GLfloat *v);
GLAPI void APIENTRY stub_glGetnMapiv (GLenum target, GLenum query, GLsizei bufSize, GLint *v);
GLAPI void APIENTRY stub_glGetnPixelMapfv (GLenum map, GLsizei bufSize, GLfloat *values);
GLAPI void APIENTRY stub_glGetnPixelMapuiv (GLenum map, GLsizei bufSize, GLuint *values);
GLAPI void APIENTRY stub_glGetnPixelMapusv (GLenum map, GLsizei bufSize, GLushort *values);
GLAPI void APIENTRY stub_glGetnPolygonStipple (GLsizei bufSize, GLubyte *pattern);
GLAPI void APIENTRY stub_glGetnColorTable (GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *table);
GLAPI void APIENTRY stub_glGetnConvolutionFilter (GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *image);
GLAPI void APIENTRY stub_glGetnSeparableFilter (GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void *row, GLsizei columnBufSize, void *column, void *span);
GLAPI void APIENTRY stub_glGetnHistogram (GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values);
GLAPI void APIENTRY stub_glGetnMinmax (GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values);
GLAPI void APIENTRY stub_glTextureBarrier (void);
GLAPI void APIENTRY stub_glPrimitiveBoundingBoxARB (GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW);
GLAPI GLuint64 APIENTRY stub_glGetTextureHandleARB (GLuint texture);
GLAPI GLuint64 APIENTRY stub_glGetTextureSamplerHandleARB (GLuint texture, GLuint sampler);
GLAPI void APIENTRY stub_glMakeTextureHandleResidentARB (GLuint64 handle);
GLAPI void APIENTRY stub_glMakeTextureHandleNonResidentARB (GLuint64 handle);
GLAPI GLuint64 APIENTRY stub_glGetImageHandleARB (GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format);
GLAPI void APIENTRY stub_glMakeImageHandleResidentARB (GLuint64 handle, GLenum access);
GLAPI void APIENTRY stub_glMakeImageHandleNonResidentARB (GLuint64 handle);
GLAPI void APIENTRY stub_glUniformHandleui64ARB (GLint location, GLuint64 value);
GLAPI void APIENTRY stub_glUniformHandleui64vARB (GLint location, GLsizei count, const GLuint64 *value);
GLAPI void APIENTRY stub_glProgramUniformHandleui64ARB (GLuint program, GLint location, GLuint64 value);
GLAPI void APIENTRY stub_glProgramUniformHandleui64vARB (GLuint program, GLint location, GLsizei count, const GLuint64 *values);
GLAPI GLboolean APIENTRY stub_glIsTextureHandleResidentARB (GLuint64 handle);
GLAPI GLboolean APIENTRY stub_glIsImageHandleResidentARB (GLuint64 handle);
GLAPI void APIENTRY stub_glVertexAttribL1ui64ARB (GLuint index, GLuint64EXT x);
GLAPI void APIENTRY stub_glVertexAttribL1ui64vARB (GLuint index, const GLuint64EXT *v);
GLAPI void APIENTRY stub_glGetVertexAttribLui64vARB (GLuint index, GLenum pname, GLuint64EXT *params);
GLAPI GLsync APIENTRY stub_glCreateSyncFromCLeventARB (struct _cl_context *context, struct _cl_event *event, GLbitfield flags);
GLAPI void APIENTRY stub_glClampColorARB (GLenum target, GLenum clamp);
GLAPI void APIENTRY stub_glDispatchComputeGroupSizeARB (GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z, GLuint group_size_x, GLuint group_size_y, GLuint group_size_z);
GLAPI void APIENTRY stub_glDebugMessageControlARB (GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled);
GLAPI void APIENTRY stub_glDebugMessageInsertARB (GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf);
GLAPI void APIENTRY stub_glDebugMessageCallbackARB (GLDEBUGPROCARB callback, const void *userParam);
GLAPI GLuint APIENTRY stub_glGetDebugMessageLogARB (GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog);
GLAPI void APIENTRY stub_glDrawBuffersARB (GLsizei n, const GLenum *bufs);
GLAPI void APIENTRY stub_glBlendEquationiARB (GLuint buf, GLenum mode);
GLAPI void APIENTRY stub_glBlendEquationSeparateiARB (GLuint buf, GLenum modeRGB, GLenum modeAlpha);
GLAPI void APIENTRY stub_glBlendFunciARB (GLuint buf, GLenum src, GLenum dst);
GLAPI void APIENTRY stub_glBlendFuncSeparateiARB (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
GLAPI void APIENTRY stub_glDrawArraysInstancedARB (GLenum mode, GLint first, GLsizei count, GLsizei primcount);
GLAPI void APIENTRY stub_glDrawElementsInstancedARB (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount);
GLAPI void APIENTRY stub_glProgramStringARB (GLenum target, GLenum format, GLsizei len, const void *string);
GLAPI void APIENTRY stub_glBindProgramARB (GLenum target, GLuint program);
GLAPI void APIENTRY stub_glDeleteProgramsARB (GLsizei n, const GLuint *programs);
GLAPI void APIENTRY stub_glGenProgramsARB (GLsizei n, GLuint *programs);
GLAPI void APIENTRY stub_glProgramEnvParameter4dARB (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
GLAPI void APIENTRY stub_glProgramEnvParameter4dvARB (GLenum target, GLuint index, const GLdouble *params);
GLAPI void APIENTRY stub_glProgramEnvParameter4fARB (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
GLAPI void APIENTRY stub_glProgramEnvParameter4fvARB (GLenum target, GLuint index, const GLfloat *params);
GLAPI void APIENTRY stub_glProgramLocalParameter4dARB (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
GLAPI void APIENTRY stub_glProgramLocalParameter4dvARB (GLenum target, GLuint index, const GLdouble *params);
GLAPI void APIENTRY stub_glProgramLocalParameter4fARB (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
GLAPI void APIENTRY stub_glProgramLocalParameter4fvARB (GLenum target, GLuint index, const GLfloat *params);
GLAPI void APIENTRY stub_glGetProgramEnvParameterdvARB (GLenum target, GLuint index, GLdouble *params);
GLAPI void APIENTRY stub_glGetProgramEnvParameterfvARB (GLenum target, GLuint index, GLfloat *params);
GLAPI void APIENTRY stub_glGetProgramLocalParameterdvARB (GLenum target, GLuint index, GLdouble *params);
GLAPI void APIENTRY stub_glGetProgramLocalParameterfvARB (GLenum target, GLuint index, GLfloat *params);
GLAPI void APIENTRY stub_glGetProgramivARB (GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetProgramStringARB (GLenum target, GLenum pname, void *string);
GLAPI GLboolean APIENTRY stub_glIsProgramARB (GLuint program);
GLAPI void APIENTRY stub_glProgramParameteriARB (GLuint program, GLenum pname, GLint value);
GLAPI void APIENTRY stub_glFramebufferTextureARB (GLenum target, GLenum attachment, GLuint texture, GLint level);
GLAPI void APIENTRY stub_glFramebufferTextureLayerARB (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
GLAPI void APIENTRY stub_glFramebufferTextureFaceARB (GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face);
GLAPI void APIENTRY stub_glUniform1i64ARB (GLint location, GLint64 x);
GLAPI void APIENTRY stub_glUniform2i64ARB (GLint location, GLint64 x, GLint64 y);
GLAPI void APIENTRY stub_glUniform3i64ARB (GLint location, GLint64 x, GLint64 y, GLint64 z);
GLAPI void APIENTRY stub_glUniform4i64ARB (GLint location, GLint64 x, GLint64 y, GLint64 z, GLint64 w);
GLAPI void APIENTRY stub_glUniform1i64vARB (GLint location, GLsizei count, const GLint64 *value);
GLAPI void APIENTRY stub_glUniform2i64vARB (GLint location, GLsizei count, const GLint64 *value);
GLAPI void APIENTRY stub_glUniform3i64vARB (GLint location, GLsizei count, const GLint64 *value);
GLAPI void APIENTRY stub_glUniform4i64vARB (GLint location, GLsizei count, const GLint64 *value);
GLAPI void APIENTRY stub_glUniform1ui64ARB (GLint location, GLuint64 x);
GLAPI void APIENTRY stub_glUniform2ui64ARB (GLint location, GLuint64 x, GLuint64 y);
GLAPI void APIENTRY stub_glUniform3ui64ARB (GLint location, GLuint64 x, GLuint64 y, GLuint64 z);
GLAPI void APIENTRY stub_glUniform4ui64ARB (GLint location, GLuint64 x, GLuint64 y, GLuint64 z, GLuint64 w);
GLAPI void APIENTRY stub_glUniform1ui64vARB (GLint location, GLsizei count, const GLuint64 *value);
GLAPI void APIENTRY stub_glUniform2ui64vARB (GLint location, GLsizei count, const GLuint64 *value);
GLAPI void APIENTRY stub_glUniform3ui64vARB (GLint location, GLsizei count, const GLuint64 *value);
GLAPI void APIENTRY stub_glUniform4ui64vARB (GLint location, GLsizei count, const GLuint64 *value);
GLAPI void APIENTRY stub_glGetUniformi64vARB (GLuint program, GLint location, GLint64 *params);
GLAPI void APIENTRY stub_glGetUniformui64vARB (GLuint program, GLint location, GLuint64 *params);
GLAPI void APIENTRY stub_glGetnUniformi64vARB (GLuint program, GLint location, GLsizei bufSize, GLint64 *params);
GLAPI void APIENTRY stub_glGetnUniformui64vARB (GLuint program, GLint location, GLsizei bufSize, GLuint64 *params);
GLAPI void APIENTRY stub_glProgramUniform1i64ARB (GLuint program, GLint location, GLint64 x);
GLAPI void APIENTRY stub_glProgramUniform2i64ARB (GLuint program, GLint location, GLint64 x, GLint64 y);
GLAPI void APIENTRY stub_glProgramUniform3i64ARB (GLuint program, GLint location, GLint64 x, GLint64 y, GLint64 z);
GLAPI void APIENTRY stub_glProgramUniform4i64ARB (GLuint program, GLint location, GLint64 x, GLint64 y, GLint64 z, GLint64 w);
GLAPI void APIENTRY stub_glProgramUniform1i64vARB (GLuint program, GLint location, GLsizei count, const GLint64 *value);
GLAPI void APIENTRY stub_glProgramUniform2i64vARB (GLuint program, GLint location, GLsizei count, const GLint64 *value);
GLAPI void APIENTRY stub_glProgramUniform3i64vARB (GLuint program, GLint location, GLsizei count, const GLint64 *value);
GLAPI void APIENTRY stub_glProgramUniform4i64vARB (GLuint program, GLint location, GLsizei count, const GLint64 *value);
GLAPI void APIENTRY stub_glProgramUniform1ui64ARB (GLuint program, GLint location, GLuint64 x);
GLAPI void APIENTRY stub_glProgramUniform2ui64ARB (GLuint program, GLint location, GLuint64 x, GLuint64 y);
GLAPI void APIENTRY stub_glProgramUniform3ui64ARB (GLuint program, GLint location, GLuint64 x, GLuint64 y, GLuint64 z);
GLAPI void APIENTRY stub_glProgramUniform4ui64ARB (GLuint program, GLint location, GLuint64 x, GLuint64 y, GLuint64 z, GLuint64 w);
GLAPI void APIENTRY stub_glProgramUniform1ui64vARB (GLuint program, GLint location, GLsizei count, const GLuint64 *value);
GLAPI void APIENTRY stub_glProgramUniform2ui64vARB (GLuint program, GLint location, GLsizei count, const GLuint64 *value);
GLAPI void APIENTRY stub_glProgramUniform3ui64vARB (GLuint program, GLint location, GLsizei count, const GLuint64 *value);
GLAPI void APIENTRY stub_glProgramUniform4ui64vARB (GLuint program, GLint location, GLsizei count, const GLuint64 *value);
GLAPI void APIENTRY stub_glColorTable (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *table);
GLAPI void APIENTRY stub_glColorTableParameterfv (GLenum target, GLenum pname, const GLfloat *params);
GLAPI void APIENTRY stub_glColorTableParameteriv (GLenum target, GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glCopyColorTable (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
GLAPI void APIENTRY stub_glGetColorTable (GLenum target, GLenum format, GLenum type, void *table);
GLAPI void APIENTRY stub_glGetColorTableParameterfv (GLenum target, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetColorTableParameteriv (GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glColorSubTable (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data);
GLAPI void APIENTRY stub_glCopyColorSubTable (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
GLAPI void APIENTRY stub_glConvolutionFilter1D (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *image);
GLAPI void APIENTRY stub_glConvolutionFilter2D (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *image);
GLAPI void APIENTRY stub_glConvolutionParameterf (GLenum target, GLenum pname, GLfloat params);
GLAPI void APIENTRY stub_glConvolutionParameterfv (GLenum target, GLenum pname, const GLfloat *params);
GLAPI void APIENTRY stub_glConvolutionParameteri (GLenum target, GLenum pname, GLint params);
GLAPI void APIENTRY stub_glConvolutionParameteriv (GLenum target, GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glCopyConvolutionFilter1D (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
GLAPI void APIENTRY stub_glCopyConvolutionFilter2D (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glGetConvolutionFilter (GLenum target, GLenum format, GLenum type, void *image);
GLAPI void APIENTRY stub_glGetConvolutionParameterfv (GLenum target, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetConvolutionParameteriv (GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetSeparableFilter (GLenum target, GLenum format, GLenum type, void *row, void *column, void *span);
GLAPI void APIENTRY stub_glSeparableFilter2D (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *row, const void *column);
GLAPI void APIENTRY stub_glGetHistogram (GLenum target, GLboolean reset, GLenum format, GLenum type, void *values);
GLAPI void APIENTRY stub_glGetHistogramParameterfv (GLenum target, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetHistogramParameteriv (GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetMinmax (GLenum target, GLboolean reset, GLenum format, GLenum type, void *values);
GLAPI void APIENTRY stub_glGetMinmaxParameterfv (GLenum target, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetMinmaxParameteriv (GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glHistogram (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
GLAPI void APIENTRY stub_glMinmax (GLenum target, GLenum internalformat, GLboolean sink);
GLAPI void APIENTRY stub_glResetHistogram (GLenum target);
GLAPI void APIENTRY stub_glResetMinmax (GLenum target);
GLAPI void APIENTRY stub_glMultiDrawArraysIndirectCountARB (GLenum mode, GLintptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride);
GLAPI void APIENTRY stub_glMultiDrawElementsIndirectCountARB (GLenum mode, GLenum type, GLintptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride);
GLAPI void APIENTRY stub_glVertexAttribDivisorARB (GLuint index, GLuint divisor);
GLAPI void APIENTRY stub_glCurrentPaletteMatrixARB (GLint index);
GLAPI void APIENTRY stub_glMatrixIndexubvARB (GLint size, const GLubyte *indices);
GLAPI void APIENTRY stub_glMatrixIndexusvARB (GLint size, const GLushort *indices);
GLAPI void APIENTRY stub_glMatrixIndexuivARB (GLint size, const GLuint *indices);
GLAPI void APIENTRY stub_glMatrixIndexPointerARB (GLint size, GLenum type, GLsizei stride, const void *pointer);
GLAPI void APIENTRY stub_glSampleCoverageARB (GLfloat value, GLboolean invert);
GLAPI void APIENTRY stub_glActiveTextureARB (GLenum texture);
GLAPI void APIENTRY stub_glClientActiveTextureARB (GLenum texture);
GLAPI void APIENTRY stub_glMultiTexCoord1dARB (GLenum target, GLdouble s);
GLAPI void APIENTRY stub_glMultiTexCoord1dvARB (GLenum target, const GLdouble *v);
GLAPI void APIENTRY stub_glMultiTexCoord1fARB (GLenum target, GLfloat s);
GLAPI void APIENTRY stub_glMultiTexCoord1fvARB (GLenum target, const GLfloat *v);
GLAPI void APIENTRY stub_glMultiTexCoord1iARB (GLenum target, GLint s);
GLAPI void APIENTRY stub_glMultiTexCoord1ivARB (GLenum target, const GLint *v);
GLAPI void APIENTRY stub_glMultiTexCoord1sARB (GLenum target, GLshort s);
GLAPI void APIENTRY stub_glMultiTexCoord1svARB (GLenum target, const GLshort *v);
GLAPI void APIENTRY stub_glMultiTexCoord2dARB (GLenum target, GLdouble s, GLdouble t);
GLAPI void APIENTRY stub_glMultiTexCoord2dvARB (GLenum target, const GLdouble *v);
GLAPI void APIENTRY stub_glMultiTexCoord2fARB (GLenum target, GLfloat s, GLfloat t);
GLAPI void APIENTRY stub_glMultiTexCoord2fvARB (GLenum target, const GLfloat *v);
GLAPI void APIENTRY stub_glMultiTexCoord2iARB (GLenum target, GLint s, GLint t);
GLAPI void APIENTRY stub_glMultiTexCoord2ivARB (GLenum target, const GLint *v);
GLAPI void APIENTRY stub_glMultiTexCoord2sARB (GLenum target, GLshort s, GLshort t);
GLAPI void APIENTRY stub_glMultiTexCoord2svARB (GLenum target, const GLshort *v);
GLAPI void APIENTRY stub_glMultiTexCoord3dARB (GLenum target, GLdouble s, GLdouble t, GLdouble r);
GLAPI void APIENTRY stub_glMultiTexCoord3dvARB (GLenum target, const GLdouble *v);
GLAPI void APIENTRY stub_glMultiTexCoord3fARB (GLenum target, GLfloat s, GLfloat t, GLfloat r);
GLAPI void APIENTRY stub_glMultiTexCoord3fvARB (GLenum target, const GLfloat *v);
GLAPI void APIENTRY stub_glMultiTexCoord3iARB (GLenum target, GLint s, GLint t, GLint r);
GLAPI void APIENTRY stub_glMultiTexCoord3ivARB (GLenum target, const GLint *v);
GLAPI void APIENTRY stub_glMultiTexCoord3sARB (GLenum target, GLshort s, GLshort t, GLshort r);
GLAPI void APIENTRY stub_glMultiTexCoord3svARB (GLenum target, const GLshort *v);
GLAPI void APIENTRY stub_glMultiTexCoord4dARB (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
GLAPI void APIENTRY stub_glMultiTexCoord4dvARB (GLenum target, const GLdouble *v);
GLAPI void APIENTRY stub_glMultiTexCoord4fARB (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
GLAPI void APIENTRY stub_glMultiTexCoord4fvARB (GLenum target, const GLfloat *v);
GLAPI void APIENTRY stub_glMultiTexCoord4iARB (GLenum target, GLint s, GLint t, GLint r, GLint q);
GLAPI void APIENTRY stub_glMultiTexCoord4ivARB (GLenum target, const GLint *v);
GLAPI void APIENTRY stub_glMultiTexCoord4sARB (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
GLAPI void APIENTRY stub_glMultiTexCoord4svARB (GLenum target, const GLshort *v);
GLAPI void APIENTRY stub_glGenQueriesARB (GLsizei n, GLuint *ids);
GLAPI void APIENTRY stub_glDeleteQueriesARB (GLsizei n, const GLuint *ids);
GLAPI GLboolean APIENTRY stub_glIsQueryARB (GLuint id);
GLAPI void APIENTRY stub_glBeginQueryARB (GLenum target, GLuint id);
GLAPI void APIENTRY stub_glEndQueryARB (GLenum target);
GLAPI void APIENTRY stub_glGetQueryivARB (GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetQueryObjectivARB (GLuint id, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetQueryObjectuivARB (GLuint id, GLenum pname, GLuint *params);
GLAPI void APIENTRY stub_glMaxShaderCompilerThreadsARB (GLuint count);
GLAPI void APIENTRY stub_glPointParameterfARB (GLenum pname, GLfloat param);
GLAPI void APIENTRY stub_glPointParameterfvARB (GLenum pname, const GLfloat *params);
GLAPI GLenum APIENTRY stub_glGetGraphicsResetStatusARB (void);
GLAPI void APIENTRY stub_glGetnTexImageARB (GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *img);
GLAPI void APIENTRY stub_glReadnPixelsARB (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data);
GLAPI void APIENTRY stub_glGetnCompressedTexImageARB (GLenum target, GLint lod, GLsizei bufSize, void *img);
GLAPI void APIENTRY stub_glGetnUniformfvARB (GLuint program, GLint location, GLsizei bufSize, GLfloat *params);
GLAPI void APIENTRY stub_glGetnUniformivARB (GLuint program, GLint location, GLsizei bufSize, GLint *params);
GLAPI void APIENTRY stub_glGetnUniformuivARB (GLuint program, GLint location, GLsizei bufSize, GLuint *params);
GLAPI void APIENTRY stub_glGetnUniformdvARB (GLuint program, GLint location, GLsizei bufSize, GLdouble *params);
GLAPI void APIENTRY stub_glGetnMapdvARB (GLenum target, GLenum query, GLsizei bufSize, GLdouble *v);
GLAPI void APIENTRY stub_glGetnMapfvARB (GLenum target, GLenum query, GLsizei bufSize, GLfloat *v);
GLAPI void APIENTRY stub_glGetnMapivARB (GLenum target, GLenum query, GLsizei bufSize, GLint *v);
GLAPI void APIENTRY stub_glGetnPixelMapfvARB (GLenum map, GLsizei bufSize, GLfloat *values);
GLAPI void APIENTRY stub_glGetnPixelMapuivARB (GLenum map, GLsizei bufSize, GLuint *values);
GLAPI void APIENTRY stub_glGetnPixelMapusvARB (GLenum map, GLsizei bufSize, GLushort *values);
GLAPI void APIENTRY stub_glGetnPolygonStippleARB (GLsizei bufSize, GLubyte *pattern);
GLAPI void APIENTRY stub_glGetnColorTableARB (GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *table);
GLAPI void APIENTRY stub_glGetnConvolutionFilterARB (GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *image);
GLAPI void APIENTRY stub_glGetnSeparableFilterARB (GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void *row, GLsizei columnBufSize, void *column, void *span);
GLAPI void APIENTRY stub_glGetnHistogramARB (GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values);
GLAPI void APIENTRY stub_glGetnMinmaxARB (GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values);
GLAPI void APIENTRY stub_glFramebufferSampleLocationsfvARB (GLenum target, GLuint start, GLsizei count, const GLfloat *v);
GLAPI void APIENTRY stub_glNamedFramebufferSampleLocationsfvARB (GLuint framebuffer, GLuint start, GLsizei count, const GLfloat *v);
GLAPI void APIENTRY stub_glEvaluateDepthValuesARB (void);
GLAPI void APIENTRY stub_glMinSampleShadingARB (GLfloat value);
GLAPI void APIENTRY stub_glDeleteObjectARB (GLhandleARB obj);
GLAPI GLhandleARB APIENTRY stub_glGetHandleARB (GLenum pname);
GLAPI void APIENTRY stub_glDetachObjectARB (GLhandleARB containerObj, GLhandleARB attachedObj);
GLAPI GLhandleARB APIENTRY stub_glCreateShaderObjectARB (GLenum shaderType);
GLAPI void APIENTRY stub_glShaderSourceARB (GLhandleARB shaderObj, GLsizei count, const GLcharARB **string, const GLint *length);
GLAPI void APIENTRY stub_glCompileShaderARB (GLhandleARB shaderObj);
GLAPI GLhandleARB APIENTRY stub_glCreateProgramObjectARB (void);
GLAPI void APIENTRY stub_glAttachObjectARB (GLhandleARB containerObj, GLhandleARB obj);
GLAPI void APIENTRY stub_glLinkProgramARB (GLhandleARB programObj);
GLAPI void APIENTRY stub_glUseProgramObjectARB (GLhandleARB programObj);
GLAPI void APIENTRY stub_glValidateProgramARB (GLhandleARB programObj);
GLAPI void APIENTRY stub_glUniform1fARB (GLint location, GLfloat v0);
GLAPI void APIENTRY stub_glUniform2fARB (GLint location, GLfloat v0, GLfloat v1);
GLAPI void APIENTRY stub_glUniform3fARB (GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
GLAPI void APIENTRY stub_glUniform4fARB (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
GLAPI void APIENTRY stub_glUniform1iARB (GLint location, GLint v0);
GLAPI void APIENTRY stub_glUniform2iARB (GLint location, GLint v0, GLint v1);
GLAPI void APIENTRY stub_glUniform3iARB (GLint location, GLint v0, GLint v1, GLint v2);
GLAPI void APIENTRY stub_glUniform4iARB (GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
GLAPI void APIENTRY stub_glUniform1fvARB (GLint location, GLsizei count, const GLfloat *value);
GLAPI void APIENTRY stub_glUniform2fvARB (GLint location, GLsizei count, const GLfloat *value);
GLAPI void APIENTRY stub_glUniform3fvARB (GLint location, GLsizei count, const GLfloat *value);
GLAPI void APIENTRY stub_glUniform4fvARB (GLint location, GLsizei count, const GLfloat *value);
GLAPI void APIENTRY stub_glUniform1ivARB (GLint location, GLsizei count, const GLint *value);
GLAPI void APIENTRY stub_glUniform2ivARB (GLint location, GLsizei count, const GLint *value);
GLAPI void APIENTRY stub_glUniform3ivARB (GLint location, GLsizei count, const GLint *value);
GLAPI void APIENTRY stub_glUniform4ivARB (GLint location, GLsizei count, const GLint *value);
GLAPI void APIENTRY stub_glUniformMatrix2fvARB (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glUniformMatrix3fvARB (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glUniformMatrix4fvARB (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glGetObjectParameterfvARB (GLhandleARB obj, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetObjectParameterivARB (GLhandleARB obj, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetInfoLogARB (GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *infoLog);
GLAPI void APIENTRY stub_glGetAttachedObjectsARB (GLhandleARB containerObj, GLsizei maxCount, GLsizei *count, GLhandleARB *obj);
GLAPI GLint APIENTRY stub_glGetUniformLocationARB (GLhandleARB programObj, const GLcharARB *name);
GLAPI void APIENTRY stub_glGetActiveUniformARB (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name);
GLAPI void APIENTRY stub_glGetUniformfvARB (GLhandleARB programObj, GLint location, GLfloat *params);
GLAPI void APIENTRY stub_glGetUniformivARB (GLhandleARB programObj, GLint location, GLint *params);
GLAPI void APIENTRY stub_glGetShaderSourceARB (GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *source);
GLAPI void APIENTRY stub_glNamedStringARB (GLenum type, GLint namelen, const GLchar *name, GLint stringlen, const GLchar *string);
GLAPI void APIENTRY stub_glDeleteNamedStringARB (GLint namelen, const GLchar *name);
GLAPI void APIENTRY stub_glCompileShaderIncludeARB (GLuint shader, GLsizei count, const GLchar *const*path, const GLint *length);
GLAPI GLboolean APIENTRY stub_glIsNamedStringARB (GLint namelen, const GLchar *name);
GLAPI void APIENTRY stub_glGetNamedStringARB (GLint namelen, const GLchar *name, GLsizei bufSize, GLint *stringlen, GLchar *string);
GLAPI void APIENTRY stub_glGetNamedStringivARB (GLint namelen, const GLchar *name, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glBufferPageCommitmentARB (GLenum target, GLintptr offset, GLsizeiptr size, GLboolean commit);
GLAPI void APIENTRY stub_glNamedBufferPageCommitmentEXT (GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit);
GLAPI void APIENTRY stub_glNamedBufferPageCommitmentARB (GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit);
GLAPI void APIENTRY stub_glTexPageCommitmentARB (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit);
GLAPI void APIENTRY stub_glTexBufferARB (GLenum target, GLenum internalformat, GLuint buffer);
GLAPI void APIENTRY stub_glCompressedTexImage3DARB (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data);
GLAPI void APIENTRY stub_glCompressedTexImage2DARB (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data);
GLAPI void APIENTRY stub_glCompressedTexImage1DARB (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data);
GLAPI void APIENTRY stub_glCompressedTexSubImage3DARB (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data);
GLAPI void APIENTRY stub_glCompressedTexSubImage2DARB (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data);
GLAPI void APIENTRY stub_glCompressedTexSubImage1DARB (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data);
GLAPI void APIENTRY stub_glGetCompressedTexImageARB (GLenum target, GLint level, void *img);
GLAPI void APIENTRY stub_glLoadTransposeMatrixfARB (const GLfloat *m);
GLAPI void APIENTRY stub_glLoadTransposeMatrixdARB (const GLdouble *m);
GLAPI void APIENTRY stub_glMultTransposeMatrixfARB (const GLfloat *m);
GLAPI void APIENTRY stub_glMultTransposeMatrixdARB (const GLdouble *m);
GLAPI void APIENTRY stub_glWeightbvARB (GLint size, const GLbyte *weights);
GLAPI void APIENTRY stub_glWeightsvARB (GLint size, const GLshort *weights);
GLAPI void APIENTRY stub_glWeightivARB (GLint size, const GLint *weights);
GLAPI void APIENTRY stub_glWeightfvARB (GLint size, const GLfloat *weights);
GLAPI void APIENTRY stub_glWeightdvARB (GLint size, const GLdouble *weights);
GLAPI void APIENTRY stub_glWeightubvARB (GLint size, const GLubyte *weights);
GLAPI void APIENTRY stub_glWeightusvARB (GLint size, const GLushort *weights);
GLAPI void APIENTRY stub_glWeightuivARB (GLint size, const GLuint *weights);
GLAPI void APIENTRY stub_glWeightPointerARB (GLint size, GLenum type, GLsizei stride, const void *pointer);
GLAPI void APIENTRY stub_glVertexBlendARB (GLint count);
GLAPI void APIENTRY stub_glBindBufferARB (GLenum target, GLuint buffer);
GLAPI void APIENTRY stub_glDeleteBuffersARB (GLsizei n, const GLuint *buffers);
GLAPI void APIENTRY stub_glGenBuffersARB (GLsizei n, GLuint *buffers);
GLAPI GLboolean APIENTRY stub_glIsBufferARB (GLuint buffer);
GLAPI void APIENTRY stub_glBufferDataARB (GLenum target, GLsizeiptrARB size, const void *data, GLenum usage);
GLAPI void APIENTRY stub_glBufferSubDataARB (GLenum target, GLintptrARB offset, GLsizeiptrARB size, const void *data);
GLAPI void APIENTRY stub_glGetBufferSubDataARB (GLenum target, GLintptrARB offset, GLsizeiptrARB size, void *data);
GLAPI void *APIENTRY stub_glMapBufferARB (GLenum target, GLenum access);
GLAPI GLboolean APIENTRY stub_glUnmapBufferARB (GLenum target);
GLAPI void APIENTRY stub_glGetBufferParameterivARB (GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetBufferPointervARB (GLenum target, GLenum pname, void **params);
GLAPI void APIENTRY stub_glVertexAttrib1dARB (GLuint index, GLdouble x);
GLAPI void APIENTRY stub_glVertexAttrib1dvARB (GLuint index, const GLdouble *v);
GLAPI void APIENTRY stub_glVertexAttrib1fARB (GLuint index, GLfloat x);
GLAPI void APIENTRY stub_glVertexAttrib1fvARB (GLuint index, const GLfloat *v);
GLAPI void APIENTRY stub_glVertexAttrib1sARB (GLuint index, GLshort x);
GLAPI void APIENTRY stub_glVertexAttrib1svARB (GLuint index, const GLshort *v);
GLAPI void APIENTRY stub_glVertexAttrib2dARB (GLuint index, GLdouble x, GLdouble y);
GLAPI void APIENTRY stub_glVertexAttrib2dvARB (GLuint index, const GLdouble *v);
GLAPI void APIENTRY stub_glVertexAttrib2fARB (GLuint index, GLfloat x, GLfloat y);
GLAPI void APIENTRY stub_glVertexAttrib2fvARB (GLuint index, const GLfloat *v);
GLAPI void APIENTRY stub_glVertexAttrib2sARB (GLuint index, GLshort x, GLshort y);
GLAPI void APIENTRY stub_glVertexAttrib2svARB (GLuint index, const GLshort *v);
GLAPI void APIENTRY stub_glVertexAttrib3dARB (GLuint index, GLdouble x, GLdouble y, GLdouble z);
GLAPI void APIENTRY stub_glVertexAttrib3dvARB (GLuint index, const GLdouble *v);
GLAPI void APIENTRY stub_glVertexAttrib3fARB (GLuint index, GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glVertexAttrib3fvARB (GLuint index, const GLfloat *v);
GLAPI void APIENTRY stub_glVertexAttrib3sARB (GLuint index, GLshort x, GLshort y, GLshort z);
GLAPI void APIENTRY stub_glVertexAttrib3svARB (GLuint index, const GLshort *v);
GLAPI void APIENTRY stub_glVertexAttrib4NbvARB (GLuint index, const GLbyte *v);
GLAPI void APIENTRY stub_glVertexAttrib4NivARB (GLuint index, const GLint *v);
GLAPI void APIENTRY stub_glVertexAttrib4NsvARB (GLuint index, const GLshort *v);
GLAPI void APIENTRY stub_glVertexAttrib4NubARB (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
GLAPI void APIENTRY stub_glVertexAttrib4NubvARB (GLuint index, const GLubyte *v);
GLAPI void APIENTRY stub_glVertexAttrib4NuivARB (GLuint index, const GLuint *v);
GLAPI void APIENTRY stub_glVertexAttrib4NusvARB (GLuint index, const GLushort *v);
GLAPI void APIENTRY stub_glVertexAttrib4bvARB (GLuint index, const GLbyte *v);
GLAPI void APIENTRY stub_glVertexAttrib4dARB (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
GLAPI void APIENTRY stub_glVertexAttrib4dvARB (GLuint index, const GLdouble *v);
GLAPI void APIENTRY stub_glVertexAttrib4fARB (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
GLAPI void APIENTRY stub_glVertexAttrib4fvARB (GLuint index, const GLfloat *v);
GLAPI void APIENTRY stub_glVertexAttrib4ivARB (GLuint index, const GLint *v);
GLAPI void APIENTRY stub_glVertexAttrib4sARB (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
GLAPI void APIENTRY stub_glVertexAttrib4svARB (GLuint index, const GLshort *v);
GLAPI void APIENTRY stub_glVertexAttrib4ubvARB (GLuint index, const GLubyte *v);
GLAPI void APIENTRY stub_glVertexAttrib4uivARB (GLuint index, const GLuint *v);
GLAPI void APIENTRY stub_glVertexAttrib4usvARB (GLuint index, const GLushort *v);
GLAPI void APIENTRY stub_glVertexAttribPointerARB (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer);
GLAPI void APIENTRY stub_glEnableVertexAttribArrayARB (GLuint index);
GLAPI void APIENTRY stub_glDisableVertexAttribArrayARB (GLuint index);
GLAPI void APIENTRY stub_glGetVertexAttribdvARB (GLuint index, GLenum pname, GLdouble *params);
GLAPI void APIENTRY stub_glGetVertexAttribfvARB (GLuint index, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetVertexAttribivARB (GLuint index, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetVertexAttribPointervARB (GLuint index, GLenum pname, void **pointer);
GLAPI void APIENTRY stub_glBindAttribLocationARB (GLhandleARB programObj, GLuint index, const GLcharARB *name);
GLAPI void APIENTRY stub_glGetActiveAttribARB (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name);
GLAPI GLint APIENTRY stub_glGetAttribLocationARB (GLhandleARB programObj, const GLcharARB *name);
GLAPI void APIENTRY stub_glWindowPos2dARB (GLdouble x, GLdouble y);
GLAPI void APIENTRY stub_glWindowPos2dvARB (const GLdouble *v);
GLAPI void APIENTRY stub_glWindowPos2fARB (GLfloat x, GLfloat y);
GLAPI void APIENTRY stub_glWindowPos2fvARB (const GLfloat *v);
GLAPI void APIENTRY stub_glWindowPos2iARB (GLint x, GLint y);
GLAPI void APIENTRY stub_glWindowPos2ivARB (const GLint *v);
GLAPI void APIENTRY stub_glWindowPos2sARB (GLshort x, GLshort y);
GLAPI void APIENTRY stub_glWindowPos2svARB (const GLshort *v);
GLAPI void APIENTRY stub_glWindowPos3dARB (GLdouble x, GLdouble y, GLdouble z);
GLAPI void APIENTRY stub_glWindowPos3dvARB (const GLdouble *v);
GLAPI void APIENTRY stub_glWindowPos3fARB (GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glWindowPos3fvARB (const GLfloat *v);
GLAPI void APIENTRY stub_glWindowPos3iARB (GLint x, GLint y, GLint z);
GLAPI void APIENTRY stub_glWindowPos3ivARB (const GLint *v);
GLAPI void APIENTRY stub_glWindowPos3sARB (GLshort x, GLshort y, GLshort z);
GLAPI void APIENTRY stub_glWindowPos3svARB (const GLshort *v);
GLAPI void APIENTRY stub_glBlendBarrierKHR (void);
GLAPI void APIENTRY stub_glMultiTexCoord1bOES (GLenum texture, GLbyte s);
GLAPI void APIENTRY stub_glMultiTexCoord1bvOES (GLenum texture, const GLbyte *coords);
GLAPI void APIENTRY stub_glMultiTexCoord2bOES (GLenum texture, GLbyte s, GLbyte t);
GLAPI void APIENTRY stub_glMultiTexCoord2bvOES (GLenum texture, const GLbyte *coords);
GLAPI void APIENTRY stub_glMultiTexCoord3bOES (GLenum texture, GLbyte s, GLbyte t, GLbyte r);
GLAPI void APIENTRY stub_glMultiTexCoord3bvOES (GLenum texture, const GLbyte *coords);
GLAPI void APIENTRY stub_glMultiTexCoord4bOES (GLenum texture, GLbyte s, GLbyte t, GLbyte r, GLbyte q);
GLAPI void APIENTRY stub_glMultiTexCoord4bvOES (GLenum texture, const GLbyte *coords);
GLAPI void APIENTRY stub_glTexCoord1bOES (GLbyte s);
GLAPI void APIENTRY stub_glTexCoord1bvOES (const GLbyte *coords);
GLAPI void APIENTRY stub_glTexCoord2bOES (GLbyte s, GLbyte t);
GLAPI void APIENTRY stub_glTexCoord2bvOES (const GLbyte *coords);
GLAPI void APIENTRY stub_glTexCoord3bOES (GLbyte s, GLbyte t, GLbyte r);
GLAPI void APIENTRY stub_glTexCoord3bvOES (const GLbyte *coords);
GLAPI void APIENTRY stub_glTexCoord4bOES (GLbyte s, GLbyte t, GLbyte r, GLbyte q);
GLAPI void APIENTRY stub_glTexCoord4bvOES (const GLbyte *coords);
GLAPI void APIENTRY stub_glVertex2bOES (GLbyte x, GLbyte y);
GLAPI void APIENTRY stub_glVertex2bvOES (const GLbyte *coords);
GLAPI void APIENTRY stub_glVertex3bOES (GLbyte x, GLbyte y, GLbyte z);
GLAPI void APIENTRY stub_glVertex3bvOES (const GLbyte *coords);
GLAPI void APIENTRY stub_glVertex4bOES (GLbyte x, GLbyte y, GLbyte z, GLbyte w);
GLAPI void APIENTRY stub_glVertex4bvOES (const GLbyte *coords);
GLAPI void APIENTRY stub_glAlphaFuncxOES (GLenum func, GLfixed ref);
GLAPI void APIENTRY stub_glClearColorxOES (GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);
GLAPI void APIENTRY stub_glClearDepthxOES (GLfixed depth);
GLAPI void APIENTRY stub_glClipPlanexOES (GLenum plane, const GLfixed *equation);
GLAPI void APIENTRY stub_glColor4xOES (GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);
GLAPI void APIENTRY stub_glDepthRangexOES (GLfixed n, GLfixed f);
GLAPI void APIENTRY stub_glFogxOES (GLenum pname, GLfixed param);
GLAPI void APIENTRY stub_glFogxvOES (GLenum pname, const GLfixed *param);
GLAPI void APIENTRY stub_glFrustumxOES (GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f);
GLAPI void APIENTRY stub_glGetClipPlanexOES (GLenum plane, GLfixed *equation);
GLAPI void APIENTRY stub_glGetFixedvOES (GLenum pname, GLfixed *params);
GLAPI void APIENTRY stub_glGetTexEnvxvOES (GLenum target, GLenum pname, GLfixed *params);
GLAPI void APIENTRY stub_glGetTexParameterxvOES (GLenum target, GLenum pname, GLfixed *params);
GLAPI void APIENTRY stub_glLightModelxOES (GLenum pname, GLfixed param);
GLAPI void APIENTRY stub_glLightModelxvOES (GLenum pname, const GLfixed *param);
GLAPI void APIENTRY stub_glLightxOES (GLenum light, GLenum pname, GLfixed param);
GLAPI void APIENTRY stub_glLightxvOES (GLenum light, GLenum pname, const GLfixed *params);
GLAPI void APIENTRY stub_glLineWidthxOES (GLfixed width);
GLAPI void APIENTRY stub_glLoadMatrixxOES (const GLfixed *m);
GLAPI void APIENTRY stub_glMaterialxOES (GLenum face, GLenum pname, GLfixed param);
GLAPI void APIENTRY stub_glMaterialxvOES (GLenum face, GLenum pname, const GLfixed *param);
GLAPI void APIENTRY stub_glMultMatrixxOES (const GLfixed *m);
GLAPI void APIENTRY stub_glMultiTexCoord4xOES (GLenum texture, GLfixed s, GLfixed t, GLfixed r, GLfixed q);
GLAPI void APIENTRY stub_glNormal3xOES (GLfixed nx, GLfixed ny, GLfixed nz);
GLAPI void APIENTRY stub_glOrthoxOES (GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f);
GLAPI void APIENTRY stub_glPointParameterxvOES (GLenum pname, const GLfixed *params);
GLAPI void APIENTRY stub_glPointSizexOES (GLfixed size);
GLAPI void APIENTRY stub_glPolygonOffsetxOES (GLfixed factor, GLfixed units);
GLAPI void APIENTRY stub_glRotatexOES (GLfixed angle, GLfixed x, GLfixed y, GLfixed z);
GLAPI void APIENTRY stub_glScalexOES (GLfixed x, GLfixed y, GLfixed z);
GLAPI void APIENTRY stub_glTexEnvxOES (GLenum target, GLenum pname, GLfixed param);
GLAPI void APIENTRY stub_glTexEnvxvOES (GLenum target, GLenum pname, const GLfixed *params);
GLAPI void APIENTRY stub_glTexParameterxOES (GLenum target, GLenum pname, GLfixed param);
GLAPI void APIENTRY stub_glTexParameterxvOES (GLenum target, GLenum pname, const GLfixed *params);
GLAPI void APIENTRY stub_glTranslatexOES (GLfixed x, GLfixed y, GLfixed z);
GLAPI void APIENTRY stub_glAccumxOES (GLenum op, GLfixed value);
GLAPI void APIENTRY stub_glBitmapxOES (GLsizei width, GLsizei height, GLfixed xorig, GLfixed yorig, GLfixed xmove, GLfixed ymove, const GLubyte *bitmap);
GLAPI void APIENTRY stub_glBlendColorxOES (GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);
GLAPI void APIENTRY stub_glClearAccumxOES (GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);
GLAPI void APIENTRY stub_glColor3xOES (GLfixed red, GLfixed green, GLfixed blue);
GLAPI void APIENTRY stub_glColor3xvOES (const GLfixed *components);
GLAPI void APIENTRY stub_glColor4xvOES (const GLfixed *components);
GLAPI void APIENTRY stub_glConvolutionParameterxOES (GLenum target, GLenum pname, GLfixed param);
GLAPI void APIENTRY stub_glConvolutionParameterxvOES (GLenum target, GLenum pname, const GLfixed *params);
GLAPI void APIENTRY stub_glEvalCoord1xOES (GLfixed u);
GLAPI void APIENTRY stub_glEvalCoord1xvOES (const GLfixed *coords);
GLAPI void APIENTRY stub_glEvalCoord2xOES (GLfixed u, GLfixed v);
GLAPI void APIENTRY stub_glEvalCoord2xvOES (const GLfixed *coords);
GLAPI void APIENTRY stub_glFeedbackBufferxOES (GLsizei n, GLenum type, const GLfixed *buffer);
GLAPI void APIENTRY stub_glGetConvolutionParameterxvOES (GLenum target, GLenum pname, GLfixed *params);
GLAPI void APIENTRY stub_glGetHistogramParameterxvOES (GLenum target, GLenum pname, GLfixed *params);
GLAPI void APIENTRY stub_glGetLightxOES (GLenum light, GLenum pname, GLfixed *params);
GLAPI void APIENTRY stub_glGetMapxvOES (GLenum target, GLenum query, GLfixed *v);
GLAPI void APIENTRY stub_glGetMaterialxOES (GLenum face, GLenum pname, GLfixed param);
GLAPI void APIENTRY stub_glGetPixelMapxv (GLenum map, GLint size, GLfixed *values);
GLAPI void APIENTRY stub_glGetTexGenxvOES (GLenum coord, GLenum pname, GLfixed *params);
GLAPI void APIENTRY stub_glGetTexLevelParameterxvOES (GLenum target, GLint level, GLenum pname, GLfixed *params);
GLAPI void APIENTRY stub_glIndexxOES (GLfixed component);
GLAPI void APIENTRY stub_glIndexxvOES (const GLfixed *component);
GLAPI void APIENTRY stub_glLoadTransposeMatrixxOES (const GLfixed *m);
GLAPI void APIENTRY stub_glMap1xOES (GLenum target, GLfixed u1, GLfixed u2, GLint stride, GLint order, GLfixed points);
GLAPI void APIENTRY stub_glMap2xOES (GLenum target, GLfixed u1, GLfixed u2, GLint ustride, GLint uorder, GLfixed v1, GLfixed v2, GLint vstride, GLint vorder, GLfixed points);
GLAPI void APIENTRY stub_glMapGrid1xOES (GLint n, GLfixed u1, GLfixed u2);
GLAPI void APIENTRY stub_glMapGrid2xOES (GLint n, GLfixed u1, GLfixed u2, GLfixed v1, GLfixed v2);
GLAPI void APIENTRY stub_glMultTransposeMatrixxOES (const GLfixed *m);
GLAPI void APIENTRY stub_glMultiTexCoord1xOES (GLenum texture, GLfixed s);
GLAPI void APIENTRY stub_glMultiTexCoord1xvOES (GLenum texture, const GLfixed *coords);
GLAPI void APIENTRY stub_glMultiTexCoord2xOES (GLenum texture, GLfixed s, GLfixed t);
GLAPI void APIENTRY stub_glMultiTexCoord2xvOES (GLenum texture, const GLfixed *coords);
GLAPI void APIENTRY stub_glMultiTexCoord3xOES (GLenum texture, GLfixed s, GLfixed t, GLfixed r);
GLAPI void APIENTRY stub_glMultiTexCoord3xvOES (GLenum texture, const GLfixed *coords);
GLAPI void APIENTRY stub_glMultiTexCoord4xvOES (GLenum texture, const GLfixed *coords);
GLAPI void APIENTRY stub_glNormal3xvOES (const GLfixed *coords);
GLAPI void APIENTRY stub_glPassThroughxOES (GLfixed token);
GLAPI void APIENTRY stub_glPixelMapx (GLenum map, GLint size, const GLfixed *values);
GLAPI void APIENTRY stub_glPixelStorex (GLenum pname, GLfixed param);
GLAPI void APIENTRY stub_glPixelTransferxOES (GLenum pname, GLfixed param);
GLAPI void APIENTRY stub_glPixelZoomxOES (GLfixed xfactor, GLfixed yfactor);
GLAPI void APIENTRY stub_glPrioritizeTexturesxOES (GLsizei n, const GLuint *textures, const GLfixed *priorities);
GLAPI void APIENTRY stub_glRasterPos2xOES (GLfixed x, GLfixed y);
GLAPI void APIENTRY stub_glRasterPos2xvOES (const GLfixed *coords);
GLAPI void APIENTRY stub_glRasterPos3xOES (GLfixed x, GLfixed y, GLfixed z);
GLAPI void APIENTRY stub_glRasterPos3xvOES (const GLfixed *coords);
GLAPI void APIENTRY stub_glRasterPos4xOES (GLfixed x, GLfixed y, GLfixed z, GLfixed w);
GLAPI void APIENTRY stub_glRasterPos4xvOES (const GLfixed *coords);
GLAPI void APIENTRY stub_glRectxOES (GLfixed x1, GLfixed y1, GLfixed x2, GLfixed y2);
GLAPI void APIENTRY stub_glRectxvOES (const GLfixed *v1, const GLfixed *v2);
GLAPI void APIENTRY stub_glTexCoord1xOES (GLfixed s);
GLAPI void APIENTRY stub_glTexCoord1xvOES (const GLfixed *coords);
GLAPI void APIENTRY stub_glTexCoord2xOES (GLfixed s, GLfixed t);
GLAPI void APIENTRY stub_glTexCoord2xvOES (const GLfixed *coords);
GLAPI void APIENTRY stub_glTexCoord3xOES (GLfixed s, GLfixed t, GLfixed r);
GLAPI void APIENTRY stub_glTexCoord3xvOES (const GLfixed *coords);
GLAPI void APIENTRY stub_glTexCoord4xOES (GLfixed s, GLfixed t, GLfixed r, GLfixed q);
GLAPI void APIENTRY stub_glTexCoord4xvOES (const GLfixed *coords);
GLAPI void APIENTRY stub_glTexGenxOES (GLenum coord, GLenum pname, GLfixed param);
GLAPI void APIENTRY stub_glTexGenxvOES (GLenum coord, GLenum pname, const GLfixed *params);
GLAPI void APIENTRY stub_glVertex2xOES (GLfixed x);
GLAPI void APIENTRY stub_glVertex2xvOES (const GLfixed *coords);
GLAPI void APIENTRY stub_glVertex3xOES (GLfixed x, GLfixed y);
GLAPI void APIENTRY stub_glVertex3xvOES (const GLfixed *coords);
GLAPI void APIENTRY stub_glVertex4xOES (GLfixed x, GLfixed y, GLfixed z);
GLAPI void APIENTRY stub_glVertex4xvOES (const GLfixed *coords);
GLAPI GLbitfield APIENTRY stub_glQueryMatrixxOES (GLfixed *mantissa, GLint *exponent);
GLAPI void APIENTRY stub_glClearDepthfOES (GLclampf depth);
GLAPI void APIENTRY stub_glClipPlanefOES (GLenum plane, const GLfloat *equation);
GLAPI void APIENTRY stub_glDepthRangefOES (GLclampf n, GLclampf f);
GLAPI void APIENTRY stub_glFrustumfOES (GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f);
GLAPI void APIENTRY stub_glGetClipPlanefOES (GLenum plane, GLfloat *equation);
GLAPI void APIENTRY stub_glOrthofOES (GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f);
GLAPI void APIENTRY stub_glTbufferMask3DFX (GLuint mask);
GLAPI void APIENTRY stub_glDebugMessageEnableAMD (GLenum category, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled);
GLAPI void APIENTRY stub_glDebugMessageInsertAMD (GLenum category, GLenum severity, GLuint id, GLsizei length, const GLchar *buf);
GLAPI void APIENTRY stub_glDebugMessageCallbackAMD (GLDEBUGPROCAMD callback, void *userParam);
GLAPI GLuint APIENTRY stub_glGetDebugMessageLogAMD (GLuint count, GLsizei bufsize, GLenum *categories, GLuint *severities, GLuint *ids, GLsizei *lengths, GLchar *message);
GLAPI void APIENTRY stub_glBlendFuncIndexedAMD (GLuint buf, GLenum src, GLenum dst);
GLAPI void APIENTRY stub_glBlendFuncSeparateIndexedAMD (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
GLAPI void APIENTRY stub_glBlendEquationIndexedAMD (GLuint buf, GLenum mode);
GLAPI void APIENTRY stub_glBlendEquationSeparateIndexedAMD (GLuint buf, GLenum modeRGB, GLenum modeAlpha);
GLAPI void APIENTRY stub_glUniform1i64NV (GLint location, GLint64EXT x);
GLAPI void APIENTRY stub_glUniform2i64NV (GLint location, GLint64EXT x, GLint64EXT y);
GLAPI void APIENTRY stub_glUniform3i64NV (GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z);
GLAPI void APIENTRY stub_glUniform4i64NV (GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w);
GLAPI void APIENTRY stub_glUniform1i64vNV (GLint location, GLsizei count, const GLint64EXT *value);
GLAPI void APIENTRY stub_glUniform2i64vNV (GLint location, GLsizei count, const GLint64EXT *value);
GLAPI void APIENTRY stub_glUniform3i64vNV (GLint location, GLsizei count, const GLint64EXT *value);
GLAPI void APIENTRY stub_glUniform4i64vNV (GLint location, GLsizei count, const GLint64EXT *value);
GLAPI void APIENTRY stub_glUniform1ui64NV (GLint location, GLuint64EXT x);
GLAPI void APIENTRY stub_glUniform2ui64NV (GLint location, GLuint64EXT x, GLuint64EXT y);
GLAPI void APIENTRY stub_glUniform3ui64NV (GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z);
GLAPI void APIENTRY stub_glUniform4ui64NV (GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w);
GLAPI void APIENTRY stub_glUniform1ui64vNV (GLint location, GLsizei count, const GLuint64EXT *value);
GLAPI void APIENTRY stub_glUniform2ui64vNV (GLint location, GLsizei count, const GLuint64EXT *value);
GLAPI void APIENTRY stub_glUniform3ui64vNV (GLint location, GLsizei count, const GLuint64EXT *value);
GLAPI void APIENTRY stub_glUniform4ui64vNV (GLint location, GLsizei count, const GLuint64EXT *value);
GLAPI void APIENTRY stub_glGetUniformi64vNV (GLuint program, GLint location, GLint64EXT *params);
GLAPI void APIENTRY stub_glGetUniformui64vNV (GLuint program, GLint location, GLuint64EXT *params);
GLAPI void APIENTRY stub_glProgramUniform1i64NV (GLuint program, GLint location, GLint64EXT x);
GLAPI void APIENTRY stub_glProgramUniform2i64NV (GLuint program, GLint location, GLint64EXT x, GLint64EXT y);
GLAPI void APIENTRY stub_glProgramUniform3i64NV (GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z);
GLAPI void APIENTRY stub_glProgramUniform4i64NV (GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w);
GLAPI void APIENTRY stub_glProgramUniform1i64vNV (GLuint program, GLint location, GLsizei count, const GLint64EXT *value);
GLAPI void APIENTRY stub_glProgramUniform2i64vNV (GLuint program, GLint location, GLsizei count, const GLint64EXT *value);
GLAPI void APIENTRY stub_glProgramUniform3i64vNV (GLuint program, GLint location, GLsizei count, const GLint64EXT *value);
GLAPI void APIENTRY stub_glProgramUniform4i64vNV (GLuint program, GLint location, GLsizei count, const GLint64EXT *value);
GLAPI void APIENTRY stub_glProgramUniform1ui64NV (GLuint program, GLint location, GLuint64EXT x);
GLAPI void APIENTRY stub_glProgramUniform2ui64NV (GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y);
GLAPI void APIENTRY stub_glProgramUniform3ui64NV (GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z);
GLAPI void APIENTRY stub_glProgramUniform4ui64NV (GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w);
GLAPI void APIENTRY stub_glProgramUniform1ui64vNV (GLuint program, GLint location, GLsizei count, const GLuint64EXT *value);
GLAPI void APIENTRY stub_glProgramUniform2ui64vNV (GLuint program, GLint location, GLsizei count, const GLuint64EXT *value);
GLAPI void APIENTRY stub_glProgramUniform3ui64vNV (GLuint program, GLint location, GLsizei count, const GLuint64EXT *value);
GLAPI void APIENTRY stub_glProgramUniform4ui64vNV (GLuint program, GLint location, GLsizei count, const GLuint64EXT *value);
GLAPI void APIENTRY stub_glVertexAttribParameteriAMD (GLuint index, GLenum pname, GLint param);
GLAPI void APIENTRY stub_glMultiDrawArraysIndirectAMD (GLenum mode, const void *indirect, GLsizei primcount, GLsizei stride);
GLAPI void APIENTRY stub_glMultiDrawElementsIndirectAMD (GLenum mode, GLenum type, const void *indirect, GLsizei primcount, GLsizei stride);
GLAPI void APIENTRY stub_glGenNamesAMD (GLenum identifier, GLuint num, GLuint *names);
GLAPI void APIENTRY stub_glDeleteNamesAMD (GLenum identifier, GLuint num, const GLuint *names);
GLAPI GLboolean APIENTRY stub_glIsNameAMD (GLenum identifier, GLuint name);
GLAPI void APIENTRY stub_glQueryObjectParameteruiAMD (GLenum target, GLuint id, GLenum pname, GLuint param);
GLAPI void APIENTRY stub_glGetPerfMonitorGroupsAMD (GLint *numGroups, GLsizei groupsSize, GLuint *groups);
GLAPI void APIENTRY stub_glGetPerfMonitorCountersAMD (GLuint group, GLint *numCounters, GLint *maxActiveCounters, GLsizei counterSize, GLuint *counters);
GLAPI void APIENTRY stub_glGetPerfMonitorGroupStringAMD (GLuint group, GLsizei bufSize, GLsizei *length, GLchar *groupString);
GLAPI void APIENTRY stub_glGetPerfMonitorCounterStringAMD (GLuint group, GLuint counter, GLsizei bufSize, GLsizei *length, GLchar *counterString);
GLAPI void APIENTRY stub_glGetPerfMonitorCounterInfoAMD (GLuint group, GLuint counter, GLenum pname, void *data);
GLAPI void APIENTRY stub_glGenPerfMonitorsAMD (GLsizei n, GLuint *monitors);
GLAPI void APIENTRY stub_glDeletePerfMonitorsAMD (GLsizei n, GLuint *monitors);
GLAPI void APIENTRY stub_glSelectPerfMonitorCountersAMD (GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint *counterList);
GLAPI void APIENTRY stub_glBeginPerfMonitorAMD (GLuint monitor);
GLAPI void APIENTRY stub_glEndPerfMonitorAMD (GLuint monitor);
GLAPI void APIENTRY stub_glGetPerfMonitorCounterDataAMD (GLuint monitor, GLenum pname, GLsizei dataSize, GLuint *data, GLint *bytesWritten);
GLAPI void APIENTRY stub_glSetMultisamplefvAMD (GLenum pname, GLuint index, const GLfloat *val);
GLAPI void APIENTRY stub_glTexStorageSparseAMD (GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei layers, GLbitfield flags);
GLAPI void APIENTRY stub_glTextureStorageSparseAMD (GLuint texture, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei layers, GLbitfield flags);
GLAPI void APIENTRY stub_glStencilOpValueAMD (GLenum face, GLuint value);
GLAPI void APIENTRY stub_glTessellationFactorAMD (GLfloat factor);
GLAPI void APIENTRY stub_glTessellationModeAMD (GLenum mode);
GLAPI void APIENTRY stub_glElementPointerAPPLE (GLenum type, const void *pointer);
GLAPI void APIENTRY stub_glDrawElementArrayAPPLE (GLenum mode, GLint first, GLsizei count);
GLAPI void APIENTRY stub_glDrawRangeElementArrayAPPLE (GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count);
GLAPI void APIENTRY stub_glMultiDrawElementArrayAPPLE (GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount);
GLAPI void APIENTRY stub_glMultiDrawRangeElementArrayAPPLE (GLenum mode, GLuint start, GLuint end, const GLint *first, const GLsizei *count, GLsizei primcount);
GLAPI void APIENTRY stub_glGenFencesAPPLE (GLsizei n, GLuint *fences);
GLAPI void APIENTRY stub_glDeleteFencesAPPLE (GLsizei n, const GLuint *fences);
GLAPI void APIENTRY stub_glSetFenceAPPLE (GLuint fence);
GLAPI GLboolean APIENTRY stub_glIsFenceAPPLE (GLuint fence);
GLAPI GLboolean APIENTRY stub_glTestFenceAPPLE (GLuint fence);
GLAPI void APIENTRY stub_glFinishFenceAPPLE (GLuint fence);
GLAPI GLboolean APIENTRY stub_glTestObjectAPPLE (GLenum object, GLuint name);
GLAPI void APIENTRY stub_glFinishObjectAPPLE (GLenum object, GLint name);
GLAPI void APIENTRY stub_glBufferParameteriAPPLE (GLenum target, GLenum pname, GLint param);
GLAPI void APIENTRY stub_glFlushMappedBufferRangeAPPLE (GLenum target, GLintptr offset, GLsizeiptr size);
GLAPI GLenum APIENTRY stub_glObjectPurgeableAPPLE (GLenum objectType, GLuint name, GLenum option);
GLAPI GLenum APIENTRY stub_glObjectUnpurgeableAPPLE (GLenum objectType, GLuint name, GLenum option);
GLAPI void APIENTRY stub_glGetObjectParameterivAPPLE (GLenum objectType, GLuint name, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glTextureRangeAPPLE (GLenum target, GLsizei length, const void *pointer);
GLAPI void APIENTRY stub_glGetTexParameterPointervAPPLE (GLenum target, GLenum pname, void **params);
GLAPI void APIENTRY stub_glBindVertexArrayAPPLE (GLuint array);
GLAPI void APIENTRY stub_glDeleteVertexArraysAPPLE (GLsizei n, const GLuint *arrays);
GLAPI void APIENTRY stub_glGenVertexArraysAPPLE (GLsizei n, GLuint *arrays);
GLAPI GLboolean APIENTRY stub_glIsVertexArrayAPPLE (GLuint array);
GLAPI void APIENTRY stub_glVertexArrayRangeAPPLE (GLsizei length, void *pointer);
GLAPI void APIENTRY stub_glFlushVertexArrayRangeAPPLE (GLsizei length, void *pointer);
GLAPI void APIENTRY stub_glVertexArrayParameteriAPPLE (GLenum pname, GLint param);
GLAPI void APIENTRY stub_glEnableVertexAttribAPPLE (GLuint index, GLenum pname);
GLAPI void APIENTRY stub_glDisableVertexAttribAPPLE (GLuint index, GLenum pname);
GLAPI GLboolean APIENTRY stub_glIsVertexAttribEnabledAPPLE (GLuint index, GLenum pname);
GLAPI void APIENTRY stub_glMapVertexAttrib1dAPPLE (GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
GLAPI void APIENTRY stub_glMapVertexAttrib1fAPPLE (GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
GLAPI void APIENTRY stub_glMapVertexAttrib2dAPPLE (GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
GLAPI void APIENTRY stub_glMapVertexAttrib2fAPPLE (GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
GLAPI void APIENTRY stub_glDrawBuffersATI (GLsizei n, const GLenum *bufs);
GLAPI void APIENTRY stub_glElementPointerATI (GLenum type, const void *pointer);
GLAPI void APIENTRY stub_glDrawElementArrayATI (GLenum mode, GLsizei count);
GLAPI void APIENTRY stub_glDrawRangeElementArrayATI (GLenum mode, GLuint start, GLuint end, GLsizei count);
GLAPI void APIENTRY stub_glTexBumpParameterivATI (GLenum pname, const GLint *param);
GLAPI void APIENTRY stub_glTexBumpParameterfvATI (GLenum pname, const GLfloat *param);
GLAPI void APIENTRY stub_glGetTexBumpParameterivATI (GLenum pname, GLint *param);
GLAPI void APIENTRY stub_glGetTexBumpParameterfvATI (GLenum pname, GLfloat *param);
GLAPI GLuint APIENTRY stub_glGenFragmentShadersATI (GLuint range);
GLAPI void APIENTRY stub_glBindFragmentShaderATI (GLuint id);
GLAPI void APIENTRY stub_glDeleteFragmentShaderATI (GLuint id);
GLAPI void APIENTRY stub_glBeginFragmentShaderATI (void);
GLAPI void APIENTRY stub_glEndFragmentShaderATI (void);
GLAPI void APIENTRY stub_glPassTexCoordATI (GLuint dst, GLuint coord, GLenum swizzle);
GLAPI void APIENTRY stub_glSampleMapATI (GLuint dst, GLuint interp, GLenum swizzle);
GLAPI void APIENTRY stub_glColorFragmentOp1ATI (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
GLAPI void APIENTRY stub_glColorFragmentOp2ATI (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
GLAPI void APIENTRY stub_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);
GLAPI void APIENTRY stub_glAlphaFragmentOp1ATI (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
GLAPI void APIENTRY stub_glAlphaFragmentOp2ATI (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
GLAPI void APIENTRY stub_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);
GLAPI void APIENTRY stub_glSetFragmentShaderConstantATI (GLuint dst, const GLfloat *value);
GLAPI void *APIENTRY stub_glMapObjectBufferATI (GLuint buffer);
GLAPI void APIENTRY stub_glUnmapObjectBufferATI (GLuint buffer);
GLAPI void APIENTRY stub_glPNTrianglesiATI (GLenum pname, GLint param);
GLAPI void APIENTRY stub_glPNTrianglesfATI (GLenum pname, GLfloat param);
GLAPI void APIENTRY stub_glStencilOpSeparateATI (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
GLAPI void APIENTRY stub_glStencilFuncSeparateATI (GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask);
GLAPI GLuint APIENTRY stub_glNewObjectBufferATI (GLsizei size, const void *pointer, GLenum usage);
GLAPI GLboolean APIENTRY stub_glIsObjectBufferATI (GLuint buffer);
GLAPI void APIENTRY stub_glUpdateObjectBufferATI (GLuint buffer, GLuint offset, GLsizei size, const void *pointer, GLenum preserve);
GLAPI void APIENTRY stub_glGetObjectBufferfvATI (GLuint buffer, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetObjectBufferivATI (GLuint buffer, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glFreeObjectBufferATI (GLuint buffer);
GLAPI void APIENTRY stub_glArrayObjectATI (GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset);
GLAPI void APIENTRY stub_glGetArrayObjectfvATI (GLenum array, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetArrayObjectivATI (GLenum array, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glVariantArrayObjectATI (GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset);
GLAPI void APIENTRY stub_glGetVariantArrayObjectfvATI (GLuint id, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetVariantArrayObjectivATI (GLuint id, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glVertexAttribArrayObjectATI (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset);
GLAPI void APIENTRY stub_glGetVertexAttribArrayObjectfvATI (GLuint index, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetVertexAttribArrayObjectivATI (GLuint index, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glVertexStream1sATI (GLenum stream, GLshort x);
GLAPI void APIENTRY stub_glVertexStream1svATI (GLenum stream, const GLshort *coords);
GLAPI void APIENTRY stub_glVertexStream1iATI (GLenum stream, GLint x);
GLAPI void APIENTRY stub_glVertexStream1ivATI (GLenum stream, const GLint *coords);
GLAPI void APIENTRY stub_glVertexStream1fATI (GLenum stream, GLfloat x);
GLAPI void APIENTRY stub_glVertexStream1fvATI (GLenum stream, const GLfloat *coords);
GLAPI void APIENTRY stub_glVertexStream1dATI (GLenum stream, GLdouble x);
GLAPI void APIENTRY stub_glVertexStream1dvATI (GLenum stream, const GLdouble *coords);
GLAPI void APIENTRY stub_glVertexStream2sATI (GLenum stream, GLshort x, GLshort y);
GLAPI void APIENTRY stub_glVertexStream2svATI (GLenum stream, const GLshort *coords);
GLAPI void APIENTRY stub_glVertexStream2iATI (GLenum stream, GLint x, GLint y);
GLAPI void APIENTRY stub_glVertexStream2ivATI (GLenum stream, const GLint *coords);
GLAPI void APIENTRY stub_glVertexStream2fATI (GLenum stream, GLfloat x, GLfloat y);
GLAPI void APIENTRY stub_glVertexStream2fvATI (GLenum stream, const GLfloat *coords);
GLAPI void APIENTRY stub_glVertexStream2dATI (GLenum stream, GLdouble x, GLdouble y);
GLAPI void APIENTRY stub_glVertexStream2dvATI (GLenum stream, const GLdouble *coords);
GLAPI void APIENTRY stub_glVertexStream3sATI (GLenum stream, GLshort x, GLshort y, GLshort z);
GLAPI void APIENTRY stub_glVertexStream3svATI (GLenum stream, const GLshort *coords);
GLAPI void APIENTRY stub_glVertexStream3iATI (GLenum stream, GLint x, GLint y, GLint z);
GLAPI void APIENTRY stub_glVertexStream3ivATI (GLenum stream, const GLint *coords);
GLAPI void APIENTRY stub_glVertexStream3fATI (GLenum stream, GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glVertexStream3fvATI (GLenum stream, const GLfloat *coords);
GLAPI void APIENTRY stub_glVertexStream3dATI (GLenum stream, GLdouble x, GLdouble y, GLdouble z);
GLAPI void APIENTRY stub_glVertexStream3dvATI (GLenum stream, const GLdouble *coords);
GLAPI void APIENTRY stub_glVertexStream4sATI (GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w);
GLAPI void APIENTRY stub_glVertexStream4svATI (GLenum stream, const GLshort *coords);
GLAPI void APIENTRY stub_glVertexStream4iATI (GLenum stream, GLint x, GLint y, GLint z, GLint w);
GLAPI void APIENTRY stub_glVertexStream4ivATI (GLenum stream, const GLint *coords);
GLAPI void APIENTRY stub_glVertexStream4fATI (GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
GLAPI void APIENTRY stub_glVertexStream4fvATI (GLenum stream, const GLfloat *coords);
GLAPI void APIENTRY stub_glVertexStream4dATI (GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
GLAPI void APIENTRY stub_glVertexStream4dvATI (GLenum stream, const GLdouble *coords);
GLAPI void APIENTRY stub_glNormalStream3bATI (GLenum stream, GLbyte nx, GLbyte ny, GLbyte nz);
GLAPI void APIENTRY stub_glNormalStream3bvATI (GLenum stream, const GLbyte *coords);
GLAPI void APIENTRY stub_glNormalStream3sATI (GLenum stream, GLshort nx, GLshort ny, GLshort nz);
GLAPI void APIENTRY stub_glNormalStream3svATI (GLenum stream, const GLshort *coords);
GLAPI void APIENTRY stub_glNormalStream3iATI (GLenum stream, GLint nx, GLint ny, GLint nz);
GLAPI void APIENTRY stub_glNormalStream3ivATI (GLenum stream, const GLint *coords);
GLAPI void APIENTRY stub_glNormalStream3fATI (GLenum stream, GLfloat nx, GLfloat ny, GLfloat nz);
GLAPI void APIENTRY stub_glNormalStream3fvATI (GLenum stream, const GLfloat *coords);
GLAPI void APIENTRY stub_glNormalStream3dATI (GLenum stream, GLdouble nx, GLdouble ny, GLdouble nz);
GLAPI void APIENTRY stub_glNormalStream3dvATI (GLenum stream, const GLdouble *coords);
GLAPI void APIENTRY stub_glClientActiveVertexStreamATI (GLenum stream);
GLAPI void APIENTRY stub_glVertexBlendEnviATI (GLenum pname, GLint param);
GLAPI void APIENTRY stub_glVertexBlendEnvfATI (GLenum pname, GLfloat param);
GLAPI void APIENTRY stub_glUniformBufferEXT (GLuint program, GLint location, GLuint buffer);
GLAPI GLint APIENTRY stub_glGetUniformBufferSizeEXT (GLuint program, GLint location);
GLAPI GLintptr APIENTRY stub_glGetUniformOffsetEXT (GLuint program, GLint location);
GLAPI void APIENTRY stub_glBlendColorEXT (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
GLAPI void APIENTRY stub_glBlendEquationSeparateEXT (GLenum modeRGB, GLenum modeAlpha);
GLAPI void APIENTRY stub_glBlendFuncSeparateEXT (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
GLAPI void APIENTRY stub_glBlendEquationEXT (GLenum mode);
GLAPI void APIENTRY stub_glColorSubTableEXT (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data);
GLAPI void APIENTRY stub_glCopyColorSubTableEXT (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
GLAPI void APIENTRY stub_glLockArraysEXT (GLint first, GLsizei count);
GLAPI void APIENTRY stub_glUnlockArraysEXT (void);
GLAPI void APIENTRY stub_glConvolutionFilter1DEXT (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *image);
GLAPI void APIENTRY stub_glConvolutionFilter2DEXT (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *image);
GLAPI void APIENTRY stub_glConvolutionParameterfEXT (GLenum target, GLenum pname, GLfloat params);
GLAPI void APIENTRY stub_glConvolutionParameterfvEXT (GLenum target, GLenum pname, const GLfloat *params);
GLAPI void APIENTRY stub_glConvolutionParameteriEXT (GLenum target, GLenum pname, GLint params);
GLAPI void APIENTRY stub_glConvolutionParameterivEXT (GLenum target, GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glCopyConvolutionFilter1DEXT (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
GLAPI void APIENTRY stub_glCopyConvolutionFilter2DEXT (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glGetConvolutionFilterEXT (GLenum target, GLenum format, GLenum type, void *image);
GLAPI void APIENTRY stub_glGetConvolutionParameterfvEXT (GLenum target, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetConvolutionParameterivEXT (GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetSeparableFilterEXT (GLenum target, GLenum format, GLenum type, void *row, void *column, void *span);
GLAPI void APIENTRY stub_glSeparableFilter2DEXT (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *row, const void *column);
GLAPI void APIENTRY stub_glTangent3bEXT (GLbyte tx, GLbyte ty, GLbyte tz);
GLAPI void APIENTRY stub_glTangent3bvEXT (const GLbyte *v);
GLAPI void APIENTRY stub_glTangent3dEXT (GLdouble tx, GLdouble ty, GLdouble tz);
GLAPI void APIENTRY stub_glTangent3dvEXT (const GLdouble *v);
GLAPI void APIENTRY stub_glTangent3fEXT (GLfloat tx, GLfloat ty, GLfloat tz);
GLAPI void APIENTRY stub_glTangent3fvEXT (const GLfloat *v);
GLAPI void APIENTRY stub_glTangent3iEXT (GLint tx, GLint ty, GLint tz);
GLAPI void APIENTRY stub_glTangent3ivEXT (const GLint *v);
GLAPI void APIENTRY stub_glTangent3sEXT (GLshort tx, GLshort ty, GLshort tz);
GLAPI void APIENTRY stub_glTangent3svEXT (const GLshort *v);
GLAPI void APIENTRY stub_glBinormal3bEXT (GLbyte bx, GLbyte by, GLbyte bz);
GLAPI void APIENTRY stub_glBinormal3bvEXT (const GLbyte *v);
GLAPI void APIENTRY stub_glBinormal3dEXT (GLdouble bx, GLdouble by, GLdouble bz);
GLAPI void APIENTRY stub_glBinormal3dvEXT (const GLdouble *v);
GLAPI void APIENTRY stub_glBinormal3fEXT (GLfloat bx, GLfloat by, GLfloat bz);
GLAPI void APIENTRY stub_glBinormal3fvEXT (const GLfloat *v);
GLAPI void APIENTRY stub_glBinormal3iEXT (GLint bx, GLint by, GLint bz);
GLAPI void APIENTRY stub_glBinormal3ivEXT (const GLint *v);
GLAPI void APIENTRY stub_glBinormal3sEXT (GLshort bx, GLshort by, GLshort bz);
GLAPI void APIENTRY stub_glBinormal3svEXT (const GLshort *v);
GLAPI void APIENTRY stub_glTangentPointerEXT (GLenum type, GLsizei stride, const void *pointer);
GLAPI void APIENTRY stub_glBinormalPointerEXT (GLenum type, GLsizei stride, const void *pointer);
GLAPI void APIENTRY stub_glCopyTexImage1DEXT (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
GLAPI void APIENTRY stub_glCopyTexImage2DEXT (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
GLAPI void APIENTRY stub_glCopyTexSubImage1DEXT (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
GLAPI void APIENTRY stub_glCopyTexSubImage2DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glCopyTexSubImage3DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glCullParameterdvEXT (GLenum pname, GLdouble *params);
GLAPI void APIENTRY stub_glCullParameterfvEXT (GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glLabelObjectEXT (GLenum type, GLuint object, GLsizei length, const GLchar *label);
GLAPI void APIENTRY stub_glGetObjectLabelEXT (GLenum type, GLuint object, GLsizei bufSize, GLsizei *length, GLchar *label);
GLAPI void APIENTRY stub_glInsertEventMarkerEXT (GLsizei length, const GLchar *marker);
GLAPI void APIENTRY stub_glPushGroupMarkerEXT (GLsizei length, const GLchar *marker);
GLAPI void APIENTRY stub_glPopGroupMarkerEXT (void);
GLAPI void APIENTRY stub_glDepthBoundsEXT (GLclampd zmin, GLclampd zmax);
GLAPI void APIENTRY stub_glMatrixLoadfEXT (GLenum mode, const GLfloat *m);
GLAPI void APIENTRY stub_glMatrixLoaddEXT (GLenum mode, const GLdouble *m);
GLAPI void APIENTRY stub_glMatrixMultfEXT (GLenum mode, const GLfloat *m);
GLAPI void APIENTRY stub_glMatrixMultdEXT (GLenum mode, const GLdouble *m);
GLAPI void APIENTRY stub_glMatrixLoadIdentityEXT (GLenum mode);
GLAPI void APIENTRY stub_glMatrixRotatefEXT (GLenum mode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glMatrixRotatedEXT (GLenum mode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
GLAPI void APIENTRY stub_glMatrixScalefEXT (GLenum mode, GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glMatrixScaledEXT (GLenum mode, GLdouble x, GLdouble y, GLdouble z);
GLAPI void APIENTRY stub_glMatrixTranslatefEXT (GLenum mode, GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glMatrixTranslatedEXT (GLenum mode, GLdouble x, GLdouble y, GLdouble z);
GLAPI void APIENTRY stub_glMatrixFrustumEXT (GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
GLAPI void APIENTRY stub_glMatrixOrthoEXT (GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
GLAPI void APIENTRY stub_glMatrixPopEXT (GLenum mode);
GLAPI void APIENTRY stub_glMatrixPushEXT (GLenum mode);
GLAPI void APIENTRY stub_glClientAttribDefaultEXT (GLbitfield mask);
GLAPI void APIENTRY stub_glPushClientAttribDefaultEXT (GLbitfield mask);
GLAPI void APIENTRY stub_glTextureParameterfEXT (GLuint texture, GLenum target, GLenum pname, GLfloat param);
GLAPI void APIENTRY stub_glTextureParameterfvEXT (GLuint texture, GLenum target, GLenum pname, const GLfloat *params);
GLAPI void APIENTRY stub_glTextureParameteriEXT (GLuint texture, GLenum target, GLenum pname, GLint param);
GLAPI void APIENTRY stub_glTextureParameterivEXT (GLuint texture, GLenum target, GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glTextureImage1DEXT (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels);
GLAPI void APIENTRY stub_glTextureImage2DEXT (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels);
GLAPI void APIENTRY stub_glTextureSubImage1DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels);
GLAPI void APIENTRY stub_glTextureSubImage2DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
GLAPI void APIENTRY stub_glCopyTextureImage1DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
GLAPI void APIENTRY stub_glCopyTextureImage2DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
GLAPI void APIENTRY stub_glCopyTextureSubImage1DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
GLAPI void APIENTRY stub_glCopyTextureSubImage2DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glGetTextureImageEXT (GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, void *pixels);
GLAPI void APIENTRY stub_glGetTextureParameterfvEXT (GLuint texture, GLenum target, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetTextureParameterivEXT (GLuint texture, GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetTextureLevelParameterfvEXT (GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetTextureLevelParameterivEXT (GLuint texture, GLenum target, GLint level, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glTextureImage3DEXT (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels);
GLAPI void APIENTRY stub_glTextureSubImage3DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);
GLAPI void APIENTRY stub_glCopyTextureSubImage3DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glBindMultiTextureEXT (GLenum texunit, GLenum target, GLuint texture);
GLAPI void APIENTRY stub_glMultiTexEnvfEXT (GLenum texunit, GLenum target, GLenum pname, GLfloat param);
GLAPI void APIENTRY stub_glMultiTexEnvfvEXT (GLenum texunit, GLenum target, GLenum pname, const GLfloat *params);
GLAPI void APIENTRY stub_glMultiTexEnviEXT (GLenum texunit, GLenum target, GLenum pname, GLint param);
GLAPI void APIENTRY stub_glMultiTexEnvivEXT (GLenum texunit, GLenum target, GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glMultiTexGendEXT (GLenum texunit, GLenum coord, GLenum pname, GLdouble param);
GLAPI void APIENTRY stub_glMultiTexGendvEXT (GLenum texunit, GLenum coord, GLenum pname, const GLdouble *params);
GLAPI void APIENTRY stub_glMultiTexGenfEXT (GLenum texunit, GLenum coord, GLenum pname, GLfloat param);
GLAPI void APIENTRY stub_glMultiTexGenfvEXT (GLenum texunit, GLenum coord, GLenum pname, const GLfloat *params);
GLAPI void APIENTRY stub_glMultiTexGeniEXT (GLenum texunit, GLenum coord, GLenum pname, GLint param);
GLAPI void APIENTRY stub_glMultiTexGenivEXT (GLenum texunit, GLenum coord, GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glGetMultiTexEnvfvEXT (GLenum texunit, GLenum target, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetMultiTexEnvivEXT (GLenum texunit, GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetMultiTexGendvEXT (GLenum texunit, GLenum coord, GLenum pname, GLdouble *params);
GLAPI void APIENTRY stub_glGetMultiTexGenfvEXT (GLenum texunit, GLenum coord, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetMultiTexGenivEXT (GLenum texunit, GLenum coord, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glMultiTexParameteriEXT (GLenum texunit, GLenum target, GLenum pname, GLint param);
GLAPI void APIENTRY stub_glMultiTexParameterivEXT (GLenum texunit, GLenum target, GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glMultiTexParameterfEXT (GLenum texunit, GLenum target, GLenum pname, GLfloat param);
GLAPI void APIENTRY stub_glMultiTexParameterfvEXT (GLenum texunit, GLenum target, GLenum pname, const GLfloat *params);
GLAPI void APIENTRY stub_glMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels);
GLAPI void APIENTRY stub_glMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels);
GLAPI void APIENTRY stub_glMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels);
GLAPI void APIENTRY stub_glMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
GLAPI void APIENTRY stub_glCopyMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
GLAPI void APIENTRY stub_glCopyMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
GLAPI void APIENTRY stub_glCopyMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
GLAPI void APIENTRY stub_glCopyMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glGetMultiTexImageEXT (GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, void *pixels);
GLAPI void APIENTRY stub_glGetMultiTexParameterfvEXT (GLenum texunit, GLenum target, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetMultiTexParameterivEXT (GLenum texunit, GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetMultiTexLevelParameterfvEXT (GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetMultiTexLevelParameterivEXT (GLenum texunit, GLenum target, GLint level, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glMultiTexImage3DEXT (GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels);
GLAPI void APIENTRY stub_glMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);
GLAPI void APIENTRY stub_glCopyMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glEnableClientStateIndexedEXT (GLenum array, GLuint index);
GLAPI void APIENTRY stub_glDisableClientStateIndexedEXT (GLenum array, GLuint index);
GLAPI void APIENTRY stub_glGetFloatIndexedvEXT (GLenum target, GLuint index, GLfloat *data);
GLAPI void APIENTRY stub_glGetDoubleIndexedvEXT (GLenum target, GLuint index, GLdouble *data);
GLAPI void APIENTRY stub_glGetPointerIndexedvEXT (GLenum target, GLuint index, void **data);
GLAPI void APIENTRY stub_glEnableIndexedEXT (GLenum target, GLuint index);
GLAPI void APIENTRY stub_glDisableIndexedEXT (GLenum target, GLuint index);
GLAPI GLboolean APIENTRY stub_glIsEnabledIndexedEXT (GLenum target, GLuint index);
GLAPI void APIENTRY stub_glGetIntegerIndexedvEXT (GLenum target, GLuint index, GLint *data);
GLAPI void APIENTRY stub_glGetBooleanIndexedvEXT (GLenum target, GLuint index, GLboolean *data);
GLAPI void APIENTRY stub_glCompressedTextureImage3DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *bits);
GLAPI void APIENTRY stub_glCompressedTextureImage2DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *bits);
GLAPI void APIENTRY stub_glCompressedTextureImage1DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *bits);
GLAPI void APIENTRY stub_glCompressedTextureSubImage3DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *bits);
GLAPI void APIENTRY stub_glCompressedTextureSubImage2DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *bits);
GLAPI void APIENTRY stub_glCompressedTextureSubImage1DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *bits);
GLAPI void APIENTRY stub_glGetCompressedTextureImageEXT (GLuint texture, GLenum target, GLint lod, void *img);
GLAPI void APIENTRY stub_glCompressedMultiTexImage3DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *bits);
GLAPI void APIENTRY stub_glCompressedMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *bits);
GLAPI void APIENTRY stub_glCompressedMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *bits);
GLAPI void APIENTRY stub_glCompressedMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *bits);
GLAPI void APIENTRY stub_glCompressedMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *bits);
GLAPI void APIENTRY stub_glCompressedMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *bits);
GLAPI void APIENTRY stub_glGetCompressedMultiTexImageEXT (GLenum texunit, GLenum target, GLint lod, void *img);
GLAPI void APIENTRY stub_glMatrixLoadTransposefEXT (GLenum mode, const GLfloat *m);
GLAPI void APIENTRY stub_glMatrixLoadTransposedEXT (GLenum mode, const GLdouble *m);
GLAPI void APIENTRY stub_glMatrixMultTransposefEXT (GLenum mode, const GLfloat *m);
GLAPI void APIENTRY stub_glMatrixMultTransposedEXT (GLenum mode, const GLdouble *m);
GLAPI void APIENTRY stub_glNamedBufferDataEXT (GLuint buffer, GLsizeiptr size, const void *data, GLenum usage);
GLAPI void APIENTRY stub_glNamedBufferSubDataEXT (GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data);
GLAPI void *APIENTRY stub_glMapNamedBufferEXT (GLuint buffer, GLenum access);
GLAPI GLboolean APIENTRY stub_glUnmapNamedBufferEXT (GLuint buffer);
GLAPI void APIENTRY stub_glGetNamedBufferParameterivEXT (GLuint buffer, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetNamedBufferPointervEXT (GLuint buffer, GLenum pname, void **params);
GLAPI void APIENTRY stub_glGetNamedBufferSubDataEXT (GLuint buffer, GLintptr offset, GLsizeiptr size, void *data);
GLAPI void APIENTRY stub_glProgramUniform1fEXT (GLuint program, GLint location, GLfloat v0);
GLAPI void APIENTRY stub_glProgramUniform2fEXT (GLuint program, GLint location, GLfloat v0, GLfloat v1);
GLAPI void APIENTRY stub_glProgramUniform3fEXT (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
GLAPI void APIENTRY stub_glProgramUniform4fEXT (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
GLAPI void APIENTRY stub_glProgramUniform1iEXT (GLuint program, GLint location, GLint v0);
GLAPI void APIENTRY stub_glProgramUniform2iEXT (GLuint program, GLint location, GLint v0, GLint v1);
GLAPI void APIENTRY stub_glProgramUniform3iEXT (GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
GLAPI void APIENTRY stub_glProgramUniform4iEXT (GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
GLAPI void APIENTRY stub_glProgramUniform1fvEXT (GLuint program, GLint location, GLsizei count, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniform2fvEXT (GLuint program, GLint location, GLsizei count, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniform3fvEXT (GLuint program, GLint location, GLsizei count, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniform4fvEXT (GLuint program, GLint location, GLsizei count, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniform1ivEXT (GLuint program, GLint location, GLsizei count, const GLint *value);
GLAPI void APIENTRY stub_glProgramUniform2ivEXT (GLuint program, GLint location, GLsizei count, const GLint *value);
GLAPI void APIENTRY stub_glProgramUniform3ivEXT (GLuint program, GLint location, GLsizei count, const GLint *value);
GLAPI void APIENTRY stub_glProgramUniform4ivEXT (GLuint program, GLint location, GLsizei count, const GLint *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix2fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix3fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix4fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix2x3fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix3x2fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix2x4fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix4x2fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix3x4fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix4x3fvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
GLAPI void APIENTRY stub_glTextureBufferEXT (GLuint texture, GLenum target, GLenum internalformat, GLuint buffer);
GLAPI void APIENTRY stub_glMultiTexBufferEXT (GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer);
GLAPI void APIENTRY stub_glTextureParameterIivEXT (GLuint texture, GLenum target, GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glTextureParameterIuivEXT (GLuint texture, GLenum target, GLenum pname, const GLuint *params);
GLAPI void APIENTRY stub_glGetTextureParameterIivEXT (GLuint texture, GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetTextureParameterIuivEXT (GLuint texture, GLenum target, GLenum pname, GLuint *params);
GLAPI void APIENTRY stub_glMultiTexParameterIivEXT (GLenum texunit, GLenum target, GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glMultiTexParameterIuivEXT (GLenum texunit, GLenum target, GLenum pname, const GLuint *params);
GLAPI void APIENTRY stub_glGetMultiTexParameterIivEXT (GLenum texunit, GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetMultiTexParameterIuivEXT (GLenum texunit, GLenum target, GLenum pname, GLuint *params);
GLAPI void APIENTRY stub_glProgramUniform1uiEXT (GLuint program, GLint location, GLuint v0);
GLAPI void APIENTRY stub_glProgramUniform2uiEXT (GLuint program, GLint location, GLuint v0, GLuint v1);
GLAPI void APIENTRY stub_glProgramUniform3uiEXT (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
GLAPI void APIENTRY stub_glProgramUniform4uiEXT (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
GLAPI void APIENTRY stub_glProgramUniform1uivEXT (GLuint program, GLint location, GLsizei count, const GLuint *value);
GLAPI void APIENTRY stub_glProgramUniform2uivEXT (GLuint program, GLint location, GLsizei count, const GLuint *value);
GLAPI void APIENTRY stub_glProgramUniform3uivEXT (GLuint program, GLint location, GLsizei count, const GLuint *value);
GLAPI void APIENTRY stub_glProgramUniform4uivEXT (GLuint program, GLint location, GLsizei count, const GLuint *value);
GLAPI void APIENTRY stub_glNamedProgramLocalParameters4fvEXT (GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat *params);
GLAPI void APIENTRY stub_glNamedProgramLocalParameterI4iEXT (GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w);
GLAPI void APIENTRY stub_glNamedProgramLocalParameterI4ivEXT (GLuint program, GLenum target, GLuint index, const GLint *params);
GLAPI void APIENTRY stub_glNamedProgramLocalParametersI4ivEXT (GLuint program, GLenum target, GLuint index, GLsizei count, const GLint *params);
GLAPI void APIENTRY stub_glNamedProgramLocalParameterI4uiEXT (GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
GLAPI void APIENTRY stub_glNamedProgramLocalParameterI4uivEXT (GLuint program, GLenum target, GLuint index, const GLuint *params);
GLAPI void APIENTRY stub_glNamedProgramLocalParametersI4uivEXT (GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint *params);
GLAPI void APIENTRY stub_glGetNamedProgramLocalParameterIivEXT (GLuint program, GLenum target, GLuint index, GLint *params);
GLAPI void APIENTRY stub_glGetNamedProgramLocalParameterIuivEXT (GLuint program, GLenum target, GLuint index, GLuint *params);
GLAPI void APIENTRY stub_glEnableClientStateiEXT (GLenum array, GLuint index);
GLAPI void APIENTRY stub_glDisableClientStateiEXT (GLenum array, GLuint index);
GLAPI void APIENTRY stub_glGetFloati_vEXT (GLenum pname, GLuint index, GLfloat *params);
GLAPI void APIENTRY stub_glGetDoublei_vEXT (GLenum pname, GLuint index, GLdouble *params);
GLAPI void APIENTRY stub_glGetPointeri_vEXT (GLenum pname, GLuint index, void **params);
GLAPI void APIENTRY stub_glNamedProgramStringEXT (GLuint program, GLenum target, GLenum format, GLsizei len, const void *string);
GLAPI void APIENTRY stub_glNamedProgramLocalParameter4dEXT (GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
GLAPI void APIENTRY stub_glNamedProgramLocalParameter4dvEXT (GLuint program, GLenum target, GLuint index, const GLdouble *params);
GLAPI void APIENTRY stub_glNamedProgramLocalParameter4fEXT (GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
GLAPI void APIENTRY stub_glNamedProgramLocalParameter4fvEXT (GLuint program, GLenum target, GLuint index, const GLfloat *params);
GLAPI void APIENTRY stub_glGetNamedProgramLocalParameterdvEXT (GLuint program, GLenum target, GLuint index, GLdouble *params);
GLAPI void APIENTRY stub_glGetNamedProgramLocalParameterfvEXT (GLuint program, GLenum target, GLuint index, GLfloat *params);
GLAPI void APIENTRY stub_glGetNamedProgramivEXT (GLuint program, GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetNamedProgramStringEXT (GLuint program, GLenum target, GLenum pname, void *string);
GLAPI void APIENTRY stub_glNamedRenderbufferStorageEXT (GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glGetNamedRenderbufferParameterivEXT (GLuint renderbuffer, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glNamedRenderbufferStorageMultisampleEXT (GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glNamedRenderbufferStorageMultisampleCoverageEXT (GLuint renderbuffer, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height);
GLAPI GLenum APIENTRY stub_glCheckNamedFramebufferStatusEXT (GLuint framebuffer, GLenum target);
GLAPI void APIENTRY stub_glNamedFramebufferTexture1DEXT (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
GLAPI void APIENTRY stub_glNamedFramebufferTexture2DEXT (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
GLAPI void APIENTRY stub_glNamedFramebufferTexture3DEXT (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
GLAPI void APIENTRY stub_glNamedFramebufferRenderbufferEXT (GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
GLAPI void APIENTRY stub_glGetNamedFramebufferAttachmentParameterivEXT (GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGenerateTextureMipmapEXT (GLuint texture, GLenum target);
GLAPI void APIENTRY stub_glGenerateMultiTexMipmapEXT (GLenum texunit, GLenum target);
GLAPI void APIENTRY stub_glFramebufferDrawBufferEXT (GLuint framebuffer, GLenum mode);
GLAPI void APIENTRY stub_glFramebufferDrawBuffersEXT (GLuint framebuffer, GLsizei n, const GLenum *bufs);
GLAPI void APIENTRY stub_glFramebufferReadBufferEXT (GLuint framebuffer, GLenum mode);
GLAPI void APIENTRY stub_glGetFramebufferParameterivEXT (GLuint framebuffer, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glNamedCopyBufferSubDataEXT (GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
GLAPI void APIENTRY stub_glNamedFramebufferTextureEXT (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level);
GLAPI void APIENTRY stub_glNamedFramebufferTextureLayerEXT (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer);
GLAPI void APIENTRY stub_glNamedFramebufferTextureFaceEXT (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLenum face);
GLAPI void APIENTRY stub_glTextureRenderbufferEXT (GLuint texture, GLenum target, GLuint renderbuffer);
GLAPI void APIENTRY stub_glMultiTexRenderbufferEXT (GLenum texunit, GLenum target, GLuint renderbuffer);
GLAPI void APIENTRY stub_glVertexArrayVertexOffsetEXT (GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset);
GLAPI void APIENTRY stub_glVertexArrayColorOffsetEXT (GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset);
GLAPI void APIENTRY stub_glVertexArrayEdgeFlagOffsetEXT (GLuint vaobj, GLuint buffer, GLsizei stride, GLintptr offset);
GLAPI void APIENTRY stub_glVertexArrayIndexOffsetEXT (GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset);
GLAPI void APIENTRY stub_glVertexArrayNormalOffsetEXT (GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset);
GLAPI void APIENTRY stub_glVertexArrayTexCoordOffsetEXT (GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset);
GLAPI void APIENTRY stub_glVertexArrayMultiTexCoordOffsetEXT (GLuint vaobj, GLuint buffer, GLenum texunit, GLint size, GLenum type, GLsizei stride, GLintptr offset);
GLAPI void APIENTRY stub_glVertexArrayFogCoordOffsetEXT (GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset);
GLAPI void APIENTRY stub_glVertexArraySecondaryColorOffsetEXT (GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset);
GLAPI void APIENTRY stub_glVertexArrayVertexAttribOffsetEXT (GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLintptr offset);
GLAPI void APIENTRY stub_glVertexArrayVertexAttribIOffsetEXT (GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset);
GLAPI void APIENTRY stub_glEnableVertexArrayEXT (GLuint vaobj, GLenum array);
GLAPI void APIENTRY stub_glDisableVertexArrayEXT (GLuint vaobj, GLenum array);
GLAPI void APIENTRY stub_glEnableVertexArrayAttribEXT (GLuint vaobj, GLuint index);
GLAPI void APIENTRY stub_glDisableVertexArrayAttribEXT (GLuint vaobj, GLuint index);
GLAPI void APIENTRY stub_glGetVertexArrayIntegervEXT (GLuint vaobj, GLenum pname, GLint *param);
GLAPI void APIENTRY stub_glGetVertexArrayPointervEXT (GLuint vaobj, GLenum pname, void **param);
GLAPI void APIENTRY stub_glGetVertexArrayIntegeri_vEXT (GLuint vaobj, GLuint index, GLenum pname, GLint *param);
GLAPI void APIENTRY stub_glGetVertexArrayPointeri_vEXT (GLuint vaobj, GLuint index, GLenum pname, void **param);
GLAPI void *APIENTRY stub_glMapNamedBufferRangeEXT (GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access);
GLAPI void APIENTRY stub_glFlushMappedNamedBufferRangeEXT (GLuint buffer, GLintptr offset, GLsizeiptr length);
GLAPI void APIENTRY stub_glNamedBufferStorageEXT (GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags);
GLAPI void APIENTRY stub_glClearNamedBufferDataEXT (GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data);
GLAPI void APIENTRY stub_glClearNamedBufferSubDataEXT (GLuint buffer, GLenum internalformat, GLsizeiptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data);
GLAPI void APIENTRY stub_glNamedFramebufferParameteriEXT (GLuint framebuffer, GLenum pname, GLint param);
GLAPI void APIENTRY stub_glGetNamedFramebufferParameterivEXT (GLuint framebuffer, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glProgramUniform1dEXT (GLuint program, GLint location, GLdouble x);
GLAPI void APIENTRY stub_glProgramUniform2dEXT (GLuint program, GLint location, GLdouble x, GLdouble y);
GLAPI void APIENTRY stub_glProgramUniform3dEXT (GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z);
GLAPI void APIENTRY stub_glProgramUniform4dEXT (GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
GLAPI void APIENTRY stub_glProgramUniform1dvEXT (GLuint program, GLint location, GLsizei count, const GLdouble *value);
GLAPI void APIENTRY stub_glProgramUniform2dvEXT (GLuint program, GLint location, GLsizei count, const GLdouble *value);
GLAPI void APIENTRY stub_glProgramUniform3dvEXT (GLuint program, GLint location, GLsizei count, const GLdouble *value);
GLAPI void APIENTRY stub_glProgramUniform4dvEXT (GLuint program, GLint location, GLsizei count, const GLdouble *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix2dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix3dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix4dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix2x3dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix2x4dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix3x2dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix3x4dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix4x2dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glProgramUniformMatrix4x3dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
GLAPI void APIENTRY stub_glTextureBufferRangeEXT (GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size);
GLAPI void APIENTRY stub_glTextureStorage1DEXT (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
GLAPI void APIENTRY stub_glTextureStorage2DEXT (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glTextureStorage3DEXT (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
GLAPI void APIENTRY stub_glTextureStorage2DMultisampleEXT (GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
GLAPI void APIENTRY stub_glTextureStorage3DMultisampleEXT (GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
GLAPI void APIENTRY stub_glVertexArrayBindVertexBufferEXT (GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
GLAPI void APIENTRY stub_glVertexArrayVertexAttribFormatEXT (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
GLAPI void APIENTRY stub_glVertexArrayVertexAttribIFormatEXT (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
GLAPI void APIENTRY stub_glVertexArrayVertexAttribLFormatEXT (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
GLAPI void APIENTRY stub_glVertexArrayVertexAttribBindingEXT (GLuint vaobj, GLuint attribindex, GLuint bindingindex);
GLAPI void APIENTRY stub_glVertexArrayVertexBindingDivisorEXT (GLuint vaobj, GLuint bindingindex, GLuint divisor);
GLAPI void APIENTRY stub_glVertexArrayVertexAttribLOffsetEXT (GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset);
GLAPI void APIENTRY stub_glTexturePageCommitmentEXT (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit);
GLAPI void APIENTRY stub_glVertexArrayVertexAttribDivisorEXT (GLuint vaobj, GLuint index, GLuint divisor);
GLAPI void APIENTRY stub_glColorMaskIndexedEXT (GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
GLAPI void APIENTRY stub_glDrawArraysInstancedEXT (GLenum mode, GLint start, GLsizei count, GLsizei primcount);
GLAPI void APIENTRY stub_glDrawElementsInstancedEXT (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount);
GLAPI void APIENTRY stub_glDrawRangeElementsEXT (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices);
GLAPI void APIENTRY stub_glFogCoordfEXT (GLfloat coord);
GLAPI void APIENTRY stub_glFogCoordfvEXT (const GLfloat *coord);
GLAPI void APIENTRY stub_glFogCoorddEXT (GLdouble coord);
GLAPI void APIENTRY stub_glFogCoorddvEXT (const GLdouble *coord);
GLAPI void APIENTRY stub_glFogCoordPointerEXT (GLenum type, GLsizei stride, const void *pointer);
GLAPI void APIENTRY stub_glBlitFramebufferEXT (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
GLAPI void APIENTRY stub_glRenderbufferStorageMultisampleEXT (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
GLAPI GLboolean APIENTRY stub_glIsRenderbufferEXT (GLuint renderbuffer);
GLAPI void APIENTRY stub_glBindRenderbufferEXT (GLenum target, GLuint renderbuffer);
GLAPI void APIENTRY stub_glDeleteRenderbuffersEXT (GLsizei n, const GLuint *renderbuffers);
GLAPI void APIENTRY stub_glGenRenderbuffersEXT (GLsizei n, GLuint *renderbuffers);
GLAPI void APIENTRY stub_glRenderbufferStorageEXT (GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glGetRenderbufferParameterivEXT (GLenum target, GLenum pname, GLint *params);
GLAPI GLboolean APIENTRY stub_glIsFramebufferEXT (GLuint framebuffer);
GLAPI void APIENTRY stub_glBindFramebufferEXT (GLenum target, GLuint framebuffer);
GLAPI void APIENTRY stub_glDeleteFramebuffersEXT (GLsizei n, const GLuint *framebuffers);
GLAPI void APIENTRY stub_glGenFramebuffersEXT (GLsizei n, GLuint *framebuffers);
GLAPI GLenum APIENTRY stub_glCheckFramebufferStatusEXT (GLenum target);
GLAPI void APIENTRY stub_glFramebufferTexture1DEXT (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
GLAPI void APIENTRY stub_glFramebufferTexture2DEXT (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
GLAPI void APIENTRY stub_glFramebufferTexture3DEXT (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
GLAPI void APIENTRY stub_glFramebufferRenderbufferEXT (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
GLAPI void APIENTRY stub_glGetFramebufferAttachmentParameterivEXT (GLenum target, GLenum attachment, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGenerateMipmapEXT (GLenum target);
GLAPI void APIENTRY stub_glProgramParameteriEXT (GLuint program, GLenum pname, GLint value);
GLAPI void APIENTRY stub_glProgramEnvParameters4fvEXT (GLenum target, GLuint index, GLsizei count, const GLfloat *params);
GLAPI void APIENTRY stub_glProgramLocalParameters4fvEXT (GLenum target, GLuint index, GLsizei count, const GLfloat *params);
GLAPI void APIENTRY stub_glGetUniformuivEXT (GLuint program, GLint location, GLuint *params);
GLAPI void APIENTRY stub_glBindFragDataLocationEXT (GLuint program, GLuint color, const GLchar *name);
GLAPI GLint APIENTRY stub_glGetFragDataLocationEXT (GLuint program, const GLchar *name);
GLAPI void APIENTRY stub_glUniform1uiEXT (GLint location, GLuint v0);
GLAPI void APIENTRY stub_glUniform2uiEXT (GLint location, GLuint v0, GLuint v1);
GLAPI void APIENTRY stub_glUniform3uiEXT (GLint location, GLuint v0, GLuint v1, GLuint v2);
GLAPI void APIENTRY stub_glUniform4uiEXT (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
GLAPI void APIENTRY stub_glUniform1uivEXT (GLint location, GLsizei count, const GLuint *value);
GLAPI void APIENTRY stub_glUniform2uivEXT (GLint location, GLsizei count, const GLuint *value);
GLAPI void APIENTRY stub_glUniform3uivEXT (GLint location, GLsizei count, const GLuint *value);
GLAPI void APIENTRY stub_glUniform4uivEXT (GLint location, GLsizei count, const GLuint *value);
GLAPI void APIENTRY stub_glGetHistogramEXT (GLenum target, GLboolean reset, GLenum format, GLenum type, void *values);
GLAPI void APIENTRY stub_glGetHistogramParameterfvEXT (GLenum target, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetHistogramParameterivEXT (GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetMinmaxEXT (GLenum target, GLboolean reset, GLenum format, GLenum type, void *values);
GLAPI void APIENTRY stub_glGetMinmaxParameterfvEXT (GLenum target, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetMinmaxParameterivEXT (GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glHistogramEXT (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
GLAPI void APIENTRY stub_glMinmaxEXT (GLenum target, GLenum internalformat, GLboolean sink);
GLAPI void APIENTRY stub_glResetHistogramEXT (GLenum target);
GLAPI void APIENTRY stub_glResetMinmaxEXT (GLenum target);
GLAPI void APIENTRY stub_glIndexFuncEXT (GLenum func, GLclampf ref);
GLAPI void APIENTRY stub_glIndexMaterialEXT (GLenum face, GLenum mode);
GLAPI void APIENTRY stub_glApplyTextureEXT (GLenum mode);
GLAPI void APIENTRY stub_glTextureLightEXT (GLenum pname);
GLAPI void APIENTRY stub_glTextureMaterialEXT (GLenum face, GLenum mode);
GLAPI void APIENTRY stub_glMultiDrawArraysEXT (GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount);
GLAPI void APIENTRY stub_glMultiDrawElementsEXT (GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei primcount);
GLAPI void APIENTRY stub_glSampleMaskEXT (GLclampf value, GLboolean invert);
GLAPI void APIENTRY stub_glSamplePatternEXT (GLenum pattern);
GLAPI void APIENTRY stub_glColorTableEXT (GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const void *table);
GLAPI void APIENTRY stub_glGetColorTableEXT (GLenum target, GLenum format, GLenum type, void *data);
GLAPI void APIENTRY stub_glGetColorTableParameterivEXT (GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetColorTableParameterfvEXT (GLenum target, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glPixelTransformParameteriEXT (GLenum target, GLenum pname, GLint param);
GLAPI void APIENTRY stub_glPixelTransformParameterfEXT (GLenum target, GLenum pname, GLfloat param);
GLAPI void APIENTRY stub_glPixelTransformParameterivEXT (GLenum target, GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glPixelTransformParameterfvEXT (GLenum target, GLenum pname, const GLfloat *params);
GLAPI void APIENTRY stub_glGetPixelTransformParameterivEXT (GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetPixelTransformParameterfvEXT (GLenum target, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glPointParameterfEXT (GLenum pname, GLfloat param);
GLAPI void APIENTRY stub_glPointParameterfvEXT (GLenum pname, const GLfloat *params);
GLAPI void APIENTRY stub_glPolygonOffsetEXT (GLfloat factor, GLfloat bias);
GLAPI void APIENTRY stub_glPolygonOffsetClampEXT (GLfloat factor, GLfloat units, GLfloat clamp);
GLAPI void APIENTRY stub_glProvokingVertexEXT (GLenum mode);
GLAPI void APIENTRY stub_glRasterSamplesEXT (GLuint samples, GLboolean fixedsamplelocations);
GLAPI void APIENTRY stub_glSecondaryColor3bEXT (GLbyte red, GLbyte green, GLbyte blue);
GLAPI void APIENTRY stub_glSecondaryColor3bvEXT (const GLbyte *v);
GLAPI void APIENTRY stub_glSecondaryColor3dEXT (GLdouble red, GLdouble green, GLdouble blue);
GLAPI void APIENTRY stub_glSecondaryColor3dvEXT (const GLdouble *v);
GLAPI void APIENTRY stub_glSecondaryColor3fEXT (GLfloat red, GLfloat green, GLfloat blue);
GLAPI void APIENTRY stub_glSecondaryColor3fvEXT (const GLfloat *v);
GLAPI void APIENTRY stub_glSecondaryColor3iEXT (GLint red, GLint green, GLint blue);
GLAPI void APIENTRY stub_glSecondaryColor3ivEXT (const GLint *v);
GLAPI void APIENTRY stub_glSecondaryColor3sEXT (GLshort red, GLshort green, GLshort blue);
GLAPI void APIENTRY stub_glSecondaryColor3svEXT (const GLshort *v);
GLAPI void APIENTRY stub_glSecondaryColor3ubEXT (GLubyte red, GLubyte green, GLubyte blue);
GLAPI void APIENTRY stub_glSecondaryColor3ubvEXT (const GLubyte *v);
GLAPI void APIENTRY stub_glSecondaryColor3uiEXT (GLuint red, GLuint green, GLuint blue);
GLAPI void APIENTRY stub_glSecondaryColor3uivEXT (const GLuint *v);
GLAPI void APIENTRY stub_glSecondaryColor3usEXT (GLushort red, GLushort green, GLushort blue);
GLAPI void APIENTRY stub_glSecondaryColor3usvEXT (const GLushort *v);
GLAPI void APIENTRY stub_glSecondaryColorPointerEXT (GLint size, GLenum type, GLsizei stride, const void *pointer);
GLAPI void APIENTRY stub_glUseShaderProgramEXT (GLenum type, GLuint program);
GLAPI void APIENTRY stub_glActiveProgramEXT (GLuint program);
GLAPI GLuint APIENTRY stub_glCreateShaderProgramEXT (GLenum type, const GLchar *string);
GLAPI void APIENTRY stub_glBindImageTextureEXT (GLuint index, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLint format);
GLAPI void APIENTRY stub_glMemoryBarrierEXT (GLbitfield barriers);
GLAPI void APIENTRY stub_glStencilClearTagEXT (GLsizei stencilTagBits, GLuint stencilClearTag);
GLAPI void APIENTRY stub_glActiveStencilFaceEXT (GLenum face);
GLAPI void APIENTRY stub_glTexSubImage1DEXT (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels);
GLAPI void APIENTRY stub_glTexSubImage2DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
GLAPI void APIENTRY stub_glTexImage3DEXT (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels);
GLAPI void APIENTRY stub_glTexSubImage3DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);
GLAPI void APIENTRY stub_glFramebufferTextureLayerEXT (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
GLAPI void APIENTRY stub_glTexBufferEXT (GLenum target, GLenum internalformat, GLuint buffer);
GLAPI void APIENTRY stub_glTexParameterIivEXT (GLenum target, GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glTexParameterIuivEXT (GLenum target, GLenum pname, const GLuint *params);
GLAPI void APIENTRY stub_glGetTexParameterIivEXT (GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetTexParameterIuivEXT (GLenum target, GLenum pname, GLuint *params);
GLAPI void APIENTRY stub_glClearColorIiEXT (GLint red, GLint green, GLint blue, GLint alpha);
GLAPI void APIENTRY stub_glClearColorIuiEXT (GLuint red, GLuint green, GLuint blue, GLuint alpha);
GLAPI GLboolean APIENTRY stub_glAreTexturesResidentEXT (GLsizei n, const GLuint *textures, GLboolean *residences);
GLAPI void APIENTRY stub_glBindTextureEXT (GLenum target, GLuint texture);
GLAPI void APIENTRY stub_glDeleteTexturesEXT (GLsizei n, const GLuint *textures);
GLAPI void APIENTRY stub_glGenTexturesEXT (GLsizei n, GLuint *textures);
GLAPI GLboolean APIENTRY stub_glIsTextureEXT (GLuint texture);
GLAPI void APIENTRY stub_glPrioritizeTexturesEXT (GLsizei n, const GLuint *textures, const GLclampf *priorities);
GLAPI void APIENTRY stub_glTextureNormalEXT (GLenum mode);
GLAPI void APIENTRY stub_glGetQueryObjecti64vEXT (GLuint id, GLenum pname, GLint64 *params);
GLAPI void APIENTRY stub_glGetQueryObjectui64vEXT (GLuint id, GLenum pname, GLuint64 *params);
GLAPI void APIENTRY stub_glBeginTransformFeedbackEXT (GLenum primitiveMode);
GLAPI void APIENTRY stub_glEndTransformFeedbackEXT (void);
GLAPI void APIENTRY stub_glBindBufferRangeEXT (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
GLAPI void APIENTRY stub_glBindBufferOffsetEXT (GLenum target, GLuint index, GLuint buffer, GLintptr offset);
GLAPI void APIENTRY stub_glBindBufferBaseEXT (GLenum target, GLuint index, GLuint buffer);
GLAPI void APIENTRY stub_glTransformFeedbackVaryingsEXT (GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode);
GLAPI void APIENTRY stub_glGetTransformFeedbackVaryingEXT (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
GLAPI void APIENTRY stub_glArrayElementEXT (GLint i);
GLAPI void APIENTRY stub_glColorPointerEXT (GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer);
GLAPI void APIENTRY stub_glDrawArraysEXT (GLenum mode, GLint first, GLsizei count);
GLAPI void APIENTRY stub_glEdgeFlagPointerEXT (GLsizei stride, GLsizei count, const GLboolean *pointer);
GLAPI void APIENTRY stub_glGetPointervEXT (GLenum pname, void **params);
GLAPI void APIENTRY stub_glIndexPointerEXT (GLenum type, GLsizei stride, GLsizei count, const void *pointer);
GLAPI void APIENTRY stub_glNormalPointerEXT (GLenum type, GLsizei stride, GLsizei count, const void *pointer);
GLAPI void APIENTRY stub_glTexCoordPointerEXT (GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer);
GLAPI void APIENTRY stub_glVertexPointerEXT (GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer);
GLAPI void APIENTRY stub_glVertexAttribL1dEXT (GLuint index, GLdouble x);
GLAPI void APIENTRY stub_glVertexAttribL2dEXT (GLuint index, GLdouble x, GLdouble y);
GLAPI void APIENTRY stub_glVertexAttribL3dEXT (GLuint index, GLdouble x, GLdouble y, GLdouble z);
GLAPI void APIENTRY stub_glVertexAttribL4dEXT (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
GLAPI void APIENTRY stub_glVertexAttribL1dvEXT (GLuint index, const GLdouble *v);
GLAPI void APIENTRY stub_glVertexAttribL2dvEXT (GLuint index, const GLdouble *v);
GLAPI void APIENTRY stub_glVertexAttribL3dvEXT (GLuint index, const GLdouble *v);
GLAPI void APIENTRY stub_glVertexAttribL4dvEXT (GLuint index, const GLdouble *v);
GLAPI void APIENTRY stub_glVertexAttribLPointerEXT (GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer);
GLAPI void APIENTRY stub_glGetVertexAttribLdvEXT (GLuint index, GLenum pname, GLdouble *params);
GLAPI void APIENTRY stub_glBeginVertexShaderEXT (void);
GLAPI void APIENTRY stub_glEndVertexShaderEXT (void);
GLAPI void APIENTRY stub_glBindVertexShaderEXT (GLuint id);
GLAPI GLuint APIENTRY stub_glGenVertexShadersEXT (GLuint range);
GLAPI void APIENTRY stub_glDeleteVertexShaderEXT (GLuint id);
GLAPI void APIENTRY stub_glShaderOp1EXT (GLenum op, GLuint res, GLuint arg1);
GLAPI void APIENTRY stub_glShaderOp2EXT (GLenum op, GLuint res, GLuint arg1, GLuint arg2);
GLAPI void APIENTRY stub_glShaderOp3EXT (GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3);
GLAPI void APIENTRY stub_glSwizzleEXT (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW);
GLAPI void APIENTRY stub_glWriteMaskEXT (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW);
GLAPI void APIENTRY stub_glInsertComponentEXT (GLuint res, GLuint src, GLuint num);
GLAPI void APIENTRY stub_glExtractComponentEXT (GLuint res, GLuint src, GLuint num);
GLAPI GLuint APIENTRY stub_glGenSymbolsEXT (GLenum datatype, GLenum storagetype, GLenum range, GLuint components);
GLAPI void APIENTRY stub_glSetInvariantEXT (GLuint id, GLenum type, const void *addr);
GLAPI void APIENTRY stub_glSetLocalConstantEXT (GLuint id, GLenum type, const void *addr);
GLAPI void APIENTRY stub_glVariantbvEXT (GLuint id, const GLbyte *addr);
GLAPI void APIENTRY stub_glVariantsvEXT (GLuint id, const GLshort *addr);
GLAPI void APIENTRY stub_glVariantivEXT (GLuint id, const GLint *addr);
GLAPI void APIENTRY stub_glVariantfvEXT (GLuint id, const GLfloat *addr);
GLAPI void APIENTRY stub_glVariantdvEXT (GLuint id, const GLdouble *addr);
GLAPI void APIENTRY stub_glVariantubvEXT (GLuint id, const GLubyte *addr);
GLAPI void APIENTRY stub_glVariantusvEXT (GLuint id, const GLushort *addr);
GLAPI void APIENTRY stub_glVariantuivEXT (GLuint id, const GLuint *addr);
GLAPI void APIENTRY stub_glVariantPointerEXT (GLuint id, GLenum type, GLuint stride, const void *addr);
GLAPI void APIENTRY stub_glEnableVariantClientStateEXT (GLuint id);
GLAPI void APIENTRY stub_glDisableVariantClientStateEXT (GLuint id);
GLAPI GLuint APIENTRY stub_glBindLightParameterEXT (GLenum light, GLenum value);
GLAPI GLuint APIENTRY stub_glBindMaterialParameterEXT (GLenum face, GLenum value);
GLAPI GLuint APIENTRY stub_glBindTexGenParameterEXT (GLenum unit, GLenum coord, GLenum value);
GLAPI GLuint APIENTRY stub_glBindTextureUnitParameterEXT (GLenum unit, GLenum value);
GLAPI GLuint APIENTRY stub_glBindParameterEXT (GLenum value);
GLAPI GLboolean APIENTRY stub_glIsVariantEnabledEXT (GLuint id, GLenum cap);
GLAPI void APIENTRY stub_glGetVariantBooleanvEXT (GLuint id, GLenum value, GLboolean *data);
GLAPI void APIENTRY stub_glGetVariantIntegervEXT (GLuint id, GLenum value, GLint *data);
GLAPI void APIENTRY stub_glGetVariantFloatvEXT (GLuint id, GLenum value, GLfloat *data);
GLAPI void APIENTRY stub_glGetVariantPointervEXT (GLuint id, GLenum value, void **data);
GLAPI void APIENTRY stub_glGetInvariantBooleanvEXT (GLuint id, GLenum value, GLboolean *data);
GLAPI void APIENTRY stub_glGetInvariantIntegervEXT (GLuint id, GLenum value, GLint *data);
GLAPI void APIENTRY stub_glGetInvariantFloatvEXT (GLuint id, GLenum value, GLfloat *data);
GLAPI void APIENTRY stub_glGetLocalConstantBooleanvEXT (GLuint id, GLenum value, GLboolean *data);
GLAPI void APIENTRY stub_glGetLocalConstantIntegervEXT (GLuint id, GLenum value, GLint *data);
GLAPI void APIENTRY stub_glGetLocalConstantFloatvEXT (GLuint id, GLenum value, GLfloat *data);
GLAPI void APIENTRY stub_glVertexWeightfEXT (GLfloat weight);
GLAPI void APIENTRY stub_glVertexWeightfvEXT (const GLfloat *weight);
GLAPI void APIENTRY stub_glVertexWeightPointerEXT (GLint size, GLenum type, GLsizei stride, const void *pointer);
GLAPI void APIENTRY stub_glWindowRectanglesEXT (GLenum mode, GLsizei count, const GLint *box);
GLAPI GLsync APIENTRY stub_glImportSyncEXT (GLenum external_sync_type, GLintptr external_sync, GLbitfield flags);
GLAPI void APIENTRY stub_glFrameTerminatorGREMEDY (void);
GLAPI void APIENTRY stub_glStringMarkerGREMEDY (GLsizei len, const void *string);
GLAPI void APIENTRY stub_glImageTransformParameteriHP (GLenum target, GLenum pname, GLint param);
GLAPI void APIENTRY stub_glImageTransformParameterfHP (GLenum target, GLenum pname, GLfloat param);
GLAPI void APIENTRY stub_glImageTransformParameterivHP (GLenum target, GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glImageTransformParameterfvHP (GLenum target, GLenum pname, const GLfloat *params);
GLAPI void APIENTRY stub_glGetImageTransformParameterivHP (GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetImageTransformParameterfvHP (GLenum target, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glMultiModeDrawArraysIBM (const GLenum *mode, const GLint *first, const GLsizei *count, GLsizei primcount, GLint modestride);
GLAPI void APIENTRY stub_glMultiModeDrawElementsIBM (const GLenum *mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei primcount, GLint modestride);
GLAPI void APIENTRY stub_glFlushStaticDataIBM (GLenum target);
GLAPI void APIENTRY stub_glColorPointerListIBM (GLint size, GLenum type, GLint stride, const void **pointer, GLint ptrstride);
GLAPI void APIENTRY stub_glSecondaryColorPointerListIBM (GLint size, GLenum type, GLint stride, const void **pointer, GLint ptrstride);
GLAPI void APIENTRY stub_glEdgeFlagPointerListIBM (GLint stride, const GLboolean **pointer, GLint ptrstride);
GLAPI void APIENTRY stub_glFogCoordPointerListIBM (GLenum type, GLint stride, const void **pointer, GLint ptrstride);
GLAPI void APIENTRY stub_glIndexPointerListIBM (GLenum type, GLint stride, const void **pointer, GLint ptrstride);
GLAPI void APIENTRY stub_glNormalPointerListIBM (GLenum type, GLint stride, const void **pointer, GLint ptrstride);
GLAPI void APIENTRY stub_glTexCoordPointerListIBM (GLint size, GLenum type, GLint stride, const void **pointer, GLint ptrstride);
GLAPI void APIENTRY stub_glVertexPointerListIBM (GLint size, GLenum type, GLint stride, const void **pointer, GLint ptrstride);
GLAPI void APIENTRY stub_glBlendFuncSeparateINGR (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
GLAPI void APIENTRY stub_glApplyFramebufferAttachmentCMAAINTEL (void);
GLAPI void APIENTRY stub_glSyncTextureINTEL (GLuint texture);
GLAPI void APIENTRY stub_glUnmapTexture2DINTEL (GLuint texture, GLint level);
GLAPI void *APIENTRY stub_glMapTexture2DINTEL (GLuint texture, GLint level, GLbitfield access, GLint *stride, GLenum *layout);
GLAPI void APIENTRY stub_glVertexPointervINTEL (GLint size, GLenum type, const void **pointer);
GLAPI void APIENTRY stub_glNormalPointervINTEL (GLenum type, const void **pointer);
GLAPI void APIENTRY stub_glColorPointervINTEL (GLint size, GLenum type, const void **pointer);
GLAPI void APIENTRY stub_glTexCoordPointervINTEL (GLint size, GLenum type, const void **pointer);
GLAPI void APIENTRY stub_glBeginPerfQueryINTEL (GLuint queryHandle);
GLAPI void APIENTRY stub_glCreatePerfQueryINTEL (GLuint queryId, GLuint *queryHandle);
GLAPI void APIENTRY stub_glDeletePerfQueryINTEL (GLuint queryHandle);
GLAPI void APIENTRY stub_glEndPerfQueryINTEL (GLuint queryHandle);
GLAPI void APIENTRY stub_glGetFirstPerfQueryIdINTEL (GLuint *queryId);
GLAPI void APIENTRY stub_glGetNextPerfQueryIdINTEL (GLuint queryId, GLuint *nextQueryId);
GLAPI void APIENTRY stub_glGetPerfCounterInfoINTEL (GLuint queryId, GLuint counterId, GLuint counterNameLength, GLchar *counterName, GLuint counterDescLength, GLchar *counterDesc, GLuint *counterOffset, GLuint *counterDataSize, GLuint *counterTypeEnum, GLuint *counterDataTypeEnum, GLuint64 *rawCounterMaxValue);
GLAPI void APIENTRY stub_glGetPerfQueryDataINTEL (GLuint queryHandle, GLuint flags, GLsizei dataSize, GLvoid *data, GLuint *bytesWritten);
GLAPI void APIENTRY stub_glGetPerfQueryIdByNameINTEL (GLchar *queryName, GLuint *queryId);
GLAPI void APIENTRY stub_glGetPerfQueryInfoINTEL (GLuint queryId, GLuint queryNameLength, GLchar *queryName, GLuint *dataSize, GLuint *noCounters, GLuint *noInstances, GLuint *capsMask);
GLAPI void APIENTRY stub_glResizeBuffersMESA (void);
GLAPI void APIENTRY stub_glWindowPos2dMESA (GLdouble x, GLdouble y);
GLAPI void APIENTRY stub_glWindowPos2dvMESA (const GLdouble *v);
GLAPI void APIENTRY stub_glWindowPos2fMESA (GLfloat x, GLfloat y);
GLAPI void APIENTRY stub_glWindowPos2fvMESA (const GLfloat *v);
GLAPI void APIENTRY stub_glWindowPos2iMESA (GLint x, GLint y);
GLAPI void APIENTRY stub_glWindowPos2ivMESA (const GLint *v);
GLAPI void APIENTRY stub_glWindowPos2sMESA (GLshort x, GLshort y);
GLAPI void APIENTRY stub_glWindowPos2svMESA (const GLshort *v);
GLAPI void APIENTRY stub_glWindowPos3dMESA (GLdouble x, GLdouble y, GLdouble z);
GLAPI void APIENTRY stub_glWindowPos3dvMESA (const GLdouble *v);
GLAPI void APIENTRY stub_glWindowPos3fMESA (GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glWindowPos3fvMESA (const GLfloat *v);
GLAPI void APIENTRY stub_glWindowPos3iMESA (GLint x, GLint y, GLint z);
GLAPI void APIENTRY stub_glWindowPos3ivMESA (const GLint *v);
GLAPI void APIENTRY stub_glWindowPos3sMESA (GLshort x, GLshort y, GLshort z);
GLAPI void APIENTRY stub_glWindowPos3svMESA (const GLshort *v);
GLAPI void APIENTRY stub_glWindowPos4dMESA (GLdouble x, GLdouble y, GLdouble z, GLdouble w);
GLAPI void APIENTRY stub_glWindowPos4dvMESA (const GLdouble *v);
GLAPI void APIENTRY stub_glWindowPos4fMESA (GLfloat x, GLfloat y, GLfloat z, GLfloat w);
GLAPI void APIENTRY stub_glWindowPos4fvMESA (const GLfloat *v);
GLAPI void APIENTRY stub_glWindowPos4iMESA (GLint x, GLint y, GLint z, GLint w);
GLAPI void APIENTRY stub_glWindowPos4ivMESA (const GLint *v);
GLAPI void APIENTRY stub_glWindowPos4sMESA (GLshort x, GLshort y, GLshort z, GLshort w);
GLAPI void APIENTRY stub_glWindowPos4svMESA (const GLshort *v);
GLAPI void APIENTRY stub_glBeginConditionalRenderNVX (GLuint id);
GLAPI void APIENTRY stub_glEndConditionalRenderNVX (void);
GLAPI void APIENTRY stub_glMultiDrawArraysIndirectBindlessNV (GLenum mode, const void *indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount);
GLAPI void APIENTRY stub_glMultiDrawElementsIndirectBindlessNV (GLenum mode, GLenum type, const void *indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount);
GLAPI void APIENTRY stub_glMultiDrawArraysIndirectBindlessCountNV (GLenum mode, const void *indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount);
GLAPI void APIENTRY stub_glMultiDrawElementsIndirectBindlessCountNV (GLenum mode, GLenum type, const void *indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount);
GLAPI GLuint64 APIENTRY stub_glGetTextureHandleNV (GLuint texture);
GLAPI GLuint64 APIENTRY stub_glGetTextureSamplerHandleNV (GLuint texture, GLuint sampler);
GLAPI void APIENTRY stub_glMakeTextureHandleResidentNV (GLuint64 handle);
GLAPI void APIENTRY stub_glMakeTextureHandleNonResidentNV (GLuint64 handle);
GLAPI GLuint64 APIENTRY stub_glGetImageHandleNV (GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format);
GLAPI void APIENTRY stub_glMakeImageHandleResidentNV (GLuint64 handle, GLenum access);
GLAPI void APIENTRY stub_glMakeImageHandleNonResidentNV (GLuint64 handle);
GLAPI void APIENTRY stub_glUniformHandleui64NV (GLint location, GLuint64 value);
GLAPI void APIENTRY stub_glUniformHandleui64vNV (GLint location, GLsizei count, const GLuint64 *value);
GLAPI void APIENTRY stub_glProgramUniformHandleui64NV (GLuint program, GLint location, GLuint64 value);
GLAPI void APIENTRY stub_glProgramUniformHandleui64vNV (GLuint program, GLint location, GLsizei count, const GLuint64 *values);
GLAPI GLboolean APIENTRY stub_glIsTextureHandleResidentNV (GLuint64 handle);
GLAPI GLboolean APIENTRY stub_glIsImageHandleResidentNV (GLuint64 handle);
GLAPI void APIENTRY stub_glBlendParameteriNV (GLenum pname, GLint value);
GLAPI void APIENTRY stub_glBlendBarrierNV (void);
GLAPI void APIENTRY stub_glViewportPositionWScaleNV (GLuint index, GLfloat xcoeff, GLfloat ycoeff);
GLAPI void APIENTRY stub_glCreateStatesNV (GLsizei n, GLuint *states);
GLAPI void APIENTRY stub_glDeleteStatesNV (GLsizei n, const GLuint *states);
GLAPI GLboolean APIENTRY stub_glIsStateNV (GLuint state);
GLAPI void APIENTRY stub_glStateCaptureNV (GLuint state, GLenum mode);
GLAPI GLuint APIENTRY stub_glGetCommandHeaderNV (GLenum tokenID, GLuint size);
GLAPI GLushort APIENTRY stub_glGetStageIndexNV (GLenum shadertype);
GLAPI void APIENTRY stub_glDrawCommandsNV (GLenum primitiveMode, GLuint buffer, const GLintptr *indirects, const GLsizei *sizes, GLuint count);
GLAPI void APIENTRY stub_glDrawCommandsAddressNV (GLenum primitiveMode, const GLuint64 *indirects, const GLsizei *sizes, GLuint count);
GLAPI void APIENTRY stub_glDrawCommandsStatesNV (GLuint buffer, const GLintptr *indirects, const GLsizei *sizes, const GLuint *states, const GLuint *fbos, GLuint count);
GLAPI void APIENTRY stub_glDrawCommandsStatesAddressNV (const GLuint64 *indirects, const GLsizei *sizes, const GLuint *states, const GLuint *fbos, GLuint count);
GLAPI void APIENTRY stub_glCreateCommandListsNV (GLsizei n, GLuint *lists);
GLAPI void APIENTRY stub_glDeleteCommandListsNV (GLsizei n, const GLuint *lists);
GLAPI GLboolean APIENTRY stub_glIsCommandListNV (GLuint list);
GLAPI void APIENTRY stub_glListDrawCommandsStatesClientNV (GLuint list, GLuint segment, const void **indirects, const GLsizei *sizes, const GLuint *states, const GLuint *fbos, GLuint count);
GLAPI void APIENTRY stub_glCommandListSegmentsNV (GLuint list, GLuint segments);
GLAPI void APIENTRY stub_glCompileCommandListNV (GLuint list);
GLAPI void APIENTRY stub_glCallCommandListNV (GLuint list);
GLAPI void APIENTRY stub_glBeginConditionalRenderNV (GLuint id, GLenum mode);
GLAPI void APIENTRY stub_glEndConditionalRenderNV (void);
GLAPI void APIENTRY stub_glSubpixelPrecisionBiasNV (GLuint xbits, GLuint ybits);
GLAPI void APIENTRY stub_glConservativeRasterParameterfNV (GLenum pname, GLfloat value);
GLAPI void APIENTRY stub_glConservativeRasterParameteriNV (GLenum pname, GLint param);
GLAPI void APIENTRY stub_glCopyImageSubDataNV (GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth);
GLAPI void APIENTRY stub_glDepthRangedNV (GLdouble zNear, GLdouble zFar);
GLAPI void APIENTRY stub_glClearDepthdNV (GLdouble depth);
GLAPI void APIENTRY stub_glDepthBoundsdNV (GLdouble zmin, GLdouble zmax);
GLAPI void APIENTRY stub_glDrawTextureNV (GLuint texture, GLuint sampler, GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1, GLfloat z, GLfloat s0, GLfloat t0, GLfloat s1, GLfloat t1);
GLAPI void APIENTRY stub_glMapControlPointsNV (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const void *points);
GLAPI void APIENTRY stub_glMapParameterivNV (GLenum target, GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glMapParameterfvNV (GLenum target, GLenum pname, const GLfloat *params);
GLAPI void APIENTRY stub_glGetMapControlPointsNV (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, void *points);
GLAPI void APIENTRY stub_glGetMapParameterivNV (GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetMapParameterfvNV (GLenum target, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetMapAttribParameterivNV (GLenum target, GLuint index, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetMapAttribParameterfvNV (GLenum target, GLuint index, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glEvalMapsNV (GLenum target, GLenum mode);
GLAPI void APIENTRY stub_glGetMultisamplefvNV (GLenum pname, GLuint index, GLfloat *val);
GLAPI void APIENTRY stub_glSampleMaskIndexedNV (GLuint index, GLbitfield mask);
GLAPI void APIENTRY stub_glTexRenderbufferNV (GLenum target, GLuint renderbuffer);
GLAPI void APIENTRY stub_glDeleteFencesNV (GLsizei n, const GLuint *fences);
GLAPI void APIENTRY stub_glGenFencesNV (GLsizei n, GLuint *fences);
GLAPI GLboolean APIENTRY stub_glIsFenceNV (GLuint fence);
GLAPI GLboolean APIENTRY stub_glTestFenceNV (GLuint fence);
GLAPI void APIENTRY stub_glGetFenceivNV (GLuint fence, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glFinishFenceNV (GLuint fence);
GLAPI void APIENTRY stub_glSetFenceNV (GLuint fence, GLenum condition);
GLAPI void APIENTRY stub_glFragmentCoverageColorNV (GLuint color);
GLAPI void APIENTRY stub_glProgramNamedParameter4fNV (GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
GLAPI void APIENTRY stub_glProgramNamedParameter4fvNV (GLuint id, GLsizei len, const GLubyte *name, const GLfloat *v);
GLAPI void APIENTRY stub_glProgramNamedParameter4dNV (GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
GLAPI void APIENTRY stub_glProgramNamedParameter4dvNV (GLuint id, GLsizei len, const GLubyte *name, const GLdouble *v);
GLAPI void APIENTRY stub_glGetProgramNamedParameterfvNV (GLuint id, GLsizei len, const GLubyte *name, GLfloat *params);
GLAPI void APIENTRY stub_glGetProgramNamedParameterdvNV (GLuint id, GLsizei len, const GLubyte *name, GLdouble *params);
GLAPI void APIENTRY stub_glCoverageModulationTableNV (GLsizei n, const GLfloat *v);
GLAPI void APIENTRY stub_glGetCoverageModulationTableNV (GLsizei bufsize, GLfloat *v);
GLAPI void APIENTRY stub_glCoverageModulationNV (GLenum components);
GLAPI void APIENTRY stub_glRenderbufferStorageMultisampleCoverageNV (GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height);
GLAPI void APIENTRY stub_glProgramVertexLimitNV (GLenum target, GLint limit);
GLAPI void APIENTRY stub_glFramebufferTextureEXT (GLenum target, GLenum attachment, GLuint texture, GLint level);
GLAPI void APIENTRY stub_glFramebufferTextureFaceEXT (GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face);
GLAPI void APIENTRY stub_glProgramLocalParameterI4iNV (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w);
GLAPI void APIENTRY stub_glProgramLocalParameterI4ivNV (GLenum target, GLuint index, const GLint *params);
GLAPI void APIENTRY stub_glProgramLocalParametersI4ivNV (GLenum target, GLuint index, GLsizei count, const GLint *params);
GLAPI void APIENTRY stub_glProgramLocalParameterI4uiNV (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
GLAPI void APIENTRY stub_glProgramLocalParameterI4uivNV (GLenum target, GLuint index, const GLuint *params);
GLAPI void APIENTRY stub_glProgramLocalParametersI4uivNV (GLenum target, GLuint index, GLsizei count, const GLuint *params);
GLAPI void APIENTRY stub_glProgramEnvParameterI4iNV (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w);
GLAPI void APIENTRY stub_glProgramEnvParameterI4ivNV (GLenum target, GLuint index, const GLint *params);
GLAPI void APIENTRY stub_glProgramEnvParametersI4ivNV (GLenum target, GLuint index, GLsizei count, const GLint *params);
GLAPI void APIENTRY stub_glProgramEnvParameterI4uiNV (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
GLAPI void APIENTRY stub_glProgramEnvParameterI4uivNV (GLenum target, GLuint index, const GLuint *params);
GLAPI void APIENTRY stub_glProgramEnvParametersI4uivNV (GLenum target, GLuint index, GLsizei count, const GLuint *params);
GLAPI void APIENTRY stub_glGetProgramLocalParameterIivNV (GLenum target, GLuint index, GLint *params);
GLAPI void APIENTRY stub_glGetProgramLocalParameterIuivNV (GLenum target, GLuint index, GLuint *params);
GLAPI void APIENTRY stub_glGetProgramEnvParameterIivNV (GLenum target, GLuint index, GLint *params);
GLAPI void APIENTRY stub_glGetProgramEnvParameterIuivNV (GLenum target, GLuint index, GLuint *params);
GLAPI void APIENTRY stub_glProgramSubroutineParametersuivNV (GLenum target, GLsizei count, const GLuint *params);
GLAPI void APIENTRY stub_glGetProgramSubroutineParameteruivNV (GLenum target, GLuint index, GLuint *param);
GLAPI void APIENTRY stub_glVertex2hNV (GLhalfNV x, GLhalfNV y);
GLAPI void APIENTRY stub_glVertex2hvNV (const GLhalfNV *v);
GLAPI void APIENTRY stub_glVertex3hNV (GLhalfNV x, GLhalfNV y, GLhalfNV z);
GLAPI void APIENTRY stub_glVertex3hvNV (const GLhalfNV *v);
GLAPI void APIENTRY stub_glVertex4hNV (GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w);
GLAPI void APIENTRY stub_glVertex4hvNV (const GLhalfNV *v);
GLAPI void APIENTRY stub_glNormal3hNV (GLhalfNV nx, GLhalfNV ny, GLhalfNV nz);
GLAPI void APIENTRY stub_glNormal3hvNV (const GLhalfNV *v);
GLAPI void APIENTRY stub_glColor3hNV (GLhalfNV red, GLhalfNV green, GLhalfNV blue);
GLAPI void APIENTRY stub_glColor3hvNV (const GLhalfNV *v);
GLAPI void APIENTRY stub_glColor4hNV (GLhalfNV red, GLhalfNV green, GLhalfNV blue, GLhalfNV alpha);
GLAPI void APIENTRY stub_glColor4hvNV (const GLhalfNV *v);
GLAPI void APIENTRY stub_glTexCoord1hNV (GLhalfNV s);
GLAPI void APIENTRY stub_glTexCoord1hvNV (const GLhalfNV *v);
GLAPI void APIENTRY stub_glTexCoord2hNV (GLhalfNV s, GLhalfNV t);
GLAPI void APIENTRY stub_glTexCoord2hvNV (const GLhalfNV *v);
GLAPI void APIENTRY stub_glTexCoord3hNV (GLhalfNV s, GLhalfNV t, GLhalfNV r);
GLAPI void APIENTRY stub_glTexCoord3hvNV (const GLhalfNV *v);
GLAPI void APIENTRY stub_glTexCoord4hNV (GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q);
GLAPI void APIENTRY stub_glTexCoord4hvNV (const GLhalfNV *v);
GLAPI void APIENTRY stub_glMultiTexCoord1hNV (GLenum target, GLhalfNV s);
GLAPI void APIENTRY stub_glMultiTexCoord1hvNV (GLenum target, const GLhalfNV *v);
GLAPI void APIENTRY stub_glMultiTexCoord2hNV (GLenum target, GLhalfNV s, GLhalfNV t);
GLAPI void APIENTRY stub_glMultiTexCoord2hvNV (GLenum target, const GLhalfNV *v);
GLAPI void APIENTRY stub_glMultiTexCoord3hNV (GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r);
GLAPI void APIENTRY stub_glMultiTexCoord3hvNV (GLenum target, const GLhalfNV *v);
GLAPI void APIENTRY stub_glMultiTexCoord4hNV (GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q);
GLAPI void APIENTRY stub_glMultiTexCoord4hvNV (GLenum target, const GLhalfNV *v);
GLAPI void APIENTRY stub_glFogCoordhNV (GLhalfNV fog);
GLAPI void APIENTRY stub_glFogCoordhvNV (const GLhalfNV *fog);
GLAPI void APIENTRY stub_glSecondaryColor3hNV (GLhalfNV red, GLhalfNV green, GLhalfNV blue);
GLAPI void APIENTRY stub_glSecondaryColor3hvNV (const GLhalfNV *v);
GLAPI void APIENTRY stub_glVertexWeighthNV (GLhalfNV weight);
GLAPI void APIENTRY stub_glVertexWeighthvNV (const GLhalfNV *weight);
GLAPI void APIENTRY stub_glVertexAttrib1hNV (GLuint index, GLhalfNV x);
GLAPI void APIENTRY stub_glVertexAttrib1hvNV (GLuint index, const GLhalfNV *v);
GLAPI void APIENTRY stub_glVertexAttrib2hNV (GLuint index, GLhalfNV x, GLhalfNV y);
GLAPI void APIENTRY stub_glVertexAttrib2hvNV (GLuint index, const GLhalfNV *v);
GLAPI void APIENTRY stub_glVertexAttrib3hNV (GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z);
GLAPI void APIENTRY stub_glVertexAttrib3hvNV (GLuint index, const GLhalfNV *v);
GLAPI void APIENTRY stub_glVertexAttrib4hNV (GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w);
GLAPI void APIENTRY stub_glVertexAttrib4hvNV (GLuint index, const GLhalfNV *v);
GLAPI void APIENTRY stub_glVertexAttribs1hvNV (GLuint index, GLsizei n, const GLhalfNV *v);
GLAPI void APIENTRY stub_glVertexAttribs2hvNV (GLuint index, GLsizei n, const GLhalfNV *v);
GLAPI void APIENTRY stub_glVertexAttribs3hvNV (GLuint index, GLsizei n, const GLhalfNV *v);
GLAPI void APIENTRY stub_glVertexAttribs4hvNV (GLuint index, GLsizei n, const GLhalfNV *v);
GLAPI void APIENTRY stub_glGetInternalformatSampleivNV (GLenum target, GLenum internalformat, GLsizei samples, GLenum pname, GLsizei bufSize, GLint *params);
GLAPI void APIENTRY stub_glGenOcclusionQueriesNV (GLsizei n, GLuint *ids);
GLAPI void APIENTRY stub_glDeleteOcclusionQueriesNV (GLsizei n, const GLuint *ids);
GLAPI GLboolean APIENTRY stub_glIsOcclusionQueryNV (GLuint id);
GLAPI void APIENTRY stub_glBeginOcclusionQueryNV (GLuint id);
GLAPI void APIENTRY stub_glEndOcclusionQueryNV (void);
GLAPI void APIENTRY stub_glGetOcclusionQueryivNV (GLuint id, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetOcclusionQueryuivNV (GLuint id, GLenum pname, GLuint *params);
GLAPI void APIENTRY stub_glProgramBufferParametersfvNV (GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLfloat *params);
GLAPI void APIENTRY stub_glProgramBufferParametersIivNV (GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLint *params);
GLAPI void APIENTRY stub_glProgramBufferParametersIuivNV (GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLuint *params);
GLAPI GLuint APIENTRY stub_glGenPathsNV (GLsizei range);
GLAPI void APIENTRY stub_glDeletePathsNV (GLuint path, GLsizei range);
GLAPI GLboolean APIENTRY stub_glIsPathNV (GLuint path);
GLAPI void APIENTRY stub_glPathCommandsNV (GLuint path, GLsizei numCommands, const GLubyte *commands, GLsizei numCoords, GLenum coordType, const void *coords);
GLAPI void APIENTRY stub_glPathCoordsNV (GLuint path, GLsizei numCoords, GLenum coordType, const void *coords);
GLAPI void APIENTRY stub_glPathSubCommandsNV (GLuint path, GLsizei commandStart, GLsizei commandsToDelete, GLsizei numCommands, const GLubyte *commands, GLsizei numCoords, GLenum coordType, const void *coords);
GLAPI void APIENTRY stub_glPathSubCoordsNV (GLuint path, GLsizei coordStart, GLsizei numCoords, GLenum coordType, const void *coords);
GLAPI void APIENTRY stub_glPathStringNV (GLuint path, GLenum format, GLsizei length, const void *pathString);
GLAPI void APIENTRY stub_glPathGlyphsNV (GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLsizei numGlyphs, GLenum type, const void *charcodes, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale);
GLAPI void APIENTRY stub_glPathGlyphRangeNV (GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint firstGlyph, GLsizei numGlyphs, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale);
GLAPI void APIENTRY stub_glWeightPathsNV (GLuint resultPath, GLsizei numPaths, const GLuint *paths, const GLfloat *weights);
GLAPI void APIENTRY stub_glCopyPathNV (GLuint resultPath, GLuint srcPath);
GLAPI void APIENTRY stub_glInterpolatePathsNV (GLuint resultPath, GLuint pathA, GLuint pathB, GLfloat weight);
GLAPI void APIENTRY stub_glTransformPathNV (GLuint resultPath, GLuint srcPath, GLenum transformType, const GLfloat *transformValues);
GLAPI void APIENTRY stub_glPathParameterivNV (GLuint path, GLenum pname, const GLint *value);
GLAPI void APIENTRY stub_glPathParameteriNV (GLuint path, GLenum pname, GLint value);
GLAPI void APIENTRY stub_glPathParameterfvNV (GLuint path, GLenum pname, const GLfloat *value);
GLAPI void APIENTRY stub_glPathParameterfNV (GLuint path, GLenum pname, GLfloat value);
GLAPI void APIENTRY stub_glPathDashArrayNV (GLuint path, GLsizei dashCount, const GLfloat *dashArray);
GLAPI void APIENTRY stub_glPathStencilFuncNV (GLenum func, GLint ref, GLuint mask);
GLAPI void APIENTRY stub_glPathStencilDepthOffsetNV (GLfloat factor, GLfloat units);
GLAPI void APIENTRY stub_glStencilFillPathNV (GLuint path, GLenum fillMode, GLuint mask);
GLAPI void APIENTRY stub_glStencilStrokePathNV (GLuint path, GLint reference, GLuint mask);
GLAPI void APIENTRY stub_glStencilFillPathInstancedNV (GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum transformType, const GLfloat *transformValues);
GLAPI void APIENTRY stub_glStencilStrokePathInstancedNV (GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLint reference, GLuint mask, GLenum transformType, const GLfloat *transformValues);
GLAPI void APIENTRY stub_glPathCoverDepthFuncNV (GLenum func);
GLAPI void APIENTRY stub_glCoverFillPathNV (GLuint path, GLenum coverMode);
GLAPI void APIENTRY stub_glCoverStrokePathNV (GLuint path, GLenum coverMode);
GLAPI void APIENTRY stub_glCoverFillPathInstancedNV (GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat *transformValues);
GLAPI void APIENTRY stub_glCoverStrokePathInstancedNV (GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat *transformValues);
GLAPI void APIENTRY stub_glGetPathParameterivNV (GLuint path, GLenum pname, GLint *value);
GLAPI void APIENTRY stub_glGetPathParameterfvNV (GLuint path, GLenum pname, GLfloat *value);
GLAPI void APIENTRY stub_glGetPathCommandsNV (GLuint path, GLubyte *commands);
GLAPI void APIENTRY stub_glGetPathCoordsNV (GLuint path, GLfloat *coords);
GLAPI void APIENTRY stub_glGetPathDashArrayNV (GLuint path, GLfloat *dashArray);
GLAPI void APIENTRY stub_glGetPathMetricsNV (GLbitfield metricQueryMask, GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLsizei stride, GLfloat *metrics);
GLAPI void APIENTRY stub_glGetPathMetricRangeNV (GLbitfield metricQueryMask, GLuint firstPathName, GLsizei numPaths, GLsizei stride, GLfloat *metrics);
GLAPI void APIENTRY stub_glGetPathSpacingNV (GLenum pathListMode, GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLfloat advanceScale, GLfloat kerningScale, GLenum transformType, GLfloat *returnedSpacing);
GLAPI GLboolean APIENTRY stub_glIsPointInFillPathNV (GLuint path, GLuint mask, GLfloat x, GLfloat y);
GLAPI GLboolean APIENTRY stub_glIsPointInStrokePathNV (GLuint path, GLfloat x, GLfloat y);
GLAPI GLfloat APIENTRY stub_glGetPathLengthNV (GLuint path, GLsizei startSegment, GLsizei numSegments);
GLAPI GLboolean APIENTRY stub_glPointAlongPathNV (GLuint path, GLsizei startSegment, GLsizei numSegments, GLfloat distance, GLfloat *x, GLfloat *y, GLfloat *tangentX, GLfloat *tangentY);
GLAPI void APIENTRY stub_glMatrixLoad3x2fNV (GLenum matrixMode, const GLfloat *m);
GLAPI void APIENTRY stub_glMatrixLoad3x3fNV (GLenum matrixMode, const GLfloat *m);
GLAPI void APIENTRY stub_glMatrixLoadTranspose3x3fNV (GLenum matrixMode, const GLfloat *m);
GLAPI void APIENTRY stub_glMatrixMult3x2fNV (GLenum matrixMode, const GLfloat *m);
GLAPI void APIENTRY stub_glMatrixMult3x3fNV (GLenum matrixMode, const GLfloat *m);
GLAPI void APIENTRY stub_glMatrixMultTranspose3x3fNV (GLenum matrixMode, const GLfloat *m);
GLAPI void APIENTRY stub_glStencilThenCoverFillPathNV (GLuint path, GLenum fillMode, GLuint mask, GLenum coverMode);
GLAPI void APIENTRY stub_glStencilThenCoverStrokePathNV (GLuint path, GLint reference, GLuint mask, GLenum coverMode);
GLAPI void APIENTRY stub_glStencilThenCoverFillPathInstancedNV (GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat *transformValues);
GLAPI void APIENTRY stub_glStencilThenCoverStrokePathInstancedNV (GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLint reference, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat *transformValues);
GLAPI GLenum APIENTRY stub_glPathGlyphIndexRangeNV (GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint pathParameterTemplate, GLfloat emScale, GLuint baseAndCount[2]);
GLAPI GLenum APIENTRY stub_glPathGlyphIndexArrayNV (GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale);
GLAPI GLenum APIENTRY stub_glPathMemoryGlyphIndexArrayNV (GLuint firstPathName, GLenum fontTarget, GLsizeiptr fontSize, const void *fontData, GLsizei faceIndex, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale);
GLAPI void APIENTRY stub_glProgramPathFragmentInputGenNV (GLuint program, GLint location, GLenum genMode, GLint components, const GLfloat *coeffs);
GLAPI void APIENTRY stub_glGetProgramResourcefvNV (GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLfloat *params);
GLAPI void APIENTRY stub_glPathColorGenNV (GLenum color, GLenum genMode, GLenum colorFormat, const GLfloat *coeffs);
GLAPI void APIENTRY stub_glPathTexGenNV (GLenum texCoordSet, GLenum genMode, GLint components, const GLfloat *coeffs);
GLAPI void APIENTRY stub_glPathFogGenNV (GLenum genMode);
GLAPI void APIENTRY stub_glGetPathColorGenivNV (GLenum color, GLenum pname, GLint *value);
GLAPI void APIENTRY stub_glGetPathColorGenfvNV (GLenum color, GLenum pname, GLfloat *value);
GLAPI void APIENTRY stub_glGetPathTexGenivNV (GLenum texCoordSet, GLenum pname, GLint *value);
GLAPI void APIENTRY stub_glGetPathTexGenfvNV (GLenum texCoordSet, GLenum pname, GLfloat *value);
GLAPI void APIENTRY stub_glPixelDataRangeNV (GLenum target, GLsizei length, const void *pointer);
GLAPI void APIENTRY stub_glFlushPixelDataRangeNV (GLenum target);
GLAPI void APIENTRY stub_glPointParameteriNV (GLenum pname, GLint param);
GLAPI void APIENTRY stub_glPointParameterivNV (GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glPresentFrameKeyedNV (GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLuint key0, GLenum target1, GLuint fill1, GLuint key1);
GLAPI void APIENTRY stub_glPresentFrameDualFillNV (GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLenum target1, GLuint fill1, GLenum target2, GLuint fill2, GLenum target3, GLuint fill3);
GLAPI void APIENTRY stub_glGetVideoivNV (GLuint video_slot, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetVideouivNV (GLuint video_slot, GLenum pname, GLuint *params);
GLAPI void APIENTRY stub_glGetVideoi64vNV (GLuint video_slot, GLenum pname, GLint64EXT *params);
GLAPI void APIENTRY stub_glGetVideoui64vNV (GLuint video_slot, GLenum pname, GLuint64EXT *params);
GLAPI void APIENTRY stub_glPrimitiveRestartNV (void);
GLAPI void APIENTRY stub_glPrimitiveRestartIndexNV (GLuint index);
GLAPI void APIENTRY stub_glCombinerParameterfvNV (GLenum pname, const GLfloat *params);
GLAPI void APIENTRY stub_glCombinerParameterfNV (GLenum pname, GLfloat param);
GLAPI void APIENTRY stub_glCombinerParameterivNV (GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glCombinerParameteriNV (GLenum pname, GLint param);
GLAPI void APIENTRY stub_glCombinerInputNV (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
GLAPI void APIENTRY stub_glCombinerOutputNV (GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum);
GLAPI void APIENTRY stub_glFinalCombinerInputNV (GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
GLAPI void APIENTRY stub_glGetCombinerInputParameterfvNV (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetCombinerInputParameterivNV (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetCombinerOutputParameterfvNV (GLenum stage, GLenum portion, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetCombinerOutputParameterivNV (GLenum stage, GLenum portion, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetFinalCombinerInputParameterfvNV (GLenum variable, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetFinalCombinerInputParameterivNV (GLenum variable, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glCombinerStageParameterfvNV (GLenum stage, GLenum pname, const GLfloat *params);
GLAPI void APIENTRY stub_glGetCombinerStageParameterfvNV (GLenum stage, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glFramebufferSampleLocationsfvNV (GLenum target, GLuint start, GLsizei count, const GLfloat *v);
GLAPI void APIENTRY stub_glNamedFramebufferSampleLocationsfvNV (GLuint framebuffer, GLuint start, GLsizei count, const GLfloat *v);
GLAPI void APIENTRY stub_glResolveDepthValuesNV (void);
GLAPI void APIENTRY stub_glMakeBufferResidentNV (GLenum target, GLenum access);
GLAPI void APIENTRY stub_glMakeBufferNonResidentNV (GLenum target);
GLAPI GLboolean APIENTRY stub_glIsBufferResidentNV (GLenum target);
GLAPI void APIENTRY stub_glMakeNamedBufferResidentNV (GLuint buffer, GLenum access);
GLAPI void APIENTRY stub_glMakeNamedBufferNonResidentNV (GLuint buffer);
GLAPI GLboolean APIENTRY stub_glIsNamedBufferResidentNV (GLuint buffer);
GLAPI void APIENTRY stub_glGetBufferParameterui64vNV (GLenum target, GLenum pname, GLuint64EXT *params);
GLAPI void APIENTRY stub_glGetNamedBufferParameterui64vNV (GLuint buffer, GLenum pname, GLuint64EXT *params);
GLAPI void APIENTRY stub_glGetIntegerui64vNV (GLenum value, GLuint64EXT *result);
GLAPI void APIENTRY stub_glUniformui64NV (GLint location, GLuint64EXT value);
GLAPI void APIENTRY stub_glUniformui64vNV (GLint location, GLsizei count, const GLuint64EXT *value);
GLAPI void APIENTRY stub_glProgramUniformui64NV (GLuint program, GLint location, GLuint64EXT value);
GLAPI void APIENTRY stub_glProgramUniformui64vNV (GLuint program, GLint location, GLsizei count, const GLuint64EXT *value);
GLAPI void APIENTRY stub_glTextureBarrierNV (void);
GLAPI void APIENTRY stub_glTexImage2DMultisampleCoverageNV (GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations);
GLAPI void APIENTRY stub_glTexImage3DMultisampleCoverageNV (GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations);
GLAPI void APIENTRY stub_glTextureImage2DMultisampleNV (GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations);
GLAPI void APIENTRY stub_glTextureImage3DMultisampleNV (GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations);
GLAPI void APIENTRY stub_glTextureImage2DMultisampleCoverageNV (GLuint texture, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations);
GLAPI void APIENTRY stub_glTextureImage3DMultisampleCoverageNV (GLuint texture, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations);
GLAPI void APIENTRY stub_glBeginTransformFeedbackNV (GLenum primitiveMode);
GLAPI void APIENTRY stub_glEndTransformFeedbackNV (void);
GLAPI void APIENTRY stub_glTransformFeedbackAttribsNV (GLsizei count, const GLint *attribs, GLenum bufferMode);
GLAPI void APIENTRY stub_glBindBufferRangeNV (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
GLAPI void APIENTRY stub_glBindBufferOffsetNV (GLenum target, GLuint index, GLuint buffer, GLintptr offset);
GLAPI void APIENTRY stub_glBindBufferBaseNV (GLenum target, GLuint index, GLuint buffer);
GLAPI void APIENTRY stub_glTransformFeedbackVaryingsNV (GLuint program, GLsizei count, const GLint *locations, GLenum bufferMode);
GLAPI void APIENTRY stub_glActiveVaryingNV (GLuint program, const GLchar *name);
GLAPI GLint APIENTRY stub_glGetVaryingLocationNV (GLuint program, const GLchar *name);
GLAPI void APIENTRY stub_glGetActiveVaryingNV (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
GLAPI void APIENTRY stub_glGetTransformFeedbackVaryingNV (GLuint program, GLuint index, GLint *location);
GLAPI void APIENTRY stub_glTransformFeedbackStreamAttribsNV (GLsizei count, const GLint *attribs, GLsizei nbuffers, const GLint *bufstreams, GLenum bufferMode);
GLAPI void APIENTRY stub_glBindTransformFeedbackNV (GLenum target, GLuint id);
GLAPI void APIENTRY stub_glDeleteTransformFeedbacksNV (GLsizei n, const GLuint *ids);
GLAPI void APIENTRY stub_glGenTransformFeedbacksNV (GLsizei n, GLuint *ids);
GLAPI GLboolean APIENTRY stub_glIsTransformFeedbackNV (GLuint id);
GLAPI void APIENTRY stub_glPauseTransformFeedbackNV (void);
GLAPI void APIENTRY stub_glResumeTransformFeedbackNV (void);
GLAPI void APIENTRY stub_glDrawTransformFeedbackNV (GLenum mode, GLuint id);
GLAPI void APIENTRY stub_glVDPAUInitNV (const void *vdpDevice, const void *getProcAddress);
GLAPI void APIENTRY stub_glVDPAUFiniNV (void);
GLAPI GLvdpauSurfaceNV APIENTRY stub_glVDPAURegisterVideoSurfaceNV (const void *vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames);
GLAPI GLvdpauSurfaceNV APIENTRY stub_glVDPAURegisterOutputSurfaceNV (const void *vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames);
GLAPI GLboolean APIENTRY stub_glVDPAUIsSurfaceNV (GLvdpauSurfaceNV surface);
GLAPI void APIENTRY stub_glVDPAUUnregisterSurfaceNV (GLvdpauSurfaceNV surface);
GLAPI void APIENTRY stub_glVDPAUGetSurfaceivNV (GLvdpauSurfaceNV surface, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
GLAPI void APIENTRY stub_glVDPAUSurfaceAccessNV (GLvdpauSurfaceNV surface, GLenum access);
GLAPI void APIENTRY stub_glVDPAUMapSurfacesNV (GLsizei numSurfaces, const GLvdpauSurfaceNV *surfaces);
GLAPI void APIENTRY stub_glVDPAUUnmapSurfacesNV (GLsizei numSurface, const GLvdpauSurfaceNV *surfaces);
GLAPI void APIENTRY stub_glFlushVertexArrayRangeNV (void);
GLAPI void APIENTRY stub_glVertexArrayRangeNV (GLsizei length, const void *pointer);
GLAPI void APIENTRY stub_glVertexAttribL1i64NV (GLuint index, GLint64EXT x);
GLAPI void APIENTRY stub_glVertexAttribL2i64NV (GLuint index, GLint64EXT x, GLint64EXT y);
GLAPI void APIENTRY stub_glVertexAttribL3i64NV (GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z);
GLAPI void APIENTRY stub_glVertexAttribL4i64NV (GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w);
GLAPI void APIENTRY stub_glVertexAttribL1i64vNV (GLuint index, const GLint64EXT *v);
GLAPI void APIENTRY stub_glVertexAttribL2i64vNV (GLuint index, const GLint64EXT *v);
GLAPI void APIENTRY stub_glVertexAttribL3i64vNV (GLuint index, const GLint64EXT *v);
GLAPI void APIENTRY stub_glVertexAttribL4i64vNV (GLuint index, const GLint64EXT *v);
GLAPI void APIENTRY stub_glVertexAttribL1ui64NV (GLuint index, GLuint64EXT x);
GLAPI void APIENTRY stub_glVertexAttribL2ui64NV (GLuint index, GLuint64EXT x, GLuint64EXT y);
GLAPI void APIENTRY stub_glVertexAttribL3ui64NV (GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z);
GLAPI void APIENTRY stub_glVertexAttribL4ui64NV (GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w);
GLAPI void APIENTRY stub_glVertexAttribL1ui64vNV (GLuint index, const GLuint64EXT *v);
GLAPI void APIENTRY stub_glVertexAttribL2ui64vNV (GLuint index, const GLuint64EXT *v);
GLAPI void APIENTRY stub_glVertexAttribL3ui64vNV (GLuint index, const GLuint64EXT *v);
GLAPI void APIENTRY stub_glVertexAttribL4ui64vNV (GLuint index, const GLuint64EXT *v);
GLAPI void APIENTRY stub_glGetVertexAttribLi64vNV (GLuint index, GLenum pname, GLint64EXT *params);
GLAPI void APIENTRY stub_glGetVertexAttribLui64vNV (GLuint index, GLenum pname, GLuint64EXT *params);
GLAPI void APIENTRY stub_glVertexAttribLFormatNV (GLuint index, GLint size, GLenum type, GLsizei stride);
GLAPI void APIENTRY stub_glBufferAddressRangeNV (GLenum pname, GLuint index, GLuint64EXT address, GLsizeiptr length);
GLAPI void APIENTRY stub_glVertexFormatNV (GLint size, GLenum type, GLsizei stride);
GLAPI void APIENTRY stub_glNormalFormatNV (GLenum type, GLsizei stride);
GLAPI void APIENTRY stub_glColorFormatNV (GLint size, GLenum type, GLsizei stride);
GLAPI void APIENTRY stub_glIndexFormatNV (GLenum type, GLsizei stride);
GLAPI void APIENTRY stub_glTexCoordFormatNV (GLint size, GLenum type, GLsizei stride);
GLAPI void APIENTRY stub_glEdgeFlagFormatNV (GLsizei stride);
GLAPI void APIENTRY stub_glSecondaryColorFormatNV (GLint size, GLenum type, GLsizei stride);
GLAPI void APIENTRY stub_glFogCoordFormatNV (GLenum type, GLsizei stride);
GLAPI void APIENTRY stub_glVertexAttribFormatNV (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride);
GLAPI void APIENTRY stub_glVertexAttribIFormatNV (GLuint index, GLint size, GLenum type, GLsizei stride);
GLAPI void APIENTRY stub_glGetIntegerui64i_vNV (GLenum value, GLuint index, GLuint64EXT *result);
GLAPI GLboolean APIENTRY stub_glAreProgramsResidentNV (GLsizei n, const GLuint *programs, GLboolean *residences);
GLAPI void APIENTRY stub_glBindProgramNV (GLenum target, GLuint id);
GLAPI void APIENTRY stub_glDeleteProgramsNV (GLsizei n, const GLuint *programs);
GLAPI void APIENTRY stub_glExecuteProgramNV (GLenum target, GLuint id, const GLfloat *params);
GLAPI void APIENTRY stub_glGenProgramsNV (GLsizei n, GLuint *programs);
GLAPI void APIENTRY stub_glGetProgramParameterdvNV (GLenum target, GLuint index, GLenum pname, GLdouble *params);
GLAPI void APIENTRY stub_glGetProgramParameterfvNV (GLenum target, GLuint index, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetProgramivNV (GLuint id, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetProgramStringNV (GLuint id, GLenum pname, GLubyte *program);
GLAPI void APIENTRY stub_glGetTrackMatrixivNV (GLenum target, GLuint address, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetVertexAttribdvNV (GLuint index, GLenum pname, GLdouble *params);
GLAPI void APIENTRY stub_glGetVertexAttribfvNV (GLuint index, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetVertexAttribivNV (GLuint index, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetVertexAttribPointervNV (GLuint index, GLenum pname, void **pointer);
GLAPI GLboolean APIENTRY stub_glIsProgramNV (GLuint id);
GLAPI void APIENTRY stub_glLoadProgramNV (GLenum target, GLuint id, GLsizei len, const GLubyte *program);
GLAPI void APIENTRY stub_glProgramParameter4dNV (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
GLAPI void APIENTRY stub_glProgramParameter4dvNV (GLenum target, GLuint index, const GLdouble *v);
GLAPI void APIENTRY stub_glProgramParameter4fNV (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
GLAPI void APIENTRY stub_glProgramParameter4fvNV (GLenum target, GLuint index, const GLfloat *v);
GLAPI void APIENTRY stub_glProgramParameters4dvNV (GLenum target, GLuint index, GLsizei count, const GLdouble *v);
GLAPI void APIENTRY stub_glProgramParameters4fvNV (GLenum target, GLuint index, GLsizei count, const GLfloat *v);
GLAPI void APIENTRY stub_glRequestResidentProgramsNV (GLsizei n, const GLuint *programs);
GLAPI void APIENTRY stub_glTrackMatrixNV (GLenum target, GLuint address, GLenum matrix, GLenum transform);
GLAPI void APIENTRY stub_glVertexAttribPointerNV (GLuint index, GLint fsize, GLenum type, GLsizei stride, const void *pointer);
GLAPI void APIENTRY stub_glVertexAttrib1dNV (GLuint index, GLdouble x);
GLAPI void APIENTRY stub_glVertexAttrib1dvNV (GLuint index, const GLdouble *v);
GLAPI void APIENTRY stub_glVertexAttrib1fNV (GLuint index, GLfloat x);
GLAPI void APIENTRY stub_glVertexAttrib1fvNV (GLuint index, const GLfloat *v);
GLAPI void APIENTRY stub_glVertexAttrib1sNV (GLuint index, GLshort x);
GLAPI void APIENTRY stub_glVertexAttrib1svNV (GLuint index, const GLshort *v);
GLAPI void APIENTRY stub_glVertexAttrib2dNV (GLuint index, GLdouble x, GLdouble y);
GLAPI void APIENTRY stub_glVertexAttrib2dvNV (GLuint index, const GLdouble *v);
GLAPI void APIENTRY stub_glVertexAttrib2fNV (GLuint index, GLfloat x, GLfloat y);
GLAPI void APIENTRY stub_glVertexAttrib2fvNV (GLuint index, const GLfloat *v);
GLAPI void APIENTRY stub_glVertexAttrib2sNV (GLuint index, GLshort x, GLshort y);
GLAPI void APIENTRY stub_glVertexAttrib2svNV (GLuint index, const GLshort *v);
GLAPI void APIENTRY stub_glVertexAttrib3dNV (GLuint index, GLdouble x, GLdouble y, GLdouble z);
GLAPI void APIENTRY stub_glVertexAttrib3dvNV (GLuint index, const GLdouble *v);
GLAPI void APIENTRY stub_glVertexAttrib3fNV (GLuint index, GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glVertexAttrib3fvNV (GLuint index, const GLfloat *v);
GLAPI void APIENTRY stub_glVertexAttrib3sNV (GLuint index, GLshort x, GLshort y, GLshort z);
GLAPI void APIENTRY stub_glVertexAttrib3svNV (GLuint index, const GLshort *v);
GLAPI void APIENTRY stub_glVertexAttrib4dNV (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
GLAPI void APIENTRY stub_glVertexAttrib4dvNV (GLuint index, const GLdouble *v);
GLAPI void APIENTRY stub_glVertexAttrib4fNV (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
GLAPI void APIENTRY stub_glVertexAttrib4fvNV (GLuint index, const GLfloat *v);
GLAPI void APIENTRY stub_glVertexAttrib4sNV (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
GLAPI void APIENTRY stub_glVertexAttrib4svNV (GLuint index, const GLshort *v);
GLAPI void APIENTRY stub_glVertexAttrib4ubNV (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
GLAPI void APIENTRY stub_glVertexAttrib4ubvNV (GLuint index, const GLubyte *v);
GLAPI void APIENTRY stub_glVertexAttribs1dvNV (GLuint index, GLsizei count, const GLdouble *v);
GLAPI void APIENTRY stub_glVertexAttribs1fvNV (GLuint index, GLsizei count, const GLfloat *v);
GLAPI void APIENTRY stub_glVertexAttribs1svNV (GLuint index, GLsizei count, const GLshort *v);
GLAPI void APIENTRY stub_glVertexAttribs2dvNV (GLuint index, GLsizei count, const GLdouble *v);
GLAPI void APIENTRY stub_glVertexAttribs2fvNV (GLuint index, GLsizei count, const GLfloat *v);
GLAPI void APIENTRY stub_glVertexAttribs2svNV (GLuint index, GLsizei count, const GLshort *v);
GLAPI void APIENTRY stub_glVertexAttribs3dvNV (GLuint index, GLsizei count, const GLdouble *v);
GLAPI void APIENTRY stub_glVertexAttribs3fvNV (GLuint index, GLsizei count, const GLfloat *v);
GLAPI void APIENTRY stub_glVertexAttribs3svNV (GLuint index, GLsizei count, const GLshort *v);
GLAPI void APIENTRY stub_glVertexAttribs4dvNV (GLuint index, GLsizei count, const GLdouble *v);
GLAPI void APIENTRY stub_glVertexAttribs4fvNV (GLuint index, GLsizei count, const GLfloat *v);
GLAPI void APIENTRY stub_glVertexAttribs4svNV (GLuint index, GLsizei count, const GLshort *v);
GLAPI void APIENTRY stub_glVertexAttribs4ubvNV (GLuint index, GLsizei count, const GLubyte *v);
GLAPI void APIENTRY stub_glVertexAttribI1iEXT (GLuint index, GLint x);
GLAPI void APIENTRY stub_glVertexAttribI2iEXT (GLuint index, GLint x, GLint y);
GLAPI void APIENTRY stub_glVertexAttribI3iEXT (GLuint index, GLint x, GLint y, GLint z);
GLAPI void APIENTRY stub_glVertexAttribI4iEXT (GLuint index, GLint x, GLint y, GLint z, GLint w);
GLAPI void APIENTRY stub_glVertexAttribI1uiEXT (GLuint index, GLuint x);
GLAPI void APIENTRY stub_glVertexAttribI2uiEXT (GLuint index, GLuint x, GLuint y);
GLAPI void APIENTRY stub_glVertexAttribI3uiEXT (GLuint index, GLuint x, GLuint y, GLuint z);
GLAPI void APIENTRY stub_glVertexAttribI4uiEXT (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
GLAPI void APIENTRY stub_glVertexAttribI1ivEXT (GLuint index, const GLint *v);
GLAPI void APIENTRY stub_glVertexAttribI2ivEXT (GLuint index, const GLint *v);
GLAPI void APIENTRY stub_glVertexAttribI3ivEXT (GLuint index, const GLint *v);
GLAPI void APIENTRY stub_glVertexAttribI4ivEXT (GLuint index, const GLint *v);
GLAPI void APIENTRY stub_glVertexAttribI1uivEXT (GLuint index, const GLuint *v);
GLAPI void APIENTRY stub_glVertexAttribI2uivEXT (GLuint index, const GLuint *v);
GLAPI void APIENTRY stub_glVertexAttribI3uivEXT (GLuint index, const GLuint *v);
GLAPI void APIENTRY stub_glVertexAttribI4uivEXT (GLuint index, const GLuint *v);
GLAPI void APIENTRY stub_glVertexAttribI4bvEXT (GLuint index, const GLbyte *v);
GLAPI void APIENTRY stub_glVertexAttribI4svEXT (GLuint index, const GLshort *v);
GLAPI void APIENTRY stub_glVertexAttribI4ubvEXT (GLuint index, const GLubyte *v);
GLAPI void APIENTRY stub_glVertexAttribI4usvEXT (GLuint index, const GLushort *v);
GLAPI void APIENTRY stub_glVertexAttribIPointerEXT (GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer);
GLAPI void APIENTRY stub_glGetVertexAttribIivEXT (GLuint index, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetVertexAttribIuivEXT (GLuint index, GLenum pname, GLuint *params);
GLAPI void APIENTRY stub_glBeginVideoCaptureNV (GLuint video_capture_slot);
GLAPI void APIENTRY stub_glBindVideoCaptureStreamBufferNV (GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLintptrARB offset);
GLAPI void APIENTRY stub_glBindVideoCaptureStreamTextureNV (GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLenum target, GLuint texture);
GLAPI void APIENTRY stub_glEndVideoCaptureNV (GLuint video_capture_slot);
GLAPI void APIENTRY stub_glGetVideoCaptureivNV (GLuint video_capture_slot, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetVideoCaptureStreamivNV (GLuint video_capture_slot, GLuint stream, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetVideoCaptureStreamfvNV (GLuint video_capture_slot, GLuint stream, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetVideoCaptureStreamdvNV (GLuint video_capture_slot, GLuint stream, GLenum pname, GLdouble *params);
GLAPI GLenum APIENTRY stub_glVideoCaptureNV (GLuint video_capture_slot, GLuint *sequence_num, GLuint64EXT *capture_time);
GLAPI void APIENTRY stub_glVideoCaptureStreamParameterivNV (GLuint video_capture_slot, GLuint stream, GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glVideoCaptureStreamParameterfvNV (GLuint video_capture_slot, GLuint stream, GLenum pname, const GLfloat *params);
GLAPI void APIENTRY stub_glVideoCaptureStreamParameterdvNV (GLuint video_capture_slot, GLuint stream, GLenum pname, const GLdouble *params);
GLAPI void APIENTRY stub_glViewportSwizzleNV (GLuint index, GLenum swizzlex, GLenum swizzley, GLenum swizzlez, GLenum swizzlew);
GLAPI void APIENTRY stub_glFramebufferTextureMultiviewOVR (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint baseViewIndex, GLsizei numViews);
GLAPI void APIENTRY stub_glHintPGI (GLenum target, GLint mode);
GLAPI void APIENTRY stub_glDetailTexFuncSGIS (GLenum target, GLsizei n, const GLfloat *points);
GLAPI void APIENTRY stub_glGetDetailTexFuncSGIS (GLenum target, GLfloat *points);
GLAPI void APIENTRY stub_glFogFuncSGIS (GLsizei n, const GLfloat *points);
GLAPI void APIENTRY stub_glGetFogFuncSGIS (GLfloat *points);
GLAPI void APIENTRY stub_glSampleMaskSGIS (GLclampf value, GLboolean invert);
GLAPI void APIENTRY stub_glSamplePatternSGIS (GLenum pattern);
GLAPI void APIENTRY stub_glPixelTexGenParameteriSGIS (GLenum pname, GLint param);
GLAPI void APIENTRY stub_glPixelTexGenParameterivSGIS (GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glPixelTexGenParameterfSGIS (GLenum pname, GLfloat param);
GLAPI void APIENTRY stub_glPixelTexGenParameterfvSGIS (GLenum pname, const GLfloat *params);
GLAPI void APIENTRY stub_glGetPixelTexGenParameterivSGIS (GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetPixelTexGenParameterfvSGIS (GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glPointParameterfSGIS (GLenum pname, GLfloat param);
GLAPI void APIENTRY stub_glPointParameterfvSGIS (GLenum pname, const GLfloat *params);
GLAPI void APIENTRY stub_glSharpenTexFuncSGIS (GLenum target, GLsizei n, const GLfloat *points);
GLAPI void APIENTRY stub_glGetSharpenTexFuncSGIS (GLenum target, GLfloat *points);
GLAPI void APIENTRY stub_glTexImage4DSGIS (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const void *pixels);
GLAPI void APIENTRY stub_glTexSubImage4DSGIS (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const void *pixels);
GLAPI void APIENTRY stub_glTextureColorMaskSGIS (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
GLAPI void APIENTRY stub_glGetTexFilterFuncSGIS (GLenum target, GLenum filter, GLfloat *weights);
GLAPI void APIENTRY stub_glTexFilterFuncSGIS (GLenum target, GLenum filter, GLsizei n, const GLfloat *weights);
GLAPI void APIENTRY stub_glAsyncMarkerSGIX (GLuint marker);
GLAPI GLint APIENTRY stub_glFinishAsyncSGIX (GLuint *markerp);
GLAPI GLint APIENTRY stub_glPollAsyncSGIX (GLuint *markerp);
GLAPI GLuint APIENTRY stub_glGenAsyncMarkersSGIX (GLsizei range);
GLAPI void APIENTRY stub_glDeleteAsyncMarkersSGIX (GLuint marker, GLsizei range);
GLAPI GLboolean APIENTRY stub_glIsAsyncMarkerSGIX (GLuint marker);
GLAPI void APIENTRY stub_glFlushRasterSGIX (void);
GLAPI void APIENTRY stub_glFragmentColorMaterialSGIX (GLenum face, GLenum mode);
GLAPI void APIENTRY stub_glFragmentLightfSGIX (GLenum light, GLenum pname, GLfloat param);
GLAPI void APIENTRY stub_glFragmentLightfvSGIX (GLenum light, GLenum pname, const GLfloat *params);
GLAPI void APIENTRY stub_glFragmentLightiSGIX (GLenum light, GLenum pname, GLint param);
GLAPI void APIENTRY stub_glFragmentLightivSGIX (GLenum light, GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glFragmentLightModelfSGIX (GLenum pname, GLfloat param);
GLAPI void APIENTRY stub_glFragmentLightModelfvSGIX (GLenum pname, const GLfloat *params);
GLAPI void APIENTRY stub_glFragmentLightModeliSGIX (GLenum pname, GLint param);
GLAPI void APIENTRY stub_glFragmentLightModelivSGIX (GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glFragmentMaterialfSGIX (GLenum face, GLenum pname, GLfloat param);
GLAPI void APIENTRY stub_glFragmentMaterialfvSGIX (GLenum face, GLenum pname, const GLfloat *params);
GLAPI void APIENTRY stub_glFragmentMaterialiSGIX (GLenum face, GLenum pname, GLint param);
GLAPI void APIENTRY stub_glFragmentMaterialivSGIX (GLenum face, GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glGetFragmentLightfvSGIX (GLenum light, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetFragmentLightivSGIX (GLenum light, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glGetFragmentMaterialfvSGIX (GLenum face, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetFragmentMaterialivSGIX (GLenum face, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glLightEnviSGIX (GLenum pname, GLint param);
GLAPI void APIENTRY stub_glFrameZoomSGIX (GLint factor);
GLAPI void APIENTRY stub_glIglooInterfaceSGIX (GLenum pname, const void *params);
GLAPI GLint APIENTRY stub_glGetInstrumentsSGIX (void);
GLAPI void APIENTRY stub_glInstrumentsBufferSGIX (GLsizei size, GLint *buffer);
GLAPI GLint APIENTRY stub_glPollInstrumentsSGIX (GLint *marker_p);
GLAPI void APIENTRY stub_glReadInstrumentsSGIX (GLint marker);
GLAPI void APIENTRY stub_glStartInstrumentsSGIX (void);
GLAPI void APIENTRY stub_glStopInstrumentsSGIX (GLint marker);
GLAPI void APIENTRY stub_glGetListParameterfvSGIX (GLuint list, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetListParameterivSGIX (GLuint list, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glListParameterfSGIX (GLuint list, GLenum pname, GLfloat param);
GLAPI void APIENTRY stub_glListParameterfvSGIX (GLuint list, GLenum pname, const GLfloat *params);
GLAPI void APIENTRY stub_glListParameteriSGIX (GLuint list, GLenum pname, GLint param);
GLAPI void APIENTRY stub_glListParameterivSGIX (GLuint list, GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glPixelTexGenSGIX (GLenum mode);
GLAPI void APIENTRY stub_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);
GLAPI void APIENTRY stub_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);
GLAPI void APIENTRY stub_glDeformSGIX (GLbitfield mask);
GLAPI void APIENTRY stub_glLoadIdentityDeformationMapSGIX (GLbitfield mask);
GLAPI void APIENTRY stub_glReferencePlaneSGIX (const GLdouble *equation);
GLAPI void APIENTRY stub_glSpriteParameterfSGIX (GLenum pname, GLfloat param);
GLAPI void APIENTRY stub_glSpriteParameterfvSGIX (GLenum pname, const GLfloat *params);
GLAPI void APIENTRY stub_glSpriteParameteriSGIX (GLenum pname, GLint param);
GLAPI void APIENTRY stub_glSpriteParameterivSGIX (GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glTagSampleBufferSGIX (void);
GLAPI void APIENTRY stub_glColorTableSGI (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *table);
GLAPI void APIENTRY stub_glColorTableParameterfvSGI (GLenum target, GLenum pname, const GLfloat *params);
GLAPI void APIENTRY stub_glColorTableParameterivSGI (GLenum target, GLenum pname, const GLint *params);
GLAPI void APIENTRY stub_glCopyColorTableSGI (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
GLAPI void APIENTRY stub_glGetColorTableSGI (GLenum target, GLenum format, GLenum type, void *table);
GLAPI void APIENTRY stub_glGetColorTableParameterfvSGI (GLenum target, GLenum pname, GLfloat *params);
GLAPI void APIENTRY stub_glGetColorTableParameterivSGI (GLenum target, GLenum pname, GLint *params);
GLAPI void APIENTRY stub_glFinishTextureSUNX (void);
GLAPI void APIENTRY stub_glGlobalAlphaFactorbSUN (GLbyte factor);
GLAPI void APIENTRY stub_glGlobalAlphaFactorsSUN (GLshort factor);
GLAPI void APIENTRY stub_glGlobalAlphaFactoriSUN (GLint factor);
GLAPI void APIENTRY stub_glGlobalAlphaFactorfSUN (GLfloat factor);
GLAPI void APIENTRY stub_glGlobalAlphaFactordSUN (GLdouble factor);
GLAPI void APIENTRY stub_glGlobalAlphaFactorubSUN (GLubyte factor);
GLAPI void APIENTRY stub_glGlobalAlphaFactorusSUN (GLushort factor);
GLAPI void APIENTRY stub_glGlobalAlphaFactoruiSUN (GLuint factor);
GLAPI void APIENTRY stub_glDrawMeshArraysSUN (GLenum mode, GLint first, GLsizei count, GLsizei width);
GLAPI void APIENTRY stub_glReplacementCodeuiSUN (GLuint code);
GLAPI void APIENTRY stub_glReplacementCodeusSUN (GLushort code);
GLAPI void APIENTRY stub_glReplacementCodeubSUN (GLubyte code);
GLAPI void APIENTRY stub_glReplacementCodeuivSUN (const GLuint *code);
GLAPI void APIENTRY stub_glReplacementCodeusvSUN (const GLushort *code);
GLAPI void APIENTRY stub_glReplacementCodeubvSUN (const GLubyte *code);
GLAPI void APIENTRY stub_glReplacementCodePointerSUN (GLenum type, GLsizei stride, const void **pointer);
GLAPI void APIENTRY stub_glColor4ubVertex2fSUN (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y);
GLAPI void APIENTRY stub_glColor4ubVertex2fvSUN (const GLubyte *c, const GLfloat *v);
GLAPI void APIENTRY stub_glColor4ubVertex3fSUN (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glColor4ubVertex3fvSUN (const GLubyte *c, const GLfloat *v);
GLAPI void APIENTRY stub_glColor3fVertex3fSUN (GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glColor3fVertex3fvSUN (const GLfloat *c, const GLfloat *v);
GLAPI void APIENTRY stub_glNormal3fVertex3fSUN (GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glNormal3fVertex3fvSUN (const GLfloat *n, const GLfloat *v);
GLAPI void APIENTRY stub_glColor4fNormal3fVertex3fSUN (GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glColor4fNormal3fVertex3fvSUN (const GLfloat *c, const GLfloat *n, const GLfloat *v);
GLAPI void APIENTRY stub_glTexCoord2fVertex3fSUN (GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glTexCoord2fVertex3fvSUN (const GLfloat *tc, const GLfloat *v);
GLAPI void APIENTRY stub_glTexCoord4fVertex4fSUN (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
GLAPI void APIENTRY stub_glTexCoord4fVertex4fvSUN (const GLfloat *tc, const GLfloat *v);
GLAPI void APIENTRY stub_glTexCoord2fColor4ubVertex3fSUN (GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glTexCoord2fColor4ubVertex3fvSUN (const GLfloat *tc, const GLubyte *c, const GLfloat *v);
GLAPI void APIENTRY stub_glTexCoord2fColor3fVertex3fSUN (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glTexCoord2fColor3fVertex3fvSUN (const GLfloat *tc, const GLfloat *c, const GLfloat *v);
GLAPI void APIENTRY stub_glTexCoord2fNormal3fVertex3fSUN (GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glTexCoord2fNormal3fVertex3fvSUN (const GLfloat *tc, const GLfloat *n, const GLfloat *v);
GLAPI void APIENTRY stub_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);
GLAPI void APIENTRY stub_glTexCoord2fColor4fNormal3fVertex3fvSUN (const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
GLAPI void APIENTRY stub_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);
GLAPI void APIENTRY stub_glTexCoord4fColor4fNormal3fVertex4fvSUN (const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
GLAPI void APIENTRY stub_glReplacementCodeuiVertex3fSUN (GLuint rc, GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glReplacementCodeuiVertex3fvSUN (const GLuint *rc, const GLfloat *v);
GLAPI void APIENTRY stub_glReplacementCodeuiColor4ubVertex3fSUN (GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glReplacementCodeuiColor4ubVertex3fvSUN (const GLuint *rc, const GLubyte *c, const GLfloat *v);
GLAPI void APIENTRY stub_glReplacementCodeuiColor3fVertex3fSUN (GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glReplacementCodeuiColor3fVertex3fvSUN (const GLuint *rc, const GLfloat *c, const GLfloat *v);
GLAPI void APIENTRY stub_glReplacementCodeuiNormal3fVertex3fSUN (GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glReplacementCodeuiNormal3fVertex3fvSUN (const GLuint *rc, const GLfloat *n, const GLfloat *v);
GLAPI void APIENTRY stub_glReplacementCodeuiColor4fNormal3fVertex3fSUN (GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glReplacementCodeuiColor4fNormal3fVertex3fvSUN (const GLuint *rc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
GLAPI void APIENTRY stub_glReplacementCodeuiTexCoord2fVertex3fSUN (GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glReplacementCodeuiTexCoord2fVertex3fvSUN (const GLuint *rc, const GLfloat *tc, const GLfloat *v);
GLAPI void APIENTRY stub_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN (GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
GLAPI void APIENTRY stub_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN (const GLuint *rc, const GLfloat *tc, const GLfloat *n, const GLfloat *v);
GLAPI void APIENTRY stub_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);
GLAPI void APIENTRY stub_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN (const GLuint *rc, const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
HANDLE WINAPI stub_wglCreateBufferRegionARB (HDC hDC, int iLayerPlane, UINT uType);
VOID WINAPI stub_wglDeleteBufferRegionARB (HANDLE hRegion);
BOOL WINAPI stub_wglSaveBufferRegionARB (HANDLE hRegion, int x, int y, int width, int height);
BOOL WINAPI stub_wglRestoreBufferRegionARB (HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc);
HGLRC WINAPI stub_wglCreateContextAttribsARB (HDC hDC, HGLRC hShareContext, const int *attribList);
const char *WINAPI stub_wglGetExtensionsStringARB (HDC hdc);
BOOL WINAPI stub_wglMakeContextCurrentARB (HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
HDC WINAPI stub_wglGetCurrentReadDCARB (void);
HPBUFFERARB WINAPI stub_wglCreatePbufferARB (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
HDC WINAPI stub_wglGetPbufferDCARB (HPBUFFERARB hPbuffer);
int WINAPI stub_wglReleasePbufferDCARB (HPBUFFERARB hPbuffer, HDC hDC);
BOOL WINAPI stub_wglDestroyPbufferARB (HPBUFFERARB hPbuffer);
BOOL WINAPI stub_wglQueryPbufferARB (HPBUFFERARB hPbuffer, int iAttribute, int *piValue);
BOOL WINAPI stub_wglGetPixelFormatAttribivARB (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues);
BOOL WINAPI stub_wglGetPixelFormatAttribfvARB (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues);
BOOL WINAPI stub_wglChoosePixelFormatARB (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
BOOL WINAPI stub_wglBindTexImageARB (HPBUFFERARB hPbuffer, int iBuffer);
BOOL WINAPI stub_wglReleaseTexImageARB (HPBUFFERARB hPbuffer, int iBuffer);
BOOL WINAPI stub_wglSetPbufferAttribARB (HPBUFFERARB hPbuffer, const int *piAttribList);
BOOL WINAPI stub_wglSetStereoEmitterState3DL (HDC hDC, UINT uState);
UINT WINAPI stub_wglGetGPUIDsAMD (UINT maxCount, UINT *ids);
INT WINAPI stub_wglGetGPUInfoAMD (UINT id, int property, GLenum dataType, UINT size, void *data);
UINT WINAPI stub_wglGetContextGPUIDAMD (HGLRC hglrc);
HGLRC WINAPI stub_wglCreateAssociatedContextAMD (UINT id);
HGLRC WINAPI stub_wglCreateAssociatedContextAttribsAMD (UINT id, HGLRC hShareContext, const int *attribList);
BOOL WINAPI stub_wglDeleteAssociatedContextAMD (HGLRC hglrc);
BOOL WINAPI stub_wglMakeAssociatedContextCurrentAMD (HGLRC hglrc);
HGLRC WINAPI stub_wglGetCurrentAssociatedContextAMD (void);
VOID WINAPI stub_wglBlitContextFramebufferAMD (HGLRC dstCtx, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
GLboolean WINAPI stub_wglCreateDisplayColorTableEXT (GLushort id);
GLboolean WINAPI stub_wglLoadDisplayColorTableEXT (const GLushort *table, GLuint length);
GLboolean WINAPI stub_wglBindDisplayColorTableEXT (GLushort id);
VOID WINAPI stub_wglDestroyDisplayColorTableEXT (GLushort id);
const char *WINAPI stub_wglGetExtensionsStringEXT (void);
BOOL WINAPI stub_wglMakeContextCurrentEXT (HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
HDC WINAPI stub_wglGetCurrentReadDCEXT (void);
HPBUFFEREXT WINAPI stub_wglCreatePbufferEXT (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
HDC WINAPI stub_wglGetPbufferDCEXT (HPBUFFEREXT hPbuffer);
int WINAPI stub_wglReleasePbufferDCEXT (HPBUFFEREXT hPbuffer, HDC hDC);
BOOL WINAPI stub_wglDestroyPbufferEXT (HPBUFFEREXT hPbuffer);
BOOL WINAPI stub_wglQueryPbufferEXT (HPBUFFEREXT hPbuffer, int iAttribute, int *piValue);
BOOL WINAPI stub_wglGetPixelFormatAttribivEXT (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, int *piValues);
BOOL WINAPI stub_wglGetPixelFormatAttribfvEXT (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, FLOAT *pfValues);
BOOL WINAPI stub_wglChoosePixelFormatEXT (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
BOOL WINAPI stub_wglSwapIntervalEXT (int interval);
int WINAPI stub_wglGetSwapIntervalEXT (void);
BOOL WINAPI stub_wglGetDigitalVideoParametersI3D (HDC hDC, int iAttribute, int *piValue);
BOOL WINAPI stub_wglSetDigitalVideoParametersI3D (HDC hDC, int iAttribute, const int *piValue);
BOOL WINAPI stub_wglGetGammaTableParametersI3D (HDC hDC, int iAttribute, int *piValue);
BOOL WINAPI stub_wglSetGammaTableParametersI3D (HDC hDC, int iAttribute, const int *piValue);
BOOL WINAPI stub_wglGetGammaTableI3D (HDC hDC, int iEntries, USHORT *puRed, USHORT *puGreen, USHORT *puBlue);
BOOL WINAPI stub_wglSetGammaTableI3D (HDC hDC, int iEntries, const USHORT *puRed, const USHORT *puGreen, const USHORT *puBlue);
BOOL WINAPI stub_wglEnableGenlockI3D (HDC hDC);
BOOL WINAPI stub_wglDisableGenlockI3D (HDC hDC);
BOOL WINAPI stub_wglIsEnabledGenlockI3D (HDC hDC, BOOL *pFlag);
BOOL WINAPI stub_wglGenlockSourceI3D (HDC hDC, UINT uSource);
BOOL WINAPI stub_wglGetGenlockSourceI3D (HDC hDC, UINT *uSource);
BOOL WINAPI stub_wglGenlockSourceEdgeI3D (HDC hDC, UINT uEdge);
BOOL WINAPI stub_wglGetGenlockSourceEdgeI3D (HDC hDC, UINT *uEdge);
BOOL WINAPI stub_wglGenlockSampleRateI3D (HDC hDC, UINT uRate);
BOOL WINAPI stub_wglGetGenlockSampleRateI3D (HDC hDC, UINT *uRate);
BOOL WINAPI stub_wglGenlockSourceDelayI3D (HDC hDC, UINT uDelay);
BOOL WINAPI stub_wglGetGenlockSourceDelayI3D (HDC hDC, UINT *uDelay);
BOOL WINAPI stub_wglQueryGenlockMaxSourceDelayI3D (HDC hDC, UINT *uMaxLineDelay, UINT *uMaxPixelDelay);
LPVOID WINAPI stub_wglCreateImageBufferI3D (HDC hDC, DWORD dwSize, UINT uFlags);
BOOL WINAPI stub_wglDestroyImageBufferI3D (HDC hDC, LPVOID pAddress);
BOOL WINAPI stub_wglAssociateImageBufferEventsI3D (HDC hDC, const HANDLE *pEvent, const LPVOID *pAddress, const DWORD *pSize, UINT count);
BOOL WINAPI stub_wglReleaseImageBufferEventsI3D (HDC hDC, const LPVOID *pAddress, UINT count);
BOOL WINAPI stub_wglEnableFrameLockI3D (void);
BOOL WINAPI stub_wglDisableFrameLockI3D (void);
BOOL WINAPI stub_wglIsEnabledFrameLockI3D (BOOL *pFlag);
BOOL WINAPI stub_wglQueryFrameLockMasterI3D (BOOL *pFlag);
BOOL WINAPI stub_wglGetFrameUsageI3D (float *pUsage);
BOOL WINAPI stub_wglBeginFrameTrackingI3D (void);
BOOL WINAPI stub_wglEndFrameTrackingI3D (void);
BOOL WINAPI stub_wglQueryFrameTrackingI3D (DWORD *pFrameCount, DWORD *pMissedFrames, float *pLastMissedUsage);
BOOL WINAPI stub_wglDXSetResourceShareHandleNV (void *dxObject, HANDLE shareHandle);
HANDLE WINAPI stub_wglDXOpenDeviceNV (void *dxDevice);
BOOL WINAPI stub_wglDXCloseDeviceNV (HANDLE hDevice);
HANDLE WINAPI stub_wglDXRegisterObjectNV (HANDLE hDevice, void *dxObject, GLuint name, GLenum type, GLenum access);
BOOL WINAPI stub_wglDXUnregisterObjectNV (HANDLE hDevice, HANDLE hObject);
BOOL WINAPI stub_wglDXObjectAccessNV (HANDLE hObject, GLenum access);
BOOL WINAPI stub_wglDXLockObjectsNV (HANDLE hDevice, GLint count, HANDLE *hObjects);
BOOL WINAPI stub_wglDXUnlockObjectsNV (HANDLE hDevice, GLint count, HANDLE *hObjects);
BOOL WINAPI stub_wglCopyImageSubDataNV (HGLRC hSrcRC, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, HGLRC hDstRC, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth);
BOOL WINAPI stub_wglDelayBeforeSwapNV (HDC hDC, GLfloat seconds);
BOOL WINAPI stub_wglEnumGpusNV (UINT iGpuIndex, HGPUNV *phGpu);
BOOL WINAPI stub_wglEnumGpuDevicesNV (HGPUNV hGpu, UINT iDeviceIndex, PGPU_DEVICE lpGpuDevice);
HDC WINAPI stub_wglCreateAffinityDCNV (const HGPUNV *phGpuList);
BOOL WINAPI stub_wglEnumGpusFromAffinityDCNV (HDC hAffinityDC, UINT iGpuIndex, HGPUNV *hGpu);
BOOL WINAPI stub_wglDeleteDCNV (HDC hdc);
int WINAPI stub_wglEnumerateVideoDevicesNV (HDC hDC, HVIDEOOUTPUTDEVICENV *phDeviceList);
BOOL WINAPI stub_wglBindVideoDeviceNV (HDC hDC, unsigned int uVideoSlot, HVIDEOOUTPUTDEVICENV hVideoDevice, const int *piAttribList);
BOOL WINAPI stub_wglQueryCurrentContextNV (int iAttribute, int *piValue);
BOOL WINAPI stub_wglJoinSwapGroupNV (HDC hDC, GLuint group);
BOOL WINAPI stub_wglBindSwapBarrierNV (GLuint group, GLuint barrier);
BOOL WINAPI stub_wglQuerySwapGroupNV (HDC hDC, GLuint *group, GLuint *barrier);
BOOL WINAPI stub_wglQueryMaxSwapGroupsNV (HDC hDC, GLuint *maxGroups, GLuint *maxBarriers);
BOOL WINAPI stub_wglQueryFrameCountNV (HDC hDC, GLuint *count);
BOOL WINAPI stub_wglResetFrameCountNV (HDC hDC);
void *WINAPI stub_wglAllocateMemoryNV (GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority);
void WINAPI stub_wglFreeMemoryNV (void *pointer);
BOOL WINAPI stub_wglBindVideoCaptureDeviceNV (UINT uVideoSlot, HVIDEOINPUTDEVICENV hDevice);
UINT WINAPI stub_wglEnumerateVideoCaptureDevicesNV (HDC hDc, HVIDEOINPUTDEVICENV *phDeviceList);
BOOL WINAPI stub_wglLockVideoCaptureDeviceNV (HDC hDc, HVIDEOINPUTDEVICENV hDevice);
BOOL WINAPI stub_wglQueryVideoCaptureDeviceNV (HDC hDc, HVIDEOINPUTDEVICENV hDevice, int iAttribute, int *piValue);
BOOL WINAPI stub_wglReleaseVideoCaptureDeviceNV (HDC hDc, HVIDEOINPUTDEVICENV hDevice);
BOOL WINAPI stub_wglGetVideoDeviceNV (HDC hDC, int numDevices, HPVIDEODEV *hVideoDevice);
BOOL WINAPI stub_wglReleaseVideoDeviceNV (HPVIDEODEV hVideoDevice);
BOOL WINAPI stub_wglBindVideoImageNV (HPVIDEODEV hVideoDevice, HPBUFFERARB hPbuffer, int iVideoBuffer);
BOOL WINAPI stub_wglReleaseVideoImageNV (HPBUFFERARB hPbuffer, int iVideoBuffer);
BOOL WINAPI stub_wglSendPbufferToVideoNV (HPBUFFERARB hPbuffer, int iBufferType, unsigned long *pulCounterPbuffer, BOOL bBlock);
BOOL WINAPI stub_wglGetVideoInfoNV (HPVIDEODEV hpVideoDevice, unsigned long *pulCounterOutputPbuffer, unsigned long *pulCounterOutputVideo);
BOOL WINAPI stub_wglGetSyncValuesOML (HDC hdc, INT64 *ust, INT64 *msc, INT64 *sbc);
BOOL WINAPI stub_wglGetMscRateOML (HDC hdc, INT32 *numerator, INT32 *denominator);
INT64 WINAPI stub_wglSwapBuffersMscOML (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder);
INT64 WINAPI stub_wglSwapLayerBuffersMscOML (HDC hdc, int fuPlanes, INT64 target_msc, INT64 divisor, INT64 remainder);
BOOL WINAPI stub_wglWaitForMscOML (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder, INT64 *ust, INT64 *msc, INT64 *sbc);
BOOL WINAPI stub_wglWaitForSbcOML (HDC hdc, INT64 target_sbc, INT64 *ust, INT64 *msc, INT64 *sbc);
void glexfp::Reset();
bool glexfp::Load();
| 51a4cd66529dc6b02eb7bcbb5508afe5ad189e017ebc9b0050ebcd9ef6759b09 | 135 |
|
tetious | Marlin | Marlin/src/lcd/dogm/status_screen_lite_ST7920.cpp | ST7920_Lite_Status_Screen::set_cgram_address |
void ST7920_Lite_Status_Screen::set_cgram_address(const uint8_t addr) {
extended_function_set(false);
cmd(0b01000000 | (addr & 0b00111111));
} |
void ST7920_Lite_Status_Screen::cmd(const uint8_t cmd);
void ST7920_Lite_Status_Screen::begin_data();
void ST7920_Lite_Status_Screen::write_str(const char *str);
void ST7920_Lite_Status_Screen::write_str(const char *str, uint8_t len);
void ST7920_Lite_Status_Screen::write_str_P(PGM_P const str);
void ST7920_Lite_Status_Screen::write_number(const int16_t value, const uint8_t digits/*=3*/);
void ST7920_Lite_Status_Screen::display_status(const bool display_on, const bool cursor_on, const bool blink_on);
void ST7920_Lite_Status_Screen::_extended_function_set(const bool extended, const bool graphics);
void ST7920_Lite_Status_Screen::extended_function_set(const bool extended);
void ST7920_Lite_Status_Screen::graphics(const bool graphics);
void ST7920_Lite_Status_Screen::entry_mode_select(const bool ac_increase, const bool shift);
void ST7920_Lite_Status_Screen::_scroll_or_addr_select(const bool sa);
void ST7920_Lite_Status_Screen::scroll_or_addr_select(const bool sa);
void ST7920_Lite_Status_Screen::set_ddram_address(const uint8_t addr);
void ST7920_Lite_Status_Screen::set_gdram_address(const uint8_t x, const uint8_t y);
void ST7920_Lite_Status_Screen::clear();
void ST7920_Lite_Status_Screen::home();
void ST7920_Lite_Status_Screen::clear_ddram();
void ST7920_Lite_Status_Screen::clear_gdram();
void ST7920_Lite_Status_Screen::load_cgram_icon(const uint16_t addr, const void *data);
void ST7920_Lite_Status_Screen::draw_gdram_icon(uint8_t x, uint8_t y, const void *data);
void ST7920_Lite_Status_Screen::draw_degree_symbol(uint8_t x, uint8_t y, const bool draw);
void ST7920_Lite_Status_Screen::draw_static_elements();
void ST7920_Lite_Status_Screen::draw_progress_bar(const uint8_t value);
void ST7920_Lite_Status_Screen::draw_fan_icon(const bool whichIcon);
void ST7920_Lite_Status_Screen::draw_temps(uint8_t line, const int16_t temp, const int16_t target, bool showTarget, bool targetStateChange);
void ST7920_Lite_Status_Screen::draw_extruder_1_temp(const int16_t temp, const int16_t target, bool forceUpdate);
void ST7920_Lite_Status_Screen::draw_extruder_2_temp(const int16_t temp, const int16_t target, bool forceUpdate);
void ST7920_Lite_Status_Screen::draw_bed_temp(const int16_t temp, const int16_t target, bool forceUpdate);
void ST7920_Lite_Status_Screen::draw_fan_speed(const uint8_t value);
void ST7920_Lite_Status_Screen::draw_print_time(const duration_t &elapsed);
void ST7920_Lite_Status_Screen::draw_feedrate_percentage(const uint16_t percentage);
void ST7920_Lite_Status_Screen::draw_status_message();
void ST7920_Lite_Status_Screen::draw_position(const xyze_pos_t &pos, const bool position_known);
bool ST7920_Lite_Status_Screen::indicators_changed();
void ST7920_Lite_Status_Screen::update_indicators(const bool forceUpdate);
bool ST7920_Lite_Status_Screen::position_changed();
bool ST7920_Lite_Status_Screen::status_changed();
bool ST7920_Lite_Status_Screen::blink_changed();
void ST7920_Lite_Status_Screen::update_status_or_position(bool forceUpdate);
void ST7920_Lite_Status_Screen::update_progress(const bool forceUpdate);
void ST7920_Lite_Status_Screen::update(const bool forceUpdate);
void ST7920_Lite_Status_Screen::reset_state_from_unknown();
void ST7920_Lite_Status_Screen::on_entry();
void ST7920_Lite_Status_Screen::on_exit();
void ST7920_Lite_Status_Screen::clear_text_buffer();
void MarlinUI::draw_status_screen();
void MarlinUI::lcd_in_status(const bool inStatus);
| 1e2d9dff22d1b5865342715c15bc03434f5998c40e42dfe6b4f546b09e7394eb | 147 |
|
suilteam | suil | suil/json.cpp | Object::Object | Object::Object(suil::json::Object_t)
: mNode(json_mkobject())
{} |
static void sb_init(SB *sb);
static void sb_grow(SB *sb, int need);
static char *sb_finish(SB *sb);
static void sb_free(SB *sb);
static int utf8_validate_cz(const char *s);
static bool utf8_validate(const char *s);
static int utf8_read_char(const char *s, uchar_t *out);
static int utf8_write_char(uchar_t unicode, char *out);
static bool from_surrogate_pair(uint16_t uc, uint16_t lc, uchar_t *unicode);
static void to_surrogate_pair(uchar_t unicode, uint16_t *uc, uint16_t *lc);
static JsonNode *json_decode(const char *json);
static void json_delete(JsonNode *node);
bool json_validate(const char *json);
JsonNode *json_find_element(JsonNode *array, int index);
JsonNode *json_find_member(JsonNode *object, const char *name);
JsonNode *json_find_member(JsonNode *object, const char *key, size_t keyLen);
JsonNode *json_first_child(const JsonNode *node);
static JsonNode *mknode(JsonTag tag);
JsonNode *json_mknull(void);
JsonNode *json_mkbool(bool b);
static JsonNode *mkstring(char *s);
JsonNode *json_mkstring(const char *s);
JsonNode *json_mknstring(const char *s, size_t size);
JsonNode *json_mknumber(double n);
JsonNode *json_mkarray(void);
JsonNode *json_mkobject(void);
static void append_node(JsonNode *parent, JsonNode *child);
static void prepend_node(JsonNode *parent, JsonNode *child);
static void append_member(JsonNode *object, char *key, JsonNode *value);
void json_append_element(JsonNode *array, JsonNode *element);
void json_prepend_element(JsonNode *array, JsonNode *element);
void json_append_member(JsonNode *object, const char *key, JsonNode *value);
void json_prepend_member(JsonNode *object, const char *key, JsonNode *value);
void json_remove_from_parent(JsonNode *node);
static bool parse_value(const char **sp, JsonNode **out);
static bool parse_array(const char **sp, JsonNode **out);
static bool parse_object(const char **sp, JsonNode **out);
bool parse_string(const char **sp, char **out);
bool parse_number(const char **sp, double *out);
static void skip_space(const char **sp);
static void emit_value(iod::encode_stream& out, const JsonNode *node);
void emit_value_indented(iod::encode_stream& out, const JsonNode *node, const char *space, int indent_level);
static void emit_array(iod::encode_stream& out, const JsonNode *array);
static void emit_array_indented(iod::encode_stream& out, const JsonNode *array, const char *space, int indent_level);
static void emit_object(iod::encode_stream& out, const JsonNode *object);
static void emit_object_indented(iod::encode_stream& out, const JsonNode *object, const char *space, int indent_level);
void emit_string(iod::encode_stream& out, const char *str);
static void emit_number(iod::encode_stream& out, double num);
static bool tag_is_valid(unsigned int tag);
static bool number_is_valid(const char *num);
static bool expect_literal(const char **sp, const char *str);
static bool parse_hex16(const char **sp, uint16_t *out);
static int write_hex16(iod::encode_stream& out, uint16_t val);
bool json_check(const JsonNode *node, char errmsg[256]);
int luaEnv(lua_State *L);
Object::Object();
Object::Object(bool b);
Object::Object(double d);
Object::Object(const char *str);
Object::Object(const suil::String &str);
Object::Object(const std::string &str);
Object::Object(suil::json::Array_t);
void Object::push(suil::json::Object &&o);
void Object::set(const char *key, suil::json::Object &&o);
Object Object::operator[](int index);
Object Object::operator();
Object Object::operator[](const suil::String &key);
Object Object::get(const suil::String &key, bool shouldThrow);
Object::operator bool();
Object::operator double();
Object::operator const char*();
bool Object::empty();
bool Object::isNull();
bool Object::isBool();
bool Object::isNumber();
bool Object::isString();
bool Object::isArray();
bool Object::isObject();
Object Object::push(const suil::json::Array_t &);
Object Object::push(const suil::json::Object_t&);
Object Object::set(const char *key, const suil::json::Object_t &);
Object Object::set(const char *key, const suil::json::Array_t &);
void Object::encode(iod::encode_stream &ss);
Object Object::decode(const char *str, size_t& sz);
void Object::operator|(suil::json::Object::ArrayEnumerator f);
void Object::operator|(suil::json::Object::ObjectEnumerator f);
bool Object::operator==(const Object &other);
Object::iterator Object::iterator::operator++();
const std::pair<const char*,Object> Object::iterator::operator*();
Object::iterator Object::begin();
Object::const_iterator Object::begin();
Object& Object::operator=(suil::json::Object &&o);
Object Object::fromLuaFile(const suil::String &file);
static Object parseLuaValue(lua_State* L);
Object parseLuaTable(lua_State* L);
Object Object::fromLuaTable(lua_State *L, int index);
Object Object::fromLuaString(const suil::String &script);
Object::~Object();
void toJson(iod::json::jstream& ss);
static Mt fromJson(iod::json::parser& p);
| f3f8db6b2503c051d72dfcc058bb374796bb0cb8f9211c1404776a42dac95912 | 77 |
|
emlai | ivan | Main/Source/lterras.cpp | altar::StepOn |
void altar::StepOn(character* Stepper)
{
if(Stepper->IsPlayer() && !GetMasterGod()->IsKnown())
{
ADD_MESSAGE("The ancient altar is covered with strange markings. You manage to decipher them. The altar is "
"dedicated to %s, the %s. You now know the sacred rituals that allow you to contact this deity "
"via prayers.", GetMasterGod()->GetName(), GetMasterGod()->GetDescription());
game::LearnAbout(GetMasterGod());
}
} |
truth door::Open(character* Opener);
truth door::Close(character* Closer);
void altar::Draw(blitdata& BlitData);
void door::BeKicked(character* Kicker, int KickDamage, int);
void door::Save(outputfile& SaveFile);
void door::Load(inputfile& SaveFile);
void door::MakeWalkable();
void door::MakeNotWalkable();
truth throne::SitOn(character* Sitter);
void altar::BeKicked(character* Kicker, int, int);
truth altar::ReceiveVomit(character* Who, liquid* Liquid);
truth altar::VomitingIsDangerous(ccharacter*);
truth door::AddAdjective(festring& String, truth Articled);
truth fountain::SitOn(character* Sitter);
truth fountain::Drink(character* Drinker);
void fountain::DryOut();
void brokendoor::BeKicked(character* Kicker, int KickDamage, int);
truth altar::Polymorph(character*);
truth altar::SitOn(character* Sitter);
void door::Break();
void door::ActivateBoobyTrap();
void door::CreateBoobyTrap();
truth fountain::DipInto(item* ToBeDipped, character* Who);
void fountain::Save(outputfile& SaveFile);
void fountain::Load(inputfile& SaveFile);
material* fountain::GetMaterial(int I);
col16 fountain::GetMaterialColorB(int);
void door::PostConstruct();
void door::SetParameters(int Param);
truth door::TryKey(item* Thingy, character* Applier);
void fountain::GenerateMaterials();
truth fountain::AddAdjective(festring& String, truth Articled);
fountain::~fountain();
int fountain::GetSparkleFlags();
void stairs::Save(outputfile& SaveFile);
void stairs::Load(inputfile& SaveFile);
truth stairs::Enter(truth DirectionUp);
void stairs::StepOn(character* Stepper);
void stairs::PostConstruct();
void sign::AddPostFix(festring& String, int);
void sign::StepOn(character* Stepper);
void sign::Save(outputfile& SaveFile);
void sign::Load(inputfile& SaveFile);
void olterraincontainer::Save(outputfile& SaveFile);
void olterraincontainer::Load(inputfile& SaveFile);
olterraincontainer::olterraincontainer();
truth olterraincontainer::Open(character* Opener);
void olterraincontainer::SetItemsInside(const fearray<contentscript<item>>& ItemArray, int SpecialFlags);
void door::ReceiveDamage(character* Villain, int Damage, int);
void brokendoor::ReceiveDamage(character* Villain, int Damage, int);
olterraincontainer::~olterraincontainer();
void olterraincontainer::Break();
truth fountain::IsDipDestination();
int door::GetWalkability();
truth door::IsTransparent();
truth liquidterrain::DipInto(item* ToBeDipped, character* Who);
void earth::PostConstruct();
void earth::Save(outputfile& SaveFile);
void earth::Load(inputfile& SaveFile);
v2 earth::GetBitmapPos(int I);
void door::BeDestroyed();
truth fountain::IsFountainWithWater();
void liquidterrain::SurviveEffect(character* Survivor);
monsterportal::monsterportal();
void olterraincontainer::PreProcessForBone();
void olterraincontainer::PostProcessForBone();
void olterraincontainer::FinalProcessForBone();
v2 liquidterrain::GetBitmapPos(int F);
void liquidterrain::AddLocationDescription(festring& String);
void stairs::AddSpecialCursors();
void coffin::Save(outputfile& SaveFile);
void coffin::Load(inputfile& SaveFile);
truth coffin::Open(character* Opener);
void coffin::Break();
void coffin::GenerateGhost(lsquare* Square);
void barwall::Break();
void ironmaiden::Save(outputfile& SaveFile);
void ironmaiden::Load(inputfile& SaveFile);
v2 ironmaiden::GetBitmapPos(int);
truth ironmaiden::Open(character* Opener);
truth ironmaiden::Close(character* Closer);
int christmastree::GetSparkleFlags();
| 5e2895a3dc4a0bc8c82f3097e67ffdbeb4861080a9ff8e0b9f1294c620f48e76 | 465 |
|
DARKPOP | external_chromium_org_third_party_WebKit | Source/core/css/parser/SizesAttributeParserTest.cpp |
TEST |
TEST(SizesAttributeParserTest, Basic)
{
TestCase testCases[] = {
{"screen", 500, true},
{"(min-width:500px)", 500, true},
{"(min-width:500px) 200px", 200, false},
{"(min-width:500px) 50vw", 250, true},
{"(min-width:500px) 200px, 400px", 200, false},
{"400px, (min-width:500px) 200px", 400, false},
{"40vw, (min-width:500px) 201px", 200, true},
{"(min-width:500px) 201px, 40vw", 201, false},
{"(min-width:5000px) 40vw, 201px", 201, false},
{"(min-width:500px) calc(201px), calc(40vw)", 201, false},
{"(min-width:5000px) calc(40vw), calc(201px)", 201, false},
{"(min-width:5000px) 200px, 400px", 400, false},
{"(blalbadfsdf) 200px, 400px", 400, false},
{"0", 0, false},
{"-0", 0, false},
{"1", 500, true},
{"300px, 400px", 300, false},
{"(min-width:5000px) 200px, (min-width:500px) 400px", 400, false},
{"", 500, true},
{" ", 500, true},
{"
", 500, true},
{"
300px", 300, false},
{"300px
", 300, false},
{"
(min-width:500px)
300px", 300, false},
{"-100px, 200px", 200, false},
{"-50vw, 20vw", 100, true},
{"50asdf, 200px", 200, false},
{"asdf, 200px", 200, false},
{"(max-width: 3000px) 200w, 400w", 500, true},
{",, ,
,200px", 200, false},
{"50vw", 250, true},
{"5em", 80, false},
{"5rem", 80, false},
{"calc(40vw*2)", 400, true},
{"(min-width:5000px) calc(5000px/10), (min-width:500px) calc(1200px/3)", 400, false},
{"(min-width:500px) calc(1200/3)", 500, true},
{"(min-width:500px) calc(1200px/(0px*14))", 500, true},
{"(max-width: 3000px) 200px, 400px", 200, false},
{"(max-width: 3000px) 20em, 40em", 320, false},
{"(max-width: 3000px) 0, 40em", 0, false},
{"(max-width: 3000px) 50vw, 40em", 250, true},
{"(max-width: 3000px) 50px, 40vw", 50, false},
{0, 0, false}
};
MediaValuesCached::MediaValuesCachedData data;
data.viewportWidth = 500;
data.viewportHeight = 500;
data.deviceWidth = 500;
data.deviceHeight = 500;
data.devicePixelRatio = 2.0;
data.colorBitsPerComponent = 24;
data.monochromeBitsPerComponent = 0;
data.primaryPointerType = PointerTypeFine;
data.defaultFontSize = 16;
data.threeDEnabled = true;
data.mediaType = MediaTypeNames::screen;
data.strictMode = true;
RefPtr<MediaValues> mediaValues = MediaValuesCached::create(data);
for (unsigned i = 0; testCases[i].input; ++i) {
SizesAttributeParser parser(mediaValues, testCases[i].input);
ASSERT_EQ(testCases[i].effectiveSize, parser.length());
ASSERT_EQ(testCases[i].viewportDependant, parser.viewportDependant());
}
} | c0bf1843258992066e99ef2f712a67fd6ab709adcb22e0ba3efa69614813cca1 | 2,846 |
||
Yukarumya | Yukarum-Redfoxes | layout/painting/nsCSSRendering.cpp |
void
nsCSSRendering::PaintGradient |
void
nsCSSRendering::PaintGradient(nsPresContext* aPresContext,
gfxContext& aContext,
nsStyleGradient* aGradient,
const nsRect& aDirtyRect,
const nsRect& aDest,
const nsRect& aFillArea,
const nsSize& aRepeatSize,
const CSSIntRect& aSrc,
const nsSize& aIntrinsicSize,
float aOpacity)
{
PROFILER_LABEL("nsCSSRendering", "PaintGradient",
js::ProfileEntry::Category::GRAPHICS);
Telemetry::AutoTimer<Telemetry::GRADIENT_DURATION, Telemetry::Microsecond> gradientTimer;
if (aDest.IsEmpty() || aFillArea.IsEmpty()) {
return;
}
nscoord appUnitsPerDevPixel = aPresContext->AppUnitsPerDevPixel();
gfxSize srcSize = gfxSize(gfxFloat(aIntrinsicSize.width)/appUnitsPerDevPixel,
gfxFloat(aIntrinsicSize.height)/appUnitsPerDevPixel);
bool cellContainsFill = aDest.Contains(aFillArea);
gfxPoint lineStart, lineEnd;
double radiusX = 0, radiusY = 0;
if (aGradient->mShape == NS_STYLE_GRADIENT_SHAPE_LINEAR) {
ComputeLinearGradientLine(aPresContext, aGradient, srcSize,
&lineStart, &lineEnd);
} else {
ComputeRadialGradientLine(aPresContext, aGradient, srcSize,
&lineStart, &lineEnd, &radiusX, &radiusY);
}
if (!lineStart.IsFinite() || !lineEnd.IsFinite()) {
lineStart = lineEnd = gfxPoint(0, 0);
}
gfxFloat lineLength = NS_hypot(lineEnd.x - lineStart.x,
lineEnd.y - lineStart.y);
MOZ_ASSERT(aGradient->mStops.Length() >= 2,
"The parser should reject gradients with less than two stops");
nsTArray<ColorStop> stops;
int32_t firstUnsetPosition = -1;
for (uint32_t i = 0; i < aGradient->mStops.Length(); ++i) {
const nsStyleGradientStop& stop = aGradient->mStops[i];
double position;
switch (stop.mLocation.GetUnit()) {
case eStyleUnit_None:
if (i == 0) {
position = 0.0;
} else if (i == aGradient->mStops.Length() - 1) {
position = 1.0;
} else {
if (firstUnsetPosition < 0) {
firstUnsetPosition = i;
}
stops.AppendElement(ColorStop(0, stop.mIsInterpolationHint,
Color::FromABGR(stop.mColor)));
continue;
}
break;
case eStyleUnit_Percent:
position = stop.mLocation.GetPercentValue();
break;
case eStyleUnit_Coord:
position = lineLength < 1e-6 ? 0.0 :
stop.mLocation.GetCoordValue() / appUnitsPerDevPixel / lineLength;
break;
case eStyleUnit_Calc:
nsStyleCoord::Calc *calc;
calc = stop.mLocation.GetCalcValue();
position = calc->mPercent +
((lineLength < 1e-6) ? 0.0 :
(NSAppUnitsToFloatPixels(calc->mLength, appUnitsPerDevPixel) / lineLength));
break;
default:
MOZ_ASSERT(false, "Unknown stop position type");
}
if (i > 0) {
position = std::max(position, stops[i - 1].mPosition);
}
stops.AppendElement(ColorStop(position, stop.mIsInterpolationHint,
Color::FromABGR(stop.mColor)));
if (firstUnsetPosition > 0) {
double p = stops[firstUnsetPosition - 1].mPosition;
double d = (stops[i].mPosition - p)/(i - firstUnsetPosition + 1);
for (uint32_t j = firstUnsetPosition; j < i; ++j) {
p += d;
stops[j].mPosition = p;
}
firstUnsetPosition = -1;
}
}
bool forceRepeatToCoverTiles =
aGradient->mShape == NS_STYLE_GRADIENT_SHAPE_LINEAR &&
(lineStart.x == lineEnd.x) != (lineStart.y == lineEnd.y) &&
aRepeatSize.width == aDest.width && aRepeatSize.height == aDest.height &&
!aGradient->mRepeating && !aSrc.IsEmpty() && !cellContainsFill;
gfxMatrix matrix;
if (forceRepeatToCoverTiles) {
double rectLen;
double offset;
if (lineStart.x > lineEnd.x || lineStart.y > lineEnd.y) {
std::swap(lineStart, lineEnd);
matrix.Scale(-1, -1);
}
gfxRect srcRectDev = nsLayoutUtils::RectToGfxRect(
CSSPixel::ToAppUnits(aSrc), appUnitsPerDevPixel);
if (lineStart.x != lineEnd.x) {
rectLen = srcRectDev.width;
offset = (srcRectDev.x - lineStart.x) / lineLength;
lineStart.x = srcRectDev.x;
lineEnd.x = srcRectDev.XMost();
} else {
rectLen = srcRectDev.height;
offset = (srcRectDev.y - lineStart.y) / lineLength;
lineStart.y = srcRectDev.y;
lineEnd.y = srcRectDev.YMost();
}
double scale = lineLength / rectLen;
for (size_t i = 0; i < stops.Length(); i++) {
stops[i].mPosition = (stops[i].mPosition - offset) * fabs(scale);
}
ClampColorStops(stops);
lineLength = rectLen;
}
double firstStop = stops[0].mPosition;
if (aGradient->mShape != NS_STYLE_GRADIENT_SHAPE_LINEAR && firstStop < 0.0) {
if (aGradient->mRepeating) {
double lastStop = stops[stops.Length() - 1].mPosition;
double stopDelta = lastStop - firstStop;
if (stopDelta >= 1e-6) {
double instanceCount = ceil(-firstStop/stopDelta);
double offset = instanceCount*stopDelta;
for (uint32_t i = 0; i < stops.Length(); i++) {
stops[i].mPosition += offset;
}
}
} else {
for (uint32_t i = 0; i < stops.Length(); i++) {
double pos = stops[i].mPosition;
if (pos < 0.0) {
stops[i].mPosition = 0.0;
if (i < stops.Length() - 1) {
double nextPos = stops[i + 1].mPosition;
if (nextPos >= 0.0 && nextPos - pos >= 1e-6) {
float frac = float((0.0 - pos)/(nextPos - pos));
stops[i].mColor =
InterpolateColor(stops[i].mColor, stops[i + 1].mColor, frac);
}
}
}
}
}
firstStop = stops[0].mPosition;
MOZ_ASSERT(firstStop >= 0.0, "Failed to fix stop offsets");
}
if (aGradient->mShape != NS_STYLE_GRADIENT_SHAPE_LINEAR && !aGradient->mRepeating) {
firstStop = 0;
}
double lastStop = stops[stops.Length() - 1].mPosition;
double stopScale;
double stopOrigin = firstStop;
double stopEnd = lastStop;
double stopDelta = lastStop - firstStop;
bool zeroRadius = aGradient->mShape != NS_STYLE_GRADIENT_SHAPE_LINEAR &&
(radiusX < 1e-6 || radiusY < 1e-6);
if (stopDelta < 1e-6 || lineLength < 1e-6 || zeroRadius) {
if (aGradient->mRepeating || zeroRadius) {
radiusX = radiusY = 0.0;
}
stopDelta = 0.0;
lastStop = firstStop;
}
if (!aGradient->mRepeating || stopDelta == 0.0) {
stopOrigin = std::min(stopOrigin, 0.0);
stopEnd = std::max(stopEnd, 1.0);
}
stopScale = 1.0/(stopEnd - stopOrigin);
RefPtr<gfxPattern> gradientPattern;
gfxPoint gradientStart;
gfxPoint gradientEnd;
if (aGradient->mShape == NS_STYLE_GRADIENT_SHAPE_LINEAR) {
gradientStart = lineStart + (lineEnd - lineStart)*stopOrigin;
gradientEnd = lineStart + (lineEnd - lineStart)*stopEnd;
gfxPoint gradientStopStart = lineStart + (lineEnd - lineStart)*firstStop;
gfxPoint gradientStopEnd = lineStart + (lineEnd - lineStart)*lastStop;
if (stopDelta == 0.0) {
gradientEnd = gradientStart + (lineEnd - lineStart);
gradientStopEnd = gradientStopStart + (lineEnd - lineStart);
}
gradientPattern = new gfxPattern(gradientStart.x, gradientStart.y,
gradientEnd.x, gradientEnd.y);
} else {
NS_ASSERTION(firstStop >= 0.0,
"Negative stops not allowed for radial gradients");
double innerRadius = radiusX*stopOrigin;
double outerRadius = radiusX*stopEnd;
if (stopDelta == 0.0) {
outerRadius = innerRadius + 1;
}
gradientPattern = new gfxPattern(lineStart.x, lineStart.y, innerRadius,
lineStart.x, lineStart.y, outerRadius);
if (radiusX != radiusY) {
matrix.Translate(lineStart);
matrix.Scale(1.0, radiusX/radiusY);
matrix.Translate(-lineStart);
}
}
matrix.Translate(gfxPoint(aPresContext->CSSPixelsToDevPixels(aSrc.x),
aPresContext->CSSPixelsToDevPixels(aSrc.y)));
matrix.Scale(gfxFloat(aPresContext->CSSPixelsToAppUnits(aSrc.width))/aDest.width,
gfxFloat(aPresContext->CSSPixelsToAppUnits(aSrc.height))/aDest.height);
gradientPattern->SetMatrix(matrix);
if (gradientPattern->CairoStatus())
return;
if (stopDelta == 0.0) {
Color firstColor(stops[0].mColor);
Color lastColor(stops.LastElement().mColor);
stops.Clear();
if (!aGradient->mRepeating && !zeroRadius) {
stops.AppendElement(ColorStop(firstStop, false, firstColor));
}
stops.AppendElement(ColorStop(firstStop, false, lastColor));
}
ResolveMidpoints(stops);
ResolvePremultipliedAlpha(stops);
bool isRepeat = aGradient->mRepeating || forceRepeatToCoverTiles;
nsTArray<gfx::GradientStop> rawStops(stops.Length());
rawStops.SetLength(stops.Length());
for(uint32_t i = 0; i < stops.Length(); i++) {
rawStops[i].color = stops[i].mColor;
rawStops[i].color.a *= aOpacity;
rawStops[i].offset = stopScale * (stops[i].mPosition - stopOrigin);
}
RefPtr<mozilla::gfx::GradientStops> gs =
gfxGradientCache::GetOrCreateGradientStops(aContext.GetDrawTarget(),
rawStops,
isRepeat ? gfx::ExtendMode::REPEAT : gfx::ExtendMode::CLAMP);
gradientPattern->SetColorStops(gs);
nsRect dirty;
if (!dirty.IntersectRect(aDirtyRect, aFillArea))
return;
gfxRect areaToFill =
nsLayoutUtils::RectToGfxRect(aFillArea, appUnitsPerDevPixel);
gfxRect dirtyAreaToFill = nsLayoutUtils::RectToGfxRect(dirty, appUnitsPerDevPixel);
dirtyAreaToFill.RoundOut();
gfxMatrix ctm = aContext.CurrentMatrix();
bool isCTMPreservingAxisAlignedRectangles = ctm.PreservesAxisAlignedRectangles();
nscoord xStart = FindTileStart(dirty.x, aDest.x, aRepeatSize.width);
nscoord yStart = FindTileStart(dirty.y, aDest.y, aRepeatSize.height);
nscoord xEnd = forceRepeatToCoverTiles ? xStart + aDest.width : dirty.XMost();
nscoord yEnd = forceRepeatToCoverTiles ? yStart + aDest.height : dirty.YMost();
for (nscoord y = yStart; y < yEnd; y += aRepeatSize.height) {
for (nscoord x = xStart; x < xEnd; x += aRepeatSize.width) {
gfxRect tileRect = nsLayoutUtils::RectToGfxRect(
nsRect(x, y, aDest.width, aDest.height),
appUnitsPerDevPixel);
gfxRect fillRect =
forceRepeatToCoverTiles ? areaToFill : tileRect.Intersect(areaToFill);
gfxPoint snappedFillRectTopLeft = fillRect.TopLeft();
gfxPoint snappedFillRectTopRight = fillRect.TopRight();
gfxPoint snappedFillRectBottomRight = fillRect.BottomRight();
if (isCTMPreservingAxisAlignedRectangles &&
aContext.UserToDevicePixelSnapped(snappedFillRectTopLeft, true) &&
aContext.UserToDevicePixelSnapped(snappedFillRectBottomRight, true) &&
aContext.UserToDevicePixelSnapped(snappedFillRectTopRight, true)) {
if (snappedFillRectTopLeft.x == snappedFillRectBottomRight.x ||
snappedFillRectTopLeft.y == snappedFillRectBottomRight.y) {
continue;
}
gfxMatrix transform = gfxUtils::TransformRectToRect(fillRect,
snappedFillRectTopLeft, snappedFillRectTopRight,
snappedFillRectBottomRight);
aContext.SetMatrix(transform);
}
aContext.NewPath();
aContext.Rectangle(fillRect);
gfxRect dirtyFillRect = fillRect.Intersect(dirtyAreaToFill);
gfxRect fillRectRelativeToTile = dirtyFillRect - tileRect.TopLeft();
Color edgeColor;
if (aGradient->mShape == NS_STYLE_GRADIENT_SHAPE_LINEAR && !isRepeat &&
RectIsBeyondLinearGradientEdge(fillRectRelativeToTile, matrix, stops,
gradientStart, gradientEnd, &edgeColor)) {
edgeColor.a *= aOpacity;
aContext.SetColor(edgeColor);
} else {
aContext.SetMatrix(
aContext.CurrentMatrix().Copy().Translate(tileRect.TopLeft()));
aContext.SetPattern(gradientPattern);
}
aContext.Fill();
aContext.SetMatrix(ctm);
}
}
} | InlineBackgroundData();
~InlineBackgroundData();
void Reset();
nsRect GetContinuousRect(nsIFrame* aFrame);
nsRect GetBorderContinuousRect(nsIFrame* aFrame, nsRect aBorderArea);
nsRect GetBoundingRect(nsIFrame* aFrame);
void SetFrame(nsIFrame* aFrame);
nsIFrame* GetPrevContinuation(nsIFrame* aFrame);
nsIFrame* GetNextContinuation(nsIFrame* aFrame);
void Init(nsIFrame* aFrame);
bool AreOnSameLine(nsIFrame* aFrame1, nsIFrame* aFrame2);
void nsCSSRendering::Init();
void nsCSSRendering::Shutdown();
static float Interpolate(float aF1, float aF2, float aFrac);
static void ResolveMidpoints(nsTArray<ColorStop>& stops);
tatic nscoord
ComputeRoundedSize(nscoord aCurrentSize, nscoord aPositioningSize);
tatic void SetPoly(const Rect& aRect, Point* poly);
ect
nsCSSRendering::DecorationLineToPath(const PaintDecorationLineParams& aParams);
sImageRenderer::~nsImageRenderer();
ool
nsImageRenderer::PrepareImage();
sSize
CSSSizeOrRatio::ComputeConcreteSize();
SSSizeOrRatio
nsImageRenderer::ComputeIntrinsicSize();
tatic uint32_t
ConvertImageRendererToDrawFlags(uint32_t aImageRendererFlags);
ool
nsImageRenderer::IsRasterImage();
ool
nsImageRenderer::IsAnimatedImage();
lready_AddRefed<imgIContainer>
nsImageRenderer::GetImage();
oid
nsContextBoxBlur::DoPaint();
fxContext*
nsContextBoxBlur::GetContext();
| 80f36fd7a18634afd390707e7ee53d5da6637df0d81e520a1403fb24e602ba96 | 13,303 |
|
mgrosso | cplusql | frame/src/CountChangesProjection.cpp |
CountChangesProjection::CountChangesProjection |
CountChangesProjection::CountChangesProjection( ExpressionPtr &src )
{
d_=new CountChangesProjectionPriv ( src );
result_=0;
} | CountChangesProjectionPriv( ExpressionPtr &src );
CountChangesProjection::~CountChangesProjection();
| 57f3fa067da625dcc73c497b1e601d7cae61fdc9e30dc9942241bb3a952f0ff6 | 135 |
|
AndroidOpenSourceProject | platform_frameworks_av | android/frameworks/av/camera/ProCamera.cpp | ProCamera::createStreamCpu |
status_t ProCamera::createStreamCpu(int width, int height, int format,
int heapCount,
bool synchronousMode,
sp<CpuConsumer>* cpuConsumer,
int* streamId)
{
ALOGV("%s: createStreamW %dx%d (fmt=0x%x)", __FUNCTION__, width, height,
format);
*cpuConsumer = NULL;
sp <IProCameraUser> c = mCamera;
if (c == 0) return NO_INIT;
sp<BufferQueue> bq = new BufferQueue();
sp<CpuConsumer> cc = new CpuConsumer(bq, heapCount
);
cc->setName(String8("ProCamera::mCpuConsumer"));
sp<Surface> stc = new Surface(bq);
status_t s = createStream(width, height, format,
stc->getIGraphicBufferProducer(),
streamId);
if (s != OK) {
ALOGE("%s: Failure to create stream %dx%d (fmt=0x%x)", __FUNCTION__,
width, height, format);
return s;
}
sp<ProFrameListener> frameAvailableListener =
new ProFrameListener(this, *streamId);
getStreamInfo(*streamId).cpuStream = true;
getStreamInfo(*streamId).cpuConsumer = cc;
getStreamInfo(*streamId).synchronousMode = synchronousMode;
getStreamInfo(*streamId).stc = stc;
getStreamInfo(*streamId).frameAvailableListener = frameAvailableListener;
cc->setFrameAvailableListener(frameAvailableListener);
*cpuConsumer = cc;
return s;
} |
sp<ProCamera> ProCamera::connect(int cameraId);
ProCamera::ProCamera(int cameraId);
ProCamera::~ProCamera();
void ProCamera::notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2);
void ProCamera::onResultReceived(int32_t requestId, camera_metadata* result);
status_t ProCamera::exclusiveTryLock();
status_t ProCamera::exclusiveLock();
status_t ProCamera::exclusiveUnlock();
bool ProCamera::hasExclusiveLock();
status_t ProCamera::cancelRequest(int requestId);
status_t ProCamera::deleteStream(int streamId);
camera_metadata* ProCamera::getCameraInfo(int cameraId);
void ProCamera::onFrameAvailable(int streamId);
int ProCamera::waitForFrameBuffer(int streamId);
int ProCamera::dropFrameBuffer(int streamId, int count);
status_t ProCamera::waitForFrameMetadata();
CameraMetadata ProCamera::consumeFrameMetadata();
ProCamera::StreamInfo& ProCamera::getStreamInfo(int streamId);
| 303aa357ec48c9fb6caba1cca19450d26fb3d2b20712622dee72f5bd7c6d0372 | 1,593 |
|
mekolat | ManaPlus | src/progs/manaplus/actions/windows.cpp |
impHandler0 |
impHandler0(minimapWindowShow)
{
if (minimap != nullptr)
{
minimap->toggle();
return true;
}
return false;
} |
impHandler0(setupWindowShow);
impHandler0(hideWindows);
static bool showHelpPage(const std::string &page, const bool showHide);
impHandler(helpWindowShow);
impHandler0(aboutWindowShow);
static void showHideWindow(Window *const window);
impHandler0(statusWindowShow);
impHandler0(inventoryWindowShow);
impHandler0(equipmentWindowShow);
impHandler0(skillDialogShow);
impHandler0(chatWindowShow);
impHandler0(shortcutWindowShow);
impHandler0(debugWindowShow);
impHandler0(socialWindowShow);
impHandler0(emoteShortcutWindowShow);
impHandler0(outfitWindowShow);
impHandler0(shopWindowShow);
impHandler0(dropShortcutWindowShow);
impHandler0(killStatsWindowShow);
impHandler0(spellShortcutWindowShow);
impHandler0(whoIsOnlineWindowShow);
impHandler0(didYouKnowWindowShow);
impHandler0(questsWindowShow);
impHandler0(bankWindowShow);
impHandler0(cartWindowShow);
impHandler0(updaterWindowShow);
impHandler0(quickWindowShow);
impHandler0(mailWindowShow);
impHandler0(serverInfoWindowShow);
impHandler0(clanWindowShow);
impHandler(showItems);
| fd0cc13e2d7baf80c4165aa925c492e65cb32c773fdcab850e51e65ab803e379 | 141 |
|
iclosure | jframework | src/3rdpart/BCGCBPro/BCGPChartSeries.cpp | CBCGPChartBubbleSeries::GetSeriesFillGradientType |
CBCGPBrush::BCGP_GRADIENT_TYPE CBCGPChartBubbleSeries::GetSeriesFillGradientType() const
{
return CBCGPBrush::BCGP_GRADIENT_RADIAL_CENTER;
} |
CBCGPChartSeries::CBCGPChartSeries();
CBCGPChartSeries::~CBCGPChartSeries();
void CBCGPChartSeries::SetDefaultSeriesColor(const CBCGPColor& seriesColor);
void CBCGPChartSeries::SetIndexMode(BOOL bSet);
BOOL CBCGPChartSeries::IsVirtualMode();
const CBCGPPointsArray& CBCGPChartSeries::GetVirtualSeriesScreenPoints();
BOOL CBCGPChartSeries::IsFormulaSeries();
CBCGPChartBaseFormula* CBCGPChartSeries::GetFormula();
void CBCGPChartSeries::SetFormula(const CBCGPChartBaseFormula& formula, BOOL bRedraw);
void CBCGPChartSeries::SetTreatNulls(CBCGPChartSeries::TreatNulls tn, BOOL bRecalcMinMax);
CBCGPPoint CBCGPChartSeries::ScreenPointFromChartData(const CBCGPChartData& data, int nDataPointIndex);
void CBCGPChartSeries::ResizeDataPointArray(int nNewSize);
void CBCGPChartSeries::ResizeLongDataArray(int nNewSize, BOOL bGrowByCount, CBCGPChartData::ComponentIndex ci);
void CBCGPChartSeries::UpdateAxes();
int CBCGPChartSeries::GetMinDataPointIndex();
int CBCGPChartSeries::GetMaxDataPointIndex();
CBCGPBaseChartImpl* CBCGPChartSeries::OnCreateChartImpl(BCGPChartCategory chartCategory);
void CBCGPChartSeries::SetChartCtrl(CBCGPChartVisualObject* pChartCtrl);
CBCGPBaseChartImpl* CBCGPChartSeries::GetChartImpl();
void CBCGPChartSeries::SetChartImpl(CBCGPBaseChartImpl* pImpl);
BOOL CBCGPChartSeries::CanBeConvertedToCategory(BCGPChartCategory chartCategory);
void CBCGPChartSeries::EnableAutoColorDataPoints(BOOL bEnable, BOOL bRedraw);
void CBCGPChartSeries::ShowOnPrimaryAxis(BOOL bPrimary);
CBCGPRect CBCGPChartSeries::GetAxesBoundingRect();
void CBCGPChartSeries::SetRelatedAxes(CBCGPChartAxis* pXAxis, CBCGPChartAxis* pYAxis, CBCGPChartAxis* pZAxis);
void CBCGPChartSeries::SetRelatedAxis(CBCGPChartAxis* pAxis, CBCGPChartSeries::AxisIndex axisIndex);
void CBCGPChartSeries::ReplaceAxis(CBCGPChartAxis* pAxisOld, CBCGPChartAxis* pAxisNew);
void CBCGPChartSeries::UpdateAxisCategories();
CBCGPChartAxis* CBCGPChartSeries::GetRelatedAxis(CBCGPChartSeries::AxisIndex axisIndex);
CBCGPChartSeries::AxisIndex CBCGPChartSeries::GetRelatedAxisIndex(CBCGPChartAxis* pAxis);
BOOL CBCGPChartSeries::IsShownOnCustomOrResizedAxis();
void CBCGPChartSeries::SetGroupID(int nGroupID, BOOL bRecalcMinMaxValues);
void CBCGPChartSeries::ClearMinMaxValues();
void CBCGPChartSeries::SetMinValue(double dblValue, CBCGPChartData::ComponentIndex ci);
void CBCGPChartSeries::SetMaxValue(double dblValue, CBCGPChartData::ComponentIndex ci);
CBCGPChartValue CBCGPChartSeries::GetMinValue(CBCGPChartData::ComponentIndex ci);
CBCGPChartValue CBCGPChartSeries::GetMaxValue(CBCGPChartData::ComponentIndex ci);
void CBCGPChartSeries::SetMinMaxValuesSimple(double dblValue, CBCGPChartData::ComponentIndex ci, int nDataPointIndex);
void CBCGPChartSeries::SetMinMaxValuesRange(double dblValue, CBCGPChartData::ComponentIndex ci, int nDataPointIndex);
void CBCGPChartSeries::SetMinMaxValuesStacked(double dblValue, CBCGPChartData::ComponentIndex ci, int nDataPointIndex);
void CBCGPChartSeries::SetMinMaxValues100Stacked(double dblValue, CBCGPChartData::ComponentIndex ci, int nDataPointIndex);
void CBCGPChartSeries::SetMinMaxValues(const CBCGPChartValue& val, CBCGPChartData::ComponentIndex ci, int nDataPointIndex);
void CBCGPChartSeries::OnCalcScreenPointsSimple(CBCGPGraphicsManager* /*pGM*/, const CBCGPRect& /*rectDiagramArea*/);
void CBCGPChartSeries::OnCalcScreenPointsRange(CBCGPGraphicsManager* /*pGM*/, const CBCGPRect& /*rectDiagramArea*/);
void CBCGPChartSeries::OnCalcScreenPointsStacked(CBCGPGraphicsManager* pGM, const CBCGPRect& /*rectDiagramArea*/);
void CBCGPChartSeries::OnCalcScreenPoints100Stacked(CBCGPGraphicsManager* pGM, const CBCGPRect& /*rectDiagramArea*/);
void CBCGPChartSeries::OnCalcScreenPoints(CBCGPGraphicsManager* pGM, const CBCGPRect& rectDiagramArea);
int CBCGPChartSeries::GetDataPointCount();
const CBCGPChartDataPoint* CBCGPChartSeries::GetDataPointAt(int nIndex);
int CBCGPChartSeries::FindDataPointIndex(CBCGPChartDataPoint* pDataPoint);
void CBCGPChartSeries::RemoveDataPoints(int nStartIdx, int nCount, BOOL bFreeExtra);
void CBCGPChartSeries::RemoveAllDataPoints();
void CBCGPChartSeries::MoveDataPoints(int nFromIdx, int nToIdx, int nCount);
int CBCGPChartSeries::AddDataPoint(CBCGPChartDataPoint* pDataPoint);
int CBCGPChartSeries::AddDataPoint(const CBCGPChartDataPoint& srcDataPoint);
int CBCGPChartSeries::AddDataPoint(const CString& strCategoryName, double dblY, BCGPChartFormatSeries* pDataPointFormat, DWORD_PTR dwUserData);
int CBCGPChartSeries::AddDataPoint(double dblY, BCGPChartFormatSeries* pDataPointFormat, DWORD_PTR dwUserData);
int CBCGPChartSeries::AddDataPoint(double dblY, double dblX, BCGPChartFormatSeries* pDataPointFormat, DWORD_PTR dwUserData);
int CBCGPChartSeries::AddEmptyDataPoint(const CString& strCategoryName, DWORD_PTR dwUserData, BCGPChartFormatSeries* pDataPointFormat);
int CBCGPChartSeries::AddEmptyDataPoint(DWORD_PTR dwUserData, BCGPChartFormatSeries* pDataPointFormat);
int CBCGPChartSeries::AddEmptyDataPoint(double dblX, DWORD_PTR dwUserData, BCGPChartFormatSeries* pDataPointFormat);
const BCGPChartFormatSeries* CBCGPChartSeries::GetDataPointFormat(int nIndex, BOOL bAlloc);
const BCGPChartFormatSeries* CBCGPChartSeries::GetDataPointFormat(int nIndex);
void CBCGPChartSeries::ClearDataPointFormat(int nDataPointIndex);
const BCGPChartFormatSeries* CBCGPChartSeries::GetColors(BCGPSeriesColorsPtr& seriesColors, int nDataPointIndex);
BOOL CBCGPChartSeries::SetDataPointColorIndex(int nDataPointIndex, int nColorIndex);
int CBCGPChartSeries::GetDataPointColorIndex(int nDataPointIndex);
CBCGPRect CBCGPChartSeries::GetDataPointBoundingRect(int nDataPointIndex);
void CBCGPChartSeries::SetDataPointBoundingRect(int nDataPointIndex, const CBCGPRect& rect);
CBCGPRect CBCGPChartSeries::GetDataPointLabelRect(int nDataPointIndex);
BOOL CBCGPChartSeries::SetDataPointLabelRect(int nDataPointIndex, const CBCGPRect& rect);
BOOL CBCGPChartSeries::SetUseWordWrapForDataLabels(BOOL bSet, int nDataPointIndex);
BOOL CBCGPChartSeries::IsUseWordWrapForDataLabels(int nDataPointIndex);
LPCTSTR CBCGPChartSeries::GetDataPointCategoryName(int nDataPointIndex);
BOOL CBCGPChartSeries::SetDataPointCategoryName(const CString& strName, int nDataPointIndex);
DWORD_PTR CBCGPChartSeries::GetDataPointUserData(int nDataPointIndex);
BOOL CBCGPChartSeries::SetDataPointUserData(int nDataPointIndex, DWORD_PTR dwUserData);
CBCGPPoint CBCGPChartSeries::GetDataPointScreenPoint(int nDataPointIndex, int nScreenPointIndex);
void CBCGPChartSeries::SetDataPointScreenPoint(int nDataPointIndex, int nScreenPointIndex, CBCGPPoint pt);
void CBCGPChartSeries::RemoveAllDataPointScreenPoints(int nDataPointIndex);
BOOL CBCGPChartSeries::IsDataPointScreenPointsEmpty(int nDataPointIndex);
int CBCGPChartSeries::GetDataPointScreenPointCount(int nDataPointIndex);
CBCGPChartShape3D* CBCGPChartSeries::GetDataPointShape3D(int nDataPointIndex);
void CBCGPChartSeries::SetDataPointShape3D(const CBCGPChartShape3D& shape3D, int nDataPointIndex);
void CBCGPChartSeries::SetDataPointShape3D(CBCGPChartShape3D* pShape3D, int nDataPointIndex);
BOOL CBCGPChartSeries::OnSetDataPointDataLabelText(int nDataPointIndex, const CString& strText);
BOOL CBCGPChartSeries::OnGetDataLabelText(int nDataPointIndex, CString& strText);
void CBCGPChartSeries::OnGetDataPointLegendLabel(int nDataPointIndex, CString& strLabel);
BOOL CBCGPChartSeries::CanIncludeDataPointToLegend(int nDataPointIndex);
BOOL CBCGPChartSeries::GetDataPointTableText(int nDataPointIndex, CString& strDPLabel, int nPrecision);
CBCGPChartData CBCGPChartSeries::GetDataPointData(int nDataPointIndex);
CBCGPChartValue CBCGPChartSeries::GetDataPointValue(int nDataPointIndex, CBCGPChartData::ComponentIndex ci);
BOOL CBCGPChartSeries::SetDataPointValue(int nDataPointIndex, double dblValue, CBCGPChartData::ComponentIndex ci);
BOOL CBCGPChartSeries::OnGetDataPointTooltip(int nDataPointIndex, CString& strTooltip, CString& strTooltipDescr);
void CBCGPChartSeries::CopyDataPoints(CArray<CBCGPChartDataPoint*, CBCGPChartDataPoint*>& dest);
void CBCGPChartSeries::CopyFrom(const CBCGPChartSeries& src);
void CBCGPChartSeries::RecalcMinMaxValues();
void CBCGPChartSeries::SetFullStackedMinMax();
void CBCGPChartSeries::ApplySeriesColorsToDataPointFormat(int nDataPointIndex);
void CBCGPChartSeries::SetMarkerFill(const CBCGPBrush& br, int nDataPointIndex);
void CBCGPChartSeries::SetMarkerLineColor(const CBCGPBrush& br, int nDataPointIndex);
void CBCGPChartSeries::SetMarkerLineWidth(double dblWidth, int nDataPointIndex);
void CBCGPChartSeries::SetMarkerStrokeStyle(const CBCGPStrokeStyle& strokeStyle, int nDataPointIndex);
void CBCGPChartSeries::SetMarkerSize (int nSize, int nDataPointIndex);
void CBCGPChartSeries::SetMarkerShape(BCGPChartMarkerOptions::MarkerShape shape, int nDataPointIndex);
void CBCGPChartSeries::SetMarkerFormat(const BCGPChartFormatMarker& format, int nDataPointIndex);
void CBCGPChartSeries::SetMarkerOptions(const BCGPChartMarkerOptions& options, int nDataPointIndex);
void CBCGPChartSeries::ShowMarker(BOOL bShow, int nDataPointIndex);
void CBCGPChartSeries::SetSeriesFill(const CBCGPBrush& br, int nDataPointIndex);
void CBCGPChartSeries::SetSeriesLineColor(const CBCGPBrush& br, int nDataPointIndex);
void CBCGPChartSeries::SetSeriesLineWidth(double dblWidth, int nDataPointIndex);
void CBCGPChartSeries::SetSeriesLineDashStyle(CBCGPStrokeStyle::BCGP_DASH_STYLE style, int nDataPointIndex);
void CBCGPChartSeries::SetSeriesStrokeStyle(const CBCGPStrokeStyle& strokeStyle, int nDataPointIndex);
void CBCGPChartSeries::SetSeriesElementFormat(const BCGPChartFormatArea& format, int nDataPointIndex);
void CBCGPChartSeries::ShowDataLabel(BOOL bShow, int nDataPointIndex);
void CBCGPChartSeries::SetDataLabelOptions(const BCGPChartDataLabelOptions& options, int nDataPointIndex);
void CBCGPChartSeries::SetDataLabelFill(const CBCGPBrush& br, int nDataPointIndex);
void CBCGPChartSeries::SetDataLabelLineColor(const CBCGPBrush& br, int nDataPointIndex);
void CBCGPChartSeries::SetDataLabelLineWidth(double dblWidth, int nDataPointIndex);
void CBCGPChartSeries::SetDataLabelStrokeStyle(const CBCGPStrokeStyle& strokeStyle, int nDataPointIndex);
void CBCGPChartSeries::SetDataLabelTextFormat(const CBCGPTextFormat& textFormat, int nDataPointIndex);
void CBCGPChartSeries::SetDataLabelDrawBorder(BOOL bDraw, int nDataPointIndex);
void CBCGPChartSeries::SetDataLabelDropLineToMarker(BOOL bDrop, int nDataPointIndex);
void CBCGPChartSeries::SetDataLabelUnderline(BOOL bUnderline, int nDataPointIndex);
void CBCGPChartSeries::SetDataLabelSeparator(const CString& strSeparator, int nDataPointIndex);
void CBCGPChartSeries::SetDataLabelDisplayKey(BOOL bSet, int nDataPointIndex);
void CBCGPChartSeries::SetDataLabelAngle(double dblAngle, int nDataPointIndex);
double CBCGPChartSeries::GetDataPointLabelAngle(int nDataPointIndex);
double CBCGPChartSeries::GetDataPointLabelDistance(int nDataPointIndex);
void CBCGPChartSeries::SetDataLabelDistanceFromMarker(double dblOffset, int nDataPointIndex);
void CBCGPChartSeries::SetDataLabelPosition(BCGPChartDataLabelOptions::LabelPosition position, int nDataPointIndex);
void CBCGPChartSeries::SetDataLabelContent(BCGPChartDataLabelOptions::LabelContent content, int nDataPointIndex);
void CBCGPChartSeries::SetDataLabelContentPadding(const CBCGPSize& sz, int nDataPointIndex);
void CBCGPChartSeries::SetDataLabelDataFormat(const CString& strFormat, int nDataPointIndex);
void CBCGPChartSeries::SetDataLabelFormat(const BCGPChartFormatDataLabel& format, int nDataPointIndex);
void CBCGPChartSeries::SetLegendLabelTextFormat(const CBCGPTextFormat& textFormat, int nDataPointIndex);
void CBCGPChartSeries::SetLegendLabelTextColor(const CBCGPBrush& br, int nDataPointIndex);
void CBCGPChartSeries::SetLegendLabelFillColor(const CBCGPBrush& br, int nDataPointIndex);
void CBCGPChartSeries::SetLegendLabelFormat(const BCGPChartFormatLabel& format, int nDataPointIndex);
void CBCGPChartSeries::SetLegendLabelContent(BCGPChartDataLabelOptions::LabelContent content, int nDataPointIndex);
void CBCGPChartSeries::SetDataPoint3DLineThickness(double dblLineThickness, int nDataPointIndex);
void CBCGPChartSeries::SetCurveType(BCGPChartFormatSeries::ChartCurveType type);
BCGPChartFormatSeries::ChartCurveType CBCGPChartSeries::GetCurveType();
void CBCGPChartSeries::AdjustGradientAngels();
void CBCGPChartSeries::OnScaleRatioChanged(const CBCGPSize& sizeScaleRatioNew, const CBCGPSize& sizeScaleRatioOld);
int CBCGPChartSeries::GetLegendElementCount();
void CBCGPChartSeries::UpdateSeriesColors();
CBCGPDoubleArray* CBCGPChartSeries::GetDataBuffer(int nBufferIndex);
BOOL CBCGPChartSeries::HitTestDataPoint(const CBCGPPoint& pt, BCGPChartHitInfo* pHitInfo);
int CBCGPChartSeries::GetShadowAngle();
int CBCGPChartSeries::GetShadowTransparencyPercent();
BOOL CBCGPChartSeries::IsDisplayShadow();
CBCGPBrush::BCGP_GRADIENT_TYPE CBCGPChartSeries::GetDefaultFillGradientType();
CBCGPChartLineSeries::CBCGPChartLineSeries();
void CBCGPChartLineSeries::CommonInit();
void CBCGPChartLineSeries::EnableColorEachLine(BOOL bEnable, BOOL bRedraw);
CBCGPChartAreaSeries::CBCGPChartAreaSeries();
void CBCGPChartAreaSeries::CommonInit();
void CBCGPChartAreaSeries::ClearMinMaxValues();
void CBCGPChartAreaSeries::RecalcMinMaxValues();
void CBCGPChartAreaSeries::SetAreaOrigin(double dblValue, BOOL bRedraw);
BOOL CBCGPChartAreaSeries::SetDataPointValue(int nDataPointIndex, double dblValue, CBCGPChartData::ComponentIndex ci);
int CBCGPChartAreaSeries::AddDataPoint(CBCGPChartDataPoint* pDataPoint);
int CBCGPChartAreaSeries::AddDataPoint(const CBCGPChartDataPoint& srcDataPoint);
int CBCGPChartAreaSeries::AddDataPoint(const CString& strCategoryName, double dblY, BCGPChartFormatSeries* pDataPointFormat, DWORD_PTR dwUserData);
int CBCGPChartAreaSeries::AddDataPoint(double dblY, BCGPChartFormatSeries* pDataPointFormat, DWORD_PTR dwUserData);
int CBCGPChartAreaSeries::AddDataPoint(double dblY, double dblX, BCGPChartFormatSeries* pDataPointFormat, DWORD_PTR dwUserData);
CBCGPChartSurfaceSeries::CBCGPChartSurfaceSeries(CBCGPChartVisualObject* pChartCtrl);
void CBCGPChartSurfaceSeries::CommonInit();
CBCGPChartSurfaceSeries::~CBCGPChartSurfaceSeries();
void CBCGPChartSurfaceSeries::CleanBrushes();
void CBCGPChartSurfaceSeries::SetSurfaceType(SurfaceType type);
void CBCGPChartSurfaceSeries::SetFrameStyle(FrameStyle style);
void CBCGPChartSurfaceSeries::SetFrameColor(const CBCGPBrush& br);
void CBCGPChartSurfaceSeries::SetWireFrame(BOOL bSet);
void CBCGPChartSurfaceSeries::SetSurfaceDimension(int nXSize);
void CBCGPChartSurfaceSeries::SetColorMapCount(int nCount);
void CBCGPChartSurfaceSeries::SetColorMode(ColorMode colorMode);
void CBCGPChartSurfaceSeries::SetSurfaceOpacity(double dblOpacity);
void CBCGPChartSurfaceSeries::EnableFrameTransparency(BOOL bEnable);
const BCGPChartFormatSeries* CBCGPChartSurfaceSeries::GetColors(BCGPSeriesColorsPtr& seriesColors, int nDataPointIndex);
int CBCGPChartSurfaceSeries::AddDataPoint(CBCGPChartDataPoint* pDataPoint);
int CBCGPChartSurfaceSeries::AddDataPoint(const CBCGPChartDataPoint& srcDataPoint);
int CBCGPChartSurfaceSeries::AddDataPoint(double dblY, double dblX, BCGPChartFormatSeries* pDataPointFormat , DWORD_PTR dwUserData);
void CBCGPChartSurfaceSeries::OnCalcScreenPoints(CBCGPGraphicsManager* /*pGM*/, const CBCGPRect& /*rectDiagramArea*/);
void CBCGPChartSurfaceSeries::ClearSurfaceCells();
int __cdecl compare(const void* pPt1, const void* pPt2);
void CBCGPChartSurfaceSeries::CreateSurfaceTriangles(double dblLevelStep);
void CBCGPChartSurfaceSeries::UpdateSurfaceTriangleColors();
void CBCGPChartSurfaceSeries::SetLevelRangeMode(LevelRangeMode rangeMode, double dblMinCustomRangeValue, double dblMaxCustomRangeValue);
void CBCGPChartSurfaceSeries::SetDrawFlat(BOOL bSet, double dblFlatLevel);
void CBCGPChartSurfaceSeries::GetLevelRange(double& dblMinValue, double& dblMaxValue);
int CBCGPChartSurfaceSeries::GetBrushIndex(int nDataPointIndex);
void CBCGPChartSurfaceSeries::LevelIndexToString(int nLevelIndex, CString& strValues);
void CBCGPChartSurfaceSeries::EnableLevelRangeInLegendLabel(BOOL bEnable);
CBCGPBrush* CBCGPChartSurfaceSeries::GetLevelFillBrush(int nIndex);
CBCGPBrush* CBCGPChartSurfaceSeries::GetLevelFillBackBrush(int nIndex);
CBCGPBrush* CBCGPChartSurfaceSeries::GetLevelLineBrush(int nIndex);
CBCGPBrush* CBCGPChartSurfaceSeries::GetLevelLineBackBrush(int nIndex);
void CBCGPChartSurfaceSeries::InitLegendElements();
void CBCGPChartSurfaceSeries::AddLegendElement(const CBCGPRect& rectKey, const CBCGPRect& rectLabel, const CString& strLabel);
void CBCGPChartSurfaceSeries::GetLegendElementRects(int nIndex, CBCGPRect& rectKey, CBCGPRect& rectLabel);
void CBCGPChartSurfaceSeries::GetLegendElementLabel(int nIndex, CString& strLabel);
void CBCGPChartSurfaceSeries::SetLegendElementRects(int nIndex, const CBCGPRect& rectKey, const CBCGPRect& rectLabel);
int CBCGPChartSurfaceSeries::GetLegendElementCount();
void CBCGPChartSurfaceSeries::SetContinuousLegendKey(BOOL bSet);
void CBCGPChartSurfaceSeries::UpdateSeriesColors();
CBCGPChartLongSeries::CBCGPChartLongSeries(CBCGPChartVisualObject* pChartCtrl, int nDataCount, int nGrowBy);
void CBCGPChartLongSeries::SetScatterMode(BOOL bSet/* = TRUE*/, double dblSize/* = 2.0*/);
void CBCGPChartLongSeries::OnScaleRatioChanged(const CBCGPSize& sizeScaleRatioNew, const CBCGPSize& sizeScaleRatioOld);
void CBCGPChartLongSeries::SetSeriesData(double dblY, double dblX, int nIndex);
int CBCGPChartLongSeries::AddDataPoint(CBCGPChartDataPoint* pDataPoint);
int CBCGPChartLongSeries::AddDataPoint(const CString& /*strCategoryName*/, double dblY, BCGPChartFormatSeries* pDataPointFormat, DWORD_PTR dwUserData);
int CBCGPChartLongSeries::AddDataPoint(double dblY, BCGPChartFormatSeries* pDataPointFormat, DWORD_PTR dwUserData);
void CBCGPChartLongSeries::AddDataPoints(const CBCGPDoubleArray& arYValues, CBCGPDoubleArray* pXValues, CBCGPDoubleArray* pY1Values, BOOL bRecalcMinMaxValues);
BOOL CBCGPChartLongSeries::SetDataPointValue(int nDataPointIndex, double dblValue, CBCGPChartData::ComponentIndex ci);
void CBCGPChartLongSeries::RemoveDataPoints(int nStartIdx, int nCount, BOOL bFreeExtra);
void CBCGPChartLongSeries::MoveDataPoints(int nFromIdx, int nToIdx, int nCount);
CBCGPChartValue CBCGPChartLongSeries::GetDataPointValue(int nDataPointIndex, CBCGPChartData::ComponentIndex ci);
const CBCGPChartDataPoint* CBCGPChartLongSeries::GetDataPointAt(int nIndex);
void CBCGPChartLongSeries::SetDataPointCount(int nCount);
void CBCGPChartLongSeries::OnCalcScreenPoints(CBCGPGraphicsManager* pGM, const CBCGPRect& rectDiagramArea);
CBCGPChartHistoricalLineSeries::CBCGPChartHistoricalLineSeries(CBCGPChartVisualObject* pRelatedChart, int nHistoryDepth, double dblDefaultY);
void CBCGPChartHistoricalLineSeries::CommonInit();
void CBCGPChartHistoricalLineSeries::SetHistoryDepth(int nDepth, BOOL bInitY, double dblDefaultY);
void CBCGPChartHistoricalLineSeries::RemoveAllDataPoints();
int CBCGPChartHistoricalLineSeries::AddDataPoint(const CString& /*strCategoryName*/, double dblY, BCGPChartFormatSeries* pDataPointFormat, DWORD_PTR dwUserData);
int CBCGPChartHistoricalLineSeries::AddDataPoint(double dblY, double /*dblX*/, BCGPChartFormatSeries* pDataPointFormat, DWORD_PTR dwUserData);
int CBCGPChartHistoricalLineSeries::AddDataPoint(double dblY, BCGPChartFormatSeries* /*pDataPointFormat*/, DWORD_PTR /*dwUserData*/);
int CBCGPChartHistoricalLineSeries::AddDataPoint(CBCGPChartDataPoint* pDataPoint);
void CBCGPChartHistoricalLineSeries::AddDataPoints(const CBCGPDoubleArray& arYValues, CBCGPDoubleArray* /*pXValues*/, CBCGPDoubleArray* /*pY1Values*/, BOOL /*bRecalcMinMaxValues*/);
void CBCGPChartHistoricalLineSeries::SetSeriesData(double dblY, double /*dblX*/, int /*nIndex*/);
void CBCGPChartHistoricalLineSeries::SetSeriesData(double dblY, BOOL bRedraw);
void CBCGPChartHistoricalLineSeries::SetRelatedAxes(CBCGPChartAxis* pXAxis, CBCGPChartAxis* pYAxis, CBCGPChartAxis* pZAxis);
void CBCGPChartHistoricalLineSeries::SetRelatedAxis(CBCGPChartAxis* pAxis, CBCGPChartSeries::AxisIndex axisIndex);
void CBCGPChartHistoricalLineSeries::EnableHistoryMode(BOOL bEnable, int nHistoryDepth, BOOL bReverseOrder, BOOL bSetDefaultValue, double dblDefaultYValue);
CBCGPChartBubbleSeries::CBCGPChartBubbleSeries();
CBCGPChartBubbleSeries::CBCGPChartBubbleSeries(CBCGPChartVisualObject* pChartCtrl);
void CBCGPChartBubbleSeries::CommonInit();
void CBCGPChartBubbleSeries::SetBubbleScale(double dblScale);
void CBCGPChartBubbleSeries::SetMinMaxValues(const CBCGPChartValue& val, CBCGPChartData::ComponentIndex ci, int nDataPointIndex);
void CBCGPChartBubbleSeries::OnCalcScreenPoints(CBCGPGraphicsManager* /*pGM*/, const CBCGPRect& /*rectDiagramArea*/);
BOOL CBCGPChartBubbleSeries::CanIncludeDataPointToLegend(int nDataPointIndex);
void CBCGPChartPieSeries::CommonInit();
CBCGPBrush::BCGP_GRADIENT_TYPE CBCGPChartPieSeries::GetSeriesFillGradientType();
void CBCGPChartPieSeries::SetGroupSmallerSlices(BOOL bSet, double dblMinPercent/* = 5.0*/, BOOL bGroupInGegend/* = FALSE*/, const CString& strLabel/* = _T("Others (< 1%);
void CBCGPChartPieSeries::OnCalcScreenPoints(CBCGPGraphicsManager* pGM, const CBCGPRect& /*rectDiagramArea*/);
BOOL CBCGPChartPieSeries::GetDataPointLabelText(int nDataPointIndex, BCGPChartDataLabelOptions::LabelContent content, CString& strDPLabel);
void CBCGPChartPieSeries::OnBeforeChangeType();
void CBCGPChartPieSeries::SetHeightPercent(int nPercent);
void CBCGPChartPieSeries::SetPieAngle(double dblAngle);
void CBCGPChartPieSeries::SetPieExplosion(double dblExplosion);
void CBCGPChartPieSeries::SetDataPointPieExplosion(double dblExplosion, int nDataPontIndex);
double CBCGPChartPieSeries::GetDataPointPieExplosion(int nDataPointIndex);
CBCGPChartValue CBCGPChartPieSeries::GetDataPointValue(int nDataPointIndex, CBCGPChartData::ComponentIndex ci);
BOOL CBCGPChartPieSeries::CanIncludeDataPointToLegend(int nDataPointIndex);
BOOL CBCGPChartPieSeries::HitTestDataPoint(const CBCGPPoint& pt, BCGPChartHitInfo* pHitInfo);
BOOL CBCGPChartPieSeries::OnGetDataPointTooltip(int nDataPointIndex, CString& strTooltip, CString& strTooltipDescr);
void CBCGPChartDoughnutSeries::SetDoughnutPercent(int nPercent);
CBCGPChartPyramidSeries::CBCGPChartPyramidSeries(CBCGPChartVisualObject* pChartCtrl, BCGPChartCategory category);
void CBCGPChartPyramidSeries::CommonInit();
CBCGPBrush::BCGP_GRADIENT_TYPE CBCGPChartPyramidSeries::GetSeriesFillGradientType();
void CBCGPChartPyramidSeries::SetGap(int nGap);
void CBCGPChartPyramidSeries::SetDepthPercent(int nDepthPercent);
void CBCGPChartPyramidSeries::SetRotation(double dblRotation);
void CBCGPChartPyramidSeries::SetCircularBase(BOOL bIsCircularBase);
void CBCGPChartPyramidSeries::OnBeforeChangeType();
CBCGPChartValue CBCGPChartPyramidSeries::GetDataPointValue(int nDataPointIndex, CBCGPChartData::ComponentIndex ci);
BOOL CBCGPChartPyramidSeries::CanIncludeDataPointToLegend(int nDataPointIndex);
void CBCGPChartPyramidSeries::SortDataPoints(int nScreenPointIndex, CArray<CBCGPChartDataPoint*, CBCGPChartDataPoint*>& arDPSorted);
void CBCGPChartPyramidSeries::OnCalcScreenPoints(CBCGPGraphicsManager* pGM, const CBCGPRect& /*rectDiagramArea*/);
CBCGPChartFunnelSeries::CBCGPChartFunnelSeries(CBCGPChartVisualObject* pChartCtrl, BCGPChartCategory category);
void CBCGPChartFunnelSeries::CommonInit();
void CBCGPChartFunnelSeries::SetNeckHeightInPercents(double dblHeight);
void CBCGPChartFunnelSeries::SetNeckHeightInChartValues(double dblValue);
void CBCGPChartFunnelSeries::SetNeckWidth(int nWidth);
void CBCGPChartFunnelSeries::OnCalcScreenPoints(CBCGPGraphicsManager* pGM, const CBCGPRect& /*rectDiagramArea*/);
CBCGPBaseChartStockSeries::CBCGPBaseChartStockSeries();
CBCGPBaseChartStockSeries::CBCGPBaseChartStockSeries(CBCGPChartVisualObject* pChartCtrl, StockSeriesType seriesType);
CBCGPChartStockData CBCGPBaseChartStockSeries::GetStockDataAt(int nDataPointIndex);
CBCGPChartValue CBCGPBaseChartStockSeries::GetDataPointValue(int nDataPointIndex, CBCGPChartData::ComponentIndex ci);
int CBCGPBaseChartStockSeries::GetDataPointCount();
const CBCGPChartDataPoint* CBCGPBaseChartStockSeries::GetDataPointAt(int nIndex);
const CBCGPStockDataArray& CBCGPBaseChartStockSeries::GetStockData();
void CBCGPChartStockSeries::CommonInit();
CBCGPChartStockSeries::~CBCGPChartStockSeries();
CBCGPChartStockData CBCGPChartStockSeries::GetStockDataAt(int nDataPointIndex);
BOOL CBCGPChartStockSeries::OnGetDataPointTooltip(int nDataPointIndex, CString& strTooltip, CString& strTooltipDescr);
CBCGPBaseChartStockSeries* CBCGPChartStockSeries::GetChildSeries(int nIdx);
void CBCGPChartStockSeries::OnScaleRatioChanged(const CBCGPSize& sizeScaleRatioNew, const CBCGPSize& sizeScaleRatioOld);
void CBCGPChartStockSeries::EnableHistoryMode(BOOL bEnable, int nHistoryDepth, BOOL bReverseOrder, BOOL /*bSetDefaultValue*/, double /*dblDefaultYValue*/);
void CBCGPChartStockSeries::ResizeDataPointArray(int nNewSize);
void CBCGPChartStockSeries::RecalcMinMaxValues();
CBCGPChartValue CBCGPChartStockSeries::GetMinValue(CBCGPChartData::ComponentIndex ci);
CBCGPChartValue CBCGPChartStockSeries::GetMaxValue(CBCGPChartData::ComponentIndex ci);
void CBCGPChartStockSeries::ClearMinMaxValues();
void CBCGPChartStockSeries::SetCustomStockValueCallback(BCGPCHART_STOCK_CALLBACK pfn, BOOL bRedraw);
void CBCGPChartStockSeries::OnCalcScreenPoints(CBCGPGraphicsManager* pGM, const CBCGPRect& rectDiagramArea);
void CBCGPChartStockSeries::OnCalcScreenPointsSimple(CBCGPGraphicsManager* pGM, const CBCGPRect& rectDiagramArea);
CBCGPPoint CBCGPChartStockSeries::GetDataPointScreenPoint(int nDataPointIndex, int nScreenPointIndex);
void CBCGPChartStockSeries::SetRelatedAxes(CBCGPChartAxis* pXAxis, CBCGPChartAxis* pYAxis, CBCGPChartAxis* pZAxis);
void CBCGPChartStockSeries::SetRelatedAxis(CBCGPChartAxis* pAxis, CBCGPChartSeries::AxisIndex axisIndex);
void CBCGPChartStockSeries::SetIndexMode(BOOL bSet);
void CBCGPChartStockSeries::SetStockSeriesType(CBCGPBaseChartStockSeries::StockSeriesType type, BOOL bRedraw);
void CBCGPChartStockSeries::SetTreatNulls(CBCGPChartSeries::TreatNulls tn, BOOL /*bRecalcMinMax*/);
void CBCGPChartStockSeries::AddData(const CBCGPChartStockData& data);
void CBCGPChartStockSeries::AddData(const CBCGPStockDataArray& arStockData);
int CBCGPChartStockSeries::AddEmptyDataPoint(const CString& /*strCategoryName*/, DWORD_PTR /*dwUserData*/, BCGPChartFormatSeries* /*pDataPointFormat*/);
int CBCGPChartStockSeries::AddEmptyDataPoint(DWORD_PTR /*dwUserData*/, BCGPChartFormatSeries* /*pDataPointFormat*/);
int CBCGPChartStockSeries::AddEmptyDataPoint(double dblX, DWORD_PTR /*dwUserData*/, BCGPChartFormatSeries* /*pDataPointFormat*/);
CBCGPChartBarSeries::CBCGPChartBarSeries();
void CBCGPChartBarSeries::CommonInit();
int CBCGPChartBarSeries::GetColumnOverlapPercent();
int CBCGPChartBarSeries::GetColumnDistancePercent();
void CBCGPChartBarSeries::SetColumnDistancePercent(int nPercent);
void CBCGPChartBarSeries::SetColumnOverlapPercent(int nPercent);
void CBCGPChartBarSeries::CalcNumberOfSeriesOnAxis();
void CBCGPChartBarSeries::CopyFrom(const CBCGPChartSeries& src);
void CBCGPChartBarSeries::SetRelatedAxis(CBCGPChartAxis* pAxis, CBCGPChartSeries::AxisIndex axisIndex);
CBCGPBrush::BCGP_GRADIENT_TYPE CBCGPChartBarSeries::GetSeriesFillGradientType();
int CBCGPChartBarSeries::GetDefaultShadowAngle();
CBCGPChartHistogramSeries::CBCGPChartHistogramSeries();
CBCGPChartHistogramSeries::CBCGPChartHistogramSeries(CBCGPChartVisualObject* pChartCtrl, BCGPChartType chartType);
void CBCGPChartHistogramSeries::CommonInit();
void CBCGPChartHistogramSeries::ClearMinMaxValues();
void CBCGPChartHistogramSeries::SetOrigin(double dblValue, BOOL bRedraw);
CBCGPChartPolarSeries::CBCGPChartPolarSeries(CBCGPChartVisualObject* pChartCtrl);
CBCGPChartPolarSeries::~CBCGPChartPolarSeries();
void CBCGPChartPolarSeries::CommonInit();
void CBCGPChartPolarSeries::ShowOnPrimaryAxis(BOOL /*bPrimary*/);
void CBCGPChartPolarSeries::MakeRose(int nPoints, BOOL bFillArea);
CBCGPPoint CBCGPChartPolarSeries::ScreenPointFromChartData(const CBCGPChartData& data, int nDataPointIndex);
void CBCGPChartPolarSeries::OnCalcScreenPoints(CBCGPGraphicsManager* /*pGM*/, const CBCGPRect& /*rectDiagramArea*/);
CBCGPChartTernarySeries::CBCGPChartTernarySeries();
CBCGPChartTernarySeries::CBCGPChartTernarySeries(CBCGPChartVisualObject* pChartCtrl);
CBCGPChartTernarySeries::~CBCGPChartTernarySeries();
void CBCGPChartTernarySeries::CommonInit();
void CBCGPChartTernarySeries::ShowOnPrimaryAxis(BOOL /*bPrimary*/);
CBCGPPoint CBCGPChartTernarySeries::ScreenPointFromChartData(const CBCGPChartData& data, int /*nDataPointIndex*/);
void CBCGPChartTernarySeries::OnCalcScreenPoints(CBCGPGraphicsManager* /*pGM*/, const CBCGPRect& /*rectDiagramArea*/);
void CBCGPChartTernarySeries::SetMinMaxValues(const CBCGPChartValue& val, CBCGPChartData::ComponentIndex ci, int nDataPointIndex);
CBCGPChartValue CBCGPChartTernarySeries::GetMinPercentage(CBCGPChartData::ComponentIndex ci);
CBCGPChartValue CBCGPChartTernarySeries::GetMaxPercentage(CBCGPChartData::ComponentIndex ci);
void CBCGPChartTernarySeries::SetMinMaxPercentage(double dblValue, CBCGPChartData::ComponentIndex ci);
double CBCGPChartTernarySeries::GetDataPointComponentPercent(int nDataPointIndex, CBCGPChartData::ComponentIndex ci);
BOOL CBCGPChartTernarySeries::OnGetDataPointTooltip(int nDataPointIndex, CString& strTooltip, CString& strTooltipDescr);
| 3bc957ec6893d25a13af56de11d55352fe8728f8a683443357852e1428e2b504 | 142 |
|
sufism | qucs_chs | qucs/qucs_actions.cpp | QucsApp::slotInsertPort |
void QucsApp::slotInsertPort(bool on)
{
editText->setHidden(true);
MouseReleaseAction = 0;
MouseDoubleClickAction = 0;
if(!on) {
MouseMoveAction = 0;
MousePressAction = 0;
activeAction = 0;
return;
}
if(activeAction) {
activeAction->blockSignals(true);
activeAction->setOn(false);
activeAction->blockSignals(false);
}
activeAction = insPort;
if(view->selElem)
delete view->selElem;
view->selElem = new SubCirPort();
Schematic *Doc = (Schematic*)DocumentTab->currentPage();
if(view->drawn) Doc->viewport()->update();
view->drawn = false;
MouseMoveAction = &MouseActions::MMoveElement;
MousePressAction = &MouseActions::MPressElement;
} |
void QucsApp::slotOnGrid(bool on);
void QucsApp::slotEditRotate(bool on);
void QucsApp::slotEditMirrorX(bool on);
void QucsApp::slotEditMirrorY(bool on);
void QucsApp::slotEditActivate (bool on);
void QucsApp::slotEditDelete(bool on);
void QucsApp::slotSetWire(bool on);
void QucsApp::slotInsertLabel(bool on);
void QucsApp::slotSetMarker(bool on);
void QucsApp::slotMoveText(bool on);
void QucsApp::slotZoomIn(bool on);
void QucsApp::slotSelect(bool on);
void QucsApp::slotEditPaste(bool on);
void QucsApp::slotInsertEntity ();
void QucsApp::slotInsertEquation(bool on);
void QucsApp::slotInsertGround(bool on);
void QucsApp::slotEditUndo();
void QucsApp::slotEditRedo();
void QucsApp::slotAlignTop();
void QucsApp::slotAlignBottom();
void QucsApp::slotAlignLeft();
void QucsApp::slotAlignRight();
void QucsApp::slotDistribHoriz();
void QucsApp::slotDistribVert();
void QucsApp::slotCenterHorizontal();
void QucsApp::slotCenterVertical();
void QucsApp::slotSelectAll();
void QucsApp::slotSelectMarker();
void QucsApp::editFile(const QString& File);
void QucsApp::slotShowLastMsg();
void QucsApp::slotShowLastNetlist();
void QucsApp::slotCallEditor();
void QucsApp::slotCallFilter();
void QucsApp::slotCallLine();
void QucsApp::slotCallLibrary();
void QucsApp::slotCallMatch();
void QucsApp::slotCallAtt();
void QucsApp::slotHelpIndex();
void QucsApp::slotGettingStarted();
void QucsApp::showHTML(const QString& Page);
void QucsApp::slotEditFind();
void QucsApp::slotEditFindAgain();
void QucsApp::slotChangeProps();
void QucsApp::slotAddToProject();
void QucsApp::slotCursorLeft();
void QucsApp::slotCursorRight();
void QucsApp::slotCursorUp();
void QucsApp::slotCursorDown();
void QucsApp::slotApplyCompText();
void QucsApp::slotResizePropEdit(const QString& t);
void QucsApp::slotCreateLib();
void QucsApp::slotImportData();
void QucsApp::slotExportGraphAsCsv();
void QucsApp::slotCreatePackage();
void QucsApp::slotExtractPackage();
| e326882973b59a8b4aad20be655bb793744044f63cea4f7493da4ed476f1d997 | 720 |
|
Edimartin | edk-source | edk/tiles/TileSet2D.cpp | edk::tiles::TileSet2D::drawTileSelectionInWorld |
void edk::tiles::TileSet2D::drawTileSelectionInWorld(edk::vec2f32 position,
edk::float32 angle,
edk::size2f32 size
){
this->tileTemp.setPosition(position.x,position.y);
this->tileTemp.drawSelection(angle,size);
} |
edk::tiles::TileSet2D::TileSet2D();
edk::tiles::TileSet2D::~TileSet2D();
void edk::tiles::TileSet2D::deleteTiles();
bool edk::tiles::TileSet2D::deleteTile(edk::uint32 position);
bool edk::tiles::TileSet2D::deleteTilePosition(edk::uint32 position);
bool edk::tiles::TileSet2D::haveTile(edk::uint32 position);
bool edk::tiles::TileSet2D::setSizeOfTiles(edk::size2f32 size);
bool edk::tiles::TileSet2D::setSizeOfTiles(edk::float32 width,edk::float32 height);
edk::size2f32 edk::tiles::TileSet2D::getSizeOfTiles();
edk::uint32 edk::tiles::TileSet2D::getTileSize();
edk::uint32 edk::tiles::TileSet2D::newTile(const edk::char8* image,edk::uint32 filter,edk::color4f32 color);
edk::uint32 edk::tiles::TileSet2D::newTile(edk::char8* image,edk::uint32 filter,edk::color4f32 color);
edk::uint32 edk::tiles::TileSet2D::newTile(edk::color4f32 color);
edk::uint32 edk::tiles::TileSet2D::newTileFromMemory(const edk::char8* name,edk::uint8* image,edk::uint32 size,edk::uint32 filter,edk::color4f32 color);
edk::uint32 edk::tiles::TileSet2D::newTileFromMemory(edk::char8* name,edk::uint8* image,edk::uint32 size,edk::uint32 filter,edk::color4f32 color);
edk::uint32 edk::tiles::TileSet2D::newTileFromPack(edk::pack::FilePackage* pack,const edk::char8* image,edk::uint32 filter,edk::color4f32 color);
edk::uint32 edk::tiles::TileSet2D::newTileFromPack(edk::pack::FilePackage* pack,edk::char8* image,edk::uint32 filter,edk::color4f32 color);
edk::uint32 edk::tiles::TileSet2D::newTileIsometric(const edk::char8* image,edk::uint32 filter,edk::color4f32 color);
edk::uint32 edk::tiles::TileSet2D::newTileIsometric(edk::char8* image,edk::uint32 filter,edk::color4f32 color);
edk::uint32 edk::tiles::TileSet2D::newTileIsometric(edk::color4f32 color);
edk::uint32 edk::tiles::TileSet2D::newTileIsometricFromMemory(const edk::char8* name,edk::uint8* image,edk::uint32 size,edk::uint32 filter,edk::color4f32 color);
edk::uint32 edk::tiles::TileSet2D::newTileIsometricFromMemory(edk::char8* name,edk::uint8* image,edk::uint32 size,edk::uint32 filter,edk::color4f32 color);
edk::uint32 edk::tiles::TileSet2D::newTileIsometricFromPack(edk::pack::FilePackage* pack,const edk::char8* image,edk::uint32 filter,edk::color4f32 color);
edk::uint32 edk::tiles::TileSet2D::newTileIsometricFromPack(edk::pack::FilePackage* pack,edk::char8* image,edk::uint32 filter,edk::color4f32 color);
edk::uint32 edk::tiles::TileSet2D::newTileIsometricFlat(const edk::char8* image,edk::uint32 filter,edk::color4f32 color);
edk::uint32 edk::tiles::TileSet2D::newTileIsometricFlat(edk::char8* image,edk::uint32 filter,edk::color4f32 color);
edk::uint32 edk::tiles::TileSet2D::newTileIsometricFlat(edk::color4f32 color);
edk::uint32 edk::tiles::TileSet2D::newTileIsometricFlatFromMemory(const edk::char8* name,edk::uint8* image,edk::uint32 size,edk::uint32 filter,edk::color4f32 color);
edk::uint32 edk::tiles::TileSet2D::newTileIsometricFlatFromMemory(edk::char8* name,edk::uint8* image,edk::uint32 size,edk::uint32 filter,edk::color4f32 color);
edk::uint32 edk::tiles::TileSet2D::newTileIsometricFlatFromPack(edk::pack::FilePackage* pack,const edk::char8* image,edk::uint32 filter,edk::color4f32 color);
edk::uint32 edk::tiles::TileSet2D::newTileIsometricFlatFromPack(edk::pack::FilePackage* pack,edk::char8* image,edk::uint32 filter,edk::color4f32 color);
bool edk::tiles::TileSet2D::setTileFramesUV(edk::uint32 tile,edk::vec2ui32 frames);
bool edk::tiles::TileSet2D::setTileFramesUV(edk::uint32 tile,edk::uint32 x,edk::uint32 y);
bool edk::tiles::TileSet2D::setTileFrameUV(edk::uint32 tile,edk::vec2ui32 frame);
bool edk::tiles::TileSet2D::setTileFrameUV(edk::uint32 tile,edk::uint32 x,edk::uint32 y);
bool edk::tiles::TileSet2D::setTileFrameUVinPosition(edk::uint32 tile,edk::uint32 position);
bool edk::tiles::TileSet2D::addDrawCallback(edk::uint32 tile,edk::tiles::DrawTile2DCallback* callback);
bool edk::tiles::TileSet2D::removeDrawCallback(edk::uint32 tile,edk::tiles::DrawTile2DCallback* callback);
bool edk::tiles::TileSet2D::runStartDraw(edk::uint32 id,edk::vec2ui32 position,edk::vec2f32 worldPosition);
bool edk::tiles::TileSet2D::runEndDraw(edk::uint32 id,edk::vec2ui32 position,edk::vec2f32 worldPosition);
bool edk::tiles::TileSet2D::addFrameInterpolation(edk::uint32 tile,edk::float32 second,edk::float32 frame);
edk::uint32 edk::tiles::TileSet2D::getInterpolationSize(edk::uint32 tile);
bool edk::tiles::TileSet2D::cleanFrames(edk::uint32 tile);
bool edk::tiles::TileSet2D::playForward(edk::uint32 tile);
bool edk::tiles::TileSet2D::playForwardIn(edk::uint32 tile,edk::float32 second);
bool edk::tiles::TileSet2D::playRewind(edk::uint32 tile);
bool edk::tiles::TileSet2D::playRewindIn(edk::uint32 tile,edk::float32 second);
bool edk::tiles::TileSet2D::pause(edk::uint32 tile);
bool edk::tiles::TileSet2D::stop(edk::uint32 tile);
bool edk::tiles::TileSet2D::setLoop(edk::uint32 tile,bool loop);
bool edk::tiles::TileSet2D::loopOn(edk::uint32 tile);
bool edk::tiles::TileSet2D::loopOff(edk::uint32 tile);
edk::float32 edk::tiles::TileSet2D::getSecond(edk::uint32 tile);
bool edk::tiles::TileSet2D::isPlaying(edk::uint32 tile);
bool edk::tiles::TileSet2D::isPlayingName(edk::uint32 tile,const edk::char8* name);
bool edk::tiles::TileSet2D::isPlayingName(edk::uint32 tile,edk::char8* name);
bool edk::tiles::TileSet2D::addAnimationName(edk::uint32 tile,const edk::char8* name, edk::float32 start,edk::float32 end);
bool edk::tiles::TileSet2D::addAnimationName(edk::uint32 tile,edk::char8* name, edk::float32 start,edk::float32 end);
bool edk::tiles::TileSet2D::haveAnimationName(edk::uint32 tile,const edk::char8* name);
bool edk::tiles::TileSet2D::haveAnimationName(edk::uint32 tile,edk::char8* name);
bool edk::tiles::TileSet2D::playNameForward(edk::uint32 tile,const edk::char8* name);
bool edk::tiles::TileSet2D::playNameForward(edk::uint32 tile,edk::char8* name);
bool edk::tiles::TileSet2D::playNameRewind(edk::uint32 tile,const edk::char8* name);
bool edk::tiles::TileSet2D::playNameRewind(edk::uint32 tile,edk::char8* name);
bool edk::tiles::TileSet2D::removeAnimationName(edk::uint32 tile,const edk::char8* name);
bool edk::tiles::TileSet2D::removeAnimationName(edk::uint32 tile,edk::char8* name);
bool edk::tiles::TileSet2D::setCurveX(edk::uint32 tile,edk::uint32 position);
bool edk::tiles::TileSet2D::setNotCurveX(edk::uint32 tile,edk::uint32 position);
bool edk::tiles::TileSet2D::getIsCurveX(edk::uint32 tile,edk::uint32 position);
bool edk::tiles::TileSet2D::setCurveP1X(edk::uint32 tile,edk::uint32 position,edk::float32 second,edk::float32 x);
bool edk::tiles::TileSet2D::setCurveP2X(edk::uint32 tile,edk::uint32 position,edk::float32 second,edk::float32 x);
bool edk::tiles::TileSet2D::updateAnimations(edk::uint32 tile);
bool edk::tiles::TileSet2D::updateAnimations(edk::uint32 tile,edk::float32 seconds);
bool edk::tiles::TileSet2D::updateAnimations();
bool edk::tiles::TileSet2D::updateAnimations(edk::float32 seconds);
bool edk::tiles::TileSet2D::setTilePhysics(edk::uint32 tile,edk::physics::bodyType type);
bool edk::tiles::TileSet2D::addTilePhysicsPolygon(edk::uint32 tile,edk::shape::Polygon2D poly);
bool edk::tiles::TileSet2D::cleanTilePhysicsPolygons(edk::uint32 tile);
edk::physics2D::PhysicsMesh2D* edk::tiles::TileSet2D::getTilePhysicsMeshPointer(edk::uint32 tile);
edk::shape::Mesh2D* edk::tiles::TileSet2D::getTileMeshPointer(edk::uint32 tile);
bool edk::tiles::TileSet2D::deleteTilePhysics(edk::uint32 tile);
edk::physics2D::PhysicObject2D* edk::tiles::TileSet2D::getTilePhysicsObject(edk::uint32 tile);
bool edk::tiles::TileSet2D::isTilePhysics(edk::uint32 tile);
bool edk::tiles::TileSet2D::printTile(edk::uint32 tile);
bool edk::tiles::TileSet2D::writeToXML(edk::XML* xml,edk::uint32 id);
bool edk::tiles::TileSet2D::readFromXML(edk::XML* xml,edk::uint32 id);
bool edk::tiles::TileSet2D::readFromXMLFromPack(edk::pack::FilePackage* pack,edk::XML* xml,edk::uint32 id);
| 9068e118b5f018fe92bf4278733e03ee0d798ed0de3ad0b2792bf5e176222ffd | 380 |
|
mashengchen | incubator-trafodion | core/sqf/src/seabed/src/stream.cpp | SB_Trans::Trans_Stream::finish_open |
void SB_Trans::Trans_Stream::finish_open(MS_Md_Type *pp_md) {
const char *WHERE = "Trans_Stream::finish_open";
if (gv_ms_trace)
trace_where_printf(WHERE,
"stream=%p %s, processing open md (msgid=%d, md=%p), setting reply-done=1\n",
pfp(this), ia_stream_name,
pp_md->iv_link.iv_id.i, pfp(pp_md));
iv_req_map.remove(pp_md->iv_link.iv_id.i);
pp_md->iv_md_state = MD_STATE_OPEN_FIN;
pp_md->iv_reply_done = true;
pp_md->iv_cv.signal(true);
} |
static RM_Node *new_RM_Node(int pv_reqid, int pv_msgid);
static void thread_key_dtor(void *pp_buf);
SB_Trans::Stream_Base::Stream_Base();
SB_Trans::Stream_Base::~Stream_Base();
SB_Trans::Trans_Stream::Trans_Stream(int pv_stream_type);
SB_Trans::Trans_Stream::~Trans_Stream();
void SB_Trans::Trans_Stream::add_reply_piggyback(MS_Md_Type *pp_md);
void SB_Trans::Trans_Stream::add_stream_acc_count(int pv_val);
void SB_Trans::Trans_Stream::add_stream_con_count(int pv_val);
void SB_Trans::Trans_Stream::add_stream_for_close();
void SB_Trans::Trans_Stream::close_nidpid_streams(bool pv_lock);
void SB_Trans::Trans_Stream::delete_streams(bool pv_ref_zero);
void SB_Trans::Trans_Stream::finish_abandon(MS_Md_Type *pp_md);
void SB_Trans::Trans_Stream::finish_close(MS_Md_Type *pp_md);
void SB_Trans::Trans_Stream::finish_conn(MS_Md_Type *pp_md);
void SB_Trans::Trans_Stream::finish_writereads(short pv_fserr);
bool SB_Trans::Trans_Stream::error_of_generation(int pv_generation);
void SB_Trans::Trans_Stream::error_sync();
void SB_Trans::Trans_Stream::free_reply_md(MS_Md_Type *pp_md);
void SB_Trans::Trans_Stream::get_hdr_type(int pv_hdr_type, char *pp_hdr_type);
SB_TML_Type *SB_Trans::Trans_Stream::get_idle_timer_link();
SB_Trans::Trans_Stream *SB_Trans::Trans_Stream::get_mon_stream();
char *SB_Trans::Trans_Stream::get_name();
int SB_Trans::Trans_Stream::get_oid();
int SB_Trans::Trans_Stream::get_open_nid();
int SB_Trans::Trans_Stream::get_open_pid();
int SB_Trans::Trans_Stream::get_remote_nid();
int SB_Trans::Trans_Stream::get_remote_pid();
SB_Verif_Type SB_Trans::Trans_Stream::get_remote_verif();
bool SB_Trans::Trans_Stream::get_shutdown();
int SB_Trans::Trans_Stream::get_stream_acc_count();
int SB_Trans::Trans_Stream::get_stream_acc_hi_count();
int SB_Trans::Trans_Stream::get_stream_con_count();
int SB_Trans::Trans_Stream::get_stream_con_hi_count();
int SB_Trans::Trans_Stream::get_stream_total_count();
int SB_Trans::Trans_Stream::get_stream_total_hi_count();
bool SB_Trans::Trans_Stream::get_thread_marker();
bool SB_Trans::Trans_Stream::is_self();
void SB_Trans::Trans_Stream::map_nidpid_add_stream(int pv_nid, int pv_pid, bool pv_lock);
SB_LLmap_Enum *SB_Trans::Trans_Stream::map_nidpid_keys();
void SB_Trans::Trans_Stream::map_nidpid_lock();
int SB_Trans::Trans_Stream::map_nidpid_trylock();
bool SB_Trans::Trans_Stream::map_nidpid_remove(bool pv_lock);
int SB_Trans::Trans_Stream::map_nidpid_size();
void SB_Trans::Trans_Stream::map_nidpid_unlock();
int SB_Trans::Trans_Stream::md_ref_dec();
int SB_Trans::Trans_Stream::md_ref_get();
void SB_Trans::Trans_Stream::md_ref_inc();
void SB_Trans::Trans_Stream::md_ref_set(int pv_val);
bool SB_Trans::Trans_Stream::post_mon_messages_get();
void SB_Trans::Trans_Stream::post_mon_messages_set(bool pv_post_mon_messages);
void SB_Trans::Trans_Stream::post_mon_mutex_lock();
void SB_Trans::Trans_Stream::post_mon_mutex_unlock();
int SB_Trans::Trans_Stream::ref_dec(const char *pp_where, void *pp_referee);
int SB_Trans::Trans_Stream::ref_get();
int SB_Trans::Trans_Stream::ref_inc(const char *pp_where, void *pp_referee);
void SB_Trans::Trans_Stream::ref_set(int pv_val);
bool SB_Trans::Trans_Stream::remove_comp_q(MS_Md_Type *pp_md);
bool SB_Trans::Trans_Stream::remove_comp_q_static(MS_Md_Type *pp_md);
bool SB_Trans::Trans_Stream::remove_recv_q(MS_Md_Type *pp_md);
MS_Md_Type *SB_Trans::Trans_Stream::remove_reply_piggyback();
void SB_Trans::Trans_Stream::send_close_ack(MS_Md_Type *pp_md, int pv_reqid);
void SB_Trans::Trans_Stream::send_close_ind();
void SB_Trans::Trans_Stream::send_conn_ack(MS_Md_Type *pp_md, int pv_reqid);
void SB_Trans::Trans_Stream::send_open_ack(MS_Md_Type *pp_md, int pv_reqid);
void SB_Trans::Trans_Stream::send_reply_nack(MS_Md_Type *pp_md, int pv_reqid);
void SB_Trans::Trans_Stream::set_mon_stream(Trans_Stream *pp_stream);
void SB_Trans::Trans_Stream::set_pname(const char *pp_pname);
void SB_Trans::Trans_Stream::set_prog(const char *pp_prog);
void SB_Trans::Trans_Stream::set_stream_name();
void SB_Trans::Trans_Stream::set_thread_marker(bool pv_marker);
void SB_Trans::Trans_Stream::set_shutdown(bool pv_shutdown);
void SB_Trans::Trans_Stream::trace_close_del_q(const char *pp_where);
void SB_Trans::Trans_Stream::wait_rep_done(MS_Md_Type *pp_md);
int SB_Trans::Trans_Stream::wait_req_done(MS_Md_Type *pp_md);
int SB_Trans::Trans_Stream::wait_req_done_static(MS_Md_Type *pp_md);
const char *sb_print_stream_md_state(int pv_state);
char *sb_stream_get_name(MS_Md_Type *pp_md);
| 0c88a135449cee0c0d137c6b0b1e91d7f06fb3569073a01424d2f156a5a29e21 | 573 |
|
fuzzylite | fuzzylite | fuzzylite/src/term/Activated.cpp | Activated::setDegree | void Activated::setDegree(scalar degree) {
this->_degree = degree;
} | Activated::Activated(const Term* term, scalar degree, const TNorm* implication);
std::string Activated::className();
Complexity Activated::complexity();
scalar Activated::membership(scalar x);
std::string Activated::parameters();
void Activated::configure(const std::string& parameters);
std::string Activated::toString();
void Activated::setTerm(const Term* term);
const Term* Activated::getTerm();
scalar Activated::getDegree();
void Activated::setImplication(const TNorm* implication);
const TNorm* Activated::getImplication();
Activated* Activated::clone();
| 36335ad26713caf7b0bfd850b4bb6645e7b6f66f204e859bbf5a4fb443d1aee3 | 81 |
|
j0r1 | JRTPLIB | android_app/crossAnroid/final/jrtplib3/rtptcptransmitter.cpp | RTPTCPTransmitter::DeleteFromIgnoreList |
int RTPTCPTransmitter::DeleteFromIgnoreList(const RTPAddress &)
{
return ERR_RTP_TCPTRANS_RECEIVEMODENOTSUPPORTED;
} |
RTPTCPTransmitter::RTPTCPTransmitter(RTPMemoryManager *mgr);
RTPTCPTransmitter::~RTPTCPTransmitter();
int RTPTCPTransmitter::Init(bool tsafe);
int RTPTCPTransmitter::Create(size_t maximumpacketsize, const RTPTransmissionParams *transparams);
void RTPTCPTransmitter::Destroy();
RTPTransmissionInfo *RTPTCPTransmitter::GetTransmissionInfo();
void RTPTCPTransmitter::DeleteTransmissionInfo(RTPTransmissionInfo *i);
int RTPTCPTransmitter::GetLocalHostName(uint8_t *buffer,size_t *bufferlength);
bool RTPTCPTransmitter::ComesFromThisTransmitter(const RTPAddress *addr);
int RTPTCPTransmitter::Poll();
int RTPTCPTransmitter::WaitForIncomingData(const RTPTime &delay,bool *dataavailable);
int RTPTCPTransmitter::AbortWait();
int RTPTCPTransmitter::SendRTPData(const void *data,size_t len);
int RTPTCPTransmitter::SendRTCPData(const void *data,size_t len);
int RTPTCPTransmitter::AddDestination(const RTPAddress &addr);
int RTPTCPTransmitter::DeleteDestination(const RTPAddress &addr);
void RTPTCPTransmitter::ClearDestinations();
bool RTPTCPTransmitter::SupportsMulticasting();
int RTPTCPTransmitter::JoinMulticastGroup(const RTPAddress &);
int RTPTCPTransmitter::LeaveMulticastGroup(const RTPAddress &);
void RTPTCPTransmitter::LeaveAllMulticastGroups();
int RTPTCPTransmitter::SetReceiveMode(RTPTransmitter::ReceiveMode m);
int RTPTCPTransmitter::AddToIgnoreList(const RTPAddress &);
void RTPTCPTransmitter::ClearIgnoreList();
int RTPTCPTransmitter::AddToAcceptList(const RTPAddress &);
int RTPTCPTransmitter::DeleteFromAcceptList(const RTPAddress &);
void RTPTCPTransmitter::ClearAcceptList();
int RTPTCPTransmitter::SetMaximumPacketSize(size_t s);
bool RTPTCPTransmitter::NewDataAvailable();
RTPRawPacket *RTPTCPTransmitter::GetNextPacket();
void RTPTCPTransmitter::FlushPackets();
int RTPTCPTransmitter::PollSocket(SocketType sock, SocketData &sdata);
void RTPTCPTransmitter::Dump();
int RTPTCPTransmitter::SendRTPRTCPData(const void *data, size_t len);
int RTPTCPTransmitter::ValidateSocket(SocketType);
void RTPTCPTransmitter::ClearDestSockets();
RTPTCPTransmitter::SocketData::SocketData();
void RTPTCPTransmitter::SocketData::Reset();
RTPTCPTransmitter::SocketData::~SocketData();
int RTPTCPTransmitter::SocketData::ProcessAvailableBytes(SocketType sock, int availLen, bool &complete, RTPMemoryManager *pMgr);
| 8ebba48a5a80ae9a07628477dccc1bc88eefc8c1034a4f90e3b2ecbcf0e38624 | 118 |
|
ManaPlus | ManaPlus | src/gui/widgets/widget.cpp | *Widget::callPostInit | idget *Widget::callPostInit(Widget *const widget)
{
if (widget != nullptr)
widget->postInit();
return widget;
}
| idget::Widget(const Widget2 *const widget);
idget::~Widget();
oid Widget::setWidth(const int width);
oid Widget::setHeight(const int height);
oid Widget::setX(const int x);
oid Widget::setY(const int y);
oid Widget::setPosition(const int x, const int y);
oid Widget::setDimension(const Rect& dimension);
ool Widget::isFocused();
oid Widget::setFocusable(const bool focusable);
ool Widget::isFocusable();
oid Widget::requestFocus();
oid Widget::requestMoveToTop();
oid Widget::requestMoveToBottom();
oid Widget::setVisible(Visible visible);
oid Widget::setFocusHandler(FocusHandler *const focusHandler);
oid Widget::addActionListener(ActionListener *const actionListener);
oid Widget::removeActionListener(ActionListener *const actionListener);
oid Widget::addDeathListener(WidgetDeathListener *const deathListener);
oid Widget::removeDeathListener(WidgetDeathListener *const deathListener);
oid Widget::addKeyListener(KeyListener *const keyListener);
oid Widget::removeKeyListener(KeyListener *const keyListener);
oid Widget::addFocusListener(FocusListener *const focusListener);
oid Widget::removeFocusListener(FocusListener *const focusListener);
oid Widget::addMouseListener(MouseListener *const mouseListener);
oid Widget::removeMouseListener(MouseListener *const mouseListener);
oid Widget::addWidgetListener(WidgetListener *const widgetListener);
oid Widget::removeWidgetListener(WidgetListener *const widgetListener);
oid Widget::getAbsolutePosition(int& x, int& y);
ont* Widget::getFont();
oid Widget::setGlobalFont(Font *const font);
oid Widget::setFont(Font *const font);
oid Widget::distributeWindowResizeEvent();
ool Widget::widgetExists(const Widget *const widget);
oid Widget::setSize(const int width, const int height);
ool Widget::isEnabled();
oid Widget::requestModalFocus();
oid Widget::requestModalMouseInputFocus();
oid Widget::releaseModalFocus();
oid Widget::releaseModalMouseInputFocus();
ool Widget::isModalFocused();
ool Widget::isModalMouseInputFocused();
onst std::list<MouseListener*> &Widget::getMouseListeners();
onst std::list<KeyListener*> &Widget::getKeyListeners();
onst std::list<FocusListener*> &Widget::getFocusListeners();
ect Widget::getChildrenArea();
ocusHandler* Widget::getInternalFocusHandler();
oid Widget::setInternalFocusHandler(FocusHandler *const focusHandler);
oid Widget::distributeResizedEvent();
oid Widget::distributeMovedEvent();
oid Widget::distributeHiddenEvent();
oid Widget::distributeActionEvent();
oid Widget::distributeShownEvent();
oid Widget::showPart(const Rect &rectangle);
oid Widget::windowResized();
| ecabd0220674c6e9b8f9ad197376617f67f3e67dbeaf8ae341cc38a959534a60 | 128 |
|
andrewrhyder | epicsqt | framework/widgets/QEPlot/QEPlot.cpp | QEPlot::getXUnit |
QString QEPlot::getXUnit()
{
return axisTitle( xBottom ).text();
} |
QEPlot::QEPlot( QWidget *parent );
QEPlot::QEPlot( const QString &variableNameIn, QWidget *parent );
void QEPlot::setup();
QEPlot::~QEPlot();
QSize QEPlot::sizeHint();
qcaobject::QCaObject* QEPlot::createQcaItem( unsigned int variableIndex );
void QEPlot::establishConnection( unsigned int variableIndex );
void QEPlot::connectionChanged( QCaConnectionInfo& connectionInfo, const unsigned int & variableIndex);
void QEPlot::setPlotData( const double value, QCaAlarmInfo& alarmInfo, QCaDateTime& timestamp, const unsigned int& variableIndex );
void QEPlot::setPlotData( const QVector<double>& values, QCaAlarmInfo& alarmInfo, QCaDateTime&, const unsigned int& variableIndex );
void QEPlot::setPlotDataCommon( const unsigned int variableIndex );
void QEPlot::setalarmInfoCommon( QCaAlarmInfo& alarmInfo, const unsigned int variableIndex );
void QEPlot::regenerateTickXData( const unsigned int variableIndex );
void QEPlot::tickTimeout();
void QEPlot::setCurveColor( const QColor color, const unsigned int variableIndex );
void QEPlot::setDrop( QVariant drop );
QVariant QEPlot::getDrop();
QString QEPlot::copyVariable();
QVariant QEPlot::copyData();
void QEPlot::paste( QVariant v );
void QEPlot::setYMin( double yMinIn );
double QEPlot::getYMin();
void QEPlot::setYMax( double yMaxIn );
double QEPlot::getYMax();
void QEPlot::setAutoScale( bool autoScaleIn );
bool QEPlot::getAutoScale();
void QEPlot::setAxisEnableX( bool axisEnableXIn );
bool QEPlot::getAxisEnableX();
void QEPlot::setAxisEnableY( bool axisEnableYIn );
bool QEPlot::getAxisEnableY();
void QEPlot::setGridEnableMajorX( bool gridEnableMajorXIn );
void QEPlot::setGridEnableMajorY( bool gridEnableMajorYIn );
void QEPlot::setGridEnableMinorX( bool gridEnableMinorXIn );
void QEPlot::setGridEnableMinorY( bool gridEnableMinorYIn );
void QEPlot::setGridEnable();
bool QEPlot::getGridEnableMajorX();
bool QEPlot::getGridEnableMajorY();
bool QEPlot::getGridEnableMinorX();
bool QEPlot::getGridEnableMinorY();
void QEPlot::setGridMajorColor( QColor gridMajorColorIn );
void QEPlot::setGridMinorColor( QColor gridMinorColorIn );
QColor QEPlot::getGridMajorColor();
QColor QEPlot::getGridMinorColor();
QString QEPlot::getTitle();
void QEPlot::setBackgroundColor( QColor backgroundColor );
QColor QEPlot::getBackgroundColor();
void QEPlot::setTraceStyle( QwtPlotCurve::CurveStyle traceStyle, const unsigned int variableIndex );
QwtPlotCurve::CurveStyle QEPlot::getTraceStyle( const unsigned int variableIndex );
void QEPlot::setTraceColor( QColor traceColor, const unsigned int variableIndex );
QColor QEPlot::getTraceColor( const unsigned int variableIndex );
void QEPlot::setTraceLegend( QString traceLegend, const unsigned int variableIndex );
QString QEPlot::getTraceLegend( const unsigned int variableIndex );
void QEPlot::setXUnit( QString xUnit );
void QEPlot::setYUnit( QString yUnit );
QString QEPlot::getYUnit();
void QEPlot::setXStart( double xStartIn );
double QEPlot::getXStart();
void QEPlot::setXIncrement( double xIncrementIn );
double QEPlot::getXIncrement();
void QEPlot::setTimeSpan( unsigned int timeSpanIn );
unsigned int QEPlot::getTimeSpan();
void QEPlot::setTickRate( unsigned int tickRateIn );
unsigned int QEPlot::getTickRate();
| c889697f11c2d92308a39e163b5ee35bbf3928c5711652c43a015981e4e7d651 | 71 |
|
hlzz | dotfiles | graphics/meshlab/src/common/scriptinterface.cpp | ScriptAdapterGenerator::parNames |
QString ScriptAdapterGenerator::parNames(const RichParameterSet& set) const
{
QString names;
int ii;
for(ii = 0;ii < (set.paramList.size() - 1);++ii)
names += set.paramList[ii]->name + ", ";
if (set.paramList.size() != 0)
names += set.paramList[ii]->name;
return names;
} |
QString ScriptAdapterGenerator::parNames( const QString& filterName,MLXMLPluginInfo& xmlInfo );
QString ScriptAdapterGenerator::funCodeGenerator(const QString& filtername,const RichParameterSet& set);
QString ScriptAdapterGenerator::funCodeGenerator( const QString& filterName,MLXMLPluginInfo& xmlInfo );
QString ScriptAdapterGenerator::mergeOptParamsCodeGenerator();
static bool TestCallback(const int , const char* );
QScriptValue PluginInterfaceApplyXML(QScriptContext *context, QScriptEngine *engine, void * param);
QScriptValue IRichParameterSet_prototype_setBool(QScriptContext* c,QScriptEngine* e);
QScriptValue IRichParameterSet_prototype_setInt(QScriptContext* c,QScriptEngine* e);
QScriptValue IRichParameterSet_prototype_setAbsPerc(QScriptContext* c,QScriptEngine* e);
QScriptValue IRichParameterSet_prototype_setFloat( QScriptContext* c,QScriptEngine* e );
QScriptValue IRichParameterSet_ctor(QScriptContext* /*c*/,QScriptEngine* e);
QScriptValue myprint (QScriptContext* sc, QScriptEngine* se);
MeshDocumentSI::MeshDocumentSI( MeshDocument* doc );
Q_INVOKABLE MeshModelSI* MeshDocumentSI::getMesh( int meshId );
Q_INVOKABLE MeshModelSI* MeshDocumentSI::current();
Q_INVOKABLE int MeshDocumentSI::currentId();
Q_INVOKABLE int MeshDocumentSI::setCurrent(const int meshId);
Q_INVOKABLE MeshModelSI* MeshDocumentSI::operator[]( const QString& name );
Q_INVOKABLE MeshModelSI* MeshDocumentSI::getMeshByName( const QString& name );
MeshModelSI::MeshModelSI(MeshModel& meshModel,MeshDocumentSI* parent);
Q_INVOKABLE float MeshModelSI::bboxDiag();
Q_INVOKABLE QVector<float> MeshModelSI::bboxMin();
Q_INVOKABLE QVector<float> MeshModelSI::bboxMax();
Q_INVOKABLE int MeshModelSI::id();
VCGVertexSI::VCGVertexSI( CMeshO::VertexType& v );
Q_INVOKABLE VCGVertexSI* MeshModelSI::v( const int ind );
Q_INVOKABLE ShotSI* MeshModelSI::shot();
Q_INVOKABLE int MeshModelSI::vn();
Q_INVOKABLE int MeshModelSI::fn();
Q_INVOKABLE QVector<VCGVertexSI*> MeshModelSI::vert();
Q_INVOKABLE Point3Vector MeshModelSI::getVertPosArray();
Q_INVOKABLE void MeshModelSI::setVertPosArray( const Point3Vector& pa );
Q_INVOKABLE void MeshModelSI::setVertNormArray( const Point3Vector& na );
Q_INVOKABLE Point3Vector MeshModelSI::getVertNormArray();
Q_INVOKABLE QVector<float> VCGVertexSI::getP();
Q_INVOKABLE void VCGVertexSI::setPC( const float x,const float y,const float z );
Q_INVOKABLE void VCGVertexSI::setP( const QVector<float>& p );
Q_INVOKABLE QVector<float> VCGVertexSI::getN();
Q_INVOKABLE void VCGVertexSI::setN( const float x,const float y,const float z );
Q_INVOKABLE VCGPoint3SI VCGVertexSI::getPoint();
Q_INVOKABLE void VCGVertexSI::setPoint( const VCGPoint3SI& p );
Q_INVOKABLE VCGPoint3SI VCGVertexSI::getNormal();
Q_INVOKABLE void VCGVertexSI::setNormal( const VCGPoint3SI& p );
QScriptValue MeshModelScriptInterfaceToScriptValue(QScriptEngine* eng,MeshModelSI* const& in);
void MeshModelScriptInterfaceFromScriptValue(const QScriptValue& val,MeshModelSI*& out);
QScriptValue MeshDocumentScriptInterfaceToScriptValue( QScriptEngine* eng,MeshDocumentSI* const& in );
void MeshDocumentScriptInterfaceFromScriptValue( const QScriptValue& val,MeshDocumentSI*& out );
QScriptValue VCGVertexScriptInterfaceToScriptValue( QScriptEngine* eng,VCGVertexSI* const& in );
void VCGVertexScriptInterfaceFromScriptValue( const QScriptValue& val,VCGVertexSI*& out );
QScriptValue ShotScriptInterfaceToScriptValue( QScriptEngine* eng,ShotSI* const& in );
void ShotScriptInterfaceFromScriptValue( const QScriptValue& val,ShotSI*& out );
QScriptValue EnvWrap_ctor( QScriptContext* c,QScriptEngine* e );
QScriptValue VCGPoint3ScriptInterface_ctor( QScriptContext *c, QScriptEngine *e );
EnvWrap::EnvWrap(Env& envir);
QScriptValue EnvWrap::evalExp( const QString& nm );
bool EnvWrap::evalBool( const QString& nm );
double EnvWrap::evalDouble( const QString& nm );
float EnvWrap::evalFloat( const QString& nm );
int EnvWrap::evalInt( const QString& nm );
vcg::Point3f EnvWrap::evalVec3( const QString& nm );
int EnvWrap::evalEnum( const QString& nm );
MeshModel* EnvWrap::evalMesh(const QString& nm);
QColor EnvWrap::evalColor( const QString& nm );
bool EnvWrap::constStatement( const QString& statement );
QString EnvWrap::evalString( const QString& nm );
vcg::Shotf EnvWrap::evalShot( const QString& nm );
QScriptValue Env_ctor( QScriptContext */*context*/,QScriptEngine *engine );
QScriptValue ShotSI_ctor( QScriptContext* c,QScriptEngine* e );
QScriptValue ShotSI_defctor( QScriptContext* /*c*/,QScriptEngine* e );
Env::Env();
void Env::insertExpressionBinding( const QString& nm,const QString& exp );
QString Env::output();
void Env::appendOutput( const QString& output );
QScriptValue Env::loadMLScriptEnv( MeshDocument& md,PluginManager& pm );
ShotSI::ShotSI( const vcg::Shotf& st );
ShotSI::ShotSI();
Q_INVOKABLE ShotSI* ShotSI::itSelf();
QVector<float> ScriptInterfaceUtilities::vcgPoint2ToVector2( const vcg::Point2f& p );
vcg::Point2f ScriptInterfaceUtilities::vector2ToVcgPoint2( const QVector<float>& v );
QVector<float> ScriptInterfaceUtilities::vcgPoint3ToVector3( const vcg::Point3f& p );
vcg::Point3f ScriptInterfaceUtilities::vector3ToVcgPoint3( const QVector<float>& v );
QVector<float> ScriptInterfaceUtilities::vcgPoint4ToVector4( const vcg::Point4f& p );
vcg::Point4f ScriptInterfaceUtilities::vector4ToVcgPoint4( const QVector<float>& v );
QVector<float> ScriptInterfaceUtilities::vcgMatrix44ToVector16( const vcg::Matrix44f& m );
vcg::Matrix44f ScriptInterfaceUtilities::vector16ToVcgMatrix44( const QVector<float>& v );
vcg::Point2i ScriptInterfaceUtilities::vector2ToVcgPoint2i( const QVector<float>& v );
| 15b048e8d62b4b0f3da0a56686edfbfd615518d097e032c9891eb736aa0dfae5 | 290 |
|
metalex10 | PPSSPP-X360 | Core/HW/SasAudio.cpp | ADSREnvelope::SetState |
void ADSREnvelope::SetState(ADSRState state) {
steps_ = 0;
state_ = state;
switch (state) {
case STATE_ATTACK:
rate_ = attackRate;
type_ = attackType;
break;
case STATE_DECAY:
rate_ = decayRate;
type_ = decayType;
break;
case STATE_SUSTAIN:
rate_ = sustainRate;
type_ = sustainType;
break;
case STATE_RELEASE:
rate_ = releaseRate;
type_ = releaseType;
break;
case STATE_OFF:
return;
}
switch (type_) {
case PSP_SAS_ADSR_CURVE_MODE_EXPONENT_DECREASE:
case PSP_SAS_ADSR_CURVE_MODE_EXPONENT_INCREASE:
{
int duration = durationFromRate(rate_);
if (duration == 0) {
invDuration_ = 0.0f;
} else {
invDuration_ = 1.0f / (float)duration;
}
}
break;
default:
break;
}
} |
void VagDecoder::Start(u32 data, int vagSize, bool loopEnabled);
void VagDecoder::DecodeBlock(u8 *&readp);
inline void VagDecoder::DecodeSample(int i, int sample, int predict_nr);
void VagDecoder::GetSamples(s16 *outSamples, int numSamples);
void VagDecoder::DoState(PointerWrap &p);
int SasAtrac3::setContext(u32 context);
int SasAtrac3::getNextSamples(s16* outbuf, int wantedSamples);
int SasAtrac3::addStreamData(u8* buf, u32 addbytes);
void SasAtrac3::DoState(PointerWrap &p);
int simpleRate(int n);
static int getAttackRate(int bitfield1);
static int getAttackType(int bitfield1);
static int getDecayRate(int bitfield1);
static int getSustainRate(int bitfield2);
static int getSustainType(int bitfield2);
static int getReleaseType(int bitfield2);
static int getReleaseRate(int bitfield2);
static int getSustainLevel(int bitfield1);
void ADSREnvelope::SetSimpleEnvelope(u32 ADSREnv1, u32 ADSREnv2);
SasInstance::SasInstance();
SasInstance::~SasInstance();
void SasInstance::ClearGrainSize();
void SasInstance::SetGrainSize(int newGrainSize);
void SasVoice::ReadSamples(s16 *output, int numSamples);
void SasInstance::MixVoice(SasVoice &voice);
void SasInstance::Mix(u32 outAddr, u32 inAddr, int leftVol, int rightVol);
void SasInstance::ApplyReverb();
void SasInstance::DoState(PointerWrap &p);
void SasVoice::Reset();
void SasVoice::KeyOn();
void SasVoice::KeyOff();
void SasVoice::ChangedParams(bool changedVag);
void SasVoice::DoState(PointerWrap &p);
static int durationFromRate(int rate);
static float computeExpCurveAt(int index, float invDuration);
ADSREnvelope::ADSREnvelope();
void ADSREnvelope::WalkCurve(int type);
void ADSREnvelope::Step();
void ADSREnvelope::KeyOn();
void ADSREnvelope::KeyOff();
void ADSREnvelope::DoState(PointerWrap &p);
| 637a633044b1395c84e520052fd17b4f7a645e310bb7c950194e477d7442bf57 | 730 |