hexsha stringlengths 40 40 | size int64 5 1.05M | ext stringclasses 588
values | lang stringclasses 305
values | max_stars_repo_path stringlengths 3 363 | max_stars_repo_name stringlengths 5 118 | max_stars_repo_head_hexsha stringlengths 40 40 | max_stars_repo_licenses listlengths 1 10 | max_stars_count float64 1 191k ⌀ | max_stars_repo_stars_event_min_datetime stringdate 2015-01-01 00:00:35 2022-03-31 23:43:49 ⌀ | max_stars_repo_stars_event_max_datetime stringdate 2015-01-01 12:37:38 2022-03-31 23:59:52 ⌀ | max_issues_repo_path stringlengths 3 363 | max_issues_repo_name stringlengths 5 118 | max_issues_repo_head_hexsha stringlengths 40 40 | max_issues_repo_licenses listlengths 1 10 | max_issues_count float64 1 134k ⌀ | max_issues_repo_issues_event_min_datetime stringlengths 24 24 ⌀ | max_issues_repo_issues_event_max_datetime stringlengths 24 24 ⌀ | max_forks_repo_path stringlengths 3 363 | max_forks_repo_name stringlengths 5 135 | max_forks_repo_head_hexsha stringlengths 40 40 | max_forks_repo_licenses listlengths 1 10 | max_forks_count float64 1 105k ⌀ | max_forks_repo_forks_event_min_datetime stringdate 2015-01-01 00:01:02 2022-03-31 23:27:27 ⌀ | max_forks_repo_forks_event_max_datetime stringdate 2015-01-03 08:55:07 2022-03-31 23:59:24 ⌀ | content stringlengths 5 1.05M | avg_line_length float64 1.13 1.04M | max_line_length int64 1 1.05M | alphanum_fraction float64 0 1 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
f2bca6a668063a29a7bf6cfa0a2bf91f85bdb4c8 | 397 | c | C | src/graphics/pictures/bankSwitch/getRBankByPkId.c | AngheloAlf/GenIAlgos | 8354895a0a085e71a87ff27ec32317882d98e89b | [
"MIT"
] | null | null | null | src/graphics/pictures/bankSwitch/getRBankByPkId.c | AngheloAlf/GenIAlgos | 8354895a0a085e71a87ff27ec32317882d98e89b | [
"MIT"
] | null | null | null | src/graphics/pictures/bankSwitch/getRBankByPkId.c | AngheloAlf/GenIAlgos | 8354895a0a085e71a87ff27ec32317882d98e89b | [
"MIT"
] | null | null | null | #include "bankSwitch.h"
size_t getRBankByPkId(size_t pkId, bool y_mode){
if(!y_mode && pkId == 0x15){
return 0x01;
}
if(pkId == 0xB6){
return 0x0B;
}
if(pkId < 0x1F){
return 0x09;
}
if(pkId < 0x4A){
return 0x0A;
}
if(pkId < 0x74){
return 0x0B;
}
if(pkId < 0x99){
return 0x0C;
}
return 0x0D;
}
| 14.703704 | 48 | 0.488665 |
62d29c0282a2d8e729f6f770d5eedbe22b0eaf6b | 1,090 | h | C | StandardAlgorithms/stack/stack_push/stack_push.h | fraunhoferfokus/acsl-by-example | d8472670150fb3ff4360924af2d0eb14bc80d1e2 | [
"MIT"
] | 90 | 2017-06-14T04:17:53.000Z | 2022-02-07T06:07:36.000Z | StandardAlgorithms/stack/stack_push/stack_push.h | fraunhoferfokus/acsl-by-example | d8472670150fb3ff4360924af2d0eb14bc80d1e2 | [
"MIT"
] | 22 | 2017-10-18T13:30:41.000Z | 2021-06-17T07:10:16.000Z | StandardAlgorithms/stack/stack_push/stack_push.h | fraunhoferfokus/acsl-by-example | d8472670150fb3ff4360924af2d0eb14bc80d1e2 | [
"MIT"
] | 19 | 2017-06-21T13:49:31.000Z | 2022-03-31T16:27:06.000Z |
#ifndef STACK_PUSH_H_INCLUDED
#define STACK_PUSH_H_INCLUDED
#include "Stack.acsl"
/*@
requires valid: \valid(s) && StackInvariant(s);
assigns s->size, s->obj[s->size];
behavior full:
assumes StackFull(s);
assigns \nothing;
ensures valid: \valid(s) && StackInvariant(s);
ensures full: StackFull(s);
ensures unchanged: StackUnchanged{Old,Here}(s);
behavior not_full:
assumes !StackFull(s);
assigns s->size;
assigns s->obj[s->size];
ensures valid: \valid(s) && StackInvariant(s);
ensures size: StackSize(s) == StackSize{Old}(s) + 1;
ensures top: StackTop(s) == v;
ensures storage: StackStorage(s) == StackStorage{Old}(s);
ensures capacity: StackCapacity(s) == StackCapacity{Old}(s);
ensures not_empty: !StackEmpty(s);
ensures unchanged: Unchanged{Old,Here}(StackStorage(s), StackSize{Old}(s));
complete behaviors;
disjoint behaviors;
*/
void
stack_push(Stack* s, value_type v);
#endif /* STACK_PUSH_H_INCLUDED */
| 28.684211 | 79 | 0.618349 |
2e2c206f40d0bc67b3ab917ee7a9337cdc1a9d76 | 4,469 | h | C | include/polarphp/pil/lang/LoopInfo.h | agxmaster/polarphp | 31012ff7e6c0f72ee587546c296b06013c98cf9a | [
"PHP-3.01"
] | 1,083 | 2018-05-26T09:12:13.000Z | 2022-02-14T00:13:01.000Z | include/polarphp/pil/lang/LoopInfo.h | agxmaster/polarphp | 31012ff7e6c0f72ee587546c296b06013c98cf9a | [
"PHP-3.01"
] | 27 | 2018-08-25T07:28:25.000Z | 2021-05-06T06:31:09.000Z | include/polarphp/pil/lang/LoopInfo.h | agxmaster/polarphp | 31012ff7e6c0f72ee587546c296b06013c98cf9a | [
"PHP-3.01"
] | 78 | 2018-08-28T02:43:09.000Z | 2020-11-21T15:45:24.000Z | //===--- LoopInfo.h - PIL Loop Analysis -------------------------*- C++ -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
#ifndef POLARPHP_PIL_LOOPINFO_H
#define POLARPHP_PIL_LOOPINFO_H
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/ADT/iterator_range.h"
namespace polar {
class DominanceInfo;
class PILLoop;
class PILPassManager;
class PILBasicBlock;
class PILInstruction;
class PILFunction;
}
// Implementation in LoopInfoImpl.h
#ifdef __GNUC__
__extension__ extern template
class llvm::LoopBase<polar::PILBasicBlock, polar::PILLoop>;
__extension__ extern template
class llvm::LoopInfoBase<polar::PILBasicBlock, polar::PILLoop>;
#endif
namespace polar {
/// Information about a single natural loop.
class PILLoop : public llvm::LoopBase<PILBasicBlock, PILLoop> {
public:
PILLoop() {}
void dump() const;
llvm::iterator_range<iterator> getSubLoopRange() const {
return make_range(begin(), end());
}
/// Check whether it is safe to duplicate this instruction when duplicating
/// this loop by unrolling or versioning.
bool canDuplicate(PILInstruction *Inst) const;
private:
friend class llvm::LoopInfoBase<PILBasicBlock, PILLoop>;
explicit PILLoop(PILBasicBlock *BB)
: llvm::LoopBase<PILBasicBlock, PILLoop>(BB) {}
};
/// Information about loops in a function.
class PILLoopInfo {
friend class llvm::LoopBase<PILBasicBlock, PILLoop>;
using PILLoopInfoBase = llvm::LoopInfoBase<PILBasicBlock, PILLoop>;
PILLoopInfoBase LI;
DominanceInfo *Dominance;
void operator=(const PILLoopInfo &) = delete;
PILLoopInfo(const PILLoopInfo &) = delete;
public:
PILLoopInfo(PILFunction *F, DominanceInfo *DT);
PILLoopInfoBase &getBase() { return LI; }
/// Verify loop information. This is very expensive.
void verify() const;
/// The iterator interface to the top-level loops in the current
/// function.
using iterator = PILLoopInfoBase::iterator;
iterator begin() const { return LI.begin(); }
iterator end() const { return LI.end(); }
bool empty() const { return LI.empty(); }
llvm::iterator_range<iterator> getTopLevelLoops() const {
return make_range(begin(), end());
}
/// Return the inner most loop that BB lives in. If a basic block is in no
/// loop (for example the entry node), null is returned.
PILLoop *getLoopFor(const PILBasicBlock *BB) const {
return LI.getLoopFor(BB);
}
/// Return the inner most loop that BB lives in. If a basic block is in no
/// loop (for example the entry node), null is returned.
const PILLoop *operator[](const PILBasicBlock *BB) const {
return LI.getLoopFor(BB);
}
/// Return the loop nesting level of the specified block.
unsigned getLoopDepth(const PILBasicBlock *BB) const {
return LI.getLoopDepth(BB);
}
/// True if the block is a loop header node.
bool isLoopHeader(PILBasicBlock *BB) const {
return LI.isLoopHeader(BB);
}
/// This removes the specified top-level loop from this loop info object. The
/// loop is not deleted, as it will presumably be inserted into another loop.
PILLoop *removeLoop(iterator I) { return LI.removeLoop(I); }
/// Change the top-level loop that contains BB to the specified loop. This
/// should be used by transformations that restructure the loop hierarchy
/// tree.
void changeLoopFor(PILBasicBlock *BB, PILLoop *L) { LI.changeLoopFor(BB, L); }
/// Replace the specified loop in the top-level loops list with the indicated
/// loop.
void changeTopLevelLoop(PILLoop *OldLoop, PILLoop *NewLoop) {
LI.changeTopLevelLoop(OldLoop, NewLoop);
}
/// This adds the specified loop to the collection of top-level loops.
void addTopLevelLoop(PILLoop *New) {
LI.addTopLevelLoop(New);
}
/// This method completely removes BB from all data structures, including all
/// of the Loop objects it is nested in and our mapping from PILBasicBlocks to
/// loops.
void removeBlock(PILBasicBlock *BB) {
LI.removeBlock(BB);
}
};
} // end namespace polar
#endif
| 31.921429 | 81 | 0.693891 |
289004292c1fcf952b3ed9ee313f23db960b1ad2 | 2,369 | h | C | include/ld.h | CreRecombinase/tomahawk | 0e816bca4f49732d2c56f01fa4e7ec68bb10b60b | [
"MIT"
] | 39 | 2018-02-01T14:05:05.000Z | 2022-03-23T08:33:36.000Z | include/ld.h | CreRecombinase/tomahawk | 0e816bca4f49732d2c56f01fa4e7ec68bb10b60b | [
"MIT"
] | 16 | 2018-02-03T02:24:30.000Z | 2022-03-15T02:04:18.000Z | include/ld.h | CreRecombinase/tomahawk | 0e816bca4f49732d2c56f01fa4e7ec68bb10b60b | [
"MIT"
] | 12 | 2018-02-03T02:03:20.000Z | 2021-02-19T10:58:22.000Z | /*
Copyright (C) 2016-current Genome Research Ltd.
Author: Marcus D. R. Klarqvist <mk819@cam.ac.uk>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
==============================================================================*/
#ifndef TWK_LD_H_
#define TWK_LD_H_
#include <cassert>
#include <thread>
#include "core.h"
#include "twk_reader.h"
#include "writer.h"
namespace tomahawk {
struct twk_ld_balancer; // forward declare balancer
/****************************
* LD handler
****************************/
class twk_ld {
public:
twk_ld();
~twk_ld();
void operator=(const twk_ld_settings& settings){ this->settings = settings; }
/**<
* Helper function to call Compute subroutine when passing a new settings
* object to be used.
* @param settings Src settings objects.
* @return Returns TRUE upon success or FALSE otherwise.
*/
bool Compute(const twk_ld_settings& settings);
bool ComputeSingle(const twk_ld_settings& settings, bool verbose = false, bool progress = true);
/**<
* Main subroutine for computing linkage-disequilibrium as contextually
* determined given the user-defined parameters.
* @return Returns TRUE upon success or FALSE otherwise.
*/
bool Compute();
bool ComputeSingle(bool verbose = false, bool progress = true);
bool ComputePerformance();
private:
class twk_ld_impl;
twk_ld_settings settings;
twk_ld_impl* mImpl;
};
}
#endif
| 32.013514 | 97 | 0.724356 |
fab74f7923f6da289db3a74997cd1758f035de87 | 33,698 | c | C | src/cfl_type.generate.c | burz/cfl | 0b115e5d1c1a24e73da09e5028cbb571c8991ef4 | [
"MIT"
] | 11 | 2016-07-20T04:08:07.000Z | 2022-01-28T00:21:04.000Z | src/cfl_type.generate.c | burz/cfl | 0b115e5d1c1a24e73da09e5028cbb571c8991ef4 | [
"MIT"
] | null | null | null | src/cfl_type.generate.c | burz/cfl | 0b115e5d1c1a24e73da09e5028cbb571c8991ef4 | [
"MIT"
] | 1 | 2021-01-24T10:25:34.000Z | 2021-01-24T10:25:34.000Z | #include "cfl_type.h"
#include <stdio.h>
#include <string.h>
extern void* cfl_type_malloc(size_t size);
static unsigned int cfl_next_id;
void cfl_reset_type_generator(void)
{
cfl_next_id = 1;
}
unsigned int cfl_type_get_next_id(void)
{
return cfl_next_id++;
}
unsigned int cfl_lookup_hypothesis(cfl_type_hypothesis_chain* chain, char* name)
{
unsigned int result = 0;
while(chain)
{
if(!strcmp(name, chain->name))
{
result = chain->id;
break;
}
chain = chain->next;
}
return result;
}
void cfl_remove_n_hypotheses(
cfl_type_hypothesis_chain* hypothesis_head,
unsigned int n)
{
while(n)
{
cfl_type_hypothesis_chain* temp = hypothesis_head->next;
hypothesis_head->next = temp->next;
free(temp);
--n;
}
}
static unsigned int cfl_generate_hypotheses(
cfl_type** variable_type,
cfl_type_hypothesis_chain* hypothesis_head,
cfl_node* variable)
{
if(variable->type == CFL_NODE_VARIABLE)
{
unsigned int id = cfl_next_id++;
cfl_type_hypothesis_chain* hypothesis_chain_node =
cfl_type_malloc(sizeof(cfl_type_hypothesis_chain));
if(!hypothesis_chain_node)
return 0;
hypothesis_chain_node->name = variable->data;
hypothesis_chain_node->id = id;
hypothesis_chain_node->next = hypothesis_head->next;
hypothesis_head->next = hypothesis_chain_node;
*variable_type = cfl_type_malloc(sizeof(cfl_type));
if(!*variable_type)
return 0;
cfl_create_type_variable(*variable_type, id);
return 1;
}
cfl_type** children = cfl_type_malloc(sizeof(cfl_type*) *
variable->number_of_children);
if(!children)
return 0;
unsigned int hypothesis_count = 0;
int i = 0;
for( ; i < variable->number_of_children; ++i)
{
unsigned int change = cfl_generate_hypotheses(&children[i],
hypothesis_head,
variable->children[i]);
if(!change)
{
int j = 0;
for( ; j < i; ++j)
{
cfl_free_type(children[j]);
cfl_type_hypothesis_chain* temp = hypothesis_head->next;
hypothesis_head->next = temp->next;
free(temp);
}
free(children);
return 0;
}
hypothesis_count += change;
}
*variable_type = cfl_type_malloc(sizeof(cfl_type));
if(!*variable_type)
{
for(i = 0; i < variable->number_of_children; ++i)
{
cfl_free_type(children[i]);
cfl_type_hypothesis_chain* temp = hypothesis_head->next;
hypothesis_head->next = temp->next;
free(temp);
}
free(children);
return 0;
}
cfl_create_type_tuple(*variable_type, variable->number_of_children, children);
return hypothesis_count;
}
static bool cfl_generate_type_equation_chain_given_variable(
cfl_type** variable_type,
cfl_type** node_type,
cfl_type_equations* equations,
cfl_type_hypothesis_chain* hypothesis_head,
cfl_node* variable,
cfl_node* node)
{
unsigned int added_hypotheses = cfl_generate_hypotheses(variable_type,
hypothesis_head,
variable);
*node_type = cfl_generate_type_equation_chain(equations,
hypothesis_head,
node);
cfl_remove_n_hypotheses(hypothesis_head, added_hypotheses);
if(!*node_type)
return false;
return true;
}
cfl_type* cfl_generate_type_equation_chain(
cfl_type_equations* equations,
cfl_type_hypothesis_chain* hypothesis_head,
cfl_node* node)
{
cfl_type* result = 0;
int i;
int j;
unsigned int id0;
unsigned int id1;
cfl_type_hypothesis_chain* hypothesis_chain_node;
cfl_type* child_type0;
cfl_type* child_type1;
cfl_type* child_type2;
cfl_type* temp_type0;
cfl_type* temp_type1;
cfl_type* temp_type2;
cfl_type** children;
switch(node->type)
{
case CFL_NODE_VARIABLE:
id0 = cfl_lookup_hypothesis(hypothesis_head->next, node->data);
if(!id0)
{
cfl_type_error_undefined_variable(node->data);
break;
}
result = cfl_type_malloc(sizeof(cfl_type));
if(!result)
break;
cfl_create_type_variable(result, id0);
break;
case CFL_NODE_BOOL:
result = cfl_type_malloc(sizeof(cfl_type));
if(!result)
break;
cfl_create_type_bool(result);
break;
case CFL_NODE_INTEGER:
result = cfl_type_malloc(sizeof(cfl_type));
if(!result)
break;
cfl_create_type_integer(result);
break;
case CFL_NODE_CHAR:
result = cfl_type_malloc(sizeof(cfl_type));
if(!result)
break;
cfl_create_type_char(result);
break;
case CFL_NODE_LIST:
temp_type0 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type0)
break;
id0 = cfl_next_id++;
cfl_create_type_variable(temp_type0, id0);
cfl_list_node* pos = node->data;
while(pos)
{
temp_type1 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type1)
{
cfl_free_type(temp_type0);
return 0;
}
if(!cfl_copy_type(temp_type1, temp_type0))
{
cfl_free_type(temp_type0);
free(temp_type1);
return 0;
}
child_type0 = cfl_generate_type_equation_chain(equations,
hypothesis_head,
pos->node);
if(!child_type0)
{
cfl_free_type(temp_type0);
cfl_free_type(temp_type1);
return 0;
}
if(!cfl_add_type_equations(equations, child_type0, temp_type1))
{
cfl_free_type(temp_type0);
cfl_free_type(temp_type1);
cfl_free_type(child_type0);
return 0;
}
pos = pos->next;
}
result = cfl_type_malloc(sizeof(cfl_type));
if(!result)
{
cfl_free_type(temp_type0);
return 0;
}
cfl_create_type_list(result, temp_type0);
break;
case CFL_NODE_TUPLE:
children = 0;
if(node->number_of_children)
{
children = cfl_type_malloc(sizeof(cfl_type*) * node->number_of_children);
for(i = 0; i < node->number_of_children; ++i)
{
id0 = cfl_next_id++;
child_type0 = cfl_generate_type_equation_chain(equations,
hypothesis_head,
node->children[i]);
temp_type0 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type0)
{
cfl_free_type(child_type0);
for(j = 0; j < i; ++j)
cfl_free_type(children[j]);
free(children);
return 0;
}
cfl_create_type_variable(temp_type0, id0);
if(!cfl_add_type_equations(equations, child_type0, temp_type0))
{
cfl_free_type(child_type0);
free(temp_type0);
for(j = 0; j < i; ++j)
cfl_free_type(children[j]);
free(children);
return 0;
}
children[i] = cfl_type_malloc(sizeof(cfl_type));
if(!children[i])
{
for(j = 0; j < i; ++j)
cfl_free_type(children[j]);
free(children);
return 0;
}
cfl_create_type_variable(children[i], id0);
}
}
result = cfl_type_malloc(sizeof(cfl_type));
if(!result)
{
for(i = 0; i < node->number_of_children; ++i)
cfl_free_type(children[i]);
free(children);
break;
}
cfl_create_type_tuple(result, node->number_of_children, children);
break;
case CFL_NODE_FUNCTION:
if(!cfl_generate_type_equation_chain_given_variable(&temp_type0,
&child_type1,
equations,
hypothesis_head,
node->children[0],
node->children[1]))
break;
result = cfl_type_malloc(sizeof(cfl_type));
if(!result)
{
cfl_free_type(temp_type0);
cfl_free_type(child_type1);
}
cfl_create_type_arrow(result, temp_type0, child_type1);
break;
case CFL_NODE_AND:
case CFL_NODE_OR:
child_type0 = cfl_generate_type_equation_chain(equations,
hypothesis_head,
node->children[0]);
if(!child_type0)
break;
child_type1 = cfl_generate_type_equation_chain(equations,
hypothesis_head,
node->children[1]);
if(!child_type1)
{
cfl_free_type(child_type0);
break;
}
temp_type0 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type0)
{
cfl_free_type(child_type0);
cfl_free_type(child_type1);
break;
}
cfl_create_type_bool(temp_type0);
if(!cfl_add_type_equations(equations, child_type0, temp_type0))
{
cfl_free_type(child_type0);
cfl_free_type(child_type1);
cfl_free_type(temp_type0);
break;
}
temp_type0 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type0)
{
cfl_free_type(child_type1);
break;
}
cfl_create_type_bool(temp_type0);
if(!cfl_add_type_equations(equations, child_type1, temp_type0))
{
cfl_free_type(child_type1);
cfl_free_type(temp_type0);
break;
}
result = cfl_type_malloc(sizeof(cfl_type));
if(!result)
break;
cfl_create_type_bool(result);
break;
case CFL_NODE_NOT:
child_type0 = cfl_generate_type_equation_chain(equations,
hypothesis_head,
node->children[0]);
if(!child_type0)
break;
temp_type0 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type0)
{
cfl_free_type(child_type0);
break;
}
cfl_create_type_bool(temp_type0);
if(!cfl_add_type_equations(equations, child_type0, temp_type0))
{
cfl_free_type(child_type0);
cfl_free_type(temp_type0);
break;
}
result = cfl_type_malloc(sizeof(cfl_type));
if(!result)
break;
cfl_create_type_bool(result);
break;
case CFL_NODE_ADD:
case CFL_NODE_MULTIPLY:
case CFL_NODE_DIVIDE:
child_type0 = cfl_generate_type_equation_chain(equations,
hypothesis_head,
node->children[0]);
if(!child_type0)
break;
child_type1 = cfl_generate_type_equation_chain(equations,
hypothesis_head,
node->children[1]);
if(!child_type1)
{
cfl_free_type(child_type0);
break;
}
temp_type0 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type0)
{
cfl_free_type(child_type0);
cfl_free_type(child_type1);
break;
}
cfl_create_type_integer(temp_type0);
if(!cfl_add_type_equations(equations, child_type0, temp_type0))
{
cfl_free_type(child_type0);
cfl_free_type(child_type1);
cfl_free_type(temp_type0);
break;
}
temp_type0 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type0)
{
cfl_free_type(child_type1);
break;
}
cfl_create_type_integer(temp_type0);
if(!cfl_add_type_equations(equations, child_type1, temp_type0))
{
cfl_free_type(child_type1);
cfl_free_type(temp_type0);
break;
}
result = cfl_type_malloc(sizeof(cfl_type));
if(!result)
break;
cfl_create_type_integer(result);
break;
case CFL_NODE_EQUAL:
case CFL_NODE_LESS:
child_type0 = cfl_generate_type_equation_chain(equations,
hypothesis_head,
node->children[0]);
if(!child_type0)
break;
child_type1 = cfl_generate_type_equation_chain(equations,
hypothesis_head,
node->children[1]);
if(!child_type1)
{
cfl_free_type(child_type0);
break;
}
temp_type0 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type0)
{
cfl_free_type(child_type0);
cfl_free_type(child_type1);
break;
}
cfl_create_type_integer(temp_type0);
if(!cfl_add_type_equations(equations, child_type0, temp_type0))
{
cfl_free_type(child_type0);
cfl_free_type(child_type1);
cfl_free_type(temp_type0);
break;
}
temp_type0 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type0)
{
cfl_free_type(child_type1);
break;
}
cfl_create_type_integer(temp_type0);
if(!cfl_add_type_equations(equations, child_type1, temp_type0))
{
cfl_free_type(child_type1);
cfl_free_type(temp_type0);
break;
}
result = cfl_type_malloc(sizeof(cfl_type));
if(!result)
break;
cfl_create_type_bool(result);
break;
case CFL_NODE_APPLICATION:
child_type0 = cfl_generate_type_equation_chain(equations,
hypothesis_head,
node->children[0]);
if(!child_type0)
break;
child_type1 = cfl_generate_type_equation_chain(equations,
hypothesis_head,
node->children[1]);
if(!child_type1)
{
cfl_free_type(child_type0);
break;
}
temp_type0 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type0)
{
cfl_free_type(child_type0);
cfl_free_type(child_type1);
break;
}
id0 = cfl_next_id++;
cfl_create_type_variable(temp_type0, id0);
temp_type1 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type1)
{
cfl_free_type(child_type0);
cfl_free_type(child_type1);
cfl_free_type(temp_type0);
break;
}
cfl_create_type_arrow(temp_type1, child_type1, temp_type0);
if(!cfl_add_type_equations(equations, child_type0, temp_type1))
{
cfl_free_type(child_type0);
cfl_free_type(temp_type1);
break;
}
result = cfl_type_malloc(sizeof(cfl_type));
if(!result)
break;
cfl_create_type_variable(result, id0);
break;
case CFL_NODE_IF:
child_type0 = cfl_generate_type_equation_chain(equations,
hypothesis_head,
node->children[0]);
if(!child_type0)
break;
child_type1 = cfl_generate_type_equation_chain(equations,
hypothesis_head,
node->children[1]);
if(!child_type1)
{
cfl_free_type(child_type0);
break;
}
child_type2 = cfl_generate_type_equation_chain(equations,
hypothesis_head,
node->children[2]);
if(!child_type2)
{
cfl_free_type(child_type0);
cfl_free_type(child_type1);
break;
}
temp_type0 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type0)
{
cfl_free_type(child_type0);
cfl_free_type(child_type1);
cfl_free_type(child_type2);
break;
}
if(!cfl_copy_type(temp_type0, child_type2))
{
cfl_free_type(child_type0);
cfl_free_type(child_type1);
cfl_free_type(child_type2);
free(temp_type0);
break;
}
if(!cfl_add_type_equations(equations, child_type1, child_type2))
{
cfl_free_type(child_type0);
cfl_free_type(child_type1);
cfl_free_type(child_type2);
cfl_free_type(temp_type0);
break;
}
temp_type1 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type1)
{
cfl_free_type(child_type0);
cfl_free_type(temp_type0);
break;
}
cfl_create_type_bool(temp_type1);
if(!cfl_add_type_equations(equations, child_type0, temp_type1))
{
cfl_free_type(child_type0);
cfl_free_type(temp_type0);
cfl_free_type(temp_type1);
break;
}
temp_type1 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type1)
{
cfl_free_type(temp_type0);
break;
}
id0 = cfl_next_id++;
cfl_create_type_variable(temp_type1, id0);
if(!cfl_add_type_equations(equations, temp_type0, temp_type1))
{
cfl_free_type(temp_type0);
cfl_free_type(temp_type1);
return 0;
}
result = cfl_type_malloc(sizeof(cfl_type));
if(!result)
break;
cfl_create_type_variable(result, id0);
break;
case CFL_NODE_LET_REC:
temp_type0 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type0)
break;
id0 = cfl_next_id++;
cfl_create_type_variable(temp_type0, id0);
hypothesis_chain_node =
cfl_type_malloc(sizeof(cfl_type_hypothesis_chain));
if(!hypothesis_chain_node)
{
cfl_free_type(temp_type0);
break;
}
hypothesis_chain_node->name = node->children[0]->data;
hypothesis_chain_node->id = id0;
hypothesis_chain_node->next = hypothesis_head->next;
hypothesis_head->next = hypothesis_chain_node;
result = cfl_generate_type_equation_chain(equations,
hypothesis_head,
node->children[3]);
if(!cfl_generate_type_equation_chain_given_variable(&temp_type1,
&child_type0,
equations,
hypothesis_head,
node->children[1],
node->children[2]))
{
cfl_free_type(temp_type0);
if(result)
cfl_free_type(result);
hypothesis_chain_node = hypothesis_head->next;
hypothesis_head->next = hypothesis_chain_node->next;
free(hypothesis_chain_node);
return 0;
}
hypothesis_head->next = hypothesis_chain_node->next;
free(hypothesis_chain_node);
if(!result)
{
cfl_free_type(temp_type0);
cfl_free_type(temp_type1);
if(child_type0)
cfl_free_type(child_type0);
break;
}
if(!child_type0)
{
cfl_free_type(temp_type0);
cfl_free_type(temp_type1);
cfl_free_type(result);
return 0;
}
temp_type2 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type2)
{
cfl_free_type(temp_type0);
cfl_free_type(temp_type1);
cfl_free_type(child_type0);
cfl_free_type(result);
return 0;
}
cfl_create_type_arrow(temp_type2, temp_type1, child_type0);
if(!cfl_add_type_equations(equations, temp_type0, temp_type2))
{
cfl_free_type(temp_type0);
cfl_free_type(temp_type2);
cfl_free_type(result);
return 0;
}
break;
case CFL_NODE_PUSH:
child_type0 = cfl_generate_type_equation_chain(equations,
hypothesis_head,
node->children[0]);
if(!child_type0)
break;
child_type1 = cfl_generate_type_equation_chain(equations,
hypothesis_head,
node->children[1]);
if(!child_type1)
{
cfl_free_type(child_type0);
break;
}
temp_type0 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type0)
{
cfl_free_type(child_type0);
cfl_free_type(child_type1);
break;
}
id0 = cfl_next_id++;
cfl_create_type_variable(temp_type0, id0);
if(!cfl_add_type_equations(equations, child_type0, temp_type0))
{
cfl_free_type(child_type0);
cfl_free_type(child_type1);
cfl_free_type(temp_type0);
break;
}
temp_type0 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type0)
{
cfl_free_type(child_type1);
break;
}
cfl_create_type_variable(temp_type0, id0);
temp_type1 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type1)
{
cfl_free_type(child_type1);
cfl_free_type(temp_type0);
break;
}
cfl_create_type_list(temp_type1, temp_type0);
result = cfl_type_malloc(sizeof(cfl_type));
if(!result)
{
cfl_free_type(child_type1);
cfl_free_type(temp_type1);
break;
}
if(!cfl_copy_type(result, temp_type1))
{
cfl_free_type(child_type1);
cfl_free_type(temp_type1);
free(result);
break;
}
if(!cfl_add_type_equations(equations, child_type1, temp_type1))
{
cfl_free_type(child_type1);
cfl_free_type(temp_type1);
cfl_free_type(result);
return 0;
}
break;
case CFL_NODE_CONCATENATE:
child_type0 = cfl_generate_type_equation_chain(equations,
hypothesis_head,
node->children[0]);
if(!child_type0)
break;
child_type1 = cfl_generate_type_equation_chain(equations,
hypothesis_head,
node->children[1]);
if(!child_type1)
{
cfl_free_type(child_type0);
break;
}
temp_type0 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type0)
{
cfl_free_type(child_type0);
cfl_free_type(child_type1);
break;
}
id0 = cfl_next_id++;
cfl_create_type_variable(temp_type0, id0);
temp_type1 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type1)
{
cfl_free_type(child_type0);
cfl_free_type(child_type1);
cfl_free_type(temp_type0);
break;
}
cfl_create_type_list(temp_type1, temp_type0);
temp_type0 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type0)
{
cfl_free_type(child_type0);
cfl_free_type(child_type1);
cfl_free_type(temp_type1);
break;
}
if(!cfl_copy_type(temp_type0, temp_type1))
{
cfl_free_type(child_type0);
cfl_free_type(child_type1);
free(temp_type0);
cfl_free_type(temp_type1);
break;
}
if(!cfl_add_type_equations(equations, child_type0, temp_type1))
{
cfl_free_type(child_type0);
cfl_free_type(child_type1);
cfl_free_type(temp_type0);
cfl_free_type(temp_type1);
break;
}
result = cfl_type_malloc(sizeof(cfl_type));
if(!result)
{
cfl_free_type(child_type1);
cfl_free_type(temp_type0);
break;
}
if(!cfl_copy_type(result, temp_type0))
{
free(result);
cfl_free_type(child_type1);
cfl_free_type(temp_type0);
return 0;
}
if(!cfl_add_type_equations(equations, child_type1, temp_type0))
{
cfl_free_type(result);
cfl_free_type(child_type1);
cfl_free_type(temp_type0);
return 0;
}
break;
case CFL_NODE_CASE:
child_type0 = cfl_generate_type_equation_chain(equations,
hypothesis_head,
node->children[0]);
if(!child_type0)
break;
temp_type0 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type0)
{
cfl_free_type(child_type0);
break;
}
id0 = cfl_next_id++;
cfl_create_type_variable(temp_type0, id0);
if(!cfl_add_type_equations(equations, child_type0, temp_type0))
{
cfl_free_type(child_type0);
cfl_free_type(temp_type0);
return 0;
}
child_type0 = cfl_generate_type_equation_chain(equations,
hypothesis_head,
node->children[1]);
if(!child_type0)
break;
temp_type0 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type0)
{
cfl_free_type(child_type0);
break;
}
id1 = cfl_next_id++;
cfl_create_type_variable(temp_type0, id1);
if(!cfl_add_type_equations(equations, child_type0, temp_type0))
{
cfl_free_type(child_type0);
cfl_free_type(temp_type0);
return 0;
}
hypothesis_chain_node =
cfl_type_malloc(sizeof(cfl_type_hypothesis_chain));
if(!hypothesis_chain_node)
break;
hypothesis_chain_node->name = node->children[3]->data;
hypothesis_chain_node->id = id0;
hypothesis_chain_node->next = hypothesis_head->next;
hypothesis_head->next = hypothesis_chain_node;
bool success = cfl_generate_type_equation_chain_given_variable(
&temp_type0, &child_type0, equations,
hypothesis_head, node->children[2], node->children[4]);
hypothesis_head->next = hypothesis_chain_node->next;
free(hypothesis_chain_node);
if(!success)
return 0;
temp_type1 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type1)
{
cfl_free_type(child_type0);
cfl_free_type(temp_type0);
break;
}
cfl_create_type_variable(temp_type1, id1);
if(!cfl_add_type_equations(equations, child_type0, temp_type1))
{
cfl_free_type(temp_type0);
break;
}
temp_type1 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type1)
{
cfl_free_type(temp_type0);
break;
}
cfl_create_type_list(temp_type1, temp_type0);
temp_type0 = cfl_type_malloc(sizeof(cfl_type));
if(!temp_type0)
{
cfl_free_type(temp_type1);
break;
}
cfl_create_type_variable(temp_type0, id0);
if(!cfl_add_type_equations(equations, temp_type1, temp_type0))
{
cfl_free_type(temp_type0);
cfl_free_type(temp_type1);
break;
}
result = cfl_type_malloc(sizeof(cfl_type));
if(!result)
break;
cfl_create_type_variable(result, id1);
break;
default:
break;
}
return result;
}
| 26.786963 | 89 | 0.460027 |
7abea174a4d51d0497e567afeaa4a5444c0e3268 | 3,315 | h | C | Iceberg3D/include/KeyCode.h | Odin366/Iceberg3D | f3109e58f3607869b0f28c9d418f2d2b11b3cc72 | [
"MIT"
] | null | null | null | Iceberg3D/include/KeyCode.h | Odin366/Iceberg3D | f3109e58f3607869b0f28c9d418f2d2b11b3cc72 | [
"MIT"
] | null | null | null | Iceberg3D/include/KeyCode.h | Odin366/Iceberg3D | f3109e58f3607869b0f28c9d418f2d2b11b3cc72 | [
"MIT"
] | null | null | null | #ifndef KEY_CODES_H
#define KEY_CODES_H
namespace iceberg
{
enum KeyCode
{
ICEBERG_KEY_UNKNOWN,
ICEBERG_KEY_SPACE,
ICEBERG_KEY_APOSTROPHE,
ICEBERG_KEY_COMMA,
ICEBERG_KEY_MINUS,
ICEBERG_KEY_PERIOD,
ICEBERG_KEY_SLASH,
ICEBERG_KEY_0,
ICEBERG_KEY_1,
ICEBERG_KEY_2,
ICEBERG_KEY_3,
ICEBERG_KEY_4,
ICEBERG_KEY_5,
ICEBERG_KEY_6,
ICEBERG_KEY_7,
ICEBERG_KEY_8,
ICEBERG_KEY_9,
ICEBERG_KEY_SEMICOLON,
ICEBERG_KEY_EQUAL,
ICEBERG_KEY_A,
ICEBERG_KEY_B,
ICEBERG_KEY_C,
ICEBERG_KEY_D,
ICEBERG_KEY_E,
ICEBERG_KEY_F,
ICEBERG_KEY_G,
ICEBERG_KEY_H,
ICEBERG_KEY_I,
ICEBERG_KEY_J,
ICEBERG_KEY_K,
ICEBERG_KEY_L,
ICEBERG_KEY_M,
ICEBERG_KEY_N,
ICEBERG_KEY_O,
ICEBERG_KEY_P,
ICEBERG_KEY_Q,
ICEBERG_KEY_R,
ICEBERG_KEY_S,
ICEBERG_KEY_T,
ICEBERG_KEY_U,
ICEBERG_KEY_V,
ICEBERG_KEY_W,
ICEBERG_KEY_X,
ICEBERG_KEY_Y,
ICEBERG_KEY_Z,
ICEBERG_KEY_LEFT_BRACKET,
ICEBERG_KEY_BACKSLASH,
ICEBERG_KEY_RIGHT_BRACKET,
ICEBERG_KEY_GRAVE_ACCENT,
ICEBERG_KEY_WORLD_1,
ICEBERG_KEY_WORLD_2,
ICEBERG_KEY_ESCAPE,
ICEBERG_KEY_ENTER,
ICEBERG_KEY_TAB,
ICEBERG_KEY_BACKSPACE,
ICEBERG_KEY_INSERT,
ICEBERG_KEY_DELETE,
ICEBERG_KEY_RIGHT,
ICEBERG_KEY_LEFT,
ICEBERG_KEY_DOWN,
ICEBERG_KEY_UP,
ICEBERG_KEY_PAGE_UP,
ICEBERG_KEY_PAGE_DOWN,
ICEBERG_KEY_HOME,
ICEBERG_KEY_END,
ICEBERG_KEY_CAPS_LOCK,
ICEBERG_KEY_SCROLL_LOCK,
ICEBERG_KEY_NUM_LOCK,
ICEBERG_KEY_PRINT_SCREEN,
ICEBERG_KEY_PAUSE,
ICEBERG_KEY_F1,
ICEBERG_KEY_F2,
ICEBERG_KEY_F3,
ICEBERG_KEY_F4,
ICEBERG_KEY_F5,
ICEBERG_KEY_F6,
ICEBERG_KEY_F7,
ICEBERG_KEY_F8,
ICEBERG_KEY_F9,
ICEBERG_KEY_F10,
ICEBERG_KEY_F11,
ICEBERG_KEY_F12,
ICEBERG_KEY_F13,
ICEBERG_KEY_F14,
ICEBERG_KEY_F15,
ICEBERG_KEY_F16,
ICEBERG_KEY_F17,
ICEBERG_KEY_F18,
ICEBERG_KEY_F19,
ICEBERG_KEY_F20,
ICEBERG_KEY_F21,
ICEBERG_KEY_F22,
ICEBERG_KEY_F23,
ICEBERG_KEY_F24,
ICEBERG_KEY_F25,
ICEBERG_KEY_KP_0,
ICEBERG_KEY_KP_1,
ICEBERG_KEY_KP_2,
ICEBERG_KEY_KP_3,
ICEBERG_KEY_KP_4,
ICEBERG_KEY_KP_5,
ICEBERG_KEY_KP_6,
ICEBERG_KEY_KP_7,
ICEBERG_KEY_KP_8,
ICEBERG_KEY_KP_9,
ICEBERG_KEY_KP_DECIMAL,
ICEBERG_KEY_KP_DIVIDE,
ICEBERG_KEY_KP_MULTIPLY,
ICEBERG_KEY_KP_SUBTRACT,
ICEBERG_KEY_KP_ADD,
ICEBERG_KEY_KP_ENTER,
ICEBERG_KEY_KP_EQUAL,
ICEBERG_KEY_LEFT_SHIFT,
ICEBERG_KEY_LEFT_CONTROL,
ICEBERG_KEY_LEFT_ALT,
ICEBERG_KEY_LEFT_SUPER,
ICEBERG_KEY_RIGHT_SHIFT,
ICEBERG_KEY_RIGHT_CONTROL,
ICEBERG_KEY_RIGHT_ALT,
ICEBERG_KEY_RIGHT_SUPER,
ICEBERG_KEY_MENU,
ICEBERG_KEY_LAST
};
}
#endif | 24.924812 | 34 | 0.622021 |
7a79c157e42246759cc906e735ba39f7a726111d | 1,336 | h | C | WildMagic4/LibFoundation/NumericalAnalysis/Wm4OdeSolver.h | rms80/libgeometry | e60ec7d34968573a9cda3f3bf56d2d4717385dc9 | [
"BSL-1.0"
] | 23 | 2015-08-13T07:36:00.000Z | 2022-01-24T19:00:04.000Z | WildMagic4/LibFoundation/NumericalAnalysis/Wm4OdeSolver.h | rms80/libgeometry | e60ec7d34968573a9cda3f3bf56d2d4717385dc9 | [
"BSL-1.0"
] | null | null | null | WildMagic4/LibFoundation/NumericalAnalysis/Wm4OdeSolver.h | rms80/libgeometry | e60ec7d34968573a9cda3f3bf56d2d4717385dc9 | [
"BSL-1.0"
] | 6 | 2015-07-06T21:37:31.000Z | 2020-07-01T04:07:50.000Z | // Geometric Tools, LLC
// Copyright (c) 1998-2010
// Distributed under the Boost Software License, Version 1.0.
// http://www.boost.org/LICENSE_1_0.txt
// http://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
//
// File Version: 4.10.0 (2009/11/18)
#ifndef WM4ODESOLVER_H
#define WM4ODESOLVER_H
#include "Wm4FoundationLIB.h"
#include "Wm4System.h"
namespace Wm4
{
template <class Real>
class WM4_FOUNDATION_ITEM OdeSolver
{
public:
// abstract base class
virtual ~OdeSolver ();
// The system is dx/dt = F(t,x). The dimension of x is passed to the
// constructor of OdeSolver.
typedef void (*Function)(
Real, // t
const Real*, // x
void*, // user-specified data
Real*); // F(t,x)
virtual void Update (Real fTIn, Real* afXIn, Real& rfTOut,
Real* afXOut) = 0;
virtual void SetStepSize (Real fStep) = 0;
Real GetStepSize () const;
void SetData (void* pvData);
void* GetData () const;
protected:
OdeSolver (int iDim, Real fStep, Function oFunction, void* pvData = 0);
int m_iDim;
Real m_fStep;
Function m_oFunction;
void* m_pvData;
Real* m_afFValue;
};
typedef OdeSolver<float> OdeSolverf;
typedef OdeSolver<double> OdeSolverd;
}
#endif
| 23.034483 | 76 | 0.625749 |
932855dfd756b747a4866294a412133c10d479a4 | 527 | h | C | pge/source/pge/rendering/model/SceneObjectStaticModelBatcher.h | 222464/PGE | 8801301046a0412c323444a7f9f49e02f9ac87cc | [
"Zlib"
] | 100 | 2016-05-04T00:05:43.000Z | 2021-09-11T17:34:31.000Z | pge/source/pge/rendering/model/SceneObjectStaticModelBatcher.h | 222464/PGE | 8801301046a0412c323444a7f9f49e02f9ac87cc | [
"Zlib"
] | 8 | 2016-05-06T12:51:53.000Z | 2017-07-20T20:15:46.000Z | pge/source/pge/rendering/model/SceneObjectStaticModelBatcher.h | 222464/PGE | 8801301046a0412c323444a7f9f49e02f9ac87cc | [
"Zlib"
] | 16 | 2016-05-04T06:37:20.000Z | 2020-11-12T17:24:55.000Z | #pragma once
#include <pge/scene/RenderScene.h>
#include <pge/rendering/model/StaticModel.h>
namespace pge {
class SceneObjectStaticModelBatcher : public SceneObject {
private:
std::unordered_map<StaticModel*, std::list<Matrix4x4f>> _modelTransforms;
public:
SceneObjectStaticModelBatcher() {
_renderMask = 0xffff;
}
// Inherited from SceneObject
void batchRender();
SceneObjectStaticModelBatcher* copyFactory() {
return new SceneObjectStaticModelBatcher(*this);
}
friend class StaticModel;
};
} | 21.08 | 75 | 0.755218 |
1a1a97131c3954edb427a17a7ae02136fcb26a9e | 173 | c | C | src/main/noclip.c | StarBlazeNatlus/HideNSeek | ad02d1ffa8158276a36491607a7d741ba6aa8f65 | [
"MIT"
] | null | null | null | src/main/noclip.c | StarBlazeNatlus/HideNSeek | ad02d1ffa8158276a36491607a7d741ba6aa8f65 | [
"MIT"
] | null | null | null | src/main/noclip.c | StarBlazeNatlus/HideNSeek | ad02d1ffa8158276a36491607a7d741ba6aa8f65 | [
"MIT"
] | null | null | null | #include <hidenseek.h>
#include <player.h>
bool NoClip(PlayerHolderPlayer* player) {
return (!HideNSeekData.players[player->playerPointers->params->playerId].isSeeker);
}
| 24.714286 | 84 | 0.768786 |
1a843992cecb9d7666b1662ab4d5bb29f75b174d | 2,123 | h | C | src/win32_opengl.h | TheSandvichMaker/pulsar | 8636db508b6b008b3ea56bf98464aeedffd44de7 | [
"Unlicense"
] | 2 | 2020-09-20T21:07:14.000Z | 2020-09-29T08:22:21.000Z | src/win32_opengl.h | TheSandvichMaker/pulsar | 8636db508b6b008b3ea56bf98464aeedffd44de7 | [
"Unlicense"
] | null | null | null | src/win32_opengl.h | TheSandvichMaker/pulsar | 8636db508b6b008b3ea56bf98464aeedffd44de7 | [
"Unlicense"
] | null | null | null | #ifndef WIN32_OPENGL_H
#define WIN32_OPENGL_H
static const GLuint WGL_CONTEXT_MAJOR_VERSION_ARB = 0x2091;
static const GLuint WGL_CONTEXT_MINOR_VERSION_ARB = 0x2092;
static const GLuint WGL_CONTEXT_LAYER_PLANE_ARB = 0x2093;
static const GLuint WGL_CONTEXT_FLAGS_ARB = 0x2094;
static const GLuint WGL_CONTEXT_PROFILE_MASK_ARB = 0x9126;
static const GLuint WGL_CONTEXT_DEBUG_BIT_ARB = 0x0001;
static const GLuint WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB = 0x0002;
static const GLuint WGL_CONTEXT_CORE_PROFILE_BIT_ARB = 0x00000001;
static const GLuint WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = 0x00000002;
static const GLuint WGL_DRAW_TO_WINDOW_ARB = 0x2001;
static const GLuint WGL_ACCELERATION_ARB = 0x2003;
static const GLuint WGL_SUPPORT_OPENGL_ARB = 0x2010;
static const GLuint WGL_DOUBLE_BUFFER_ARB = 0x2011;
static const GLuint WGL_PIXEL_TYPE_ARB = 0x2013;
static const GLuint WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB = 0x20A9;
static const GLuint WGL_SAMPLE_BUFFERS_ARB = 0x2041;
static const GLuint WGL_SAMPLES_ARB = 0x2042;
static const GLuint WGL_COLOR_BITS_ARB = 0x2014;
static const GLuint WGL_DEPTH_BITS_ARB = 0x2022;
static const GLuint WGL_STENCIL_BITS_ARB = 0x2023;
static const GLuint WGL_FULL_ACCELERATION_ARB = 0x2027;
static const GLuint WGL_TYPE_RGBA_ARB = 0x202B;
GL_FUNCTION(BOOL, wglChoosePixelFormatARB, HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
GL_FUNCTION(HGLRC, wglCreateContextAttribsARB, HDC hDC, HGLRC hShareContext, const int *attribList);
GL_FUNCTION(BOOL, wglSwapIntervalEXT, int interval);
GL_FUNCTION(const char*, wglGetExtensionsStringEXT);
struct WglInfo {
b32 WGL_EXT_framebuffer_sRGB;
b32 WGL_ARB_multisample;
};
#endif /* WIN32_OPENGL_H */
| 51.780488 | 159 | 0.696185 |
4d4834938b380327236cf5eeab5ec41466b37385 | 360 | h | C | Dev/asd_cpp/core/Collision/2D/asd.CoreRectangleCollider.h | GCLemon/Altseed | b525740d64001aaed673552eb4ba3e98a321fcdf | [
"FTL"
] | 37 | 2015-07-12T14:21:03.000Z | 2020-10-17T03:08:17.000Z | Dev/asd_cpp/core/Collision/2D/asd.CoreRectangleCollider.h | GCLemon/Altseed | b525740d64001aaed673552eb4ba3e98a321fcdf | [
"FTL"
] | 91 | 2015-06-14T10:47:22.000Z | 2020-06-29T18:05:21.000Z | Dev/asd_cpp/core/Collision/2D/asd.CoreRectangleCollider.h | GCLemon/Altseed | b525740d64001aaed673552eb4ba3e98a321fcdf | [
"FTL"
] | 14 | 2015-07-13T04:15:20.000Z | 2021-09-30T01:34:51.000Z | #pragma once
#include "asd.CoreCollider2D.h"
#include "../common/Math/asd.Vector2DF.h"
#include "../common/Math/asd.RectF.h"
namespace asd
{
class CoreRectangleCollider
:public CoreCollider2D
{
public:
CoreRectangleCollider() {}
virtual ~CoreRectangleCollider() {}
virtual RectF GetArea() const = 0;
virtual void SetArea(RectF area) = 0;
};
}; | 20 | 41 | 0.713889 |
9e9a4e986cc2d9ceb76cde5d4986c364edaaab04 | 1,018 | h | C | cpp/SMLMLib/Context.h | qnano/photonpy | 9c03a1c9f4c2177c9c6fb3f2f16dfec2306006d4 | [
"MIT"
] | 5 | 2021-04-29T21:06:05.000Z | 2022-03-23T03:45:25.000Z | cpp/SMLMLib/Context.h | qnano/photonpy | 9c03a1c9f4c2177c9c6fb3f2f16dfec2306006d4 | [
"MIT"
] | null | null | null | cpp/SMLMLib/Context.h | qnano/photonpy | 9c03a1c9f4c2177c9c6fb3f2f16dfec2306006d4 | [
"MIT"
] | 1 | 2021-06-18T12:39:28.000Z | 2021-06-18T12:39:28.000Z | // Context class to manage C++ objects lifetime from python
//
// photonpy - Single molecule localization microscopy library
// © Jelmer Cnossen 2018-2021
#pragma once
#include "DLLMacros.h"
#include <unordered_set>
#include <mutex>
class Context;
class ContextObject;
class Context {
std::mutex mtx;
std::unordered_set<ContextObject*> objects;
public:
Context(int deviceIndex=0) : deviceIndex(deviceIndex) {}
DLL_EXPORT ~Context();
int GetDeviceIndex() { return deviceIndex; }
private:
int deviceIndex;
DLL_EXPORT void Add(ContextObject* obj);
DLL_EXPORT void Remove(ContextObject* obj);
friend class ContextObject;
};
class DLL_EXPORT ContextObject {
public:
ContextObject(Context*ctx=0) :context(0) { if(ctx) ctx->Add(this); }
virtual ~ContextObject();
void SetContext(Context* ctx);
Context* GetContext() { return context; }
protected:
void SetCudaDevice();
Context* context;
friend class Context;
};
CDLL_EXPORT Context* Context_Create();
CDLL_EXPORT void Context_Destroy(Context* ctx);
| 22.130435 | 69 | 0.752456 |
9ee18d34f49df298e22b6771b232cc3a7656154d | 1,642 | h | C | usr/libexec/cloudphotod/CPLCKFeatureAvailabilityRequest.h | lechium/tvOS144Headers | e22dcf52662ae03002e3a6d57273f54e74013cb0 | [
"MIT"
] | 2 | 2021-04-15T10:50:21.000Z | 2021-08-19T19:00:09.000Z | usr/sbin/usr/libexec/cloudphotod/CPLCKFeatureAvailabilityRequest.h | lechium/tvOS144Headers | e22dcf52662ae03002e3a6d57273f54e74013cb0 | [
"MIT"
] | null | null | null | usr/sbin/usr/libexec/cloudphotod/CPLCKFeatureAvailabilityRequest.h | lechium/tvOS144Headers | e22dcf52662ae03002e3a6d57273f54e74013cb0 | [
"MIT"
] | null | null | null | //
// Generated by classdumpios 1.0.1 (64 bit) (iOS port by DreamDevLost)(Debug version compiled Sep 26 2020 13:48:20).
//
// Copyright (C) 1997-2019 Steve Nygard.
//
#import <ProtocolBuffer/PBRequest.h>
#import "CKCodeOperationMessageMutation-Protocol.h"
#import "NSCopying-Protocol.h"
@class NSMutableArray, NSString;
@interface CPLCKFeatureAvailabilityRequest : PBRequest <CKCodeOperationMessageMutation, NSCopying>
{
NSMutableArray *_features; // 8 = 0x8
}
+ (Class)featuresType; // IMP=0x0000000100091c64
- (void).cxx_destruct; // IMP=0x0000000100092680
@property(retain, nonatomic) NSMutableArray *features; // @synthesize features=_features;
- (void)mergeFrom:(id)arg1; // IMP=0x0000000100092534
@property(readonly) unsigned long long hash;
- (_Bool)isEqual:(id)arg1; // IMP=0x000000010009247c
- (id)copyWithZone:(struct _NSZone *)arg1; // IMP=0x0000000100092304
- (void)copyTo:(id)arg1; // IMP=0x0000000100092230
- (void)writeTo:(id)arg1; // IMP=0x0000000100092104
- (_Bool)readFrom:(id)arg1; // IMP=0x00000001000920fc
- (id)dictionaryRepresentation; // IMP=0x0000000100091d24
@property(readonly, copy) NSString *description;
- (id)featuresAtIndex:(unsigned long long)arg1; // IMP=0x0000000100091c4c
- (unsigned long long)featuresCount; // IMP=0x0000000100091c34
- (void)addFeatures:(id)arg1; // IMP=0x0000000100091bc0
- (void)clearFeatures; // IMP=0x0000000100091ba8
- (void)substituteRecordTransports:(id)arg1; // IMP=0x000000010008da7c
- (id)extractRecordTransports; // IMP=0x000000010008da70
// Remaining properties
@property(readonly, copy) NSString *debugDescription;
@property(readonly) Class superclass;
@end
| 37.318182 | 120 | 0.767357 |
36e7b56612ac9c3e42b2d705c386b6792590a11b | 1,947 | h | C | fpdfsdk/cpdfsdk_annot.h | guidopola/pdfium | 4117500e4809c74ec7f800f1729dcffa2ce54874 | [
"BSD-3-Clause"
] | 38 | 2015-11-25T02:25:25.000Z | 2022-01-04T01:11:15.000Z | fpdfsdk/cpdfsdk_annot.h | guidopola/pdfium | 4117500e4809c74ec7f800f1729dcffa2ce54874 | [
"BSD-3-Clause"
] | 1 | 2017-02-14T01:38:56.000Z | 2017-02-15T06:01:13.000Z | fpdfsdk/cpdfsdk_annot.h | guidopola/pdfium | 4117500e4809c74ec7f800f1729dcffa2ce54874 | [
"BSD-3-Clause"
] | 13 | 2016-08-03T02:35:18.000Z | 2020-12-17T10:14:04.000Z | // Copyright 2016 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
#ifndef FPDFSDK_CPDFSDK_ANNOT_H_
#define FPDFSDK_CPDFSDK_ANNOT_H_
#include "core/fpdfdoc/cpdf_aaction.h"
#include "core/fpdfdoc/cpdf_annot.h"
#include "core/fpdfdoc/cpdf_defaultappearance.h"
#include "core/fxcrt/cfx_observable.h"
#include "core/fxcrt/fx_basic.h"
#include "fpdfsdk/cfx_systemhandler.h"
#include "fpdfsdk/fsdk_common.h"
#include "fpdfsdk/fsdk_define.h"
class CFX_Matrix;
class CFX_RenderDevice;
class CPDF_Page;
class CPDF_RenderOptions;
class CPDFSDK_PageView;
class CPDFSDK_Annot : public CFX_Observable<CPDFSDK_Annot> {
public:
explicit CPDFSDK_Annot(CPDFSDK_PageView* pPageView);
virtual ~CPDFSDK_Annot();
#ifdef PDF_ENABLE_XFA
virtual bool IsXFAField();
virtual CXFA_FFWidget* GetXFAWidget() const;
#endif // PDF_ENABLE_XFA
virtual FX_FLOAT GetMinWidth() const;
virtual FX_FLOAT GetMinHeight() const;
virtual int GetLayoutOrder() const;
virtual CPDF_Annot* GetPDFAnnot() const;
virtual CPDF_Annot::Subtype GetAnnotSubtype() const;
virtual bool IsSignatureWidget() const;
virtual CFX_FloatRect GetRect() const;
virtual void SetRect(const CFX_FloatRect& rect);
virtual void Annot_OnDraw(CFX_RenderDevice* pDevice,
CFX_Matrix* pUser2Device,
CPDF_RenderOptions* pOptions);
UnderlyingPageType* GetUnderlyingPage();
CPDF_Page* GetPDFPage();
#ifdef PDF_ENABLE_XFA
CPDFXFA_Page* GetPDFXFAPage();
#endif // PDF_ENABLE_XFA
void SetPage(CPDFSDK_PageView* pPageView);
CPDFSDK_PageView* GetPageView() const { return m_pPageView; }
bool IsSelected();
void SetSelected(bool bSelected);
protected:
CPDFSDK_PageView* m_pPageView;
bool m_bSelected;
};
#endif // FPDFSDK_CPDFSDK_ANNOT_H_
| 29.5 | 80 | 0.76528 |
32326d081851807cccf5e0d96bb536ac1362fcb5 | 3,512 | h | C | vendors/renesas/boards/rx65n-rsk/aws_tests/config_files/aws_test_ota_config.h | archigup/amazon-freertos | dcbe7a6553bca8a4ae3f5a93aaf737aa64214e88 | [
"MIT"
] | 2,637 | 2017-11-29T18:41:48.000Z | 2022-03-29T01:03:36.000Z | vendors/renesas/boards/rx65n-rsk/aws_tests/config_files/aws_test_ota_config.h | archigup/amazon-freertos | dcbe7a6553bca8a4ae3f5a93aaf737aa64214e88 | [
"MIT"
] | 1,926 | 2017-11-29T21:42:02.000Z | 2022-03-31T22:12:50.000Z | vendors/renesas/boards/rx65n-rsk/aws_tests/config_files/aws_test_ota_config.h | archigup/amazon-freertos | dcbe7a6553bca8a4ae3f5a93aaf737aa64214e88 | [
"MIT"
] | 1,384 | 2017-11-29T19:04:27.000Z | 2022-03-29T14:40:27.000Z | /*
* FreeRTOS V202012.00
* Copyright (C) 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
* the Software, and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* http://aws.amazon.com/freertos
* http://www.FreeRTOS.org
*/
/**
* @file aws_test_ota_config.h
* @brief Port-specific variables for firmware Over-the-Air Update tests. */
#ifndef AWS_TEST_OTA_CONFIG_H_
#define AWS_TEST_OTA_CONFIG_H_
/**
* @brief Path to the OTA PAL test certificate used to verify the signature.
*
* If applicable, the device must be pre-provisioned with this certificate.
* Please see tests/integration_test/ota_pal/test_files for the set of
* certificates.
*/
#define otatestpalCERTIFICATE_FILE "ecdsa-sha256-signer.crt.pem"
/**
* @brief Some boards have a hard-coded name for the firmware image to boot.
*/
#define otatestpalFIRMWARE_FILE "dummy.bin"
/**
* @brief Some boards OTA PAL layers will use the file names passed into it for the
* image and the certificates because their non-volatile memory is abstracted by a
* file system. Set this to 1 if that is the case for your device.
*/
#define otatestpalUSE_FILE_SYSTEM 0
/**
* @brief 1 if otaPAL_CheckFileSignature is implemented in ota_pal.c.
*/
#define otatestpalCHECK_FILE_SIGNATURE_SUPPORTED 1
/**
* @brief 1 if otaPAL_ReadAndAssumeCertificate is implemented in ota_pal.c.
*/
#define otatestpalREAD_AND_ASSUME_CERTIFICATE_SUPPORTED 1
/**
* @brief 1 if using PKCS #11 to access the code sign certificate from NVM.
*/
#define otatestpalREAD_CERTIFICATE_FROM_NVM_WITH_PKCS11 1
/**
* @brief Include of signature testing data applicable to this device.
*/
#include "aws_test_ota_pal_ecdsa_sha256_signature.h"
/**
* @brief Major version of the firmware.
*
* This is used in the OTA demo to set the appFirmwareVersion variable that is
* declared in the ota_appversion32.h file in the OTA library.
*/
#define APP_VERSION_MAJOR 0
/**
* @brief Minor version of the firmware.
*
* This is used in the OTA demo to set the appFirmwareVersion variable that is
* declared in the ota_appversion32.h file in the OTA library.
*/
#define APP_VERSION_MINOR 9
/**
* @brief Build version of the firmware.
*
* This is used in the OTA demo to set the appFirmwareVersion variable that is
* declared in the ota_appversion32.h file in the OTA library.
*/
#define APP_VERSION_BUILD 2
#endif /* ifndef AWS_TEST_OTA_CONFIG_H_ */
| 35.474747 | 88 | 0.737756 |
2c8d00df434cd7518717ce4a31bc0feb6b0dae88 | 212 | h | C | Library/include/qt/Qt3DInput/qt3dinputversion.h | T3chy/WordAnalysis | 5ac2f2409a4be24b74468be0c907946f6276af26 | [
"PSF-2.0"
] | null | null | null | Library/include/qt/Qt3DInput/qt3dinputversion.h | T3chy/WordAnalysis | 5ac2f2409a4be24b74468be0c907946f6276af26 | [
"PSF-2.0"
] | null | null | null | Library/include/qt/Qt3DInput/qt3dinputversion.h | T3chy/WordAnalysis | 5ac2f2409a4be24b74468be0c907946f6276af26 | [
"PSF-2.0"
] | null | null | null | /* This file was generated by syncqt. */
#ifndef QT_QT3DINPUT_VERSION_H
#define QT_QT3DINPUT_VERSION_H
#define QT3DINPUT_VERSION_STR "5.9.4"
#define QT3DINPUT_VERSION 0x050904
#endif // QT_QT3DINPUT_VERSION_H
| 21.2 | 40 | 0.811321 |
d2ada6f3043fe1cb84bba13de493e00cf8ca72f3 | 1,371 | c | C | data-structures/reverselinkedlistusingrecursion.c | ayushi-khandelwal/c | 1e20fc14065b92164a1219c0a36fc22def72ae34 | [
"MIT"
] | 5 | 2017-10-06T13:35:57.000Z | 2020-10-18T13:55:27.000Z | data-structures/reverselinkedlistusingrecursion.c | ayushi-khandelwal/c | 1e20fc14065b92164a1219c0a36fc22def72ae34 | [
"MIT"
] | 10 | 2017-10-05T08:58:38.000Z | 2019-12-29T10:25:17.000Z | data-structures/reverselinkedlistusingrecursion.c | ayushi-khandelwal/c | 1e20fc14065b92164a1219c0a36fc22def72ae34 | [
"MIT"
] | 61 | 2017-10-05T09:09:05.000Z | 2021-10-03T17:36:08.000Z | #include<stdio.h>
#include<stdlib.h>
struct node
{
int data;
struct node* next;
};
struct node* head;
struct node* create_ll(int d)
{
struct node* ins =(struct node *) malloc(sizeof(struct node));
ins->data = d;
if(head == NULL)
{
head=ins;
ins->next = NULL;
}
else
{
struct node* temp = head;
while(temp->next != NULL)
{
temp = temp->next;
}
ins->next = NULL;
temp->next = ins;
}
return head;
}
void print()
{
struct node* temp = head;
while(temp != NULL)
{
printf("%d ",temp->data);
temp = temp->next;
}
printf("\n");
}
struct node* reverse(struct node* head)
{
if(head == NULL)
return NULL;
struct node* new_head;
if(head->next == NULL)
{
new_head = head;
return new_head;
}
new_head = reverse( head->next);
head->next->next = head;
head->next = NULL;
return new_head;
}
int main(void)
{
int n,i;
printf("enter the no. of nodes");
scanf("%d",&n);
head=NULL;
for(i = 0; i < n; i++)
{
int d;
scanf("%d",&d);
head = create_ll(d);
}
printf("linked list is : ");
print();
head = reverse(head);
printf("\nafter reverse linked list is : ");
print();
return 0;
}
| 16.719512 | 66 | 0.492341 |
d04e988b4cbef88dacc54db05681078b5b29d529 | 5,271 | c | C | drivers/gpu/drm/vkms/vkms_gem.c | YFShiftFinance/Unix | b82f0634af26793369af6df5fa9d374d0e09a54c | [
"MIT"
] | 1 | 2020-09-20T03:48:15.000Z | 2020-09-20T03:48:15.000Z | drivers/gpu/drm/vkms/vkms_gem.c | YFShiftFinance/Unix | b82f0634af26793369af6df5fa9d374d0e09a54c | [
"MIT"
] | null | null | null | drivers/gpu/drm/vkms/vkms_gem.c | YFShiftFinance/Unix | b82f0634af26793369af6df5fa9d374d0e09a54c | [
"MIT"
] | null | null | null | // SPDX-License-Identifier: GPL-2.0
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*/
#include <linux/shmem_fs.h>
#include "vkms_drv.h"
static struct vkms_gem_object *__vkms_gem_create(struct drm_device *dev,
u64 size)
{
struct vkms_gem_object *obj;
int ret;
obj = kzalloc(sizeof(*obj), GFP_KERNEL);
if (!obj)
return ERR_PTR(-ENOMEM);
size = roundup(size, PAGE_SIZE);
ret = drm_gem_object_init(dev, &obj->gem, size);
if (ret) {
kfree(obj);
return ERR_PTR(ret);
}
mutex_init(&obj->pages_lock);
return obj;
}
void vkms_gem_free_object(struct drm_gem_object *obj)
{
struct vkms_gem_object *gem = container_of(obj, struct vkms_gem_object,
gem);
WARN_ON(gem->pages);
WARN_ON(gem->vaddr);
mutex_destroy(&gem->pages_lock);
drm_gem_object_release(obj);
kfree(gem);
}
vm_fault_t vkms_gem_fault(struct vm_fault *vmf)
{
struct vm_area_struct *vma = vmf->vma;
struct vkms_gem_object *obj = vma->vm_private_data;
unsigned long vaddr = vmf->address;
pgoff_t page_offset;
loff_t num_pages;
vm_fault_t ret = VM_FAULT_SIGBUS;
page_offset = (vaddr - vma->vm_start) >> PAGE_SHIFT;
num_pages = DIV_ROUND_UP(obj->gem.size, PAGE_SIZE);
if (page_offset > num_pages)
return VM_FAULT_SIGBUS;
mutex_lock(&obj->pages_lock);
if (obj->pages) {
get_page(obj->pages[page_offset]);
vmf->page = obj->pages[page_offset];
ret = 0;
}
mutex_unlock(&obj->pages_lock);
if (ret) {
struct page *page;
struct address_space *mapping;
mapping = file_inode(obj->gem.filp)->i_mapping;
page = shmem_read_mapping_page(mapping, page_offset);
if (!IS_ERR(page)) {
vmf->page = page;
ret = 0;
} else {
switch (PTR_ERR(page)) {
case -ENOSPC:
case -ENOMEM:
ret = VM_FAULT_OOM;
break;
case -EBUSY:
ret = VM_FAULT_RETRY;
break;
case -EFAULT:
case -EINVAL:
ret = VM_FAULT_SIGBUS;
break;
default:
WARN_ON(PTR_ERR(page));
ret = VM_FAULT_SIGBUS;
break;
}
}
}
return ret;
}
struct drm_gem_object *vkms_gem_create(struct drm_device *dev,
struct drm_file *file,
u32 *handle,
u64 size)
{
struct vkms_gem_object *obj;
int ret;
if (!file || !dev || !handle)
return ERR_PTR(-EINVAL);
obj = __vkms_gem_create(dev, size);
if (IS_ERR(obj))
return ERR_CAST(obj);
ret = drm_gem_handle_create(file, &obj->gem, handle);
drm_gem_object_put_unlocked(&obj->gem);
if (ret) {
drm_gem_object_release(&obj->gem);
kfree(obj);
return ERR_PTR(ret);
}
return &obj->gem;
}
int vkms_dumb_create(struct drm_file *file, struct drm_device *dev,
struct drm_mode_create_dumb *args)
{
struct drm_gem_object *gem_obj;
u64 pitch, size;
if (!args || !dev || !file)
return -EINVAL;
pitch = args->width * DIV_ROUND_UP(args->bpp, 8);
size = pitch * args->height;
if (!size)
return -EINVAL;
gem_obj = vkms_gem_create(dev, file, &args->handle, size);
if (IS_ERR(gem_obj))
return PTR_ERR(gem_obj);
args->size = gem_obj->size;
args->pitch = pitch;
DRM_DEBUG_DRIVER("Created object of size %lld\n", size);
return 0;
}
int vkms_dumb_map(struct drm_file *file, struct drm_device *dev,
u32 handle, u64 *offset)
{
struct drm_gem_object *obj;
int ret;
obj = drm_gem_object_lookup(file, handle);
if (!obj)
return -ENOENT;
if (!obj->filp) {
ret = -EINVAL;
goto unref;
}
ret = drm_gem_create_mmap_offset(obj);
if (ret)
goto unref;
*offset = drm_vma_node_offset_addr(&obj->vma_node);
unref:
drm_gem_object_put_unlocked(obj);
return ret;
}
static struct page **_get_pages(struct vkms_gem_object *vkms_obj)
{
struct drm_gem_object *gem_obj = &vkms_obj->gem;
if (!vkms_obj->pages) {
struct page **pages = drm_gem_get_pages(gem_obj);
if (IS_ERR(pages))
return pages;
if (cmpxchg(&vkms_obj->pages, NULL, pages))
drm_gem_put_pages(gem_obj, pages, false, true);
}
return vkms_obj->pages;
}
void vkms_gem_vunmap(struct drm_gem_object *obj)
{
struct vkms_gem_object *vkms_obj = drm_gem_to_vkms_gem(obj);
mutex_lock(&vkms_obj->pages_lock);
if (vkms_obj->vmap_count < 1) {
WARN_ON(vkms_obj->vaddr);
WARN_ON(vkms_obj->pages);
mutex_unlock(&vkms_obj->pages_lock);
return;
}
vkms_obj->vmap_count--;
if (vkms_obj->vmap_count == 0) {
vunmap(vkms_obj->vaddr);
vkms_obj->vaddr = NULL;
drm_gem_put_pages(obj, vkms_obj->pages, false, true);
vkms_obj->pages = NULL;
}
mutex_unlock(&vkms_obj->pages_lock);
}
int vkms_gem_vmap(struct drm_gem_object *obj)
{
struct vkms_gem_object *vkms_obj = drm_gem_to_vkms_gem(obj);
int ret = 0;
mutex_lock(&vkms_obj->pages_lock);
if (!vkms_obj->vaddr) {
unsigned int n_pages = obj->size >> PAGE_SHIFT;
struct page **pages = _get_pages(vkms_obj);
if (IS_ERR(pages)) {
ret = PTR_ERR(pages);
goto out;
}
vkms_obj->vaddr = vmap(pages, n_pages, VM_MAP, PAGE_KERNEL);
if (!vkms_obj->vaddr)
goto err_vmap;
}
vkms_obj->vmap_count++;
goto out;
err_vmap:
ret = -ENOMEM;
drm_gem_put_pages(obj, vkms_obj->pages, false, true);
vkms_obj->pages = NULL;
out:
mutex_unlock(&vkms_obj->pages_lock);
return ret;
}
| 20.670588 | 72 | 0.691899 |
d0b374be8820c6ce400c388438677f3601971b59 | 584 | c | C | libctru/source/util/utf/utf32_to_utf16.c | kitling/TreeHome | 5a26eecdae80ff3707fecb76e9fb4de5f5de27bd | [
"MIT"
] | 2 | 2019-01-22T18:53:02.000Z | 2022-03-25T20:03:49.000Z | libctru/source/util/utf/utf32_to_utf16.c | kitling/TreeHome | 5a26eecdae80ff3707fecb76e9fb4de5f5de27bd | [
"MIT"
] | 1 | 2018-07-25T19:02:29.000Z | 2018-07-25T19:02:29.000Z | libctru/source/util/utf/utf32_to_utf16.c | kitling/TreeHome | 5a26eecdae80ff3707fecb76e9fb4de5f5de27bd | [
"MIT"
] | 2 | 2017-09-29T09:48:58.000Z | 2020-07-18T15:54:24.000Z | #include "3ds/types.h"
#include "3ds/util/utf.h"
ssize_t
utf32_to_utf16(uint16_t *out,
const uint32_t *in,
size_t len)
{
ssize_t rc = 0;
ssize_t units;
uint16_t encoded[2];
while(*in > 0)
{
units = encode_utf16(encoded, *in++);
if(units == -1)
return -1;
if(out != NULL)
{
if(rc + units <= len)
{
*out++ = encoded[0];
if(units > 1)
*out++ = encoded[1];
}
}
if(SSIZE_MAX - units >= rc)
rc += units;
else
return -1;
}
return rc;
}
| 15.783784 | 41 | 0.465753 |
653f6c54a348c5bf3c42f6f5b1904e9795720bb8 | 1,009 | h | C | client/include/AlertQueue.h | bendelec/Grandma | d7ac708b5357107a0e4b32e175c2e8cb71fdbcd8 | [
"MIT"
] | 2 | 2020-05-25T11:12:19.000Z | 2022-01-18T01:38:19.000Z | client/include/AlertQueue.h | bendelec/Grandma | d7ac708b5357107a0e4b32e175c2e8cb71fdbcd8 | [
"MIT"
] | 1 | 2020-03-28T03:47:22.000Z | 2020-03-28T03:47:22.000Z | client/include/AlertQueue.h | bendelec/Grandma | d7ac708b5357107a0e4b32e175c2e8cb71fdbcd8 | [
"MIT"
] | 1 | 2022-01-18T01:50:30.000Z | 2022-01-18T01:50:30.000Z | /**
* Alert queue for Grandma OMA-DM client
*
* (c) Christian Bendele
*
* TODO: unfinished architecture. Rewrite comment once architecture more clear
*
* This class will manage the queue of outstanding Alerts.
*
* It will contain methods for adding alerts and for serializing them for sending
* them to the server in P1 and P3.
*
* It should later contain some logic for keeping track which alerts were
* successfully sent to the server, and then remove them from the queue (TODO)
*
*/
#ifndef GRANDMA_ALERTQUEUE_H
#define GRANDMA_ALERTQUEUE_H
#include <deque>
#include <nlohmann/json.hpp>
namespace Grandma {
struct Alert {
std::string AlertType;
std::string SourceURI;
std::string TargetURI;
std::string Mark;
std::string DataType;
std::string Data;
bool in_transit;
Alert(std::string AlertType);
};
class AlertQueue {
std::deque<Alert> alert_queue;
public:
nlohmann::json package_alert_json();
void add_alert(Alert alert);
};
} // namespace
#endif
| 17.396552 | 81 | 0.720515 |
a9e9234fff32fa7157872eeea92bdd1b13a19a9a | 4,374 | h | C | src/openms/include/OpenMS/QC/IdentificationSummary.h | JangJang3/OpenMS | 66e74389300350dfa21dcafa4b3d055e91424b6e | [
"BSL-1.0",
"Zlib",
"Apache-2.0"
] | 1 | 2017-12-18T09:01:54.000Z | 2017-12-18T09:01:54.000Z | src/openms/include/OpenMS/QC/IdentificationSummary.h | JangJang3/OpenMS | 66e74389300350dfa21dcafa4b3d055e91424b6e | [
"BSL-1.0",
"Zlib",
"Apache-2.0"
] | 4 | 2016-03-03T09:42:34.000Z | 2019-05-22T14:30:06.000Z | src/openms/include/OpenMS/QC/IdentificationSummary.h | timosachsenberg/OpenMS | fe62fff281daa2623977a1f2aafb4444b2c36513 | [
"BSL-1.0",
"Zlib",
"Apache-2.0"
] | null | null | null | // --------------------------------------------------------------------------
// OpenMS -- Open-Source Mass Spectrometry
// --------------------------------------------------------------------------
// Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
// ETH Zurich, and Freie Universitaet Berlin 2002-2020.
//
// This software is released under a three-clause BSD license:
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// * Neither the name of any author or any participating institution
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
// For a full list of authors, refer to the file AUTHORS.
// --------------------------------------------------------------------------
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL ANY OF THE AUTHORS OR THE CONTRIBUTING
// INSTITUTIONS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// --------------------------------------------------------------------------
// $Maintainer: Axel Walter $
// $Authors: Axel Walter $
// --------------------------------------------------------------------------
#pragma once
#include <OpenMS/QC/QCBase.h>
#include <OpenMS/METADATA/ProteinIdentification.h>
#include <OpenMS/METADATA/PeptideIdentification.h>
#include <vector>
/**
* @brief Detected Proteins/Peptides as a Proteomics QC metric
*
* Simple class to return a summary of detected proteins/peptides
* from a given idXML file.
*
*/
namespace OpenMS
{
class OPENMS_DLLAPI IdentificationSummary : public QCBase
{
public:
/// Constructor
IdentificationSummary() = default;
/// Destructor
virtual ~IdentificationSummary() = default;
// small struct for unique peptide / protein identifications (considering sequence only)
// count: number of unique identifiecations, fdr_threshold: significance threshold if score type is FDR, else -1
struct OPENMS_DLLAPI UniqueID
{
UInt count = 0;
float fdr_threshold = -1.0;
};
// stores identification summary values calculated by compute function
struct OPENMS_DLLAPI Result
{
UInt peptide_spectrum_matches = 0;
UniqueID unique_peptides;
UniqueID unique_proteins;
float missed_cleavages_mean = 0;
double protein_hit_scores_mean = 0;
double peptide_length_mean = 0;
bool operator==(const Result& rhs) const;
};
/**
@brief computes a summary of an idXML file
@param prot_ids vector with ProteinIdentifications
@param pep_ids vector with PeptideIdentifications
@return result object with summary values:
total number of PSM (peptide_spectrum_matches),
number of identified peptides with given FDR threshold (unique_peptides),
number of identified proteins with given FDR threshold (unique_proteins),
missed cleavages mean (missed_cleavages_mean),
identification score mean of protein hits (protein_hit_scores_mean),
identified peptide lengths mean (peptide_length_mean)
**/
Result compute(std::vector<ProteinIdentification>& prot_ids,
std::vector<PeptideIdentification>& pep_ids);
const String& getName() const override;
QCBase::Status requires() const override;
private:
const String name_ = "Summary of detected Proteins and Peptides from idXML file";
};
}
| 41.264151 | 116 | 0.663695 |
b747f9eae0d30ce2105539a4dabc32b17fe8aa7f | 1,606 | h | C | ICG/include/icg/static_detector.h | XiaoJake/3DObjectTracking | c1fbf9241a0cd1ce450a1d6b86c67613025e1836 | [
"MIT"
] | 1 | 2022-03-17T08:17:47.000Z | 2022-03-17T08:17:47.000Z | ICG/include/icg/static_detector.h | 0smile/3DObjectTracking | c1fbf9241a0cd1ce450a1d6b86c67613025e1836 | [
"MIT"
] | null | null | null | ICG/include/icg/static_detector.h | 0smile/3DObjectTracking | c1fbf9241a0cd1ce450a1d6b86c67613025e1836 | [
"MIT"
] | null | null | null | // SPDX-License-Identifier: MIT
// Copyright (c) 2022 Manuel Stoiber, German Aerospace Center (DLR)
#ifndef ICG_INCLUDE_ICG_STATIC_DETECTOR_H_
#define ICG_INCLUDE_ICG_STATIC_DETECTOR_H_
#include <icg/body.h>
#include <icg/common.h>
#include <icg/detector.h>
#include <filesystem/filesystem.h>
#include <Eigen/Geometry>
#include <iostream>
#include <opencv2/opencv.hpp>
#include <string>
namespace icg {
/**
* \brief \ref Detector that assigns a defined pose to a referenced \ref Body
* object.
*
* @param body_ptr referenced \ref Body object for which the pose is set.
* @param body2world_pose pose that is assigned to the \ref Body object.
*/
class StaticDetector : public Detector {
public:
// Constructor and setup method
StaticDetector(const std::string &name, const std::shared_ptr<Body> &body_ptr,
const Transform3fA &body2world_pose);
StaticDetector(const std::string &name,
const std::filesystem::path &metafile_path,
const std::shared_ptr<icg::Body> &body_ptr);
bool SetUp() override;
// Setters
void set_body_ptr(const std::shared_ptr<Body> &body_ptr);
void set_body2world_pose(const Transform3fA &body2world_pose);
// Main methods
bool DetectBody() override;
// Getters
const std::shared_ptr<Body> &body_ptr() const;
const Transform3fA &body2world_pose() const;
std::vector<std::shared_ptr<Body>> body_ptrs() const override;
private:
bool LoadMetaData();
std::shared_ptr<Body> body_ptr_{};
Transform3fA body2world_pose_{};
};
} // namespace icg
#endif // ICG_INCLUDE_ICG_STATIC_DETECTOR_H_
| 27.689655 | 80 | 0.725405 |
ecce8e1509dfa1f81bbfdecaedfb37903087d324 | 15,683 | h | C | content/browser/service_worker/service_worker_context_wrapper.h | metux/chromium-deb | 3c08e9b89a1b6f95f103a61ff4f528dbcd57fc42 | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | null | null | null | content/browser/service_worker/service_worker_context_wrapper.h | metux/chromium-deb | 3c08e9b89a1b6f95f103a61ff4f528dbcd57fc42 | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | null | null | null | content/browser/service_worker/service_worker_context_wrapper.h | metux/chromium-deb | 3c08e9b89a1b6f95f103a61ff4f528dbcd57fc42 | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | null | null | null | // Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CONTEXT_WRAPPER_H_
#define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CONTEXT_WRAPPER_H_
#include <stdint.h>
#include <memory>
#include <string>
#include <vector>
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "base/observer_list.h"
#include "base/observer_list_threadsafe.h"
#include "content/browser/service_worker/service_worker_context_core.h"
#include "content/browser/service_worker/service_worker_context_core_observer.h"
#include "content/common/content_export.h"
#include "content/common/worker_url_loader_factory_provider.mojom.h"
#include "content/public/browser/service_worker_context.h"
namespace base {
class FilePath;
class SingleThreadTaskRunner;
}
namespace storage {
class QuotaManagerProxy;
class SpecialStoragePolicy;
}
namespace content {
class BrowserContext;
class ChromeBlobStorageContext;
class ResourceContext;
class ServiceWorkerContextObserver;
class StoragePartitionImpl;
class URLLoaderFactoryGetter;
// A refcounted wrapper class for our core object. Higher level content lib
// classes keep references to this class on mutliple threads. The inner core
// instance is strictly single threaded and is not refcounted, the core object
// is what is used internally in the service worker lib.
class CONTENT_EXPORT ServiceWorkerContextWrapper
: NON_EXPORTED_BASE(public ServiceWorkerContext),
public ServiceWorkerContextCoreObserver,
public base::RefCountedThreadSafe<ServiceWorkerContextWrapper> {
public:
using StatusCallback = base::Callback<void(ServiceWorkerStatusCode)>;
using BoolCallback = base::Callback<void(bool)>;
using FindRegistrationCallback =
ServiceWorkerStorage::FindRegistrationCallback;
using GetRegistrationsInfosCallback =
ServiceWorkerStorage::GetRegistrationsInfosCallback;
using GetUserDataCallback = ServiceWorkerStorage::GetUserDataCallback;
using GetUserDataForAllRegistrationsCallback =
ServiceWorkerStorage::GetUserDataForAllRegistrationsCallback;
ServiceWorkerContextWrapper(BrowserContext* browser_context);
// Init and Shutdown are for use on the UI thread when the profile,
// storagepartition is being setup and torn down.
// |blob_context| and |url_loader_factory_getter| are used only
// when IsServicificationEnabled is true.
void Init(const base::FilePath& user_data_directory,
storage::QuotaManagerProxy* quota_manager_proxy,
storage::SpecialStoragePolicy* special_storage_policy,
ChromeBlobStorageContext* blob_context,
URLLoaderFactoryGetter* url_loader_factory_getter);
void Shutdown();
// Must be called on the IO thread.
void InitializeResourceContext(ResourceContext* resource_context);
// Deletes all files on disk and restarts the system asynchronously. This
// leaves the system in a disabled state until it's done. This should be
// called on the IO thread.
void DeleteAndStartOver();
// The StoragePartition should only be used on the UI thread.
// Can be null before/during init and during/after shutdown.
StoragePartitionImpl* storage_partition() const;
void set_storage_partition(StoragePartitionImpl* storage_partition);
// The ResourceContext for the associated BrowserContext. This should only
// be accessed on the IO thread, and can be null during initialization and
// shutdown.
ResourceContext* resource_context();
// The process manager can be used on either UI or IO.
ServiceWorkerProcessManager* process_manager() {
return process_manager_.get();
}
// ServiceWorkerContextCoreObserver implementation:
void OnRegistrationStored(int64_t registration_id,
const GURL& pattern) override;
// ServiceWorkerContext implementation:
void AddObserver(ServiceWorkerContextObserver* observer) override;
void RemoveObserver(ServiceWorkerContextObserver* observer) override;
void RegisterServiceWorker(const GURL& pattern,
const GURL& script_url,
const ResultCallback& continuation) override;
void UnregisterServiceWorker(const GURL& pattern,
const ResultCallback& continuation) override;
void GetAllOriginsInfo(const GetUsageInfoCallback& callback) override;
void DeleteForOrigin(const GURL& origin,
const ResultCallback& callback) override;
void CheckHasServiceWorker(
const GURL& url,
const GURL& other_url,
const CheckHasServiceWorkerCallback& callback) override;
void CountExternalRequestsForTest(
const GURL& url,
const CountExternalRequestsCallback& callback) override;
void StopAllServiceWorkersForOrigin(const GURL& origin) override;
void ClearAllServiceWorkersForTest(const base::Closure& callback) override;
bool StartingExternalRequest(int64_t service_worker_version_id,
const std::string& request_uuid) override;
bool FinishedExternalRequest(int64_t service_worker_version_id,
const std::string& request_uuid) override;
void StartServiceWorkerForNavigationHint(
const GURL& document_url,
const StartServiceWorkerForNavigationHintCallback& callback) override;
void StartActiveWorkerForPattern(const GURL& pattern,
StartActiveWorkerCallback info_callback,
base::OnceClosure failure_callback) override;
// These methods must only be called from the IO thread.
ServiceWorkerRegistration* GetLiveRegistration(int64_t registration_id);
ServiceWorkerVersion* GetLiveVersion(int64_t version_id);
std::vector<ServiceWorkerRegistrationInfo> GetAllLiveRegistrationInfo();
std::vector<ServiceWorkerVersionInfo> GetAllLiveVersionInfo();
// Must be called from the IO thread.
void HasMainFrameProviderHost(const GURL& origin,
const BoolCallback& callback) const;
// Returns all render process ids and frame ids for the given |origin|.
std::unique_ptr<
std::vector<std::pair<int /* render process id */, int /* frame id */>>>
GetProviderHostIds(const GURL& origin) const;
// Returns the registration whose scope longest matches |document_url|. It is
// guaranteed that the returned registration has the activated worker.
//
// - If the registration is not found, returns ERROR_NOT_FOUND.
// - If the registration has neither the waiting version nor the active
// version, returns ERROR_NOT_FOUND.
// - If the registration does not have the active version but has the waiting
// version, activates the waiting version and runs |callback| when it is
// activated.
//
// Must be called from the IO thread.
void FindReadyRegistrationForDocument(
const GURL& document_url,
const FindRegistrationCallback& callback);
// Returns the registration for |scope|. It is guaranteed that the returned
// registration has the activated worker.
//
// - If the registration is not found, returns ERROR_NOT_FOUND.
// - If the registration has neither the waiting version nor the active
// version, returns ERROR_NOT_FOUND.
// - If the registration does not have the active version but has the waiting
// version, activates the waiting version and runs |callback| when it is
// activated.
//
// Must be called from the IO thread.
void FindReadyRegistrationForPattern(
const GURL& scope,
const FindRegistrationCallback& callback);
// Returns the registration for |registration_id|. It is guaranteed that the
// returned registration has the activated worker.
//
// - If the registration is not found, returns ERROR_NOT_FOUND.
// - If the registration has neither the waiting version nor the active
// version, returns ERROR_NOT_FOUND.
// - If the registration does not have the active version but has the waiting
// version, activates the waiting version and runs |callback| when it is
// activated.
//
// Must be called from the IO thread.
void FindReadyRegistrationForId(int64_t registration_id,
const GURL& origin,
const FindRegistrationCallback& callback);
// Returns the registration for |registration_id|. It is guaranteed that the
// returned registration has the activated worker.
//
// Generally |FindReadyRegistrationForId| should be used to look up a
// registration by |registration_id| since it's more efficient. But if a
// |registration_id| is all that is available this method can be used instead.
//
// - If the registration is not found, returns ERROR_NOT_FOUND.
// - If the registration has neither the waiting version nor the active
// version, returns ERROR_NOT_FOUND.
// - If the registration does not have the active version but has the waiting
// version, activates the waiting version and runs |callback| when it is
// activated.
//
// Must be called from the IO thread.
void FindReadyRegistrationForIdOnly(int64_t registration_id,
const FindRegistrationCallback& callback);
// All these methods must be called from the IO thread.
void GetAllRegistrations(const GetRegistrationsInfosCallback& callback);
void GetRegistrationUserData(int64_t registration_id,
const std::vector<std::string>& keys,
const GetUserDataCallback& callback);
void GetRegistrationUserDataByKeyPrefix(int64_t registration_id,
const std::string& key_prefix,
const GetUserDataCallback& callback);
void StoreRegistrationUserData(
int64_t registration_id,
const GURL& origin,
const std::vector<std::pair<std::string, std::string>>& key_value_pairs,
const StatusCallback& callback);
void ClearRegistrationUserData(int64_t registration_id,
const std::vector<std::string>& keys,
const StatusCallback& callback);
void GetUserDataForAllRegistrations(
const std::string& key,
const GetUserDataForAllRegistrationsCallback& callback);
void GetUserDataForAllRegistrationsByKeyPrefix(
const std::string& key_prefix,
const GetUserDataForAllRegistrationsCallback& callback);
// This function can be called from any thread, but the callback will always
// be called on the UI thread.
void StartServiceWorker(const GURL& pattern, const StatusCallback& callback);
// This function can be called from any thread.
void SkipWaitingWorker(const GURL& pattern);
// These methods can be called from any thread.
void UpdateRegistration(const GURL& pattern);
void SetForceUpdateOnPageLoad(bool force_update_on_page_load);
void AddObserver(ServiceWorkerContextCoreObserver* observer);
void RemoveObserver(ServiceWorkerContextCoreObserver* observer);
bool is_incognito() const { return is_incognito_; }
// Must be called from the IO thread.
bool OriginHasForeignFetchRegistrations(const GURL& origin);
// Binds the ServiceWorkerWorkerClient of a dedicated (or shared) worker to
// the parent frame's ServiceWorkerProviderHost. (This is used only when
// off-main-thread-fetch is enabled.)
void BindWorkerFetchContext(
int render_process_id,
int service_worker_provider_id,
mojom::ServiceWorkerWorkerClientAssociatedPtrInfo client_ptr_info);
private:
friend class BackgroundSyncManagerTest;
friend class base::RefCountedThreadSafe<ServiceWorkerContextWrapper>;
friend class EmbeddedWorkerTestHelper;
friend class EmbeddedWorkerBrowserTest;
friend class ForeignFetchRequestHandler;
friend class ServiceWorkerDispatcherHost;
friend class ServiceWorkerInternalsUI;
friend class ServiceWorkerNavigationHandleCore;
friend class ServiceWorkerProcessManager;
friend class ServiceWorkerRequestHandler;
friend class ServiceWorkerVersionBrowserTest;
friend class MockServiceWorkerContextWrapper;
~ServiceWorkerContextWrapper() override;
void InitInternal(
const base::FilePath& user_data_directory,
std::unique_ptr<ServiceWorkerDatabaseTaskManager> database_task_manager,
const scoped_refptr<base::SingleThreadTaskRunner>& disk_cache_thread,
storage::QuotaManagerProxy* quota_manager_proxy,
storage::SpecialStoragePolicy* special_storage_policy,
ChromeBlobStorageContext* blob_context,
URLLoaderFactoryGetter* url_loader_factory_getter);
void ShutdownOnIO();
void DidFindRegistrationForFindReady(
const FindRegistrationCallback& callback,
ServiceWorkerStatusCode status,
scoped_refptr<ServiceWorkerRegistration> registration);
void OnStatusChangedForFindReadyRegistration(
const FindRegistrationCallback& callback,
scoped_refptr<ServiceWorkerRegistration> registration);
void DidDeleteAndStartOver(ServiceWorkerStatusCode status);
void DidGetAllRegistrationsForGetAllOrigins(
const GetUsageInfoCallback& callback,
ServiceWorkerStatusCode status,
const std::vector<ServiceWorkerRegistrationInfo>& registrations);
void DidCheckHasServiceWorker(const CheckHasServiceWorkerCallback& callback,
content::ServiceWorkerCapability status);
void DidFindRegistrationForUpdate(
ServiceWorkerStatusCode status,
scoped_refptr<content::ServiceWorkerRegistration> registration);
void StartServiceWorkerForNavigationHintOnIO(
const GURL& document_url,
const StartServiceWorkerForNavigationHintCallback& callback);
void DidFindRegistrationForNavigationHint(
const StartServiceWorkerForNavigationHintCallback& callback,
ServiceWorkerStatusCode status,
scoped_refptr<ServiceWorkerRegistration> registration);
void DidStartServiceWorkerForNavigationHint(
const GURL& pattern,
const StartServiceWorkerForNavigationHintCallback& callback,
ServiceWorkerStatusCode code);
void RecordStartServiceWorkerForNavigationHintResult(
const StartServiceWorkerForNavigationHintCallback& callback,
StartServiceWorkerForNavigationHintResult result);
// The core context is only for use on the IO thread.
// Can be null before/during init, during/after shutdown, and after
// DeleteAndStartOver fails.
ServiceWorkerContextCore* context();
// Observers of |context_core_| which live within content's implementation
// boundary. Shared with |context_core_|.
const scoped_refptr<
base::ObserverListThreadSafe<ServiceWorkerContextCoreObserver>>
core_observer_list_;
// Observers which live outside content's implementation boundary. Observer
// methods will always be dispatched on the UI thread.
base::ObserverList<ServiceWorkerContextObserver> observer_list_;
const std::unique_ptr<ServiceWorkerProcessManager> process_manager_;
// Cleared in ShutdownOnIO():
std::unique_ptr<ServiceWorkerContextCore> context_core_;
// Initialized in Init(); true if the user data directory is empty.
bool is_incognito_;
// Raw pointer to the StoragePartitionImpl owning |this|.
StoragePartitionImpl* storage_partition_;
// The ResourceContext associated with this context.
ResourceContext* resource_context_;
DISALLOW_COPY_AND_ASSIGN(ServiceWorkerContextWrapper);
};
} // namespace content
#endif // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CONTEXT_WRAPPER_H_
| 43.443213 | 80 | 0.754192 |
8337a7deedde5887c9da4ff16531b9fbcbf33dc2 | 325 | h | C | src/device/peripheral/mros-dev/mros-src/api/mros_topic_callback.h | mikoto2000/athrill-1 | 70bc17fa2915d5bde544779424d4eb7149b5da3b | [
"OLDAP-2.6"
] | 44 | 2018-03-14T02:13:09.000Z | 2022-01-23T20:14:48.000Z | src/device/peripheral/mros-dev/mros-src/api/mros_topic_callback.h | mikoto2000/athrill-1 | 70bc17fa2915d5bde544779424d4eb7149b5da3b | [
"OLDAP-2.6"
] | 46 | 2020-06-09T08:55:02.000Z | 2021-11-13T06:58:50.000Z | src/device/peripheral/mros-dev/mros-src/api/mros_topic_callback.h | mikoto2000/athrill-1 | 70bc17fa2915d5bde544779424d4eb7149b5da3b | [
"OLDAP-2.6"
] | 11 | 2018-03-14T02:06:49.000Z | 2020-12-04T15:31:28.000Z | #ifndef _MROS_INTEGRATION_H_
#define _MROS_INTEGRATION_H_
#ifdef __cplusplus
extern "C" {
#endif
#include "mros_types.h"
extern void mros_topic_callback(mros_uint32 topic_id, mros_uint32 type_id, mRosFuncIdType func_id, const char *data, mros_uint32 len);
#ifdef __cplusplus
}
#endif
#endif /* _MROS_INTEGRATION_H_ */
| 17.105263 | 134 | 0.793846 |
836ba91ac1d42faf65d5fb4aaf1f775231617e7b | 12,980 | c | C | test/stringTest.c | qawse3dr/cstringlib | 61ff53dc890918d54e973b8e991d0a05f8bf425b | [
"MIT"
] | null | null | null | test/stringTest.c | qawse3dr/cstringlib | 61ff53dc890918d54e973b8e991d0a05f8bf425b | [
"MIT"
] | null | null | null | test/stringTest.c | qawse3dr/cstringlib | 61ff53dc890918d54e973b8e991d0a05f8bf425b | [
"MIT"
] | null | null | null | /**test units for String lib*/
#include "String.h"
#include <string.h>
#include <stdio.h>
void test(char* testDesc,int testResult){
//keeps track of test number
static int testNum = 0;
static int pass = 0;
static int fail = 0;
testNum++;
if(strcmp(testDesc,"Done") == 0){
printf("Testing complete\n");
printf("\n\nRESULT\n");
printf("------\n");
printf("\nTests Failed: %d\n",fail);
printf("Tests Passed: %d\n",pass);
return;
}
printf("Test %d (%s): ",testNum,testDesc);
if(testResult){
printf("PASS\n");
pass++;
} else{
fail++;
printf("\033[0;31m");
printf("FAIL\n");
printf("\033[0m");
}
}
int main(){
//test createString and setString with NULL
printf("Create String test\n");
printf("------------------\n\n");
test("Creating string with NULL",!createString(NULL));
test("freeString With NULL PASS if it doesn't crash",1);
freeString(NULL);
//test1 string creation
String hello = createString("Hello World!");
String bye = createString("bye");
//one line tests
test("Creating a string hello",strcmp(hello->data, "Hello World!") == 0 );
printf("\n");
printf("checking value for string\n");
printf("-------------------------\n\n");
test("charAt(hello,0)",'H' == charAt(hello,0));
test("charAt(hello,-1)",'\0' == charAt(hello,-1));
test("charAt(hello,100)",'\0' == charAt(hello,100));
printf("\n");
printf("Testing strcmp functions\n");
printf("-----------------------\n\n");
test("Checking value for getString",strcmp(hello->data,getString(hello)) == 0);
test("Checking for correct Length",hello->length == 12);
test("stringcmp(\"Hello World!\", \"bye\")",stringcmp(hello,bye));
test("stringcmp(\"Hello World!\", \"Hello World!\"",stringcmp(hello,hello) == 0);
test("stringcmp(NULL,NULL)",stringcmp(NULL,NULL));
test("stringcmp(NULL,NULL)",stringcmp(hello,NULL));
test("stringcmp(NULL,NULL)",stringcmp(NULL,bye));
test("stringcmpC(\"Hello World!\", \"Hello World!\")",stringcmpC(hello,"Hello World!") == 0);
test("stringcmpC(\"Hello World!\", \"bye\")",stringcmpC(hello,"bye"));
test("stringcmpC(NULL,NULL)",stringcmpC(NULL,NULL));
test("stringcmpC(NULL,NULL)",stringcmpC(hello,NULL));
test("stringcmpC(NULL,NULL)",stringcmpC(NULL,"Hello"));
printf("\n");
printf("Test set fuctions\n");
printf("-----------------\n\n");
//test setCharAt
setCharAt(hello,0,'B');
test("setCharAt(hello,0,\'B\')",charAt(hello,0));
//testing setString
setString(hello,bye);
test("changing value of hello to \"bye\" using SetString",stringcmp(hello,bye) == 0);
test("Checking hellos length was changed to 3",hello->length == 3);
setStringC(hello,"test");
test("changing value of hello to \"test\" using SetString",stringcmpC(hello,"test") == 0);
test("Checking hellos length was changed to 4",hello->length == 4);
printf("\n");
printf("Test for concat functions\n");
printf("-------------------------\n\n");
//testing concat function
stringcat(1,hello,bye);
test("concating bye to hello",stringcmpC(hello,"testbye") == 0);
stringcat(2,hello,bye,bye);
test("concating bye 2 times to hello",stringcmpC(hello,"testbyebyebye") == 0);
stringcatC(1,bye,"hello");
test("concating \"hello\" to bye",stringcmpC(bye,"byehello") == 0);
stringcatC(2,bye,"hello","hello");
test("concating \"hello\" 2 times to bye",stringcmpC(bye,"byehellohellohello") == 0);
setStringC(bye,"hello");
stringcatChar(5,bye,'h','e','l','l','o');
test("concating chars \"hello\" to bye",stringcmpC(bye,"hellohello") == 0);
//testing copy string
freeString(bye);
printf("\n");
printf("Test starts with and ends with functions\n");
printf("----------------------------------------\n\n");
setStringC(hello,"hello");
bye = copyString(hello);
test("Checking copy string", stringcmp(bye,hello) == 0 && bye->data != hello->data);
//testing starts with and ends with function
test("starts with when equal",stringStartsWith(hello,bye));
test("ends with when equal",stringStartsWith(hello,bye));
test("char* starts with when equal",stringStartsWithC(hello,"hello"));
test("char* ends with when equal",stringStartsWithC(hello,"hello"));
setStringC(bye,"bye");
test("starts with when not equal",!stringStartsWith(hello,bye));
test("ends with when not equal",!stringStartsWith(hello,bye));
test("char* starts with when not equal",!stringStartsWithC(bye,"hello"));
test("char* ends with when not equal",!stringStartsWithC(bye,"hello"));
setStringC(hello,"ye");
test("ends with when end equal",stringEndsWith(bye,hello));
test("char* ends with when end equal",stringEndsWithC(bye,"ye"));
setStringC(hello,"by");
test("starts with when start equal",stringStartsWith(bye,hello));
test("char* starts with when start equal",stringStartsWithC(hello,"by"));
//testing for null parameters
test("starts with with null parameters",!stringStartsWith(hello,NULL));
test("starts with with null parameters 2",!stringStartsWith(NULL,hello));
test("starts with with null parameters 3",!stringStartsWith(NULL,NULL));
test("char* starts with with null parameters",!stringStartsWithC(hello,NULL));
test("char* starts with with null parameters 2",!stringStartsWithC(NULL,"hello"));
test("char* starts with with null parameters 3",!stringStartsWithC(NULL,NULL));
test("ends with with null parameters",!stringEndsWith(hello,NULL));
test("ends with with null parameters 2",!stringEndsWith(NULL,hello));
test("ends with with null parameters 3",!stringEndsWith(NULL,NULL));
test("ends with with null parameters",!stringEndsWithC(hello,NULL));
test("ends with with null parameters 2",!stringEndsWithC(NULL,"hello"));
test("ends starts with with null parameters 3",!stringEndsWithC(NULL,NULL));
printf("\n");
printf("Test trim\n");
printf("---------\n\n");
setStringC(hello," \t\n test \n\t\n ");
trim(hello);
test("test trim \"\\t\\n test \\n\\t\\n \"",stringcmpC(hello,"test") == 0);
test("strlength of trim test == 4",hello->length == 4);
printf("\n");
printf("String munipluation tests\n");
printf("-------------------------\n\n");
String fileName = createString("test/latin.txt");
String fileString = fileToString(fileName);
freeString(fileName);
//reads in content from latin.txt
FILE* fp = fopen("test/latin.txt","r");
char fileBuffer[10000];
int i;
//work done in loop
for(i = 0; (fileBuffer[i] = getc(fp)) != EOF; i++);
fileBuffer[i] = '\0';
fclose(fp);
fileName = createString("/not/a/file/txt");
test("test fileToString", stringcmpC(fileString,fileBuffer) == 0);
test("test fileToString with null value",!fileToString(NULL));
test("test fileToString with invalid file",!fileToString(fileName));
freeString(fileName);
printf("\n");
printf("test convertion from types to string\n");
printf("------------------------------------\n\n");
//create data for convertion testing
String stringChar = stringFromChar('a');
String stringInt = stringFromInt(100);
String stringFloat = stringFromFloat(10.222222,1);
//tests for convertion
test("test stringFromChar", stringcmpC(stringChar,"a") == 0);
test("test stringFromInt", stringcmpC(stringInt,"100") == 0);
test("test StringFromFloat", stringcmpC(stringFloat,"10.2") == 0);
//free data from testing
freeString(stringChar);
freeString(stringInt);
freeString(stringFloat);
printf("\n");
printf("test string search functions\n");
printf("----------------------------\n\n");
//uses string from stringFromFile
String searchString = createString("ea");
test("Tests string contains", stringContains(fileString,searchString));
setStringC(searchString,"test");
test("Tests string contains for string no in file", !stringContains(fileString,searchString));
test("test 1 String contains invalid args nulls",stringContains(NULL,NULL) == 0);
test("test 2 String contains invalid args nulls",stringContains(fileString,NULL) == 0);
test("test 3 String contains invalid args nulls",stringContains(NULL,searchString) == 0);
//tests stringContainsC
test("Tests string containsC", stringContainsC(fileString,"ea"));
test("Tests string contains for string no in fileC", !stringContainsC(fileString,"test"));
test("test 1 String containsC invalid args nulls",stringContainsC(NULL,NULL) == 0);
test("test 2 String containsC invalid args nulls",stringContainsC(fileString,NULL) == 0);
test("test 3 String containsC invalid args nulls",stringContainsC(NULL,"test") == 0);
//test countStrings
setStringC(searchString,"ea");
test("Tests string count for ea == 4",countString(fileString,searchString) == 4);
setStringC(searchString,"test");
test("Tests string count for test == 0",countString(fileString,searchString) == 0);
test("test 1 String invalid args nulls",countString(NULL,NULL) == 0);
test("test 2 String invalid args nulls",countString(fileString,NULL) == 0);
test("test 3 String invalid args nulls",countString(NULL,searchString) == 0);
//test countStringC
setStringC(searchString,"ea");
test("Tests string count for ea == 4",countStringC(fileString,"ea") == 4);
setStringC(searchString,"test");
test("Tests string count for test == 0",countStringC(fileString,"test") == 0);
test("test 1 String invalid args nulls",countStringC(NULL,NULL) == 0);
test("test 2 String invalid args nulls",countStringC(fileString,NULL) == 0);
test("test 3 String invalid args nulls",countStringC(NULL,"string") == 0);
String delimiter = createString("\n\t ");
Array* array = splitToArray(fileString,delimiter);
test("splitToArray ArrayLength", array->length == 98);
test("splitToArray index 0",stringcmpC(arrayGet(array,0),"Lorem") == 0);
test("splitToArray index 97",stringcmpC(arrayGet(array,97),"Persius") == 0);
test("splitToArray invalid args 1",!splitToArray(NULL,NULL));
test("splitToArray invalid args 2",!splitToArray(fileString,NULL));
test("splitToArray invalid args 3",!splitToArray(NULL,fileString));
freeArray(array);
array = splitToArrayC(fileString,"\n\t ");
test("splitToArrayC ArrayLength", array->length == 98);
test("splitToArrayC index 0",stringcmpC(arrayGet(array,0),"Lorem") == 0);
test("splitToArrayC index 97",stringcmpC(arrayGet(array,97),"Persius") == 0);
test("splitToArrayC invalid args 1",!splitToArrayC(NULL,NULL));
test("splitToArrayC invalid args 2",!splitToArrayC(fileString,NULL));
test("splitToArrayC invalid args 3",!splitToArrayC(NULL,"string"));
freeArray(array);
//split to list
List* list = splitToList(fileString,delimiter);
test("SplitToList length",list->length == 98);
test("SplitToList head",stringcmpC(getData(getHead(list)),"Lorem") == 0);
test("SplitToList tail",stringcmpC(getData(getTail(list)),"Persius") == 0);
test("SplitToList invalid args 1",!splitToList(NULL,NULL));
test("SplitToList invalid args 2",!splitToList(fileString,NULL));
test("SplitToList invalid args 3",!splitToList(NULL,delimiter));
freeList(list);
//split to listC
list = splitToListC(fileString,"\n\t ");
test("SplitToList length",list->length == 98);
test("SplitToList head",stringcmpC(getData(getHead(list)),"Lorem") == 0);
test("SplitToList tail",stringcmpC(getData(getTail(list)),"Persius") == 0);
test("SplitToList invalid args 1",!splitToListC(NULL,NULL));
test("SplitToList invalid args 2",!splitToListC(fileString,NULL));
test("SplitToList invalid args 3",!splitToListC(NULL,"string"));
freeList(list);
//test replace
setStringC(fileString,"This is a test string a apple is nice");
setStringC(hello,"apple");
setStringC(bye,"potato");
stringReplace(fileString,hello,bye);
test("test stringReplace",stringcmpC(fileString,"This is a test string a potato is nice") == 0);
test("test stringReplace strlength", fileString->length == 38);
test("test stringRepalce with invalid args if it doesn't crash it passes",1);
stringReplace(NULL,NULL,NULL);
stringReplace(fileString,NULL,NULL);
stringReplace(NULL,hello,NULL);
stringReplace(NULL,NULL,bye);
stringReplace(fileString,hello,NULL);
stringReplace(fileString,NULL,bye);
stringReplace(NULL,hello,bye);
//test replaceC
setStringC(fileString,"This is a test string a apple is nice");
stringReplaceC(fileString,"a","");
test("test stringReplaceC",stringcmpC(fileString,"This is test string pple is nice") == 0);
test("test stringReplaceC strlength", fileString->length == 34);
test("test stringReplaceC with invalid args if it doesn't crash it passes",1);
stringReplaceC(NULL,NULL,NULL);
stringReplaceC(fileString,NULL,NULL);
stringReplaceC(NULL,"hello",NULL);
stringReplaceC(NULL,NULL,"bye");
stringReplaceC(fileString,"hello",NULL);
stringReplaceC(fileString,NULL,"bye");
stringReplaceC(NULL,"hello","bye");
printf("\nfreeing Strings\n\n");
freeString(delimiter);
freeString(searchString);
freeString(hello);
freeString(bye);
freeString(fileString);
test("Done",1);
}
| 38.978979 | 98 | 0.683359 |
648989ca4971e5da3c167da7c42592c6510eaeb3 | 2,115 | h | C | usr/lib/libcoreroutine.dylib/RTWiFiFootprintMonitor.h | lechium/tvOS135Headers | 46cd30d3f0f7962eaa0c3f925cd71f414c65e2ac | [
"MIT"
] | 2 | 2020-07-26T20:30:54.000Z | 2020-08-10T04:26:23.000Z | usr/lib/libcoreroutine.dylib/RTWiFiFootprintMonitor.h | lechium/tvOS135Headers | 46cd30d3f0f7962eaa0c3f925cd71f414c65e2ac | [
"MIT"
] | 1 | 2020-07-26T20:45:31.000Z | 2020-08-09T09:30:46.000Z | usr/lib/libcoreroutine.dylib/RTWiFiFootprintMonitor.h | lechium/tvOS135Headers | 46cd30d3f0f7962eaa0c3f925cd71f414c65e2ac | [
"MIT"
] | null | null | null | /*
* This header is generated by classdump-dyld 1.0
* on Sunday, June 7, 2020 at 11:42:00 AM Mountain Standard Time
* Operating System: Version 13.4.5 (Build 17L562)
* Image Source: /usr/lib/libcoreroutine.dylib
* classdump-dyld is licensed under GPLv3, Copyright © 2013-2016 by Elias Limneos.
*/
#import <libcoreroutine.dylib/RTService.h>
@class RTPersistentTimer, NSMutableArray, RTWiFiManager;
@interface RTWiFiFootprintMonitor : RTService {
long long _footprintState;
RTPersistentTimer* _scanTimer;
NSMutableArray* _scanResults;
RTWiFiManager* _wifiManager;
}
@property (assign,nonatomic) long long footprintState; //@synthesize footprintState=_footprintState - In the implementation block
@property (nonatomic,retain) RTPersistentTimer * scanTimer; //@synthesize scanTimer=_scanTimer - In the implementation block
@property (nonatomic,retain) NSMutableArray * scanResults; //@synthesize scanResults=_scanResults - In the implementation block
@property (nonatomic,retain) RTWiFiManager * wifiManager; //@synthesize wifiManager=_wifiManager - In the implementation block
+(id)footprintStateToString:(long long)arg1 ;
-(id)init;
-(void)_start;
-(RTWiFiManager *)wifiManager;
-(void)setWifiManager:(RTWiFiManager *)arg1 ;
-(void)_stop;
-(void)_shutdown;
-(NSMutableArray *)scanResults;
-(void)setScanResults:(NSMutableArray *)arg1 ;
-(RTPersistentTimer *)scanTimer;
-(void)setScanTimer:(RTPersistentTimer *)arg1 ;
-(void)internalAddObserver:(id)arg1 name:(id)arg2 ;
-(void)internalRemoveObserver:(id)arg1 name:(id)arg2 ;
-(id)initWithWiFiManager:(id)arg1 ;
-(void)onWiFiManagerNotificationScanResults:(id)arg1 ;
-(void)onWiFiManagerNotificationPowerStatusChanged:(id)arg1 ;
-(void)setFootprintState:(long long)arg1 ;
-(void)_processScanResults:(id)arg1 ;
-(void)_handlePowerStatusChanged:(unsigned long long)arg1 ;
-(long long)_footprintStateForScanResults:(id)arg1 ;
-(void)_pruneScanResults;
-(void)_checkFootprint;
-(void)fetchConstantFootprintStatusForScanResults:(id)arg1 withHandler:(/*^block*/id)arg2 ;
-(long long)footprintState;
@end
| 40.673077 | 147 | 0.767376 |
d6c7d670a79857dc9353579da2acb41ca62d1da9 | 8,755 | h | C | C++/src/proto/cpp/messages_robocup_ssl_wrapper_legacy.pb.h | Nlict-RC/SSL_Tutorials | d43c463d259abb9b4e5ef84500b501f8d189a4e1 | [
"MIT"
] | 3 | 2020-03-23T03:17:34.000Z | 2021-11-29T11:45:54.000Z | C++/src/proto/cpp/messages_robocup_ssl_wrapper_legacy.pb.h | Nlict-RC/SSL_Tutorials | d43c463d259abb9b4e5ef84500b501f8d189a4e1 | [
"MIT"
] | null | null | null | C++/src/proto/cpp/messages_robocup_ssl_wrapper_legacy.pb.h | Nlict-RC/SSL_Tutorials | d43c463d259abb9b4e5ef84500b501f8d189a4e1 | [
"MIT"
] | 2 | 2019-05-14T08:27:09.000Z | 2019-06-20T12:58:44.000Z | // Generated by the protocol buffer compiler. DO NOT EDIT!
// source: messages_robocup_ssl_wrapper_legacy.proto
#ifndef PROTOBUF_messages_5frobocup_5fssl_5fwrapper_5flegacy_2eproto__INCLUDED
#define PROTOBUF_messages_5frobocup_5fssl_5fwrapper_5flegacy_2eproto__INCLUDED
#include <string>
#include <google/protobuf/stubs/common.h>
#if GOOGLE_PROTOBUF_VERSION < 2006000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/unknown_field_set.h>
#include "messages_robocup_ssl_detection.pb.h"
#include "messages_robocup_ssl_geometry_legacy.pb.h"
// @@protoc_insertion_point(includes)
namespace RoboCup2014Legacy {
namespace Wrapper {
// Internal implementation detail -- do not call these.
void protobuf_AddDesc_messages_5frobocup_5fssl_5fwrapper_5flegacy_2eproto();
void protobuf_AssignDesc_messages_5frobocup_5fssl_5fwrapper_5flegacy_2eproto();
void protobuf_ShutdownFile_messages_5frobocup_5fssl_5fwrapper_5flegacy_2eproto();
class SSL_WrapperPacket;
// ===================================================================
class SSL_WrapperPacket : public ::google::protobuf::Message {
public:
SSL_WrapperPacket();
virtual ~SSL_WrapperPacket();
SSL_WrapperPacket(const SSL_WrapperPacket& from);
inline SSL_WrapperPacket& operator=(const SSL_WrapperPacket& from) {
CopyFrom(from);
return *this;
}
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _unknown_fields_;
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return &_unknown_fields_;
}
static const ::google::protobuf::Descriptor* descriptor();
static const SSL_WrapperPacket& default_instance();
void Swap(SSL_WrapperPacket* other);
// implements Message ----------------------------------------------
SSL_WrapperPacket* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const SSL_WrapperPacket& from);
void MergeFrom(const SSL_WrapperPacket& from);
void Clear();
bool IsInitialized() const;
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const;
::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
int GetCachedSize() const { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
public:
::google::protobuf::Metadata GetMetadata() const;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// optional .SSL_DetectionFrame detection = 1;
inline bool has_detection() const;
inline void clear_detection();
static const int kDetectionFieldNumber = 1;
inline const ::SSL_DetectionFrame& detection() const;
inline ::SSL_DetectionFrame* mutable_detection();
inline ::SSL_DetectionFrame* release_detection();
inline void set_allocated_detection(::SSL_DetectionFrame* detection);
// optional .RoboCup2014Legacy.Geometry.SSL_GeometryData geometry = 2;
inline bool has_geometry() const;
inline void clear_geometry();
static const int kGeometryFieldNumber = 2;
inline const ::RoboCup2014Legacy::Geometry::SSL_GeometryData& geometry() const;
inline ::RoboCup2014Legacy::Geometry::SSL_GeometryData* mutable_geometry();
inline ::RoboCup2014Legacy::Geometry::SSL_GeometryData* release_geometry();
inline void set_allocated_geometry(::RoboCup2014Legacy::Geometry::SSL_GeometryData* geometry);
// @@protoc_insertion_point(class_scope:RoboCup2014Legacy.Wrapper.SSL_WrapperPacket)
private:
inline void set_has_detection();
inline void clear_has_detection();
inline void set_has_geometry();
inline void clear_has_geometry();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::uint32 _has_bits_[1];
mutable int _cached_size_;
::SSL_DetectionFrame* detection_;
::RoboCup2014Legacy::Geometry::SSL_GeometryData* geometry_;
friend void protobuf_AddDesc_messages_5frobocup_5fssl_5fwrapper_5flegacy_2eproto();
friend void protobuf_AssignDesc_messages_5frobocup_5fssl_5fwrapper_5flegacy_2eproto();
friend void protobuf_ShutdownFile_messages_5frobocup_5fssl_5fwrapper_5flegacy_2eproto();
void InitAsDefaultInstance();
static SSL_WrapperPacket* default_instance_;
};
// ===================================================================
// ===================================================================
// SSL_WrapperPacket
// optional .SSL_DetectionFrame detection = 1;
inline bool SSL_WrapperPacket::has_detection() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SSL_WrapperPacket::set_has_detection() {
_has_bits_[0] |= 0x00000001u;
}
inline void SSL_WrapperPacket::clear_has_detection() {
_has_bits_[0] &= ~0x00000001u;
}
inline void SSL_WrapperPacket::clear_detection() {
if (detection_ != NULL) detection_->::SSL_DetectionFrame::Clear();
clear_has_detection();
}
inline const ::SSL_DetectionFrame& SSL_WrapperPacket::detection() const {
// @@protoc_insertion_point(field_get:RoboCup2014Legacy.Wrapper.SSL_WrapperPacket.detection)
return detection_ != NULL ? *detection_ : *default_instance_->detection_;
}
inline ::SSL_DetectionFrame* SSL_WrapperPacket::mutable_detection() {
set_has_detection();
if (detection_ == NULL) detection_ = new ::SSL_DetectionFrame;
// @@protoc_insertion_point(field_mutable:RoboCup2014Legacy.Wrapper.SSL_WrapperPacket.detection)
return detection_;
}
inline ::SSL_DetectionFrame* SSL_WrapperPacket::release_detection() {
clear_has_detection();
::SSL_DetectionFrame* temp = detection_;
detection_ = NULL;
return temp;
}
inline void SSL_WrapperPacket::set_allocated_detection(::SSL_DetectionFrame* detection) {
delete detection_;
detection_ = detection;
if (detection) {
set_has_detection();
} else {
clear_has_detection();
}
// @@protoc_insertion_point(field_set_allocated:RoboCup2014Legacy.Wrapper.SSL_WrapperPacket.detection)
}
// optional .RoboCup2014Legacy.Geometry.SSL_GeometryData geometry = 2;
inline bool SSL_WrapperPacket::has_geometry() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SSL_WrapperPacket::set_has_geometry() {
_has_bits_[0] |= 0x00000002u;
}
inline void SSL_WrapperPacket::clear_has_geometry() {
_has_bits_[0] &= ~0x00000002u;
}
inline void SSL_WrapperPacket::clear_geometry() {
if (geometry_ != NULL) geometry_->::RoboCup2014Legacy::Geometry::SSL_GeometryData::Clear();
clear_has_geometry();
}
inline const ::RoboCup2014Legacy::Geometry::SSL_GeometryData& SSL_WrapperPacket::geometry() const {
// @@protoc_insertion_point(field_get:RoboCup2014Legacy.Wrapper.SSL_WrapperPacket.geometry)
return geometry_ != NULL ? *geometry_ : *default_instance_->geometry_;
}
inline ::RoboCup2014Legacy::Geometry::SSL_GeometryData* SSL_WrapperPacket::mutable_geometry() {
set_has_geometry();
if (geometry_ == NULL) geometry_ = new ::RoboCup2014Legacy::Geometry::SSL_GeometryData;
// @@protoc_insertion_point(field_mutable:RoboCup2014Legacy.Wrapper.SSL_WrapperPacket.geometry)
return geometry_;
}
inline ::RoboCup2014Legacy::Geometry::SSL_GeometryData* SSL_WrapperPacket::release_geometry() {
clear_has_geometry();
::RoboCup2014Legacy::Geometry::SSL_GeometryData* temp = geometry_;
geometry_ = NULL;
return temp;
}
inline void SSL_WrapperPacket::set_allocated_geometry(::RoboCup2014Legacy::Geometry::SSL_GeometryData* geometry) {
delete geometry_;
geometry_ = geometry;
if (geometry) {
set_has_geometry();
} else {
clear_has_geometry();
}
// @@protoc_insertion_point(field_set_allocated:RoboCup2014Legacy.Wrapper.SSL_WrapperPacket.geometry)
}
// @@protoc_insertion_point(namespace_scope)
} // namespace Wrapper
} // namespace RoboCup2014Legacy
#ifndef SWIG
namespace google {
namespace protobuf {
} // namespace google
} // namespace protobuf
#endif // SWIG
// @@protoc_insertion_point(global_scope)
#endif // PROTOBUF_messages_5frobocup_5fssl_5fwrapper_5flegacy_2eproto__INCLUDED
| 36.327801 | 114 | 0.752599 |
d91c44505cee8e54f4d00e2f3d1399d5aa3dcbc5 | 5,598 | h | C | aws-cpp-sdk-lookoutequipment/include/aws/lookoutequipment/model/ListDatasetsRequest.h | perfectrecall/aws-sdk-cpp | fb8cbebf2fd62720b65aeff841ad2950e73d8ebd | [
"Apache-2.0"
] | 1 | 2022-02-12T08:09:30.000Z | 2022-02-12T08:09:30.000Z | aws-cpp-sdk-lookoutequipment/include/aws/lookoutequipment/model/ListDatasetsRequest.h | perfectrecall/aws-sdk-cpp | fb8cbebf2fd62720b65aeff841ad2950e73d8ebd | [
"Apache-2.0"
] | 1 | 2022-01-03T23:59:37.000Z | 2022-01-03T23:59:37.000Z | aws-cpp-sdk-lookoutequipment/include/aws/lookoutequipment/model/ListDatasetsRequest.h | ravindra-wagh/aws-sdk-cpp | 7d5ff01b3c3b872f31ca98fb4ce868cd01e97696 | [
"Apache-2.0"
] | 1 | 2021-12-30T04:25:33.000Z | 2021-12-30T04:25:33.000Z | /**
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
* SPDX-License-Identifier: Apache-2.0.
*/
#pragma once
#include <aws/lookoutequipment/LookoutEquipment_EXPORTS.h>
#include <aws/lookoutequipment/LookoutEquipmentRequest.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <utility>
namespace Aws
{
namespace LookoutEquipment
{
namespace Model
{
/**
*/
class AWS_LOOKOUTEQUIPMENT_API ListDatasetsRequest : public LookoutEquipmentRequest
{
public:
ListDatasetsRequest();
// Service request name is the Operation name which will send this request out,
// each operation should has unique request name, so that we can get operation's name from this request.
// Note: this is not true for response, multiple operations may have the same response name,
// so we can not get operation's name from response.
inline virtual const char* GetServiceRequestName() const override { return "ListDatasets"; }
Aws::String SerializePayload() const override;
Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
/**
* <p> An opaque pagination token indicating where to continue the listing of
* datasets. </p>
*/
inline const Aws::String& GetNextToken() const{ return m_nextToken; }
/**
* <p> An opaque pagination token indicating where to continue the listing of
* datasets. </p>
*/
inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
/**
* <p> An opaque pagination token indicating where to continue the listing of
* datasets. </p>
*/
inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }
/**
* <p> An opaque pagination token indicating where to continue the listing of
* datasets. </p>
*/
inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }
/**
* <p> An opaque pagination token indicating where to continue the listing of
* datasets. </p>
*/
inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }
/**
* <p> An opaque pagination token indicating where to continue the listing of
* datasets. </p>
*/
inline ListDatasetsRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}
/**
* <p> An opaque pagination token indicating where to continue the listing of
* datasets. </p>
*/
inline ListDatasetsRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}
/**
* <p> An opaque pagination token indicating where to continue the listing of
* datasets. </p>
*/
inline ListDatasetsRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}
/**
* <p> Specifies the maximum number of datasets to list. </p>
*/
inline int GetMaxResults() const{ return m_maxResults; }
/**
* <p> Specifies the maximum number of datasets to list. </p>
*/
inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
/**
* <p> Specifies the maximum number of datasets to list. </p>
*/
inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }
/**
* <p> Specifies the maximum number of datasets to list. </p>
*/
inline ListDatasetsRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}
/**
* <p>The beginning of the name of the datasets to be listed. </p>
*/
inline const Aws::String& GetDatasetNameBeginsWith() const{ return m_datasetNameBeginsWith; }
/**
* <p>The beginning of the name of the datasets to be listed. </p>
*/
inline bool DatasetNameBeginsWithHasBeenSet() const { return m_datasetNameBeginsWithHasBeenSet; }
/**
* <p>The beginning of the name of the datasets to be listed. </p>
*/
inline void SetDatasetNameBeginsWith(const Aws::String& value) { m_datasetNameBeginsWithHasBeenSet = true; m_datasetNameBeginsWith = value; }
/**
* <p>The beginning of the name of the datasets to be listed. </p>
*/
inline void SetDatasetNameBeginsWith(Aws::String&& value) { m_datasetNameBeginsWithHasBeenSet = true; m_datasetNameBeginsWith = std::move(value); }
/**
* <p>The beginning of the name of the datasets to be listed. </p>
*/
inline void SetDatasetNameBeginsWith(const char* value) { m_datasetNameBeginsWithHasBeenSet = true; m_datasetNameBeginsWith.assign(value); }
/**
* <p>The beginning of the name of the datasets to be listed. </p>
*/
inline ListDatasetsRequest& WithDatasetNameBeginsWith(const Aws::String& value) { SetDatasetNameBeginsWith(value); return *this;}
/**
* <p>The beginning of the name of the datasets to be listed. </p>
*/
inline ListDatasetsRequest& WithDatasetNameBeginsWith(Aws::String&& value) { SetDatasetNameBeginsWith(std::move(value)); return *this;}
/**
* <p>The beginning of the name of the datasets to be listed. </p>
*/
inline ListDatasetsRequest& WithDatasetNameBeginsWith(const char* value) { SetDatasetNameBeginsWith(value); return *this;}
private:
Aws::String m_nextToken;
bool m_nextTokenHasBeenSet;
int m_maxResults;
bool m_maxResultsHasBeenSet;
Aws::String m_datasetNameBeginsWith;
bool m_datasetNameBeginsWithHasBeenSet;
};
} // namespace Model
} // namespace LookoutEquipment
} // namespace Aws
| 34.555556 | 151 | 0.688817 |
d9691369cac05dfc757704cabd1c9ca1980f1525 | 407 | h | C | PrivateFrameworks/SafariShared/WBSHistoryLoader-Protocol.h | phatblat/macOSPrivateFrameworks | 9047371eb80f925642c8a7c4f1e00095aec66044 | [
"MIT"
] | 17 | 2018-11-13T04:02:58.000Z | 2022-01-20T09:27:13.000Z | PrivateFrameworks/SafariShared/WBSHistoryLoader-Protocol.h | phatblat/macOSPrivateFrameworks | 9047371eb80f925642c8a7c4f1e00095aec66044 | [
"MIT"
] | 3 | 2018-04-06T02:02:27.000Z | 2018-10-02T01:12:10.000Z | PrivateFrameworks/SafariShared/WBSHistoryLoader-Protocol.h | phatblat/macOSPrivateFrameworks | 9047371eb80f925642c8a7c4f1e00095aec66044 | [
"MIT"
] | 1 | 2018-09-28T13:54:23.000Z | 2018-09-28T13:54:23.000Z | //
// Generated by class-dump 3.5 (64 bit).
//
// class-dump is Copyright (C) 1997-1998, 2000-2001, 2004-2013 by Steve Nygard.
//
#import "NSObject.h"
@class NSURL;
@protocol WBSHistoryLoader <NSObject>
- (void)waitForLoadingToComplete;
- (void)startLoading;
- (id)initWithURL:(NSURL *)arg1 itemCountLimit:(unsigned long long)arg2 historyAgeLimit:(double)arg3 historyItemClass:(Class)arg4;
@end
| 23.941176 | 130 | 0.724816 |
6c521d6abeaf9defad41ee0024360f4e729175ab | 271 | h | C | student-distrib/interrupts-exceptions/idt.h | SidiqJ/Linux-Kernel-OS | 137be5869ee77e436e618f657cecf539a80acf70 | [
"MIT"
] | null | null | null | student-distrib/interrupts-exceptions/idt.h | SidiqJ/Linux-Kernel-OS | 137be5869ee77e436e618f657cecf539a80acf70 | [
"MIT"
] | null | null | null | student-distrib/interrupts-exceptions/idt.h | SidiqJ/Linux-Kernel-OS | 137be5869ee77e436e618f657cecf539a80acf70 | [
"MIT"
] | null | null | null | #pragma once
#include "../x86_desc.h"
#include "../lib.h"
#include "interruptHandlers.h"
#include "exceptionHandlers.h"
#include "../linkages/isr_wrapper.h"
#include "../linkages/syscall_wrapper.h"
#define SYS_CALL 0x80
// initializes the idt
extern void init_idt();
| 18.066667 | 40 | 0.730627 |
8c0b006c1635e162c92d55a3153587f28ec1e0e7 | 3,511 | h | C | include/eforce/Exception.h | sphaerophoria/eforce | 9dc608334d2dd92ddf646cb76c71f9d6fb5d8524 | [
"MIT"
] | null | null | null | include/eforce/Exception.h | sphaerophoria/eforce | 9dc608334d2dd92ddf646cb76c71f9d6fb5d8524 | [
"MIT"
] | null | null | null | include/eforce/Exception.h | sphaerophoria/eforce | 9dc608334d2dd92ddf646cb76c71f9d6fb5d8524 | [
"MIT"
] | null | null | null | #pragma once
#include <eforce/BuiltinConstant.h>
#include <eforce/CompiletimeRegistry.h>
namespace eforce
{
using GenExceptionPtrFnPtr_t = std::exception_ptr(*)();
/// Information to store for exception forcing
struct ThrowInfo
{
constexpr ThrowInfo(
void* throwAddr,
char const* file,
int line,
char const* exceptionStr,
GenExceptionPtrFnPtr_t const& fn)
: throwAddr(throwAddr)
, file(file)
, line(line)
, exceptionStr(exceptionStr)
, GetException(fn)
{}
/// Approximate address of throw
void* const throwAddr;
/// File containing throw
char const* const file;
/// Line containing throw
int const line;
/// Stringized exception constructor
char const* const exceptionStr;
/**
* @brief Gets an exception ptr which mimics the exception thrown from this
* location. May be null in the case that the exception constructor params
* are not constexpr.
*/
GenExceptionPtrFnPtr_t const& GetException;
};
/**
* @brief Helper union to cast a lambda to our GenExceptionPtrFnPtr_t. Given that we only
* use this in scenarios where we've guaranteed that the lambda in question takes no
* input we can safely cast this way. This union helps us get around the casting rules
* in constexpr contexts. See reasoning in the THROW_REGISTERED_EXCEPTION_HELPER macro
*/
template <typename T>
union LambdaCastHelper
{
decltype(&T::operator()) memFn;
GenExceptionPtrFnPtr_t ptr;
constexpr LambdaCastHelper()
: memFn(&T::operator())
{ }
constexpr LambdaCastHelper(GenExceptionPtrFnPtr_t ptr)
: ptr(ptr) {}
};
} // namespace eforce
#define THROW_CAT_HELPER(a, b) a ## b
#define THROW_CAT(a, b) THROW_CAT_HELPER(a, b)
#define UNIQUE_THROW_LABEL(__counter) THROW_CAT(THROW_LABEL_START, __counter)
#define THROW_REGISTERED_EXCEPTION_HELPER(__counter, __etype, ...) do { \
UNIQUE_THROW_LABEL(__counter): \
/*
* We capture by reference here, but as long as IS_CONSTEXPR is doing it's job
* we won't actually try to use anything unless all passed in arguments are
* constexpr. This means it's safe to capture by reference because either
* 1. It's a constant expression stored in a static memory location (safe to
* access)
* 2. It's somewhere else and we won't try.
* Because of this it's also safe to cast operator() from the lambda into a
* regular function pointer, which we do with a little union trickery.
*/ \
static auto genExceptionFn = [&] { return std::make_exception_ptr(__etype(__VA_ARGS__)); }; \
static constexpr auto __fn = (IS_CONSTEXPR(true, ##__VA_ARGS__)) \
? ::eforce::LambdaCastHelper<decltype(genExceptionFn)>() \
: ::eforce::LambdaCastHelper<decltype(genExceptionFn)>(nullptr); \
static constexpr ::eforce::ThrowInfo throwInfo( \
&&UNIQUE_THROW_LABEL(__counter), __FILE__, __LINE__, #__etype "(" #__VA_ARGS__ ")", __fn.ptr); \
COMPILETIME_REGISTER(&throwInfo, "throw_locations" ); \
throw __etype(__VA_ARGS__); \
} while(0)
/**
* @brief Throws an exception, but first registers it for exception forcing later.
* If all inputs are constexpr we will be able to throw this exception later
* without any user input. If they are not constexpr we will need a little help
* populating the exception
* @param[in] __etype The type of exception to throw
* @param[in] vaargs Constructor arguments for __etype
*/
#define THROW_REGISTERED_EXCEPTION(__etype, ...) \
THROW_REGISTERED_EXCEPTION_HELPER(__COUNTER__, __etype, ##__VA_ARGS__)
| 34.762376 | 99 | 0.725719 |
15cbd258d0ec5672da90f9ae213f246a1c23ddec | 1,014 | h | C | utests/fixtures/fixtures.h | yapbreak/libyaplog | 384dc86d14f0d4663337f26d3340d8b3082bbbc0 | [
"WTFPL"
] | null | null | null | utests/fixtures/fixtures.h | yapbreak/libyaplog | 384dc86d14f0d4663337f26d3340d8b3082bbbc0 | [
"WTFPL"
] | null | null | null | utests/fixtures/fixtures.h | yapbreak/libyaplog | 384dc86d14f0d4663337f26d3340d8b3082bbbc0 | [
"WTFPL"
] | null | null | null | #ifndef FIXTURES_H_BL2ZH1S6
#define FIXTURES_H_BL2ZH1S6
#include <map>
#include <string>
#include <cstring>
#include <CppUTest/TestHarness.h>
#define DIM_OF(array) (sizeof(array) / sizeof((array)[0]))
#include "exposed_conf.h"
inline void check_file_content(const char *filename, const std::string &expected)
{
FILE *f = fopen(filename, "rb");
if (f != NULL) {
if (expected.size() != 0) {
char *content = new char[expected.size() + 1];
memset(content, 0, expected.size() + 1);
UNSIGNED_LONGS_EQUAL(1, fread(content, expected.size(), 1, f));
STRCMP_EQUAL(expected.c_str(), content);
delete [] content;
}
char extra[1024] = { };
size_t ret = fread(extra, 1, 1024, f);
if (ret != 0) {
FAIL(extra);
}
UNSIGNED_LONGS_EQUAL(0, ret);
fclose(f);
} else {
UNSIGNED_LONGS_EQUAL(0, expected.size());
}
}
#endif /* end of include guard: FIXTURES_H_BL2ZH1S6 */
| 26.684211 | 81 | 0.586785 |
af7fc4b5e8ba9e2e5c6e976bf03b4d1aaf3b0e00 | 14,513 | h | C | lonestar/experimental/ordered/avi/main/AVIodgExplicit.h | lineagech/Galois | 5c7c0abaf7253cb354e35a3836147a960a37ad5b | [
"BSD-3-Clause"
] | null | null | null | lonestar/experimental/ordered/avi/main/AVIodgExplicit.h | lineagech/Galois | 5c7c0abaf7253cb354e35a3836147a960a37ad5b | [
"BSD-3-Clause"
] | null | null | null | lonestar/experimental/ordered/avi/main/AVIodgExplicit.h | lineagech/Galois | 5c7c0abaf7253cb354e35a3836147a960a37ad5b | [
"BSD-3-Clause"
] | null | null | null | /*
* This file belongs to the Galois project, a C++ library for exploiting
* parallelism. The code is being released under the terms of the 3-Clause BSD
* License (a copy is located in LICENSE.txt at the top-level directory).
*
* Copyright (C) 2018, The University of Texas at Austin. All rights reserved.
* UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING THIS
* SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR ANY PARTICULAR PURPOSE, NON-INFRINGEMENT AND WARRANTIES OF
* PERFORMANCE, AND ANY WARRANTY THAT MIGHT OTHERWISE ARISE FROM COURSE OF
* DEALING OR USAGE OF TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH
* RESPECT TO THE USE OF THE SOFTWARE OR DOCUMENTATION. Under no circumstances
* shall University be liable for incidental, special, indirect, direct or
* consequential damages or loss of profits, interruption of business, or
* related expenses which may arise from use of Software or Documentation,
* including but not limited to those resulting from defects in Software and/or
* Documentation, or loss or inaccuracy of data of any kind.
*/
#ifndef AVI_ODG_EXPLICIT_H
#define AVI_ODG_EXPLICIT_H
#include <string>
#include <sstream>
#include <limits>
#include <iostream>
#include <fstream>
#include <set>
#include <utility>
#include <cassert>
#include "AuxDefs.h"
#include "AVI.h"
#include "Element.h"
#include "AVIabstractMain.h"
/**
*
* Unordered AVI algorithm uses two key data structures
*
* 1) Element Adjacency Graph
* 2) in degree vector
*
* This graph has a node for each mesh element and
* keeps track of node-adjacency between AVI elements. Two elements
* are adjacent if they share a node in the mesh between them.
* We create a graph by connecting adjacent elements with an edge.
* Conceptually the edge is directed from the avi element with smaller
* time stamp to the greater one. But in implementation this direction
* information is not kept in the graph but in an array 'inDegVec', which has an
* entry corresponding to each AVI element. An avi element with 0 in edges has
* the minimum time stamp among its neighbors and is therefore eligible for an
* update It is assumed that AVI elements have unique integer id's
* 0..numElements-1, and the id is used to index into inDegVec
*
*/
//#define USE_LC_GRAPH
class AVIodgExplicit : public AVIabstractMain {
protected:
static const bool DEBUG = false;
#ifdef USE_LC_GRAPH
typedef galois::graphs::LC_CSR_Graph<AVI*, void> Graph;
typedef Graph::GraphNode GNode;
#else
typedef galois::graphs::MorphGraph<AVI*, void, false> Graph;
typedef Graph::GraphNode GNode;
#endif
Graph graph;
virtual const std::string getVersion() const {
return "ODG explicit, abstract locks on ODG nodes";
}
/**
* Generate element adjacency graph, where nodes are elements
* in the mesh, and there is an edge between the nodes if their
* corresponding elements share a vertex in the mesh
*
* @param meshInit
* @param g
*/
void genElemAdjGraph(const MeshInit& meshInit, const GlobalVec& g) {
#ifdef USE_LC_GRAPH
typedef galois::graphs::MorphGraph<AVI*, void, false> MGraph;
typedef MGraph::GraphNode MNode;
MGraph mgraph;
#else
Graph& mgraph = graph;
typedef GNode MNode;
#endif
std::vector<MNode> aviAdjNodes;
const std::vector<AVI*>& aviList = meshInit.getAVIVec();
for (std::vector<AVI*>::const_iterator i = aviList.begin(),
e = aviList.end();
i != e; ++i) {
AVI* avi = *i;
MNode gn = mgraph.createNode(avi);
mgraph.addNode(gn);
aviAdjNodes.push_back(gn);
}
// map where
// key is node id
// value is a list of avi elements that share this node
std::vector<std::vector<MNode>> nodeSharers(meshInit.getNumNodes());
// for (int i = 0; i < nodeSharers.size (); ++i) {
// nodeSharers[i] = new ArrayList<GNode<AVIAdjNode>> ();
// }
for (std::vector<MNode>::const_iterator i = aviAdjNodes.begin(),
ei = aviAdjNodes.end();
i != ei; ++i) {
MNode aviAdjN = *i;
AVI* avi = mgraph.getData(aviAdjN, galois::MethodFlag::UNPROTECTED);
const VecSize_t& conn = avi->getGeometry().getConnectivity();
for (VecSize_t::const_iterator j = conn.begin(), ej = conn.end(); j != ej;
++j) {
GlobalNodalIndex n = *j;
nodeSharers[n].push_back(aviAdjN);
}
}
int numEdges = 0;
for (std::vector<std::vector<MNode>>::const_iterator
it = nodeSharers.begin(),
ei = nodeSharers.end();
it != ei; ++it) {
const std::vector<MNode>& adjElms = *it;
// adjElms is the list of elements who share the node with id == current
// index pos in the array and therefore form a clique among themselves
for (size_t i = 0; i < adjElms.size(); ++i) {
// populate the upper triangle of the adj matrix
for (size_t j = i + 1; j < adjElms.size(); ++j) {
// if (!adjElms[i].hasNeighbor (adjElms[j])) {
if (mgraph.findEdge(adjElms[i], adjElms[j]) ==
mgraph.edge_end(adjElms[i])) {
++numEdges;
}
mgraph.addEdge(adjElms[i], adjElms[j]);
}
}
}
#ifdef USE_LC_GRAPH
graph.copyFromGraph(mgraph);
#endif
printf("Graph created with %u nodes and %d edges\n", graph.size(),
numEdges);
}
virtual void initRemaining(const MeshInit& meshInit, const GlobalVec& g) {
galois::StatTimer t_graph("Time spent in creating the graph: ");
t_graph.start();
genElemAdjGraph(meshInit, g);
t_graph.stop();
}
//! Functor for loop body
struct Process {
Graph& graph;
std::vector<int>& inDegVec;
MeshInit& meshInit;
GlobalVec& g;
PerThrdLocalVec& perIterLocalVec;
bool createSyncFiles;
IterCounter& iter;
Process(Graph& graph, std::vector<int>& inDegVec, MeshInit& meshInit,
GlobalVec& g, PerThrdLocalVec& perIterLocalVec,
bool createSyncFiles, IterCounter& iter)
:
graph(graph), inDegVec(inDegVec), meshInit(meshInit), g(g),
perIterLocalVec(perIterLocalVec), createSyncFiles(createSyncFiles),
iter(iter) {}
/**
* Loop body
*
* The loop body uses one-shot optimization, where we grab abstract locks on
* the node and its neighbors before performing the udpates. This removes
* the need for saving and performing undo operations.
*
*
* @param src is active elemtn
* @param lwl is the worklist handle
*/
template <typename ContextTy>
void operator()(GNode& src, ContextTy& lwl) {
// one-shot optimization: acquire abstract locks on active node and
// neighbors (all its neighbors, in this case) before performing any
// modifications
AVI* srcAVI = graph.getData(src, galois::MethodFlag::WRITE);
for (Graph::edge_iterator
e = graph.edge_begin(src, galois::MethodFlag::WRITE),
ende = graph.edge_end(src, galois::MethodFlag::WRITE);
e != ende; ++e) {
}
// past the fail-safe point now
int inDeg = inDegVec[srcAVI->getGlobalIndex()];
// assert inDeg == 0 : String.format ("active node %s with inDeg = %d\n",
// srcAVI, inDeg);
// // TODO: DEBUG
// std::cout << "Processing element: " << srcAVI->toString() <<
// std::endl;
assert(inDeg == 0);
LocalVec& l = *perIterLocalVec.getLocal();
AVIabstractMain::simulate(srcAVI, meshInit, g, l, createSyncFiles);
// update the inEdges count and determine
// which neighbor is at local minimum and needs to be added to the
// worklist
for (Graph::edge_iterator
e = graph.edge_begin(src, galois::MethodFlag::UNPROTECTED),
ende = graph.edge_end(src, galois::MethodFlag::UNPROTECTED);
e != ende; ++e) {
const GNode& dst = graph.getEdgeDst(e);
AVI* dstAVI = graph.getData(dst, galois::MethodFlag::UNPROTECTED);
if (AVIComparator::compare(srcAVI, dstAVI) > 0) {
// if srcAVI has a higher time stamp that dstAVI
++inDegVec[srcAVI->getGlobalIndex()];
int din = (--inDegVec[dstAVI->getGlobalIndex()]);
if (din == 0) {
// dstAVI has become minimum among its neighbors
if (dstAVI->getNextTimeStamp() < meshInit.getSimEndTime()) {
lwl.push(dst);
}
}
}
} // end for
if (inDegVec[srcAVI->getGlobalIndex()] == 0) {
// srcAVI is still the minimum among its neighbors
if (srcAVI->getNextTimeStamp() < meshInit.getSimEndTime()) {
lwl.push(src);
}
}
iter += 1;
// if (iter.get () == 5000) {
// meshInit.writeMesh ();
// meshInit.plotMeshCenters ();
// }
}
};
template <typename T>
void initWorkList(std::vector<GNode>& initWL, std::vector<T>& inDegVec) {
galois::StatTimer t_wl("Time to populate the worklist");
t_wl.start();
for (Graph::iterator i = graph.begin(), e = graph.end(); i != e; ++i) {
const GNode& src = *i;
AVI* srcAVI = graph.getData(src, galois::MethodFlag::UNPROTECTED);
// calculate the in degree of src by comparing it against its neighbors
for (Graph::edge_iterator
e = graph.edge_begin(src, galois::MethodFlag::UNPROTECTED),
ende = graph.edge_end(src, galois::MethodFlag::UNPROTECTED);
e != ende; ++e) {
GNode dst = graph.getEdgeDst(e);
AVI* dstAVI = graph.getData(dst, galois::MethodFlag::UNPROTECTED);
if (AVIComparator::compare(srcAVI, dstAVI) > 0) {
++inDegVec[srcAVI->getGlobalIndex()];
}
}
// if src is less than all its neighbors then add to initWL
if (inDegVec[srcAVI->getGlobalIndex()] == 0) {
initWL.push_back(src);
}
}
t_wl.stop();
printf("Initial worklist contains %zd elements\n", initWL.size());
}
public:
virtual void runLoop(MeshInit& meshInit, GlobalVec& g, bool createSyncFiles) {
/////////////////////////////////////////////////////////////////
// populate an initial worklist
/////////////////////////////////////////////////////////////////
std::vector<int> inDegVec(meshInit.getNumElements(), 0);
std::vector<GNode> initWL;
initWorkList(initWL, inDegVec);
// // TODO: DEBUG
// std::cout << "Initial Worklist = " << std::endl;
// for (size_t i = 0; i < initWL.size (); ++i) {
// std::cout << graph.getData (initWL[i],
// galois::MethodFlag::UNPROTECTED)->toString () << ", ";
// }
// std::cout << std::endl;
/////////////////////////////////////////////////////////////////
// perform the simulation
/////////////////////////////////////////////////////////////////
// uncomment to plot the mesh
meshInit.writeMesh();
// meshInit.plotMeshCenters ();
writeAdjacencyGraph(meshInit, graph);
// temporary matrices
size_t nrows = meshInit.getSpatialDim();
size_t ncols = meshInit.getNodesPerElem();
PerThrdLocalVec perIterLocalVec;
for (unsigned int i = 0; i < perIterLocalVec.size(); ++i)
*perIterLocalVec.getRemote(i) = LocalVec(nrows, ncols);
IterCounter iter;
Process p(graph, inDegVec, meshInit, g, perIterLocalVec, createSyncFiles,
iter);
galois::for_each(galois::iterate(initWL), p, galois::wl<AVIWorkList>());
printf("iterations = %zd\n", iter.reduce());
}
static void
writeAdjacencyGraph(const MeshInit& meshInit, Graph& graph,
const char* nodesFileName = "mesh-nodes.csv",
const char* edgesFileName = "mesh-edges.csv") {
if (meshInit.getSpatialDim() != 2) {
std::cerr << "implemented for 2D elements only" << std::endl;
abort();
}
FILE* nodesFile = fopen(nodesFileName, "w");
if (nodesFile == NULL) {
abort();
}
fprintf(nodesFile, "nodeId, inDeg, outDeg, centerX, centerY, timeStamp\n");
// a set of edges computed by picking outgoing edges for each node
std::vector<std::pair<GNode, GNode>> outEdges;
VecDouble center(meshInit.getSpatialDim(), 0.0);
for (Graph::iterator i = graph.begin(), e = graph.end(); i != e; ++i) {
const GNode& src = *i;
AVI* srcAVI = graph.getData(src, galois::MethodFlag::UNPROTECTED);
size_t inDeg = 0;
// calculate the in degree of src by comparing it against its neighbors
for (Graph::edge_iterator
e = graph.edge_begin(src, galois::MethodFlag::UNPROTECTED),
ende = graph.edge_end(src, galois::MethodFlag::UNPROTECTED);
e != ende; ++e) {
GNode dst = graph.getEdgeDst(e);
AVI* dstAVI = graph.getData(dst, galois::MethodFlag::UNPROTECTED);
if (AVIComparator::compare(srcAVI, dstAVI) > 0) {
++inDeg;
} else { // is an out-going edge
outEdges.push_back(std::make_pair(src, dst));
}
}
// size_t outDeg = graph.neighborsSize(src,
// galois::MethodFlag::UNPROTECTED) - inDeg;
size_t outDeg =
std::distance(graph.edge_begin(src, galois::MethodFlag::UNPROTECTED),
graph.edge_end(src, galois::MethodFlag::UNPROTECTED));
std::fill(center.begin(), center.end(), 0.0);
srcAVI->getElement().getGeometry().computeCenter(center);
fprintf(nodesFile, "%zd, %zd, %zd, %g, %g, %g\n",
srcAVI->getGlobalIndex(), inDeg, outDeg, center[0], center[1],
srcAVI->getNextTimeStamp());
}
fclose(nodesFile);
FILE* edgesFile = fopen(edgesFileName, "w");
if (edgesFile == NULL) {
abort();
}
fprintf(edgesFile, "srcId, dstId\n");
for (std::vector<std::pair<GNode, GNode>>::const_iterator
i = outEdges.begin(),
ei = outEdges.end();
i != ei; ++i) {
size_t srcId = graph.getData(i->first, galois::MethodFlag::UNPROTECTED)
->getGlobalIndex();
size_t dstId = graph.getData(i->second, galois::MethodFlag::UNPROTECTED)
->getGlobalIndex();
fprintf(edgesFile, "%zd, %zd\n", srcId, dstId);
}
fclose(edgesFile);
}
};
#endif
| 32.613483 | 80 | 0.607593 |
4b54e6d1498305f44cbfba04b0430371facd750d | 1,924 | c | C | src/principal.c | CrisCod3r/LPPL | e5bb3ada725b8b7bc4dd01f4d4b725d34282820c | [
"MIT"
] | null | null | null | src/principal.c | CrisCod3r/LPPL | e5bb3ada725b8b7bc4dd01f4d4b725d34282820c | [
"MIT"
] | null | null | null | src/principal.c | CrisCod3r/LPPL | e5bb3ada725b8b7bc4dd01f4d4b725d34282820c | [
"MIT"
] | null | null | null | /*****************************************************************************/
/* Programa principal y tratamiento de errores. */
/* Jose Miguel Benedi, 2021-2022 <jbenedi@dsic.upv.es> */
/*****************************************************************************/
#include <stdio.h>
#include <string.h>
#include "header.h"
#include "libgci.h"
int verTdS=FALSE; /* Flag para mostrar la TDS */
int verbosidad=FALSE; /* Flag si se desea una traza */
int numErrores=0; /* Contador del numero de errores */
/*****************************************************************************/
void yyerror(const char * msg)
/* Tratamiento de errores. */
{
numErrores++; fflush(stdout);
fprintf(stdout, "\nError en %d: %s\n", yylineno, msg);
}
/*****************************************************************************/
int main (int argc, char **argv)
/* Gestiona la linea de comandos e invoca al analizador sintactico-semantico.*/
{ int i, n = 1; char *nom_fich;
for (i=1; i<argc; ++i) {
if (strcmp(argv[i], "-v")==0) { verbosidad = TRUE; n++; }
else if (strcmp(argv[i], "-t")==0) { verTdS = TRUE; n++; }
}
if (argc == n+1) {
if ((yyin = fopen (argv[n], "r")) == NULL) {
fprintf (stderr, "El fichero '%s' no es valido\n", argv[n]);
fprintf (stderr, "Uso: cmc [-v] fichero\n");
}
else {
if (verbosidad == TRUE) fprintf(stdout,"%3d.- ", yylineno);
nom_fich = argv[n];
yyparse ();
if (numErrores == 0) volcarCodigo(nom_fich);
else fprintf(stderr,"\nNumero de errores: %d\n", numErrores);
}
}
else fprintf (stderr, "Uso: cmc [-v] [-t] fichero\n");
return (0);
}
/*****************************************************************************/
| 40.93617 | 79 | 0.414241 |
f4f99b06ff527ba619c57f2aa5a9b31bff6eb48c | 28,467 | h | C | OgreMain/include/OgreTextureGpu.h | DavidYKay/ogre-next | 5e624bcc6bfc6b061de241bafb9cf1e6ad1aa92a | [
"MIT"
] | null | null | null | OgreMain/include/OgreTextureGpu.h | DavidYKay/ogre-next | 5e624bcc6bfc6b061de241bafb9cf1e6ad1aa92a | [
"MIT"
] | null | null | null | OgreMain/include/OgreTextureGpu.h | DavidYKay/ogre-next | 5e624bcc6bfc6b061de241bafb9cf1e6ad1aa92a | [
"MIT"
] | null | null | null | /*
-----------------------------------------------------------------------------
This source file is part of OGRE
(Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/
Copyright (c) 2000-2017 Torus Knot Software Ltd
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/
#ifndef _OgreTextureGpu_H_
#define _OgreTextureGpu_H_
#include "OgreGpuResource.h"
#include "OgrePixelFormatGpu.h"
#include "Vao/OgreBufferPacked.h"
#include "OgreHeaderPrefix.h"
namespace Ogre
{
/** \addtogroup Core
* @{
*/
/** \addtogroup Resources
* @{
*/
namespace MsaaPatterns
{
enum MsaaPatterns
{
/// Let the GPU decide.
Undefined,
/// The subsample locations follow a fixed known pattern.
/// Call TextureGpu::getSubsampleLocations to get them.
Standard,
/// The subsample locations are centered in a grid.
/// May not be supported by the GPU/API, in which case Standard will be used instead
/// Call TextureGpu::isMsaaPatternSupported to check whether it will be honoured.
Center,
/// All subsamples are at 0, 0; effectively "disabling" msaa.
CenterZero
};
}
namespace TextureTypes
{
enum TextureTypes
{
Unknown,
Type1D,
Type1DArray,
Type2D,
Type2DArray,
TypeCube,
TypeCubeArray,
Type3D
};
}
namespace CubemapSide
{
/// Please note that due to ancient GPU history reasons, cubemaps are always
/// treated as left handed. Which means +Z = Forward (which contradicts Ogre
/// and OpenGL common conventions of being right handed, where -Z = Forward)
enum CubemapSide
{
PX, NX,
PY, NY,
PZ, NZ,
};
}
namespace TextureFlags
{
enum TextureFlags
{
/// Texture cannot be used as a regular texture (bound to SRV in D3D11 terms)
NotTexture = 1u << 0u,
/// Texture can be used as an RTT (FBO in GL terms)
RenderToTexture = 1u << 1u,
/// Texture can be used as an UAV
Uav = 1u << 2u,
/// Texture can use mipmap autogeneration. This flag is NOT necessary
/// for TextureFilter::TypeGenerateHwMipmaps, as this filter will
/// create a temporary resource.
/// AllowAutomipmaps is thought for RenderToTexture textures.
AllowAutomipmaps = 1u << 3u,
/// Texture will auto generate mipmaps every time it's dirty, automatically.
/// Requires AllowAutomipmaps.
AutomipmapsAuto = 1u << 4u,
/** MSAA rendering is an antialiasing technique. MSAA works by rendering
to a special surface (an MSAA surface) and once we're done, "resolving"
from MSAA surface into a regular texture for later sampling.
@par
Without explicit resolves, Ogre will automatically resolve the MSAA
surface into the texture whenever it detects you will be sampling
from this texture.
@par
However there are cases where you want to directly access the MSAA
surface directly for advanced special effects (i.e. via Texture2DMS in
HLSL).
For cases like that, use MsaaExplicitResolve; which will let you to
manually manage MSAA surfaces and when you want to resolve it.
*/
MsaaExplicitResolve = 1u << 5u,
/// When present, you may be creating another TextureGpu that accesses
/// the internal resources of this TextureGpu but with a different format
/// (e.g. useful for viewing a PFG_RGBA8_UNORM_SRGB as PFG_RGBA8_UNORM)
Reinterpretable = 1u << 6u,
/// Prefer loading FROM FILES as sRGB when possible.
/// e.g. load PFG_RGBA8_UNORM as PFG_RGBA8_UNORM_SRGB
/// This flag does not affect RenderTextures, UAVs, or manually created textures.
/// If you're manually creating sRGB textures, set PFG_RGBA8_UNORM_SRGB directly
PrefersLoadingFromFileAsSRGB = 1u << 7u,
/// Indicates this texture contains a RenderWindow. In several APIs render windows
/// have particular limitations:
/// * Cannot be sampled as textures (i.e. NotTexture will be set)
/// * OpenGL cannot share the depth & stencil buffers with other textures.
/// * Metal requires special maintenance.
/// * etc.
RenderWindowSpecific = 1u << 9u,
RequiresTextureFlipping = 1u << 10u,
/// Indicates this texture will be filled by the user, and won't be loaded
/// from file or a listener from within a worker thread. This flag
/// is implicit if NotTexture, RenderToTexture or Uav are set.
ManualTexture = 1u << 11u,
/// When not present:
/// The Texture is exactly the type requested (e.g. 2D texture won't
/// get a 2D array instead)
/// While a texture is transitioning to Resident, no 64x64 is used,
/// but the 4x4 dummy one will be used instead (blank texture).
///
/// When this bit is set:
/// The Texture can be of a different type. Most normally we’ll treat
/// 2D textures internally as a slice to a 2D array texture.
/// Ogre will keep three API objects:
/// 1. A single 4x4 texture. Blank.
/// 2. An array of 2D textures of 64x64. One of its slices will
/// contain the mips of the texture being loaded
/// 3. An array of 2D textures in which one of its slices the fully
/// resident texture will live.
/// Each time we change the internal API object, HlmsDatablocks need to be
/// notified so it can pack the arrays, update the slices to the GPU, and
/// compute the texture hashes.
/// All of that (except updating slices to the GPU) can be done in a
/// worker thread, then all the values swapped w/ the Datablock’s.
AutomaticBatching = 1u << 12u,
/// For internal use. Indicates whether this texture is the owner
/// of a TextureGpuManager::TexturePool, which are used
/// to hold regular textures using AutomaticBatching
PoolOwner = 1u << 13u
};
}
/**
@remarks
Internal layout of data in memory:
@verbatim
Mip0 -> Slice 0, Slice 1, ..., Slice N
Mip1 -> Slice 0, Slice 1, ..., Slice N
...
MipN -> Slice 0, Slice 1, ..., Slice N
@endverbatim
The layout for 3D volume and array textures is the same. The only thing that changes
is that for 3D volumes, the number of slices also decreases with each mip, while
for array textures it is kept constant.
For 1D array textures, the number of slices is stored in mDepthOrSlices, not in Height.
For code reference, look at _getSysRamCopyAsBox implementation, and TextureBox::at
Each row of pixels is aligned to 4 bytes (except for compressed formats that require
more strict alignments, such as alignment to the block).
A TextureGpu loaded from file has the following life cycle, usually:
1. At creation it's mResidencyStatus = GpuResidency::OnStorage
2. Loading is scheduled via scheduleTransitionTo.
mNextResidencyStatus = GpuResidency::Resident
3. Texture transitions to resident. mResidencyStatus = GpuResidency::Resident
isMetadataReady returns true. How fast this happens depends on whether
there was a metadata cache or not.
4. If there is a metadata cache, and the cache turned out to be wrong (e.g. it
lied or was out of date), the texture will transition
back to OnStorage and the whole process repeats from step 1.
5. Texture finishes loading. notifyDataIsReady gets called and now
isDataReady returns true.
*/
class _OgreExport TextureGpu : public GpuTrackedResource, public GpuResource
{
protected:
uint32 mWidth;
uint32 mHeight;
/// For TypeCube this value is 6. For TypeCubeArray,
/// it contains the number of cubemaps in the array * 6u.
uint32 mDepthOrSlices;
/// Set mNumMipmaps = 0 to auto generate until last level.
/// mNumMipmaps = 1 means no extra mipmaps other than level 0.
uint8 mNumMipmaps;
uint8 mMsaa;
MsaaPatterns::MsaaPatterns mMsaaPattern;
/// Used when AutomaticBatching is set. It indicates in which slice
/// our actual data is, inside a texture array which we do not own.
uint16 mInternalSliceStart;
/// This setting can only be altered if mResidencyStatus == OnStorage).
TextureTypes::TextureTypes mTextureType;
PixelFormatGpu mPixelFormat;
/// See TextureFlags::TextureFlags
uint32 mTextureFlags;
/// Used if hasAutomaticBatching() == true
uint32 mPoolId;
/// If this pointer is nullptr and mResidencyStatus == GpuResidency::OnSystemRam
/// then that means the data is being loaded to SystemRAM
uint8 *mSysRamCopy;
TextureGpuManager *mTextureManager;
/// Used if hasAutomaticBatching() == true
TexturePool const *mTexturePool;
vector<TextureGpuListener*>::type mListeners;
virtual void createInternalResourcesImpl(void) = 0;
virtual void destroyInternalResourcesImpl(void) = 0;
void checkValidSettings(void);
void transitionToResident(void);
public:
TextureGpu( GpuPageOutStrategy::GpuPageOutStrategy pageOutStrategy,
VaoManager *vaoManager, IdString name, uint32 textureFlags,
TextureTypes::TextureTypes initialType,
TextureGpuManager *textureManager );
virtual ~TextureGpu();
void _resetTextureManager(void);
/// Note: This returns the alias name of the texture.
/// See TextureGpuManager::createOrRetrieveTexture
virtual String getNameStr(void) const;
/// Returns the real name (e.g. disk in file) of the resource.
virtual String getRealResourceNameStr(void) const;
virtual String getResourceGroupStr(void) const;
String getSettingsDesc(void) const;
/** Schedules an async transition in residency. If transitioning from
OnStorage to Resident, it will read from file (ResourceGroup was set in createTexture)
If transitioning from OnSystemRam to Resident, it will read from the pointer it has.
Multiple transitions can be stack together.
@remarks
If you're not loading from file (i.e. you're creating it programatically),
call _transitionTo & _setNextResidencyStatus directly.
Once you've called scheduleTransitionTo at least once, calling _transitionTo
is very dangerous, as there are race conditions.
@see TextureGpu::scheduleTransitionTo
@param nextResidency
The residency to change to.
@param image
Pointer to image if you want to load the texture from memory instead of loading
it from file or a listener.
Pointer must be null if this is a manual texture.
Pointer must NOT be a stack variable nor be deleted immediately.
The actual loading is postponed until the request reaches the worker thread.
That means the image pointer is safe to delete once you receive the
TextureGpuListener::Reason::ReadyForRendering message.
@param autoDeleteImage
Whether we should call "delete image" once we're done using the image.
Otherwise you must listen for TextureGpuListener::ReadyForRendering
message to know when we're done using the image.
*/
void unsafeScheduleTransitionTo( GpuResidency::GpuResidency nextResidency,
Image2 *image=0, bool autoDeleteImage=true );
/// Same as unsafeScheduleTransitionTo, but first checks if we're already
/// in the residency state we want to go to, or if it has already
/// been scheduled; thus it can be called multiple times
void scheduleTransitionTo( GpuResidency::GpuResidency nextResidency,
Image2 *image=0, bool autoDeleteImage=true );
// See isMetadataReady for threadsafety on these functions.
void setResolution( uint32 width, uint32 height, uint32 depthOrSlices=1u );
uint32 getWidth(void) const;
uint32 getHeight(void) const;
uint32 getDepthOrSlices(void) const;
/// For TypeCube & TypeCubeArray, this value returns 1.
uint32 getDepth(void) const;
/// For TypeCube this value returns 6.
/// For TypeCubeArray, value returns numSlices * 6u.
uint32 getNumSlices(void) const;
void setNumMipmaps( uint8 numMipmaps );
uint8 getNumMipmaps(void) const;
uint32 getInternalSliceStart(void) const;
virtual void setTextureType( TextureTypes::TextureTypes textureType );
TextureTypes::TextureTypes getTextureType(void) const;
TextureTypes::TextureTypes getInternalTextureType(void) const;
/** Sets the pixel format.
@remarks
If prefersLoadingFromFileAsSRGB() returns true, the format may not be fully honoured
(as we'll use the equivalent _SRGB variation).
*/
void setPixelFormat( PixelFormatGpu pixelFormat );
PixelFormatGpu getPixelFormat(void) const;
/// Note: Passing 0 will be forced to 1.
void setMsaa( uint8 msaa );
uint8 getMsaa(void) const;
void copyParametersFrom( TextureGpu *src );
bool hasEquivalentParameters( TextureGpu *other ) const;
void setHlmsProperties( Hlms *hlms, LwString &propBaseName );
void setMsaaPattern( MsaaPatterns::MsaaPatterns pattern );
MsaaPatterns::MsaaPatterns getMsaaPattern(void) const;
virtual bool isMsaaPatternSupported( MsaaPatterns::MsaaPatterns pattern );
/** Get the MSAA subsample locations. mMsaaPatterns must not be MsaaPatterns::Undefined.
@param locations
Outputs an array with the locations for each subsample. Values are in range [-1; 1]
*/
virtual void getSubsampleLocations( vector<Vector2>::type locations ) = 0;
/** This function may be called manually (if user is manually managing a texture)
or automatically (e.g. loading from file, or automatic batching is enabled)
Once you call this function, you're no longer in OnStorage mode; and will
transition to either OnSystemRam or Resident depending on whether auto
batching is enabled.
@remarks
Do NOT call this function yourself if you've created this function with
AutomaticBatching as Ogre will call this, from a worker thread!
Make sure you're done using mSysRamCopy before calling this function,
as we may free that pointer (unless autoDeleteSysRamCopyOnResident = false).
If you're calling _transitionTo yourself (i.e. you're not using scheduleTransitionTo)
then you'll need to call _setNextResidencyStatus too, so that both getResidencyStatus
and getNextResidencyStatus agree.
@param sysRamCopy
System RAM copy that backs this GPU data. May be null.
Must've been allocated with OGRE_MALLOC_SIMD( size, MEMCATEGORY_RESOURCE );
We will deallocate it.
MUST respect _getSysRamCopyBytesPerRow & _getSysRamCopyBytesPerImage.
If in doubt, use PixelFormatGpuUtils::getSizeBytes with rowAlignment = 4u;
This param must be nullptr or equal to get_getSysRamCopy when going from
Resident to OnSystemRam and strategy is not AlwaysKeepSystemRamCopy; as we
will async download the content from the GPU.
@param autoDeleteSysRamCopy
When true, we free mSysRamCopy as we should.
When false, caller is responsible for deleting this pointer else it will leak!
*/
void _transitionTo( GpuResidency::GpuResidency newResidency, uint8 *sysRamCopy,
bool autoDeleteSysRamCopy = true );
/// Notifies it is safe to use the real data. Everything has been uploaded.
virtual void notifyDataIsReady(void) = 0;
/// Forces downloading data from GPU to CPU, usually because the data on GPU changed
/// and we're in strategy AlwaysKeepSystemRamCopy. May stall.
void _syncGpuResidentToSystemRam(void);
protected:
/// Stalls until GPU -> CPU transfers (i.e. _syncGpuResidentToSystemRam) are done
/// waitForData implicitly does this. This function exists because there are times
/// where Ogre needs to know this info, and calling waitForData would never return
/// true because the texture is in an inconsistent state.
void waitForPendingSyncs();
public:
/// Do not call directly. Will change mResidencyStatus from GpuResidency::Resident to
/// GpuResidency::OnSystemRam
void _notifySysRamDownloadIsReady( uint8 *sysRamPtr, bool resyncOnly );
virtual void copyTo( TextureGpu *dst, const TextureBox &dstBox, uint8 dstMipLevel,
const TextureBox &srcBox, uint8 srcMipLevel );
/** These 3 values are used as defaults for the compositor to use, but they may be
explicitly overriden by a RenderPassDescriptor.
Particularly required when passing the textures between nodes as input and
output (since only the TextureGpu pointer is passed, and thus this information is lost)
@remarks
Changing these settings won't take immediate effect because they're only used
when creating the compositor.
@param depthBufferPoolId
Sets the pool ID this RenderTarget should query from. Default value is POOL_DEFAULT.
Set to POOL_NO_DEPTH to avoid using a DepthBuffer (or manually controlling it)
@param preferDepthTexture
Whether this RT should be attached to a depth texture, or a regular depth buffer.
On older GPUs, preferring depth textures may result in certain depth precisions
to not be available (or use integer precision instead of floating point, etc).
True to use depth textures. False otherwise (default).
@param desiredDepthBufferFormat
Ogre will try to honour this request, but if it's not supported,
you may get lower precision.
All formats will try to fallback to PF_D24_UNORM_S8_UINT if not supported.
Must be one of the following:
PFG_D24_UNORM_S8_UINT
PFG_D16_UNORM
PFG_D32_FLOAT
PFG_D32_FLOAT_X24_S8_UINT
*/
virtual void _setDepthBufferDefaults( uint16 depthBufferPoolId, bool preferDepthTexture,
PixelFormatGpu desiredDepthBufferFormat );
virtual uint16 getDepthBufferPoolId(void) const;
virtual bool getPreferDepthTexture(void) const;
virtual PixelFormatGpu getDesiredDepthBufferFormat(void) const;
/** Immediately resolves this texture to the resolveTexture argument.
Source must be MSAA texture, destination must be non-MSAA.
@remarks
This function may be slow on some APIs and should only be used when required,
for example, to capture the screen from an explicit MSAA target and save it
to disk only on user demand.
If you need to call this often (like once per frame or more), then consider setting
a Compositor with CompositorNode::mLocalRtvs::resolveTextureName set so that the
compositor automatically resolves the texture every frame as efficiently as
possible.
*/
void _resolveTo( TextureGpu *resolveTexture );
/// Tells the API to let the HW autogenerate mipmaps. Assumes the
/// allowsAutoMipmaps() == true and isRenderToTexture() == true
virtual void _autogenerateMipmaps(void) = 0;
/// Only valid for TextureGpu classes.
/// TODO: This may be moved to a different class.
virtual void swapBuffers(void) {}
bool hasAutomaticBatching(void) const;
bool isTexture(void) const;
bool isRenderToTexture(void) const;
bool isUav(void) const;
bool allowsAutoMipmaps(void) const;
bool hasAutoMipmapAuto(void) const;
bool hasMsaaExplicitResolves(void) const;
bool isReinterpretable(void) const;
bool prefersLoadingFromFileAsSRGB(void) const;
bool isRenderWindowSpecific(void) const;
bool requiresTextureFlipping(void) const;
bool _isManualTextureFlagPresent(void) const;
bool isManualTexture(void) const;
bool isPoolOwner(void) const;
/// OpenGL RenderWindows are a bit specific:
/// * Their origins are upside down. Which means we need to flip Y.
/// * They can access resolved contents of MSAA even if hasMsaaExplicitResolves = true
virtual bool isOpenGLRenderWindow(void) const;
virtual void _setToDisplayDummyTexture(void) = 0;
virtual void _notifyTextureSlotChanged( const TexturePool *newPool, uint16 slice );
/** 2D Texture with automatic batching will be merged with other textures into the
same pool as one big 2D Array texture behind the scenes.
For two textures to be placed in the same pool (assuming it's not full)
the following must match:
Width, Height, PixelFormat, number of mipmaps, poolID
Pool ID is an arbitrary value with no actual meaning. This is ID
allows you to prevent certain textures from being group together.
For example, you may want all textures from Level 0 to be grouped
together while Level 1 gets grouped together in a different pool
@see TextureFlags::AutomaticBatching
@see TextureGpuManager::reservePoolId
@remarks
This value cannot be changed while the texture is resident (i.e. because
it has already been assigned to a pool)
@param poolId
Arbitrary value. Default value is 0.
*/
void setTexturePoolId( uint32 poolId );
uint32 getTexturePoolId(void) const { return mPoolId; }
const TexturePool* getTexturePool(void) const { return mTexturePool; }
void addListener( TextureGpuListener *listener );
void removeListener( TextureGpuListener *listener );
void notifyAllListenersTextureChanged( uint32 reason, void *extraData=0 );
const vector<TextureGpuListener*>::type& getListeners(void) const;
virtual bool supportsAsDepthBufferFor( TextureGpu *colourTarget ) const;
/// Writes the current contents of the render target to the named file.
void writeContentsToFile( const String& filename, uint8 minMip, uint8 maxMip,
bool automaticResolve=true );
static const IdString msFinalTextureBuffer;
static const IdString msMsaaTextureBuffer;
virtual void getCustomAttribute( IdString name, void *pData ) {}
TextureGpuManager* getTextureManager(void) const;
TextureBox getEmptyBox( uint8 mipLevel );
TextureBox _getSysRamCopyAsBox( uint8 mipLevel );
uint8* _getSysRamCopy( uint8 mipLevel );
/// Note: Returns non-zero even if there is no system ram copy.
size_t _getSysRamCopyBytesPerRow( uint8 mipLevel );
/// Note: Returns non-zero even if there is no system ram copy.
size_t _getSysRamCopyBytesPerImage( uint8 mipLevel );
/// Returns total size in bytes used in GPU by this texture (not by its pool)
/// including mipmaps.
size_t getSizeBytes(void) const;
/** It is threadsafe to call this function from main thread.
If this returns false, then the following functions are not threadsafe:
Setters must not be called, and getters may change from a worker thread:
* setResolution
* getWidth, getHeight, getDepth, getDepthOrSlices, getNumSlices
* set/getPixelFormat
* set/getNumMipmaps
* set/getTextureType
* getTexturePool
Note that this function may return true but the worker thread
may still be uploading to this texture. Use isDataReady to
see if the worker thread is fully done with this texture.
@remarks
Function for querying/waiting for data and metadata to be ready
are for blocking the main thread when a worker thread is loading
the texture from file or a listener (i.e. isManualTexture returns false)
otherwise you don't need to call these functions.
*/
bool isMetadataReady(void) const;
/// For internal use. Do not call directly.
///
/// This function is the same isDataReady except it ignores pending residency changes,
/// which is important when TextureGpuManager needs to know this information but the
/// TextureGpu is transitioning (thus mPendingResidencyChanges is in an inconsistent state)
virtual bool _isDataReadyImpl(void) const = 0;
/// True if this texture is fully ready to be used for displaying.
///
/// IMPORTANT: Always returns true if getResidencyStatus != GpuResidency::Resident
/// and there are no pending residency transitions.
///
/// Returns false while there are pending residency status
///
/// If this is true, then isMetadataReady is also true.
/// See isMetadataReady.
bool isDataReady(void);
/// Blocks main thread until metadata is ready. Afterwards isMetadataReady
/// should return true. If it doesn't, then there was a problem loading
/// the texture.
/// See isMetadataReady remarks.
void waitForMetadata(void);
/// Blocks main thread until data is ready. Afterwards isDataReady
/// should return true. If it doesn't, then there was a problem loading
/// the texture.
/// See isMetadataReady remarks.
void waitForData(void);
};
/** @} */
/** @} */
}
#include "OgreHeaderSuffix.h"
#endif
| 48.33107 | 99 | 0.643482 |
496fa185e25ddbd081e13981ad190081286370c3 | 50 | c | C | .vim/sourceCode/glibc-2.16.0/wcsmbs/test-wcslen.c | lakehui/Vim_config | 6cab80dc1209b34bf6379f42b1a92790bd0c146b | [
"MIT"
] | 47 | 2015-03-10T23:21:52.000Z | 2022-02-17T01:04:14.000Z | include/wcsmbs/test-wcslen.c | DalavanCloud/libucresolv | 04a4827aa44c47556f425a4eed5e0ab4a5c0d25a | [
"Apache-2.0"
] | 3 | 2019-07-12T00:44:18.000Z | 2020-12-07T17:32:23.000Z | include/wcsmbs/test-wcslen.c | DalavanCloud/libucresolv | 04a4827aa44c47556f425a4eed5e0ab4a5c0d25a | [
"Apache-2.0"
] | 19 | 2015-02-25T19:50:05.000Z | 2021-10-05T14:35:54.000Z | #define WIDE 1
#include "../string/test-strlen.c"
| 16.666667 | 34 | 0.7 |
0acf84d48e3d181ae9ebd8699fcde2da7ecd1f5a | 764 | h | C | content/devtools/DevToolsProtocolDispatcher.h | gergul/MiniBlink | 7a11c52f141d54d5f8e1a9af31867cd120a2c3c4 | [
"Apache-2.0"
] | 8 | 2019-05-05T16:38:05.000Z | 2021-11-09T11:45:38.000Z | content/devtools/DevToolsProtocolDispatcher.h | gergul/MiniBlink | 7a11c52f141d54d5f8e1a9af31867cd120a2c3c4 | [
"Apache-2.0"
] | null | null | null | content/devtools/DevToolsProtocolDispatcher.h | gergul/MiniBlink | 7a11c52f141d54d5f8e1a9af31867cd120a2c3c4 | [
"Apache-2.0"
] | 4 | 2018-12-14T07:52:46.000Z | 2021-06-11T18:06:09.000Z | #if (defined ENABLE_DEVTOOLS) && (ENABLE_DEVTOOLS == 1)
#ifndef content_devtools_DevToolsProtocolDispatcher_h
#define content_devtools_DevToolsProtocolDispatcher_h
#include <string>
#include <memory>
namespace base {
class DictionaryValue;
}
namespace content {
class DevToolsClient;
class DevToolsProtocolDispatcher {
public:
DevToolsProtocolDispatcher(DevToolsClient* devToolsClient);
~DevToolsProtocolDispatcher();
bool dispatcher(const std::string& message);
private:
void sendMessage(int commandId, const base::DictionaryValue& message);
void sendSuccess(int command_id, std::unique_ptr<base::DictionaryValue> params);
DevToolsClient* m_devToolsClient;
};
}
#endif // content_devtools_DevToolsProtocolDispatcher_h
#endif | 22.470588 | 84 | 0.790576 |
6f14387e368297e06261308382bc6f16f742b1b5 | 83,436 | h | C | mitsuba-af602c6fd98a/include/mitsuba/render/gkdtree.h | NTForked-ML/pbrs | 0b405d92c12d257e2581366542762c9f0c3facce | [
"MIT"
] | 139 | 2017-04-21T00:22:34.000Z | 2022-02-16T20:33:10.000Z | mitsuba-af602c6fd98a/include/mitsuba/render/gkdtree.h | NTForked-ML/pbrs | 0b405d92c12d257e2581366542762c9f0c3facce | [
"MIT"
] | 11 | 2017-08-15T18:22:59.000Z | 2019-07-01T05:44:41.000Z | mitsuba-af602c6fd98a/include/mitsuba/render/gkdtree.h | NTForked-ML/pbrs | 0b405d92c12d257e2581366542762c9f0c3facce | [
"MIT"
] | 30 | 2017-07-21T03:56:45.000Z | 2022-03-11T06:55:34.000Z | /*
This file is part of Mitsuba, a physically based rendering system.
Copyright (c) 2007-2014 by Wenzel Jakob and others.
Mitsuba is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License Version 3
as published by the Free Software Foundation.
Mitsuba is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#if !defined(__MITSUBA_RENDER_GKDTREE_H_)
#define __MITSUBA_RENDER_GKDTREE_H_
#include <mitsuba/core/timer.h>
#include <mitsuba/core/lock.h>
#include <boost/static_assert.hpp>
#include <stack>
#if defined(__LINUX__)
#include <malloc.h>
#endif
/// Activate lots of extra checks
//#define MTS_KD_DEBUG 1
/** Compile-time KD-tree depth limit. Allows to put certain
data structures on the stack */
#define MTS_KD_MAXDEPTH 48
/// OrderedChunkAllocator: don't create chunks smaller than 512 KiB
#define MTS_KD_MIN_ALLOC 512*1024
/// Allocate nodes & index lists in blocks of 512 KiB
#define MTS_KD_BLOCKSIZE_KD (512*1024/sizeof(KDNode))
#define MTS_KD_BLOCKSIZE_IDX (512*1024/sizeof(uint32_t))
/**
* \brief To avoid numerical issues, the size of the scene
* bounding box is increased by this amount
*/
#define MTS_KD_AABB_EPSILON 1e-3f
#if defined(MTS_KD_DEBUG)
#define KDAssert(expr) SAssert(expr)
#define KDAssertEx(expr, text) SAssertEx(expr, text)
#else
#define KDAssert(expr)
#define KDAssertEx(expr, text)
#endif
MTS_NAMESPACE_BEGIN
/**
* \brief Special "ordered" memory allocator
*
* During kd-tree construction, large amounts of memory are required
* to temporarily hold index and edge event lists. When not implemented
* properly, these allocations can become a critical bottleneck.
* The class \ref OrderedChunkAllocator provides a specialized
* memory allocator, which reserves memory in chunks of at least
* 128KiB. An important assumption made by the allocator is that
* memory will be released in the exact same order, in which it was
* previously allocated. This makes it possible to create an
* implementation with a very low memory overhead. Note that no locking
* is done, hence each thread will need its own allocator.
*
* \author Wenzel Jakob
*/
class OrderedChunkAllocator {
public:
inline OrderedChunkAllocator(size_t minAllocation = MTS_KD_MIN_ALLOC)
: m_minAllocation(minAllocation) {
m_chunks.reserve(16);
}
~OrderedChunkAllocator() {
cleanup();
}
/**
* \brief Release all memory used by the allocator
*/
void cleanup() {
for (std::vector<Chunk>::iterator it = m_chunks.begin();
it != m_chunks.end(); ++it)
freeAligned((*it).start);
m_chunks.clear();
}
/**
* \brief Merge the chunks of another allocator into this one
*/
void merge(const OrderedChunkAllocator &other) {
m_chunks.reserve(m_chunks.size() + other.m_chunks.size());
m_chunks.insert(m_chunks.end(), other.m_chunks.begin(),
other.m_chunks.end());
}
/**
* \brief Forget about all chunks without actually freeing them.
* This is useful when the chunks have been merged into another
* allocator.
*/
void forget() {
m_chunks.clear();
}
/**
* \brief Request a block of memory from the allocator
*
* Walks through the list of chunks to find one with enough
* free memory. If no chunk could be found, a new one is created.
*/
template <typename T> T * __restrict allocate(size_t size) {
size *= sizeof(T);
for (std::vector<Chunk>::iterator it = m_chunks.begin();
it != m_chunks.end(); ++it) {
Chunk &chunk = *it;
if (chunk.remainder() >= size) {
T* result = reinterpret_cast<T *>(chunk.cur);
chunk.cur += size;
return result;
}
}
/* No chunk had enough free memory */
size_t allocSize = std::max(size,
m_minAllocation);
Chunk chunk;
chunk.start = (uint8_t *) allocAligned(allocSize);
chunk.cur = chunk.start + size;
chunk.size = allocSize;
m_chunks.push_back(chunk);
return reinterpret_cast<T *>(chunk.start);
}
template <typename T> void release(T *ptr) {
for (std::vector<Chunk>::iterator it = m_chunks.begin();
it != m_chunks.end(); ++it) {
Chunk &chunk = *it;
if ((uint8_t *) ptr >= chunk.start &&
(uint8_t *) ptr < chunk.start + chunk.size) {
chunk.cur = (uint8_t *) ptr;
return;
}
}
#if defined(MTS_KD_DEBUG)
/* Uh oh, allocation could not be found. Check if it has size==0 */
for (std::vector<Chunk>::iterator it = m_chunks.begin();
it != m_chunks.end(); ++it) {
const Chunk &chunk = *it;
if ((uint8_t *) ptr == chunk.start + chunk.size)
return;
}
SLog(EError, "OrderedChunkAllocator: Internal error while"
" releasing memory");
#endif
}
/**
* \brief Shrink the size of the last allocated chunk
*/
template <typename T> void shrinkAllocation(T *ptr, size_t newSize) {
newSize *= sizeof(T);
for (std::vector<Chunk>::iterator it = m_chunks.begin();
it != m_chunks.end(); ++it) {
Chunk &chunk = *it;
if ((uint8_t *) ptr >= chunk.start &&
(uint8_t *) ptr < chunk.start + chunk.size) {
chunk.cur = (uint8_t *) ptr + newSize;
return;
}
}
#if defined(MTS_KD_DEBUG)
/* Uh oh, allocation could not be found. Check if it has size == 0 */
if (newSize == 0) {
for (std::vector<Chunk>::iterator it = m_chunks.begin();
it != m_chunks.end(); ++it) {
const Chunk &chunk = *it;
if ((uint8_t *) ptr == chunk.start + chunk.size)
return;
}
}
SLog(EError, "OrderedChunkAllocator: Internal error while"
" releasing memory");
#endif
}
inline size_t getChunkCount() const { return m_chunks.size(); }
/**
* \brief Return the total amount of chunk memory in bytes
*/
size_t size() const {
size_t result = 0;
for (std::vector<Chunk>::const_iterator it = m_chunks.begin();
it != m_chunks.end(); ++it)
result += (*it).size;
return result;
}
/**
* \brief Return the total amount of used memory in bytes
*/
size_t used() const {
size_t result = 0;
for (std::vector<Chunk>::const_iterator it = m_chunks.begin();
it != m_chunks.end(); ++it)
result += (*it).used();
return result;
}
/**
* \brief Return a string representation of the chunks
*/
std::string toString() const {
std::ostringstream oss;
oss << "OrderedChunkAllocator[" << endl;
for (size_t i=0; i<m_chunks.size(); ++i)
oss << " Chunk " << i << ": " << m_chunks[i].toString() << endl;
oss << "]";
return oss.str();
}
private:
struct Chunk {
size_t size;
uint8_t *start, *cur;
inline size_t used() const {
return cur - start;
}
inline size_t remainder() const {
return size - used();
}
std::string toString() const {
return formatString("0x%llx-0x%llx (size=" SIZE_T_FMT
", used=" SIZE_T_FMT ")", start, start+size,
size, used());
}
};
size_t m_minAllocation;
std::vector<Chunk> m_chunks;
};
/**
* \brief Basic vector implementation, which stores all data
* in a list of fixed-sized blocks.
*
* This leads to a more conservative memory usage when the
* final size of a (possibly very large) growing vector is
* unknown. Also, frequent reallocations & copies are avoided.
*
* \author Wenzel Jakob
*/
template <typename T, size_t BlockSize> class BlockedVector {
public:
BlockedVector() : m_pos(0) {}
~BlockedVector() {
clear();
}
/**
* \brief Append an element to the end
*/
inline void push_back(const T &value) {
size_t blockIdx = m_pos / BlockSize;
size_t offset = m_pos % BlockSize;
if (blockIdx == m_blocks.size())
m_blocks.push_back(new T[BlockSize]);
m_blocks[blockIdx][offset] = value;
m_pos++;
}
/**
* \brief Allocate a certain number of elements and
* return a pointer to the first one.
*
* The implementation will ensure that they lie
* contiguous in memory -- note that this can potentially
* create unused elements in the previous block if a new
* one has to be allocated.
*/
inline T * __restrict allocate(size_t size) {
#if defined(MTS_KD_DEBUG)
SAssert(size <= BlockSize);
#endif
size_t blockIdx = m_pos / BlockSize;
size_t offset = m_pos % BlockSize;
T *result;
if (EXPECT_TAKEN(offset + size <= BlockSize)) {
if (blockIdx == m_blocks.size())
m_blocks.push_back(new T[BlockSize]);
result = m_blocks[blockIdx] + offset;
m_pos += size;
} else {
++blockIdx;
if (blockIdx == m_blocks.size())
m_blocks.push_back(new T[BlockSize]);
result = m_blocks[blockIdx];
m_pos += BlockSize - offset + size;
}
return result;
}
inline T &operator[](size_t index) {
return *(m_blocks[index / BlockSize] +
(index % BlockSize));
}
inline const T &operator[](size_t index) const {
return *(m_blocks[index / BlockSize] +
(index % BlockSize));
}
/**
* \brief Return the currently used number of items
*/
inline size_t size() const {
return m_pos;
}
/**
* \brief Return the number of allocated blocks
*/
inline size_t blockCount() const {
return m_blocks.size();
}
/**
* \brief Return the total capacity
*/
inline size_t capacity() const {
return m_blocks.size() * BlockSize;
}
/**
* \brief Resize the vector to the given size.
*
* Note: this implementation doesn't support
* enlarging the vector and simply changes the
* last item pointer.
*/
inline void resize(size_t pos) {
#if defined(MTS_KD_DEBUG)
SAssert(pos <= capacity());
#endif
m_pos = pos;
}
/**
* \brief Release all memory
*/
void clear() {
for (typename std::vector<T *>::iterator it = m_blocks.begin();
it != m_blocks.end(); ++it)
delete[] *it;
m_blocks.clear();
m_pos = 0;
}
private:
std::vector<T *> m_blocks;
size_t m_pos;
};
/**
* \brief Compact storage for primitive classifcation
*
* When classifying primitives with respect to a split plane,
* a data structure is needed to hold the tertiary result of
* this operation. This class implements a compact storage
* (2 bits per entry) in the spirit of the std::vector<bool>
* specialization.
*
* \author Wenzel Jakob
*/
class ClassificationStorage {
public:
ClassificationStorage()
: m_buffer(NULL), m_bufferSize(0) { }
~ClassificationStorage() {
if (m_buffer)
delete[] m_buffer;
}
void setPrimitiveCount(size_t size) {
if (m_buffer)
delete[] m_buffer;
if (size > 0) {
m_bufferSize = size/4 + ((size % 4) > 0 ? 1 : 0);
m_buffer = new uint8_t[m_bufferSize];
} else {
m_buffer = NULL;
}
}
inline void set(uint32_t index, int value) {
uint8_t *ptr = m_buffer + (index >> 2);
uint8_t shift = (index & 3) << 1;
*ptr = (*ptr & ~(3 << shift)) | (value << shift);
}
inline int get(uint32_t index) const {
uint8_t *ptr = m_buffer + (index >> 2);
uint8_t shift = (index & 3) << 1;
return (*ptr >> shift) & 3;
}
inline size_t size() const {
return m_bufferSize;
}
private:
uint8_t *m_buffer;
size_t m_bufferSize;
};
/**
* \brief Base class of all kd-trees.
*
* This class defines the byte layout for KD-tree nodes and
* provides methods for querying the tree structure.
*/
template <typename AABBType> class KDTreeBase : public Object {
public:
/// Index number format (max 2^32 prims)
typedef uint32_t IndexType;
/// Size number format
typedef uint32_t SizeType;
/**
* \brief KD-tree node in 8 bytes.
*/
struct KDNode {
union {
/* Inner node */
struct {
/* Bit layout:
31 : False (inner node)
30 : Indirection node flag
29-3 : Offset to the left child
or indirection table entry
2-0 : Split axis
*/
uint32_t combined;
/// Split plane coordinate
float split;
} inner;
/* Leaf node */
struct {
/* Bit layout:
31 : True (leaf node)
30-0 : Offset to the node's primitive list
*/
uint32_t combined;
/// End offset of the primitive list
uint32_t end;
} leaf;
};
enum EMask {
ETypeMask = 1 << 31,
EIndirectionMask = 1 << 30,
ELeafOffsetMask = ~ETypeMask,
EInnerAxisMask = 0x3,
EInnerOffsetMask = ~(EInnerAxisMask + EIndirectionMask),
ERelOffsetLimit = (1<<28) - 1
};
/// Initialize a leaf kd-Tree node
inline void initLeafNode(unsigned int offset, unsigned int numPrims) {
leaf.combined = (uint32_t) ETypeMask | offset;
leaf.end = offset + numPrims;
}
/**
* Initialize an interior kd-Tree node. Reports a failure if the
* relative offset to the left child node is too large.
*/
inline bool initInnerNode(int axis, float split, ptrdiff_t relOffset) {
if (relOffset < 0 || relOffset > ERelOffsetLimit)
return false;
inner.combined = axis | ((uint32_t) relOffset << 2);
inner.split = split;
return true;
}
/**
* \brief Initialize an interior indirection node.
*
* Indirections are necessary whenever the children cannot be
* referenced using a relative pointer, which can happen when
* they lie in different memory chunks. In this case, the node
* stores an index into a globally shared pointer list.
*/
inline void initIndirectionNode(int axis, float split,
uint32_t indirectionEntry) {
inner.combined = EIndirectionMask
| ((uint32_t) indirectionEntry << 2)
| axis;
inner.split = split;
}
/// Is this a leaf node?
FINLINE bool isLeaf() const {
return leaf.combined & (uint32_t) ETypeMask;
}
/// Is this an indirection node?
FINLINE bool isIndirection() const {
return leaf.combined & (uint32_t) EIndirectionMask;
}
/// Assuming this is a leaf node, return the first primitive index
FINLINE IndexType getPrimStart() const {
return leaf.combined & (uint32_t) ELeafOffsetMask;
}
/// Assuming this is a leaf node, return the last primitive index
FINLINE IndexType getPrimEnd() const {
return leaf.end;
}
/// Return the index of an indirection node
FINLINE IndexType getIndirectionIndex() const {
return(inner.combined & (uint32_t) EInnerOffsetMask) >> 2;
}
/// Return the left child (assuming that this is an interior node)
FINLINE const KDNode * __restrict getLeft() const {
return this +
((inner.combined & (uint32_t) EInnerOffsetMask) >> 2);
}
/// Return the sibling of the current node
FINLINE const KDNode * __restrict getSibling() const {
return (const KDNode *) ((ptrdiff_t) this ^ (ptrdiff_t) 8);
}
/// Return the left child (assuming that this is an interior node)
FINLINE KDNode * __restrict getLeft() {
return this +
((inner.combined & (uint32_t) EInnerOffsetMask) >> 2);
}
/// Return the left child (assuming that this is an interior node)
FINLINE const KDNode * __restrict getRight() const {
return getLeft() + 1;
}
/**
* \brief Return the split plane location (assuming that this
* is an interior node)
*/
FINLINE float getSplit() const {
return inner.split;
}
/// Return the split axis (assuming that this is an interior node)
FINLINE int getAxis() const {
return inner.combined & (uint32_t) EInnerAxisMask;
}
/// Return a string representation
std::string toString() const {
std::ostringstream oss;
if (isLeaf()) {
oss << "KDNode[leaf, primStart=" << getPrimStart()
<< ", primCount=" << getPrimEnd()-getPrimStart() << "]";
} else {
oss << "KDNode[interior, axis=" << getAxis()
<< ", split=" << getAxis()
<< ", leftOffset="
<< ((inner.combined & EInnerOffsetMask) >> 2)
<< "]";
}
return oss.str();
}
};
BOOST_STATIC_ASSERT(sizeof(KDNode) == 8);
/// Return the log level of kd-tree status messages
inline ELogLevel getLogLevel() const { return m_logLevel; }
/// Return the log level of kd-tree status messages
inline void setLogLevel(ELogLevel level) { m_logLevel = level; }
/// Return the root node of the kd-tree
inline const KDNode *getRoot() const {
return m_nodes;
}
/// Return whether or not the kd-tree has been built
inline bool isBuilt() const {
return m_nodes != NULL;
}
/// Return a (slightly enlarged) axis-aligned bounding box containing all primitives
inline const AABBType &getAABB() const { return m_aabb; }
/// Return a tight axis-aligned bounding box containing all primitives
inline const AABBType &getTightAABB() const { return m_tightAABB;}
MTS_DECLARE_CLASS()
protected:
virtual ~KDTreeBase() { }
protected:
KDNode *m_nodes;
ELogLevel m_logLevel;
AABBType m_aabb, m_tightAABB;
};
#if defined(_MSC_VER) && !defined(__INTELLISENSE__)
/* Use strict IEEE 754 floating point computations
for the following kd-tree building code */
MTS_NAMESPACE_END
#pragma float_control(precise, on)
MTS_NAMESPACE_BEGIN
#endif
#define KDLog(level, fmt, ...) Thread::getThread()->getLogger()->log(\
level, KDTreeBase<AABB>::m_theClass, __FILE__, __LINE__, \
fmt, ## __VA_ARGS__)
/**
* \brief Optimized KD-tree acceleration data structure for
* n-dimensional (n<=4) shapes and various queries on them.
*
* Note that this class mainly concerns itself with data that cover a
* region of space. For point data, other implementations will be more
* suitable. The most important application in Mitsuba is the fast
* construction of high-quality trees for ray tracing. See the class
* \ref SAHKDTree for this specialization.
*
* The code in this class is a fully generic kd-tree implementation, which
* can theoretically support any kind of shape. However, subclasses still
* need to provide the following signatures for a functional implementation:
*
* \code
* /// Return the total number of primitives
* inline SizeType getPrimitiveCount() const;
*
* /// Return the axis-aligned bounding box of a certain primitive
* inline AABB getAABB(IndexType primIdx) const;
*
* /// Return the AABB of a primitive when clipped to another AABB
* inline AABB getClippedAABB(IndexType primIdx, const AABBType &aabb) const;
* \endcode
*
* This class follows the "Curiously recurring template" design pattern
* so that the above functions can be inlined (in particular, no virtual
* calls will be necessary!).
*
* When the kd-tree is initially built, this class optimizes a cost
* heuristic every time a split plane has to be chosen. For ray tracing,
* the heuristic is usually the surface area heuristic (SAH), but other
* choices are possible as well. The tree construction heuristic must be
* passed as a template argument, which can use a supplied AABB and
* split candidate to compute approximate probabilities of recursing into
* the left and right subrees during a typical kd-tree query operation.
* See \ref SurfaceAreaHeuristic for an example of the interface that
* must be implemented.
*
* The kd-tree construction algorithm creates 'perfect split' trees as
* outlined in the paper "On Building fast kd-Trees for Ray Tracing, and on
* doing that in O(N log N)" by Ingo Wald and Vlastimil Havran. This works
* even when the tree is not meant to be used for ray tracing.
* For polygonal meshes, the involved Sutherland-Hodgman iterations can be
* quite expensive in terms of the overall construction time. The
* \ref setClip method can be used to deactivate perfect splits at the
* cost of a lower-quality tree.
*
* Because the O(N log N) construction algorithm tends to cause many
* incoherent memory accesses, a fast approximate technique (Min-max
* binning) is used near the top of the tree, which significantly reduces
* cache misses. Once the input data has been narrowed down to a
* reasonable amount, the implementation switches over to the O(N log N)
* builder. When multiple processors are available, the build process runs
* in parallel.
*
* \author Wenzel Jakob
* \ingroup librender
*/
template <typename AABBType, typename TreeConstructionHeuristic, typename Derived>
class GenericKDTree : public KDTreeBase<AABBType> {
protected:
// Some forward declarations
struct MinMaxBins;
struct EdgeEvent;
struct EdgeEventOrdering;
public:
typedef KDTreeBase<AABBType> Parent;
typedef typename Parent::SizeType SizeType;
typedef typename Parent::IndexType IndexType;
typedef typename Parent::KDNode KDNode;
typedef typename AABBType::Scalar Scalar;
typedef typename AABBType::PointType PointType;
typedef typename AABBType::VectorType VectorType;
using Parent::m_nodes;
using Parent::m_aabb;
using Parent::m_tightAABB;
using Parent::m_logLevel;
using Parent::isBuilt;
/**
* \brief Create a new kd-tree instance initialized with
* the default parameters.
*/
GenericKDTree() : m_indices(NULL) {
m_nodes = NULL;
m_traversalCost = 15;
m_queryCost = 20;
m_emptySpaceBonus = 0.9f;
m_clip = true;
m_stopPrims = 6;
m_maxBadRefines = 3;
m_exactPrimThreshold = 65536;
m_maxDepth = 0;
m_retract = true;
m_parallelBuild = true;
m_minMaxBins = 128;
m_logLevel = EDebug;
}
/**
* \brief Release all memory
*/
virtual ~GenericKDTree() {
if (m_indices)
delete[] m_indices;
if (m_nodes)
freeAligned(m_nodes-1); // undo alignment shift
}
/**
* \brief Set the traversal cost used by the tree construction heuristic
*/
inline void setTraversalCost(Float traversalCost) {
m_traversalCost = traversalCost;
}
/**
* \brief Returns the underlying kd-tree index buffer
*/
inline IndexType *getIndices() const { return m_indices; }
/**
* \brief Return the traversal cost used by the tree construction heuristic
*/
inline Float getTraversalCost() const {
return m_traversalCost;
}
/**
* \brief Set the query cost used by the tree construction heuristic
* (This is the average cost for testing a contained shape against
* a kd-tree search query)
*/
inline void setQueryCost(Float queryCost) {
m_queryCost = queryCost;
}
/**
* \brief Return the query cost used by the tree construction heuristic
* (This is the average cost for testing a contained shape against
* a kd-tree search query)
*/
inline Float getQueryCost() const {
return m_queryCost;
}
/**
* \brief Set the bonus factor for empty space used by the
* tree construction heuristic
*/
inline void setEmptySpaceBonus(Float emptySpaceBonus) {
m_emptySpaceBonus = emptySpaceBonus;
}
/**
* \brief Return the bonus factor for empty space used by the
* tree construction heuristic
*/
inline Float getEmptySpaceBonus() const {
return m_emptySpaceBonus;
}
/**
* \brief Set the maximum tree depth (0 = use heuristic)
*/
inline void setMaxDepth(SizeType maxDepth) {
m_maxDepth = maxDepth;
}
/**
* \brief Set the number of bins used for Min-Max binning
*/
inline void setMinMaxBins(SizeType minMaxBins) {
m_minMaxBins = minMaxBins;
}
/**
* \brief Return the number of bins used for Min-Max binning
*/
inline SizeType getMinMaxBins() const {
return m_minMaxBins;
}
/**
* \brief Return maximum tree depth (0 = use heuristic)
*/
inline SizeType getMaxDepth() const {
return m_maxDepth;
}
/**
* \brief Specify whether or not to use primitive clipping will
* be used in the tree construction.
*/
inline void setClip(bool clip) {
m_clip = clip;
}
/**
* \brief Return whether or not to use primitive clipping will
* be used in the tree construction.
*/
inline bool getClip() const {
return m_clip;
}
/**
* \brief Specify whether or not bad splits can be "retracted".
*/
inline void setRetract(bool retract) {
m_retract = retract;
}
/**
* \brief Return whether or not bad splits can be "retracted".
*/
inline bool getRetract() const {
return m_retract;
}
/**
* \brief Set the number of bad refines allowed to happen
* in succession before a leaf node will be created.
*/
inline void setMaxBadRefines(SizeType maxBadRefines) {
m_maxBadRefines = maxBadRefines;
}
/**
* \brief Return the number of bad refines allowed to happen
* in succession before a leaf node will be created.
*/
inline SizeType getMaxBadRefines() const {
return m_maxBadRefines;
}
/**
* \brief Set the number of primitives, at which recursion will
* stop when building the tree.
*/
inline void setStopPrims(SizeType stopPrims) {
m_stopPrims = stopPrims;
}
/**
* \brief Return the number of primitives, at which recursion will
* stop when building the tree.
*/
inline SizeType getStopPrims() const {
return m_stopPrims;
}
/**
* \brief Specify whether or not tree construction
* should run in parallel.
*/
inline void setParallelBuild(bool parallel) {
m_parallelBuild = parallel;
}
/**
* \brief Return whether or not tree construction
* will run in parallel.
*/
inline bool getParallelBuild() const {
return m_parallelBuild;
}
/**
* \brief Specify the number of primitives, at which the builder will
* switch from (approximate) Min-Max binning to the accurate
* O(n log n) optimization method.
*/
inline void setExactPrimitiveThreshold(SizeType exactPrimThreshold) {
m_exactPrimThreshold = exactPrimThreshold;
}
/**
* \brief Return the number of primitives, at which the builder will
* switch from (approximate) Min-Max binning to the accurate
* O(n log n) optimization method.
*/
inline SizeType getExactPrimitiveThreshold() const {
return m_exactPrimThreshold;
}
protected:
/**
* \brief Once the tree has been constructed, it is rewritten into
* a more convenient binary storage format.
*
* This data structure is used to store temporary information about
* this process.
*/
struct RewriteItem {
const KDNode *node;
KDNode *target;
const typename GenericKDTree::BuildContext *context;
AABBType aabb;
RewriteItem(const KDNode *node, KDNode *target,
const typename GenericKDTree::BuildContext *context, const AABBType &aabb) :
node(node), target(target), context(context), aabb(aabb) { }
};
/**
* \brief Build a KD-tree over the supplied geometry
*
* To be called by the subclass.
*/
void buildInternal() {
/* Some samity checks */
if (isBuilt())
KDLog(EError, "The kd-tree has already been built!");
if (m_traversalCost <= 0)
KDLog(EError, "The traveral cost must be > 0");
if (m_queryCost <= 0)
KDLog(EError, "The query cost must be > 0");
if (m_emptySpaceBonus <= 0 || m_emptySpaceBonus > 1)
KDLog(EError, "The empty space bonus must be in [0, 1]");
if (m_minMaxBins <= 1)
KDLog(EError, "The number of min-max bins must be > 2");
SizeType primCount = cast()->getPrimitiveCount();
if (primCount == 0) {
KDLog(EWarn, "kd-tree contains no geometry!");
// +1 shift is for alignment purposes (see KDNode::getSibling)
m_nodes = static_cast<KDNode *>(allocAligned(sizeof(KDNode) * 2))+1;
m_nodes[0].initLeafNode(0, 0);
return;
}
if (primCount <= m_exactPrimThreshold)
m_parallelBuild = false;
BuildContext ctx(primCount, m_minMaxBins);
/* Establish an ad-hoc depth cutoff value (Formula from PBRT) */
if (m_maxDepth == 0)
m_maxDepth = (int) (8 + 1.3f * math::log2i(primCount));
m_maxDepth = std::min(m_maxDepth, (SizeType) MTS_KD_MAXDEPTH);
KDLog(m_logLevel, "Creating a preliminary index list (%s)",
memString(primCount * sizeof(IndexType)).c_str());
OrderedChunkAllocator &leftAlloc = ctx.leftAlloc;
IndexType *indices = leftAlloc.allocate<IndexType>(primCount);
ref<Timer> timer = new Timer();
AABBType &aabb = m_aabb;
aabb.reset();
for (IndexType i=0; i<primCount; ++i) {
aabb.expandBy(cast()->getAABB(i));
indices[i] = i;
}
#if defined(DOUBLE_PRECISION)
for (int i=0; i<3; ++i) {
aabb.min[i] = math::castflt_down(aabb.min[i]);
aabb.max[i] = math::castflt_up(aabb.max[i]);
}
#endif
KDLog(m_logLevel, "Computed scene bounds in %i ms",
timer->getMilliseconds());
KDLog(m_logLevel, "");
KDLog(m_logLevel, "kd-tree configuration:");
KDLog(m_logLevel, " Traversal cost : %.2f", m_traversalCost);
KDLog(m_logLevel, " Query cost : %.2f", m_queryCost);
KDLog(m_logLevel, " Empty space bonus : %.2f", m_emptySpaceBonus);
KDLog(m_logLevel, " Max. tree depth : %i", m_maxDepth);
KDLog(m_logLevel, " Scene bounding box (min) : %s",
aabb.min.toString().c_str());
KDLog(m_logLevel, " Scene bounding box (max) : %s",
aabb.max.toString().c_str());
KDLog(m_logLevel, " Min-max bins : %i", m_minMaxBins);
KDLog(m_logLevel, " O(n log n) method : use for <= %i primitives",
m_exactPrimThreshold);
KDLog(m_logLevel, " Perfect splits : %s", m_clip ? "yes" : "no");
KDLog(m_logLevel, " Retract bad splits : %s",
m_retract ? "yes" : "no");
KDLog(m_logLevel, " Stopping primitive count : %i", m_stopPrims);
KDLog(m_logLevel, " Build tree in parallel : %s",
m_parallelBuild ? "yes" : "no");
KDLog(m_logLevel, "");
SizeType procCount = getCoreCount();
if (procCount == 1)
m_parallelBuild = false;
if (m_parallelBuild) {
m_builders.resize(procCount);
for (SizeType i=0; i<procCount; ++i) {
m_builders[i] = new TreeBuilder(i, this);
m_builders[i]->incRef();
m_builders[i]->start();
}
}
m_indirectionLock = new Mutex();
KDNode *prelimRoot = ctx.nodes.allocate(1);
buildTreeMinMax(ctx, 1, prelimRoot, aabb, aabb,
indices, primCount, true, 0);
ctx.leftAlloc.release(indices);
KDAssert(ctx.leftAlloc.used() == 0);
KDAssert(ctx.rightAlloc.used() == 0);
if (m_parallelBuild) {
UniqueLock lock(m_interface.mutex);
m_interface.done = true;
m_interface.cond->broadcast();
lock.unlock();
for (SizeType i=0; i<m_builders.size(); ++i)
m_builders[i]->join();
}
KDLog(EInfo, "Finished -- took %i ms.", timer->getMilliseconds());
KDLog(m_logLevel, "");
KDLog(m_logLevel, "Temporary memory statistics:");
KDLog(m_logLevel, " Classification storage : %s",
memString((ctx.classStorage.size() * (1+procCount))).c_str());
KDLog(m_logLevel, " Indirection entries : " SIZE_T_FMT " (%s)",
m_indirections.size(), memString(m_indirections.capacity()
* sizeof(KDNode *)).c_str());
KDLog(m_logLevel, " Main thread:");
ctx.printStats(m_logLevel);
size_t totalUsage = m_indirections.capacity()
* sizeof(KDNode *) + ctx.size();
/// Clean up event lists and print statistics
ctx.leftAlloc.cleanup();
ctx.rightAlloc.cleanup();
for (SizeType i=0; i<m_builders.size(); ++i) {
KDLog(m_logLevel, " Worker thread %i:", i+1);
BuildContext &subCtx = m_builders[i]->getContext();
subCtx.printStats(m_logLevel);
totalUsage += subCtx.size();
subCtx.leftAlloc.cleanup();
subCtx.rightAlloc.cleanup();
ctx.accumulateStatisticsFrom(subCtx);
}
KDLog(m_logLevel, " Total: %s", memString(totalUsage).c_str());
KDLog(m_logLevel, "");
timer->reset();
KDLog(m_logLevel, "Optimizing memory layout ..");
Float expTraversalSteps = 0;
Float expLeavesVisited = 0;
Float expPrimitivesIntersected = 0;
Float heuristicCost = 0;
SizeType nodePtr = 0, indexPtr = 0;
SizeType maxPrimsInLeaf = 0;
const SizeType primBucketCount = 16;
SizeType primBuckets[primBucketCount];
memset(primBuckets, 0, sizeof(SizeType)*primBucketCount);
m_nodeCount = ctx.innerNodeCount + ctx.leafNodeCount;
m_indexCount = ctx.primIndexCount;
// +1 shift is for alignment purposes (see KDNode::getSibling)
m_nodes = static_cast<KDNode *> (allocAligned(
sizeof(KDNode) * (m_nodeCount+1)))+1;
m_indices = new IndexType[m_indexCount];
/* The following code rewrites all tree nodes with proper relative
indices. It also computes the final tree cost and some other
useful heuristics */
std::stack<RewriteItem> stack;
stack.push(RewriteItem(prelimRoot, &m_nodes[nodePtr++], &ctx, aabb));
while (!stack.empty()) {
RewriteItem item = stack.top();
stack.pop();
typename std::map<const KDNode *, IndexType>::const_iterator it
= m_interface.threadMap.find(item.node);
// Check if we're switching to a subtree built by a worker thread
if (it != m_interface.threadMap.end())
item.context = &m_builders[(*it).second]->getContext();
if (item.node->isLeaf()) {
SizeType primStart = item.node->getPrimStart(),
primEnd = item.node->getPrimEnd(),
primsInLeaf = primEnd-primStart;
item.target->initLeafNode(indexPtr, primsInLeaf);
Float quantity = TreeConstructionHeuristic::getQuantity(item.aabb),
weightedQuantity = quantity * primsInLeaf;
expLeavesVisited += quantity;
expPrimitivesIntersected += weightedQuantity;
heuristicCost += weightedQuantity * m_queryCost;
if (primsInLeaf < primBucketCount)
primBuckets[primsInLeaf]++;
if (primsInLeaf > maxPrimsInLeaf)
maxPrimsInLeaf = primsInLeaf;
const BlockedVector<IndexType, MTS_KD_BLOCKSIZE_IDX> &indices
= item.context->indices;
for (SizeType idx = primStart; idx<primEnd; ++idx) {
KDAssert(indices[idx] >= 0 && indices[idx] < primCount);
m_indices[indexPtr++] = indices[idx];
}
} else {
Float quantity = TreeConstructionHeuristic::getQuantity(item.aabb);
expTraversalSteps += quantity;
heuristicCost += quantity * m_traversalCost;
const KDNode *left;
if (EXPECT_TAKEN(!item.node->isIndirection()))
left = item.node->getLeft();
else
left = m_indirections[item.node->getIndirectionIndex()];
KDNode *children = &m_nodes[nodePtr];
nodePtr += 2;
int axis = item.node->getAxis();
float split = item.node->getSplit();
bool result = item.target->initInnerNode(axis, split, children - item.target);
if (!result)
KDLog(EError, "Cannot represent relative pointer -- "
"too many primitives?");
Float tmp = item.aabb.min[axis];
item.aabb.min[axis] = split;
stack.push(RewriteItem(left+1, children+1, item.context, item.aabb));
item.aabb.min[axis] = tmp;
item.aabb.max[axis] = split;
stack.push(RewriteItem(left, children, item.context, item.aabb));
}
}
KDAssert(nodePtr == ctx.innerNodeCount + ctx.leafNodeCount);
KDAssert(indexPtr == m_indexCount);
KDLog(m_logLevel, "Finished -- took %i ms.", timer->getMilliseconds());
/* Free some more memory */
ctx.nodes.clear();
ctx.indices.clear();
for (SizeType i=0; i<m_builders.size(); ++i) {
BuildContext &subCtx = m_builders[i]->getContext();
subCtx.nodes.clear();
subCtx.indices.clear();
}
m_indirectionLock = NULL;
std::vector<KDNode *>().swap(m_indirections);
if (m_builders.size() > 0) {
for (SizeType i=0; i<m_builders.size(); ++i)
m_builders[i]->decRef();
m_builders.clear();
}
KDLog(m_logLevel, "");
Float rootQuantity = TreeConstructionHeuristic::getQuantity(aabb);
expTraversalSteps /= rootQuantity;
expLeavesVisited /= rootQuantity;
expPrimitivesIntersected /= rootQuantity;
heuristicCost /= rootQuantity;
/* Slightly enlarge the bounding box
(necessary e.g. when the scene is planar) */
m_tightAABB = aabb;
const Float eps = MTS_KD_AABB_EPSILON;
aabb.min -= (aabb.max-aabb.min) * eps + VectorType(eps);
aabb.max += (aabb.max-aabb.min) * eps + VectorType(eps);
KDLog(m_logLevel, "Structural kd-tree statistics:");
KDLog(m_logLevel, " Parallel work units : " SIZE_T_FMT,
m_interface.threadMap.size());
KDLog(m_logLevel, " Node storage cost : %s",
memString(nodePtr * sizeof(KDNode)).c_str());
KDLog(m_logLevel, " Index storage cost : %s",
memString(indexPtr * sizeof(IndexType)).c_str());
KDLog(m_logLevel, " Inner nodes : %i", ctx.innerNodeCount);
KDLog(m_logLevel, " Leaf nodes : %i", ctx.leafNodeCount);
KDLog(m_logLevel, " Nonempty leaf nodes : %i",
ctx.nonemptyLeafNodeCount);
std::ostringstream oss;
oss << " Leaf node histogram : ";
for (SizeType i=0; i<primBucketCount; i++) {
oss << i << "(" << primBuckets[i] << ") ";
if ((i+1)%4==0 && i+1<primBucketCount) {
KDLog(m_logLevel, "%s", oss.str().c_str());
oss.str("");
oss << " ";
}
}
KDLog(m_logLevel, "%s", oss.str().c_str());
KDLog(m_logLevel, "");
KDLog(m_logLevel, "Qualitative kd-tree statistics:");
KDLog(m_logLevel, " Retracted splits : %i", ctx.retractedSplits);
KDLog(m_logLevel, " Pruned primitives : %i", ctx.pruned);
KDLog(m_logLevel, " Largest leaf node : %i primitives",
maxPrimsInLeaf);
KDLog(m_logLevel, " Avg. prims/nonempty leaf : %.2f",
ctx.primIndexCount / (Float) ctx.nonemptyLeafNodeCount);
KDLog(m_logLevel, " Expected traversals/query : %.2f", expTraversalSteps);
KDLog(m_logLevel, " Expected leaf visits/query : %.2f", expLeavesVisited);
KDLog(m_logLevel, " Expected prim. visits/query : %.2f",
expPrimitivesIntersected);
KDLog(m_logLevel, " Final cost : %.2f", heuristicCost);
KDLog(m_logLevel, "");
#if defined(__LINUX__)
/* Forcefully release Heap memory back to the OS */
malloc_trim(0);
#endif
}
protected:
/// Primitive classification during tree-construction
enum EClassificationResult {
/// Straddling primitive
EBothSides = 0,
/// Primitive is entirely on the left side of the split
ELeftSide = 1,
/// Primitive is entirely on the right side of the split
ERightSide = 2,
/// Edge events have been generated for the straddling primitive
EBothSidesProcessed = 3
};
/**
* \brief Describes the beginning or end of a primitive
* when projected onto a certain dimension.
*/
struct EdgeEvent {
/// Possible event types
enum EEventType {
EEdgeEnd = 0,
EEdgePlanar = 1,
EEdgeStart = 2
};
/// Dummy constructor
inline EdgeEvent() { }
/// Create a new edge event
inline EdgeEvent(uint16_t type, int axis, float pos, IndexType index)
: pos(pos), index(index), type(type), axis(axis) { }
/// Return a string representation
std::string toString() const {
std::ostringstream oss;
oss << "EdgeEvent[" << endl
<< " pos = " << pos << "," << endl
<< " index = " << index << "," << endl
<< " type = ";
if (type == EEdgeEnd)
oss << "end";
else if (type == EEdgePlanar)
oss << "planar";
else if (type == EEdgeStart)
oss << "start";
else
oss << "unknown!";
oss << "," << endl
<< " axis = " << axis << endl
<<"]";
return oss.str();
}
/// Plane position
float pos;
/// Primitive index
IndexType index;
/// Event type: end/planar/start
unsigned int type:2;
/// Event axis
unsigned int axis:2;
};
BOOST_STATIC_ASSERT(sizeof(EdgeEvent) == 12);
/// Edge event comparison functor
struct EdgeEventOrdering : public std::binary_function<EdgeEvent, EdgeEvent, bool> {
inline bool operator()(const EdgeEvent &a, const EdgeEvent &b) const {
if (a.axis != b.axis)
return a.axis < b.axis;
if (a.pos != b.pos)
return a.pos < b.pos;
if (a.type != b.type)
return a.type < b.type;
return a.index < b.index;
}
};
/**
* \brief Data type for split candidates computed by
* the O(n log n) greedy optimization method.
* */
struct SplitCandidate {
Float cost;
float pos;
int axis;
SizeType numLeft, numRight;
bool planarLeft;
int leftBin;
inline SplitCandidate() :
cost(std::numeric_limits<Float>::infinity()),
pos(0), axis(0), numLeft(0), numRight(0), planarLeft(false), leftBin(-1) {
}
std::string toString() const {
std::ostringstream oss;
oss << "SplitCandidate[" << endl
<< " cost=" << cost << "," << endl
<< " pos=" << pos << "," << endl
<< " axis=" << axis << "," << endl
<< " numLeft=" << numLeft << "," << endl
<< " numRight=" << numRight << "," << endl
<< " leftBin=" << leftBin << "," << endl
<< " planarLeft=" << (planarLeft ? "yes" : "no") << endl
<< "]";
return oss.str();
}
};
/**
* \brief Per-thread context used to manage memory allocations,
* also records some useful statistics.
*/
struct BuildContext {
OrderedChunkAllocator leftAlloc, rightAlloc;
BlockedVector<KDNode, MTS_KD_BLOCKSIZE_KD> nodes;
BlockedVector<IndexType, MTS_KD_BLOCKSIZE_IDX> indices;
ClassificationStorage classStorage;
MinMaxBins minMaxBins;
SizeType leafNodeCount;
SizeType nonemptyLeafNodeCount;
SizeType innerNodeCount;
SizeType primIndexCount;
SizeType retractedSplits;
SizeType pruned;
BuildContext(SizeType primCount, SizeType binCount)
: minMaxBins(binCount) {
classStorage.setPrimitiveCount(primCount);
leafNodeCount = 0;
nonemptyLeafNodeCount = 0;
innerNodeCount = 0;
primIndexCount = 0;
retractedSplits = 0;
pruned = 0;
}
size_t size() {
return leftAlloc.size() + rightAlloc.size()
+ nodes.capacity() * sizeof(KDNode)
+ indices.capacity() * sizeof(IndexType)
+ classStorage.size();
}
void printStats(ELogLevel level) {
KDLog(level, " Left events : " SIZE_T_FMT " chunks (%s)",
leftAlloc.getChunkCount(),
memString(leftAlloc.size()).c_str());
KDLog(level, " Right events : " SIZE_T_FMT " chunks (%s)",
rightAlloc.getChunkCount(),
memString(rightAlloc.size()).c_str());
KDLog(level, " kd-tree nodes : " SIZE_T_FMT " entries, "
SIZE_T_FMT " blocks (%s)", nodes.size(), nodes.blockCount(),
memString(nodes.capacity() * sizeof(KDNode)).c_str());
KDLog(level, " Indices : " SIZE_T_FMT " entries, "
SIZE_T_FMT " blocks (%s)", indices.size(),
indices.blockCount(), memString(indices.capacity()
* sizeof(IndexType)).c_str());
}
void accumulateStatisticsFrom(const BuildContext &ctx) {
leafNodeCount += ctx.leafNodeCount;
nonemptyLeafNodeCount += ctx.nonemptyLeafNodeCount;
innerNodeCount += ctx.innerNodeCount;
primIndexCount += ctx.primIndexCount;
retractedSplits += ctx.retractedSplits;
pruned += ctx.pruned;
}
};
/**
* \brief Communication data structure used to pass jobs to
* kd-tree builder threads
*/
struct BuildInterface {
/* Communcation */
ref<Mutex> mutex;
ref<ConditionVariable> cond, condJobTaken;
std::map<const KDNode *, IndexType> threadMap;
bool done;
/* Job description for building a subtree */
int depth;
KDNode *node;
AABBType nodeAABB;
EdgeEvent *eventStart, *eventEnd;
SizeType primCount;
int badRefines;
inline BuildInterface() {
mutex = new Mutex();
cond = new ConditionVariable(mutex);
condJobTaken = new ConditionVariable(mutex);
node = NULL;
done = false;
}
};
/**
* \brief kd-tree builder thread
*/
class TreeBuilder : public Thread {
public:
TreeBuilder(IndexType id, GenericKDTree *parent)
: Thread(formatString("bld%i", id)),
m_id(id),
m_parent(parent),
m_context(parent->cast()->getPrimitiveCount(),
parent->getMinMaxBins()),
m_interface(parent->m_interface) {
setCritical(true);
}
~TreeBuilder() {
KDAssert(m_context.leftAlloc.used() == 0);
KDAssert(m_context.rightAlloc.used() == 0);
}
void run() {
OrderedChunkAllocator &leftAlloc = m_context.leftAlloc;
while (true) {
UniqueLock lock(m_interface.mutex);
while (!m_interface.done && !m_interface.node)
m_interface.cond->wait();
if (m_interface.done) {
break;
}
int depth = m_interface.depth;
KDNode *node = m_interface.node;
AABBType nodeAABB = m_interface.nodeAABB;
size_t eventCount = m_interface.eventEnd - m_interface.eventStart;
SizeType primCount = m_interface.primCount;
int badRefines = m_interface.badRefines;
EdgeEvent *eventStart = leftAlloc.allocate<EdgeEvent>(eventCount),
*eventEnd = eventStart + eventCount;
memcpy(eventStart, m_interface.eventStart,
eventCount * sizeof(EdgeEvent));
m_interface.threadMap[node] = m_id;
m_interface.node = NULL;
m_interface.condJobTaken->signal();
lock.unlock();
std::sort(eventStart, eventEnd, EdgeEventOrdering());
m_parent->buildTree(m_context, depth, node,
nodeAABB, eventStart, eventEnd, primCount, true, badRefines);
leftAlloc.release(eventStart);
}
}
inline BuildContext &getContext() {
return m_context;
}
private:
IndexType m_id;
GenericKDTree *m_parent;
BuildContext m_context;
BuildInterface &m_interface;
};
/// Cast to the derived class
inline Derived *cast() {
return static_cast<Derived *>(this);
}
/// Cast to the derived class (const version)
inline const Derived *cast() const {
return static_cast<const Derived *>(this);
}
struct EventList {
EdgeEvent *start, *end;
SizeType primCount;
EventList(EdgeEvent *start, EdgeEvent *end, SizeType primCount)
: start(start), end(end), primCount(primCount) { }
};
/**
* \brief Create an edge event list for a given list of primitives.
*
* This is necessary when passing from Min-Max binning to the more
* accurate O(n log n) optimizier.
*/
EventList createEventList(
OrderedChunkAllocator &alloc, const AABBType &nodeAABB,
IndexType *prims, SizeType primCount) {
SizeType initialSize = primCount * 2 * PointType::dim, actualPrimCount = 0;
EdgeEvent *eventStart = alloc.allocate<EdgeEvent>(initialSize);
EdgeEvent *eventEnd = eventStart;
for (SizeType i=0; i<primCount; ++i) {
IndexType index = prims[i];
AABBType aabb;
if (m_clip) {
aabb = cast()->getClippedAABB(index, nodeAABB);
if (!aabb.isValid() || aabb.getSurfaceArea() == 0)
continue;
} else {
aabb = cast()->getAABB(index);
}
for (int axis=0; axis<PointType::dim; ++axis) {
float min = math::castflt_down(aabb.min[axis]),
max = math::castflt_up(aabb.max[axis]);
if (min == max) {
*eventEnd++ = EdgeEvent(EdgeEvent::EEdgePlanar, axis,
min, index);
} else {
*eventEnd++ = EdgeEvent(EdgeEvent::EEdgeStart, axis,
min, index);
*eventEnd++ = EdgeEvent(EdgeEvent::EEdgeEnd, axis,
max, index);
}
}
++actualPrimCount;
}
SizeType newSize = (SizeType) (eventEnd - eventStart);
if (newSize != initialSize)
alloc.shrinkAllocation<EdgeEvent>(eventStart, newSize);
return EventList(eventStart, eventEnd, actualPrimCount);
}
/**
* \brief Leaf node creation helper function
*
* \param ctx
* Thread-specific build context containing allocators etc.
* \param node
* KD-tree node entry to be filled
* \param eventStart
* Start pointer of an edge event list
* \param eventEnd
* End pointer of an edge event list
* \param primCount
* Total primitive count for the current node
*/
void createLeaf(BuildContext &ctx, KDNode *node, EdgeEvent *eventStart,
EdgeEvent *eventEnd, SizeType primCount) {
node->initLeafNode((SizeType) ctx.indices.size(), primCount);
if (primCount > 0) {
SizeType seenPrims = 0;
ctx.nonemptyLeafNodeCount++;
for (EdgeEvent *event = eventStart; event != eventEnd
&& event->axis == 0; ++event) {
if (event->type == EdgeEvent::EEdgeStart ||
event->type == EdgeEvent::EEdgePlanar) {
ctx.indices.push_back(event->index);
seenPrims++;
}
}
KDAssert(seenPrims == primCount);
ctx.primIndexCount += primCount;
}
ctx.leafNodeCount++;
}
/**
* \brief Leaf node creation helper function
*
* \param ctx
* Thread-specific build context containing allocators etc.
* \param node
* KD-tree node entry to be filled
* \param indices
* Start pointer of an index list
* \param primCount
* Total primitive count for the current node
*/
void createLeaf(BuildContext &ctx, KDNode *node, SizeType *indices,
SizeType primCount) {
node->initLeafNode((SizeType) ctx.indices.size(), primCount);
if (primCount > 0) {
ctx.nonemptyLeafNodeCount++;
for (SizeType i=0; i<primCount; ++i)
ctx.indices.push_back(indices[i]);
ctx.primIndexCount += primCount;
}
ctx.leafNodeCount++;
}
/**
* \brief Leaf node creation helper function.
*
* Creates a unique index list by collapsing
* a subtree with a bad cost.
*
* \param ctx
* Thread-specific build context containing allocators etc.
* \param node
* KD-tree node entry to be filled
* \param start
* Start pointer of the subtree indices
*/
void createLeafAfterRetraction(BuildContext &ctx, KDNode *node, SizeType start) {
SizeType indexCount = (SizeType) (ctx.indices.size() - start);
SAssert(indexCount > 0);
OrderedChunkAllocator &alloc = ctx.leftAlloc;
/* A temporary list is allocated to do the sorting (the indices
are not guaranteed to be contiguous in memory) */
IndexType *tempStart = alloc.allocate<IndexType>(indexCount),
*tempEnd = tempStart + indexCount,
*ptr = tempStart;
for (SizeType i=start, end = start + indexCount; i<end; ++i)
*ptr++ = ctx.indices[i];
/* Generate an index list without duplicate entries */
std::sort(tempStart, tempEnd, std::less<IndexType>());
ptr = tempStart;
int idx = start;
while (ptr < tempEnd) {
ctx.indices[idx] = *ptr++;
while (ptr < tempEnd && *ptr == ctx.indices[idx])
++ptr;
idx++;
}
int nSeen = idx-start;
ctx.primIndexCount = ctx.primIndexCount - indexCount + nSeen;
ctx.indices.resize(idx);
alloc.release(tempStart);
node->initLeafNode(start, nSeen);
ctx.nonemptyLeafNodeCount++;
ctx.leafNodeCount++;
}
/**
* \brief Implements the transition from min-max-binning to the
* O(n log n) optimization.
*
* \param ctx
* Thread-specific build context containing allocators etc.
* \param depth
* Current tree depth (1 == root node)
* \param node
* KD-tree node entry to be filled
* \param nodeAABB
* Axis-aligned bounding box of the current node
* \param indices
* Index list of all triangles in the current node (for min-max binning)
* \param primCount
* Total primitive count for the current node
* \param isLeftChild
* Is this node the left child of its parent? This is important for
* memory management using the \ref OrderedChunkAllocator.
* \param badRefines
* Number of "probable bad refines" further up the tree. This makes
* it possible to split along an initially bad-looking candidate in
* the hope that the cost was significantly overestimated. The
* counter makes sure that only a limited number of such splits can
* happen in succession.
* \returns
* Final cost of the node
*/
inline Float transitionToNLogN(BuildContext &ctx, unsigned int depth, KDNode *node,
const AABBType &nodeAABB, IndexType *indices,
SizeType primCount, bool isLeftChild, SizeType badRefines) {
OrderedChunkAllocator &alloc = isLeftChild
? ctx.leftAlloc : ctx.rightAlloc;
EventList events = createEventList(alloc, nodeAABB, indices, primCount);
Float cost;
if (m_parallelBuild) {
LockGuard lock(m_interface.mutex);
m_interface.depth = depth;
m_interface.node = node;
m_interface.nodeAABB = nodeAABB;
m_interface.eventStart = events.start;
m_interface.eventEnd = events.end;
m_interface.primCount = events.primCount;
m_interface.badRefines = badRefines;
m_interface.cond->signal();
/* Wait for a worker thread to take this job */
while (m_interface.node)
m_interface.condJobTaken->wait();
// Never tear down this subtree (return a cost of -infinity)
cost = -std::numeric_limits<Float>::infinity();
} else {
std::sort(events.start, events.end, EdgeEventOrdering());
cost = buildTree(ctx, depth, node, nodeAABB, events.start,
events.end, events.primCount, isLeftChild, badRefines);
}
alloc.release(events.start);
return cost;
}
/**
* \brief Build helper function (min-max binning)
*
* \param ctx
* Thread-specific build context containing allocators etc.
* \param depth
* Current tree depth (1 == root node)
* \param node
* KD-tree node entry to be filled
* \param nodeAABB
* Axis-aligned bounding box of the current node
* \param tightAABB
* Tight bounding box of the contained geometry (for min-max binning)
* \param indices
* Index list of all triangles in the current node (for min-max binning)
* \param primCount
* Total primitive count for the current node
* \param isLeftChild
* Is this node the left child of its parent? This is important for
* memory management using the \ref OrderedChunkAllocator.
* \param badRefines
* Number of "probable bad refines" further up the tree. This makes
* it possible to split along an initially bad-looking candidate in
* the hope that the cost was significantly overestimated. The
* counter makes sure that only a limited number of such splits can
* happen in succession.
* \returns
* Final cost of the node
*/
Float buildTreeMinMax(BuildContext &ctx, unsigned int depth, KDNode *node,
const AABBType &nodeAABB, const AABBType &tightAABB, IndexType *indices,
SizeType primCount, bool isLeftChild, SizeType badRefines) {
KDAssert(nodeAABB.contains(tightAABB));
Float leafCost = primCount * m_queryCost;
if (primCount <= m_stopPrims || depth >= m_maxDepth) {
createLeaf(ctx, node, indices, primCount);
return leafCost;
}
if (primCount <= m_exactPrimThreshold)
return transitionToNLogN(ctx, depth, node, nodeAABB, indices,
primCount, isLeftChild, badRefines);
/* ==================================================================== */
/* Binning */
/* ==================================================================== */
ctx.minMaxBins.setAABB(tightAABB);
ctx.minMaxBins.bin(cast(), indices, primCount);
/* ==================================================================== */
/* Split candidate search */
/* ==================================================================== */
SplitCandidate bestSplit = ctx.minMaxBins.minimizeCost(m_traversalCost,
m_queryCost);
if (bestSplit.cost == std::numeric_limits<Float>::infinity()) {
/* This is bad: we have either run out of floating point precision to
accurately represent split planes (e.g. 'tightAABB' is almost collapsed
along an axis), or the compiler made overly liberal use of floating point
optimizations, causing the two stages of the min-max binning code to
become inconsistent. The two ways to proceed at this point are to
either create a leaf (bad) or switch over to the O(n log n) greedy
optimization, which is done below */
KDLog(EWarn, "Min-max binning was unable to split %i primitives with %s "
"-- retrying with the O(n log n) greedy optimization",
primCount, tightAABB.toString().c_str());
return transitionToNLogN(ctx, depth, node, nodeAABB, indices,
primCount, isLeftChild, badRefines);
}
/* "Bad refines" heuristic from PBRT */
if (bestSplit.cost >= leafCost) {
if ((bestSplit.cost > 4 * leafCost && primCount < 16)
|| badRefines >= m_maxBadRefines) {
createLeaf(ctx, node, indices, primCount);
return leafCost;
}
++badRefines;
}
/* ==================================================================== */
/* Partitioning */
/* ==================================================================== */
typename MinMaxBins::Partition partition =
ctx.minMaxBins.partition(ctx, cast(), indices, bestSplit,
isLeftChild, m_traversalCost, m_queryCost);
/* ==================================================================== */
/* Recursion */
/* ==================================================================== */
KDNode *children = ctx.nodes.allocate(2);
SizeType nodePosBeforeSplit = (SizeType) ctx.nodes.size();
SizeType indexPosBeforeSplit = (SizeType) ctx.indices.size();
SizeType leafNodeCountBeforeSplit = ctx.leafNodeCount;
SizeType nonemptyLeafNodeCountBeforeSplit = ctx.nonemptyLeafNodeCount;
SizeType innerNodeCountBeforeSplit = ctx.innerNodeCount;
if (!node->initInnerNode(bestSplit.axis, bestSplit.pos, children-node)) {
LockGuard lock(m_indirectionLock);
SizeType indirectionIdx = (SizeType) m_indirections.size();
m_indirections.push_back(children);
/* Unable to store relative offset -- create an indirection
table entry */
node->initIndirectionNode(bestSplit.axis, bestSplit.pos,
indirectionIdx);
}
ctx.innerNodeCount++;
AABBType childAABB(nodeAABB);
childAABB.max[bestSplit.axis] = bestSplit.pos;
Float leftCost = buildTreeMinMax(ctx, depth+1, children,
childAABB, partition.left, partition.leftIndices,
bestSplit.numLeft, true, badRefines);
childAABB.min[bestSplit.axis] = bestSplit.pos;
childAABB.max[bestSplit.axis] = nodeAABB.max[bestSplit.axis];
Float rightCost = buildTreeMinMax(ctx, depth+1, children + 1,
childAABB, partition.right, partition.rightIndices,
bestSplit.numRight, false, badRefines);
TreeConstructionHeuristic tch(nodeAABB);
std::pair<Float, Float> prob = tch(bestSplit.axis,
bestSplit.pos - nodeAABB.min[bestSplit.axis],
nodeAABB.max[bestSplit.axis] - bestSplit.pos);
/* Compute the final cost given the updated cost
values received from the children */
Float finalCost = m_traversalCost +
(prob.first * leftCost + prob.second * rightCost);
/* Release the index lists not needed by the children anymore */
if (isLeftChild)
ctx.rightAlloc.release(partition.rightIndices);
else
ctx.leftAlloc.release(partition.leftIndices);
/* ==================================================================== */
/* Final decision */
/* ==================================================================== */
if (!m_retract || finalCost < primCount * m_queryCost) {
return finalCost;
} else {
/* In the end, splitting didn't help to reduce the cost.
Tear up everything below this node and create a leaf */
ctx.nodes.resize(nodePosBeforeSplit);
ctx.retractedSplits++;
ctx.leafNodeCount = leafNodeCountBeforeSplit;
ctx.nonemptyLeafNodeCount = nonemptyLeafNodeCountBeforeSplit;
ctx.innerNodeCount = innerNodeCountBeforeSplit;
createLeafAfterRetraction(ctx, node, indexPosBeforeSplit);
return leafCost;
}
}
/*
* \brief Build helper function (greedy O(n log n) optimization)
*
* \param ctx
* Thread-specific build context containing allocators etc.
* \param depth
* Current tree depth (1 == root node)
* \param node
* KD-tree node entry to be filled
* \param nodeAABB
* Axis-aligned bounding box of the current node
* \param eventStart
* Pointer to the beginning of a sorted edge event list
* \param eventEnd
* Pointer to the end of a sorted edge event list
* \param primCount
* Total primitive count for the current node
* \param isLeftChild
* Is this node the left child of its parent? This is important for
* memory management using the \ref OrderedChunkAllocator.
* \param badRefines
* Number of "probable bad refines" further up the tree. This makes
* it possible to split along an initially bad-looking candidate in
* the hope that the cost was significantly overestimated. The
* counter makes sure that only a limited number of such splits can
* happen in succession.
* \returns
* Final cost of the node
*/
Float buildTree(BuildContext &ctx, unsigned int depth, KDNode *node,
const AABBType &nodeAABB, EdgeEvent *eventStart, EdgeEvent *eventEnd,
SizeType primCount, bool isLeftChild, SizeType badRefines) {
Float leafCost = primCount * m_queryCost;
if (primCount <= m_stopPrims || depth >= m_maxDepth) {
createLeaf(ctx, node, eventStart, eventEnd, primCount);
return leafCost;
}
SplitCandidate bestSplit;
/* ==================================================================== */
/* Split candidate search */
/* ==================================================================== */
/* First, find the optimal splitting plane according to the
tree construction heuristic. To do this in O(n), the search is
implemented as a sweep over the edge events */
/* Initially, the split plane is placed left of the scene
and thus all geometry is on its right side */
SizeType numLeft[PointType::dim],
numRight[PointType::dim];
for (int i=0; i<PointType::dim; ++i) {
numLeft[i] = 0;
numRight[i] = primCount;
}
EdgeEvent *eventsByAxis[PointType::dim];
int eventsByAxisCtr = 1;
eventsByAxis[0] = eventStart;
TreeConstructionHeuristic tch(nodeAABB);
/* Iterate over all events on the current axis */
for (EdgeEvent *event = eventStart; event < eventEnd; ) {
/* Record the current position and count the number
and type of remaining events, which are also here.
Due to the sort ordering, there is no need to worry
about an axis change in the loops below */
int axis = event->axis;
float pos = event->pos;
SizeType numStart = 0, numEnd = 0, numPlanar = 0;
/* Count "end" events */
while (event < eventEnd && event->pos == pos
&& event->axis == axis
&& event->type == EdgeEvent::EEdgeEnd) {
++numEnd; ++event;
}
/* Count "planar" events */
while (event < eventEnd && event->pos == pos
&& event->axis == axis
&& event->type == EdgeEvent::EEdgePlanar) {
++numPlanar; ++event;
}
/* Count "start" events */
while (event < eventEnd && event->pos == pos
&& event->axis == axis
&& event->type == EdgeEvent::EEdgeStart) {
++numStart; ++event;
}
/* Keep track of the beginning of dimensions */
if (event < eventEnd && event->axis != axis) {
KDAssert(eventsByAxisCtr < PointType::dim);
eventsByAxis[eventsByAxisCtr++] = event;
}
/* The split plane can now be moved onto 't'. Accordingly, all planar
and ending primitives are removed from the right side */
numRight[axis] -= numPlanar + numEnd;
/* Calculate a score using the tree construction heuristic */
if (EXPECT_TAKEN(pos > nodeAABB.min[axis] && pos < nodeAABB.max[axis])) {
const SizeType nL = numLeft[axis], nR = numRight[axis];
const Float nLF = (Float) nL, nRF = (Float) nR;
std::pair<Float, Float> prob = tch(axis,
pos - nodeAABB.min[axis],
nodeAABB.max[axis] - pos);
if (numPlanar == 0) {
Float cost = m_traversalCost + m_queryCost
* (prob.first * nLF + prob.second * nRF);
if (nL == 0 || nR == 0)
cost *= m_emptySpaceBonus;
if (cost < bestSplit.cost) {
bestSplit.pos = pos;
bestSplit.axis = axis;
bestSplit.cost = cost;
bestSplit.numLeft = nL;
bestSplit.numRight = nR;
}
} else {
Float costPlanarLeft = m_traversalCost
+ m_queryCost * (prob.first * (nL+numPlanar) + prob.second * nRF);
Float costPlanarRight = m_traversalCost
+ m_queryCost * (prob.first * nLF + prob.second * (nR+numPlanar));
if (nL + numPlanar == 0 || nR == 0)
costPlanarLeft *= m_emptySpaceBonus;
if (nL == 0 || nR + numPlanar == 0)
costPlanarRight *= m_emptySpaceBonus;
if (costPlanarLeft < bestSplit.cost ||
costPlanarRight < bestSplit.cost) {
bestSplit.pos = pos;
bestSplit.axis = axis;
if (costPlanarLeft < costPlanarRight) {
bestSplit.cost = costPlanarLeft;
bestSplit.numLeft = nL + numPlanar;
bestSplit.numRight = nR;
bestSplit.planarLeft = true;
} else {
bestSplit.cost = costPlanarRight;
bestSplit.numLeft = nL;
bestSplit.numRight = nR + numPlanar;
bestSplit.planarLeft = false;
}
}
}
} else {
#if defined(MTS_KD_DEBUG)
if (m_clip && (pos < nodeAABB.min[axis]
|| pos > nodeAABB.max[axis])) {
/* When primitive clipping is active, this should never happen! */
KDLog(EError, "Internal error: edge event is out of bounds");
}
#endif
}
/* The split plane is moved past 't'. All prims,
which were planar on 't', are moved to the left
side. Also, starting prims are now also left of
the split plane. */
numLeft[axis] += numStart + numPlanar;
}
#if defined(MTS_KD_DEBUG)
/* Sanity checks. Everything should now be left of the split plane */
for (int i=0; i<PointType::dim; ++i)
KDAssert(numRight[i] == 0 && numLeft[i] == primCount);
for (int i=1; i<PointType::dim; ++i)
KDAssert(eventsByAxis[i]->axis == i && (eventsByAxis[i]-1)->axis == i-1);
#endif
/* "Bad refines" heuristic from PBRT */
if (bestSplit.cost >= leafCost) {
if ((bestSplit.cost > 4 * leafCost && primCount < 16)
|| badRefines >= m_maxBadRefines
|| bestSplit.cost == std::numeric_limits<Float>::infinity()) {
createLeaf(ctx, node, eventStart, eventEnd, primCount);
return leafCost;
}
++badRefines;
}
/* ==================================================================== */
/* Primitive Classification */
/* ==================================================================== */
ClassificationStorage &storage = ctx.classStorage;
/* Initially mark all prims as being located on both sides */
for (EdgeEvent *event = eventsByAxis[bestSplit.axis];
event < eventEnd && event->axis == bestSplit.axis; ++event)
storage.set(event->index, EBothSides);
SizeType primsLeft = 0, primsRight = 0, primsBoth = primCount;
/* Sweep over all edge events and classify the primitives wrt. the split */
for (EdgeEvent *event = eventsByAxis[bestSplit.axis];
event < eventEnd && event->axis == bestSplit.axis; ++event) {
if (event->type == EdgeEvent::EEdgeEnd && event->pos <= bestSplit.pos) {
/* The primitive's interval ends before or on the split plane
-> classify to the left side */
KDAssert(storage.get(event->index) == EBothSides);
storage.set(event->index, ELeftSide);
primsBoth--;
primsLeft++;
} else if (event->type == EdgeEvent::EEdgeStart
&& event->pos >= bestSplit.pos) {
/* The primitive's interval starts after or on the split plane
-> classify to the right side */
KDAssert(storage.get(event->index) == EBothSides);
storage.set(event->index, ERightSide);
primsBoth--;
primsRight++;
} else if (event->type == EdgeEvent::EEdgePlanar) {
/* If the planar primitive is not on the split plane, the
classification is easy. Otherwise, place it on the side with
the lower cost */
KDAssert(storage.get(event->index) == EBothSides);
if (event->pos < bestSplit.pos || (event->pos == bestSplit.pos
&& bestSplit.planarLeft)) {
storage.set(event->index, ELeftSide);
primsBoth--;
primsLeft++;
} else if (event->pos > bestSplit.pos
|| (event->pos == bestSplit.pos && !bestSplit.planarLeft)) {
storage.set(event->index, ERightSide);
primsBoth--;
primsRight++;
} else {
KDAssertEx(false, "Internal error!");
}
}
}
/* Some sanity checks */
KDAssert(primsLeft + primsRight + primsBoth == primCount);
KDAssert(primsLeft + primsBoth == bestSplit.numLeft);
KDAssert(primsRight + primsBoth == bestSplit.numRight);
OrderedChunkAllocator &leftAlloc = ctx.leftAlloc,
&rightAlloc = ctx.rightAlloc;
EdgeEvent *leftEventsStart, *rightEventsStart;
if (isLeftChild) {
leftEventsStart = eventStart;
rightEventsStart = rightAlloc.allocate<EdgeEvent>(bestSplit.numRight * 2 * PointType::dim);
} else {
leftEventsStart = leftAlloc.allocate<EdgeEvent>(bestSplit.numLeft * 2 * PointType::dim);
rightEventsStart = eventStart;
}
EdgeEvent *leftEventsEnd = leftEventsStart, *rightEventsEnd = rightEventsStart;
AABBType leftNodeAABB = nodeAABB, rightNodeAABB = nodeAABB;
leftNodeAABB.max[bestSplit.axis] = bestSplit.pos;
rightNodeAABB.min[bestSplit.axis] = bestSplit.pos;
SizeType prunedLeft = 0, prunedRight = 0;
/* ==================================================================== */
/* Partitioning */
/* ==================================================================== */
if (m_clip) {
EdgeEvent
*leftEventsTempStart = leftAlloc.allocate<EdgeEvent>(primsLeft * 2 * PointType::dim),
*rightEventsTempStart = rightAlloc.allocate<EdgeEvent>(primsRight * 2 * PointType::dim),
*newEventsLeftStart = leftAlloc.allocate<EdgeEvent>(primsBoth * 2 * PointType::dim),
*newEventsRightStart = rightAlloc.allocate<EdgeEvent>(primsBoth * 2 * PointType::dim);
EdgeEvent *leftEventsTempEnd = leftEventsTempStart,
*rightEventsTempEnd = rightEventsTempStart,
*newEventsLeftEnd = newEventsLeftStart,
*newEventsRightEnd = newEventsRightStart;
for (EdgeEvent *event = eventStart; event<eventEnd; ++event) {
int classification = storage.get(event->index);
if (classification == ELeftSide) {
/* Left-only primitive. Move to the left list and advance */
*leftEventsTempEnd++ = *event;
} else if (classification == ERightSide) {
/* Right-only primitive. Move to the right list and advance */
*rightEventsTempEnd++ = *event;
} else if (classification == EBothSides) {
/* The primitive overlaps the split plane. Re-clip and
generate new events for each side */
const IndexType index = event->index;
AABBType clippedLeft = cast()->getClippedAABB(index, leftNodeAABB);
AABBType clippedRight = cast()->getClippedAABB(index, rightNodeAABB);
KDAssert(leftNodeAABB.contains(clippedLeft));
KDAssert(rightNodeAABB.contains(clippedRight));
if (clippedLeft.isValid() && clippedLeft.getSurfaceArea() > 0) {
for (int axis=0; axis<PointType::dim; ++axis) {
float min = clippedLeft.min[axis],
max = clippedLeft.max[axis];
if (min == max) {
*newEventsLeftEnd++ = EdgeEvent(
EdgeEvent::EEdgePlanar,
axis, min, index);
} else {
*newEventsLeftEnd++ = EdgeEvent(
EdgeEvent::EEdgeStart,
axis, min, index);
*newEventsLeftEnd++ = EdgeEvent(
EdgeEvent::EEdgeEnd,
axis, max, index);
}
}
} else {
prunedLeft++;
}
if (clippedRight.isValid() && clippedRight.getSurfaceArea() > 0) {
for (int axis=0; axis<PointType::dim; ++axis) {
float min = clippedRight.min[axis],
max = clippedRight.max[axis];
if (min == max) {
*newEventsRightEnd++ = EdgeEvent(
EdgeEvent::EEdgePlanar,
axis, min, index);
} else {
*newEventsRightEnd++ = EdgeEvent(
EdgeEvent::EEdgeStart,
axis, min, index);
*newEventsRightEnd++ = EdgeEvent(
EdgeEvent::EEdgeEnd,
axis, max, index);
}
}
} else {
prunedRight++;
}
/* Mark this primitive as processed so that clipping
is only done once */
storage.set(index, EBothSidesProcessed);
}
}
KDAssert((SizeType) (leftEventsTempEnd - leftEventsTempStart) <= primsLeft * 2 * PointType::dim);
KDAssert((SizeType) (rightEventsTempEnd - rightEventsTempStart) <= primsRight * 2 * PointType::dim);
KDAssert((SizeType) (newEventsLeftEnd - newEventsLeftStart) <= primsBoth * 2 * PointType::dim);
KDAssert((SizeType) (newEventsRightEnd - newEventsRightStart) <= primsBoth * 2 * PointType::dim);
ctx.pruned += prunedLeft + prunedRight;
/* Sort the events from overlapping prims */
std::sort(newEventsLeftStart, newEventsLeftEnd, EdgeEventOrdering());
std::sort(newEventsRightStart, newEventsRightEnd, EdgeEventOrdering());
/* Merge the left list */
leftEventsEnd = std::merge(leftEventsTempStart,
leftEventsTempEnd, newEventsLeftStart, newEventsLeftEnd,
leftEventsStart, EdgeEventOrdering());
/* Merge the right list */
rightEventsEnd = std::merge(rightEventsTempStart,
rightEventsTempEnd, newEventsRightStart, newEventsRightEnd,
rightEventsStart, EdgeEventOrdering());
/* Release temporary memory */
leftAlloc.release(newEventsLeftStart);
leftAlloc.release(leftEventsTempStart);
rightAlloc.release(newEventsRightStart);
rightAlloc.release(rightEventsTempStart);
} else {
for (EdgeEvent *event = eventStart; event < eventEnd; ++event) {
int classification = storage.get(event->index);
if (classification == ELeftSide) {
/* Left-only primitive. Move to the left list and advance */
*leftEventsEnd++ = *event;
} else if (classification == ERightSide) {
/* Right-only primitive. Move to the right list and advance */
*rightEventsEnd++ = *event;
} else if (classification == EBothSides) {
/* The primitive overlaps the split plane. Its edge events
must be added to both lists. */
*leftEventsEnd++ = *event;
*rightEventsEnd++ = *event;
}
}
KDAssert((SizeType) (leftEventsEnd - leftEventsStart) <= bestSplit.numLeft * 2 * PointType::dim);
KDAssert((SizeType) (rightEventsEnd - rightEventsStart) <= bestSplit.numRight * 2 * PointType::dim);
}
/* Shrink the edge event storage now that we know exactly how
many are on each side */
ctx.leftAlloc.shrinkAllocation(leftEventsStart,
leftEventsEnd - leftEventsStart);
ctx.rightAlloc.shrinkAllocation(rightEventsStart,
rightEventsEnd - rightEventsStart);
/* ==================================================================== */
/* Recursion */
/* ==================================================================== */
KDNode *children = ctx.nodes.allocate(2);
SizeType nodePosBeforeSplit = (SizeType) ctx.nodes.size();
SizeType indexPosBeforeSplit = (SizeType) ctx.indices.size();
SizeType leafNodeCountBeforeSplit = ctx.leafNodeCount;
SizeType nonemptyLeafNodeCountBeforeSplit = ctx.nonemptyLeafNodeCount;
SizeType innerNodeCountBeforeSplit = ctx.innerNodeCount;
if (!node->initInnerNode(bestSplit.axis, bestSplit.pos, children-node)) {
LockGuard lock(m_indirectionLock);
SizeType indirectionIdx = (SizeType) m_indirections.size();
m_indirections.push_back(children);
/* Unable to store relative offset -- create an indirection
table entry */
node->initIndirectionNode(bestSplit.axis, bestSplit.pos,
indirectionIdx);
}
ctx.innerNodeCount++;
Float leftCost = buildTree(ctx, depth+1, children,
leftNodeAABB, leftEventsStart, leftEventsEnd,
bestSplit.numLeft - prunedLeft, true, badRefines);
Float rightCost = buildTree(ctx, depth+1, children+1,
rightNodeAABB, rightEventsStart, rightEventsEnd,
bestSplit.numRight - prunedRight, false, badRefines);
std::pair<Float, Float> prob = tch(bestSplit.axis,
bestSplit.pos - nodeAABB.min[bestSplit.axis],
nodeAABB.max[bestSplit.axis] - bestSplit.pos);
/* Compute the final cost given the updated cost
values received from the children */
Float finalCost = m_traversalCost +
(prob.first * leftCost + prob.second * rightCost);
/* Release the index lists not needed by the children anymore */
if (isLeftChild)
ctx.rightAlloc.release(rightEventsStart);
else
ctx.leftAlloc.release(leftEventsStart);
/* ==================================================================== */
/* Final decision */
/* ==================================================================== */
if (!m_retract || finalCost < primCount * m_queryCost) {
return finalCost;
} else {
/* In the end, splitting didn't help to reduce the SAH cost.
Tear up everything below this node and create a leaf */
ctx.nodes.resize(nodePosBeforeSplit);
ctx.retractedSplits++;
ctx.leafNodeCount = leafNodeCountBeforeSplit;
ctx.nonemptyLeafNodeCount = nonemptyLeafNodeCountBeforeSplit;
ctx.innerNodeCount = innerNodeCountBeforeSplit;
createLeafAfterRetraction(ctx, node, indexPosBeforeSplit);
return leafCost;
}
return bestSplit.cost;
}
/**
* \brief Min-max binning as described in
* "Highly Parallel Fast KD-tree Construction for Interactive
* Ray Tracing of Dynamic Scenes"
* by M. Shevtsov, A. Soupikov and A. Kapustin
*/
struct MinMaxBins {
MinMaxBins(SizeType nBins) : m_binCount(nBins) {
m_minBins = new SizeType[m_binCount*PointType::dim];
m_maxBins = new SizeType[m_binCount*PointType::dim];
}
~MinMaxBins() {
delete[] m_minBins;
delete[] m_maxBins;
}
/**
* \brief Prepare to bin for the specified bounds
*/
void setAABB(const AABBType &aabb) {
for (int axis=0; axis<PointType::dim; ++axis) {
float min = math::castflt_down(aabb.min[axis]);
float max = math::castflt_up(aabb.max[axis]);
m_min[axis] = min;
m_aabb.min[axis] = min;
m_aabb.max[axis] = max;
m_binSize[axis] = (max-min) / m_binCount;
m_invBinSize[axis] = 1 / m_binSize[axis];
}
}
/// Compute the bin location for a given position and axis
inline IndexType computeIndex(float pos, int axis) {
return (IndexType) std::min((float) (m_binCount-1), std::max(0.0f, (pos - m_min[axis]) * m_invBinSize[axis]));
}
/**
* \brief Run min-max binning
*
* \param derived Derived class to be used to determine the AABB for
* a given list of primitives
* \param indices Primitive indirection list
* \param primCount Specifies the length of \a indices
*/
void bin(const Derived *derived, IndexType *indices,
SizeType primCount) {
m_primCount = primCount;
memset(m_minBins, 0, sizeof(SizeType) * PointType::dim * m_binCount);
memset(m_maxBins, 0, sizeof(SizeType) * PointType::dim * m_binCount);
for (SizeType i=0; i<m_primCount; ++i) {
const AABBType aabb = derived->getAABB(indices[i]);
for (int axis=0; axis<PointType::dim; ++axis) {
m_minBins[axis * m_binCount + computeIndex(math::castflt_down(aabb.min[axis]), axis)]++;
m_maxBins[axis * m_binCount + computeIndex(math::castflt_up (aabb.max[axis]), axis)]++;
}
}
}
/**
* \brief Evaluate the tree construction heuristic at each bin boundary
* and return the minimizer for the given cost constants. Min-max
* binning uses no "empty space bonus" since it cannot create such
* splits.
*/
SplitCandidate minimizeCost(Float traversalCost, Float queryCost) {
TreeConstructionHeuristic tch(m_aabb);
SplitCandidate candidate;
int binIdx = 0;
for (int axis=0; axis<PointType::dim; ++axis) {
SizeType numLeft = 0, numRight = m_primCount;
Float leftWidth = 0, rightWidth = m_aabb.max[axis] - m_aabb.min[axis];
const float binSize = m_binSize[axis];
for (int i=0; i<m_binCount-1; ++i) {
numLeft += m_minBins[binIdx];
numRight -= m_maxBins[binIdx];
leftWidth += binSize;
rightWidth -= binSize;
std::pair<Float, Float> prob =
tch(axis, leftWidth, rightWidth);
Float cost = traversalCost + queryCost
* (prob.first * numLeft + prob.second * numRight);
if (cost < candidate.cost) {
candidate.cost = cost;
candidate.axis = axis;
candidate.numLeft = numLeft;
candidate.numRight = numRight;
candidate.leftBin = i;
}
binIdx++;
}
binIdx++;
}
KDAssert(candidate.cost != std::numeric_limits<Float>::infinity() &&
candidate.leftBin >= 0);
return candidate;
}
struct Partition {
AABBType left;
IndexType *leftIndices;
AABBType right;
IndexType *rightIndices;
Partition(const AABBType &left, IndexType *leftIndices,
const AABBType &right, IndexType *rightIndices) :
left(left), leftIndices(leftIndices), right(right),
rightIndices(rightIndices) { }
};
/**
* \brief Given a suitable split candiate, compute tight bounding
* boxes for the left and right subtrees and return associated
* primitive lists.
*/
Partition partition(
BuildContext &ctx, const Derived *derived, IndexType *primIndices,
SplitCandidate &split, bool isLeftChild, Float traversalCost,
Float queryCost) {
SizeType numLeft = 0, numRight = 0;
AABBType leftBounds, rightBounds;
const int axis = split.axis;
IndexType *leftIndices, *rightIndices;
if (isLeftChild) {
OrderedChunkAllocator &rightAlloc = ctx.rightAlloc;
leftIndices = primIndices;
rightIndices = rightAlloc.allocate<IndexType>(split.numRight);
} else {
OrderedChunkAllocator &leftAlloc = ctx.leftAlloc;
leftIndices = leftAlloc.allocate<IndexType>(split.numLeft);
rightIndices = primIndices;
}
for (SizeType i=0; i<m_primCount; ++i) {
const IndexType primIndex = primIndices[i];
const AABBType aabb = derived->getAABB(primIndex);
int startIdx = computeIndex(math::castflt_down(aabb.min[axis]), axis);
int endIdx = computeIndex(math::castflt_up (aabb.max[axis]), axis);
if (endIdx <= split.leftBin) {
KDAssert(numLeft < split.numLeft);
leftBounds.expandBy(aabb);
leftIndices[numLeft++] = primIndex;
} else if (startIdx > split.leftBin) {
KDAssert(numRight < split.numRight);
rightBounds.expandBy(aabb);
rightIndices[numRight++] = primIndex;
} else {
leftBounds.expandBy(aabb);
rightBounds.expandBy(aabb);
KDAssert(numLeft < split.numLeft);
KDAssert(numRight < split.numRight);
leftIndices[numLeft++] = primIndex;
rightIndices[numRight++] = primIndex;
}
}
leftBounds.clip(m_aabb);
rightBounds.clip(m_aabb);
split.pos = m_min[axis] + m_binSize[axis] * (split.leftBin + 1);
leftBounds.max[axis] = std::min(leftBounds.max[axis], (Float) split.pos);
rightBounds.min[axis] = std::max(rightBounds.min[axis], (Float) split.pos);
KDAssert(numLeft == split.numLeft);
KDAssert(numRight == split.numRight);
/// Release the unused memory regions
if (isLeftChild)
ctx.leftAlloc.shrinkAllocation(leftIndices, split.numLeft);
else
ctx.rightAlloc.shrinkAllocation(rightIndices, split.numRight);
return Partition(leftBounds, leftIndices,
rightBounds, rightIndices);
}
private:
SizeType *m_minBins;
SizeType *m_maxBins;
SizeType m_primCount;
int m_binCount;
float m_min[PointType::dim];
float m_binSize[PointType::dim];
float m_invBinSize[PointType::dim];
AABBType m_aabb;
};
protected:
IndexType *m_indices;
Float m_traversalCost;
Float m_queryCost;
Float m_emptySpaceBonus;
bool m_clip, m_retract, m_parallelBuild;
SizeType m_maxDepth;
SizeType m_stopPrims;
SizeType m_maxBadRefines;
SizeType m_exactPrimThreshold;
SizeType m_minMaxBins;
SizeType m_nodeCount;
SizeType m_indexCount;
std::vector<TreeBuilder *> m_builders;
std::vector<KDNode *> m_indirections;
ref<Mutex> m_indirectionLock;
BuildInterface m_interface;
};
#if defined(_MSC_VER)
/* Revert back to fast / non-strict IEEE 754
floating point computations */
MTS_NAMESPACE_END
#pragma float_control(precise, off)
MTS_NAMESPACE_BEGIN
#endif
template <typename AABBType>
Class *KDTreeBase<AABBType>::m_theClass
= new Class("KDTreeBase", true, "Object");
template <typename AABBType>
const Class *KDTreeBase<AABBType>::getClass() const {
return m_theClass;
}
// Explicit instantiation to avoid linking error outside the library
#ifdef _MSC_VER
template class MTS_EXPORT_RENDER KDTreeBase<AABB>;
#endif
MTS_NAMESPACE_END
#endif /* __MITSUBA_RENDER_GKDTREE_H_ */
| 31.628506 | 113 | 0.661106 |
4fd6458b6fa13d141e10e83560931a8aa944f671 | 306 | h | C | alica_engine/include/engine/modelmanagement/factories/VariableBindingFactory.h | Hugo-V-V/alica | 8cbba9c01b52d11854ec0c5367d4a8ec4f896cfd | [
"MIT"
] | 22 | 2018-03-08T05:43:45.000Z | 2022-03-28T15:03:49.000Z | alica_engine/include/engine/modelmanagement/factories/VariableBindingFactory.h | Hugo-V-V/alica | 8cbba9c01b52d11854ec0c5367d4a8ec4f896cfd | [
"MIT"
] | 50 | 2018-03-30T10:32:01.000Z | 2022-03-22T11:58:34.000Z | alica_engine/include/engine/modelmanagement/factories/VariableBindingFactory.h | Hugo-V-V/alica | 8cbba9c01b52d11854ec0c5367d4a8ec4f896cfd | [
"MIT"
] | 6 | 2019-03-04T12:28:27.000Z | 2022-02-10T04:09:01.000Z | #pragma once
#include "engine/model/VariableBinding.h"
#include "engine/modelmanagement/factories/Factory.h"
namespace alica {
class VariableBindingFactory : public Factory {
public:
static VariableBinding* create(const YAML::Node& node);
static void attachReferences();
};
}
| 23.538462 | 63 | 0.715686 |
ae5a468f2f4755dad60bae7bbb846c19355d3554 | 28,552 | h | C | demo/ch32/usb_device/CH32V307VCT6/CherryUSB/common/usb_def.h | aozima/CherryUSB | 2379619a4d6069501c8352cd4510ad743150dfff | [
"Apache-2.0"
] | 51 | 2022-02-02T08:22:25.000Z | 2022-03-31T05:47:14.000Z | demo/ch32/usb_device/CH32V307VCT6/CherryUSB/common/usb_def.h | aozima/CherryUSB | 2379619a4d6069501c8352cd4510ad743150dfff | [
"Apache-2.0"
] | 6 | 2022-02-08T01:18:58.000Z | 2022-03-31T02:55:07.000Z | demo/ch32/usb_device/CH32V307VCT6/CherryUSB/common/usb_def.h | aozima/CherryUSB | 2379619a4d6069501c8352cd4510ad743150dfff | [
"Apache-2.0"
] | 10 | 2022-02-02T03:28:36.000Z | 2022-03-26T14:20:17.000Z | /**
* @file usb_def.h
* @brief
*
* Copyright (c) 2022 sakumisu
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
*/
#ifndef USB_DEF_H
#define USB_DEF_H
/* Useful define */
#define USB_1_1 0x0110
#define USB_2_0 0x0200
/* Set USB version to 2.1 so that the host will request the BOS descriptor */
#define USB_2_1 0x0210
/* Device speeds */
#define USB_SPEED_UNKNOWN 0 /* Transfer rate not yet set */
#define USB_SPEED_LOW 1 /* USB 1.1 */
#define USB_SPEED_FULL 2 /* USB 1.1 */
#define USB_SPEED_HIGH 3 /* USB 2.0 */
#define USB_SPEED_VARIABLE 4 /* Wireless USB 2.5 */
/* Maximum number of devices per controller */
#define USB_MAX_DEVICES (127)
// USB PID Types
#define USB_PID_OUT (0x01) /* Tokens */
#define USB_PID_IN (0x09)
#define USB_PID_SOF (0x05)
#define USB_PID_SETUP (0x0d)
#define USB_PID_DATA0 (0x03) /* Data */
#define USB_PID_DATA1 (0x0b)
#define USB_PID_DATA2 (0x07)
#define USB_PID_MDATA (0x0f)
#define USB_PID_ACK (0x02) /* Handshake */
#define USB_PID_NAK (0x0a)
#define USB_PID_STALL (0x0e)
#define USB_PID_NYET (0x06)
#define USB_PID_PRE (0x0c) /* Special */
#define USB_PID_ERR (0x0c)
#define USB_PID_SPLIT (0x08)
#define USB_PID_PING (0x04)
#define USB_PID_RESERVED (0x00)
#define USB_REQUEST_DIR_SHIFT 7U /* Bits 7: Request dir */
#define USB_REQUEST_DIR_OUT (0U << USB_REQUEST_DIR_SHIFT) /* Bit 7=0: Host-to-device */
#define USB_REQUEST_DIR_IN (1U << USB_REQUEST_DIR_SHIFT) /* Bit 7=1: Device-to-host */
#define USB_REQUEST_DIR_MASK (1U << USB_REQUEST_DIR_SHIFT) /* Bit 7=1: Direction bit */
#define USB_REQUEST_TYPE_SHIFT 5U /* Bits 5:6: Request type */
#define USB_REQUEST_STANDARD (0U << USB_REQUEST_TYPE_SHIFT)
#define USB_REQUEST_CLASS (1U << USB_REQUEST_TYPE_SHIFT)
#define USB_REQUEST_VENDOR (2U << USB_REQUEST_TYPE_SHIFT)
#define USB_REQUEST_RESERVED (3U << USB_REQUEST_TYPE_SHIFT)
#define USB_REQUEST_TYPE_MASK (3U << USB_REQUEST_TYPE_SHIFT)
#define USB_REQUEST_RECIPIENT_SHIFT 0U /* Bits 0:4: Recipient */
#define USB_REQUEST_RECIPIENT_DEVICE (0U << USB_REQUEST_RECIPIENT_SHIFT)
#define USB_REQUEST_RECIPIENT_INTERFACE (1U << USB_REQUEST_RECIPIENT_SHIFT)
#define USB_REQUEST_RECIPIENT_ENDPOINT (2U << USB_REQUEST_RECIPIENT_SHIFT)
#define USB_REQUEST_RECIPIENT_OTHER (3U << USB_REQUEST_RECIPIENT_SHIFT)
#define USB_REQUEST_RECIPIENT_MASK (3U << USB_REQUEST_RECIPIENT_SHIFT)
/* USB Standard Request Codes */
#define USB_REQUEST_GET_STATUS 0x00
#define USB_REQUEST_CLEAR_FEATURE 0x01
#define USB_REQUEST_SET_FEATURE 0x03
#define USB_REQUEST_SET_ADDRESS 0x05
#define USB_REQUEST_GET_DESCRIPTOR 0x06
#define USB_REQUEST_SET_DESCRIPTOR 0x07
#define USB_REQUEST_GET_CONFIGURATION 0x08
#define USB_REQUEST_SET_CONFIGURATION 0x09
#define USB_REQUEST_GET_INTERFACE 0x0A
#define USB_REQUEST_SET_INTERFACE 0x0B
#define USB_REQUEST_SYNCH_FRAME 0x0C
#define USB_REQUEST_SET_ENCRYPTION 0x0D
#define USB_REQUEST_GET_ENCRYPTION 0x0E
#define USB_REQUEST_RPIPE_ABORT 0x0E
#define USB_REQUEST_SET_HANDSHAKE 0x0F
#define USB_REQUEST_RPIPE_RESET 0x0F
#define USB_REQUEST_GET_HANDSHAKE 0x10
#define USB_REQUEST_SET_CONNECTION 0x11
#define USB_REQUEST_SET_SECURITY_DATA 0x12
#define USB_REQUEST_GET_SECURITY_DATA 0x13
#define USB_REQUEST_SET_WUSB_DATA 0x14
#define USB_REQUEST_LOOPBACK_DATA_WRITE 0x15
#define USB_REQUEST_LOOPBACK_DATA_READ 0x16
#define USB_REQUEST_SET_INTERFACE_DS 0x17
/* USB Standard Feature selectors */
#define USB_FEATURE_ENDPOINT_HALT 0
#define USB_FEATURE_SELF_POWERED 0
#define USB_FEATURE_REMOTE_WAKEUP 1
#define USB_FEATURE_TEST_MODE 2
#define USB_FEATURE_BATTERY 2
#define USB_FEATURE_BHNPENABLE 3
#define USB_FEATURE_WUSBDEVICE 3
#define USB_FEATURE_AHNPSUPPORT 4
#define USB_FEATURE_AALTHNPSUPPORT 5
#define USB_FEATURE_DEBUGMODE 6
/* USB GET_STATUS Bit Values */
#define USB_GETSTATUS_ENDPOINT_HALT 0x01
#define USB_GETSTATUS_SELF_POWERED 0x01
#define USB_GETSTATUS_REMOTE_WAKEUP 0x02
/* USB Descriptor Types */
#define USB_DESCRIPTOR_TYPE_DEVICE 0x01U
#define USB_DESCRIPTOR_TYPE_CONFIGURATION 0x02U
#define USB_DESCRIPTOR_TYPE_STRING 0x03U
#define USB_DESCRIPTOR_TYPE_INTERFACE 0x04U
#define USB_DESCRIPTOR_TYPE_ENDPOINT 0x05U
#define USB_DESCRIPTOR_TYPE_DEVICE_QUALIFIER 0x06U
#define USB_DESCRIPTOR_TYPE_OTHER_SPEED 0x07U
#define USB_DESCRIPTOR_TYPE_INTERFACE_POWER 0x08U
#define USB_DESCRIPTOR_TYPE_OTG 0x09U
#define USB_DESCRIPTOR_TYPE_DEBUG 0x0AU
#define USB_DESCRIPTOR_TYPE_INTERFACE_ASSOCIATION 0x0BU
#define USB_DESCRIPTOR_TYPE_BINARY_OBJECT_STORE 0x0FU
#define USB_DESCRIPTOR_TYPE_DEVICE_CAPABILITY 0x10U
#define USB_DESCRIPTOR_TYPE_WIRELESS_ENDPOINTCOMP 0x11U
/* Class Specific Descriptor */
#define USB_CS_DESCRIPTOR_TYPE_DEVICE 0x21U
#define USB_CS_DESCRIPTOR_TYPE_CONFIGURATION 0x22U
#define USB_CS_DESCRIPTOR_TYPE_STRING 0x23U
#define USB_CS_DESCRIPTOR_TYPE_INTERFACE 0x24U
#define USB_CS_DESCRIPTOR_TYPE_ENDPOINT 0x25U
#define USB_DESCRIPTOR_TYPE_SUPERSPEED_ENDPOINT_COMPANION 0x30U
#define USB_DESCRIPTOR_TYPE_SUPERSPEED_ISO_ENDPOINT_COMPANION 0x31U
/* USB Device Classes */
#define USB_DEVICE_CLASS_RESERVED 0x00
#define USB_DEVICE_CLASS_AUDIO 0x01
#define USB_DEVICE_CLASS_CDC 0x02
#define USB_DEVICE_CLASS_HID 0x03
#define USB_DEVICE_CLASS_MONITOR 0x04
#define USB_DEVICE_CLASS_PHYSICAL 0x05
#define USB_DEVICE_CLASS_IMAGE 0x06
#define USB_DEVICE_CLASS_PRINTER 0x07
#define USB_DEVICE_CLASS_MASS_STORAGE 0x08
#define USB_DEVICE_CLASS_HUB 0x09
#define USB_DEVICE_CLASS_CDC_DATA 0x0a
#define USB_DEVICE_CLASS_SMART_CARD 0x0b
#define USB_DEVICE_CLASS_SECURITY 0x0d
#define USB_DEVICE_CLASS_VIDEO 0x0e
#define USB_DEVICE_CLASS_HEALTHCARE 0x0f
#define USB_DEVICE_CLASS_DIAG_DEVICE 0xdc
#define USB_DEVICE_CLASS_WIRELESS 0xe0
#define USB_DEVICE_CLASS_MISC 0xef
#define USB_DEVICE_CLASS_APP_SPECIFIC 0xfe
#define USB_DEVICE_CLASS_VEND_SPECIFIC 0xff
/* usb string index define */
#define USB_STRING_LANGID_INDEX 0x00
#define USB_STRING_MFC_INDEX 0x01
#define USB_STRING_PRODUCT_INDEX 0x02
#define USB_STRING_SERIAL_INDEX 0x03
#define USB_STRING_CONFIG_INDEX 0x04
#define USB_STRING_INTERFACE_INDEX 0x05
#define USB_STRING_OS_INDEX 0x06
#define USB_STRING_MAX USB_STRING_OS_INDEX
/*
* Devices supporting Microsoft OS Descriptors store special string
* descriptor at fixed index (0xEE). It is read when a new device is
* attached to a computer for the first time.
*/
#define USB_OSDESC_STRING_DESC_INDEX 0xEE
/* bmAttributes in Configuration Descriptor */
#define USB_CONFIG_REMOTE_WAKEUP 0x20
#define USB_CONFIG_POWERED_MASK 0x40
#define USB_CONFIG_BUS_POWERED 0x80
#define USB_CONFIG_SELF_POWERED 0xC0
/* bMaxPower in Configuration Descriptor */
#define USB_CONFIG_POWER_MA(mA) ((mA) / 2)
/* bEndpointAddress in Endpoint Descriptor */
#define USB_ENDPOINT_DIRECTION_MASK 0x80
#define USB_ENDPOINT_OUT(addr) ((addr) | 0x00)
#define USB_ENDPOINT_IN(addr) ((addr) | 0x80)
/* bmAttributes in Endpoint Descriptor */
#define USB_ENDPOINT_TYPE_SHIFT 0
#define USB_ENDPOINT_TYPE_CONTROL (0 << USB_ENDPOINT_TYPE_SHIFT)
#define USB_ENDPOINT_TYPE_ISOCHRONOUS (1 << USB_ENDPOINT_TYPE_SHIFT)
#define USB_ENDPOINT_TYPE_BULK (2 << USB_ENDPOINT_TYPE_SHIFT)
#define USB_ENDPOINT_TYPE_INTERRUPT (3 << USB_ENDPOINT_TYPE_SHIFT)
#define USB_ENDPOINT_TYPE_MASK (3 << USB_ENDPOINT_TYPE_SHIFT)
#define USB_ENDPOINT_SYNC_SHIFT 2
#define USB_ENDPOINT_SYNC_NO_SYNCHRONIZATION (0 << USB_ENDPOINT_SYNC_SHIFT)
#define USB_ENDPOINT_SYNC_ASYNCHRONOUS (1 << USB_ENDPOINT_SYNC_SHIFT)
#define USB_ENDPOINT_SYNC_ADAPTIVE (2 << USB_ENDPOINT_SYNC_SHIFT)
#define USB_ENDPOINT_SYNC_SYNCHRONOUS (3 << USB_ENDPOINT_SYNC_SHIFT)
#define USB_ENDPOINT_SYNC_MASK (3 << USB_ENDPOINT_SYNC_SHIFT)
#define USB_ENDPOINT_USAGE_SHIFT 4
#define USB_ENDPOINT_USAGE_DATA (0 << USB_ENDPOINT_USAGE_SHIFT)
#define USB_ENDPOINT_USAGE_FEEDBACK (1 << USB_ENDPOINT_USAGE_SHIFT)
#define USB_ENDPOINT_USAGE_IMPLICIT_FEEDBACK (2 << USB_ENDPOINT_USAGE_SHIFT)
#define USB_ENDPOINT_USAGE_MASK (3 << USB_ENDPOINT_USAGE_SHIFT)
#define USB_ENDPOINT_MAX_ADJUSTABLE (1 << 7)
/* bDevCapabilityType in Device Capability Descriptor */
#define USB_DEVICE_CAPABILITY_WIRELESS_USB 1
#define USB_DEVICE_CAPABILITY_USB_2_0_EXTENSION 2
#define USB_DEVICE_CAPABILITY_SUPERSPEED_USB 3
#define USB_DEVICE_CAPABILITY_CONTAINER_ID 4
#define USB_DEVICE_CAPABILITY_PLATFORM 5
#define USB_DEVICE_CAPABILITY_POWER_DELIVERY_CAPABILITY 6
#define USB_DEVICE_CAPABILITY_BATTERY_INFO_CAPABILITY 7
#define USB_DEVICE_CAPABILITY_PD_CONSUMER_PORT_CAPABILITY 8
#define USB_DEVICE_CAPABILITY_PD_PROVIDER_PORT_CAPABILITY 9
#define USB_DEVICE_CAPABILITY_SUPERSPEED_PLUS 10
#define USB_DEVICE_CAPABILITY_PRECISION_TIME_MEASUREMENT 11
#define USB_DEVICE_CAPABILITY_WIRELESS_USB_EXT 12
#define USB_BOS_CAPABILITY_EXTENSION 0x02
#define USB_BOS_CAPABILITY_PLATFORM 0x05
/* OTG SET FEATURE Constants */
#define USB_OTG_FEATURE_B_HNP_ENABLE 3 /* Enable B device to perform HNP */
#define USB_OTG_FEATURE_A_HNP_SUPPORT 4 /* A device supports HNP */
#define USB_OTG_FEATURE_A_ALT_HNP_SUPPORT 5 /* Another port on the A device supports HNP */
/* WinUSB Microsoft OS 2.0 descriptor request codes */
#define WINUSB_REQUEST_GET_DESCRIPTOR_SET 0x07
#define WINUSB_REQUEST_SET_ALT_ENUM 0x08
/* WinUSB Microsoft OS 2.0 descriptor sizes */
#define WINUSB_DESCRIPTOR_SET_HEADER_SIZE 10
#define WINUSB_FUNCTION_SUBSET_HEADER_SIZE 8
#define WINUSB_FEATURE_COMPATIBLE_ID_SIZE 20
/* WinUSB Microsoft OS 2.0 Descriptor Types */
#define WINUSB_SET_HEADER_DESCRIPTOR_TYPE 0x00
#define WINUSB_SUBSET_HEADER_CONFIGURATION_TYPE 0x01
#define WINUSB_SUBSET_HEADER_FUNCTION_TYPE 0x02
#define WINUSB_FEATURE_COMPATIBLE_ID_TYPE 0x03
#define WINUSB_FEATURE_REG_PROPERTY_TYPE 0x04
#define WINUSB_FEATURE_MIN_RESUME_TIME_TYPE 0x05
#define WINUSB_FEATURE_MODEL_ID_TYPE 0x06
#define WINUSB_FEATURE_CCGP_DEVICE_TYPE 0x07
#define WINUSB_PROP_DATA_TYPE_REG_SZ 0x01
#define WINUSB_PROP_DATA_TYPE_REG_MULTI_SZ 0x07
/* WebUSB Descriptor Types */
#define WEBUSB_DESCRIPTOR_SET_HEADER_TYPE 0x00
#define WEBUSB_CONFIGURATION_SUBSET_HEADER_TYPE 0x01
#define WEBUSB_FUNCTION_SUBSET_HEADER_TYPE 0x02
#define WEBUSB_URL_TYPE 0x03
/* WebUSB Request Codes */
#define WEBUSB_REQUEST_GET_URL 0x02
/* bScheme in URL descriptor */
#define WEBUSB_URL_SCHEME_HTTP 0x00
#define WEBUSB_URL_SCHEME_HTTPS 0x01
/* WebUSB Descriptor sizes */
#define WEBUSB_DESCRIPTOR_SET_HEADER_SIZE 5
#define WEBUSB_CONFIGURATION_SUBSET_HEADER_SIZE 4
#define WEBUSB_FUNCTION_SUBSET_HEADER_SIZE 3
/* Setup packet definition used to read raw data from USB line */
struct usb_setup_packet {
/** Request type. Bits 0:4 determine recipient, see
* \ref usb_request_recipient. Bits 5:6 determine type, see
* \ref usb_request_type. Bit 7 determines data transfer direction, see
* \ref usb_endpoint_direction.
*/
uint8_t bmRequestType;
/** Request. If the type bits of bmRequestType are equal to
* \ref usb_request_type::LIBUSB_REQUEST_TYPE_STANDARD
* "USB_REQUEST_TYPE_STANDARD" then this field refers to
* \ref usb_standard_request. For other cases, use of this field is
* application-specific. */
uint8_t bRequest;
/** Value. Varies according to request */
uint16_t wValue;
/** Index. Varies according to request, typically used to pass an index
* or offset */
uint16_t wIndex;
/** Number of bytes to transfer */
uint16_t wLength;
} __PACKED;
#define USB_SIZEOF_SETUP_PACKET 8
/** Standard Device Descriptor */
struct usb_device_descriptor {
uint8_t bLength; /* Descriptor size in bytes = 18 */
uint8_t bDescriptorType; /* DEVICE descriptor type = 1 */
uint16_t bcdUSB; /* USB spec in BCD, e.g. 0x0200 */
uint8_t bDeviceClass; /* Class code, if 0 see interface */
uint8_t bDeviceSubClass; /* Sub-Class code, 0 if class = 0 */
uint8_t bDeviceProtocol; /* Protocol, if 0 see interface */
uint8_t bMaxPacketSize0; /* Endpoint 0 max. size */
uint16_t idVendor; /* Vendor ID per USB-IF */
uint16_t idProduct; /* Product ID per manufacturer */
uint16_t bcdDevice; /* Device release # in BCD */
uint8_t iManufacturer; /* Index to manufacturer string */
uint8_t iProduct; /* Index to product string */
uint8_t iSerialNumber; /* Index to serial number string */
uint8_t bNumConfigurations; /* Number of possible configurations */
} __PACKED;
#define USB_SIZEOF_DEVICE_DESC 18
/** Standard Configuration Descriptor */
struct usb_configuration_descriptor {
uint8_t bLength; /* Descriptor size in bytes = 9 */
uint8_t bDescriptorType; /* CONFIGURATION type = 2 or 7 */
uint16_t wTotalLength; /* Length of concatenated descriptors */
uint8_t bNumInterfaces; /* Number of interfaces, this config. */
uint8_t bConfigurationValue; /* Value to set this config. */
uint8_t iConfiguration; /* Index to configuration string */
uint8_t bmAttributes; /* Config. characteristics */
uint8_t bMaxPower; /* Max.power from bus, 2mA units */
} __PACKED;
#define USB_SIZEOF_CONFIG_DESC 9
/** Standard Interface Descriptor */
struct usb_interface_descriptor {
uint8_t bLength; /* Descriptor size in bytes = 9 */
uint8_t bDescriptorType; /* INTERFACE descriptor type = 4 */
uint8_t bInterfaceNumber; /* Interface no.*/
uint8_t bAlternateSetting; /* Value to select this IF */
uint8_t bNumEndpoints; /* Number of endpoints excluding 0 */
uint8_t bInterfaceClass; /* Class code, 0xFF = vendor */
uint8_t bInterfaceSubClass; /* Sub-Class code, 0 if class = 0 */
uint8_t bInterfaceProtocol; /* Protocol, 0xFF = vendor */
uint8_t iInterface; /* Index to interface string */
} __PACKED;
#define USB_SIZEOF_INTERFACE_DESC 9
/** Standard Endpoint Descriptor */
struct usb_endpoint_descriptor {
uint8_t bLength; /* Descriptor size in bytes = 7 */
uint8_t bDescriptorType; /* ENDPOINT descriptor type = 5 */
uint8_t bEndpointAddress; /* Endpoint # 0 - 15 | IN/OUT */
uint8_t bmAttributes; /* Transfer type */
uint16_t wMaxPacketSize; /* Bits 10:0 = max. packet size */
uint8_t bInterval; /* Polling interval in (micro) frames */
} __PACKED;
#define USB_SIZEOF_ENDPOINT_DESC 7
/** Unicode (UTF16LE) String Descriptor */
struct usb_string_descriptor {
uint8_t bLength;
uint8_t bDescriptorType;
uint16_t bString;
} __PACKED;
#define USB_SIZEOF_STRING_LANGID_DESC 4
/* USB Interface Association Descriptor */
struct usb_interface_association_descriptor {
uint8_t bLength;
uint8_t bDescriptorType;
uint8_t bFirstInterface;
uint8_t bInterfaceCount;
uint8_t bFunctionClass;
uint8_t bFunctionSubClass;
uint8_t bFunctionProtocol;
uint8_t iFunction;
} __PACKED;
#define USB_SIZEOF_IAD_DESC 8
/** USB device_qualifier descriptor */
struct usb_device_qualifier_descriptor {
uint8_t bLength; /* Descriptor size in bytes = 10 */
uint8_t bDescriptorType; /* DEVICE QUALIFIER type = 6 */
uint16_t bcdUSB; /* USB spec in BCD, e.g. 0x0200 */
uint8_t bDeviceClass; /* Class code, if 0 see interface */
uint8_t bDeviceSubClass; /* Sub-Class code, 0 if class = 0 */
uint8_t bDeviceProtocol; /* Protocol, if 0 see interface */
uint8_t bMaxPacketSize; /* Endpoint 0 max. size */
uint8_t bNumConfigurations; /* Number of possible configurations */
uint8_t bReserved; /* Reserved = 0 */
} __PACKED;
#define USB_SIZEOF_DEVICE_QUALIFIER_DESC 10
/* Microsoft OS function descriptor.
* This can be used to request a specific driver (such as WINUSB) to be
* loaded on Windows. Unlike other descriptors, it is requested by a special
* request USB_REQ_GETMSFTOSDESCRIPTOR.
* More details:
* https://msdn.microsoft.com/en-us/windows/hardware/gg463179
* And excellent explanation:
* https://github.com/pbatard/libwdi/wiki/WCID-Devices
*
* The device will have exactly one "Extended Compat ID Feature Descriptor",
* which may contain multiple "Function Descriptors" associated with
* different interfaces.
*/
/* MS OS 1.0 string descriptor */
struct usb_msosv1_string_descriptor {
uint8_t bLength;
uint8_t bDescriptorType;
uint8_t bString[14];
uint8_t bMS_VendorCode; /* Vendor Code, used for a control request */
uint8_t bPad; /* Padding byte for VendorCode look as UTF16 */
} __PACKED;
/* MS OS 1.0 Header descriptor */
struct usb_msosv1_compat_id_header_descriptor {
uint32_t dwLength;
uint16_t bcdVersion;
uint16_t wIndex;
uint8_t bCount;
uint8_t reserved[7];
} __PACKED;
/* MS OS 1.0 Function descriptor */
struct usb_msosv1_comp_id_function_descriptor {
uint8_t bFirstInterfaceNumber;
uint8_t reserved1;
uint8_t compatibleID[8];
uint8_t subCompatibleID[8];
uint8_t reserved2[6];
} __PACKED;
#define usb_msosv1_comp_id_create(x) \
struct usb_msosv1_comp_id { \
struct usb_msosv1_compat_id_header_descriptor compat_id_header; \
struct usb_msosv1_comp_id_function_descriptor compat_id_function[x]; \
};
struct usb_msosv1_descriptor {
uint8_t *string;
uint8_t string_len;
uint8_t vendor_code;
uint8_t *compat_id;
uint16_t compat_id_len;
uint8_t *comp_id_property;
uint16_t comp_id_property_len;
};
/* MS OS 2.0 Header descriptor */
struct usb_msosv2_header_descriptor {
uint32_t dwLength;
uint16_t bcdVersion;
uint16_t wIndex;
uint8_t bCount;
} __PACKED;
/*Microsoft OS 2.0 set header descriptor*/
struct usb_msosv2_set_header_descriptor {
uint16_t wLength;
uint16_t wDescriptorType;
uint32_t dwWindowsVersion;
uint16_t wDescriptorSetTotalLength;
} __PACKED;
/* Microsoft OS 2.0 compatibleID descriptor*/
struct usb_msosv2_comp_id_descriptor {
uint16_t wLength;
uint16_t wDescriptorType;
uint8_t compatibleID[8];
uint8_t subCompatibleID[8];
} __PACKED;
/* MS OS 2.0 property descriptor */
struct usb_msosv2_property_descriptor {
uint16_t wLength;
uint16_t wDescriptorType;
uint32_t dwPropertyDataType;
uint16_t wPropertyNameLength;
const char *bPropertyName;
uint32_t dwPropertyDataLength;
const char *bPropertyData;
};
/* Microsoft OS 2.0 subset function descriptor */
struct usb_msosv2_subset_function_descriptor {
uint16_t wLength;
uint16_t wDescriptorType;
uint8_t bFirstInterface;
uint8_t bReserved;
uint16_t wSubsetLength;
} __PACKED;
struct usb_msosv2_descriptor {
uint8_t *compat_id;
uint16_t compat_id_len;
uint8_t vendor_code;
};
/* BOS header Descriptor */
struct usb_bos_header_descriptor {
uint8_t bLength;
uint8_t bDescriptorType;
uint16_t wTotalLength;
uint8_t bNumDeviceCaps;
} __PACKED;
/* BOS Capability platform Descriptor */
struct usb_bos_capability_platform_descriptor {
uint8_t bLength;
uint8_t bDescriptorType;
uint8_t bDevCapabilityType;
uint8_t bReserved;
uint8_t PlatformCapabilityUUID[16];
} __PACKED;
/* BOS Capability MS OS Descriptors version 2 */
struct usb_bos_capability_msosv2_descriptor {
uint32_t dwWindowsVersion;
uint16_t wMSOSDescriptorSetTotalLength;
uint8_t bVendorCode;
uint8_t bAltEnumCode;
} __PACKED;
/* BOS Capability webusb */
struct usb_bos_capability_webusb_descriptor {
uint16_t bcdVersion;
uint8_t bVendorCode;
uint8_t iLandingPage;
} __PACKED;
/* BOS Capability extension Descriptor*/
struct usb_bos_capability_extension_descriptor {
uint8_t bLength;
uint8_t bDescriptorType;
uint8_t bDevCapabilityType;
uint32_t bmAttributes;
} __PACKED;
/* Microsoft OS 2.0 Platform Capability Descriptor
* See https://docs.microsoft.com/en-us/windows-hardware/drivers/usbcon/
* microsoft-defined-usb-descriptors
* Adapted from the source:
* https://github.com/sowbug/weblight/blob/master/firmware/webusb.c
* (BSD-2) Thanks http://janaxelson.com/files/ms_os_20_descriptors.c
*/
struct usb_bos_capability_platform_msosv2_descriptor {
struct usb_bos_capability_platform_descriptor platform_msos;
struct usb_bos_capability_msosv2_descriptor data_msosv2;
} __PACKED;
/* WebUSB Platform Capability Descriptor:
* https://wicg.github.io/webusb/#webusb-platform-capability-descriptor
*/
struct usb_bos_capability_platform_webusb_descriptor {
struct usb_bos_capability_platform_descriptor platform_webusb;
struct usb_bos_capability_webusb_descriptor data_webusb;
} __PACKED;
struct usb_webusb_url_descriptor {
uint8_t bLength;
uint8_t bDescriptorType;
uint8_t bScheme;
char URL[];
} __PACKED;
struct usb_bos_descriptor {
uint8_t *string;
uint32_t string_len;
};
/* USB Device Capability Descriptor */
struct usb_device_capability_descriptor {
uint8_t bLength;
uint8_t bDescriptorType;
uint8_t bDevCapabilityType;
} __PACKED;
/** USB descriptor header */
struct usb_desc_header {
uint8_t bLength; /**< descriptor length */
uint8_t bDescriptorType; /**< descriptor type */
};
// clang-format off
#define USB_DEVICE_DESCRIPTOR_INIT(bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, idVendor, idProduct, bcdDevice, bNumConfigurations) \
0x12, /* bLength */ \
USB_DESCRIPTOR_TYPE_DEVICE, /* bDescriptorType */ \
WBVAL(bcdUSB), /* bcdUSB */ \
bDeviceClass, /* bDeviceClass */ \
bDeviceSubClass, /* bDeviceSubClass */ \
bDeviceProtocol, /* bDeviceProtocol */ \
0x40, /* bMaxPacketSize */ \
WBVAL(idVendor), /* idVendor */ \
WBVAL(idProduct), /* idProduct */ \
WBVAL(bcdDevice), /* bcdDevice */ \
USB_STRING_MFC_INDEX, /* iManufacturer */ \
USB_STRING_PRODUCT_INDEX, /* iProduct */ \
USB_STRING_SERIAL_INDEX, /* iSerial */ \
bNumConfigurations /* bNumConfigurations */
#define USB_CONFIG_DESCRIPTOR_INIT(wTotalLength, bNumInterfaces, bConfigurationValue, bmAttributes, bMaxPower) \
0x09, /* bLength */ \
USB_DESCRIPTOR_TYPE_CONFIGURATION, /* bDescriptorType */ \
WBVAL(wTotalLength), /* wTotalLength */ \
bNumInterfaces, /* bNumInterfaces */ \
bConfigurationValue, /* bConfigurationValue */ \
0x00, /* iConfiguration */ \
bmAttributes, /* bmAttributes */ \
USB_CONFIG_POWER_MA(bMaxPower) /* bMaxPower */
#define USB_INTERFACE_DESCRIPTOR_INIT(bInterfaceNumber, bAlternateSetting, bNumEndpoints, \
bInterfaceClass, bInterfaceSubClass, bInterfaceProtocol, iInterface) \
0x09, /* bLength */ \
USB_DESCRIPTOR_TYPE_INTERFACE, /* bDescriptorType */ \
bInterfaceNumber, /* bInterfaceNumber */ \
bAlternateSetting, /* bAlternateSetting */ \
bNumEndpoints, /* bNumEndpoints */ \
bInterfaceClass, /* bInterfaceClass */ \
bInterfaceSubClass, /* bInterfaceSubClass */ \
bInterfaceProtocol, /* bInterfaceProtocol */ \
iInterface /* iInterface */
#define USB_ENDPOINT_DESCRIPTOR_INIT(bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval) \
0x07, /* bLength */ \
USB_DESCRIPTOR_TYPE_ENDPOINT, /* bDescriptorType */ \
bEndpointAddress, /* bEndpointAddress */ \
bmAttributes, /* bmAttributes */ \
WBVAL(wMaxPacketSize), /* wMaxPacketSize */ \
bInterval /* bInterval */
#define USB_IAD_INIT(bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass, bFunctionProtocol) \
0x08, /* bLength */ \
USB_DESCRIPTOR_TYPE_INTERFACE_ASSOCIATION, /* bDescriptorType */ \
bFirstInterface, /* bFirstInterface */ \
bInterfaceCount, /* bInterfaceCount */ \
bFunctionClass, /* bFunctionClass */ \
bFunctionSubClass, /* bFunctionSubClass */ \
bFunctionProtocol, /* bFunctionProtocol */ \
0x00 /* iFunction */
#define USB_LANGID_INIT(id) \
0x04, /* bLength */ \
USB_DESCRIPTOR_TYPE_STRING, /* bDescriptorType */ \
WBVAL(id) /* wLangID0 */
// clang-format on
#endif
| 42.488095 | 144 | 0.660514 |
3ea4ebf6151a23737b247f807cd001b52fe8acec | 3,606 | h | C | System/Library/Frameworks/Metal.framework/_MTLLibrary.h | zhangkn/iOS14Header | 4323e9459ed6f6f5504ecbea2710bfd6c3d7c946 | [
"MIT"
] | 1 | 2020-11-04T15:43:01.000Z | 2020-11-04T15:43:01.000Z | System/Library/Frameworks/Metal.framework/_MTLLibrary.h | zhangkn/iOS14Header | 4323e9459ed6f6f5504ecbea2710bfd6c3d7c946 | [
"MIT"
] | null | null | null | System/Library/Frameworks/Metal.framework/_MTLLibrary.h | zhangkn/iOS14Header | 4323e9459ed6f6f5504ecbea2710bfd6c3d7c946 | [
"MIT"
] | null | null | null | /*
* This header is generated by classdump-dyld 1.0
* on Sunday, September 27, 2020 at 11:41:53 AM Mountain Standard Time
* Operating System: Version 14.0 (Build 18A373)
* Image Source: /System/Library/Frameworks/Metal.framework/Metal
* classdump-dyld is licensed under GPLv3, Copyright © 2013-2016 by Elias Limneos.
*/
#import <Metal/Metal-Structs.h>
#import <Metal/_MTLObjectWithLabel.h>
#import <libobjc.A.dylib/MTLLibrarySPI.h>
@protocol MTLDevice;
@class NSString, NSArray, NSMutableDictionary;
@interface _MTLLibrary : _MTLObjectWithLabel <MTLLibrarySPI> {
id<MTLDevice> _device;
MTLLibraryData* _libraryData;
NSMutableDictionary* _functionDictionary;
MTLLibraryContainer* _cacheEntry;
}
@property (nonatomic,retain,readonly) NSMutableDictionary * functionDictionary; //@synthesize functionDictionary=_functionDictionary - In the implementation block
@property (copy) NSString * label;
@property (readonly) id<MTLDevice> device; //@synthesize device=_device - In the implementation block
@property (retain,readonly) NSArray * functionNames;
@property (retain,readonly) NSArray * externFunctionNames;
@property (readonly) MTLLibraryData* libraryData; //@synthesize libraryData=_libraryData - In the implementation block
@property (readonly) MTLLibraryContainer* cacheEntry; //@synthesize cacheEntry=_cacheEntry - In the implementation block
@property (copy) NSString * overrideTriple;
@property (readonly) NSArray * variableList;
@property (readonly) long long type;
@property (readonly) NSString * installName;
@property (readonly) unsigned long long hash;
@property (readonly) Class superclass;
@property (copy,readonly) NSString * description;
@property (copy,readonly) NSString * debugDescription;
-(id<MTLDevice>)device;
-(NSString *)overrideTriple;
-(NSArray *)functionNames;
-(id)newFunctionWithName:(id)arg1 constantValues:(id)arg2 functionCache:(id)arg3 error:(id*)arg4 ;
-(id)initWithLibraryContainer:(MTLLibraryContainer*)arg1 device:(id)arg2 ;
-(NSString *)installName;
-(void)newFunctionWithName:(id)arg1 constantValues:(id)arg2 pipelineLibrary:(id)arg3 completionHandler:(/*^block*/id)arg4 ;
-(id)newExternFunctionWithName:(id)arg1 ;
-(void)dealloc;
-(void)newFunctionWithName:(id)arg1 constantValues:(id)arg2 functionCache:(id)arg3 specializedName:(id)arg4 completionHandler:(/*^block*/id)arg5 ;
-(id)newFunctionWithName:(id)arg1 constantValues:(id)arg2 functionCache:(id)arg3 specializedName:(id)arg4 error:(id*)arg5 ;
-(id)newFunctionWithName:(id)arg1 ;
-(MTLLibraryData*)libraryData;
-(id)newFunctionWithName:(id)arg1 constantValues:(id)arg2 pipelineLibrary:(id)arg3 error:(id*)arg4 ;
-(void)newFunctionWithName:(id)arg1 constantValues:(id)arg2 completionHandler:(/*^block*/id)arg3 ;
-(NSMutableDictionary *)functionDictionary;
-(long long)type;
-(void)setOverrideTriple:(NSString *)arg1 ;
-(NSArray *)variableList;
-(void)newFunctionWithDescriptor:(id)arg1 completionHandler:(/*^block*/id)arg2 ;
-(id)newFunctionWithNameInternal:(id)arg1 ;
-(id)libraryDataContents;
-(MTLLibraryContainer*)cacheEntry;
-(void)newIntersectionFunctionWithDescriptor:(id)arg1 completionHandler:(/*^block*/id)arg2 ;
-(id)newFunctionWithName:(id)arg1 constantValues:(id)arg2 error:(id*)arg3 ;
-(id)newFunctionWithDescriptor:(id)arg1 error:(id*)arg2 ;
-(id)newIntersectionFunctionWithDescriptor:(id)arg1 error:(id*)arg2 ;
-(id)formattedDescription:(unsigned long long)arg1 ;
-(NSArray *)externFunctionNames;
-(NSString *)description;
@end
| 50.083333 | 175 | 0.754021 |
e24b7315869b56c33d689344218595d7cfdb2b19 | 14,774 | c | C | src/libxpeccy/hardware/bk0010-01.c | nihirash/Xpeccy | a739428d82205a9e22cf0c0a8d982817bb441e44 | [
"MIT"
] | 1 | 2020-10-28T16:43:28.000Z | 2020-10-28T16:43:28.000Z | src/libxpeccy/hardware/bk0010-01.c | nihirash/Xpeccy | a739428d82205a9e22cf0c0a8d982817bb441e44 | [
"MIT"
] | null | null | null | src/libxpeccy/hardware/bk0010-01.c | nihirash/Xpeccy | a739428d82205a9e22cf0c0a8d982817bb441e44 | [
"MIT"
] | 1 | 2020-06-06T15:30:59.000Z | 2020-06-06T15:30:59.000Z | #include <string.h>
#include "hardware.h"
// BK0010
// dot: 25.175MHz (~40 ns/dot)
// timer: cpu/128
// hdd
// ffe0 : wr:com rd:status (7)
// ffe1 : #17
// ffe2 : master/slave select, head (6)
// ffe3 : rd: astate (#16)
// ffe4 : trk (hi) (5)
// ffe6 : trk (low) (4)
// ffe8 : sec (3)
// ffec : rd:error code (1)
// ffee : data.low (0)
// ffef : data.high (#10 ? )
// ~bit1..3 = register
// bit 0 : alt.reg (#16, #17)
// data reg is 16-bit, others 8-bit
// fdc
int bk_fdc_rd(Computer* comp, int adr) {
comp->wdata = difIn(comp->dif, (adr & 2) >> 1, NULL, 0) & 0xffff;
return 0;
}
void bk_fdc_wr(Computer* comp, int adr, int val) {
// difOut(comp->dif, (adr & 2) ? 1 : 0, 0, comp->wdata);
}
// keboard
int bk_kbf_rd(Computer* comp, int adr) {
comp->wdata = comp->keyb->flag & 0xc0;
return 0;
}
void bk_kbf_wr(Computer* comp, int adr, int val) {
if (comp->cpu->nod & 1) {
comp->keyb->flag &= ~0x40;
comp->keyb->flag |= (val & 0x40);
}
}
int bk_kbd_rd(Computer* comp, int adr) {
comp->wdata = comp->keyb->keycode & 0x7f;
comp->keyb->flag &= 0x7f; // reset b7,flag
return 0;
}
// scroller
int bk_scr_rd(Computer* comp, int adr) {
comp->wdata = comp->vid->sc.y & 0x00ff;
if (!comp->vid->cutscr)
comp->wdata |= 0x200;
return 0;
}
void bk_scr_wr(Computer* comp, int adr, int val) {
if (comp->cpu->nod & 1) {
comp->vid->sc.y = val & 0xff;
}
if (comp->cpu->nod & 2) {
comp->vid->cutscr = (val & 0x0200) ? 0 : 1;
}
}
// pc/psw
int bk_str_rd(Computer* comp, int adr) {
comp->wdata = (comp->iomap[adr & ~1] & 0xff) | ((comp->iomap[adr | 1] << 8) & 0xff00);
return 0;
}
// timer
int bk_tiv_rd(Computer* comp, int adr) {
comp->wdata = comp->cpu->timer.ival;
return 0;
}
int bk_tva_rd(Computer* comp, int adr) {
comp->wdata = comp->cpu->timer.val;
return 0;
}
int bk_tfl_rd(Computer* comp, int adr) {
comp->wdata = (comp->cpu->timer.flag & 0xff) | 0xff00;
return 0;
}
void bk_tiv_wr(Computer* comp, int adr, int val) {
if (comp->cpu->nod & 1)
comp->cpu->timer.ivl = val & 0xff;
if (comp->cpu->nod & 2)
comp->cpu->timer.ivh = (val >> 8) & 0xff;
}
void bk_tva_wr(Computer* comp, int adr, int val) {
if (comp->cpu->nod & 1)
comp->cpu->timer.vl = val & 0xff;
if (comp->cpu->nod & 2)
comp->cpu->timer.vh = (val >> 8) & 0xff;
}
void bk_tfl_wr(Computer* comp, int adr, int val) {
if (comp->cpu->nod & 1) {
comp->cpu->timer.flag = val & 0xff;
comp->cpu->timer.per = 128;
if (val & 0x40) comp->cpu->timer.per <<= 2; // div 4
if (val & 0x20) comp->cpu->timer.per <<= 4; // div 16
if (val & 0x12) comp->cpu->timer.val = comp->cpu->timer.ival; // reload
}
}
// external
int bk_fcc_rd(Computer* comp, int adr) {
comp->wdata = 0;
return 0;
}
// 177776: system
int bk_sys_rd(Computer* comp, int adr) {
comp->wdata = 0x8000; // 8000 for 0010, c000 for 0011
// comp->wdata |= 0x80; // TL ready
if (comp->reg[0xce]) { // b2: write to system port flag
comp->wdata |= 4;
comp->reg[0xce] = 0; // reset on reading
}
// b5: tape signal
if (comp->tape->on && !comp->tape->rec && (comp->tape->volPlay & 0x80)) {
comp->wdata |= 0x20;
}
// b6: key pressed
if (!(comp->keyb->flag & 0x20)) {
comp->wdata |= 0x40; // = 0 if any key pressed, 1 if not
}
// b7: TL ready
return 0;
}
void bk_sys_wr(Computer* comp, int adr, int val) {
if (comp->cpu->nod & 1) {
// b7: tape motor control (1:stop, 0:play)
if (!(val & 0x80) && !comp->tape->on) {
tapPlay(comp->tape);
} else if ((val & 0x80) && comp->tape->on && !comp->tape->rec) {
tapStop(comp->tape);
}
// b6 : beep
comp->beep->lev = (val & 0x40) ? 1 : 0;
// b6 : tape rec (main)
comp->tape->levRec = (val & 0x40) ? 1 : 0;
// b4: TL write
comp->reg[0xce] = 1; // write to system port
}
}
// * debug
int bk_dbg_rd(Computer* comp, int adr) {
comp->wdata = 0xffff;
printf("%.4X : rd %.4X\n",comp->cpu->pc, adr);
assert(0);
return 1;
}
void bk_dbg_wr(Computer* comp, int adr, int val) {
printf("%.4X : wr %.4X, %.4X (nod = %i)\n",comp->cpu->pc, adr, val, comp->cpu->nod);
assert(0);
}
static xPort bk_io_tab[] = {
{0xfffc, 0xfe58, 2, 2, 2, bk_fdc_rd, bk_fdc_wr}, // 177130..32:fdc
{0xfffe, 0xffb0, 2, 2, 2, bk_kbf_rd, bk_kbf_wr}, // 177660: keyflag
{0xfffe, 0xffb2, 2, 2, 2, bk_kbd_rd, NULL}, // 177662: keycode
{0xfffe, 0xffb4, 2, 2, 2, bk_scr_rd, bk_scr_wr}, // 177664: scroller
{0xfffc, 0xffbc, 2, 2, 2, bk_str_rd, NULL}, // 177704: storage (pc/psw)
{0xfffe, 0xffc6, 2, 2, 2, bk_tiv_rd, bk_tiv_wr}, // 177706: timer
{0xfffe, 0xffc8, 2, 2, 2, bk_tva_rd, bk_tva_wr}, // 177710
{0xfffe, 0xffca, 2, 2, 2, bk_tfl_rd, bk_tfl_wr}, // 177712
{0xfffe, 0xffcc, 2, 2, 2, bk_fcc_rd, NULL}, // 177714: ext (printer / ay / joystick)
{0xfffe, 0xffce, 2, 2, 2, bk_sys_rd, bk_sys_wr}, // 177716: system
{0x0000, 0x0000, 2, 2, 2, bk_dbg_rd, bk_dbg_wr}
};
// cpu allways read whole word from even adr
int bk_io_rd(int adr, void* ptr) {
Computer* comp = (Computer*)ptr;
adr &= ~1;
hwIn(bk_io_tab, comp, adr, 0);
return comp->wdata;
}
// if cpu->nod = 1, write 1 byte immediately
// if cpu->nod = 0:
// even adr : store low byte in wdata
// odd adr : is high byte, add stored low byte, write whole word
void bk_io_wr(int adr, int val, void* ptr) {
Computer* comp = (Computer*)ptr;
#if 1
if (comp->cpu->nod & 1) // LSB
comp->iomap[(adr & ~1) & 0xffff] = val & 0xff;
if (comp->cpu->nod & 2) // MSB
comp->iomap[(adr | 1) & 0xffff] = (val >> 1) & 0xff;
hwOut(bk_io_tab, comp, adr & ~1, val, 0);
#else
comp->iomap[adr] = val;
if (comp->cpu->nod) { // write byte
comp->wdata = (comp->iomap[adr & ~1] | (comp->iomap[adr | 1] << 8)) & 0xffff;
hwOut(bk_io_tab, comp, adr & ~1, 0, 0);
} else {
if (adr & 1) {
comp->wdata &= 0xff;
comp->wdata |= (val << 8);
hwOut(bk_io_tab, comp, adr & ~1, 0, 0); // all data in comp->wdata
} else {
comp->wdata = val & 0xff;
}
}
#endif
}
int bk_ram_rd(int adr, void* ptr) {
Computer* comp = (Computer*)ptr;
int res;
adr &= ~1;
int fadr = (comp->mem->map[(adr >> 8) & 0xff].num << 8) | (adr & 0xff);
comp->cpu->t += 3;
res = comp->mem->ramData[fadr & comp->mem->ramMask] & 0xff;
fadr++;
res |= (comp->mem->ramData[fadr & comp->mem->ramMask] << 8) & 0xff00;
return res;
}
void bk_ram_wr(int adr, int val, void* ptr) {
Computer* comp = (Computer*)ptr;
comp->cpu->t += 2;
int fadr = (comp->mem->map[(adr >> 8) & 0xff].num << 8) | (adr & 0xff);
if (comp->cpu->nod & 1)
comp->mem->ramData[(fadr & ~1) & comp->mem->ramMask] = val & 0xff;
if (comp->cpu->nod & 2)
comp->mem->ramData[(fadr | 1) & comp->mem->ramMask] = (val >> 8) & 0xff;
}
int bk_rom_rd(int adr, void* ptr) {
Computer* comp = (Computer*)ptr;
int res;
adr &= ~1;
int fadr = (comp->mem->map[(adr >> 8) & 0xff].num << 8) | (adr & 0xff);
comp->cpu->t += 2;
res = comp->mem->romData[fadr & comp->mem->romMask] & 0xff;
fadr++;
res |= (comp->mem->romData[fadr & comp->mem->romMask] << 8) & 0xff00;
return res;
}
void bk_rom_wr(int adr, int val, void* ptr) {
// nothing to do
}
void bk_sync(Computer* comp, int ns) {
if ((comp->vid->newFrame) && (comp->iomap[0xffb3] & 0x40)) {
comp->cpu->intrq |= PDP_INT_IRQ2;
}
tapSync(comp->tape, ns);
bcSync(comp->beep, ns);
difSync(comp->dif, ns);
}
void bk_mem_map(Computer* comp) {
memSetBank(comp->mem, 0x00, MEM_RAM, 6, MEM_16K, bk_ram_rd, bk_ram_wr, comp); // page 6 (0)
memSetBank(comp->mem, 0x40, MEM_RAM, 1, MEM_16K, bk_ram_rd, bk_ram_wr, comp); // page 1 : scr 0
memSetBank(comp->mem, 0x80, MEM_ROM, 0, MEM_32K, bk_rom_rd, bk_rom_wr, comp);
memSetBank(comp->mem, 0xff, MEM_IO, 0xff, MEM_256, bk_io_rd, bk_io_wr, comp);
// for 11
/*
if (comp->reg[1] & 0x80) {
memSetBank(comp->mem, 0x80, MEM_ROM, comp->reg[1] & 3, MEM_16K, NULL, NULL, NULL);
} else {
memSetBank(comp->mem, 0x80, MEM_RAM, comp->reg[1] & 7, MEM_16K, NULL, NULL, NULL);
}
memSetBank(comp->mem, 0xc0, MEM_ROM, 4, MEM_8K, NULL, NULL, NULL);
if (comp->dif->type == DIF_SMK512) {
memSetBank(comp->mem, 0xe0, MEM_ROM, 5, MEM_8K, NULL, NULL, NULL); // disk interface rom
memSetBank(comp->mem, 0xfe, MEM_IO, 0xfe, MEM_512, bk_io_rd, bk_io_wr, comp); // 0170000..0177776 with disk interface
} else {
memSetBank(comp->mem, 0xe0, MEM_EXT, 7, MEM_8K, NULL, NULL, NULL); // empty space
memSetBank(comp->mem, 0xff, MEM_IO, 0xff, MEM_256, bk_io_rd, bk_io_wr, comp); // 0177600..0177776 without disk interface
}
*/
}
#define BK_BLK {0,0,0}
#define BK_BLU {0,0,255}
#define BK_RED {255,0,0}
#define BK_MAG {255,0,255}
#define BK_GRN {0,255,0}
#define BK_CYA {0,255,255}
#define BK_YEL {255,255,0}
#define BK_WHT {255,255,255}
static xColor bk_pal[0x40] = {
BK_BLK,BK_BLU,BK_GRN,BK_RED, // 0: standard
BK_BLK,BK_YEL,BK_MAG,BK_RED,
BK_BLK,BK_CYA,BK_BLU,BK_MAG,
BK_BLK,BK_GRN,BK_CYA,BK_YEL,
BK_BLK,BK_MAG,BK_CYA,BK_WHT,
BK_BLK,BK_WHT,BK_WHT,BK_WHT, // 5: for b/w mode
BK_BLK,BK_RED,BK_RED,BK_RED,
BK_BLK,BK_GRN,BK_GRN,BK_GRN,
BK_BLK,BK_MAG,BK_MAG,BK_MAG,
BK_BLK,BK_GRN,BK_MAG,BK_RED,
BK_BLK,BK_GRN,BK_MAG,BK_RED,
BK_BLK,BK_CYA,BK_YEL,BK_RED,
BK_BLK,BK_RED,BK_GRN,BK_CYA,
BK_BLK,BK_CYA,BK_YEL,BK_WHT,
BK_BLK,BK_YEL,BK_GRN,BK_WHT,
BK_BLK,BK_CYA,BK_GRN,BK_WHT
};
void bk_reset(Computer* comp) {
memSetSize(comp->mem, MEM_32K, MEM_32K);
// memset(comp->mem->ramData, 0x00, MEM_256);
for (int i = 0; i < 0x40; i++) {
comp->vid->pal[i] = bk_pal[i];
}
comp->reg[0] = 1;
comp->reg[1] = 0x80;
comp->cpu->reset(comp->cpu);
comp->vid->curscr = 0;
comp->vid->paln = 0;
vidSetMode(comp->vid, VID_BK_BW);
comp->keyb->flag = 0x00;
comp->keyb->keycode = 0;
bk_mem_map(comp);
}
void bk_mwr(Computer* comp, int adr, int val) {
memWr(comp->mem, adr, val);
}
int bk_mrd(Computer* comp, int adr, int m1) {
return memRd(comp->mem, adr);
}
// only for sending control signals (like INIT)
void bk_iowr(Computer* comp, int adr, int val, int dos) {
switch (val) {
case PDP11_INIT:
comp->keyb->flag = 0;
break;
}
}
sndPair bk_vol(Computer* comp, sndVolume* sv) {
sndPair vol;
int lev = comp->beep->val * sv->beep / 6;
if (comp->tape->rec) {
lev += comp->tape->levRec ? 0x1000 * sv->tape / 100 : 0;
} else {
lev += (comp->tape->volPlay << 8) * sv->tape / 1600;
}
vol.left = lev;
vol.right = lev;
return vol;
}
void bk_init(Computer* comp) {
// int perNoTurbo = 1e3 / comp->cpuFrq; // ns for full cpu tick
vidUpdateTimings(comp->vid, 302);
}
// keys
typedef struct {
int xkey;
unsigned char code;
} bkKeyCode;
static bkKeyCode bkey_big_lat[] = {
{XKEY_Q,'Q'},{XKEY_W,'W'},{XKEY_E,'E'},{XKEY_R,'R'},{XKEY_T,'T'},
{XKEY_Y,'Y'},{XKEY_U,'U'},{XKEY_I,'I'},{XKEY_O,'O'},{XKEY_P,'P'},
{XKEY_A,'A'},{XKEY_S,'S'},{XKEY_D,'D'},{XKEY_F,'F'},{XKEY_G,'G'},
{XKEY_H,'H'},{XKEY_J,'J'},{XKEY_K,'K'},{XKEY_L,'L'},
{XKEY_Z,'Z'},{XKEY_X,'X'},{XKEY_C,'C'},{XKEY_V,'V'},{XKEY_B,'B'},
{XKEY_N,'N'},{XKEY_M,'M'},
{ENDKEY, 0}
};
static bkKeyCode bkey_small_lat[] = {
{XKEY_Q,'q'},{XKEY_W,'w'},{XKEY_E,'e'},{XKEY_R,'r'},{XKEY_T,'t'},
{XKEY_Y,'y'},{XKEY_U,'u'},{XKEY_I,'i'},{XKEY_O,'o'},{XKEY_P,'p'},
{XKEY_A,'a'},{XKEY_S,'s'},{XKEY_D,'d'},{XKEY_F,'f'},{XKEY_G,'g'},
{XKEY_H,'h'},{XKEY_J,'j'},{XKEY_K,'k'},{XKEY_L,'l'},
{XKEY_Z,'z'},{XKEY_X,'x'},{XKEY_C,'c'},{XKEY_V,'v'},{XKEY_B,'b'},
{XKEY_N,'n'},{XKEY_M,'m'},
{ENDKEY, 0}
};
static bkKeyCode bkey_big_rus[] = {
{XKEY_Q,0152},{XKEY_W,0143},{XKEY_E,0165},{XKEY_R,0153},{XKEY_T,0145},
{XKEY_Y,0156},{XKEY_U,0147},{XKEY_I,0173},{XKEY_O,0175},{XKEY_P,0172},
{XKEY_LBRACK,0150},{XKEY_RBRACK,0177}, /*{XKEY_LBRACE,0150},{XKEY_RBRACE,0177},*/
{XKEY_A,0146},{XKEY_S,0171},{XKEY_D,0167},{XKEY_F,0141},{XKEY_G,0160},
{XKEY_H,0162},{XKEY_J,0157},{XKEY_K,0154},{XKEY_L,0144},{XKEY_DOTCOM,0166},{XKEY_APOS,0174},
{XKEY_Z,0161},{XKEY_X,0176},{XKEY_C,0163},{XKEY_V,0155},{XKEY_B,0111},
{XKEY_N,0164},{XKEY_M,0170},{XKEY_COMMA,0142},{XKEY_PERIOD,0140},
{ENDKEY, 0}
};
static bkKeyCode bkey_small_rus[] = {
{XKEY_Q,0112},{XKEY_W,0103},{XKEY_E,0125},{XKEY_R,0113},{XKEY_T,0105},
{XKEY_Y,0116},{XKEY_U,0107},{XKEY_I,0133},{XKEY_O,0135},{XKEY_P,0132},
{XKEY_LBRACK,0110},{XKEY_RBRACK,0137}, /*{XKEY_LBRACE,0110},{XKEY_RBRACE,0137},*/
{XKEY_A,0106},{XKEY_S,0131},{XKEY_D,0127},{XKEY_F,0101},{XKEY_G,0120},
{XKEY_H,0122},{XKEY_J,0117},{XKEY_K,0114},{XKEY_L,0104},{XKEY_DOTCOM,0126},{XKEY_APOS,0134},
{XKEY_Z,0121},{XKEY_X,0136},{XKEY_C,0123},{XKEY_V,0115},{XKEY_B,0111},
{XKEY_N,0124},{XKEY_M,0130},{XKEY_COMMA,0102},{XKEY_PERIOD,0100},
{ENDKEY, 0}
};
static bkKeyCode bkeyTab[] = {
{XKEY_1,'1'},{XKEY_2,'2'},{XKEY_3,'3'},{XKEY_4,'4'},{XKEY_5,'5'},
{XKEY_6,'6'},{XKEY_7,'7'},{XKEY_8,'8'},{XKEY_9,'9'},{XKEY_0,'0'},
{XKEY_MINUS,'-'},{XKEY_EQUAL,'+'},
{XKEY_LBRACK,'('},{XKEY_RBRACK,')'},
{XKEY_DOTCOM, ';'},{XKEY_APOS,'"'},
{XKEY_COMMA, ','},{XKEY_PERIOD, '.'},{XKEY_BSLASH,'/'},
{XKEY_SPACE,' '},{XKEY_ENTER,10},
{XKEY_BSP,24},
{XKEY_TAB,13},
{XKEY_DOWN,27},{XKEY_LEFT,8},{XKEY_RIGHT,25},{XKEY_UP,26},
// {XKEY_ESC,3},
{ENDKEY, 0}
};
int bkey_code(bkKeyCode* tab, int xkey) {
int idx = 0;
while ((tab[idx].xkey != ENDKEY) && (tab[idx].xkey != xkey))
idx++;
return tab[idx].code; // 0 if ENDKEY
}
static char bkcapson[] = " caps on ";
static char bkcapsoff[] = " caps off ";
static char bkkbdrus[] = " rus ";
static char bkkbdlat[] = " lat ";
static char bkvidcol[] = " color mode ";
static char bkvidbw[] = " b/w mode ";
void bk_keyp(Computer* comp, keyEntry xkey) {
int code = 0;
switch(xkey.key) {
case XKEY_PGDN:
switch(comp->vid->vmode) {
case VID_BK_BW:
comp->msg = bkvidcol;
vidSetMode(comp->vid, VID_BK_COL);
break;
case VID_BK_COL:
comp->msg = bkvidbw;
vidSetMode(comp->vid, VID_BK_BW);
break;
}
break;
case XKEY_LSHIFT: comp->keyb->shift = 1; break;
case XKEY_CAPS:
comp->keyb->caps ^= 1;
code = comp->keyb->caps ? 0274 : 0273;
comp->msg = comp->keyb->caps ? bkcapson : bkcapsoff;
break;
case XKEY_LCTRL:
comp->keyb->lang ^= 1;
code = comp->keyb->lang ? 016 : 017;
comp->msg = comp->keyb->lang ? bkkbdrus : bkkbdlat;
break;
}
if (code == 0) {
if (comp->keyb->caps ^ comp->keyb->shift) {
code = bkey_code(comp->keyb->lang ? bkey_big_rus : bkey_big_lat, xkey.key);
} else {
code = bkey_code(comp->keyb->lang ? bkey_small_rus : bkey_small_lat, xkey.key);
}
}
if (code == 0)
code = bkey_code(bkeyTab, xkey.key);
if (code != 0) {
comp->keyb->flag |= 0x20;
if (!(comp->keyb->flag & 0x80)) {
comp->keyb->keycode = code & 0x7f;
comp->keyb->flag |= 0x80;
if (!(comp->keyb->flag & 0x40)) { // keyboard interrupt enabled
comp->cpu->intvec = (code & 0x80) ? 0274 : 060;
comp->cpu->intrq |= PDP_INT_VIRQ;
// printf("intrq %X\n", comp->cpu->intvec);
}
}
}
}
void bk_keyr(Computer* comp, keyEntry xkey) {
switch (xkey.key) {
case XKEY_LSHIFT: comp->keyb->shift = 0; break;
}
comp->keyb->flag &= ~0x20; // 0x20 | 0x80
}
| 28.743191 | 123 | 0.615947 |
e959870e49a01dcc34c27337427f795dabb56dd3 | 2,826 | h | C | components/plugins/renderer/plugin_placeholder.h | Yannic/chromium | ab32e8aacb08c9fce0dc4bf09eec456ba46e3710 | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 76 | 2020-09-02T03:05:41.000Z | 2022-03-30T04:40:55.000Z | components/plugins/renderer/plugin_placeholder.h | blueboxd/chromium-legacy | 07223bc94bd97499909c9ed3c3f5769d718fe2e0 | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 45 | 2020-09-02T03:21:37.000Z | 2022-03-31T22:19:45.000Z | components/plugins/renderer/plugin_placeholder.h | Yannic/chromium | ab32e8aacb08c9fce0dc4bf09eec456ba46e3710 | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 8 | 2020-07-22T18:49:18.000Z | 2022-02-08T10:27:16.000Z | // Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_PLUGINS_RENDERER_PLUGIN_PLACEHOLDER_H_
#define COMPONENTS_PLUGINS_RENDERER_PLUGIN_PLACEHOLDER_H_
#include "base/macros.h"
#include "base/memory/weak_ptr.h"
#include "components/plugins/renderer/webview_plugin.h"
#include "content/public/renderer/render_frame_observer.h"
#include "gin/handle.h"
#include "gin/wrappable.h"
#include "third_party/blink/public/web/blink.h"
#include "third_party/blink/public/web/web_plugin_params.h"
namespace plugins {
// This abstract class is the base class of all plugin placeholders.
class PluginPlaceholderBase : public content::RenderFrameObserver,
public WebViewPlugin::Delegate {
public:
// |render_frame| is a weak pointer. If it is going away, our |plugin_| will
// be destroyed as well and will notify us.
PluginPlaceholderBase(content::RenderFrame* render_frame,
const blink::WebPluginParams& params,
const std::string& html_data);
PluginPlaceholderBase(const PluginPlaceholderBase&) = delete;
PluginPlaceholderBase& operator=(const PluginPlaceholderBase&) = delete;
~PluginPlaceholderBase() override;
WebViewPlugin* plugin() { return plugin_; }
protected:
const blink::WebPluginParams& GetPluginParams() const;
// WebViewPlugin::Delegate methods:
void ShowContextMenu(const blink::WebMouseEvent&) override;
void PluginDestroyed() override;
v8::Local<v8::Object> GetV8ScriptableObject(
v8::Isolate* isolate) const override;
bool IsErrorPlaceholder() override;
// Hide this placeholder.
void HidePlugin();
bool hidden() const { return hidden_; }
// JavaScript callbacks:
void HideCallback();
void NotifyPlaceholderReadyForTestingCallback();
private:
// RenderFrameObserver methods:
void OnDestruct() override;
blink::WebPluginParams plugin_params_;
WebViewPlugin* plugin_;
bool hidden_;
};
// A basic placeholder that supports only hiding.
class PluginPlaceholder final : public PluginPlaceholderBase,
public gin::Wrappable<PluginPlaceholder> {
public:
static gin::WrapperInfo kWrapperInfo;
PluginPlaceholder(content::RenderFrame* render_frame,
const blink::WebPluginParams& params,
const std::string& html_data);
~PluginPlaceholder() override;
private:
// WebViewPlugin::Delegate methods:
v8::Local<v8::Value> GetV8Handle(v8::Isolate* isolate) final;
// gin::Wrappable method:
gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
v8::Isolate* isolate) override;
};
} // namespace plugins
#endif // COMPONENTS_PLUGINS_RENDERER_PLUGIN_PLACEHOLDER_H_
| 32.482759 | 78 | 0.734607 |
e969ed40789f80f7c86ffdae500a0bb516b0be1e | 4,850 | h | C | SharedQueue.h | concurrentes/tp1 | 12a73be9bb95b19e361b5421e7a28271aec68787 | [
"MIT"
] | null | null | null | SharedQueue.h | concurrentes/tp1 | 12a73be9bb95b19e361b5421e7a28271aec68787 | [
"MIT"
] | 18 | 2018-09-29T01:51:21.000Z | 2018-10-11T13:13:45.000Z | SharedQueue.h | concurrentes/tp1 | 12a73be9bb95b19e361b5421e7a28271aec68787 | [
"MIT"
] | null | null | null | #ifndef SHARED_QUEUE_H_
#define SHARED_QUEUE_H_
#include "SharedQueueTypes.h"
#include <sys/types.h>
#include <stdint.h>
namespace smstruct {
/*
* Nota: esta clase no implementa mecanismos de sincronización;
* en cambio, utilizar BlockingSharedQueue.
*/
class SharedQueue {
private:
/*
* Distancia en bytes desde el inicio del segmento de memoria compartida
* hasta el inicio de la sección de datos de la cola.
*/
const static uint32_t DATA_OFFSET;
/*
* Identificador del segmento de memoria compartida.
*/
int shmid;
/*
* Puntero al inicio del segmento de memoria compartida.
*/
uint8_t *ptr_segment;
/*
* Reserva o se adosa al segmento de memoria compartida, y en caso de
* tener que crear el segmento, también inicializa la estructura de datos.
*/
void initialize(key_t key, size_t segment_size);
/*
* Crea el segmento de memoria compartida e inicializa los datos
* administrativos en la base de la estructura.
*/
int create_segment(key_t key, size_t segment_size);
/*
* Se adosa al segmento de memoria compartida. Se asume que el atributo
* shmid ya ha sido inicializado. Devuelve el puntero al segmento.
*/
uint8_t *attach();
/*
* Acola un nuevo elemento, con datos de tamaño size, con prioridad p,
* cuando la cola está vacía.
*/
int enqueue_on_empty(void *data, uint32_t size, uint16_t p);
/*
* Acola un nuevo elemento, con datos de tamaño size, con prioridad p,
* cuando la cola NO está vacía.
*/
int enqueue_on_non_empty(void *data, uint32_t size, uint16_t p);
/*
* Crea un nuevo nodo a partir de la dirección indicada. Se asume
* que la creación de la cabecera y la escritura de los datos a partir
* de prev->next no estará pisando datos críticos.
*/
void enqueue_after(node_header_t *prev, void *data, uint32_t size, uint16_t p);
/*
* Saca el siguiente elemento de la cola y actualiza los datos
* administrativos de la estructura; devuelve un puntero a un bloque
* en el heap local, donde los datos del nodo habrán sido copiados.
*/
void *pop_next(queue_header_t *queue_header);
void *pop_node(queue_header_t *queue_header, node_header_t *node);
/*
* Devuelve la prioridad del nodo más prioritario en la cola.
*/
uint16_t find_max_priority(queue_header_t *queue_header);
public:
/*
* Error: cuando se intenta realizar una inserción y el espacio total
* disponible en el segmento es efectivamente suficiente para almacenar
* los datos, pero por motivos de fragmentación no es posible
* realizar la inserción.
*/
const static int SMQ_ERROR_FRAGMENTATION_ISSUES;
/* Error: cuando se intenta acolar un nuevo elemento pero el espacio
* necesario no será suficiente para almacenarlo debido a que efectivamente
* no queda tal cantidad de espacio en el segmento.
*/
const static int SMQ_ERROR_NOT_ENOUGH_SPACE;
/* Error: cuando se intenta extraer un elemento de la cola, a pesar de
* que ésta está vacía.
*/
const static int SMQ_ERROR_EMPTY_QUEUE;
/*
* Error: no se pudo obtener un segmento de memoria compartida adecuado.
*/
const static int SMQ_ERROR_COULD_NOT_GET_SHM;
/*
* Tamaño por defecto para el segmento de memoria compartida que contendrá
* datos de usuario y datos administrativos de la cola compartida.
*/
const static uint32_t DEFAULT_SEGMENT_SIZE;
/*
* Constructores.
*
* El constructor más específico crea un segmento de memoria compartida
* del tamaño dado. El primer constructor utiliza el tamaño por defecto.
*/
SharedQueue(key_t key);
SharedQueue(key_t key, size_t segment_size);
/*
* Intenta agregar un nuevo elemento a la cola, almacenando en memoria
* compartida una cantidad data_size de bytes desde la dirección data.
*
* De no poder agregar el nodo por falta de espacio en el segmento de
* memoria compartida, la función devuelve -1.
*
*/
int enqueue(void *data, uint32_t data_size, uint16_t priority);
/*
* Toma el siguiente elemento de la cola y lo desacola.
*
* Los datos del elemento desacolado son copiados a un buffer en
* el heap del proceso que ejecuta la función; el puntero devuelto
* apunta a este buffer.
*
* De no haber elementos en la cola, la función devuelve NULL.
*
*/
void *next();
/*
* Retorna la cantidad de elementos en la cola.
*/
uint16_t count();
/*
* Destructor. Libera todos los recursos asociados a la estructura,
* solo si no hay otros procesos utilizándolos.
*/
~SharedQueue();
};
}
#endif
| 29.393939 | 84 | 0.67299 |
eb5c6c83d649d84a1e171df53ea567a3b366953c | 6,271 | h | C | printscan/faxsrv/print/faxmon/faxmon.h | npocmaka/Windows-Server-2003 | 5c6fe3db626b63a384230a1aa6b92ac416b0765f | [
"Unlicense"
] | 17 | 2020-11-13T13:42:52.000Z | 2021-09-16T09:13:13.000Z | printscan/faxsrv/print/faxmon/faxmon.h | sancho1952007/Windows-Server-2003 | 5c6fe3db626b63a384230a1aa6b92ac416b0765f | [
"Unlicense"
] | 2 | 2020-10-19T08:02:06.000Z | 2020-10-19T08:23:18.000Z | printscan/faxsrv/print/faxmon/faxmon.h | sancho1952007/Windows-Server-2003 | 5c6fe3db626b63a384230a1aa6b92ac416b0765f | [
"Unlicense"
] | 14 | 2020-11-14T09:43:20.000Z | 2021-08-28T08:59:57.000Z | /*++
Copyright (c) 1996 Microsoft Corporation
Module Name:
faxmon.h
Abstract:
Header file for fax print monitor
Environment:
Windows XP fax print monitor
Revision History:
02/22/96 -davidx-
Created it.
dd-mm-yy -author-
description
--*/
#ifndef _FAXMON_H_
#define _FAXMON_H_
#if defined(UNICODE) && !defined(_UNICODE)
#define _UNICODE
#endif
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <winspool.h>
#include <winsplp.h>
#include <tchar.h>
#include "faxutil.h"
#include <fxsapip.h>
#include "jobtag.h"
#include "resource.h"
#include "faxres.h"
#include "Dword2Str.h"
//
// Data structure for representing a fax monitor port
//
typedef struct _FAXPORT {
PVOID startSig; // signature
LPTSTR pName; // port name
HANDLE hFaxSvc; // fax service handle
DWORD jobId; // main job ID
DWORD nextJobId; // next job ID in the chain
HANDLE hFile; // handle to currently open file
LPTSTR pFilename; // pointer to currently open file name
LPTSTR pPrinterName; // currently connected printer name
HANDLE hPrinter; // open handle to currently connected printer
LPTSTR pParameters; // pointer to job parameter string
FAX_JOB_PARAM_EX JobParamsEx; // pointer to individual job parameters
//
FAX_COVERPAGE_INFO_EX CoverPageEx; // Cover page information
FAX_PERSONAL_PROFILE SenderProfile; // Sender information
PFAX_PERSONAL_PROFILE pRecipients; // Array of recipient information for this transmission
UINT nRecipientCount; // The number of recipients in this transmission
HANDLE hCoverPageFile;
LPTSTR pCoverPageFileName; // The name of the cover page file generated on the server by the fax monitor.
// This file contains the cover page template as transfered via the cover page
// print job.
BOOL bCoverPageJob; // TRUE if the current print job is the cover page job.
PVOID endSig; // signature
} FAXPORT, *PFAXPORT;
#define ValidFaxPort(pFaxPort) \
((pFaxPort) && (pFaxPort) == (pFaxPort)->startSig && (pFaxPort) == (pFaxPort)->endSig)
//
// Different error code when sending fax document
//
#define FAXERR_NONE 0
#define FAXERR_IGNORE 1
#define FAXERR_RESTART 2
#define FAXERR_SPECIAL 3
#define FAXERR_FATAL IDS_FAXERR_FATAL
#define FAXERR_RECOVERABLE IDS_FAXERR_RECOVERABLE
#define FAXERR_BAD_TIFF IDS_FAXERR_BAD_TIFF
#define FAXERR_BAD_DATA16 IDS_FAXERR_BAD_DATA16
//
// Memory allocation and deallocation macros
//
//
// undefine the memory allocation routines from FAXUTIL.H
//
#undef MemAlloc
#undef MemFree
#define MemAlloc(size) ((PVOID) LocalAlloc(LMEM_FIXED, (size)))
#define MemAllocZ(size) ((PVOID) LocalAlloc(LPTR, (size)))
#define MemFree(ptr) { if (ptr) LocalFree((HLOCAL) (ptr)); }
//
// Number of tags used for passing fax job parameters
//
#define NUM_JOBPARAM_TAGS 12
//
// Nul terminator for a character string
//
#define NUL 0
//
// Result of string comparison
//
#define EQUAL_STRING 0
#define IsEmptyString(p) ((p)[0] == NUL)
#define IsNulChar(c) ((c) == NUL)
#define SizeOfString(p) ((_tcslen(p) + 1) * sizeof(TCHAR))
//
// Maximum value for signed and unsigned integers
//
#ifndef MAX_LONG
#define MAX_LONG 0x7fffffff
#endif
#ifndef MAX_DWORD
#define MAX_DWORD 0xffffffff
#endif
#ifndef MAX_SHORT
#define MAX_SHORT 0x7fff
#endif
#ifndef MAX_WORD
#define MAX_WORD 0xffff
#endif
//
// Declaration of print monitor entry points
//
BOOL
FaxMonOpenPort(
LPTSTR pPortName,
PHANDLE pHandle
);
BOOL
FaxMonClosePort(
HANDLE hPort
);
BOOL
FaxMonStartDocPort(
HANDLE hPort,
LPTSTR pPrinterName,
DWORD JobId,
DWORD Level,
LPBYTE pDocInfo
);
BOOL
FaxMonEndDocPort(
HANDLE hPort
);
BOOL
FaxMonWritePort(
HANDLE hPort,
LPBYTE pBuffer,
DWORD cbBuf,
LPDWORD pcbWritten
);
BOOL
FaxMonReadPort(
HANDLE hPort,
LPBYTE pBuffer,
DWORD cbBuf,
LPDWORD pcbRead
);
BOOL
FaxMonEnumPorts(
LPTSTR pServerName,
DWORD Level,
LPBYTE pPorts,
DWORD cbBuf,
LPDWORD pcbNeeded,
LPDWORD pReturned
);
BOOL
FaxMonAddPort(
LPTSTR pServerName,
HWND hwnd,
LPTSTR pMonitorName
);
BOOL
FaxMonAddPortEx(
LPTSTR pServerName,
DWORD level,
LPBYTE pBuffer,
LPTSTR pMonitorName
);
BOOL
FaxMonDeletePort(
LPTSTR pServerName,
HWND hwnd,
LPTSTR pPortName
);
BOOL
FaxMonConfigurePort(
LPWSTR pServerName,
HWND hwnd,
LPWSTR pPortName
);
//
// Get the list of fax devices from the service
//
PFAX_PORT_INFO
MyFaxEnumPorts(
LPDWORD pcPorts,
BOOL useCache
);
//
// Wrapper function for fax service's FaxGetPort API
//
PFAX_PORT_INFO
MyFaxGetPort(
LPTSTR pPortName,
BOOL useCache
);
//
// Make a duplicate of the given character string
//
LPTSTR
DuplicateString(
LPCTSTR pSrcStr
);
//
// Wrapper function for spooler API GetJob
//
PVOID
MyGetJob(
HANDLE hPrinter,
DWORD level,
DWORD jobId
);
//
// Create a temporary file in the system spool directory for storing fax data
//
LPTSTR
CreateTempFaxFile(
LPCTSTR lpctstrPrefix
);
//
// Open a handle to the current fax job file associated with a port
//
BOOL
OpenTempFaxFile(
PFAXPORT pFaxPort,
BOOL doAppend
);
#endif // !_FAXMON_H_
| 20.833887 | 112 | 0.599107 |
6a50b2d3adc9512f4bece14ec1c2c9f68c068a83 | 9,295 | h | C | binary_icons/icon_s_13d.h | drodil/inkplate6 | f5daffdc6f010da2b3616c8923eb51c48809b253 | [
"MIT"
] | 4 | 2022-01-19T21:37:23.000Z | 2022-03-17T19:39:01.000Z | binary_icons/icon_s_13d.h | drodil/inkplate6 | f5daffdc6f010da2b3616c8923eb51c48809b253 | [
"MIT"
] | null | null | null | binary_icons/icon_s_13d.h | drodil/inkplate6 | f5daffdc6f010da2b3616c8923eb51c48809b253 | [
"MIT"
] | 2 | 2021-04-21T04:46:20.000Z | 2022-01-19T22:05:25.000Z | const uint8_t icon_s_13d[] PROGMEM = {
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x80,0x0,0x0,0x0,0x0,0xd,0xb0,0x0,0x0,0x0,0x0,0x27,0xe4,0x0,0x0,0x0,0x0,0x33,0xcc,0x0,0x0,0x0,0x1,0xb1,0x8d,0x80,0x0,0x0,0x0,0xf1,0x8f,0x0,0x0,0x0,0x0,0x79,0x9e,0x0,0x0,0x0,0x1,0xff,0xff,0x80,0x0,0x0,0x1,0x86,0x61,0x80,0x0,0x0,0x0,0x6,0x60,0x0,0x0,0x0,0x1,0xef,0x73,0x80,0x0,0x0,0x0,0xff,0xff,0x0,0x0,0x0,0x0,0x79,0x8e,0x0,0x0,0x0,0x1,0xf1,0x8f,0x80,0x0,0x0,0x0,0xb3,0xcd,0x0,0x0,0x0,0x0,0x37,0xec,0x0,0x0,0x0,0x0,0x7,0xf0,0x0,0x0,0x0,0x0,0x5,0xb0,0x0,0x0,0x0,0x0,0x1,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0
};
| 2,323.75 | 9,252 | 0.750726 |
75847f73f475fe8deaeb83b6c0bd3eaf31dc160e | 418 | h | C | harbaughsim16/HeadCoachDetailViewController.h | mohsinalimat/FootballCoach-iOS | f34080a8b10a72cdee22fc34cff77421d3570225 | [
"BSD-2-Clause"
] | 1 | 2019-07-22T04:43:02.000Z | 2019-07-22T04:43:02.000Z | harbaughsim16/HeadCoachDetailViewController.h | mohsinalimat/FootballCoach-iOS | f34080a8b10a72cdee22fc34cff77421d3570225 | [
"BSD-2-Clause"
] | null | null | null | harbaughsim16/HeadCoachDetailViewController.h | mohsinalimat/FootballCoach-iOS | f34080a8b10a72cdee22fc34cff77421d3570225 | [
"BSD-2-Clause"
] | null | null | null | //
// HeadCoachDetailViewController.h
// harbaughsim16
//
// Created by Akshay Easwaran on 12/29/18.
// Copyright © 2018 Akshay Easwaran. All rights reserved.
//
#import "FCTableViewController.h"
#import "HBPlayerDetailView.h"
@class HeadCoach;
NS_ASSUME_NONNULL_BEGIN
@interface HeadCoachDetailViewController : FCTableViewController
-(instancetype)initWithCoach:(HeadCoach*)coach;
@end
NS_ASSUME_NONNULL_END
| 19.904762 | 64 | 0.789474 |
d4f7dc1b70001ce9c4ec66eee0d15d440675a183 | 17,348 | c | C | kernel/src/arch/x86/object/iospace.c | Nexusoft/LLL-OS | 7b0ad5afb339e9bebc65142ee89bded5344cedbe | [
"BSD-2-Clause"
] | 4 | 2020-08-07T19:48:01.000Z | 2020-10-16T20:05:17.000Z | kernel/src/arch/x86/object/iospace.c | Nexusoft/LX-OS | 7b0ad5afb339e9bebc65142ee89bded5344cedbe | [
"BSD-2-Clause"
] | null | null | null | kernel/src/arch/x86/object/iospace.c | Nexusoft/LX-OS | 7b0ad5afb339e9bebc65142ee89bded5344cedbe | [
"BSD-2-Clause"
] | 2 | 2020-08-13T01:48:40.000Z | 2020-09-17T07:34:42.000Z | /*
* Copyright 2014, General Dynamics C4 Systems
*
* SPDX-License-Identifier: GPL-2.0-only
*/
#include <config.h>
#ifdef CONFIG_IOMMU
#include <api/syscall.h>
#include <machine/io.h>
#include <kernel/thread.h>
#include <arch/api/invocation.h>
#include <arch/object/iospace.h>
#include <arch/model/statedata.h>
#include <linker.h>
#include <plat/machine/intel-vtd.h>
typedef struct lookupVTDContextSlot_ret {
vtd_cte_t *cte;
word_t index;
} lookupVTDContextSlot_ret_t;
BOOT_CODE cap_t master_iospace_cap(void)
{
if (x86KSnumDrhu == 0) {
return cap_null_cap_new();
}
return
cap_io_space_cap_new(
0, /* capDomainID */
0 /* capPCIDevice */
);
}
static vtd_cte_t *lookup_vtd_context_slot(cap_t cap)
{
uint32_t vtd_root_index;
uint32_t vtd_context_index;
uint32_t pci_request_id;
vtd_rte_t *vtd_root_slot;
vtd_cte_t *vtd_context;
vtd_cte_t *vtd_context_slot;
switch (cap_get_capType(cap)) {
case cap_io_space_cap:
pci_request_id = cap_io_space_cap_get_capPCIDevice(cap);
break;
case cap_io_page_table_cap:
pci_request_id = cap_io_page_table_cap_get_capIOPTIOASID(cap);
break;
case cap_frame_cap:
pci_request_id = cap_frame_cap_get_capFMappedASID(cap);
break;
default:
fail("Invalid cap type");
}
vtd_root_index = get_pci_bus(pci_request_id);
vtd_root_slot = x86KSvtdRootTable + vtd_root_index;
vtd_context = (vtd_cte_t *)paddr_to_pptr(vtd_rte_ptr_get_ctp(vtd_root_slot));
vtd_context_index = (get_pci_dev(pci_request_id) << 3) | get_pci_fun(pci_request_id);
vtd_context_slot = &vtd_context[vtd_context_index];
return vtd_context_slot;
}
static lookupIOPTSlot_ret_t lookupIOPTSlot_resolve_levels(vtd_pte_t *iopt, word_t translation,
word_t levels_to_resolve, word_t levels_remaining)
{
lookupIOPTSlot_ret_t ret;
word_t iopt_index = 0;
vtd_pte_t *iopt_slot = 0;
vtd_pte_t *next_iopt_slot = 0;
if (iopt == 0) {
ret.ioptSlot = 0;
ret.level = levels_remaining;
ret.status = EXCEPTION_LOOKUP_FAULT;
return ret;
}
iopt_index = (translation >> (VTD_PT_INDEX_BITS * (x86KSnumIOPTLevels - 1 - (levels_to_resolve - levels_remaining)))) &
MASK(VTD_PT_INDEX_BITS);
iopt_slot = iopt + iopt_index;
if (!vtd_pte_ptr_get_write(iopt_slot) || levels_remaining == 0) {
ret.ioptSlot = iopt_slot;
ret.level = levels_remaining;
ret.status = EXCEPTION_NONE;
return ret;
}
next_iopt_slot = (vtd_pte_t *)paddr_to_pptr(vtd_pte_ptr_get_addr(iopt_slot));
return lookupIOPTSlot_resolve_levels(next_iopt_slot, translation, levels_to_resolve, levels_remaining - 1);
}
static inline lookupIOPTSlot_ret_t lookupIOPTSlot(vtd_pte_t *iopt, word_t io_address)
{
lookupIOPTSlot_ret_t ret;
if (iopt == 0) {
ret.ioptSlot = 0;
ret.level = 0;
ret.status = EXCEPTION_LOOKUP_FAULT;
return ret;
} else {
return lookupIOPTSlot_resolve_levels(iopt, io_address >> PAGE_BITS,
x86KSnumIOPTLevels - 1, x86KSnumIOPTLevels - 1);
}
}
void unmapVTDContextEntry(cap_t cap)
{
vtd_cte_t *cte = lookup_vtd_context_slot(cap);
assert(cte != 0);
*cte = vtd_cte_new(
0,
false,
0,
0,
0,
false
);
flushCacheRange(cte, VTD_CTE_SIZE_BITS);
invalidate_iotlb();
setThreadState(NODE_STATE(ksCurThread), ThreadState_Restart);
return;
}
static exception_t performX86IOPTInvocationUnmap(cap_t cap, cte_t *ctSlot)
{
deleteIOPageTable(cap);
cap = cap_io_page_table_cap_set_capIOPTIsMapped(cap, 0);
ctSlot->cap = cap;
return EXCEPTION_NONE;
}
static exception_t performX86IOPTInvocationMapContextRoot(cap_t cap, cte_t *ctSlot, vtd_cte_t vtd_cte,
vtd_cte_t *vtd_context_slot)
{
*vtd_context_slot = vtd_cte;
flushCacheRange(vtd_context_slot, VTD_CTE_SIZE_BITS);
ctSlot->cap = cap;
return EXCEPTION_NONE;
}
static exception_t performX86IOPTInvocationMapPT(cap_t cap, cte_t *ctSlot, vtd_pte_t iopte, vtd_pte_t *ioptSlot)
{
*ioptSlot = iopte;
flushCacheRange(ioptSlot, VTD_PTE_SIZE_BITS);
ctSlot->cap = cap;
return EXCEPTION_NONE;
}
exception_t decodeX86IOPTInvocation(
word_t invLabel,
word_t length,
cte_t *slot,
cap_t cap,
extra_caps_t excaps,
word_t *buffer
)
{
cap_t io_space;
paddr_t paddr;
uint32_t pci_request_id;
word_t io_address;
uint16_t domain_id;
vtd_cte_t *vtd_context_slot;
vtd_pte_t *vtd_pte;
if (invLabel == X86IOPageTableUnmap) {
setThreadState(NODE_STATE(ksCurThread), ThreadState_Restart);
return performX86IOPTInvocationUnmap(cap, slot);
}
if (invLabel != X86IOPageTableMap) {
userError("X86IOPageTable: Illegal operation.");
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
if (excaps.excaprefs[0] == NULL || length < 1) {
userError("X86IOPageTableMap: Truncated message.");
current_syscall_error.type = seL4_TruncatedMessage;
return EXCEPTION_SYSCALL_ERROR;
}
io_space = excaps.excaprefs[0]->cap;
io_address = getSyscallArg(0, buffer) & ~MASK(VTD_PT_INDEX_BITS + seL4_PageBits);
if (cap_io_page_table_cap_get_capIOPTIsMapped(cap)) {
userError("X86IOPageTableMap: IO page table is already mapped.");
current_syscall_error.type = seL4_InvalidCapability;
current_syscall_error.invalidCapNumber = 0;
return EXCEPTION_SYSCALL_ERROR;
}
if (cap_get_capType(io_space) != cap_io_space_cap) {
userError("X86IOPageTableMap: Invalid IO space capability.");
current_syscall_error.type = seL4_InvalidCapability;
current_syscall_error.invalidCapNumber = 0;
return EXCEPTION_SYSCALL_ERROR;
}
pci_request_id = cap_io_space_cap_get_capPCIDevice(io_space);
domain_id = cap_io_space_cap_get_capDomainID(io_space);
if (pci_request_id == asidInvalid) {
current_syscall_error.type = seL4_InvalidCapability;
current_syscall_error.invalidCapNumber = 0;
return EXCEPTION_SYSCALL_ERROR;
}
paddr = pptr_to_paddr(VTD_PTE_PTR(cap_io_page_table_cap_get_capIOPTBasePtr(cap)));
vtd_context_slot = lookup_vtd_context_slot(io_space);
if (!vtd_cte_ptr_get_present(vtd_context_slot)) {
/* 1st Level Page Table */
vtd_cte_t vtd_cte = vtd_cte_new(
domain_id, /* domain ID */
false, /* RMRR */
x86KSnumIOPTLevels - 2, /* addr width (x = levels - 2) */
paddr, /* address space root */
0, /* translation type */
true /* present */
);
cap = cap_io_page_table_cap_set_capIOPTIsMapped(cap, 1);
cap = cap_io_page_table_cap_set_capIOPTLevel(cap, 0);
cap = cap_io_page_table_cap_set_capIOPTIOASID(cap, pci_request_id);
setThreadState(NODE_STATE(ksCurThread), ThreadState_Restart);
return performX86IOPTInvocationMapContextRoot(cap, slot, vtd_cte, vtd_context_slot);
} else {
lookupIOPTSlot_ret_t lu_ret;
vtd_pte_t iopte;
vtd_pte = (vtd_pte_t *)paddr_to_pptr(vtd_cte_ptr_get_asr(vtd_context_slot));
lu_ret = lookupIOPTSlot(vtd_pte, io_address);
if (lu_ret.status != EXCEPTION_NONE) {
current_syscall_error.type = seL4_FailedLookup;
current_syscall_error.failedLookupWasSource = false;
return EXCEPTION_SYSCALL_ERROR;
}
lu_ret.level = x86KSnumIOPTLevels - lu_ret.level;
if (vtd_pte_ptr_get_addr(lu_ret.ioptSlot) != 0) {
current_syscall_error.type = seL4_DeleteFirst;
return EXCEPTION_SYSCALL_ERROR;
}
iopte = vtd_pte_new(
paddr, /* physical addr */
1, /* write permission flag */
1 /* read permission flag */
);
cap = cap_io_page_table_cap_set_capIOPTIsMapped(cap, 1);
cap = cap_io_page_table_cap_set_capIOPTLevel(cap, lu_ret.level);
cap = cap_io_page_table_cap_set_capIOPTIOASID(cap, pci_request_id);
cap = cap_io_page_table_cap_set_capIOPTMappedAddress(cap, io_address);
setThreadState(NODE_STATE(ksCurThread), ThreadState_Restart);
return performX86IOPTInvocationMapPT(cap, slot, iopte, lu_ret.ioptSlot);
}
}
static exception_t performX86IOInvocationMap(cap_t cap, cte_t *ctSlot, vtd_pte_t iopte, vtd_pte_t *ioptSlot)
{
ctSlot->cap = cap;
*ioptSlot = iopte;
flushCacheRange(ioptSlot, VTD_PTE_SIZE_BITS);
return EXCEPTION_NONE;
}
exception_t decodeX86IOMapInvocation(
word_t length,
cte_t *slot,
cap_t cap,
extra_caps_t excaps,
word_t *buffer
)
{
cap_t io_space;
word_t io_address;
uint32_t pci_request_id;
vtd_cte_t *vtd_context_slot;
vtd_pte_t *vtd_pte;
vtd_pte_t iopte;
paddr_t paddr;
lookupIOPTSlot_ret_t lu_ret;
vm_rights_t frame_cap_rights;
seL4_CapRights_t dma_cap_rights_mask;
if (excaps.excaprefs[0] == NULL || length < 2) {
userError("X86PageMapIO: Truncated message.");
current_syscall_error.type = seL4_TruncatedMessage;
return EXCEPTION_SYSCALL_ERROR;
}
if (cap_frame_cap_get_capFSize(cap) != X86_SmallPage) {
userError("X86PageMapIO: Invalid page size.");
current_syscall_error.type = seL4_InvalidCapability;
current_syscall_error.invalidCapNumber = 0;
return EXCEPTION_SYSCALL_ERROR;
}
if (cap_frame_cap_get_capFMappedASID(cap) != asidInvalid) {
userError("X86PageMapIO: Page already mapped.");
current_syscall_error.type = seL4_InvalidCapability;
current_syscall_error.invalidCapNumber = 0;
return EXCEPTION_SYSCALL_ERROR;
}
io_space = excaps.excaprefs[0]->cap;
io_address = getSyscallArg(1, buffer) & ~MASK(PAGE_BITS);
paddr = pptr_to_paddr((void *)cap_frame_cap_get_capFBasePtr(cap));
if (cap_get_capType(io_space) != cap_io_space_cap) {
userError("X86PageMapIO: Invalid IO space capability.");
current_syscall_error.type = seL4_InvalidCapability;
current_syscall_error.invalidCapNumber = 0;
return EXCEPTION_SYSCALL_ERROR;
}
pci_request_id = cap_io_space_cap_get_capPCIDevice(io_space);
if (pci_request_id == asidInvalid) {
userError("X86PageMapIO: Invalid PCI device.");
current_syscall_error.type = seL4_InvalidCapability;
current_syscall_error.invalidCapNumber = 0;
return EXCEPTION_SYSCALL_ERROR;
}
vtd_context_slot = lookup_vtd_context_slot(io_space);
if (!vtd_cte_ptr_get_present(vtd_context_slot)) {
/* 1st Level Page Table is not installed */
current_syscall_error.type = seL4_FailedLookup;
current_syscall_error.failedLookupWasSource = false;
return EXCEPTION_SYSCALL_ERROR;
}
vtd_pte = (vtd_pte_t *)paddr_to_pptr(vtd_cte_ptr_get_asr(vtd_context_slot));
lu_ret = lookupIOPTSlot(vtd_pte, io_address);
if (lu_ret.status != EXCEPTION_NONE || lu_ret.level != 0) {
current_syscall_error.type = seL4_FailedLookup;
current_syscall_error.failedLookupWasSource = false;
return EXCEPTION_SYSCALL_ERROR;
}
if (vtd_pte_ptr_get_addr(lu_ret.ioptSlot) != 0) {
current_syscall_error.type = seL4_DeleteFirst;
return EXCEPTION_SYSCALL_ERROR;
}
dma_cap_rights_mask = rightsFromWord(getSyscallArg(0, buffer));
frame_cap_rights = cap_frame_cap_get_capFVMRights(cap);
bool_t write = seL4_CapRights_get_capAllowWrite(dma_cap_rights_mask) && (frame_cap_rights == VMReadWrite);
bool_t read = seL4_CapRights_get_capAllowRead(dma_cap_rights_mask) && (frame_cap_rights != VMKernelOnly);
if (write || read) {
iopte = vtd_pte_new(paddr, !!write, !!read);
} else {
current_syscall_error.type = seL4_InvalidArgument;
current_syscall_error.invalidArgumentNumber = 0;
return EXCEPTION_SYSCALL_ERROR;
}
cap = cap_frame_cap_set_capFMapType(cap, X86_MappingIOSpace);
cap = cap_frame_cap_set_capFMappedASID(cap, pci_request_id);
cap = cap_frame_cap_set_capFMappedAddress(cap, io_address);
setThreadState(NODE_STATE(ksCurThread), ThreadState_Restart);
return performX86IOInvocationMap(cap, slot, iopte, lu_ret.ioptSlot);
}
void deleteIOPageTable(cap_t io_pt_cap)
{
lookupIOPTSlot_ret_t lu_ret;
uint32_t level;
word_t io_address;
vtd_cte_t *vtd_context_slot;
vtd_pte_t *vtd_pte;
if (cap_io_page_table_cap_get_capIOPTIsMapped(io_pt_cap)) {
io_pt_cap = cap_io_page_table_cap_set_capIOPTIsMapped(io_pt_cap, 0);
level = cap_io_page_table_cap_get_capIOPTLevel(io_pt_cap);
vtd_context_slot = lookup_vtd_context_slot(io_pt_cap);
if (!vtd_cte_ptr_get_present(vtd_context_slot)) {
return;
}
vtd_pte = (vtd_pte_t *)paddr_to_pptr(vtd_cte_ptr_get_asr(vtd_context_slot));
if (level == 0) {
/* if we have been overmapped or something */
if (pptr_to_paddr(vtd_pte) != pptr_to_paddr((void *)cap_io_page_table_cap_get_capIOPTBasePtr(io_pt_cap))) {
return;
}
*vtd_context_slot = vtd_cte_new(
0, /* Domain ID */
false, /* RMRR */
0, /* Address Width */
0, /* Address Space Root */
0, /* Translation Type */
0 /* Present */
);
flushCacheRange(vtd_context_slot, VTD_CTE_SIZE_BITS);
} else {
io_address = cap_io_page_table_cap_get_capIOPTMappedAddress(io_pt_cap);
lu_ret = lookupIOPTSlot_resolve_levels(vtd_pte, io_address >> PAGE_BITS, level - 1, level - 1);
/* if we have been overmapped or something */
if (lu_ret.status != EXCEPTION_NONE || lu_ret.level != 0) {
return;
}
if (vtd_pte_ptr_get_addr(lu_ret.ioptSlot) != pptr_to_paddr((void *)cap_io_page_table_cap_get_capIOPTBasePtr(
io_pt_cap))) {
return;
}
*lu_ret.ioptSlot = vtd_pte_new(
0, /* Physical Address */
0, /* Read Permission */
0 /* Write Permission */
);
flushCacheRange(lu_ret.ioptSlot, VTD_PTE_SIZE_BITS);
}
invalidate_iotlb();
}
}
void unmapIOPage(cap_t cap)
{
lookupIOPTSlot_ret_t lu_ret;
word_t io_address;
vtd_cte_t *vtd_context_slot;
vtd_pte_t *vtd_pte;
io_address = cap_frame_cap_get_capFMappedAddress(cap);
vtd_context_slot = lookup_vtd_context_slot(cap);
if (!vtd_cte_ptr_get_present(vtd_context_slot)) {
return;
}
vtd_pte = (vtd_pte_t *)paddr_to_pptr(vtd_cte_ptr_get_asr(vtd_context_slot));
lu_ret = lookupIOPTSlot(vtd_pte, io_address);
if (lu_ret.status != EXCEPTION_NONE || lu_ret.level != 0) {
return;
}
if (vtd_pte_ptr_get_addr(lu_ret.ioptSlot) != pptr_to_paddr((void *)cap_frame_cap_get_capFBasePtr(cap))) {
return;
}
*lu_ret.ioptSlot = vtd_pte_new(
0, /* Physical Address */
0, /* Read Permission */
0 /* Write Permission */
);
flushCacheRange(lu_ret.ioptSlot, VTD_PTE_SIZE_BITS);
invalidate_iotlb();
}
exception_t performX86IOUnMapInvocation(cap_t cap, cte_t *ctSlot)
{
unmapIOPage(ctSlot->cap);
ctSlot->cap = cap_frame_cap_set_capFMappedAddress(ctSlot->cap, 0);
ctSlot->cap = cap_frame_cap_set_capFMapType(ctSlot->cap, X86_MappingNone);
ctSlot->cap = cap_frame_cap_set_capFMappedASID(ctSlot->cap, asidInvalid);
return EXCEPTION_NONE;
}
exception_t decodeX86IOSpaceInvocation(word_t invLabel, cap_t cap)
{
userError("IOSpace capability has no invocations");
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
#endif /* CONFIG_IOMMU */
| 34.015686 | 124 | 0.633214 |
0763a95f9d98de56c253f8e0e4cc0010dc9546d5 | 923 | h | C | c/nametable.h | kwaters/blang | 09309914067ed37ca7d7e48b1cfc1872197ebd37 | [
"MIT"
] | 5 | 2016-10-05T04:11:19.000Z | 2021-01-02T04:09:05.000Z | c/nametable.h | kwaters/blang | 09309914067ed37ca7d7e48b1cfc1872197ebd37 | [
"MIT"
] | null | null | null | c/nametable.h | kwaters/blang | 09309914067ed37ca7d7e48b1cfc1872197ebd37 | [
"MIT"
] | 1 | 2016-10-05T04:12:04.000Z | 2016-10-05T04:12:04.000Z | #pragma once
#include "base.h"
#include "ast.h"
struct NameTableEntry
{
Name name;
I flags;
I slot; /* argument or auto slot */
};
struct NameTableIter;
enum {
NT_NEW = 0,
NT_ARG = 1,
NT_AUTO = 2,
NT_INTERNAL = 3,
NT_EXTRN = 4,
NT_KIND_MASK = 7,
NT_DEF_FLAG = 1 << 4
};
/* Remove all nametable entries */
void nt_reset();
/* Add and define entry in the nametable. */
void nt_add_arg(Name name);
void nt_add_extrn(Name name);
void nt_add_auto(Name name);
void nt_add_internal(Name name);
/* Lookup a name, if it's not in the table it's an undefined internal. */
struct NameTableEntry *nt_lookup(Name name);
/* Check that all names are defined. */
void nt_check_defined();
/* Iterate through all names in the nametable. */
struct NameTableIter *nt_iter_get(void);
void nt_iter_release(struct NameTableIter *it);
struct NameTableEntry *nt_next(struct NameTableIter *it);
| 20.065217 | 73 | 0.692308 |
7702be6b95b0c9b0c6dc24fa2b6f4b579e344014 | 2,461 | h | C | src/Lethe/Core/Ptr/RefCounted.h | killvxk/lethe | c1a9bb45063f5148dc6cf681ce907dcbb468f5e6 | [
"BSL-1.0"
] | null | null | null | src/Lethe/Core/Ptr/RefCounted.h | killvxk/lethe | c1a9bb45063f5148dc6cf681ce907dcbb468f5e6 | [
"BSL-1.0"
] | null | null | null | src/Lethe/Core/Ptr/RefCounted.h | killvxk/lethe | c1a9bb45063f5148dc6cf681ce907dcbb468f5e6 | [
"BSL-1.0"
] | 1 | 2020-03-16T21:27:50.000Z | 2020-03-16T21:27:50.000Z | #pragma once
#include "../Thread/Atomic.h"
#include "../Sys/Assert.h"
#include "../Sys/Inline.h"
#include "../Sys/Limits.h"
#include "CustomDeleter.h"
namespace lethe
{
// used for intrusive reference counting
// base class for all reference counted objects
// note: this forces the class to be virtual!
// copy handling: none; we don't want to copy refcount!
// FIXME: seems racy after WeakPtr support
class LETHE_VISIBLE LETHE_API RefCounted
{
typedef AtomicUInt AtomicType;
typedef UInt NonAtomicType;
mutable AtomicType strongRefCount;
mutable AtomicType weakRefCount;
public:
inline RefCounted() : strongRefCount(0), weakRefCount(1) {}
inline RefCounted(const RefCounted &) : strongRefCount(0), weakRefCount(1) {}
virtual inline ~RefCounted()
{
// FIXME: we can't test weakRefCount to 0
LETHE_ASSERT(!strongRefCount && weakRefCount <= 1);
}
inline RefCounted &operator =(const RefCounted &)
{
return *this;
}
inline UInt AddRef() const
{
UInt res = Atomic::Increment(strongRefCount);
LETHE_ASSERT(res);
return res;
}
// decrement strong ref count but don't release
// use at your own risk!
inline UInt DecRefCount() const
{
return Atomic::Decrement(strongRefCount);
}
inline UInt Release() const
{
UInt res = DecRefCount();
LETHE_ASSERT(res != (NonAtomicType)(((UInt)0-1) & Limits<NonAtomicType>::Max()));
if (LETHE_UNLIKELY(!res))
ReleaseAfterStrongZero();
return res;
}
inline UInt AddWeakRef() const
{
LETHE_ASSERT(strongRefCount != 0);
UInt res = Atomic::Increment(weakRefCount);
LETHE_ASSERT(res);
return res;
}
inline UInt ReleaseWeak() const
{
UInt res = Atomic::Decrement(weakRefCount);
LETHE_ASSERT(res != (NonAtomicType)(((UInt)0-1) & Limits<NonAtomicType>::Max()));
if (LETHE_UNLIKELY(!res && Atomic::CompareAndSwap(strongRefCount, (NonAtomicType)0, (NonAtomicType)0)))
CustomDeleteObjectSkeleton();
return res;
}
inline bool HasStrongRef() const
{
return Atomic::Load(strongRefCount) != 0;
}
// note: Finalize callback NOT called when object is on stack => only called for dynamically allocated objects!
inline virtual void Finalize() const {}
protected:
void ResetRefCounters()
{
strongRefCount = weakRefCount = 0;
}
using CustomDeleterFunc = void(*)(const void *);
virtual CustomDeleterFunc GetCustomDeleter() const;
void LETHE_NOINLINE CustomDeleteObjectSkeleton() const;
void LETHE_NOINLINE ReleaseAfterStrongZero() const;
};
}
| 23 | 112 | 0.723283 |
7729369ea333d56486b7801039fb1ac4f48e05de | 1,327 | c | C | djysdk/djysrc/component/djyfs/yaffs2/yaffs2-583dbd9/yaffs2-583dbd9/direct/test-framework/timothy_tests/quick_tests/test_yaffs_open_EINVAL.c | qjclinux/djyos | 5d5368604681d8a7d77c15558b84343fa857a507 | [
"BSD-2-Clause"
] | 43 | 2015-05-04T09:50:48.000Z | 2021-09-27T09:33:37.000Z | djysdk/djysrc/component/djyfs/yaffs2/yaffs2-583dbd9/yaffs2-583dbd9/direct/test-framework/timothy_tests/quick_tests/test_yaffs_open_EINVAL.c | qjclinux/djyos | 5d5368604681d8a7d77c15558b84343fa857a507 | [
"BSD-2-Clause"
] | null | null | null | djysdk/djysrc/component/djyfs/yaffs2/yaffs2-583dbd9/yaffs2-583dbd9/direct/test-framework/timothy_tests/quick_tests/test_yaffs_open_EINVAL.c | qjclinux/djyos | 5d5368604681d8a7d77c15558b84343fa857a507 | [
"BSD-2-Clause"
] | 21 | 2015-09-30T03:35:05.000Z | 2021-07-31T01:53:14.000Z | /*
* YAFFS: Yet another FFS. A NAND-flash specific file system.
*
* Copyright (C) 2002-2011 Aleph One Ltd.
* for Toby Churchill Ltd and Brightstar Engineering
*
* Created by Timothy Manning <timothy@yaffs.net>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*/
#include "test_yaffs_open_EINVAL.h"
static int handle = -1;
int test_yaffs_open_EINVAL(void)
{
int error_code = 0;
handle = yaffs_open(FILE_PATH, O_CREAT | O_RDWR, FILE_MODE);
handle=yaffs_open(FILE_PATH, 255,FILE_MODE);
if (handle == -1){
error_code = yaffs_get_error();
if (abs(error_code) == EEXIST){ /* yaffs open does not check the mode which is passed into the functon.
so yaffs open does not return EINVAL.
This causes the error EEXIST to happen instead
because both O_CREAT and O_EXCL are set */
return 1;
} else {
print_message("different error than expected\n",2);
return -1;
}
} else {
print_message(" file opened with bad mode.(which is a bad thing)\n",2);
return -1;
}
}
int test_yaffs_open_EINVAL_clean(void)
{
if (handle >= 0){
return yaffs_close(handle);
} else {
return 1; /* the file failed to open so there is no need to close it*/
}
}
| 26.54 | 106 | 0.700075 |
727c9017e5f72e34e4ad77d13e9cfab4e5c0126b | 472 | h | C | runtime/alloc/Finalizer.h | etaoins/llambda | a2a5c212ebb56701fa28649c377d0ddd8b67da0b | [
"Apache-2.0"
] | 68 | 2015-01-17T10:42:00.000Z | 2021-11-18T02:48:01.000Z | runtime/alloc/Finalizer.h | etaoins/llambda | a2a5c212ebb56701fa28649c377d0ddd8b67da0b | [
"Apache-2.0"
] | 15 | 2015-01-05T07:59:33.000Z | 2018-01-05T02:58:10.000Z | runtime/alloc/Finalizer.h | etaoins/llambda | a2a5c212ebb56701fa28649c377d0ddd8b67da0b | [
"Apache-2.0"
] | 7 | 2015-04-22T06:21:47.000Z | 2021-08-23T07:15:13.000Z | #ifndef _LLIBY_ALLOC_FINALIZER_H
#define _LLIBY_ALLOC_FINALIZER_H
namespace lliby
{
namespace alloc
{
class Heap;
class MemoryBlock;
// Although this only contains static functions it needs to be a class so it can be a friend of Heap
class Finalizer
{
public:
static void finalizeHeapAsync(Heap &heap);
static void finalizeHeapSync(Heap &heap);
private:
static void finalizeSegment(MemoryBlock *rootSegment);
static void terminateHeap(Heap &heap);
};
}
}
#endif
| 16.857143 | 100 | 0.783898 |
8804c4810015b183a197196eb869e673dd5c61c2 | 456 | h | C | PCTutorialManager.h | bitwit/postcard-ios | c4a624fdfa02da477d502839e8c5f7cce44d5c19 | [
"MIT"
] | 10 | 2015-05-25T20:38:00.000Z | 2020-07-03T11:12:12.000Z | PCTutorialManager.h | bitwit/postcard-ios | c4a624fdfa02da477d502839e8c5f7cce44d5c19 | [
"MIT"
] | null | null | null | PCTutorialManager.h | bitwit/postcard-ios | c4a624fdfa02da477d502839e8c5f7cce44d5c19 | [
"MIT"
] | 4 | 2015-05-27T19:42:40.000Z | 2020-12-06T14:40:22.000Z | //
// Created by Kyle Newsome on 1/12/2014.
// Copyright (c) 2014 Kyle Newsome. All rights reserved.
//
#import <Foundation/Foundation.h>
@interface PCTutorialManager : NSObject
+ (BOOL)hasWatchedMainViewTutorial;
+ (BOOL)hasWatchedNetworkSetupTutorial;
+ (BOOL)hasWatchedNetworkSettingsTutorial;
+ (void)setMainViewTutorialAsWatched;
+ (void)setNetworkSetupTutorialAsWatched;
+ (void)setNetworkSettingsTutorialAsWatched;
+ (void)resetTutorial;
@end | 21.714286 | 56 | 0.789474 |
e60594d377aff1e26f15f887c43b4bfb246c3c9a | 519 | h | C | MVCHub/MVCHub/Models/News.h | QiuDaniel/MVCHub | b08ad1f7caae85d4ce98b4f2b93e5bc27b7627f5 | [
"MIT"
] | 2 | 2016-12-05T06:42:28.000Z | 2016-12-05T07:22:42.000Z | MVCHub/MVCHub/Models/News.h | QiuDaniel/MVCHub | b08ad1f7caae85d4ce98b4f2b93e5bc27b7627f5 | [
"MIT"
] | null | null | null | MVCHub/MVCHub/Models/News.h | QiuDaniel/MVCHub | b08ad1f7caae85d4ce98b4f2b93e5bc27b7627f5 | [
"MIT"
] | null | null | null | //
// News.h
// MVCHub
//
// Created by daniel on 2016/10/21.
// Copyright © 2016年 Daniel. All rights reserved.
//
#import <Foundation/Foundation.h>
typedef NS_ENUM(NSUInteger, NewsViewType) {
NewsViewTypeNews,
NewsViewTypePublicActivity
};
extern NSInteger const NewsPerPage;
@interface News : NSObject
@property (nonatomic, assign) NewsViewType type;
@property (nonatomic, copy) NSString *title;
@property (nonatomic, assign) NSInteger page;
- (instancetype)initWithType:(NewsViewType) type;
@end
| 18.535714 | 50 | 0.736031 |
6a20b2b3540d159765777aa8586ccdb9feb98c59 | 679 | h | C | sysvinit-2.86/src/reboot.h | spartan263/vizio_oss | 74270002d874391148119b48882db6816e7deedc | [
"Linux-OpenIB"
] | 4 | 2016-07-01T04:50:02.000Z | 2021-11-14T21:29:42.000Z | sysvinit-2.86/src/reboot.h | spartan263/vizio_oss | 74270002d874391148119b48882db6816e7deedc | [
"Linux-OpenIB"
] | null | null | null | sysvinit-2.86/src/reboot.h | spartan263/vizio_oss | 74270002d874391148119b48882db6816e7deedc | [
"Linux-OpenIB"
] | null | null | null | /*
* reboot.h Headerfile that defines how to handle
* the reboot() system call.
*
* Version: @(#)reboot.h 2.85-17 04-Jun-2004 miquels@cistron.nl
*
*/
#include <sys/reboot.h>
#ifdef RB_ENABLE_CAD
# define BMAGIC_HARD RB_ENABLE_CAD
#endif
#ifdef RB_DISABLE_CAD
# define BMAGIC_SOFT RB_DISABLE_CAD
#endif
#ifdef RB_HALT_SYSTEM
# define BMAGIC_HALT RB_HALT_SYSTEM
#else
# define BMAGIC_HALT RB_HALT
#endif
#define BMAGIC_REBOOT RB_AUTOBOOT
#ifdef RB_POWER_OFF
# define BMAGIC_POWEROFF RB_POWER_OFF
#elif defined(RB_POWEROFF)
# define BMAGIC_POWEROFF RB_POWEROFF
#else
# define BMAGIC_POWEROFF BMAGIC_HALT
#endif
#define init_reboot(magic) reboot(magic)
| 18.351351 | 66 | 0.762887 |
1692ba649f132361f924273b9b3505c878b70138 | 10,127 | c | C | ext/mvc/model/metadata/strategy/introspection.c | digitronac/cphalcon | 4f3b540e05ef822b577b051d18851f6bb276523e | [
"BSD-3-Clause"
] | null | null | null | ext/mvc/model/metadata/strategy/introspection.c | digitronac/cphalcon | 4f3b540e05ef822b577b051d18851f6bb276523e | [
"BSD-3-Clause"
] | null | null | null | ext/mvc/model/metadata/strategy/introspection.c | digitronac/cphalcon | 4f3b540e05ef822b577b051d18851f6bb276523e | [
"BSD-3-Clause"
] | null | null | null |
/*
+------------------------------------------------------------------------+
| Phalcon Framework |
+------------------------------------------------------------------------+
| Copyright (c) 2011-2014 Phalcon Team (http://www.phalconphp.com) |
+------------------------------------------------------------------------+
| This source file is subject to the New BSD License that is bundled |
| with this package in the file docs/LICENSE.txt. |
| |
| If you did not receive a copy of the license and are unable to |
| obtain it through the world-wide-web, please send an email |
| to license@phalconphp.com so we can send you a copy immediately. |
+------------------------------------------------------------------------+
| Authors: Andres Gutierrez <andres@phalconphp.com> |
| Eduar Carvajal <eduar@phalconphp.com> |
+------------------------------------------------------------------------+
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "php.h"
#include "php_phalcon.h"
#include "phalcon.h"
#include "Zend/zend_operators.h"
#include "Zend/zend_exceptions.h"
#include "Zend/zend_interfaces.h"
#include "kernel/main.h"
#include "kernel/memory.h"
#include "kernel/fcall.h"
#include "kernel/object.h"
#include "kernel/concat.h"
#include "kernel/exception.h"
#include "kernel/file.h"
#include "kernel/array.h"
#include "kernel/operators.h"
#include "kernel/hash.h"
/**
* Phalcon\Mvc\Model\MetaData\Strategy\Instrospection
*
* Queries the table meta-data in order to instrospect the model's metadata
*/
/**
* Phalcon\Mvc\Model\MetaData\Strategy\Introspection initializer
*/
PHALCON_INIT_CLASS(Phalcon_Mvc_Model_MetaData_Strategy_Introspection){
PHALCON_REGISTER_CLASS(Phalcon\\Mvc\\Model\\MetaData\\Strategy, Introspection, mvc_model_metadata_strategy_introspection, phalcon_mvc_model_metadata_strategy_introspection_method_entry, 0);
return SUCCESS;
}
/**
* The meta-data is obtained by reading the column descriptions from the database information schema
*
* @param Phalcon\Mvc\ModelInterface $model
* @param Phalcon\DiInterface $dependencyInjector
* @return array
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Strategy_Introspection, getMetaData){
zval *model, *dependency_injector, *class_name;
zval *schema, *table, *read_connection, *exists;
zval *complete_table = NULL, *exception_message = NULL;
zval *columns, *attributes, *primary_keys, *non_primary_keys;
zval *numeric_typed, *not_null, *field_types;
zval *field_bind_types, *automatic_default;
zval *identity_field = NULL, *column = NULL, *field_name = NULL, *feature = NULL;
zval *type = NULL, *bind_type = NULL, *model_metadata;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &model, &dependency_injector);
PHALCON_INIT_VAR(class_name);
phalcon_get_class(class_name, model, 0 TSRMLS_CC);
PHALCON_INIT_VAR(schema);
phalcon_call_method(schema, model, "getschema");
PHALCON_INIT_VAR(table);
phalcon_call_method(table, model, "getsource");
/**
* Check if the mapped table exists on the database
*/
PHALCON_INIT_VAR(read_connection);
phalcon_call_method(read_connection, model, "getreadconnection");
PHALCON_INIT_VAR(exists);
phalcon_call_method_p2(exists, read_connection, "tableexists", table, schema);
if (!zend_is_true(exists)) {
if (zend_is_true(schema)) {
PHALCON_INIT_VAR(complete_table);
PHALCON_CONCAT_VSV(complete_table, schema, "\".\"", table);
} else {
PHALCON_CPY_WRT(complete_table, table);
}
/**
* The table not exists
*/
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVSV(exception_message, "Table \"", complete_table, "\" doesn't exist on database when dumping meta-data for ", class_name);
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message);
return;
}
/**
* Try to describe the table
*/
PHALCON_INIT_VAR(columns);
phalcon_call_method_p2(columns, read_connection, "describecolumns", table, schema);
if (!phalcon_fast_count_ev(columns TSRMLS_CC)) {
if (zend_is_true(schema)) {
PHALCON_INIT_NVAR(complete_table);
PHALCON_CONCAT_VSV(complete_table, schema, "\".\"", table);
} else {
PHALCON_CPY_WRT(complete_table, table);
}
/**
* The table not exists
*/
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVSV(exception_message, "Cannot obtain table columns for the mapped source \"", complete_table, "\" used in model ", class_name);
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message);
return;
}
/**
* Initialize meta-data
*/
PHALCON_INIT_VAR(attributes);
array_init(attributes);
PHALCON_INIT_VAR(primary_keys);
array_init(primary_keys);
PHALCON_INIT_VAR(non_primary_keys);
array_init(non_primary_keys);
PHALCON_INIT_VAR(numeric_typed);
array_init(numeric_typed);
PHALCON_INIT_VAR(not_null);
array_init(not_null);
PHALCON_INIT_VAR(field_types);
array_init(field_types);
PHALCON_INIT_VAR(field_bind_types);
array_init(field_bind_types);
PHALCON_INIT_VAR(automatic_default);
array_init(automatic_default);
PHALCON_INIT_VAR(identity_field);
ZVAL_BOOL(identity_field, 0);
phalcon_is_iterable(columns, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(column);
PHALCON_INIT_NVAR(field_name);
phalcon_call_method(field_name, column, "getname");
phalcon_array_append(&attributes, field_name, PH_SEPARATE);
/**
* To mark fields as primary keys
*/
PHALCON_INIT_NVAR(feature);
phalcon_call_method(feature, column, "isprimary");
if (PHALCON_IS_TRUE(feature)) {
phalcon_array_append(&primary_keys, field_name, PH_SEPARATE);
} else {
phalcon_array_append(&non_primary_keys, field_name, PH_SEPARATE);
}
/**
* To mark fields as numeric
*/
PHALCON_INIT_NVAR(feature);
phalcon_call_method(feature, column, "isnumeric");
if (PHALCON_IS_TRUE(feature)) {
phalcon_array_update_zval_bool(&numeric_typed, field_name, 1, PH_SEPARATE);
}
/**
* To mark fields as not null
*/
PHALCON_INIT_NVAR(feature);
phalcon_call_method(feature, column, "isnotnull");
if (PHALCON_IS_TRUE(feature)) {
phalcon_array_append(¬_null, field_name, PH_SEPARATE);
}
/**
* To mark fields as identity columns
*/
PHALCON_INIT_NVAR(feature);
phalcon_call_method(feature, column, "isautoincrement");
if (PHALCON_IS_TRUE(feature)) {
PHALCON_CPY_WRT(identity_field, field_name);
}
/**
* To get the internal types
*/
PHALCON_INIT_NVAR(type);
phalcon_call_method(type, column, "gettype");
phalcon_array_update_zval(&field_types, field_name, &type, PH_COPY | PH_SEPARATE);
/**
* To mark how the fields must be escaped
*/
PHALCON_INIT_NVAR(bind_type);
phalcon_call_method(bind_type, column, "getbindtype");
phalcon_array_update_zval(&field_bind_types, field_name, &bind_type, PH_COPY | PH_SEPARATE);
zend_hash_move_forward_ex(ah0, &hp0);
}
/**
* Create an array using the MODELS_* constants as indexes
*/
PHALCON_INIT_VAR(model_metadata);
array_init(model_metadata);
phalcon_array_update_long(&model_metadata, 0, &attributes, PH_COPY | PH_SEPARATE);
phalcon_array_update_long(&model_metadata, 1, &primary_keys, PH_COPY | PH_SEPARATE);
phalcon_array_update_long(&model_metadata, 2, &non_primary_keys, PH_COPY | PH_SEPARATE);
phalcon_array_update_long(&model_metadata, 3, ¬_null, PH_COPY | PH_SEPARATE);
phalcon_array_update_long(&model_metadata, 4, &field_types, PH_COPY | PH_SEPARATE);
phalcon_array_update_long(&model_metadata, 5, &numeric_typed, PH_COPY | PH_SEPARATE);
phalcon_array_update_long(&model_metadata, 8, &identity_field, PH_COPY | PH_SEPARATE);
phalcon_array_update_long(&model_metadata, 9, &field_bind_types, PH_COPY | PH_SEPARATE);
phalcon_array_update_long(&model_metadata, 10, &automatic_default, PH_COPY | PH_SEPARATE);
phalcon_array_update_long(&model_metadata, 11, &automatic_default, PH_COPY | PH_SEPARATE);
RETURN_CTOR(model_metadata);
}
/**
* Read the model's column map, this can't be infered
*
* @param Phalcon\Mvc\ModelInterface $model
* @param Phalcon\DiInterface $dependencyInjector
* @return array
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Strategy_Introspection, getColumnMaps){
zval *model, *dependency_injector, *ordered_column_map = NULL;
zval *reversed_column_map = NULL, *user_column_map;
zval *user_name = NULL, *name = NULL, *model_column_map;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &model, &dependency_injector);
PHALCON_INIT_VAR(ordered_column_map);
PHALCON_INIT_VAR(reversed_column_map);
/**
* Check for a columnMap() method on the model
*/
if (phalcon_method_exists_ex(model, SS("columnmap") TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(user_column_map);
phalcon_call_method(user_column_map, model, "columnmap");
if (Z_TYPE_P(user_column_map) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "columnMap() not returned an array");
return;
}
array_init(reversed_column_map);
PHALCON_CPY_WRT(ordered_column_map, user_column_map);
phalcon_is_iterable(user_column_map, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(name, ah0, hp0);
PHALCON_GET_HVALUE(user_name);
phalcon_array_update_zval(&reversed_column_map, user_name, &name, PH_COPY | PH_SEPARATE);
zend_hash_move_forward_ex(ah0, &hp0);
}
}
/**
* Store the column map
*/
PHALCON_INIT_VAR(model_column_map);
array_init(model_column_map);
phalcon_array_update_long(&model_column_map, 0, &ordered_column_map, PH_COPY | PH_SEPARATE);
phalcon_array_update_long(&model_column_map, 1, &reversed_column_map, PH_COPY | PH_SEPARATE);
RETURN_CTOR(model_column_map);
}
| 31.646875 | 190 | 0.706626 |
16a87ee0561d3e3665e8fabad305aa05865ccccc | 3,119 | h | C | vendor/bitsery/include/bitsery/details/adapter_utils.h | lateefx01/Aston | 0e0a2393eeac3946880c3e601c532d49e2cf3b44 | [
"Apache-2.0"
] | null | null | null | vendor/bitsery/include/bitsery/details/adapter_utils.h | lateefx01/Aston | 0e0a2393eeac3946880c3e601c532d49e2cf3b44 | [
"Apache-2.0"
] | null | null | null | vendor/bitsery/include/bitsery/details/adapter_utils.h | lateefx01/Aston | 0e0a2393eeac3946880c3e601c532d49e2cf3b44 | [
"Apache-2.0"
] | null | null | null | //MIT License
//
//Copyright (c) 2017 Mindaugas Vinkelis
//
//Permission is hereby granted, free of charge, to any person obtaining a copy
//of this software and associated documentation files (the "Software"), to deal
//in the Software without restriction, including without limitation the rights
//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
//copies of the Software, and to permit persons to whom the Software is
//furnished to do so, subject to the following conditions:
//
//The above copyright notice and this permission notice shall be included in all
//copies or substantial portions of the Software.
//
//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
//SOFTWARE.
#ifndef BITSERY_DETAILS_ADAPTER_UTILS_H
#define BITSERY_DETAILS_ADAPTER_UTILS_H
#include <cassert>
#include <cstdint>
#include <cstddef>
namespace bitsery {
enum class ReaderError {
NoError,
ReadingError, // this might be used with stream adapter
DataOverflow,
InvalidData,
InvalidPointer
};
namespace details {
/*
* size read/write functions
*/
template<typename Reader>
void readSize(Reader &r, size_t &size, size_t maxSize)
{
uint8_t hb{};
r.template readBytes<1>(hb);
if (hb < 0x80u) {
size = hb;
} else {
uint8_t lb{};
r.template readBytes<1>(lb);
if (hb & 0x40u) {
uint16_t lw{};
r.template readBytes<2>(lw);
size = ((((hb & 0x3Fu) << 8) | lb) << 16) | lw;
} else {
size = ((hb & 0x7Fu) << 8) | lb;
}
}
if (size > maxSize) {
r.setError(ReaderError::InvalidData);
size = {};
}
}
template<typename Writter>
void writeSize(Writter &w, const size_t size)
{
if (size < 0x80u) {
w.template writeBytes<1>(static_cast<uint8_t>(size));
} else {
if (size < 0x4000u) {
w.template writeBytes<1>(static_cast<uint8_t>((size >> 8) | 0x80u));
w.template writeBytes<1>(static_cast<uint8_t>(size));
} else {
assert(size < 0x40000000u);
w.template writeBytes<1>(static_cast<uint8_t>((size >> 24) | 0xC0u));
w.template writeBytes<1>(static_cast<uint8_t>(size >> 16));
w.template writeBytes<2>(static_cast<uint16_t>(size));
}
}
}
}
}
#endif //BITSERY_DETAILS_ADAPTER_UTILS_H
| 34.655556 | 89 | 0.586085 |
592e62c5a10a5a8b54d205944f56dc3291d0af13 | 4,735 | h | C | include/vcard/vcardproperty.h | ut-wangzhixuan/libvcard | ec10c5de282b994e13894da33408b5b6b638213a | [
"BSD-3-Clause"
] | 6 | 2015-12-03T19:52:28.000Z | 2019-08-24T08:15:29.000Z | include/vcard/vcardproperty.h | ut-wangzhixuan/libvcard | ec10c5de282b994e13894da33408b5b6b638213a | [
"BSD-3-Clause"
] | null | null | null | include/vcard/vcardproperty.h | ut-wangzhixuan/libvcard | ec10c5de282b994e13894da33408b5b6b638213a | [
"BSD-3-Clause"
] | 7 | 2015-03-01T16:16:00.000Z | 2021-08-25T08:29:56.000Z | /**
*
* This file is part of the libvcard project.
*
* Copyright (C) 2010, Emanuele Bertoldi (Card Tech srl).
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* $Revision$
* $Date$
*/
#ifndef VCARDPROPERTY_H
#define VCARDPROPERTY_H
#include "vcardparam.h"
#include <QtCore/QDateTime>
#include <QtCore/QStringList>
#define VC_ADDRESS "ADR"
#define VC_AGENT "AGENT"
#define VC_BIRTHDAY "BDAY"
#define VC_CATEGORIES "CATEGORIES"
#define VC_CLASS "CLASS"
#define VC_DELIVERY_LABEL "LABEL"
#define VC_EMAIL "EMAIL"
#define VC_FORMATTED_NAME "FN"
#define VC_GEOGRAPHIC_POSITION "GEO"
#define VC_KEY "KEY"
#define VC_LOGO "LOGO"
#define VC_MAILER "MAILER"
#define VC_NAME "N"
#define VC_NICKNAME "NICKNAME"
#define VC_NOTE "NOTE"
#define VC_ORGANIZATION "ORG"
#define VC_PHOTO "PHOTO"
#define VC_PRODUCT_IDENTIFIER "PRODID"
#define VC_REVISION "REV"
#define VC_ROLE "ROLE"
#define VC_SORT_STRING "SORT-STRING"
#define VC_SOUND "SOUND"
#define VC_TELEPHONE "TEL"
#define VC_TIME_ZONE "TZ"
#define VC_TITLE "TITLE"
#define VC_URL "URL"
#define VC_VERSION "VERSION"
class vCardProperty
{
public:
enum GenericFields
{
DefaultValue = 0
};
enum AddressFields
{
PostOfficeBox = 0,
ExtendedAddress,
Street,
Locality, // e.g. City.
Region, // e.g. State or province.
PostalCode,
Country
};
enum NameFields
{
Lastname = 0,
Firstname,
Additional,
Prefix,
Suffix
};
enum GeographicPositionFields
{
Latitude = 0,
Longitude
};
protected:
QString m_name;
QStringList m_values;
vCardParamList m_params;
public:
vCardProperty();
vCardProperty(const QString& name, const QString& value, const vCardParamList& params = vCardParamList());
vCardProperty(const QString& name, const QStringList& values, const vCardParamList& params = vCardParamList());
vCardProperty(const QString& name, const QString& value, const QString& params);
vCardProperty(const QString& name, const QStringList& values, const QString& params);
~vCardProperty();
QString name() const;
QString value() const;
QStringList values() const;
vCardParamList params() const;
bool isValid() const;
bool operator== (const vCardProperty& param) const;
bool operator!= (const vCardProperty& param) const;
QByteArray toByteArray(vCardVersion version = VC_VER_2_1) const;
static QList<vCardProperty> fromByteArray(const QByteArray& data);
static vCardProperty createAddress(const QString& street, const QString& locality, const QString& region, const QString& postal_code, const QString& country, const QString& post_office_box = "", const QString& ext_address = "", const vCardParamList& params = vCardParamList());
static vCardProperty createBirthday(const QDate& birthday, const vCardParamList& params = vCardParamList());
static vCardProperty createBirthday(const QDateTime& birthday, const vCardParamList& params = vCardParamList());
static vCardProperty createGeographicPosition(qreal latitude, qreal longitude, const vCardParamList& params = vCardParamList());
static vCardProperty createName(const QString& firstname, const QString& lastname, const QString& additional = "", const QString& prefix = "", const QString& suffix = "", const vCardParamList& params = vCardParamList());
static vCardProperty createOrganization(const QString& name, const QStringList& levels = QStringList(), const vCardParamList& params = vCardParamList());
};
typedef QList<vCardProperty> vCardPropertyList;
#endif // VCARDPROPERTY_H
| 36.705426 | 281 | 0.676241 |
59431cd8bacac18d7b3b0b11ae54366ad2eb139f | 3,286 | h | C | qqtw/qqheaders7.2/SupercellVideoView.h | onezens/QQTweak | 04b9efd1d93eba8ef8fec5cf9a20276637765777 | [
"MIT"
] | 5 | 2018-02-20T14:24:17.000Z | 2020-08-06T09:31:21.000Z | qqtw/qqheaders7.2/SupercellVideoView.h | onezens/QQTweak | 04b9efd1d93eba8ef8fec5cf9a20276637765777 | [
"MIT"
] | 1 | 2020-06-10T07:49:16.000Z | 2020-06-12T02:08:35.000Z | qqtw/qqheaders7.2/SupercellVideoView.h | onezens/SmartQQ | 04b9efd1d93eba8ef8fec5cf9a20276637765777 | [
"MIT"
] | null | null | null | //
// Generated by class-dump 3.5 (64 bit).
//
// class-dump is Copyright (C) 1997-1998, 2000-2001, 2004-2013 by Steve Nygard.
//
#import "QTreasureBaseView.h"
#import "QREHongbaoViewDelegate.h"
@class ARMapItemInfo, ARPaddingLabel, AVPlayer, AVPlayerItemVideoOutput, CADisplayLink, CMAttitude, CMMotionManager, NSObject, NSString, NSURL;
@interface SupercellVideoView : QTreasureBaseView <QREHongbaoViewDelegate>
{
AVPlayer *_player;
AVPlayerItemVideoOutput *_output;
CMMotionManager *_motionManager;
CMAttitude *_referenceAttitude;
CADisplayLink *_displayLink;
AVPlayer *_playerEnd;
AVPlayerItemVideoOutput *_outputEnd;
ARPaddingLabel *_hintTextView;
_Bool _isMotioning;
_Bool _isFindTimerTriggered;
_Bool _isPlayingStarted;
_Bool _isPlayerReady;
_Bool _isSensorTriggered;
int _type;
NSString *_busiName;
unsigned long long _poiID;
unsigned long long _taskID;
ARMapItemInfo *_item;
NSString *_textIconPath;
NSString *_logoPath;
NSString *_iconPath;
NSString *_topBG;
NSObject *_playerLock;
NSURL *_urlEnd;
}
- (void).cxx_destruct;
@property(copy, nonatomic) NSString *busiName; // @synthesize busiName=_busiName;
- (void)closeHongbao;
- (struct Game *)createGame:(struct Platform *)arg1;
- (void)dealloc;
- (void)hideHint;
@property(copy, nonatomic) NSString *iconPath; // @synthesize iconPath=_iconPath;
- (void)initHintView;
- (void)initMotionManager;
- (id)initWithFrame:(struct CGRect)arg1;
@property(nonatomic) _Bool isFindTimerTriggered; // @synthesize isFindTimerTriggered=_isFindTimerTriggered;
@property(nonatomic) _Bool isMotioning; // @synthesize isMotioning=_isMotioning;
@property(nonatomic) _Bool isPlayerReady; // @synthesize isPlayerReady=_isPlayerReady;
@property(nonatomic) _Bool isPlayingStarted; // @synthesize isPlayingStarted=_isPlayingStarted;
@property(nonatomic) _Bool isSensorTriggered; // @synthesize isSensorTriggered=_isSensorTriggered;
@property(retain, nonatomic) ARMapItemInfo *item; // @synthesize item=_item;
@property(copy, nonatomic) NSString *logoPath; // @synthesize logoPath=_logoPath;
- (void)movieDidFinishDecoding:(id)arg1;
- (void)movieDidFinishDecodingEnd:(id)arg1;
- (void)openHongbaoJumpToWallet:(id)arg1;
- (void)playVideo:(int)arg1;
@property(retain, nonatomic) NSObject *playerLock; // @synthesize playerLock=_playerLock;
- (void)playerReadyEnd;
@property(nonatomic) unsigned long long poiID; // @synthesize poiID=_poiID;
- (void)prepareContextAndGame;
@property(nonatomic) unsigned long long taskID; // @synthesize taskID=_taskID;
@property(copy, nonatomic) NSString *textIconPath; // @synthesize textIconPath=_textIconPath;
@property(copy, nonatomic) NSString *topBG; // @synthesize topBG=_topBG;
@property(nonatomic) int type; // @synthesize type=_type;
@property(retain, nonatomic) NSURL *urlEnd; // @synthesize urlEnd=_urlEnd;
- (void)showView;
- (void)startDeviceMotion;
- (void)stopDeviceMotion;
- (void)stopUpdating;
- (void)switchMode:(int)arg1;
- (void)update:(id)arg1;
- (void)updateDeviceMotion;
// Remaining properties
@property(readonly, copy) NSString *debugDescription;
@property(readonly, copy) NSString *description;
@property(readonly) unsigned long long hash;
@property(readonly) Class superclass;
@end
| 37.770115 | 143 | 0.767194 |
df89cefd7e999f173f84776915d860b03ecd4023 | 486 | h | C | IQ Test-Saga/ViewControllers/FBLoginViewController.h | gauravnijhara/Quiz-i--OS-App | 0369e91b9b3f434ee3613a826dffd3392fa57e2f | [
"MIT"
] | 1 | 2019-03-20T06:19:05.000Z | 2019-03-20T06:19:05.000Z | IQ Test-Saga/ViewControllers/FBLoginViewController.h | gauravnijhara/Quiz-i--OS-App | 0369e91b9b3f434ee3613a826dffd3392fa57e2f | [
"MIT"
] | null | null | null | IQ Test-Saga/ViewControllers/FBLoginViewController.h | gauravnijhara/Quiz-i--OS-App | 0369e91b9b3f434ee3613a826dffd3392fa57e2f | [
"MIT"
] | 1 | 2019-06-09T14:17:56.000Z | 2019-06-09T14:17:56.000Z | //
// ViewController.h
// IQ Test-Saga
//
// Created by Gaurav Nijhara on 24/05/15.
// Copyright (c) 2015 Gaurav Nijhara. All rights reserved.
//
#import <UIKit/UIKit.h>
#import <FBSDKCoreKit/FBSDKCoreKit.h>
#import <FBSDKLoginKit/FBSDKLoginKit.h>
@interface FBLoginViewController : UIViewController
@property (nonatomic,assign) BOOL skipNeeded;
@property (nonatomic,weak) IBOutlet FBSDKLoginButton *loginButton;
@property (nonatomic,weak) IBOutlet UIButton *skipButton;
@end
| 23.142857 | 66 | 0.759259 |
8a7a76b32d04e0b253ef06d084f73a06a6852718 | 20,551 | h | C | include/future/function.h | Nazg-Gul/libfuture-cc | 1d04e83b882b25915b171595ae3ffdbef8d041a9 | [
"MIT"
] | 2 | 2015-05-15T21:35:50.000Z | 2017-02-16T08:29:24.000Z | include/future/function.h | Nazg-Gul/libfuture-cc | 1d04e83b882b25915b171595ae3ffdbef8d041a9 | [
"MIT"
] | null | null | null | include/future/function.h | Nazg-Gul/libfuture-cc | 1d04e83b882b25915b171595ae3ffdbef8d041a9 | [
"MIT"
] | null | null | null | // Copyright (c) 2015 libfuture-c++ authors.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//
// Author: sergey.vfx@gmail.com (Sergey Sharybin)
#ifndef FUTURE_FUNCTION_H_
#define FUTURE_FUNCTION_H_
namespace future {
namespace function {
template<typename Signature> class function;
} /* namespace function */
namespace internal {
/* Base class for everyone who considers self bindable and callable. */
template <typename R>
class function_bind_base {
public:
function_bind_base() : num_arguments_(0) {}
explicit function_bind_base(int num_arguments)
: num_arguments_(num_arguments) {}
virtual ~function_bind_base() {}
int get_num_arguments() const {
return num_arguments_;
}
virtual R invoke(argument_list& arguments) = 0;
virtual bool is_bound() = 0;
virtual function_bind_base* clone() = 0;
protected:
int num_arguments_;
};
} /* namespace internal */
namespace bind {
template <typename R>
::future::internal::function_bind_base<R>*
function_bind(R func(void));
template <typename R, typename T1,
typename A1>
::future::internal::function_bind_base<R>*
function_bind(R func(T1),
A1 arg1);
template <typename R, typename T1, typename T2,
typename A1, typename A2>
::future::internal::function_bind_base<R>*
function_bind(R func(T1, T2),
A1 arg1, A2 arg2);
template <typename R, typename T1, typename T2, typename T3,
typename A1, typename A2, typename A3>
::future::internal::function_bind_base<R>*
function_bind(R func(T1, T2, T3),
A1 arg1, A2 arg2, A3 arg3);
template <typename R, typename T1, typename T2, typename T3, typename T4,
typename A1, typename A2, typename A3, typename A4>
::future::internal::function_bind_base<R>*
function_bind(R func(T1, T2, T3, T4),
A1 arg1, A2 arg2, A3 arg3, A4 arg4);
template <typename R, typename T1, typename T2, typename T3, typename T4,
typename T5,
typename A1, typename A2, typename A3, typename A4,
typename A5>
::future::internal::function_bind_base<R>*
function_bind(R func(T1, T2, T3, T4, T5),
A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5);
template <typename R, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6,
typename A1, typename A2, typename A3, typename A4,
typename A5, typename A6>
::future::internal::function_bind_base<R>*
function_bind(R func(T1, T2, T3, T4, T5, T6),
A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5,
A6 arg6);
template <typename R, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7,
typename A1, typename A2, typename A3, typename A4,
typename A5, typename A6, typename A7>
::future::internal::function_bind_base<R>*
function_bind(R func(T1, T2, T3, T4, T5, T6, T7),
A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5,
A6 arg6, A7 arg7);
template <typename R, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7, typename T8,
typename A1, typename A2, typename A3, typename A4,
typename A5, typename A6, typename A7, typename A8>
::future::internal::function_bind_base<R>*
function_bind(R func(T1, T2, T3, T4, T5, T6, T7, T8),
A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5,
A6 arg6, A7 arg7, A8 arg8);
template <typename R, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7, typename T8,
typename T9,
typename A1, typename A2, typename A3, typename A4,
typename A5, typename A6, typename A7, typename A8,
typename A9>
::future::internal::function_bind_base<R>*
function_bind(R func(T1, T2, T3, T4, T5, T6, T7, T8, T9),
A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5,
A6 arg6, A7 arg7, A8 arg8, A9 arg9);
template <typename R, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7, typename T8,
typename T9, typename T10,
typename A1, typename A2, typename A3, typename A4,
typename A5, typename A6, typename A7, typename A8,
typename A9, typename A10>
::future::internal::function_bind_base<R>*
function_bind(R func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10),
A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5,
A6 arg6, A7 arg7, A8 arg8, A9 arg9, A10 arg10);
} /* namespace bind */
namespace function {
template<typename Signature> class function;
namespace internal {
/* Bse function, superclass for all the function. */
template<typename R>
class function_base {
typedef ::future::internal::function_bind_base<R> bind_type;
typedef future::internal::argument_list argument_list_type;
public:
function_base() : function_bind_(NULL) {}
explicit function_base(bind_type *function_bind) : function_bind_(function_bind) {}
explicit function_base(const function_base& other) {
if (other.function_bind_ != NULL) {
function_bind_ = other.function_bind_->clone();
} else {
function_bind_ = NULL;
}
}
void operator=(const function_base& other) {
delete function_bind_;
if (other.function_bind_ != NULL) {
function_bind_ = other.function_bind_->clone();
} else {
function_bind_ = NULL;
}
}
~function_base() {
delete function_bind_;
}
bool is_bound() const {
return function_bind_ != NULL &&
function_bind_->is_bound();
}
operator bool() const {
return is_bound();
}
#define FUNCTION_INVOKE_COMMON_PRE() \
using future::internal::argument_wrapper; \
using future::internal::argument_wrapper_base; \
assert_invoke()
#define FUNCTION_INVOKE_COMMON_POST(arguments, num_arguments) \
argument_list_type argument_list((argument_wrapper_base**)arguments, num_arguments); \
return function_bind_->invoke(argument_list)
R invoke() {
FUNCTION_INVOKE_COMMON_PRE();
FUNCTION_INVOKE_COMMON_POST(NULL, 0);
}
template<typename T1>
R invoke(T1 arg1) {
FUNCTION_INVOKE_COMMON_PRE();
argument_wrapper<T1> a1(arg1);
argument_wrapper_base *arguments[] = {&a1};
FUNCTION_INVOKE_COMMON_POST(arguments, 1);
}
template<typename T1, typename T2>
R invoke(T1 arg1, T2 arg2) {
FUNCTION_INVOKE_COMMON_PRE();
argument_wrapper<T1> a1(arg1);
argument_wrapper<T2> a2(arg2);
argument_wrapper_base *arguments[] = {&a1, &a2};
FUNCTION_INVOKE_COMMON_POST(&arguments, 2);
}
template<typename T1, typename T2, typename T3>
R invoke(T1 arg1, T2 arg2, T3 arg3) {
FUNCTION_INVOKE_COMMON_PRE();
argument_wrapper<T1> a1(arg1);
argument_wrapper<T2> a2(arg2);
argument_wrapper<T3> a3(arg3);
argument_wrapper_base *arguments[] = {&a1, &a2, &a3};
FUNCTION_INVOKE_COMMON_POST(&arguments, 3);
}
template<typename T1, typename T2, typename T3, typename T4>
R invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
FUNCTION_INVOKE_COMMON_PRE();
argument_wrapper<T1> a1(arg1);
argument_wrapper<T2> a2(arg2);
argument_wrapper<T3> a3(arg3);
argument_wrapper<T4> a4(arg4);
argument_wrapper_base *arguments[] = {&a1, &a2, &a3, &a4};
FUNCTION_INVOKE_COMMON_POST(&arguments, 4);
}
template<typename T1, typename T2, typename T3, typename T4, typename T5>
R invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5) {
FUNCTION_INVOKE_COMMON_PRE();
argument_wrapper<T1> a1(arg1);
argument_wrapper<T2> a2(arg2);
argument_wrapper<T3> a3(arg3);
argument_wrapper<T4> a4(arg4);
argument_wrapper<T5> a5(arg5);
argument_wrapper_base *arguments[] = {&a1, &a2, &a3, &a4, &a5};
FUNCTION_INVOKE_COMMON_POST(&arguments, 5);
}
template<typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6>
R invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5,
T6 arg6) {
FUNCTION_INVOKE_COMMON_PRE();
argument_wrapper<T1> a1(arg1);
argument_wrapper<T2> a2(arg2);
argument_wrapper<T3> a3(arg3);
argument_wrapper<T4> a4(arg4);
argument_wrapper<T5> a5(arg5);
argument_wrapper<T6> a6(arg6);
argument_wrapper_base *arguments[] = {&a1, &a2, &a3, &a4, &a5,
&a6};
FUNCTION_INVOKE_COMMON_POST(&arguments, 6);
}
template<typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7>
R invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5,
T6 arg6, T7 arg7) {
FUNCTION_INVOKE_COMMON_PRE();
argument_wrapper<T1> a1(arg1);
argument_wrapper<T2> a2(arg2);
argument_wrapper<T3> a3(arg3);
argument_wrapper<T4> a4(arg4);
argument_wrapper<T5> a5(arg5);
argument_wrapper<T6> a6(arg6);
argument_wrapper<T7> a7(arg7);
argument_wrapper_base *arguments[] = {&a1, &a2, &a3, &a4, &a5,
&a6, &a7};
FUNCTION_INVOKE_COMMON_POST(&arguments, 7);
}
template<typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8>
R invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5,
T6 arg6, T7 arg7, T8 arg8) {
FUNCTION_INVOKE_COMMON_PRE();
argument_wrapper<T1> a1(arg1);
argument_wrapper<T2> a2(arg2);
argument_wrapper<T3> a3(arg3);
argument_wrapper<T4> a4(arg4);
argument_wrapper<T5> a5(arg5);
argument_wrapper<T6> a6(arg6);
argument_wrapper<T7> a7(arg7);
argument_wrapper<T8> a8(arg8);
argument_wrapper_base *arguments[] = {&a1, &a2, &a3, &a4, &a5,
&a6, &a7, &a8};
FUNCTION_INVOKE_COMMON_POST(&arguments, 8);
}
template<typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9>
R invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5,
T6 arg6, T7 arg7, T8 arg8, T9 arg9) {
FUNCTION_INVOKE_COMMON_PRE();
argument_wrapper<T1> a1(arg1);
argument_wrapper<T2> a2(arg2);
argument_wrapper<T3> a3(arg3);
argument_wrapper<T4> a4(arg4);
argument_wrapper<T5> a5(arg5);
argument_wrapper<T6> a6(arg6);
argument_wrapper<T7> a7(arg7);
argument_wrapper<T8> a8(arg8);
argument_wrapper<T9> a9(arg9);
argument_wrapper_base *arguments[] = {&a1, &a2, &a3, &a4, &a5,
&a6, &a7, &a8, &a9};
FUNCTION_INVOKE_COMMON_POST(&arguments, 9);
}
template<typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10>
R invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5,
T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10) {
FUNCTION_INVOKE_COMMON_PRE();
argument_wrapper<T1> a1(arg1);
argument_wrapper<T2> a2(arg2);
argument_wrapper<T3> a3(arg3);
argument_wrapper<T4> a4(arg4);
argument_wrapper<T5> a5(arg5);
argument_wrapper<T6> a6(arg6);
argument_wrapper<T7> a7(arg7);
argument_wrapper<T8> a8(arg8);
argument_wrapper<T9> a9(arg9);
argument_wrapper<T10> a10(arg10);
argument_wrapper_base *arguments[] = {&a1, &a2, &a3, &a4, &a5,
&a6, &a7, &a8, &a9, &a10};
FUNCTION_INVOKE_COMMON_POST(&arguments, 10);
}
#undef FUNCTION_INVOKE_COMMON_PRE
#undef FUNCTION_INVOKE_COMMON_POST
protected:
void assert_invoke() {
assert(is_bound() == true);
}
bind_type *function_bind_;
};
/* Detailed function implementations, they know exact return type and
* types of all placeholder arguments.
*/
#define FUNCTION_GLUE(a, b) a ## b
#define CLASS_FUNCTION_N_DECLARE(n) \
class FUNCTION_GLUE(function, n) : public function_base<R> { \
typedef ::future::internal::function_bind_base<R> bind_type; \
public: \
FUNCTION_GLUE(function, n)() : function_base<R>() {} \
FUNCTION_GLUE(function, n)(bind_type *function_bind) : function_base<R>(function_bind) {} \
}
template<typename R>
CLASS_FUNCTION_N_DECLARE(0);
template<typename R, typename T1>
CLASS_FUNCTION_N_DECLARE(1);
template<typename R, typename T1, typename T2>
CLASS_FUNCTION_N_DECLARE(2);
template<typename R, typename T1, typename T2, typename T3>
CLASS_FUNCTION_N_DECLARE(3);
template<typename R, typename T1, typename T2, typename T3, typename T4>
CLASS_FUNCTION_N_DECLARE(4);
template<typename R, typename T1, typename T2, typename T3, typename T4,
typename T5>
CLASS_FUNCTION_N_DECLARE(5);
template<typename R, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6>
CLASS_FUNCTION_N_DECLARE(6);
template<typename R, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7>
CLASS_FUNCTION_N_DECLARE(7);
template<typename R, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7, typename T8>
CLASS_FUNCTION_N_DECLARE(8);
template<typename R, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7, typename T8, typename T9>
CLASS_FUNCTION_N_DECLARE(9);
template<typename R, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7, typename T8, typename T9,
typename T10>
CLASS_FUNCTION_N_DECLARE(10);
#undef CLASS_FUNCTION_N_DECLARE
#undef FUNCTION_GLUE
} /* namespace internal */
/* Some magic which allows to use simple syntax when declaring functions,
* making it possible to just specify desired signature only.
*/
#define CLASS_FUNCTION_DECLARE_COMMON \
typedef function self_type; \
typedef ::future::internal::function_bind_base<R> bind_type; \
public: \
function() : base_type() {} \
function(bind_type *function_bind) : base_type(function_bind) {} \
template <typename FuncPointer> function(FuncPointer foo) \
: base_type(::future::bind::function_bind(foo)) { \
}
template<typename R>
class function<R(void)> : public internal::function0<R> {
typedef internal::function0<R> base_type;
CLASS_FUNCTION_DECLARE_COMMON
R operator() () {
return base_type::invoke();
}
};
template<typename R, typename T1>
class function<R(T1)> : public internal::function1<R , T1> {
typedef internal::function1<R, T1> base_type;
CLASS_FUNCTION_DECLARE_COMMON
R operator() (T1 arg1) {
return base_type::invoke(arg1);
}
};
template<typename R, typename T1, typename T2>
class function<R(T1, T2)> : public internal::function2<R , T1, T2> {
typedef internal::function2<R, T1, T2> base_type;
CLASS_FUNCTION_DECLARE_COMMON
R operator() (T1 arg1, T2 arg2) {
return base_type::invoke(arg1, arg2);
}
};
template<typename R, typename T1, typename T2, typename T3>
class function<R(T1, T2, T3)> : public internal::function3<R , T1, T2, T3> {
typedef internal::function3<R, T1, T2, T3> base_type;
CLASS_FUNCTION_DECLARE_COMMON
R operator() (T1 arg1, T2 arg2, T3 arg3) {
return base_type::invoke(arg1, arg2, arg3);
}
};
template<typename R, typename T1, typename T2, typename T3, typename T4>
class function<R(T1, T2, T3, T4)>
: public internal::function4<R , T1, T2, T3, T4> {
typedef internal::function4<R, T1, T2, T3, T4> base_type;
CLASS_FUNCTION_DECLARE_COMMON
R operator() (T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return base_type::invoke(arg1, arg2, arg3, arg4);
}
};
template<typename R, typename T1, typename T2, typename T3, typename T4,
typename T5>
class function<R(T1, T2, T3, T4, T5)>
: public internal::function5<R , T1, T2, T3, T4, T5> {
typedef internal::function5<R, T1, T2, T3, T4, T5> base_type;
CLASS_FUNCTION_DECLARE_COMMON
R operator() (T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5) {
return base_type::invoke(arg1, arg2, arg3, arg4, arg5);
}
};
template<typename R, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6>
class function<R(T1, T2, T3, T4, T5, T6)>
: public internal::function6<R , T1, T2, T3, T4, T5,
T6> {
typedef internal::function6<R, T1, T2, T3, T4, T5,
T6> base_type;
CLASS_FUNCTION_DECLARE_COMMON
R operator() (T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5,
T6 arg6) {
return base_type::invoke(arg1, arg2, arg3, arg4, arg5,
arg6);
}
};
template<typename R, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7>
class function<R(T1, T2, T3, T4, T5, T6, T7)>
: public internal::function7<R , T1, T2, T3, T4, T5,
T6, T7> {
typedef internal::function7<R, T1, T2, T3, T4, T5,
T6, T7> base_type;
CLASS_FUNCTION_DECLARE_COMMON
R operator() (T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5,
T6 arg6, T7 arg7) {
return base_type::invoke(arg1, arg2, arg3, arg4, arg5,
arg6, arg7);
}
};
template<typename R, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7, typename T8>
class function<R(T1, T2, T3, T4, T5, T6, T7, T8)>
: public internal::function8<R , T1, T2, T3, T4, T5,
T6, T7, T8> {
typedef internal::function8<R, T1, T2, T3, T4, T5,
T6, T7, T8> base_type;
CLASS_FUNCTION_DECLARE_COMMON
R operator() (T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5,
T6 arg6, T7 arg7, T8 arg8) {
return base_type::invoke(arg1, arg2, arg3, arg4, arg5,
arg6, arg7, arg8);
}
};
template<typename R, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7, typename T8, typename T9>
class function<R(T1, T2, T3, T4, T5, T6, T7, T8, T9)>
: public internal::function9<R , T1, T2, T3, T4, T5,
T6, T7, T8, T9> {
typedef internal::function9<R, T1, T2, T3, T4, T5,
T6, T7, T8, T9> base_type;
CLASS_FUNCTION_DECLARE_COMMON
R operator() (T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5,
T6 arg6, T7 arg7, T8 arg8, T9 arg9) {
return base_type::invoke(arg1, arg2, arg3, arg4, arg5,
arg6, arg7, arg8, arg9);
}
};
template<typename R, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7, typename T8, typename T9,
typename T10>
class function<R(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
: public internal::function10<R , T1, T2, T3, T4, T5,
T6, T7, T8, T9, T10> {
typedef internal::function10<R, T1, T2, T3, T4, T5,
T6, T7, T8, T9, T10> base_type;
CLASS_FUNCTION_DECLARE_COMMON
R operator() (T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5,
T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10) {
return base_type::invoke(arg1, arg2, arg3, arg4, arg5,
arg6, arg7, arg8, arg9, arg10);
}
};
#undef CLASS_FUNCTION_DECLARE_COMMON
} /* namespace function **/
} /* namespace future */
#endif /* FUTURE_FUNCTION_H_ */
| 35.86562 | 93 | 0.650382 |
3d5450e40f2fdbe8aca20784fee74d9cf1db93c0 | 1,720 | c | C | os_terminal_windows.c | scarybeasts/beebj | 32ce5e709c3241d2ab06f3daf56119e77c6b137d | [
"MIT"
] | 100 | 2020-04-13T21:31:41.000Z | 2022-03-25T17:00:08.000Z | os_terminal_windows.c | scarybeasts/beebj | 32ce5e709c3241d2ab06f3daf56119e77c6b137d | [
"MIT"
] | 29 | 2020-03-10T03:29:02.000Z | 2021-12-24T02:19:11.000Z | os_terminal_windows.c | scarybeasts/beebj | 32ce5e709c3241d2ab06f3daf56119e77c6b137d | [
"MIT"
] | 14 | 2020-04-13T23:01:33.000Z | 2021-10-05T10:57:53.000Z | #include "os_terminal.h"
#include "util.h"
#include <windows.h>
intptr_t
os_terminal_get_stdin_handle(void) {
HANDLE ret = GetStdHandle(STD_INPUT_HANDLE);
if (ret == INVALID_HANDLE_VALUE) {
util_bail("can't get STD_INPUT_HANDLE");
}
return (intptr_t) ret;
}
intptr_t
os_terminal_get_stdout_handle(void) {
HANDLE ret = GetStdHandle(STD_OUTPUT_HANDLE);
if (ret == INVALID_HANDLE_VALUE) {
util_bail("can't get STD_OUTPUT_HANDLE");
}
return (intptr_t) ret;
}
void
os_terminal_setup(intptr_t handle) {
(void) handle;
}
int
os_terminal_has_readable_bytes(intptr_t handle) {
DWORD ret = WaitForSingleObject((HANDLE) handle, 1);
if (ret == WAIT_TIMEOUT) {
return 0;
} else if (ret == WAIT_OBJECT_0) {
return 1;
}
util_bail("WaitForSingleObject failed");
return 0;
}
int
os_terminal_handle_read_byte(intptr_t handle, uint8_t* p_byte) {
DWORD read = 0;
BOOL ret = ReadFile((HANDLE) handle, p_byte, 1, &read, NULL);
if (!ret || (read != 1)) {
return 0;
}
return 1;
}
int
os_terminal_handle_write_byte(intptr_t handle, uint8_t byte) {
DWORD written = 0;
BOOL ret = WriteFile((HANDLE) handle, &byte, 1, &written, NULL);
if (!ret || (written != 1)) {
return 0;
}
return 1;
}
static void (*s_p_interrupt_callback)(void);
static BOOL
os_terminal_ctrl_handler(DWORD dwCtrlType) {
if (dwCtrlType != CTRL_C_EVENT) {
return FALSE;
}
s_p_interrupt_callback();
return TRUE;
}
void
os_terminal_set_ctrl_c_callback(void (*p_interrupt_callback)(void)) {
s_p_interrupt_callback = p_interrupt_callback;
BOOL ret = SetConsoleCtrlHandler(os_terminal_ctrl_handler, TRUE);
if (ret == FALSE) {
util_bail("SetConsoleCtrlHandler failed");
}
}
| 20.722892 | 69 | 0.70407 |
cd767270df9aa63cf2be4b5265bdf57b14e99e48 | 532 | h | C | Classes/vms/structs/opStack.h | Gonkalos/PL | f3d279bf293e03f311f22f56e8d2bf3f1d8bb8de | [
"MIT"
] | 1 | 2022-03-18T21:39:47.000Z | 2022-03-18T21:39:47.000Z | VirtualMachine/vms/structs/opStack.h | andrepinto42/Processamento-de-Linguagens | 98facba0d1c9ca751743b1c83dca7f441aa182e9 | [
"MIT"
] | null | null | null | VirtualMachine/vms/structs/opStack.h | andrepinto42/Processamento-de-Linguagens | 98facba0d1c9ca751743b1c83dca7f441aa182e9 | [
"MIT"
] | null | null | null |
#ifndef OPSTACK_H
#define OPSTACK_H
#include "types.h"
#include "array.h"
typedef struct operandElem{
Value val;
} *OperandElem;
typedef struct opStack{
Array stack;
opPt sp;
opPt fp;
opPt gp;
} OpStack;
int OpStack_pop(OperandElem*);
int OpStack_top(OperandElem*);
int OpStack_getPos(int, OperandElem*);
int OpStack_addPos(int, OperandElem);
void OpStack_push(OperandElem);
OperandElem newOperandElem(Value);
void OpStack_init(int);
void OpStack_free();
void printOpStack(OperandElem,char,int);
#endif
| 16.121212 | 40 | 0.746241 |
07c0dae7cbefe6050e129fe94f5eaed7aa94f4e9 | 1,409 | h | C | iOSOpenDev/frameworks/iOSDiagnosticsSupport.framework/Headers/MBSDevice.h | bzxy/cydia | f8c838cdbd86e49dddf15792e7aa56e2af80548d | [
"MIT"
] | 678 | 2017-11-17T08:33:19.000Z | 2022-03-26T10:40:20.000Z | iOSOpenDev/frameworks/iOSDiagnosticsSupport.framework/Headers/MBSDevice.h | chenfanfang/Cydia | 5efce785bfd5f1064b9c0f0e29a9cc05aa24cad0 | [
"MIT"
] | 22 | 2019-04-16T05:51:53.000Z | 2021-11-08T06:18:45.000Z | iOSOpenDev/frameworks/iOSDiagnosticsSupport.framework/Headers/MBSDevice.h | chenfanfang/Cydia | 5efce785bfd5f1064b9c0f0e29a9cc05aa24cad0 | [
"MIT"
] | 170 | 2018-06-10T07:59:20.000Z | 2022-03-22T16:19:33.000Z | /**
* This header is generated by class-dump-z 0.2b.
*
* Source: /System/Library/PrivateFrameworks/iOSDiagnosticsSupport.framework/iOSDiagnosticsSupport
*/
@class NSMutableDictionary, NSData, NSString;
@interface MBSDevice : NSObject {
@private
NSMutableDictionary *_deviceInfoDictionary; // 4 = 0x4
NSData *_logData; // 8 = 0x8
NSString *_logFileName; // 12 = 0xc
}
@property(retain) NSMutableDictionary *deviceInfoDictionary; // G=0x1799; S=0x1775; @synthesize=_deviceInfoDictionary
@property(retain) NSData *logData; // G=0x17d5; S=0x17b1; @synthesize=_logData
@property(retain) NSString *logFileName; // G=0x1811; S=0x17ed; @synthesize=_logFileName
- (void)dealloc; // 0x1701
- (BOOL)collectAllDeviceInformation; // 0x124d
- (id)collectBasicDeviceData; // 0x1f0d
- (id)collectGasGaugeData; // 0x1d59
- (id)collectAggdData; // 0x1b51
- (id)collectUbiquityData; // 0x1a49
- (BOOL)collectLogs; // 0x1829
- (BOOL)createTempDirectory; // 0x1461
- (BOOL)copyLogsToTempDirectory; // 0x159d
// declared property getter: - (id)logFileName; // 0x1811
// declared property setter: - (void)setLogFileName:(id)name; // 0x17ed
// declared property getter: - (id)logData; // 0x17d5
// declared property setter: - (void)setLogData:(id)data; // 0x17b1
// declared property getter: - (id)deviceInfoDictionary; // 0x1799
// declared property setter: - (void)setDeviceInfoDictionary:(id)dictionary; // 0x1775
@end
| 39.138889 | 117 | 0.7445 |
6db4205d7452b0393b6aea51a2a9ebc4b7ac5df3 | 2,429 | h | C | config.h | M3dry/dmenu | 7e856d3e958eab96a70c83445aa3378f52dcb468 | [
"MIT"
] | null | null | null | config.h | M3dry/dmenu | 7e856d3e958eab96a70c83445aa3378f52dcb468 | [
"MIT"
] | null | null | null | config.h | M3dry/dmenu | 7e856d3e958eab96a70c83445aa3378f52dcb468 | [
"MIT"
] | null | null | null | /* See LICENSE file for copyright and license details. */
/* Default settings; can be overriden by command line. */
static int instant = 0;
static int topbar = 1; /* -b option; if 0, dmenu appears at bottom */
static int centered = 0; /* -c option; centers dmenu on screen */
static int fuzzy = 0; /* -F option; if 0, dmenu doesn't use fuzzy matching */
static int colorprompt = 1; /* -p option; if 1, prompt uses SchemeSel, otherwise SchemeNorm */
static int min_width = 500; /* minimum width when centered */
static int opacity = 0; /* -o option; if 0, then alpha is disabled */
static const char *fonts[] = {
"Operator Mono SSm Lig:pixelsize=16:antialias=true:autohint=true",
"joypixels:pixelsize=14:antialias=true:autohint=true"
};
static const char *prompt = NULL; /* -p option; prompt to the left of input field */
static const char *colors[SchemeLast][2] = {
/* fg bg */
[SchemeNorm] = { "#eeffff", "#0f111b" },
[SchemeSel] = { "#000000", "#ff5370" },
[SchemeOut] = { "#000000", "#000000" },
[SchemeMid] = { "#eeffff", "#1e1c31" },
[SchemeSelHighlight] = { "#ff5370", "#000000" },
[SchemeNormHighlight] = { "#ff5370", "#0f111b" },
};
static const unsigned int baralpha = OPAQUE;
static const unsigned int borderalpha = OPAQUE;
static const unsigned int alphas[][3] = {
/* fg bg border */
[SchemeNorm] = { OPAQUE, baralpha, borderalpha },
[SchemeSel] = { OPAQUE, baralpha, borderalpha },
[SchemeOut] = { OPAQUE, baralpha, borderalpha },
[SchemeMid] = { OPAQUE, baralpha, borderalpha },
[SchemeSelHighlight] = { OPAQUE, baralpha, borderalpha },
[SchemeNormHighlight] = { OPAQUE, baralpha, borderalpha },
};
/* -l and -g options; controls number of lines and columns in grid if > 0 */
static unsigned int lines = 0;
static unsigned int columns = 0;
/* -h option; minimum height of a menu line */
static unsigned int lineheight = 0;
static unsigned int min_lineheight = 8;
/*
* Characters not considered part of a word while deleting words
* for example: " /?\"&[]"
*/
static const char worddelimiters[] = " ";
/* Size of the window border */
static unsigned int border_width = 0;
| 44.163636 | 110 | 0.59119 |
0d6a5564fa7ee03de6beef651f56459c740b6710 | 1,915 | h | C | src/render/geometry/resources.h | SmirnovArsenty/PathTracing | c2e8981ab2d690d15923e167627f00bd084442b3 | [
"Apache-2.0"
] | null | null | null | src/render/geometry/resources.h | SmirnovArsenty/PathTracing | c2e8981ab2d690d15923e167627f00bd084442b3 | [
"Apache-2.0"
] | null | null | null | src/render/geometry/resources.h | SmirnovArsenty/PathTracing | c2e8981ab2d690d15923e167627f00bd084442b3 | [
"Apache-2.0"
] | null | null | null | #pragma once
#include <ostream>
#include <istream>
#include <fstream>
#include <map>
#include <string>
#include <cassert>
#include <iostream>
#include <cstdio>
#include <vector>
#include <streambuf>
#include <exception>
namespace pt
{
class resource
{
protected:
std::string m_name;
public:
resource() = delete;
resource(const std::string &name);
__forceinline std::string name() const { return m_name; }
__forceinline void setName(const std::string& name ) { m_name = name; }
};
class resource_manager
{
private:
std::map<std::string, resource*> m_stock;
public:
resource_manager() = default;
~resource_manager();
resource_manager& add( resource *Res );
resource* find( const std::string &name );
};
class shader : public resource
{
private:
ID3D11VertexShader *VS = nullptr;
ID3D11PixelShader *PS = nullptr;
static void log(const std::string &Stage, const std::string &Text);
static std::string loadTextFile( const std::string &FileName );
void load();
void unload();
class renderer *m_renderer;
public:
shader(const shader&) = delete;
shader(class renderer* rnd, const std::string &FileNamePrefix);
~shader();
void apply();
void update();
};
class image : public resource
{
private:
int m_width = 0, m_height = 0;
int m_bytesPerPixel;
mutable std::vector<BYTE> m_pixels;
std::vector<DWORD *> m_rowsDword;
std::vector<BYTE (*)[4]> m_rowsByte;
public:
image( const std::string &fileName );
int width() const { return m_width; }
int height() const { return m_height; }
BYTE* pixelData() const;
};
class texture : public resource
{
int m_width, m_height;
ID3D11Texture2D *m_tex;
public:
texture( const std::string &fileName );
texture( const std::string &name, const int &width, const int &height, const int &bytesPerPixel, BYTE *m_pixels );
texture( const image &Img );
~texture();
void apply();
};
}
| 21.277778 | 116 | 0.686162 |
d45a748b29386c01803fe618685ff57bd2734b55 | 2,119 | h | C | ios/Classes/YCMobiSDK.h | VitoJIanxue/flutter_plugins_ycad | dc5e05e1d48ad6b4e28c98203911550062041a86 | [
"MIT"
] | 1 | 2021-04-08T08:56:38.000Z | 2021-04-08T08:56:38.000Z | ios/Classes/YCMobiSDK.h | VitoJIanxue/flutter_plugins_ycad | dc5e05e1d48ad6b4e28c98203911550062041a86 | [
"MIT"
] | null | null | null | ios/Classes/YCMobiSDK.h | VitoJIanxue/flutter_plugins_ycad | dc5e05e1d48ad6b4e28c98203911550062041a86 | [
"MIT"
] | null | null | null | //
// YCMobiSDK.h
// YicheMobileAds
//
// Created by YICHE on 16/8/15.
// Copyright © 2016年 YICHE. All rights reserved.
//
#import <Foundation/Foundation.h>
#import "ADMobiReqModel.h"
#import "ADBean.h"
@import UIKit;
typedef enum : NSInteger {
SSP_AD_SDK_Debug = 0, //线下调试环境
SSP_AD_SDK_PRE,//预览环境
SSP_AD_SDK_Release,//正式发版环境，正式上线务必要使用此模式！此模式下无日志打印！
}SSPEnvironment;
typedef void(^YCFailureBlock)(NSString *errrorCode,NSString *errorMsg);
typedef void(^YCSuccessBlock)(UIView *uiview,ADBean *adBean);
@interface YCMobiSDK : NSObject
/**
* 初始化 pubid & key 以及开发环境枚举设置
* SSPEnvironment，正式上线请务必设置为：SSP_AD_SDK_Release
*/
+ (void) initNativeAds:(NSString *)pubid andkey:(NSString *)key andEnvironment:(SSPEnvironment)environment;
/**
* 同步dvid 用于更新id
*/
+ (void)synchronizeForDvid:(NSString *)dvid;
/**
* 同步uid
*/
+ (void)synchronizeForUid:(NSString *)uid;
/**
* 同步idfa
*/
+ (void)synchronizeForIDFA:(NSString *)idfa;
/**
* 同步idfv
*/
+ (void)synchronizeForIDFV:(NSString *)idfv;
/**
* 同步关闭的广告id
*/
+ (void)synchronizeForClosedAdId:(NSString *)closedAdId;
/**
* 获取广告 ：只要接口调用成功, resultBlock 的 Bool 就返 回 YES。可根据 dataArray 的 count 值判断此广告位 有无物料。
* @param model 请求参数model
* Block返回值：
* isSuccess： 广告位请求是否成功 标识
* dataArray：封装好的 ADBean 广告物料数组
* msg ： 指示信息
*/
+ (void)fetchNativeAdWithADMobiReqModel:(ADMobiReqModel *)model ResultBlock:(void (^)(BOOL isSuccess, NSArray *dataArray,NSString *msg))resultBlock;
/**
* 发送曝光统计
*
* @param model 获取到的广告物料
*/
+ (void)sendExposeWithADModel:(ADBean *)model;
/**
* 发送点击统计,此方法废弃，使用 `+(void)sendClickTrackWithADModel:`方法代替
*
* @param model 获取到的广告物料
*/
+ (void)sendClickWithWithADModel:(ADBean *)model DEPRECATED_MSG_ATTRIBUTE("use +(void)sendClickTrackWithADModel: instead");
/**
* 发送点击统计
*
* @param model 获取到的广告物料
*/
+ (void)sendClickTrackWithADModel:(ADBean *)model;
/**
* 获取sdk版本号
*
* @return version
*/
+ (NSString *)sdkVersion;
/**
* 获取广告,请传单广告位大图广告
*
*/
+ (void)getBannerView:(ADMobiReqModel *)model successBlock:(YCSuccessBlock)successBlock failueBlock:(YCFailureBlock)failueBlock;
@end
| 20.572816 | 148 | 0.704106 |
dece35e11d897c089e7eefa53c2f3df1e15ef796 | 6,751 | h | C | reflex/test/implementation/legacy/testDict2/TestClasses.h | paulwratt/cin-5.34.00 | 036a8202f11a4a0e29ccb10d3c02f304584cda95 | [
"MIT"
] | 10 | 2018-03-26T07:41:44.000Z | 2021-11-06T08:33:24.000Z | reflex/test/implementation/legacy/testDict2/TestClasses.h | paulwratt/cin-5.34.00 | 036a8202f11a4a0e29ccb10d3c02f304584cda95 | [
"MIT"
] | null | null | null | reflex/test/implementation/legacy/testDict2/TestClasses.h | paulwratt/cin-5.34.00 | 036a8202f11a4a0e29ccb10d3c02f304584cda95 | [
"MIT"
] | 1 | 2020-11-17T03:17:00.000Z | 2020-11-17T03:17:00.000Z | #include <list>
#include <cstdlib>
namespace {
class ForwardedUnnamedType;
}
namespace xmlTypedefSelection {
class RealXmlSelClass {};
typedef RealXmlSelClass TypedefXmlSelClass;
typedef TypedefXmlSelClass TypedefXmlSelClass2;
} // ns xmlTypedefSelection
namespace testclasses {
class WithArray {
public:
WithArray() {
m_a[0] = 1;
m_a[1] = 2;
m_a[2] = 3;
m_a[3] = 4;
m_a[4] = 5;
}
private:
int m_a[5];
};
template <int i> class testTemplInt {
int
foo() { return i; }
};
static const int staticint = 1;
class TestFunctionReturnTypes {
public:
int
returnFundamental() { return 0; }
A
returnCompound() { A* a = new A(); return *a; }
A*
returnPointer1() { return new A(); }
int*
returnPointer2() { return 0; }
void
returnVoid() {}
const int&
returnRef1() { return staticint; }
A&
returnRef2() { A* a = new A(); return *a; }
};
class Outer {
public:
class Inner {
public:
class IInner {};
};
};
class TemplFun {
public:
template <class T> void
foooo(T /*t*/) {}
};
class DataMembers {
typedef int (*MYFUNPTR)(const std::vector<double>&, const std::vector<double>&);
int i;
int* pi;
int** ppi;
int pa[5];
int paa[5][5];
int paa2[5][4][3][2][1];
int** paa3[5][3][1];
MYFUNPTR fPtr2;
int (* fPtr)(int,
char,
bool);
};
class Typedefs {
typedef int MYINT;
typedef MYINT* PMYINT;
typedef const MYINT** PPMYINT;
typedef const PMYINT& RPMYINT;
typedef const PPMYINT* PPPMYINT;
struct A {};
typedef A A;
struct B {};
typedef B C;
typedef C B;
};
typedef int MyInt;
typedef std::vector<MyInt> MyVector;
class WithTypedefMember {
int m_i;
MyInt m_mi;
std::vector<MyInt> m_v;
MyVector m_mv;
};
template <class T> class WithTypedefMemberT {
T m_t;
};
class WithTypedef {
typedef int MyInt;
};
class UnnamedTypes {
struct {
int i;
double d;
} m_struct;
union {
struct { int i; } m_str1;
struct { int j; } m_str2;
} m_union;
private:
struct Private_Inner_Struct {
int i;
double j;
};
};
struct PrivateConstructors {
int i;
void
foo() {}
};
class WithTransientMember {
private:
int m_transient;
WithTransientMember* m_nottransient;
};
struct ConstNonConstMembers {
ConstNonConstMembers(): m_i(0),
m_ci(1),
m_vi(2) {}
int
foo(int i) { return m_i * i; }
int
foo(int i) const { return m_i * i; }
int
constfoo() const { return 0; }
int
nonconstfoo() { return 1; }
int m_i;
const int m_ci;
volatile int m_vi;
};
namespace OverloadedOperators {
struct NoOp {
public:
std::vector<int> makeItComplex; };
struct OpNew {
public:
void*
operator new(size_t n) { std::cout << "overloaded new" << n << std::endl; return malloc(n); }
};
struct PlOpNew {
public:
void*
operator new(size_t n,
void* v) { std::cout << "overloaded placement new " << n << v << std::endl; return malloc(n); }
};
struct PlOpOpNew {
public:
void*
operator new(size_t n) { std::cout << "overloaded new" << n << std::endl; return malloc(n); }
void*
operator new(size_t n,
void* v) { std::cout << "overloaded placement new " << n << v << std::endl; return malloc(n); }
};
struct OpANew {
public:
void* operator new
[](size_t n) { std::cout << "overloaded new" << n << std::endl; return malloc(n); }
};
struct PlOpANew {
public:
void* operator new
[](size_t n,
void* v) { std::cout << "overloaded placement new " << n << v << std::endl; return malloc(n); }
};
struct PlOpAOpANew {
public:
void* operator new
[](size_t n) { std::cout << "overloaded new" << n << std::endl; return malloc(n); }
void* operator new
[](size_t n,
void* v) { std::cout << "overloaded placement new " << n << v << std::endl; return malloc(n); }
};
} // ns OverloadedOperators
namespace NonPublicDestructor {
class BaseWithProtectedDestructor {
protected:
BaseWithProtectedDestructor() {}
BaseWithProtectedDestructor(const BaseWithProtectedDestructor& /* arg */) {}
~BaseWithProtectedDestructor() {}
};
class Derived20: public BaseWithProtectedDestructor {
};
class Derived21: public BaseWithProtectedDestructor {
public:
~Derived21() {}
};
} // ns NonPublicDestructor
namespace ConvOp {
struct ConversionOperator {
typedef const int* (ConversionOperator::* ptr_to_mem_fun)() const;
operator ptr_to_mem_fun() const { return & ConversionOperator::i; }
typedef int* ConversionOperator::* ptr_to_mem_data;
operator ptr_to_mem_data() const { return &ConversionOperator::m_ip; }
const int*
i() const { return &m_i; }
int m_i;
int* m_ip;
};
template <class T> struct ConversionOperatorT {
typedef const T* (ConversionOperatorT<T>::* ptr_to_mem_fun)() const;
operator ptr_to_mem_fun() const { return & ConversionOperatorT<T>::i; }
typedef T* ConversionOperatorT<T>::* ptr_to_mem_data;
operator ptr_to_mem_data() const { return &ConversionOperatorT<T>::m_ip; }
const T*
i() const { return &m_i; }
T m_i;
T* m_ip;
};
} // ns ConvOp
namespace { class ForwardedUnnamedNestedType; }
namespace FwUnnamedNSType {
struct ForwardUnnamedNamespaceType {
void
foo(const ForwardedUnnamedType* /* fp */) {}
void
foo2(const ForwardedUnnamedNestedType* /* fp */) {}
};
} // ns FwUnnamedNSType
struct Base { virtual ~Base() {} };
struct DerivedA: public Base {};
struct DerivedB: public Base {};
class MyClass {};
struct MyStruct {};
} // namespace testclasses
class BadDictionary {
public:
const A*
rioOnTrack(unsigned int indx) const {
//return new A();
return m_vect->operator [](indx);
}
std::vector<const A*>* m_vect;
}; // namespace testclasses
namespace testclasses2 {
template <class T> class WithTypedefMemberT {
T m_t;
};
}
typedef int MYINT;
typedef float MYFLOAT;
// template instances
namespace {
struct _testclasses_instances {
std::vector<MyClass> m_v2;
std::vector<MYINT> m_v0;
std::vector<MYFLOAT> m_v1;
std::list<MYINT> m_l0;
std::list<MYFLOAT> m_l1;
struct A {};
_testclasses_instances() {
A a;
testclasses::TemplFun tf;
tf.foooo(a);
}
std::vector<testclasses::Base*> mv1;
testclasses::testTemplInt<1> mi1;
testclasses::testTemplInt<-1> mim1;
testclasses::ConvOp::ConversionOperatorT<int> m1;
testclasses::WithTypedefMemberT<testclasses::MyVector> m2;
testclasses::WithTypedefMemberT<testclasses::MyInt> m3;
testclasses2::WithTypedefMemberT<testclasses::MyVector> m4;
testclasses2::WithTypedefMemberT<testclasses::MyInt> m5;
};
}
| 17.672775 | 111 | 0.636646 |
8e4e3bb8a58f3d467fd5cfe5805100caaade161c | 447 | h | C | usr/libexec/CommCenter/CCNEPolicy.h | lechium/iOS1351Headers | 6bed3dada5ffc20366b27f7f2300a24a48a6284e | [
"MIT"
] | 2 | 2021-11-02T09:23:27.000Z | 2022-03-28T08:21:57.000Z | usr/libexec/CommCenter/CCNEPolicy.h | lechium/iOS1351Headers | 6bed3dada5ffc20366b27f7f2300a24a48a6284e | [
"MIT"
] | null | null | null | usr/libexec/CommCenter/CCNEPolicy.h | lechium/iOS1351Headers | 6bed3dada5ffc20366b27f7f2300a24a48a6284e | [
"MIT"
] | 1 | 2022-03-28T08:21:59.000Z | 2022-03-28T08:21:59.000Z | //
// Generated by classdumpios 1.0.1 (64 bit) (iOS port by DreamDevLost)(Debug version compiled Sep 26 2020 13:48:20).
//
// Copyright (C) 1997-2019 Steve Nygard.
//
#import <objc/NSObject.h>
@class NEPolicy;
@interface CCNEPolicy : NSObject
{
NEPolicy *policy; // 8 = 0x8
}
- (void).cxx_destruct; // IMP=0x0000000100404b8c
- (id)initWithOrder:(unsigned int)arg1 result:(id)arg2 conditions:(id)arg3; // IMP=0x00000001004049c4
@end
| 21.285714 | 120 | 0.697987 |
8eae1727828a63a5c968f91d0f1d96c0c4891df3 | 5,268 | h | C | library/include/m2etis/wrapper/chimera/ChimeraWrapperImpl.h | ClockworkOrigins/m2etis | 3b9c0f98c172f48889e75fe0b80a61a0e47670f5 | [
"Apache-2.0"
] | 2 | 2016-01-24T22:08:27.000Z | 2017-01-01T13:06:44.000Z | library/include/m2etis/wrapper/chimera/ChimeraWrapperImpl.h | ClockworkOrigins/m2etis | 3b9c0f98c172f48889e75fe0b80a61a0e47670f5 | [
"Apache-2.0"
] | null | null | null | library/include/m2etis/wrapper/chimera/ChimeraWrapperImpl.h | ClockworkOrigins/m2etis | 3b9c0f98c172f48889e75fe0b80a61a0e47670f5 | [
"Apache-2.0"
] | null | null | null | /*
Copyright (2016) Michael Baer, Daniel Bonrath, All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#ifndef __M2ETIS_WRAPPER_CHIMERA_CHIMERAWRAPPERIMPL_H__
#define __M2ETIS_WRAPPER_CHIMERA_CHIMERAWRAPPERIMPL_H__
#include <stdexcept>
#include <memory>
#include "m2etis/util/SystemParameters.h"
#include "m2etis/net/NetworkCallbackInterface.h"
#include "m2etis/net/NetworkInterface.h"
#include "m2etis/net/NodeHandle.h"
#include "m2etis/wrapper/chimera/ChimeraWrapper.h"
#include "boost/date_time/posix_time/posix_time_types.hpp"
#include "boost/thread.hpp"
extern "C" {
#include "chimera/chimera.h"
}
namespace m2etis {
namespace wrapper {
namespace chimera {
class ChimeraWrapper;
/**
* @brief The C++-wrapper around chimera
* @details This class will have a global instance due to chimeras need for functionpointers for upcalling
* into the application. Using static methods for that …
*/
class ChimeraWrapperImpl {
friend class ChimeraWrapper;
private:
const static int CHIMERA_MESSAGE_TYPE_BASE = 15;
ChimeraWrapperImpl() : _cb(nullptr), _initialized(false), _me(new ChimeraHost), _state(new ChimeraState), periodic_(boost::posix_time::milliseconds(3000)), purge_distance_(boost::posix_time::milliseconds(6000)), neighbors_(), neighbors_mutex_(), purging_(true), purger_(boost::bind(&ChimeraWrapperImpl::manageHeartbeats, this)), map_mutex_(), map_() {
_impl = this;
}
ChimeraWrapperImpl(const ChimeraWrapperImpl &);
const ChimeraWrapperImpl & operator =(const ChimeraWrapperImpl &);
bool _initialized;
typedef std::shared_ptr<ChimeraHost> HostPtr;
HostPtr _me;
typedef std::shared_ptr<ChimeraState> StatePtr;
StatePtr _state;
inline static int encodeChimeraMessageType(message::MessageType type) {
return CHIMERA_MESSAGE_TYPE_BASE + static_cast<int>(type);
}
inline static message::MessageType decodeChimeraMessagetype(int ctype) {
return static_cast<message::MessageType>(ctype - CHIMERA_MESSAGE_TYPE_BASE);
}
void setUpcalls();
void post_init();
std::list<net::NodeHandle<net::NetworkType<net::CHIMERA> >::Ptr> createList(ChimeraHost **, int size) const;
static ChimeraWrapperImpl * _impl;
static void forward_upcall(Key **, Message **, ChimeraHost **);
static void update_upcall(Key * k, ChimeraHost * h, int joined);
static void deliver_upcall(Key * k, Message * m);
const boost::posix_time::time_duration periodic_;
const boost::posix_time::time_duration purge_distance_;
typedef std::pair<boost::posix_time::ptime, net::NetworkType<net::CHIMERA>::Key> TimePair;
typedef std::vector<TimePair> TimeList;
typedef boost::unique_lock<boost::mutex> Guard;
typedef std::map<net::NetworkType<net::CHIMERA>::Key, ChimeraHost *> KeyHostMap;
TimeList neighbors_;
mutable boost::mutex neighbors_mutex_;
volatile bool purging_;
boost::thread purger_;
mutable boost::mutex map_mutex_;
KeyHostMap map_;
void processHeartbeat(const net::NetworkType<net::CHIMERA>::Key & from);
void manageHeartbeats();
void sendHeartbeat(const net::NetworkType<net::CHIMERA>::Key & to, bool ack = false);
public:
virtual ~ChimeraWrapperImpl() {
purging_ = false;
purger_.join();
}
void init(const int port);
void init(const int port, const std::string & known_hostname, const int know_hostport);
void send(const typename message::NetworkMessage<net::NetworkType<net::CHIMERA>>::Ptr msg, typename net::NodeHandle<net::NetworkType<net::CHIMERA>>::Ptr_const hint);
void send(const typename message::NetworkMessage<net::NetworkType<net::CHIMERA>>::Ptr msg);
net::NodeHandle<net::NetworkType<net::CHIMERA> >::Ptr getSelfNodeHandle() const;
std::list<net::NodeHandle<net::NetworkType<net::CHIMERA> >::Ptr> local_lookup(const net::NetworkType<net::CHIMERA>::Key & key, const int num, const bool safe) const;
bool isResponsibleFor(const net::NetworkType<net::CHIMERA>::Key & key, const net::NetworkType<net::CHIMERA>::Key & node) const;
std::list<net::NodeHandle<net::NetworkType<net::CHIMERA> >::Ptr> neighborSet(const int num) const;
std::list<net::NodeHandle<net::NetworkType<net::CHIMERA> >::Ptr> replicaSet(const net::NetworkType<net::CHIMERA>::Key & key, const int maxRank) const;
bool range(const net::NodeHandle<net::NetworkType<net::CHIMERA> >::Ptr node, const int rank, const net::NetworkType<net::CHIMERA>::Key & lkey, const net::NetworkType<net::CHIMERA>::Key & rkey) const;
void registerMessageType(const message::MessageType type, const bool ack) const;
// MessagePtr_w createMessage(const int type, const Key& dest, const std::string& payload) const;
};
} /* namespace chimera */
} /* namespace wrapper */
} /* namespace m2etis */
#endif /* __M2ETIS_WRAPPER_CHIMERA_CHIMERAWRAPPERIMPL_H__ */
| 37.098592 | 353 | 0.752088 |
90969e15709d16f001c0524647ea6edfbb9b86b5 | 473 | h | C | Ventura/src/Scene.h | VictorAlvizo/Ventura | 57d2141f87534984acfd08ad49d91d177b8ffbe5 | [
"MIT"
] | null | null | null | Ventura/src/Scene.h | VictorAlvizo/Ventura | 57d2141f87534984acfd08ad49d91d177b8ffbe5 | [
"MIT"
] | 1 | 2020-11-22T23:34:04.000Z | 2020-11-22T23:34:04.000Z | Ventura/src/Scene.h | VictorAlvizo/Ventura | 57d2141f87534984acfd08ad49d91d177b8ffbe5 | [
"MIT"
] | null | null | null | #pragma once
#include "EngineHeader.h"
class Game;
class Scene {
public:
//Include the game class in the .cpp of the derived classes and in game friend class the derived classes
Scene(Game * m_GameClass);
virtual ~Scene();
virtual void Init() = 0;
virtual void Destroy() = 0;
virtual void ProcessInput(float deltaTime) = 0;
virtual void Update(float deltaTime) = 0;
virtual void Render() = 0;
virtual void CheckCollisions();
protected:
Game * m_GameClass;
}; | 21.5 | 105 | 0.725159 |
fd0b5e89f0e7cf189dea12e67b4e30722d7e1c25 | 3,506 | h | C | release/src-rt-6.x.4708/linux/linux-2.6.36/arch/arm/mach-nuc93x/include/mach/map.h | afeng11/tomato-arm | 1ca18a88480b34fd495e683d849f46c2d47bb572 | [
"FSFAP"
] | 21 | 2021-01-22T06:47:38.000Z | 2022-03-20T14:24:29.000Z | linux-3.0/arch/arm/mach-nuc93x/include/mach/map.h | spartan263/vizio_oss | 74270002d874391148119b48882db6816e7deedc | [
"Linux-OpenIB"
] | 1 | 2018-08-21T03:42:06.000Z | 2018-08-21T03:42:06.000Z | linux-3.0/arch/arm/mach-nuc93x/include/mach/map.h | spartan263/vizio_oss | 74270002d874391148119b48882db6816e7deedc | [
"Linux-OpenIB"
] | 12 | 2021-01-22T14:59:28.000Z | 2022-02-22T04:03:31.000Z | /*
* arch/arm/mach-nuc93x/include/mach/map.h
*
* Copyright (c) 2008 Nuvoton technology corporation.
*
* Wan ZongShun <mcuos.com@gmail.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation;version 2 of the License.
*
*/
#ifndef __ASM_ARCH_MAP_H
#define __ASM_ARCH_MAP_H
#define MAP_OFFSET (0xfff00000)
#define CLK_OFFSET (0x10)
#ifndef __ASSEMBLY__
#define NUC93X_ADDR(x) ((void __iomem *)(0xF0000000 + ((x)&(~MAP_OFFSET))))
#else
#define NUC93X_ADDR(x) (0xF0000000 + ((x)&(~MAP_OFFSET)))
#endif
/*
* nuc932 hardware register definition
*/
#define NUC93X_PA_IRQ (0xFFF83000)
#define NUC93X_PA_GCR (0xFFF00000)
#define NUC93X_PA_EBI (0xFFF01000)
#define NUC93X_PA_UART (0xFFF80000)
#define NUC93X_PA_TIMER (0xFFF81000)
#define NUC93X_PA_GPIO (0xFFF84000)
#define NUC93X_PA_GDMA (0xFFF03000)
#define NUC93X_PA_USBHOST (0xFFF0d000)
#define NUC93X_PA_I2C (0xFFF89000)
#define NUC93X_PA_LCD (0xFFF06000)
#define NUC93X_PA_GE (0xFFF05000)
#define NUC93X_PA_ADC (0xFFF85000)
#define NUC93X_PA_RTC (0xFFF87000)
#define NUC93X_PA_PWM (0xFFF82000)
#define NUC93X_PA_ACTL (0xFFF0a000)
#define NUC93X_PA_USBDEV (0xFFF0C000)
#define NUC93X_PA_JEPEG (0xFFF0e000)
#define NUC93X_PA_CACHE_T (0xFFF60000)
#define NUC93X_PA_VRAM (0xFFF0b000)
#define NUC93X_PA_DMAC (0xFFF09000)
#define NUC93X_PA_I2SM (0xFFF08000)
#define NUC93X_PA_CACHE (0xFFF02000)
#define NUC93X_PA_GPU (0xFFF04000)
#define NUC93X_PA_VIDEOIN (0xFFF07000)
#define NUC93X_PA_SPI0 (0xFFF86000)
#define NUC93X_PA_SPI1 (0xFFF88000)
/*
* nuc932 virtual address mapping.
* interrupt controller is the first thing we put in, to make
* the assembly code for the irq detection easier
*/
#define NUC93X_VA_IRQ NUC93X_ADDR(0x00000000)
#define NUC93X_SZ_IRQ SZ_4K
#define NUC93X_VA_GCR NUC93X_ADDR(NUC93X_PA_IRQ)
#define NUC93X_VA_CLKPWR (NUC93X_VA_GCR+CLK_OFFSET)
#define NUC93X_SZ_GCR SZ_4K
/* EBI management */
#define NUC93X_VA_EBI NUC93X_ADDR(NUC93X_PA_EBI)
#define NUC93X_SZ_EBI SZ_4K
/* UARTs */
#define NUC93X_VA_UART NUC93X_ADDR(NUC93X_PA_UART)
#define NUC93X_SZ_UART SZ_4K
/* Timers */
#define NUC93X_VA_TIMER NUC93X_ADDR(NUC93X_PA_TIMER)
#define NUC93X_SZ_TIMER SZ_4K
/* GPIO ports */
#define NUC93X_VA_GPIO NUC93X_ADDR(NUC93X_PA_GPIO)
#define NUC93X_SZ_GPIO SZ_4K
/* GDMA control */
#define NUC93X_VA_GDMA NUC93X_ADDR(NUC93X_PA_GDMA)
#define NUC93X_SZ_GDMA SZ_4K
/* I2C hardware controller */
#define NUC93X_VA_I2C NUC93X_ADDR(NUC93X_PA_I2C)
#define NUC93X_SZ_I2C SZ_4K
/* LCD controller*/
#define NUC93X_VA_LCD NUC93X_ADDR(NUC93X_PA_LCD)
#define NUC93X_SZ_LCD SZ_4K
/* 2D controller*/
#define NUC93X_VA_GE NUC93X_ADDR(NUC93X_PA_GE)
#define NUC93X_SZ_GE SZ_4K
/* ADC */
#define NUC93X_VA_ADC NUC93X_ADDR(NUC93X_PA_ADC)
#define NUC93X_SZ_ADC SZ_4K
/* RTC */
#define NUC93X_VA_RTC NUC93X_ADDR(NUC93X_PA_RTC)
#define NUC93X_SZ_RTC SZ_4K
/* Pulse Width Modulation(PWM) Registers */
#define NUC93X_VA_PWM NUC93X_ADDR(NUC93X_PA_PWM)
#define NUC93X_SZ_PWM SZ_4K
/* Audio Controller controller */
#define NUC93X_VA_ACTL NUC93X_ADDR(NUC93X_PA_ACTL)
#define NUC93X_SZ_ACTL SZ_4K
/* USB Device port */
#define NUC93X_VA_USBDEV NUC93X_ADDR(NUC93X_PA_USBDEV)
#define NUC93X_SZ_USBDEV SZ_4K
/* USB host controller*/
#define NUC93X_VA_USBHOST NUC93X_ADDR(NUC93X_PA_USBHOST)
#define NUC93X_SZ_USBHOST SZ_4K
#endif /* __ASM_ARCH_MAP_H */
| 25.042857 | 75 | 0.783229 |
b0442bc81277761ee6cab07dd822db65b97eda5b | 3,690 | h | C | netbsd/sys/net/if_pppoe.h | MarginC/kame | 2ef74fe29e4cca9b4a87a1d5041191a9e2e8be30 | [
"BSD-3-Clause"
] | 91 | 2015-01-05T15:18:31.000Z | 2022-03-11T16:43:28.000Z | netbsd/sys/net/if_pppoe.h | MarginC/kame | 2ef74fe29e4cca9b4a87a1d5041191a9e2e8be30 | [
"BSD-3-Clause"
] | 1 | 2016-02-25T15:57:55.000Z | 2016-02-25T16:01:02.000Z | netbsd/sys/net/if_pppoe.h | MarginC/kame | 2ef74fe29e4cca9b4a87a1d5041191a9e2e8be30 | [
"BSD-3-Clause"
] | 21 | 2015-02-07T08:23:07.000Z | 2021-12-14T06:01:49.000Z | /* $NetBSD: if_pppoe.h,v 1.3 2002/04/14 12:24:28 martin Exp $ */
/*-
* Copyright (c) 2002 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Martin Husemann <martin@netbsd.org>.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the NetBSD
* Foundation, Inc. and its contributors.
* 4. Neither the name of The NetBSD Foundation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
struct pppoediscparms {
char ifname[IFNAMSIZ]; /* pppoe interface name */
char eth_ifname[IFNAMSIZ]; /* external ethernet interface name */
char *ac_name; /* access concentrator name (or NULL) */
size_t ac_name_len; /* on write: length of buffer for ac_name */
char *service_name; /* service name (or NULL) */
size_t service_name_len; /* on write: length of buffer for service name */
};
#define PPPOESETPARMS _IOW('i', 110, struct pppoediscparms)
#define PPPOEGETPARMS _IOWR('i', 111, struct pppoediscparms)
#define PPPOE_STATE_INITIAL 0
#define PPPOE_STATE_PADI_SENT 1
#define PPPOE_STATE_PADR_SENT 2
#define PPPOE_STATE_SESSION 3
#define PPPOE_STATE_CLOSING 4
struct pppoeconnectionstate {
char ifname[IFNAMSIZ]; /* pppoe interface name */
u_int state; /* one of the PPPOE_STATE_ states above */
u_int session_id; /* if state == PPPOE_STATE_SESSION */
u_int padi_retry_no; /* number of retries already sent */
u_int padr_retry_no;
};
#define PPPOEGETSESSION _IOWR('i', 112, struct pppoeconnectionstate)
struct pppoeidletimeoutcfg {
char ifname[IFNAMSIZ]; /* pppoe interface name */
u_long idle_timeout; /* idle timeout in seconds */
};
#define PPPOEGETIDLETIMEOUT _IOWR('i', 113, struct pppoeidletimeoutcfg)
#define PPPOESETIDLETIMEOUT _IOW('i', 114, struct pppoeidletimeoutcfg)
#ifdef _KERNEL
extern struct ifqueue ppoediscinq;
extern struct ifqueue ppoeinq;
#ifdef __HAVE_GENERIC_SOFT_INTERRUPTS
extern void * pppoe_softintr; /* softinterrupt cookie */
#else
extern struct callout pppoe_softintr; /* callout (poor mans softint) */
extern void pppoe_softintr_handler(void*); /* handler function */
#endif
#endif /* _KERNEL */
| 41.460674 | 78 | 0.757724 |
40c7bcdefad3869a7cbf7b6d7eafeb77a83835b9 | 683 | h | C | spiral-core/include/spiral/internet/interfaces/IProducer.h | RangelReale/spiral-io | cf8dbdfcfbef5dc8092fd7ea0ce8d052edf2f35d | [
"Unlicense",
"MIT"
] | null | null | null | spiral-core/include/spiral/internet/interfaces/IProducer.h | RangelReale/spiral-io | cf8dbdfcfbef5dc8092fd7ea0ce8d052edf2f35d | [
"Unlicense",
"MIT"
] | null | null | null | spiral-core/include/spiral/internet/interfaces/IProducer.h | RangelReale/spiral-io | cf8dbdfcfbef5dc8092fd7ea0ce8d052edf2f35d | [
"Unlicense",
"MIT"
] | null | null | null | #ifndef _SPIRAL_INTERNET_INTERFACES_IPRODUCER_H__
#define _SPIRAL_INTERNET_INTERFACES_IPRODUCER_H__
namespace spiral {
namespace internet {
namespace interfaces {
/**
* A producer produces data for a consumer.
*
* Typically producing is done by calling the write method of an class
* implementing L{IConsumer}.
*/
class IProducer
{
public:
/**
* Stop producing data.
*
* This tells a producer that its consumer has died, so it must stop
* producing data for good.
*/
virtual void stopProducing() = 0;
virtual ~IProducer() {}
};
}}} // spiral::internet::interfaces
#endif // _SPIRAL_INTERNET_INTERFACES_IPRODUCER_H__ | 22.766667 | 75 | 0.696925 |
dc11285fb3643a34c720030219520cc39430d02a | 178 | h | C | AGL/loader.h | sherlockdoyle/AGL | e080efc7d5d3685dc686d88d4b0c3a94a23046b7 | [
"MIT"
] | 4 | 2019-12-08T16:01:33.000Z | 2022-02-02T06:46:18.000Z | AGL/loader.h | sherlockdoyle/AGL | e080efc7d5d3685dc686d88d4b0c3a94a23046b7 | [
"MIT"
] | null | null | null | AGL/loader.h | sherlockdoyle/AGL | e080efc7d5d3685dc686d88d4b0c3a94a23046b7 | [
"MIT"
] | 1 | 2021-05-31T07:15:26.000Z | 2021-05-31T07:15:26.000Z | #ifndef LOADER_H
#define LOADER_H
#include "entity.h"
namespace agl {
Entity loadObj(const char *path, bool includeNormals=false, bool includeUVs=false);
}
#endif // LOADER_H
| 16.181818 | 83 | 0.758427 |
72d3112538c28e32fd9536089f3f2ecf5d1161f0 | 2,220 | h | C | libraries/Mitov/Mitov_Microchip_ChipKIT_Basic_Shield.h | AlexRogalskiy/Duino | bef05838fe73970dea856779957fd3a3e406f295 | [
"MIT"
] | null | null | null | libraries/Mitov/Mitov_Microchip_ChipKIT_Basic_Shield.h | AlexRogalskiy/Duino | bef05838fe73970dea856779957fd3a3e406f295 | [
"MIT"
] | 1 | 2021-04-17T19:30:17.000Z | 2021-04-17T19:30:17.000Z | libraries/Mitov/Mitov_Microchip_ChipKIT_Basic_Shield.h | AlexRogalskiy/Duino | bef05838fe73970dea856779957fd3a3e406f295 | [
"MIT"
] | null | null | null | ////////////////////////////////////////////////////////////////////////////////
// //
// This software is supplied under the terms of a license agreement or //
// nondisclosure agreement with Mitov Software and may not be copied //
// or disclosed except in accordance with the terms of that agreement. //
// Copyright(c) 2002-2018 Mitov Software. All Rights Reserved. //
// //
////////////////////////////////////////////////////////////////////////////////
#ifndef _MITOV_MICROCHIP_CHIPKIT_BASIC_SHIELD_h
#define _MITOV_MICROCHIP_CHIPKIT_BASIC_SHIELD_h
#include <Mitov.h>
#ifdef __TEST_FOR_DEBUG_PRINTS__
#define Serial UNGUARDED DEBUG PRINT!!!
#endif
namespace Mitov
{
template<int C_B0, int C_B1, int C_B2, int C_B3> class Microchip_ChipKITBasicShieldButtons
{
public:
OpenWire::TypedSourcePin<bool> OutputPins[ 4 ];
public:
inline void SystemLoopBegin( unsigned long currentMicros )
{
OutputPins[ 0 ].SetValue( digitalRead( C_B0 ) != LOW, true );
OutputPins[ 1 ].SetValue( digitalRead( C_B1 ) != LOW, true );
OutputPins[ 2 ].SetValue( digitalRead( C_B2 ) != LOW, true );
OutputPins[ 3 ].SetValue( digitalRead( C_B3 ) != LOW, true );
}
inline void SystemStart()
{
OutputPins[ 0 ].SetValue( digitalRead( C_B0 ) != LOW, false );
OutputPins[ 1 ].SetValue( digitalRead( C_B1 ) != LOW, false );
OutputPins[ 2 ].SetValue( digitalRead( C_B2 ) != LOW, false );
OutputPins[ 3 ].SetValue( digitalRead( C_B3 ) != LOW, false );
}
};
//---------------------------------------------------------------------------
class Microchip_ChipKITBasicShieldLeds
{
public:
inline void InputPins_o_Receive( int AIndex, void *_Data )
{
digitalWrite( AIndex, *(bool *)_Data );
}
public:
inline void SystemStart()
{
for( int i = 26; i < 34; ++i )
{
pinMode( i, OUTPUT );
digitalWrite( i, LOW );
}
}
};
//---------------------------------------------------------------------------
}
#ifdef __TEST_FOR_DEBUG_PRINTS__
#undef Serial
#endif
#endif
| 31.714286 | 91 | 0.524775 |
f0ed1d0619890d670a1e83da99500f8ad739993a | 269,472 | h | C | libs/geGL/src/geGL/StaticCalls.h | dormon/PGRE | f8d7c46e053c6cff194f9c7deb760282c08f64da | [
"CC0-1.0"
] | null | null | null | libs/geGL/src/geGL/StaticCalls.h | dormon/PGRE | f8d7c46e053c6cff194f9c7deb760282c08f64da | [
"CC0-1.0"
] | null | null | null | libs/geGL/src/geGL/StaticCalls.h | dormon/PGRE | f8d7c46e053c6cff194f9c7deb760282c08f64da | [
"CC0-1.0"
] | null | null | null | #include<geGL/OpenGL.h>
namespace ge{
namespace gl{
GEGL_EXPORT void glMultiDrawArraysIndirectBindlessCountNV(GLenum mode,const void* indirect,GLsizei drawCount,GLsizei maxDrawCount,GLsizei stride,GLint vertexBufferCount);
GEGL_EXPORT void glTextureParameterfv(GLuint texture,GLenum pname,const GLfloat* param);
GEGL_EXPORT void glGetListParameterivSGIX(GLuint list,GLenum pname,GLint* params);
GEGL_EXPORT void glProgramUniform1i64ARB(GLuint program,GLint location,GLint64 x);
GEGL_EXPORT void glVertexArrayElementBuffer(GLuint vaobj,GLuint buffer);
GEGL_EXPORT void glHintPGI(GLenum target,GLint mode);
GEGL_EXPORT void glStencilMaskSeparate(GLenum face,GLuint mask);
GEGL_EXPORT void glGetFramebufferAttachmentParameterivEXT(GLenum target,GLenum attachment,GLenum pname,GLint* params);
GEGL_EXPORT void glTextureStorage3DMultisample(GLuint texture,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedsamplelocations);
GEGL_EXPORT void glGetIntegerIndexedvEXT(GLenum target,GLuint index,GLint* data);
GEGL_EXPORT void glCopyTexImage1D(GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLint border);
GEGL_EXPORT void glVertexAttrib4usv(GLuint index,const GLushort* v);
GEGL_EXPORT void glTexRenderbufferNV(GLenum target,GLuint renderbuffer);
GEGL_EXPORT void glVertexAttrib3hvNV(GLuint index,const GLhalfNV* v);
GEGL_EXPORT void glProgramUniform4ui64ARB(GLuint program,GLint location,GLuint64 x,GLuint64 y,GLuint64 z,GLuint64 w);
GEGL_EXPORT void glInstrumentsBufferSGIX(GLsizei size,GLint* buffer);
GEGL_EXPORT void glIndexi(GLint c);
GEGL_EXPORT void glMultiTexCoord2sARB(GLenum target,GLshort s,GLshort t);
GEGL_EXPORT void glProgramEnvParameter4fARB(GLenum target,GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w);
GEGL_EXPORT void glCompressedTexSubImage3D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,const GLvoid* data);
GEGL_EXPORT void glEvalCoord2d(GLdouble u,GLdouble v);
GEGL_EXPORT void glEvalCoord2f(GLfloat u,GLfloat v);
GEGL_EXPORT void glIndexd(GLdouble c);
GEGL_EXPORT void glSecondaryColor3hvNV(const GLhalfNV* v);
GEGL_EXPORT void glIndexf(GLfloat c);
GEGL_EXPORT void glFrustumxOES(GLfixed l,GLfixed r,GLfixed b,GLfixed t,GLfixed n,GLfixed f);
GEGL_EXPORT void glTextureStorage3DEXT(GLuint texture,GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth);
GEGL_EXPORT void glDrawCommandsStatesNV(GLuint buffer,const GLintptr* indirects,const GLsizei* sizes,const GLuint* states,const GLuint* fbos,GLuint count);
GEGL_EXPORT void glUniform4uiEXT(GLint location,GLuint v0,GLuint v1,GLuint v2,GLuint v3);
GEGL_EXPORT void glProgramUniform3ui64ARB(GLuint program,GLint location,GLuint64 x,GLuint64 y,GLuint64 z);
GEGL_EXPORT void glIndexs(GLshort c);
GEGL_EXPORT void glVertexArrayBindVertexBufferEXT(GLuint vaobj,GLuint bindingindex,GLuint buffer,GLintptr offset,GLsizei stride);
GEGL_EXPORT void glConvolutionParameteriEXT(GLenum target,GLenum pname,GLint params);
GEGL_EXPORT void glColor4ubVertex2fSUN(GLubyte r,GLubyte g,GLubyte b,GLubyte a,GLfloat x,GLfloat y);
GEGL_EXPORT void glProgramUniform1ivEXT(GLuint program,GLint location,GLsizei count,const GLint* value);
GEGL_EXPORT void glGetnMapfv(GLenum target,GLenum query,GLsizei bufSize,GLfloat* v);
GEGL_EXPORT void glTransformFeedbackBufferRange(GLuint xfb,GLuint index,GLuint buffer,GLintptr offset,GLsizeiptr size);
GEGL_EXPORT void glPathGlyphsNV(GLuint firstPathName,GLenum fontTarget,const void* fontName,GLbitfield fontStyle,GLsizei numGlyphs,GLenum type,const void* charcodes,GLenum handleMissingGlyphs,GLuint pathParameterTemplate,GLfloat emScale);
GEGL_EXPORT void glSecondaryColor3fv(const GLfloat* v);
GEGL_EXPORT void glGetCombinerInputParameterivNV(GLenum stage,GLenum portion,GLenum variable,GLenum pname,GLint* params);
GEGL_EXPORT void glEndPerfMonitorAMD(GLuint monitor);
GEGL_EXPORT void glPointParameterfvARB(GLenum pname,const GLfloat* params);
GEGL_EXPORT void glVertex2xOES(GLfixed x);
GEGL_EXPORT void glDrawElementsInstancedBaseInstance(GLenum mode,GLsizei count,GLenum type,const void* indices,GLsizei instancecount,GLuint baseinstance);
GEGL_EXPORT void glMultTransposeMatrixdARB(const GLdouble* m);
GEGL_EXPORT void glVertexAttribL4dEXT(GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w);
GEGL_EXPORT void glVertex4iv(const GLint* v);
GEGL_EXPORT void glCoverStrokePathInstancedNV(GLsizei numPaths,GLenum pathNameType,const void* paths,GLuint pathBase,GLenum coverMode,GLenum transformType,const GLfloat* transformValues);
GEGL_EXPORT void glDeformSGIX(GLbitfield mask);
GEGL_EXPORT void glUniform2ui64NV(GLint location,GLuint64EXT x,GLuint64EXT y);
GEGL_EXPORT void glCopyPathNV(GLuint resultPath,GLuint srcPath);
GEGL_EXPORT void glVertexAttribP4ui(GLuint index,GLenum type,GLboolean normalized,GLuint value);
GEGL_EXPORT void glVertexAttribL2d(GLuint index,GLdouble x,GLdouble y);
GEGL_EXPORT void glGetMultisamplefv(GLenum pname,GLuint index,GLfloat* val);
GEGL_EXPORT void glCompressedMultiTexSubImage3DEXT(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,const void* bits);
GEGL_EXPORT GLvdpauSurfaceNV glVDPAURegisterOutputSurfaceNV(const void* vdpSurface,GLenum target,GLsizei numTextureNames,const GLuint* textureNames);
GEGL_EXPORT void glMinSampleShading(GLfloat value);
GEGL_EXPORT void glProgramUniform4fEXT(GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3);
GEGL_EXPORT void glCoverStrokePathNV(GLuint path,GLenum coverMode);
GEGL_EXPORT void glTextureImage2DMultisampleNV(GLuint texture,GLenum target,GLsizei samples,GLint internalFormat,GLsizei width,GLsizei height,GLboolean fixedSampleLocations);
GEGL_EXPORT void glVertex3bOES(GLbyte x,GLbyte y,GLbyte z);
GEGL_EXPORT void glImportMemoryWin32HandleEXT(GLuint memory,GLuint64 size,GLenum handleType,void* handle);
GEGL_EXPORT void glTessellationFactorAMD(GLfloat factor);
GEGL_EXPORT void glDebugMessageControl(GLenum source,GLenum type,GLenum severity,GLsizei count,const GLuint* ids,GLboolean enabled);
GEGL_EXPORT GLboolean glIsObjectBufferATI(GLuint buffer);
GEGL_EXPORT void glPopAttrib();
GEGL_EXPORT void glProgramUniform4iEXT(GLuint program,GLint location,GLint v0,GLint v1,GLint v2,GLint v3);
GEGL_EXPORT void glVertexAttrib4ubNV(GLuint index,GLubyte x,GLubyte y,GLubyte z,GLubyte w);
GEGL_EXPORT void glColorMaterial(GLenum face,GLenum mode);
GEGL_EXPORT void glVertexAttrib2svARB(GLuint index,const GLshort* v);
GEGL_EXPORT void glMinSampleShadingARB(GLfloat value);
GEGL_EXPORT void glColor3b(GLbyte red,GLbyte green,GLbyte blue);
GEGL_EXPORT void glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(GLuint rc,GLfloat s,GLfloat t,GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glColor3f(GLfloat red,GLfloat green,GLfloat blue);
GEGL_EXPORT void glVDPAUGetSurfaceivNV(GLvdpauSurfaceNV surface,GLenum pname,GLsizei bufSize,GLsizei* length,GLint* values);
GEGL_EXPORT void glColor3d(GLdouble red,GLdouble green,GLdouble blue);
GEGL_EXPORT void glGetnMapiv(GLenum target,GLenum query,GLsizei bufSize,GLint* v);
GEGL_EXPORT void glColor3i(GLint red,GLint green,GLint blue);
GEGL_EXPORT void glGetInternalformatSampleivNV(GLenum target,GLenum internalformat,GLsizei samples,GLenum pname,GLsizei bufSize,GLint* params);
GEGL_EXPORT void glVertexAttrib4ubv(GLuint index,const GLubyte* v);
GEGL_EXPORT void glColor3s(GLshort red,GLshort green,GLshort blue);
GEGL_EXPORT void glVertexAttribs4hvNV(GLuint index,GLsizei n,const GLhalfNV* v);
GEGL_EXPORT void glVertexAttrib4NubvARB(GLuint index,const GLubyte* v);
GEGL_EXPORT void glMultiTexCoord3hvNV(GLenum target,const GLhalfNV* v);
GEGL_EXPORT void glMatrixPushEXT(GLenum mode);
GEGL_EXPORT void glProgramUniform2fEXT(GLuint program,GLint location,GLfloat v0,GLfloat v1);
GEGL_EXPORT void glGetVertexArrayIndexediv(GLuint vaobj,GLuint index,GLenum pname,GLint* param);
GEGL_EXPORT void glBlitFramebuffer(GLint srcX0,GLint srcY0,GLint srcX1,GLint srcY1,GLint dstX0,GLint dstY0,GLint dstX1,GLint dstY1,GLbitfield mask,GLenum filter);
GEGL_EXPORT void glMultiTexCoordP2ui(GLenum texture,GLenum type,GLuint coords);
GEGL_EXPORT void glColorPointerListIBM(GLint size,GLenum type,GLint stride,const void** pointer,GLint ptrstride);
GEGL_EXPORT void glVertexAttribL4d(GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w);
GEGL_EXPORT void glGetFragmentMaterialfvSGIX(GLenum face,GLenum pname,GLfloat* params);
GEGL_EXPORT void glVertex2iv(const GLint* v);
GEGL_EXPORT void glGetTexEnvxvOES(GLenum target,GLenum pname,GLfixed* params);
GEGL_EXPORT void glUniformMatrix3dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT void glGetVertexAttribLdvEXT(GLuint index,GLenum pname,GLdouble* params);
GEGL_EXPORT void glTexCoordP3uiv(GLenum type,const GLuint* coords);
GEGL_EXPORT void glDeformationMap3dSGIX(GLenum target,GLdouble u1,GLdouble u2,GLint ustride,GLint uorder,GLdouble v1,GLdouble v2,GLint vstride,GLint vorder,GLdouble w1,GLdouble w2,GLint wstride,GLint worder,const GLdouble* points);
GEGL_EXPORT void glResumeTransformFeedback();
GEGL_EXPORT void glInsertEventMarkerEXT(GLsizei length,const GLchar* marker);
GEGL_EXPORT void glTessellationModeAMD(GLenum mode);
GEGL_EXPORT void glDrawCommandsAddressNV(GLenum primitiveMode,const GLuint64* indirects,const GLsizei* sizes,GLuint count);
GEGL_EXPORT void glFogi(GLenum pname,GLint param);
GEGL_EXPORT void glGetTexParameterxvOES(GLenum target,GLenum pname,GLfixed* params);
GEGL_EXPORT void glVertexPointer(GLint size,GLenum type,GLsizei stride,const GLvoid* ptr);
GEGL_EXPORT void glGetPerfMonitorCounterDataAMD(GLuint monitor,GLenum pname,GLsizei dataSize,GLuint* data,GLint* bytesWritten);
GEGL_EXPORT void glFogf(GLenum pname,GLfloat param);
GEGL_EXPORT void glMultiTexCoord1d(GLenum target,GLdouble s);
GEGL_EXPORT void glMultiTexCoord1f(GLenum target,GLfloat s);
GEGL_EXPORT void glGetMultiTexParameterivEXT(GLenum texunit,GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glProgramUniformMatrix3x4fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glVertexAttribI2i(GLuint index,GLint x,GLint y);
GEGL_EXPORT void glMultiTexCoord1i(GLenum target,GLint s);
GEGL_EXPORT void glDeleteSemaphoresEXT(GLsizei n,const GLuint* semaphores);
GEGL_EXPORT void glLoadProgramNV(GLenum target,GLuint id,GLsizei len,const GLubyte* program);
GEGL_EXPORT void glWriteMaskEXT(GLuint res,GLuint in,GLenum outX,GLenum outY,GLenum outZ,GLenum outW);
GEGL_EXPORT GLenum glGetGraphicsResetStatus();
GEGL_EXPORT void glVertexAttrib1fv(GLuint index,const GLfloat* v);
GEGL_EXPORT void glMultiTexCoord1s(GLenum target,GLshort s);
GEGL_EXPORT void glImageTransformParameterfvHP(GLenum target,GLenum pname,const GLfloat* params);
GEGL_EXPORT void glFramebufferTexture2D(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level);
GEGL_EXPORT void glGetFragmentLightfvSGIX(GLenum light,GLenum pname,GLfloat* params);
GEGL_EXPORT void glListParameterfSGIX(GLuint list,GLenum pname,GLfloat param);
GEGL_EXPORT void glTexCoord3sv(const GLshort* v);
GEGL_EXPORT void glNamedFramebufferRenderbufferEXT(GLuint framebuffer,GLenum attachment,GLenum renderbuffertarget,GLuint renderbuffer);
GEGL_EXPORT void glFragmentLightModelfSGIX(GLenum pname,GLfloat param);
GEGL_EXPORT void glIndexPointerEXT(GLenum type,GLsizei stride,GLsizei count,const void* pointer);
GEGL_EXPORT void glBlendEquationSeparateATI(GLenum modeRGB,GLenum modeA);
GEGL_EXPORT void glVertexArrayAttribIFormat(GLuint vaobj,GLuint attribindex,GLint size,GLenum type,GLuint relativeoffset);
GEGL_EXPORT void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(GLuint rc,GLfloat s,GLfloat t,GLfloat r,GLfloat g,GLfloat b,GLfloat a,GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glReplacementCodeubvSUN(const GLubyte* code);
GEGL_EXPORT void glGenFramebuffers(GLsizei n,GLuint* framebuffers);
GEGL_EXPORT void glPixelMapx(GLenum map,GLint size,const GLfixed* values);
GEGL_EXPORT void glTexSubImage3DEXT(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,const void* pixels);
GEGL_EXPORT void glGetAttachedShaders(GLuint program,GLsizei maxCount,GLsizei* count,GLuint* shaders);
GEGL_EXPORT void glGetPixelTexGenParameterfvSGIS(GLenum pname,GLfloat* params);
GEGL_EXPORT void glReplacementCodeuiNormal3fVertex3fSUN(GLuint rc,GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT GLuint glGetDebugMessageLogAMD(GLuint count,GLsizei bufsize,GLenum* categories,GLuint* severities,GLuint* ids,GLsizei* lengths,GLchar* message);
GEGL_EXPORT void glVertexStream4sATI(GLenum stream,GLshort x,GLshort y,GLshort z,GLshort w);
GEGL_EXPORT void glVertexAttribs4dvNV(GLuint index,GLsizei count,const GLdouble* v);
GEGL_EXPORT void glGetnMapdvARB(GLenum target,GLenum query,GLsizei bufSize,GLdouble* v);
GEGL_EXPORT void glOrthofOES(GLfloat l,GLfloat r,GLfloat b,GLfloat t,GLfloat n,GLfloat f);
GEGL_EXPORT void glViewportArrayv(GLuint first,GLsizei count,const GLfloat* v);
GEGL_EXPORT void glDrawElementArrayATI(GLenum mode,GLsizei count);
GEGL_EXPORT void glBufferStorageMemEXT(GLenum target,GLsizeiptr size,GLuint memory,GLuint64 offset);
GEGL_EXPORT void glGetPathColorGenfvNV(GLenum color,GLenum pname,GLfloat* value);
GEGL_EXPORT void glWindowPos3iMESA(GLint x,GLint y,GLint z);
GEGL_EXPORT void glMultiTexCoord2s(GLenum target,GLshort s,GLshort t);
GEGL_EXPORT void glVertex3dv(const GLdouble* v);
GEGL_EXPORT void glVertexAttribI3uivEXT(GLuint index,const GLuint* v);
GEGL_EXPORT void glUniform3ui64ARB(GLint location,GLuint64 x,GLuint64 y,GLuint64 z);
GEGL_EXPORT void glVertexAttrib2fvNV(GLuint index,const GLfloat* v);
GEGL_EXPORT void glGetNamedBufferSubDataEXT(GLuint buffer,GLintptr offset,GLsizeiptr size,void* data);
GEGL_EXPORT void glConvolutionFilter2D(GLenum target,GLenum internalformat,GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid* image);
GEGL_EXPORT void glMemoryBarrierByRegion(GLbitfield barriers);
GEGL_EXPORT void glVertexArrayBindingDivisor(GLuint vaobj,GLuint bindingindex,GLuint divisor);
GEGL_EXPORT void glMatrixRotatedEXT(GLenum mode,GLdouble angle,GLdouble x,GLdouble y,GLdouble z);
GEGL_EXPORT void glTexCoord2sv(const GLshort* v);
GEGL_EXPORT GLboolean glIsProgramNV(GLuint id);
GEGL_EXPORT void glUniform2dv(GLint location,GLsizei count,const GLdouble* value);
GEGL_EXPORT void glGetPixelMapuiv(GLenum map,GLuint* values);
GEGL_EXPORT void glDepthBoundsEXT(GLclampd zmin,GLclampd zmax);
GEGL_EXPORT void glVertexAttrib4hvNV(GLuint index,const GLhalfNV* v);
GEGL_EXPORT void glMultiTexParameteriEXT(GLenum texunit,GLenum target,GLenum pname,GLint param);
GEGL_EXPORT void glGetPointerv(GLenum pname,GLvoid** params);
GEGL_EXPORT void glPathCommandsNV(GLuint path,GLsizei numCommands,const GLubyte* commands,GLsizei numCoords,GLenum coordType,const void* coords);
GEGL_EXPORT void glGetListParameterfvSGIX(GLuint list,GLenum pname,GLfloat* params);
GEGL_EXPORT void glGetUniformuiv(GLuint program,GLint location,GLuint* params);
GEGL_EXPORT void glDebugMessageInsertAMD(GLenum category,GLenum severity,GLuint id,GLsizei length,const GLchar* buf);
GEGL_EXPORT void glFrustum(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top,GLdouble near_val,GLdouble far_val);
GEGL_EXPORT void glVertexAttribL1ui64vNV(GLuint index,const GLuint64EXT* v);
GEGL_EXPORT void glClearColorxOES(GLfixed red,GLfixed green,GLfixed blue,GLfixed alpha);
GEGL_EXPORT void glProgramUniformMatrix3fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glSampleMaskIndexedNV(GLuint index,GLbitfield mask);
GEGL_EXPORT void glCompileShaderIncludeARB(GLuint shader,GLsizei count,const GLchar*const* path,const GLint* length);
GEGL_EXPORT void glGetArrayObjectfvATI(GLenum array,GLenum pname,GLfloat* params);
GEGL_EXPORT void glVertexStream4svATI(GLenum stream,const GLshort* coords);
GEGL_EXPORT void glMultiTexCoord4iARB(GLenum target,GLint s,GLint t,GLint r,GLint q);
GEGL_EXPORT void glVariantfvEXT(GLuint id,const GLfloat* addr);
GEGL_EXPORT void glMatrixLoadfEXT(GLenum mode,const GLfloat* m);
GEGL_EXPORT void glLoadIdentityDeformationMapSGIX(GLbitfield mask);
GEGL_EXPORT void glGetRenderbufferParameteriv(GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glProgramUniform3fEXT(GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2);
GEGL_EXPORT void glNamedRenderbufferStorage(GLuint renderbuffer,GLenum internalformat,GLsizei width,GLsizei height);
GEGL_EXPORT void glBindFragDataLocation(GLuint program,GLuint color,const GLchar* name);
GEGL_EXPORT void glPolygonOffsetClamp(GLfloat factor,GLfloat units,GLfloat clamp);
GEGL_EXPORT void glFogCoordPointerListIBM(GLenum type,GLint stride,const void** pointer,GLint ptrstride);
GEGL_EXPORT GLsync glFenceSync(GLenum condition,GLbitfield flags);
GEGL_EXPORT void glGetVertexAttribIivEXT(GLuint index,GLenum pname,GLint* params);
GEGL_EXPORT void glFramebufferDrawBuffersEXT(GLuint framebuffer,GLsizei n,const GLenum* bufs);
GEGL_EXPORT void glVertexAttribs4fvNV(GLuint index,GLsizei count,const GLfloat* v);
GEGL_EXPORT void glPauseTransformFeedbackNV();
GEGL_EXPORT void glGetQueryObjecti64vEXT(GLuint id,GLenum pname,GLint64* params);
GEGL_EXPORT void glVDPAUSurfaceAccessNV(GLvdpauSurfaceNV surface,GLenum access);
GEGL_EXPORT void glValidateProgramPipeline(GLuint pipeline);
GEGL_EXPORT void glTexPageCommitmentARB(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLboolean commit);
GEGL_EXPORT void glWindowPos3dvARB(const GLdouble* v);
GEGL_EXPORT void glStencilStrokePathInstancedNV(GLsizei numPaths,GLenum pathNameType,const void* paths,GLuint pathBase,GLint reference,GLuint mask,GLenum transformType,const GLfloat* transformValues);
GEGL_EXPORT void glFogfv(GLenum pname,const GLfloat* params);
GEGL_EXPORT void glGenQueriesARB(GLsizei n,GLuint* ids);
GEGL_EXPORT void glProgramUniform2i64NV(GLuint program,GLint location,GLint64EXT x,GLint64EXT y);
GEGL_EXPORT void glVertexP4ui(GLenum type,GLuint value);
GEGL_EXPORT void glVertexStream1ivATI(GLenum stream,const GLint* coords);
GEGL_EXPORT void glProgramEnvParameterI4iNV(GLenum target,GLuint index,GLint x,GLint y,GLint z,GLint w);
GEGL_EXPORT void glGenVertexArraysAPPLE(GLsizei n,GLuint* arrays);
GEGL_EXPORT void glDrawTransformFeedbackInstanced(GLenum mode,GLuint id,GLsizei instancecount);
GEGL_EXPORT void glStencilThenCoverStrokePathNV(GLuint path,GLint reference,GLuint mask,GLenum coverMode);
GEGL_EXPORT void glDeleteVertexArraysAPPLE(GLsizei n,const GLuint* arrays);
GEGL_EXPORT void glGetNamedBufferParameterui64vNV(GLuint buffer,GLenum pname,GLuint64EXT* params);
GEGL_EXPORT GLbitfield glQueryMatrixxOES(GLfixed* mantissa,GLint* exponent);
GEGL_EXPORT void glSecondaryColor3usv(const GLushort* v);
GEGL_EXPORT void glTranslatexOES(GLfixed x,GLfixed y,GLfixed z);
GEGL_EXPORT void glDrawTransformFeedback(GLenum mode,GLuint id);
GEGL_EXPORT void glTexCoord2fColor4fNormal3fVertex3fvSUN(const GLfloat* tc,const GLfloat* c,const GLfloat* n,const GLfloat* v);
GEGL_EXPORT GLvdpauSurfaceNV glVDPAURegisterVideoSurfaceNV(const void* vdpSurface,GLenum target,GLsizei numTextureNames,const GLuint* textureNames);
GEGL_EXPORT void glGetTexParameterIuiv(GLenum target,GLenum pname,GLuint* params);
GEGL_EXPORT void glBindBufferBaseNV(GLenum target,GLuint index,GLuint buffer);
GEGL_EXPORT void glIndexPointer(GLenum type,GLsizei stride,const GLvoid* ptr);
GEGL_EXPORT void glGenQueryResourceTagNV(GLsizei n,GLint* tagIds);
GEGL_EXPORT void glVertexAttrib4Nbv(GLuint index,const GLbyte* v);
GEGL_EXPORT void glListParameteriSGIX(GLuint list,GLenum pname,GLint param);
GEGL_EXPORT void glBlendColorxOES(GLfixed red,GLfixed green,GLfixed blue,GLfixed alpha);
GEGL_EXPORT void glUniformui64vNV(GLint location,GLsizei count,const GLuint64EXT* value);
GEGL_EXPORT GLboolean glIsSync(GLsync sync);
GEGL_EXPORT void glGetTextureParameterivEXT(GLuint texture,GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glFogCoordhvNV(const GLhalfNV* fog);
GEGL_EXPORT void glFramebufferTextureLayerEXT(GLenum target,GLenum attachment,GLuint texture,GLint level,GLint layer);
GEGL_EXPORT void glGetObjectPtrLabel(const void* ptr,GLsizei bufSize,GLsizei* length,GLchar* label);
GEGL_EXPORT void glTextureParameteri(GLuint texture,GLenum pname,GLint param);
GEGL_EXPORT void glMultiTexCoord1fARB(GLenum target,GLfloat s);
GEGL_EXPORT void glUniformMatrix2x3dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT void glFramebufferDrawBufferEXT(GLuint framebuffer,GLenum mode);
GEGL_EXPORT void glCopyColorSubTable(GLenum target,GLsizei start,GLint x,GLint y,GLsizei width);
GEGL_EXPORT void glGetNamedFramebufferParameterfvAMD(GLuint framebuffer,GLenum pname,GLuint numsamples,GLuint pixelindex,GLsizei size,GLfloat* values);
GEGL_EXPORT void glVertexAttribL3d(GLuint index,GLdouble x,GLdouble y,GLdouble z);
GEGL_EXPORT void glFragmentMaterialfvSGIX(GLenum face,GLenum pname,const GLfloat* params);
GEGL_EXPORT void glMatrixLoadTranspose3x3fNV(GLenum matrixMode,const GLfloat* m);
GEGL_EXPORT void glDeleteNamesAMD(GLenum identifier,GLuint num,const GLuint* names);
GEGL_EXPORT void glDrawRangeElementsEXT(GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const void* indices);
GEGL_EXPORT void glOrtho(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top,GLdouble near_val,GLdouble far_val);
GEGL_EXPORT void glProgramUniform1dvEXT(GLuint program,GLint location,GLsizei count,const GLdouble* value);
GEGL_EXPORT void glColor4xOES(GLfixed red,GLfixed green,GLfixed blue,GLfixed alpha);
GEGL_EXPORT void glTexImage4DSGIS(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLsizei size4d,GLint border,GLenum format,GLenum type,const void* pixels);
GEGL_EXPORT void glProgramUniform1ui(GLuint program,GLint location,GLuint v0);
GEGL_EXPORT void glDeleteBuffersARB(GLsizei n,const GLuint* buffers);
GEGL_EXPORT GLboolean glUnmapBufferARB(GLenum target);
GEGL_EXPORT void glCopyTexImage2D(GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLsizei height,GLint border);
GEGL_EXPORT void glMaterialxOES(GLenum face,GLenum pname,GLfixed param);
GEGL_EXPORT void glProgramUniformMatrix2x4fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT GLboolean glTestObjectAPPLE(GLenum object,GLuint name);
GEGL_EXPORT void glRenderbufferStorageEXT(GLenum target,GLenum internalformat,GLsizei width,GLsizei height);
GEGL_EXPORT void glVertexAttribL1ui64ARB(GLuint index,GLuint64EXT x);
GEGL_EXPORT void glEndFragmentShaderATI();
GEGL_EXPORT void glPathParameterivNV(GLuint path,GLenum pname,const GLint* value);
GEGL_EXPORT void glUniform4uiv(GLint location,GLsizei count,const GLuint* value);
GEGL_EXPORT void glFrameZoomSGIX(GLint factor);
GEGL_EXPORT void glSecondaryColor3fEXT(GLfloat red,GLfloat green,GLfloat blue);
GEGL_EXPORT void glLGPUInterlockNVX();
GEGL_EXPORT void glVertexAttribL1dv(GLuint index,const GLdouble* v);
GEGL_EXPORT void glNormalStream3svATI(GLenum stream,const GLshort* coords);
GEGL_EXPORT void glPathStencilFuncNV(GLenum func,GLint ref,GLuint mask);
GEGL_EXPORT void glSetInvariantEXT(GLuint id,GLenum type,const void* addr);
GEGL_EXPORT void glGetTexBumpParameterivATI(GLenum pname,GLint* param);
GEGL_EXPORT void glBlendEquationSeparateEXT(GLenum modeRGB,GLenum modeAlpha);
GEGL_EXPORT void glEndOcclusionQueryNV();
GEGL_EXPORT void glScissorArrayv(GLuint first,GLsizei count,const GLint* v);
GEGL_EXPORT void glCallList(GLuint list);
GEGL_EXPORT void* glMapTexture2DINTEL(GLuint texture,GLint level,GLbitfield access,GLint* stride,GLenum* layout);
GEGL_EXPORT GLVULKANPROCNV glGetVkProcAddrNV(const GLchar* name);
GEGL_EXPORT void glPixelTransferxOES(GLenum pname,GLfixed param);
GEGL_EXPORT void glDeleteRenderbuffersEXT(GLsizei n,const GLuint* renderbuffers);
GEGL_EXPORT void glTexCoord4fColor4fNormal3fVertex4fSUN(GLfloat s,GLfloat t,GLfloat p,GLfloat q,GLfloat r,GLfloat g,GLfloat b,GLfloat a,GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z,GLfloat w);
GEGL_EXPORT void glProgramUniformMatrix4dvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT void glGetnColorTable(GLenum target,GLenum format,GLenum type,GLsizei bufSize,void* table);
GEGL_EXPORT void glFramebufferTextureLayerARB(GLenum target,GLenum attachment,GLuint texture,GLint level,GLint layer);
GEGL_EXPORT void glVertexAttribL2dvEXT(GLuint index,const GLdouble* v);
GEGL_EXPORT void glGetCombinerStageParameterfvNV(GLenum stage,GLenum pname,GLfloat* params);
GEGL_EXPORT void glMultiTexCoord1xvOES(GLenum texture,const GLfixed* coords);
GEGL_EXPORT void* glMapBuffer(GLenum target,GLenum access);
GEGL_EXPORT void glSecondaryColor3d(GLdouble red,GLdouble green,GLdouble blue);
GEGL_EXPORT void glSecondaryColor3f(GLfloat red,GLfloat green,GLfloat blue);
GEGL_EXPORT void glVertexAttribLFormat(GLuint attribindex,GLint size,GLenum type,GLuint relativeoffset);
GEGL_EXPORT void glElementPointerAPPLE(GLenum type,const void* pointer);
GEGL_EXPORT void glVertexStream1fATI(GLenum stream,GLfloat x);
GEGL_EXPORT void glCoverageModulationNV(GLenum components);
GEGL_EXPORT void glSecondaryColor3i(GLint red,GLint green,GLint blue);
GEGL_EXPORT void glDeleteSync(GLsync sync);
GEGL_EXPORT void glGetProgramParameterfvNV(GLenum target,GLuint index,GLenum pname,GLfloat* params);
GEGL_EXPORT void glMaxShaderCompilerThreadsARB(GLuint count);
GEGL_EXPORT void glUniformMatrix4x2dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT void glVertexArrayVertexAttribLOffsetEXT(GLuint vaobj,GLuint buffer,GLuint index,GLint size,GLenum type,GLsizei stride,GLintptr offset);
GEGL_EXPORT void glSecondaryColor3s(GLshort red,GLshort green,GLshort blue);
GEGL_EXPORT GLboolean glIsImageHandleResidentNV(GLuint64 handle);
GEGL_EXPORT void glUniform3iv(GLint location,GLsizei count,const GLint* value);
GEGL_EXPORT void glVertexAttribL3i64vNV(GLuint index,const GLint64EXT* v);
GEGL_EXPORT void glPolygonMode(GLenum face,GLenum mode);
GEGL_EXPORT void glFramebufferSamplePositionsfvAMD(GLenum target,GLuint numsamples,GLuint pixelindex,const GLfloat* values);
GEGL_EXPORT void glConvolutionFilter1DEXT(GLenum target,GLenum internalformat,GLsizei width,GLenum format,GLenum type,const void* image);
GEGL_EXPORT void glVertexAttrib1dvARB(GLuint index,const GLdouble* v);
GEGL_EXPORT void glTextureSubImage2DEXT(GLuint texture,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,const void* pixels);
GEGL_EXPORT GLboolean glIsVertexArrayAPPLE(GLuint array);
GEGL_EXPORT void glUseProgram(GLuint program);
GEGL_EXPORT void glLineStipple(GLint factor,GLushort pattern);
GEGL_EXPORT void glMultiTexCoord4fvARB(GLenum target,const GLfloat* v);
GEGL_EXPORT GLenum glVideoCaptureNV(GLuint video_capture_slot,GLuint* sequence_num,GLuint64EXT* capture_time);
GEGL_EXPORT void glVertexArrayVertexAttribLFormatEXT(GLuint vaobj,GLuint attribindex,GLint size,GLenum type,GLuint relativeoffset);
GEGL_EXPORT void glUniform3fvARB(GLint location,GLsizei count,const GLfloat* value);
GEGL_EXPORT void glProgramUniformMatrix3x2fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glCopyTextureSubImage3DEXT(GLuint texture,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height);
GEGL_EXPORT void glMultiTexCoord2bvOES(GLenum texture,const GLbyte* coords);
GEGL_EXPORT void glDeleteObjectARB(GLhandleARB obj);
GEGL_EXPORT void glTextureLightEXT(GLenum pname);
GEGL_EXPORT void glRasterPos3i(GLint x,GLint y,GLint z);
GEGL_EXPORT void glMultiTexCoord3dARB(GLenum target,GLdouble s,GLdouble t,GLdouble r);
GEGL_EXPORT void glNamedFramebufferTextureEXT(GLuint framebuffer,GLenum attachment,GLuint texture,GLint level);
GEGL_EXPORT void glTextureParameteriEXT(GLuint texture,GLenum target,GLenum pname,GLint param);
GEGL_EXPORT void glEvalCoord2xvOES(const GLfixed* coords);
GEGL_EXPORT void glBindVideoCaptureStreamBufferNV(GLuint video_capture_slot,GLuint stream,GLenum frame_region,GLintptrARB offset);
GEGL_EXPORT void glTexImage2DMultisampleCoverageNV(GLenum target,GLsizei coverageSamples,GLsizei colorSamples,GLint internalFormat,GLsizei width,GLsizei height,GLboolean fixedSampleLocations);
GEGL_EXPORT GLint glGetAttribLocationARB(GLhandleARB programObj,const GLcharARB* name);
GEGL_EXPORT void glDeleteShader(GLuint shader);
GEGL_EXPORT void glVertexAttrib1fARB(GLuint index,GLfloat x);
GEGL_EXPORT void glTexCoord2fColor4ubVertex3fSUN(GLfloat s,GLfloat t,GLubyte r,GLubyte g,GLubyte b,GLubyte a,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glTexCoord4fVertex4fSUN(GLfloat s,GLfloat t,GLfloat p,GLfloat q,GLfloat x,GLfloat y,GLfloat z,GLfloat w);
GEGL_EXPORT void glGetMapdv(GLenum target,GLenum query,GLdouble* v);
GEGL_EXPORT void glMapParameterfvNV(GLenum target,GLenum pname,const GLfloat* params);
GEGL_EXPORT void glTextureParameterIuiv(GLuint texture,GLenum pname,const GLuint* params);
GEGL_EXPORT void glTransformFeedbackAttribsNV(GLsizei count,const GLint* attribs,GLenum bufferMode);
GEGL_EXPORT void glFragmentLightfvSGIX(GLenum light,GLenum pname,const GLfloat* params);
GEGL_EXPORT void glWindowPos3sARB(GLshort x,GLshort y,GLshort z);
GEGL_EXPORT void glGetConvolutionParameterfv(GLenum target,GLenum pname,GLfloat* params);
GEGL_EXPORT void glCopyTexSubImage3D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height);
GEGL_EXPORT void glVertexAttribI3i(GLuint index,GLint x,GLint y,GLint z);
GEGL_EXPORT GLhandleARB glCreateShaderObjectARB(GLenum shaderType);
GEGL_EXPORT void glVertexAttribFormat(GLuint attribindex,GLint size,GLenum type,GLboolean normalized,GLuint relativeoffset);
GEGL_EXPORT void glGetProgramivARB(GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glVertexAttribI4usv(GLuint index,const GLushort* v);
GEGL_EXPORT void glTexParameterf(GLenum target,GLenum pname,GLfloat param);
GEGL_EXPORT void glVertexAttribBinding(GLuint attribindex,GLuint bindingindex);
GEGL_EXPORT void glGetHistogramParameteriv(GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glTexParameteri(GLenum target,GLenum pname,GLint param);
GEGL_EXPORT void glGetShaderSource(GLuint shader,GLsizei bufSize,GLsizei* length,GLchar* source);
GEGL_EXPORT void glVertexAttrib4s(GLuint index,GLshort x,GLshort y,GLshort z,GLshort w);
GEGL_EXPORT void glVertexAttrib4dvNV(GLuint index,const GLdouble* v);
GEGL_EXPORT void glVertexAttrib1dvNV(GLuint index,const GLdouble* v);
GEGL_EXPORT void glPopName();
GEGL_EXPORT void glTextureBufferEXT(GLuint texture,GLenum target,GLenum internalformat,GLuint buffer);
GEGL_EXPORT void glGetMultiTexImageEXT(GLenum texunit,GLenum target,GLint level,GLenum format,GLenum type,void* pixels);
GEGL_EXPORT void glGetPointerIndexedvEXT(GLenum target,GLuint index,void** data);
GEGL_EXPORT GLboolean glIsNameAMD(GLenum identifier,GLuint name);
GEGL_EXPORT void glColor4ub(GLubyte red,GLubyte green,GLubyte blue,GLubyte alpha);
GEGL_EXPORT void glBufferParameteriAPPLE(GLenum target,GLenum pname,GLint param);
GEGL_EXPORT void glColor4ui(GLuint red,GLuint green,GLuint blue,GLuint alpha);
GEGL_EXPORT void glGetInternalformativ(GLenum target,GLenum internalformat,GLenum pname,GLsizei bufSize,GLint* params);
GEGL_EXPORT void glColor4us(GLushort red,GLushort green,GLushort blue,GLushort alpha);
GEGL_EXPORT void glVertexAttribP1uiv(GLuint index,GLenum type,GLboolean normalized,const GLuint* value);
GEGL_EXPORT void glLinkProgram(GLuint program);
GEGL_EXPORT void glTexCoord3s(GLshort s,GLshort t,GLshort r);
GEGL_EXPORT void glTexCoord2dv(const GLdouble* v);
GEGL_EXPORT void glGetObjectLabel(GLenum identifier,GLuint name,GLsizei bufSize,GLsizei* length,GLchar* label);
GEGL_EXPORT void glVertexPointerEXT(GLint size,GLenum type,GLsizei stride,GLsizei count,const void* pointer);
GEGL_EXPORT void glDebugMessageCallbackARB(GLDEBUGPROCARB callback,const void* userParam);
GEGL_EXPORT const GLubyte* glGetString(GLenum name);
GEGL_EXPORT void glGetPathParameterfvNV(GLuint path,GLenum pname,GLfloat* value);
GEGL_EXPORT void glLightxvOES(GLenum light,GLenum pname,const GLfixed* params);
GEGL_EXPORT void glEndQuery(GLenum target);
GEGL_EXPORT void glSecondaryColor3uiv(const GLuint* v);
GEGL_EXPORT void glPrioritizeTexturesxOES(GLsizei n,const GLuint* textures,const GLfixed* priorities);
GEGL_EXPORT void glEdgeFlagPointer(GLsizei stride,const GLvoid* ptr);
GEGL_EXPORT void glFramebufferParameteri(GLenum target,GLenum pname,GLint param);
GEGL_EXPORT void glTexCoord3hNV(GLhalfNV s,GLhalfNV t,GLhalfNV r);
GEGL_EXPORT void glMultiModeDrawElementsIBM(const GLenum* mode,const GLsizei* count,GLenum type,const void*const* indices,GLsizei primcount,GLint modestride);
GEGL_EXPORT void glCopyPixels(GLint x,GLint y,GLsizei width,GLsizei height,GLenum type);
GEGL_EXPORT void glVertexAttribI2ui(GLuint index,GLuint x,GLuint y);
GEGL_EXPORT void glClampColorARB(GLenum target,GLenum clamp);
GEGL_EXPORT void glColorPointervINTEL(GLint size,GLenum type,const void** pointer);
GEGL_EXPORT void glDeleteTextures(GLsizei n,const GLuint* textures);
GEGL_EXPORT void glGetMinmaxParameterfvEXT(GLenum target,GLenum pname,GLfloat* params);
GEGL_EXPORT void glWindowPos3sMESA(GLshort x,GLshort y,GLshort z);
GEGL_EXPORT void glVertexAttrib4f(GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w);
GEGL_EXPORT void glNamedFramebufferParameteri(GLuint framebuffer,GLenum pname,GLint param);
GEGL_EXPORT void glTexCoord2fVertex3fvSUN(const GLfloat* tc,const GLfloat* v);
GEGL_EXPORT void glReplacementCodeusSUN(GLushort code);
GEGL_EXPORT void glGetNamedFramebufferParameteriv(GLuint framebuffer,GLenum pname,GLint* param);
GEGL_EXPORT void glVertexStream1fvATI(GLenum stream,const GLfloat* coords);
GEGL_EXPORT void glCreateVertexArrays(GLsizei n,GLuint* arrays);
GEGL_EXPORT void glBeginConditionalRender(GLuint id,GLenum mode);
GEGL_EXPORT void glGetUnsignedBytevEXT(GLenum pname,GLubyte* data);
GEGL_EXPORT void glConvolutionFilter1D(GLenum target,GLenum internalformat,GLsizei width,GLenum format,GLenum type,const GLvoid* image);
GEGL_EXPORT void glMultiTexCoord3fARB(GLenum target,GLfloat s,GLfloat t,GLfloat r);
GEGL_EXPORT void glGetQueryObjectuivARB(GLuint id,GLenum pname,GLuint* params);
GEGL_EXPORT void glScalexOES(GLfixed x,GLfixed y,GLfixed z);
GEGL_EXPORT void glSamplerParameteri(GLuint sampler,GLenum pname,GLint param);
GEGL_EXPORT void glSamplerParameterf(GLuint sampler,GLenum pname,GLfloat param);
GEGL_EXPORT void glShaderOp1EXT(GLenum op,GLuint res,GLuint arg1);
GEGL_EXPORT void glBeginVideoCaptureNV(GLuint video_capture_slot);
GEGL_EXPORT void glGetnHistogram(GLenum target,GLboolean reset,GLenum format,GLenum type,GLsizei bufSize,void* values);
GEGL_EXPORT void glUniform1d(GLint location,GLdouble x);
GEGL_EXPORT GLint glRenderMode(GLenum mode);
GEGL_EXPORT void glClearColorIiEXT(GLint red,GLint green,GLint blue,GLint alpha);
GEGL_EXPORT void glSignalSemaphoreEXT(GLuint semaphore,GLuint numBufferBarriers,const GLuint* buffers,GLuint numTextureBarriers,const GLuint* textures,const GLenum* dstLayouts);
GEGL_EXPORT void glGetCompressedTexImage(GLenum target,GLint lod,GLvoid* img);
GEGL_EXPORT void glCompressedTextureImage1DEXT(GLuint texture,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLint border,GLsizei imageSize,const void* bits);
GEGL_EXPORT void glGetActiveUniformBlockiv(GLuint program,GLuint uniformBlockIndex,GLenum pname,GLint* params);
GEGL_EXPORT void glUniform1i(GLint location,GLint v0);
GEGL_EXPORT void glMultiDrawArraysIndirectCount(GLenum mode,const void* indirect,GLintptr drawcount,GLsizei maxdrawcount,GLsizei stride);
GEGL_EXPORT void glGetTexEnvfv(GLenum target,GLenum pname,GLfloat* params);
GEGL_EXPORT void glColorTableParameterivSGI(GLenum target,GLenum pname,const GLint* params);
GEGL_EXPORT void glCullFace(GLenum mode);
GEGL_EXPORT void glDeleteFencesAPPLE(GLsizei n,const GLuint* fences);
GEGL_EXPORT void glProgramUniform4i(GLuint program,GLint location,GLint v0,GLint v1,GLint v2,GLint v3);
GEGL_EXPORT void glUniformHandleui64ARB(GLint location,GLuint64 value);
GEGL_EXPORT void glProgramUniform4f(GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3);
GEGL_EXPORT void glViewportIndexedf(GLuint index,GLfloat x,GLfloat y,GLfloat w,GLfloat h);
GEGL_EXPORT void glProgramUniform4d(GLuint program,GLint location,GLdouble v0,GLdouble v1,GLdouble v2,GLdouble v3);
GEGL_EXPORT void glTexCoord1xOES(GLfixed s);
GEGL_EXPORT void glVertexStream3ivATI(GLenum stream,const GLint* coords);
GEGL_EXPORT GLboolean glPointAlongPathNV(GLuint path,GLsizei startSegment,GLsizei numSegments,GLfloat distance,GLfloat* x,GLfloat* y,GLfloat* tangentX,GLfloat* tangentY);
GEGL_EXPORT void glEndQueryARB(GLenum target);
GEGL_EXPORT void glVDPAUMapSurfacesNV(GLsizei numSurfaces,const GLvdpauSurfaceNV* surfaces);
GEGL_EXPORT void glVertex3i(GLint x,GLint y,GLint z);
GEGL_EXPORT void glVertexAttrib4uivARB(GLuint index,const GLuint* v);
GEGL_EXPORT void glTextureStorageMem3DEXT(GLuint texture,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLuint memory,GLuint64 offset);
GEGL_EXPORT void glAttachShader(GLuint program,GLuint shader);
GEGL_EXPORT void glColor4hNV(GLhalfNV red,GLhalfNV green,GLhalfNV blue,GLhalfNV alpha);
GEGL_EXPORT void glGetFenceivNV(GLuint fence,GLenum pname,GLint* params);
GEGL_EXPORT void glTexCoord2fColor4ubVertex3fvSUN(const GLfloat* tc,const GLubyte* c,const GLfloat* v);
GEGL_EXPORT void glGetColorTable(GLenum target,GLenum format,GLenum type,GLvoid* table);
GEGL_EXPORT void glFogCoordPointer(GLenum type,GLsizei stride,const void* pointer);
GEGL_EXPORT void glTexStorageSparseAMD(GLenum target,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLsizei layers,GLbitfield flags);
GEGL_EXPORT GLboolean glUnmapNamedBuffer(GLuint buffer);
GEGL_EXPORT void glTexCoord4bvOES(const GLbyte* coords);
GEGL_EXPORT void glVertexAttrib3fARB(GLuint index,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glRasterPos2xOES(GLfixed x,GLfixed y);
GEGL_EXPORT void glCreateMemoryObjectsEXT(GLsizei n,GLuint* memoryObjects);
GEGL_EXPORT void glColor4ubVertex2fvSUN(const GLubyte* c,const GLfloat* v);
GEGL_EXPORT void glSecondaryColor3dv(const GLdouble* v);
GEGL_EXPORT void glVertexAttribI4sv(GLuint index,const GLshort* v);
GEGL_EXPORT void glDrawTransformFeedbackStreamInstanced(GLenum mode,GLuint id,GLuint stream,GLsizei instancecount);
GEGL_EXPORT void glMultiTexCoord4ivARB(GLenum target,const GLint* v);
GEGL_EXPORT void glSpriteParameterfSGIX(GLenum pname,GLfloat param);
GEGL_EXPORT void glSecondaryColor3sv(const GLshort* v);
GEGL_EXPORT void glBindVideoCaptureStreamTextureNV(GLuint video_capture_slot,GLuint stream,GLenum frame_region,GLenum target,GLuint texture);
GEGL_EXPORT void glTexParameterIuiv(GLenum target,GLenum pname,const GLuint* params);
GEGL_EXPORT void glFlushPixelDataRangeNV(GLenum target);
GEGL_EXPORT void glWindowPos3fv(const GLfloat* v);
GEGL_EXPORT void glVertexAttribLFormatNV(GLuint index,GLint size,GLenum type,GLsizei stride);
GEGL_EXPORT void glLightModelfv(GLenum pname,const GLfloat* params);
GEGL_EXPORT void glGetColorTableSGI(GLenum target,GLenum format,GLenum type,void* table);
GEGL_EXPORT void glGetCompressedTexImageARB(GLenum target,GLint level,void* img);
GEGL_EXPORT void glConvolutionParameteri(GLenum target,GLenum pname,GLint params);
GEGL_EXPORT void glVertexWeighthNV(GLhalfNV weight);
GEGL_EXPORT void glColorMaskIndexedEXT(GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a);
GEGL_EXPORT void glColorMaski(GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a);
GEGL_EXPORT void glColorFragmentOp1ATI(GLenum op,GLuint dst,GLuint dstMask,GLuint dstMod,GLuint arg1,GLuint arg1Rep,GLuint arg1Mod);
GEGL_EXPORT void glVertexAttribI4ubvEXT(GLuint index,const GLubyte* v);
GEGL_EXPORT void glVertexAttrib1dNV(GLuint index,GLdouble x);
GEGL_EXPORT void glUnmapObjectBufferATI(GLuint buffer);
GEGL_EXPORT void glNamedProgramLocalParameterI4uiEXT(GLuint program,GLenum target,GLuint index,GLuint x,GLuint y,GLuint z,GLuint w);
GEGL_EXPORT void glProgramUniform1iEXT(GLuint program,GLint location,GLint v0);
GEGL_EXPORT void glDeleteQueriesARB(GLsizei n,const GLuint* ids);
GEGL_EXPORT void glWindowPos3svARB(const GLshort* v);
GEGL_EXPORT void glVertex4s(GLshort x,GLshort y,GLshort z,GLshort w);
GEGL_EXPORT void glImportMemoryWin32NameEXT(GLuint memory,GLuint64 size,GLenum handleType,const void* name);
GEGL_EXPORT void glStringMarkerGREMEDY(GLsizei len,const void* string);
GEGL_EXPORT GLboolean glIsTransformFeedback(GLuint id);
GEGL_EXPORT void glProgramUniformMatrix2x3dvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT void glGetObjectLabelEXT(GLenum type,GLuint object,GLsizei bufSize,GLsizei* length,GLchar* label);
GEGL_EXPORT void glUniformHandleui64vNV(GLint location,GLsizei count,const GLuint64* value);
GEGL_EXPORT void glRotated(GLdouble angle,GLdouble x,GLdouble y,GLdouble z);
GEGL_EXPORT GLboolean glIsProgramPipeline(GLuint pipeline);
GEGL_EXPORT void glRotatef(GLfloat angle,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glVertex4i(GLint x,GLint y,GLint z,GLint w);
GEGL_EXPORT void glGetActiveSubroutineUniformName(GLuint program,GLenum shadertype,GLuint index,GLsizei bufsize,GLsizei* length,GLchar* name);
GEGL_EXPORT void glVertexAttrib4sNV(GLuint index,GLshort x,GLshort y,GLshort z,GLshort w);
GEGL_EXPORT void glProgramLocalParameter4dvARB(GLenum target,GLuint index,const GLdouble* params);
GEGL_EXPORT void glReplacementCodeubSUN(GLubyte code);
GEGL_EXPORT void glMultiDrawElementsIndirectBindlessNV(GLenum mode,GLenum type,const void* indirect,GLsizei drawCount,GLsizei stride,GLint vertexBufferCount);
GEGL_EXPORT void glImportSemaphoreWin32HandleEXT(GLuint semaphore,GLenum handleType,void* handle);
GEGL_EXPORT void glUniformMatrix3fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glGetnMapfvARB(GLenum target,GLenum query,GLsizei bufSize,GLfloat* v);
GEGL_EXPORT void glGetnUniformfv(GLuint program,GLint location,GLsizei bufSize,GLfloat* params);
GEGL_EXPORT void glVertexAttribL2dv(GLuint index,const GLdouble* v);
GEGL_EXPORT void glVertexWeightPointerEXT(GLint size,GLenum type,GLsizei stride,const void* pointer);
GEGL_EXPORT void glTangent3sEXT(GLshort tx,GLshort ty,GLshort tz);
GEGL_EXPORT void glSecondaryColorPointer(GLint size,GLenum type,GLsizei stride,const void* pointer);
GEGL_EXPORT void glAlphaFunc(GLenum func,GLclampf ref);
GEGL_EXPORT void glGetNamedStringARB(GLint namelen,const GLchar* name,GLsizei bufSize,GLint* stringlen,GLchar* string);
GEGL_EXPORT void glTexCoord4d(GLdouble s,GLdouble t,GLdouble r,GLdouble q);
GEGL_EXPORT void glBufferPageCommitmentARB(GLenum target,GLintptr offset,GLsizeiptr size,GLboolean commit);
GEGL_EXPORT void glProgramLocalParameters4fvEXT(GLenum target,GLuint index,GLsizei count,const GLfloat* params);
GEGL_EXPORT void glStencilFunc(GLenum func,GLint ref,GLuint mask);
GEGL_EXPORT void glSemaphoreParameterui64vEXT(GLuint semaphore,GLenum pname,const GLuint64* params);
GEGL_EXPORT void glGetVertexAttribdvNV(GLuint index,GLenum pname,GLdouble* params);
GEGL_EXPORT void glTexCoord3dv(const GLdouble* v);
GEGL_EXPORT void glGetQueryBufferObjectiv(GLuint id,GLuint buffer,GLenum pname,GLintptr offset);
GEGL_EXPORT void glTexGenxOES(GLenum coord,GLenum pname,GLfixed param);
GEGL_EXPORT void glMultiTexCoord1fvARB(GLenum target,const GLfloat* v);
GEGL_EXPORT void glLightEnviSGIX(GLenum pname,GLint param);
GEGL_EXPORT void glGetProgramPipelineiv(GLuint pipeline,GLenum pname,GLint* params);
GEGL_EXPORT void glVertexStream2ivATI(GLenum stream,const GLint* coords);
GEGL_EXPORT void glGetColorTableEXT(GLenum target,GLenum format,GLenum type,void* data);
GEGL_EXPORT void glGetShaderInfoLog(GLuint shader,GLsizei bufSize,GLsizei* length,GLchar* infoLog);
GEGL_EXPORT void glGetOcclusionQueryuivNV(GLuint id,GLenum pname,GLuint* params);
GEGL_EXPORT void glInvalidateNamedFramebufferSubData(GLuint framebuffer,GLsizei numAttachments,const GLenum* attachments,GLint x,GLint y,GLsizei width,GLsizei height);
GEGL_EXPORT void glVertexAttribL1i64NV(GLuint index,GLint64EXT x);
GEGL_EXPORT void glVDPAUInitNV(const void* vdpDevice,const void* getProcAddress);
GEGL_EXPORT void glVertexAttrib1hvNV(GLuint index,const GLhalfNV* v);
GEGL_EXPORT void glVertexAttribI4i(GLuint index,GLint x,GLint y,GLint z,GLint w);
GEGL_EXPORT void glRasterPos2iv(const GLint* v);
GEGL_EXPORT void glGetIntegerui64i_vNV(GLenum value,GLuint index,GLuint64EXT* result);
GEGL_EXPORT void glUniformHandleui64NV(GLint location,GLuint64 value);
GEGL_EXPORT void glWindowPos3ivMESA(const GLint* v);
GEGL_EXPORT void glBlendEquationSeparate(GLenum modeRGB,GLenum modeAlpha);
GEGL_EXPORT void glDrawElementsInstancedARB(GLenum mode,GLsizei count,GLenum type,const void* indices,GLsizei primcount);
GEGL_EXPORT GLuint glGetSubroutineIndex(GLuint program,GLenum shadertype,const GLchar* name);
GEGL_EXPORT void glVertexAttrib2sv(GLuint index,const GLshort* v);
GEGL_EXPORT void glSamplePatternSGIS(GLenum pattern);
GEGL_EXPORT void glEGLImageTargetRenderbufferStorageOES(GLenum target,GLeglImageOES image);
GEGL_EXPORT void glPushAttrib(GLbitfield mask);
GEGL_EXPORT void glVertex3hNV(GLhalfNV x,GLhalfNV y,GLhalfNV z);
GEGL_EXPORT void glRasterPos3xvOES(const GLfixed* coords);
GEGL_EXPORT void glPathParameterfNV(GLuint path,GLenum pname,GLfloat value);
GEGL_EXPORT void glGetUniformi64vNV(GLuint program,GLint location,GLint64EXT* params);
GEGL_EXPORT void glLightiv(GLenum light,GLenum pname,const GLint* params);
GEGL_EXPORT void glMaterialxvOES(GLenum face,GLenum pname,const GLfixed* param);
GEGL_EXPORT void glNamedProgramLocalParameter4fEXT(GLuint program,GLenum target,GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w);
GEGL_EXPORT void glVertexAttribL1dEXT(GLuint index,GLdouble x);
GEGL_EXPORT void glGetnUniformdvARB(GLuint program,GLint location,GLsizei bufSize,GLdouble* params);
GEGL_EXPORT void glSecondaryColor3bEXT(GLbyte red,GLbyte green,GLbyte blue);
GEGL_EXPORT void glBeginPerfQueryINTEL(GLuint queryHandle);
GEGL_EXPORT void glProgramUniform1uivEXT(GLuint program,GLint location,GLsizei count,const GLuint* value);
GEGL_EXPORT void glImageTransformParameterivHP(GLenum target,GLenum pname,const GLint* params);
GEGL_EXPORT void glDeleteBuffers(GLsizei n,const GLuint* buffers);
GEGL_EXPORT void glBindProgramPipeline(GLuint pipeline);
GEGL_EXPORT void glScissor(GLint x,GLint y,GLsizei width,GLsizei height);
GEGL_EXPORT void glProgramUniform4fv(GLuint program,GLint location,GLsizei count,const GLfloat* value);
GEGL_EXPORT void glGetBooleanv(GLenum pname,GLboolean* params);
GEGL_EXPORT void glMaterialfv(GLenum face,GLenum pname,const GLfloat* params);
GEGL_EXPORT void glWindowPos4fvMESA(const GLfloat* v);
GEGL_EXPORT void glVertexAttribIPointerEXT(GLuint index,GLint size,GLenum type,GLsizei stride,const void* pointer);
GEGL_EXPORT void glProgramBufferParametersfvNV(GLenum target,GLuint bindingIndex,GLuint wordIndex,GLsizei count,const GLfloat* params);
GEGL_EXPORT void glAlphaFuncxOES(GLenum func,GLfixed ref);
GEGL_EXPORT void glMultiDrawArraysIndirectAMD(GLenum mode,const void* indirect,GLsizei primcount,GLsizei stride);
GEGL_EXPORT void glNormalStream3ivATI(GLenum stream,const GLint* coords);
GEGL_EXPORT void glTextureImage3DMultisampleNV(GLuint texture,GLenum target,GLsizei samples,GLint internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedSampleLocations);
GEGL_EXPORT void glProgramUniform4uivEXT(GLuint program,GLint location,GLsizei count,const GLuint* value);
GEGL_EXPORT void glReplacementCodeusvSUN(const GLushort* code);
GEGL_EXPORT GLint glPollInstrumentsSGIX(GLint* marker_p);
GEGL_EXPORT void glGetTextureLevelParameteriv(GLuint texture,GLint level,GLenum pname,GLint* params);
GEGL_EXPORT void glVertexAttribI2uiv(GLuint index,const GLuint* v);
GEGL_EXPORT void glMapControlPointsNV(GLenum target,GLuint index,GLenum type,GLsizei ustride,GLsizei vstride,GLint uorder,GLint vorder,GLboolean packed,const void* points);
GEGL_EXPORT void glColor4dv(const GLdouble* v);
GEGL_EXPORT void glInvalidateBufferSubData(GLuint buffer,GLintptr offset,GLsizeiptr length);
GEGL_EXPORT void glMultiTexCoord1hNV(GLenum target,GLhalfNV s);
GEGL_EXPORT void glPointParameterfv(GLenum pname,const GLfloat* params);
GEGL_EXPORT void glUniformMatrix2fvARB(GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glUniform2fv(GLint location,GLsizei count,const GLfloat* value);
GEGL_EXPORT void glVertexPointerListIBM(GLint size,GLenum type,GLint stride,const void** pointer,GLint ptrstride);
GEGL_EXPORT void glGetMultiTexGenfvEXT(GLenum texunit,GLenum coord,GLenum pname,GLfloat* params);
GEGL_EXPORT void glGetMinmaxEXT(GLenum target,GLboolean reset,GLenum format,GLenum type,void* values);
GEGL_EXPORT GLboolean glIsFenceNV(GLuint fence);
GEGL_EXPORT void glMatrixFrustumEXT(GLenum mode,GLdouble left,GLdouble right,GLdouble bottom,GLdouble top,GLdouble zNear,GLdouble zFar);
GEGL_EXPORT void glDispatchComputeIndirect(GLintptr indirect);
GEGL_EXPORT GLint glQueryResourceNV(GLenum queryType,GLint tagId,GLuint bufSize,GLint* buffer);
GEGL_EXPORT void glMultiTexCoord4bOES(GLenum texture,GLbyte s,GLbyte t,GLbyte r,GLbyte q);
GEGL_EXPORT void glProgramEnvParameter4dARB(GLenum target,GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w);
GEGL_EXPORT void glProgramUniform1uiEXT(GLuint program,GLint location,GLuint v0);
GEGL_EXPORT void glBindBufferRange(GLenum target,GLuint index,GLuint buffer,GLintptr offset,GLsizeiptr size);
GEGL_EXPORT void glNormal3iv(const GLint* v);
GEGL_EXPORT void glVertexAttribL3dv(GLuint index,const GLdouble* v);
GEGL_EXPORT void glGetUniformdv(GLuint program,GLint location,GLdouble* params);
GEGL_EXPORT void glGetMultiTexLevelParameterfvEXT(GLenum texunit,GLenum target,GLint level,GLenum pname,GLfloat* params);
GEGL_EXPORT void glFinalCombinerInputNV(GLenum variable,GLenum input,GLenum mapping,GLenum componentUsage);
GEGL_EXPORT void glCullParameterdvEXT(GLenum pname,GLdouble* params);
GEGL_EXPORT void glMultiTexCoord4s(GLenum target,GLshort s,GLshort t,GLshort r,GLshort q);
GEGL_EXPORT void glMapVertexAttrib1fAPPLE(GLuint index,GLuint size,GLfloat u1,GLfloat u2,GLint stride,GLint order,const GLfloat* points);
GEGL_EXPORT void glConvolutionParameterfEXT(GLenum target,GLenum pname,GLfloat params);
GEGL_EXPORT void glTexCoord1iv(const GLint* v);
GEGL_EXPORT void glProgramUniform3fvEXT(GLuint program,GLint location,GLsizei count,const GLfloat* value);
GEGL_EXPORT void glColor3uiv(const GLuint* v);
GEGL_EXPORT void glRenderGpuMaskNV(GLbitfield mask);
GEGL_EXPORT void glListBase(GLuint base);
GEGL_EXPORT void glTexCoord2bOES(GLbyte s,GLbyte t);
GEGL_EXPORT GLuint glBindMaterialParameterEXT(GLenum face,GLenum value);
GEGL_EXPORT void glGlobalAlphaFactorubSUN(GLubyte factor);
GEGL_EXPORT void glVertexAttribL1ui64NV(GLuint index,GLuint64EXT x);
GEGL_EXPORT void glPointParameterfSGIS(GLenum pname,GLfloat param);
GEGL_EXPORT void glGetImageTransformParameterivHP(GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glColorSubTableEXT(GLenum target,GLsizei start,GLsizei count,GLenum format,GLenum type,const void* data);
GEGL_EXPORT void glPixelTexGenParameterfvSGIS(GLenum pname,const GLfloat* params);
GEGL_EXPORT GLenum glClientWaitSync(GLsync sync,GLbitfield flags,GLuint64 timeout);
GEGL_EXPORT void glQueryObjectParameteruiAMD(GLenum target,GLuint id,GLenum pname,GLuint param);
GEGL_EXPORT void glVertexAttribs1fvNV(GLuint index,GLsizei count,const GLfloat* v);
GEGL_EXPORT void glVertexAttrib4NusvARB(GLuint index,const GLushort* v);
GEGL_EXPORT void glVariantPointerEXT(GLuint id,GLenum type,GLuint stride,const void* addr);
GEGL_EXPORT void glTextureBuffer(GLuint texture,GLenum internalformat,GLuint buffer);
GEGL_EXPORT void glVertexAttribI1uiEXT(GLuint index,GLuint x);
GEGL_EXPORT void glInvalidateTexImage(GLuint texture,GLint level);
GEGL_EXPORT void glProgramEnvParametersI4ivNV(GLenum target,GLuint index,GLsizei count,const GLint* params);
GEGL_EXPORT GLenum glPathGlyphIndexArrayNV(GLuint firstPathName,GLenum fontTarget,const void* fontName,GLbitfield fontStyle,GLuint firstGlyphIndex,GLsizei numGlyphs,GLuint pathParameterTemplate,GLfloat emScale);
GEGL_EXPORT void glCopyImageSubData(GLuint srcName,GLenum srcTarget,GLint srcLevel,GLint srcX,GLint srcY,GLint srcZ,GLuint dstName,GLenum dstTarget,GLint dstLevel,GLint dstX,GLint dstY,GLint dstZ,GLsizei srcWidth,GLsizei srcHeight,GLsizei srcDepth);
GEGL_EXPORT void glGetUniformSubroutineuiv(GLenum shadertype,GLint location,GLuint* params);
GEGL_EXPORT void glBindVertexBuffer(GLuint bindingindex,GLuint buffer,GLintptr offset,GLsizei stride);
GEGL_EXPORT void glMultiTexCoord1iARB(GLenum target,GLint s);
GEGL_EXPORT void glDebugMessageInsert(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar* buf);
GEGL_EXPORT void glBeginVertexShaderEXT();
GEGL_EXPORT GLboolean glIsVariantEnabledEXT(GLuint id,GLenum cap);
GEGL_EXPORT void glPassThroughxOES(GLfixed token);
GEGL_EXPORT GLboolean glIsSampler(GLuint sampler);
GEGL_EXPORT void glConservativeRasterParameterfNV(GLenum pname,GLfloat value);
GEGL_EXPORT void glMultiTexGenivEXT(GLenum texunit,GLenum coord,GLenum pname,const GLint* params);
GEGL_EXPORT void glNamedFramebufferTexture2DEXT(GLuint framebuffer,GLenum attachment,GLenum textarget,GLuint texture,GLint level);
GEGL_EXPORT void glCopyTexSubImage1D(GLenum target,GLint level,GLint xoffset,GLint x,GLint y,GLsizei width);
GEGL_EXPORT void glTexCoord1i(GLint s);
GEGL_EXPORT GLenum glCheckFramebufferStatus(GLenum target);
GEGL_EXPORT void glDrawElementArrayAPPLE(GLenum mode,GLint first,GLsizei count);
GEGL_EXPORT void glTexCoord1d(GLdouble s);
GEGL_EXPORT void glTexCoord1f(GLfloat s);
GEGL_EXPORT void glFragmentLightivSGIX(GLenum light,GLenum pname,const GLint* params);
GEGL_EXPORT void glBindImageTexture(GLuint unit,GLuint texture,GLint level,GLboolean layered,GLint layer,GLenum access,GLenum format);
GEGL_EXPORT void glTransformFeedbackVaryings(GLuint program,GLsizei count,const GLchar*const* varyings,GLenum bufferMode);
GEGL_EXPORT void glMulticastBufferSubDataNV(GLbitfield gpuMask,GLuint buffer,GLintptr offset,GLsizeiptr size,const GLvoid* data);
GEGL_EXPORT void glDrawRangeElements(GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const GLvoid* indices);
GEGL_EXPORT void glTexCoord1s(GLshort s);
GEGL_EXPORT void glBindBufferBase(GLenum target,GLuint index,GLuint buffer);
GEGL_EXPORT void glColor3bv(const GLbyte* v);
GEGL_EXPORT void glSyncTextureINTEL(GLuint texture);
GEGL_EXPORT void glCreateSamplers(GLsizei n,GLuint* samplers);
GEGL_EXPORT void glCombinerParameterfNV(GLenum pname,GLfloat param);
GEGL_EXPORT void glGetArrayObjectivATI(GLenum array,GLenum pname,GLint* params);
GEGL_EXPORT void glMultiDrawArrays(GLenum mode,const GLint* first,const GLsizei* count,GLsizei drawcount);
GEGL_EXPORT void glSampleMapATI(GLuint dst,GLuint interp,GLenum swizzle);
GEGL_EXPORT void glProgramUniform2i64ARB(GLuint program,GLint location,GLint64 x,GLint64 y);
GEGL_EXPORT void glBinormal3ivEXT(const GLint* v);
GEGL_EXPORT void glMultiDrawArraysIndirectCountARB(GLenum mode,const void* indirect,GLintptr drawcount,GLsizei maxdrawcount,GLsizei stride);
GEGL_EXPORT void glTextureStorageMem1DEXT(GLuint texture,GLsizei levels,GLenum internalFormat,GLsizei width,GLuint memory,GLuint64 offset);
GEGL_EXPORT void glWindowPos2ivMESA(const GLint* v);
GEGL_EXPORT void glTexCoordP4ui(GLenum type,GLuint coords);
GEGL_EXPORT void glMultiTexSubImage1DEXT(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLenum type,const void* pixels);
GEGL_EXPORT void glProgramUniformMatrix2x3fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glBufferDataARB(GLenum target,GLsizeiptrARB size,const void* data,GLenum usage);
GEGL_EXPORT void glVertexAttribIFormat(GLuint attribindex,GLint size,GLenum type,GLuint relativeoffset);
GEGL_EXPORT void glCreateFramebuffers(GLsizei n,GLuint* framebuffers);
GEGL_EXPORT void glNormalStream3dvATI(GLenum stream,const GLdouble* coords);
GEGL_EXPORT void glClearAccum(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha);
GEGL_EXPORT void glUniform3i64vNV(GLint location,GLsizei count,const GLint64EXT* value);
GEGL_EXPORT void glNormal3fVertex3fSUN(GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glUniform2uivEXT(GLint location,GLsizei count,const GLuint* value);
GEGL_EXPORT void glBeginQuery(GLenum target,GLuint id);
GEGL_EXPORT void glStencilThenCoverStrokePathInstancedNV(GLsizei numPaths,GLenum pathNameType,const void* paths,GLuint pathBase,GLint reference,GLuint mask,GLenum coverMode,GLenum transformType,const GLfloat* transformValues);
GEGL_EXPORT void glBindBuffer(GLenum target,GLuint buffer);
GEGL_EXPORT void glMap2d(GLenum target,GLdouble u1,GLdouble u2,GLint ustride,GLint uorder,GLdouble v1,GLdouble v2,GLint vstride,GLint vorder,const GLdouble* points);
GEGL_EXPORT void glMap2f(GLenum target,GLfloat u1,GLfloat u2,GLint ustride,GLint uorder,GLfloat v1,GLfloat v2,GLint vstride,GLint vorder,const GLfloat* points);
GEGL_EXPORT void glMakeImageHandleResidentNV(GLuint64 handle,GLenum access);
GEGL_EXPORT void glUniformMatrix2x4fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glGetMultiTexParameterfvEXT(GLenum texunit,GLenum target,GLenum pname,GLfloat* params);
GEGL_EXPORT void glDepthRangeIndexed(GLuint index,GLdouble n,GLdouble f);
GEGL_EXPORT GLboolean glIsEnabled(GLenum cap);
GEGL_EXPORT void glMatrixScalefEXT(GLenum mode,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT GLenum glGetError();
GEGL_EXPORT void glGetTexEnviv(GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT GLuint glBindTextureUnitParameterEXT(GLenum unit,GLenum value);
GEGL_EXPORT void glGetnUniformfvARB(GLuint program,GLint location,GLsizei bufSize,GLfloat* params);
GEGL_EXPORT void glReplacementCodeuiNormal3fVertex3fvSUN(const GLuint* rc,const GLfloat* n,const GLfloat* v);
GEGL_EXPORT void glDeletePerfQueryINTEL(GLuint queryHandle);
GEGL_EXPORT void glActiveVaryingNV(GLuint program,const GLchar* name);
GEGL_EXPORT void glGetActiveUniformARB(GLhandleARB programObj,GLuint index,GLsizei maxLength,GLsizei* length,GLint* size,GLenum* type,GLcharARB* name);
GEGL_EXPORT void glVertexAttribI3ivEXT(GLuint index,const GLint* v);
GEGL_EXPORT void glEvalCoord1d(GLdouble u);
GEGL_EXPORT void glNamedCopyBufferSubDataEXT(GLuint readBuffer,GLuint writeBuffer,GLintptr readOffset,GLintptr writeOffset,GLsizeiptr size);
GEGL_EXPORT void glEvalCoord1f(GLfloat u);
GEGL_EXPORT void glPixelMapfv(GLenum map,GLsizei mapsize,const GLfloat* values);
GEGL_EXPORT void glVertexAttribI1ivEXT(GLuint index,const GLint* v);
GEGL_EXPORT GLsync glCreateSyncFromCLeventARB(struct _cl_context* context,struct _cl_event* event,GLbitfield flags);
GEGL_EXPORT void glGetPixelMapusv(GLenum map,GLushort* values);
GEGL_EXPORT void glGetnColorTableARB(GLenum target,GLenum format,GLenum type,GLsizei bufSize,void* table);
GEGL_EXPORT void glAccum(GLenum op,GLfloat value);
GEGL_EXPORT void glRasterPos3sv(const GLshort* v);
GEGL_EXPORT void glTexCoord2iv(const GLint* v);
GEGL_EXPORT void glBlendFunciARB(GLuint buf,GLenum src,GLenum dst);
GEGL_EXPORT void glProgramUniform3i64vARB(GLuint program,GLint location,GLsizei count,const GLint64* value);
GEGL_EXPORT void glGetFramebufferAttachmentParameteriv(GLenum target,GLenum attachment,GLenum pname,GLint* params);
GEGL_EXPORT void glProgramUniform4ui(GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2,GLuint v3);
GEGL_EXPORT void glStencilMask(GLuint mask);
GEGL_EXPORT void glResetHistogramEXT(GLenum target);
GEGL_EXPORT void glLightxOES(GLenum light,GLenum pname,GLfixed param);
GEGL_EXPORT void glNamedBufferData(GLuint buffer,GLsizeiptr size,const void* data,GLenum usage);
GEGL_EXPORT void glVertexStream3sATI(GLenum stream,GLshort x,GLshort y,GLshort z);
GEGL_EXPORT void glVertexAttrib3fvARB(GLuint index,const GLfloat* v);
GEGL_EXPORT void glClearNamedBufferSubData(GLuint buffer,GLenum internalformat,GLintptr offset,GLsizeiptr size,GLenum format,GLenum type,const void* data);
GEGL_EXPORT void glProgramUniformHandleui64ARB(GLuint program,GLint location,GLuint64 value);
GEGL_EXPORT void glUniform3iARB(GLint location,GLint v0,GLint v1,GLint v2);
GEGL_EXPORT GLhandleARB glCreateProgramObjectARB();
GEGL_EXPORT void glMultiTexCoord1dvARB(GLenum target,const GLdouble* v);
GEGL_EXPORT void glGetObjectParameterfvARB(GLhandleARB obj,GLenum pname,GLfloat* params);
GEGL_EXPORT void glRectsv(const GLshort* v1,const GLshort* v2);
GEGL_EXPORT void glMultiTexImage2DEXT(GLenum texunit,GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,const void* pixels);
GEGL_EXPORT void glProgramUniform1i64NV(GLuint program,GLint location,GLint64EXT x);
GEGL_EXPORT void glGetObjectBufferivATI(GLuint buffer,GLenum pname,GLint* params);
GEGL_EXPORT void glUniform4i64ARB(GLint location,GLint64 x,GLint64 y,GLint64 z,GLint64 w);
GEGL_EXPORT void glReplacementCodeuiColor4ubVertex3fvSUN(const GLuint* rc,const GLubyte* c,const GLfloat* v);
GEGL_EXPORT void glBlendFuncSeparateINGR(GLenum sfactorRGB,GLenum dfactorRGB,GLenum sfactorAlpha,GLenum dfactorAlpha);
GEGL_EXPORT void glGetVideoCaptureStreamfvNV(GLuint video_capture_slot,GLuint stream,GLenum pname,GLfloat* params);
GEGL_EXPORT void glVertexAttrib2fARB(GLuint index,GLfloat x,GLfloat y);
GEGL_EXPORT void glGetTexGeniv(GLenum coord,GLenum pname,GLint* params);
GEGL_EXPORT void glPixelStorei(GLenum pname,GLint param);
GEGL_EXPORT void glGetCompressedTextureSubImage(GLuint texture,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLsizei bufSize,void* pixels);
GEGL_EXPORT void glCopyImageSubDataNV(GLuint srcName,GLenum srcTarget,GLint srcLevel,GLint srcX,GLint srcY,GLint srcZ,GLuint dstName,GLenum dstTarget,GLint dstLevel,GLint dstX,GLint dstY,GLint dstZ,GLsizei width,GLsizei height,GLsizei depth);
GEGL_EXPORT void glActiveShaderProgram(GLuint pipeline,GLuint program);
GEGL_EXPORT void glVertexStream1iATI(GLenum stream,GLint x);
GEGL_EXPORT void glPatchParameterfv(GLenum pname,const GLfloat* values);
GEGL_EXPORT GLboolean glIsFramebufferEXT(GLuint framebuffer);
GEGL_EXPORT void glTextureStorage2D(GLuint texture,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height);
GEGL_EXPORT void glProgramUniform1ui64ARB(GLuint program,GLint location,GLuint64 x);
GEGL_EXPORT void glTexBufferRange(GLenum target,GLenum internalformat,GLuint buffer,GLintptr offset,GLsizeiptr size);
GEGL_EXPORT void glGetPixelTexGenParameterivSGIS(GLenum pname,GLint* params);
GEGL_EXPORT void glTextureSubImage3DEXT(GLuint texture,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,const void* pixels);
GEGL_EXPORT void glClipControl(GLenum origin,GLenum depth);
GEGL_EXPORT void glGetProgramResourceiv(GLuint program,GLenum programInterface,GLuint index,GLsizei propCount,const GLenum* props,GLsizei bufSize,GLsizei* length,GLint* params);
GEGL_EXPORT void glMultiTexCoordP2uiv(GLenum texture,GLenum type,const GLuint* coords);
GEGL_EXPORT void glVertexAttribI3ui(GLuint index,GLuint x,GLuint y,GLuint z);
GEGL_EXPORT void glSampleMaskSGIS(GLclampf value,GLboolean invert);
GEGL_EXPORT void glVertexAttrib4NivARB(GLuint index,const GLint* v);
GEGL_EXPORT void glGlobalAlphaFactorfSUN(GLfloat factor);
GEGL_EXPORT void glBlendEquationSeparateIndexedAMD(GLuint buf,GLenum modeRGB,GLenum modeAlpha);
GEGL_EXPORT void glGetPerfCounterInfoINTEL(GLuint queryId,GLuint counterId,GLuint counterNameLength,GLchar* counterName,GLuint counterDescLength,GLchar* counterDesc,GLuint* counterOffset,GLuint* counterDataSize,GLuint* counterTypeEnum,GLuint* counterDataTypeEnum,GLuint64* rawCounterMaxValue);
GEGL_EXPORT void glDeleteProgramsNV(GLsizei n,const GLuint* programs);
GEGL_EXPORT void glPixelZoomxOES(GLfixed xfactor,GLfixed yfactor);
GEGL_EXPORT void glGetCombinerOutputParameterivNV(GLenum stage,GLenum portion,GLenum pname,GLint* params);
GEGL_EXPORT void glRasterPos2xvOES(const GLfixed* coords);
GEGL_EXPORT void glGetTexImage(GLenum target,GLint level,GLenum format,GLenum type,GLvoid* pixels);
GEGL_EXPORT void glVertexArrayVertexBuffers(GLuint vaobj,GLuint first,GLsizei count,const GLuint* buffers,const GLintptr* offsets,const GLsizei* strides);
GEGL_EXPORT void glUniform1ui64NV(GLint location,GLuint64EXT x);
GEGL_EXPORT void glProgramParameteri(GLuint program,GLenum pname,GLint value);
GEGL_EXPORT void glNormal3xOES(GLfixed nx,GLfixed ny,GLfixed nz);
GEGL_EXPORT void glGetMapfv(GLenum target,GLenum query,GLfloat* v);
GEGL_EXPORT void glVertexStream2dvATI(GLenum stream,const GLdouble* coords);
GEGL_EXPORT void glPathStencilDepthOffsetNV(GLfloat factor,GLfloat units);
GEGL_EXPORT GLboolean glIsStateNV(GLuint state);
GEGL_EXPORT void glGetIntegerui64vNV(GLenum value,GLuint64EXT* result);
GEGL_EXPORT void glGetImageTransformParameterfvHP(GLenum target,GLenum pname,GLfloat* params);
GEGL_EXPORT void glRasterPos2fv(const GLfloat* v);
GEGL_EXPORT void glVertex3xOES(GLfixed x,GLfixed y);
GEGL_EXPORT GLboolean glIsMemoryObjectEXT(GLuint memoryObject);
GEGL_EXPORT void glWeightPointerARB(GLint size,GLenum type,GLsizei stride,const void* pointer);
GEGL_EXPORT void glFinishFenceNV(GLuint fence);
GEGL_EXPORT void glDepthRangexOES(GLfixed n,GLfixed f);
GEGL_EXPORT void glEnableVertexArrayAttribEXT(GLuint vaobj,GLuint index);
GEGL_EXPORT void glProgramUniform2uivEXT(GLuint program,GLint location,GLsizei count,const GLuint* value);
GEGL_EXPORT void glGetDoubleIndexedvEXT(GLenum target,GLuint index,GLdouble* data);
GEGL_EXPORT void glWindowPos2fMESA(GLfloat x,GLfloat y);
GEGL_EXPORT void glSecondaryColor3b(GLbyte red,GLbyte green,GLbyte blue);
GEGL_EXPORT void glCopyConvolutionFilter1DEXT(GLenum target,GLenum internalformat,GLint x,GLint y,GLsizei width);
GEGL_EXPORT void glWindowPos2sv(const GLshort* v);
GEGL_EXPORT void glBindFramebufferEXT(GLenum target,GLuint framebuffer);
GEGL_EXPORT GLuint glCreateShader(GLenum type);
GEGL_EXPORT GLuint glGenPathsNV(GLsizei range);
GEGL_EXPORT void glGenRenderbuffers(GLsizei n,GLuint* renderbuffers);
GEGL_EXPORT void glCopyTexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint x,GLint y,GLsizei width,GLsizei height);
GEGL_EXPORT void glVertexAttrib4ubvARB(GLuint index,const GLubyte* v);
GEGL_EXPORT void glDrawTextureNV(GLuint texture,GLuint sampler,GLfloat x0,GLfloat y0,GLfloat x1,GLfloat y1,GLfloat z,GLfloat s0,GLfloat t0,GLfloat s1,GLfloat t1);
GEGL_EXPORT void glVertexAttribs1svNV(GLuint index,GLsizei count,const GLshort* v);
GEGL_EXPORT void glClearNamedBufferSubDataEXT(GLuint buffer,GLenum internalformat,GLsizeiptr offset,GLsizeiptr size,GLenum format,GLenum type,const void* data);
GEGL_EXPORT void glBlendFuncSeparate(GLenum sfactorRGB,GLenum dfactorRGB,GLenum sfactorAlpha,GLenum dfactorAlpha);
GEGL_EXPORT void glPointParameterfARB(GLenum pname,GLfloat param);
GEGL_EXPORT void glTexCoord2fv(const GLfloat* v);
GEGL_EXPORT void glGetVariantFloatvEXT(GLuint id,GLenum value,GLfloat* data);
GEGL_EXPORT void glVertexP2ui(GLenum type,GLuint value);
GEGL_EXPORT void glWindowPos2dMESA(GLdouble x,GLdouble y);
GEGL_EXPORT void glTexCoord4fv(const GLfloat* v);
GEGL_EXPORT void glBindFragDataLocationEXT(GLuint program,GLuint color,const GLchar* name);
GEGL_EXPORT void glCompressedTexSubImage1DARB(GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLsizei imageSize,const void* data);
GEGL_EXPORT void glGetTextureImageEXT(GLuint texture,GLenum target,GLint level,GLenum format,GLenum type,void* pixels);
GEGL_EXPORT void glFogCoordd(GLdouble coord);
GEGL_EXPORT void glPointSize(GLfloat size);
GEGL_EXPORT void glBindTextureUnit(GLuint unit,GLuint texture);
GEGL_EXPORT void glProgramEnvParameterI4uiNV(GLenum target,GLuint index,GLuint x,GLuint y,GLuint z,GLuint w);
GEGL_EXPORT void glGetProgramPipelineInfoLog(GLuint pipeline,GLsizei bufSize,GLsizei* length,GLchar* infoLog);
GEGL_EXPORT void glProgramUniform4i64vARB(GLuint program,GLint location,GLsizei count,const GLint64* value);
GEGL_EXPORT void glVertexAttrib4Nuiv(GLuint index,const GLuint* v);
GEGL_EXPORT void glGetUniformfvARB(GLhandleARB programObj,GLint location,GLfloat* params);
GEGL_EXPORT void glWaitSync(GLsync sync,GLbitfield flags,GLuint64 timeout);
GEGL_EXPORT void glUniform3i(GLint location,GLint v0,GLint v1,GLint v2);
GEGL_EXPORT void glBlendEquationSeparatei(GLuint buf,GLenum modeRGB,GLenum modeAlpha);
GEGL_EXPORT void glVertexAttrib2hvNV(GLuint index,const GLhalfNV* v);
GEGL_EXPORT void glTextureParameterivEXT(GLuint texture,GLenum target,GLenum pname,const GLint* params);
GEGL_EXPORT void glUniform3d(GLint location,GLdouble x,GLdouble y,GLdouble z);
GEGL_EXPORT void glUniform3f(GLint location,GLfloat v0,GLfloat v1,GLfloat v2);
GEGL_EXPORT void glActiveProgramEXT(GLuint program);
GEGL_EXPORT void glProgramUniform3uiv(GLuint program,GLint location,GLsizei count,const GLuint* value);
GEGL_EXPORT void glUniform3ui64vARB(GLint location,GLsizei count,const GLuint64* value);
GEGL_EXPORT void glProgramUniform1ui64vARB(GLuint program,GLint location,GLsizei count,const GLuint64* value);
GEGL_EXPORT void glTextureParameterfEXT(GLuint texture,GLenum target,GLenum pname,GLfloat param);
GEGL_EXPORT void glSetFragmentShaderConstantATI(GLuint dst,const GLfloat* value);
GEGL_EXPORT void glColorSubTable(GLenum target,GLsizei start,GLsizei count,GLenum format,GLenum type,const GLvoid* data);
GEGL_EXPORT void glReplacementCodeuiSUN(GLuint code);
GEGL_EXPORT void glStateCaptureNV(GLuint state,GLenum mode);
GEGL_EXPORT void glBindAttribLocation(GLuint program,GLuint index,const GLchar* name);
GEGL_EXPORT void glWeightusvARB(GLint size,const GLushort* weights);
GEGL_EXPORT GLint glGetFragDataIndex(GLuint program,const GLchar* name);
GEGL_EXPORT void glMultiTexCoord2xOES(GLenum texture,GLfixed s,GLfixed t);
GEGL_EXPORT void glColor3sv(const GLshort* v);
GEGL_EXPORT void glTexCoord2fVertex3fSUN(GLfloat s,GLfloat t,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glGetMemoryObjectParameterivEXT(GLuint memoryObject,GLenum pname,GLint* params);
GEGL_EXPORT void glPolygonOffsetEXT(GLfloat factor,GLfloat bias);
GEGL_EXPORT void glWeightPathsNV(GLuint resultPath,GLsizei numPaths,const GLuint* paths,const GLfloat* weights);
GEGL_EXPORT void glCombinerStageParameterfvNV(GLenum stage,GLenum pname,const GLfloat* params);
GEGL_EXPORT void glPointParameterfEXT(GLenum pname,GLfloat param);
GEGL_EXPORT void glCopyTexImage1DEXT(GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLint border);
GEGL_EXPORT void glVertex4sv(const GLshort* v);
GEGL_EXPORT void glMatrixMultfEXT(GLenum mode,const GLfloat* m);
GEGL_EXPORT void glCompressedTextureSubImage3DEXT(GLuint texture,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,const void* bits);
GEGL_EXPORT void glGetTexLevelParameterxvOES(GLenum target,GLint level,GLenum pname,GLfixed* params);
GEGL_EXPORT void glVertexAttribL3dvEXT(GLuint index,const GLdouble* v);
GEGL_EXPORT void glMultiTexCoordP4ui(GLenum texture,GLenum type,GLuint coords);
GEGL_EXPORT void glGetTextureLevelParameterivEXT(GLuint texture,GLenum target,GLint level,GLenum pname,GLint* params);
GEGL_EXPORT void glAlphaFragmentOp2ATI(GLenum op,GLuint dst,GLuint dstMod,GLuint arg1,GLuint arg1Rep,GLuint arg1Mod,GLuint arg2,GLuint arg2Rep,GLuint arg2Mod);
GEGL_EXPORT void glDeleteFramebuffers(GLsizei n,const GLuint* framebuffers);
GEGL_EXPORT void glDrawArrays(GLenum mode,GLint first,GLsizei count);
GEGL_EXPORT void glGetTransformFeedbackiv(GLuint xfb,GLenum pname,GLint* param);
GEGL_EXPORT void glGetnTexImageARB(GLenum target,GLint level,GLenum format,GLenum type,GLsizei bufSize,void* img);
GEGL_EXPORT void glClear(GLbitfield mask);
GEGL_EXPORT void glVertexArrayParameteriAPPLE(GLenum pname,GLint param);
GEGL_EXPORT void glMultiTexCoord2dvARB(GLenum target,const GLdouble* v);
GEGL_EXPORT void glGetVideoCaptureStreamdvNV(GLuint video_capture_slot,GLuint stream,GLenum pname,GLdouble* params);
GEGL_EXPORT void glFragmentLightModelivSGIX(GLenum pname,const GLint* params);
GEGL_EXPORT void glVertexAttribP2ui(GLuint index,GLenum type,GLboolean normalized,GLuint value);
GEGL_EXPORT void glMultiTexCoordPointerEXT(GLenum texunit,GLint size,GLenum type,GLsizei stride,const void* pointer);
GEGL_EXPORT void glProgramUniform3iEXT(GLuint program,GLint location,GLint v0,GLint v1,GLint v2);
GEGL_EXPORT void glTranslatef(GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glVertexAttrib4Nub(GLuint index,GLubyte x,GLubyte y,GLubyte z,GLubyte w);
GEGL_EXPORT void glTranslated(GLdouble x,GLdouble y,GLdouble z);
GEGL_EXPORT void glSamplerParameterIiv(GLuint sampler,GLenum pname,const GLint* param);
GEGL_EXPORT void glTexCoord4hNV(GLhalfNV s,GLhalfNV t,GLhalfNV r,GLhalfNV q);
GEGL_EXPORT void glDrawElementsIndirect(GLenum mode,GLenum type,const void* indirect);
GEGL_EXPORT void glDeletePerfMonitorsAMD(GLsizei n,GLuint* monitors);
GEGL_EXPORT GLboolean glIsRenderbufferEXT(GLuint renderbuffer);
GEGL_EXPORT void glDrawCommandsNV(GLenum primitiveMode,GLuint buffer,const GLintptr* indirects,const GLsizei* sizes,GLuint count);
GEGL_EXPORT void glUniform3ivARB(GLint location,GLsizei count,const GLint* value);
GEGL_EXPORT void glBufferSubData(GLenum target,GLintptr offset,GLsizeiptr size,const void* data);
GEGL_EXPORT void glSecondaryColor3bv(const GLbyte* v);
GEGL_EXPORT void glMatrixMultTransposedEXT(GLenum mode,const GLdouble* m);
GEGL_EXPORT void glRequestResidentProgramsNV(GLsizei n,const GLuint* programs);
GEGL_EXPORT void glAlphaFragmentOp1ATI(GLenum op,GLuint dst,GLuint dstMod,GLuint arg1,GLuint arg1Rep,GLuint arg1Mod);
GEGL_EXPORT void glGetQueryObjecti64v(GLuint id,GLenum pname,GLint64* params);
GEGL_EXPORT void glMatrixMult3x3fNV(GLenum matrixMode,const GLfloat* m);
GEGL_EXPORT void glColorTableParameteriv(GLenum target,GLenum pname,const GLint* params);
GEGL_EXPORT void glPathSubCommandsNV(GLuint path,GLsizei commandStart,GLsizei commandsToDelete,GLsizei numCommands,const GLubyte* commands,GLsizei numCoords,GLenum coordType,const void* coords);
GEGL_EXPORT void glGetFinalCombinerInputParameterivNV(GLenum variable,GLenum pname,GLint* params);
GEGL_EXPORT GLboolean glIsRenderbuffer(GLuint renderbuffer);
GEGL_EXPORT void glVertex3iv(const GLint* v);
GEGL_EXPORT void glTexGenfv(GLenum coord,GLenum pname,const GLfloat* params);
GEGL_EXPORT void glFrustumfOES(GLfloat l,GLfloat r,GLfloat b,GLfloat t,GLfloat n,GLfloat f);
GEGL_EXPORT void glBindVertexBuffers(GLuint first,GLsizei count,const GLuint* buffers,const GLintptr* offsets,const GLsizei* strides);
GEGL_EXPORT void glMateriali(GLenum face,GLenum pname,GLint param);
GEGL_EXPORT void glMultiTexCoord2svARB(GLenum target,const GLshort* v);
GEGL_EXPORT void glDisableVertexAttribArray(GLuint index);
GEGL_EXPORT void glWindowPos3ivARB(const GLint* v);
GEGL_EXPORT void glTexCoordFormatNV(GLint size,GLenum type,GLsizei stride);
GEGL_EXPORT void 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);
GEGL_EXPORT void glMatrixLoadTransposefEXT(GLenum mode,const GLfloat* m);
GEGL_EXPORT void glMultiTexGenfEXT(GLenum texunit,GLenum coord,GLenum pname,GLfloat param);
GEGL_EXPORT void glShaderStorageBlockBinding(GLuint program,GLuint storageBlockIndex,GLuint storageBlockBinding);
GEGL_EXPORT void glMaterialf(GLenum face,GLenum pname,GLfloat param);
GEGL_EXPORT void glReplacementCodeuiColor4fNormal3fVertex3fSUN(GLuint rc,GLfloat r,GLfloat g,GLfloat b,GLfloat a,GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT GLenum glCheckNamedFramebufferStatusEXT(GLuint framebuffer,GLenum target);
GEGL_EXPORT void glVertexArrayVertexAttribFormatEXT(GLuint vaobj,GLuint attribindex,GLint size,GLenum type,GLboolean normalized,GLuint relativeoffset);
GEGL_EXPORT void glVertex2hNV(GLhalfNV x,GLhalfNV y);
GEGL_EXPORT void glDeleteVertexShaderEXT(GLuint id);
GEGL_EXPORT void glTexImage3DEXT(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,const void* pixels);
GEGL_EXPORT void glSignalVkFenceNV(GLuint64 vkFence);
GEGL_EXPORT void glProgramLocalParameterI4ivNV(GLenum target,GLuint index,const GLint* params);
GEGL_EXPORT void glGlobalAlphaFactoriSUN(GLint factor);
GEGL_EXPORT void glTextureStorage1D(GLuint texture,GLsizei levels,GLenum internalformat,GLsizei width);
GEGL_EXPORT void glBinormal3sEXT(GLshort bx,GLshort by,GLshort bz);
GEGL_EXPORT void glGetProgramInterfaceiv(GLuint program,GLenum programInterface,GLenum pname,GLint* params);
GEGL_EXPORT void glMatrixIndexPointerARB(GLint size,GLenum type,GLsizei stride,const void* pointer);
GEGL_EXPORT void glTexCoordPointerEXT(GLint size,GLenum type,GLsizei stride,GLsizei count,const void* pointer);
GEGL_EXPORT void glMultiTexGeniEXT(GLenum texunit,GLenum coord,GLenum pname,GLint param);
GEGL_EXPORT void glVertexAttrib2fNV(GLuint index,GLfloat x,GLfloat y);
GEGL_EXPORT void glNamedProgramStringEXT(GLuint program,GLenum target,GLenum format,GLsizei len,const void* string);
GEGL_EXPORT void* glMapNamedBuffer(GLuint buffer,GLenum access);
GEGL_EXPORT void glGetMinmaxParameteriv(GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glGetnUniformdv(GLuint program,GLint location,GLsizei bufSize,GLdouble* params);
GEGL_EXPORT void glEndConditionalRenderNVX();
GEGL_EXPORT void glBinormal3fEXT(GLfloat bx,GLfloat by,GLfloat bz);
GEGL_EXPORT void glNormalStream3iATI(GLenum stream,GLint nx,GLint ny,GLint nz);
GEGL_EXPORT void glProgramBufferParametersIivNV(GLenum target,GLuint bindingIndex,GLuint wordIndex,GLsizei count,const GLint* params);
GEGL_EXPORT void glMapGrid1xOES(GLint n,GLfixed u1,GLfixed u2);
GEGL_EXPORT void glGetVertexAttribPointervARB(GLuint index,GLenum pname,void** pointer);
GEGL_EXPORT void glFlushMappedNamedBufferRangeEXT(GLuint buffer,GLintptr offset,GLsizeiptr length);
GEGL_EXPORT void glGetVertexAttribIiv(GLuint index,GLenum pname,GLint* params);
GEGL_EXPORT void glVertexP4uiv(GLenum type,const GLuint* value);
GEGL_EXPORT void glUniformui64NV(GLint location,GLuint64EXT value);
GEGL_EXPORT void glColor4fv(const GLfloat* v);
GEGL_EXPORT void glTexParameterxvOES(GLenum target,GLenum pname,const GLfixed* params);
GEGL_EXPORT void glPatchParameteri(GLenum pname,GLint value);
GEGL_EXPORT void glMap1d(GLenum target,GLdouble u1,GLdouble u2,GLint stride,GLint order,const GLdouble* points);
GEGL_EXPORT void glGetTexFilterFuncSGIS(GLenum target,GLenum filter,GLfloat* weights);
GEGL_EXPORT void glVertexStream3dATI(GLenum stream,GLdouble x,GLdouble y,GLdouble z);
GEGL_EXPORT void glVertexArrayVertexBindingDivisorEXT(GLuint vaobj,GLuint bindingindex,GLuint divisor);
GEGL_EXPORT void glMultiTexCoord3svARB(GLenum target,const GLshort* v);
GEGL_EXPORT void glBindProgramNV(GLenum target,GLuint id);
GEGL_EXPORT void glGetConvolutionParameteriv(GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glGetProgramLocalParameterfvARB(GLenum target,GLuint index,GLfloat* params);
GEGL_EXPORT GLuint glGenFragmentShadersATI(GLuint range);
GEGL_EXPORT void glTexBumpParameterivATI(GLenum pname,const GLint* param);
GEGL_EXPORT void glGetNamedFramebufferAttachmentParameteriv(GLuint framebuffer,GLenum attachment,GLenum pname,GLint* params);
GEGL_EXPORT void glGetnSeparableFilter(GLenum target,GLenum format,GLenum type,GLsizei rowBufSize,void* row,GLsizei columnBufSize,void* column,void* span);
GEGL_EXPORT void glNormal3xvOES(const GLfixed* coords);
GEGL_EXPORT void glPassTexCoordATI(GLuint dst,GLuint coord,GLenum swizzle);
GEGL_EXPORT void glFramebufferTextureFaceARB(GLenum target,GLenum attachment,GLuint texture,GLint level,GLenum face);
GEGL_EXPORT void glProgramUniform1dv(GLuint program,GLint location,GLsizei count,const GLdouble* value);
GEGL_EXPORT void glTextureStorage2DEXT(GLuint texture,GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height);
GEGL_EXPORT void glVertexArrayFogCoordOffsetEXT(GLuint vaobj,GLuint buffer,GLenum type,GLsizei stride,GLintptr offset);
GEGL_EXPORT void glDeleteNamedStringARB(GLint namelen,const GLchar* name);
GEGL_EXPORT void glMulticastGetQueryObjecti64vNV(GLuint gpu,GLuint id,GLenum pname,GLint64* params);
GEGL_EXPORT void glGenOcclusionQueriesNV(GLsizei n,GLuint* ids);
GEGL_EXPORT void glLighti(GLenum light,GLenum pname,GLint param);
GEGL_EXPORT void glTexImage1D(GLenum target,GLint level,GLint internalFormat,GLsizei width,GLint border,GLenum format,GLenum type,const GLvoid* pixels);
GEGL_EXPORT void glLightf(GLenum light,GLenum pname,GLfloat param);
GEGL_EXPORT void glClientAttribDefaultEXT(GLbitfield mask);
GEGL_EXPORT void glVertexAttrib4bvARB(GLuint index,const GLbyte* v);
GEGL_EXPORT void glVertexAttribIFormatNV(GLuint index,GLint size,GLenum type,GLsizei stride);
GEGL_EXPORT void glStencilFuncSeparate(GLenum face,GLenum func,GLint ref,GLuint mask);
GEGL_EXPORT void glGetVertexAttribfvARB(GLuint index,GLenum pname,GLfloat* params);
GEGL_EXPORT void glVertexAttrib2dNV(GLuint index,GLdouble x,GLdouble y);
GEGL_EXPORT void glProgramUniform2iEXT(GLuint program,GLint location,GLint v0,GLint v1);
GEGL_EXPORT void glClientActiveVertexStreamATI(GLenum stream);
GEGL_EXPORT void glRasterPos3xOES(GLfixed x,GLfixed y,GLfixed z);
GEGL_EXPORT void glGetMapParameterivNV(GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glSampleCoverage(GLclampf value,GLboolean invert);
GEGL_EXPORT void glClearDepthxOES(GLfixed depth);
GEGL_EXPORT void glUniformBufferEXT(GLuint program,GLint location,GLuint buffer);
GEGL_EXPORT void glTexCoord2fNormal3fVertex3fvSUN(const GLfloat* tc,const GLfloat* n,const GLfloat* v);
GEGL_EXPORT void glMulticastGetQueryObjectuivNV(GLuint gpu,GLuint id,GLenum pname,GLuint* params);
GEGL_EXPORT void glGetFirstPerfQueryIdINTEL(GLuint* queryId);
GEGL_EXPORT GLboolean glUnmapNamedBufferEXT(GLuint buffer);
GEGL_EXPORT void glGetTransformFeedbacki_v(GLuint xfb,GLenum pname,GLuint index,GLint* param);
GEGL_EXPORT void glUniform4fvARB(GLint location,GLsizei count,const GLfloat* value);
GEGL_EXPORT void glRenderbufferStorageMultisampleCoverageNV(GLenum target,GLsizei coverageSamples,GLsizei colorSamples,GLenum internalformat,GLsizei width,GLsizei height);
GEGL_EXPORT void glGetFloati_vEXT(GLenum pname,GLuint index,GLfloat* params);
GEGL_EXPORT void glBindAttribLocationARB(GLhandleARB programObj,GLuint index,const GLcharARB* name);
GEGL_EXPORT void glBufferAddressRangeNV(GLenum pname,GLuint index,GLuint64EXT address,GLsizeiptr length);
GEGL_EXPORT void glGenProgramsARB(GLsizei n,GLuint* programs);
GEGL_EXPORT void glMultiTexEnvivEXT(GLenum texunit,GLenum target,GLenum pname,const GLint* params);
GEGL_EXPORT void glSecondaryColor3uiEXT(GLuint red,GLuint green,GLuint blue);
GEGL_EXPORT void glCompressedTextureImage2DEXT(GLuint texture,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,const void* bits);
GEGL_EXPORT void glUniform2i(GLint location,GLint v0,GLint v1);
GEGL_EXPORT void glCopyTexImage2DEXT(GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLsizei height,GLint border);
GEGL_EXPORT void glUniform2d(GLint location,GLdouble x,GLdouble y);
GEGL_EXPORT void glVertexAttribL1d(GLuint index,GLdouble x);
GEGL_EXPORT void glFramebufferTextureFaceEXT(GLenum target,GLenum attachment,GLuint texture,GLint level,GLenum face);
GEGL_EXPORT void glFramebufferTextureLayer(GLenum target,GLenum attachment,GLuint texture,GLint level,GLint layer);
GEGL_EXPORT void glMultiTexCoord4bvOES(GLenum texture,const GLbyte* coords);
GEGL_EXPORT void glGetVertexArrayPointeri_vEXT(GLuint vaobj,GLuint index,GLenum pname,void** param);
GEGL_EXPORT void glNamedProgramLocalParameter4dEXT(GLuint program,GLenum target,GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w);
GEGL_EXPORT void glBinormal3bEXT(GLbyte bx,GLbyte by,GLbyte bz);
GEGL_EXPORT void glConvolutionFilter2DEXT(GLenum target,GLenum internalformat,GLsizei width,GLsizei height,GLenum format,GLenum type,const void* image);
GEGL_EXPORT void glProgramUniform2fv(GLuint program,GLint location,GLsizei count,const GLfloat* value);
GEGL_EXPORT void glColor3fVertex3fSUN(GLfloat r,GLfloat g,GLfloat b,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glNormal3fVertex3fvSUN(const GLfloat* n,const GLfloat* v);
GEGL_EXPORT void glCopyMultiTexSubImage3DEXT(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height);
GEGL_EXPORT void glProgramLocalParameterI4iNV(GLenum target,GLuint index,GLint x,GLint y,GLint z,GLint w);
GEGL_EXPORT void glProgramUniformMatrix2x4dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT GLenum glPathMemoryGlyphIndexArrayNV(GLuint firstPathName,GLenum fontTarget,GLsizeiptr fontSize,const void* fontData,GLsizei faceIndex,GLuint firstGlyphIndex,GLsizei numGlyphs,GLuint pathParameterTemplate,GLfloat emScale);
GEGL_EXPORT void glDrawArraysEXT(GLenum mode,GLint first,GLsizei count);
GEGL_EXPORT void glBlendEquationEXT(GLenum mode);
GEGL_EXPORT void glStencilOp(GLenum fail,GLenum zfail,GLenum zpass);
GEGL_EXPORT void glCopyTextureSubImage2DEXT(GLuint texture,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint x,GLint y,GLsizei width,GLsizei height);
GEGL_EXPORT void glTexEnvf(GLenum target,GLenum pname,GLfloat param);
GEGL_EXPORT void glVertexAttrib2dvNV(GLuint index,const GLdouble* v);
GEGL_EXPORT void glGenPerfMonitorsAMD(GLsizei n,GLuint* monitors);
GEGL_EXPORT void glGetInteger64i_v(GLenum target,GLuint index,GLint64* data);
GEGL_EXPORT void glGetHistogramParameterfv(GLenum target,GLenum pname,GLfloat* params);
GEGL_EXPORT void glVertexFormatNV(GLint size,GLenum type,GLsizei stride);
GEGL_EXPORT void glBlendFuncIndexedAMD(GLuint buf,GLenum src,GLenum dst);
GEGL_EXPORT void glTexEnvi(GLenum target,GLenum pname,GLint param);
GEGL_EXPORT void glMultiTexCoord1iv(GLenum target,const GLint* v);
GEGL_EXPORT GLboolean glIsEnabledi(GLenum target,GLuint index);
GEGL_EXPORT void glVertexAttribL2ui64vNV(GLuint index,const GLuint64EXT* v);
GEGL_EXPORT void glVertexAttribL4i64NV(GLuint index,GLint64EXT x,GLint64EXT y,GLint64EXT z,GLint64EXT w);
GEGL_EXPORT void glMatrixTranslatedEXT(GLenum mode,GLdouble x,GLdouble y,GLdouble z);
GEGL_EXPORT void glMakeTextureHandleResidentARB(GLuint64 handle);
GEGL_EXPORT void glMatrixMultdEXT(GLenum mode,const GLdouble* m);
GEGL_EXPORT void glBinormal3dvEXT(const GLdouble* v);
GEGL_EXPORT GLsync glImportSyncEXT(GLenum external_sync_type,GLintptr external_sync,GLbitfield flags);
GEGL_EXPORT void glGetMapiv(GLenum target,GLenum query,GLint* v);
GEGL_EXPORT void glImportSemaphoreFdEXT(GLuint semaphore,GLenum handleType,GLint fd);
GEGL_EXPORT void glMultiTexCoord4sv(GLenum target,const GLshort* v);
GEGL_EXPORT void glPNTrianglesiATI(GLenum pname,GLint param);
GEGL_EXPORT void glBindVertexArrayAPPLE(GLuint array);
GEGL_EXPORT void glObjectPtrLabel(const void* ptr,GLsizei length,const GLchar* label);
GEGL_EXPORT GLuint glGetDebugMessageLog(GLuint count,GLsizei bufSize,GLenum* sources,GLenum* types,GLuint* ids,GLenum* severities,GLsizei* lengths,GLchar* messageLog);
GEGL_EXPORT void glTrackMatrixNV(GLenum target,GLuint address,GLenum matrix,GLenum transform);
GEGL_EXPORT void glProgramPathFragmentInputGenNV(GLuint program,GLint location,GLenum genMode,GLint components,const GLfloat* coeffs);
GEGL_EXPORT void glTangent3ivEXT(const GLint* v);
GEGL_EXPORT void glGetUniformfv(GLuint program,GLint location,GLfloat* params);
GEGL_EXPORT void glSecondaryColor3ubv(const GLubyte* v);
GEGL_EXPORT void glMakeTextureHandleNonResidentNV(GLuint64 handle);
GEGL_EXPORT void glVertexAttribs4ubvNV(GLuint index,GLsizei count,const GLubyte* v);
GEGL_EXPORT void glClipPlanexOES(GLenum plane,const GLfixed* equation);
GEGL_EXPORT void glMultiTexCoord3iv(GLenum target,const GLint* v);
GEGL_EXPORT void glGetnPolygonStippleARB(GLsizei bufSize,GLubyte* pattern);
GEGL_EXPORT void glUniform2i64vNV(GLint location,GLsizei count,const GLint64EXT* value);
GEGL_EXPORT void glLightModelf(GLenum pname,GLfloat param);
GEGL_EXPORT void glDeleteMemoryObjectsEXT(GLsizei n,const GLuint* memoryObjects);
GEGL_EXPORT void glMultiTexSubImage2DEXT(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,const void* pixels);
GEGL_EXPORT void glReplacementCodeuiColor3fVertex3fSUN(GLuint rc,GLfloat r,GLfloat g,GLfloat b,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glTangent3dvEXT(const GLdouble* v);
GEGL_EXPORT void glLightModeli(GLenum pname,GLint param);
GEGL_EXPORT void glVertexWeighthvNV(const GLhalfNV* weight);
GEGL_EXPORT void glWindowPos3iv(const GLint* v);
GEGL_EXPORT void glMultiTexCoordP1uiv(GLenum texture,GLenum type,const GLuint* coords);
GEGL_EXPORT void glTransformPathNV(GLuint resultPath,GLuint srcPath,GLenum transformType,const GLfloat* transformValues);
GEGL_EXPORT void glProgramNamedParameter4dNV(GLuint id,GLsizei len,const GLubyte* name,GLdouble x,GLdouble y,GLdouble z,GLdouble w);
GEGL_EXPORT void glMultiDrawElementsIndirect(GLenum mode,GLenum type,const void* indirect,GLsizei drawcount,GLsizei stride);
GEGL_EXPORT void glProgramUniform1dEXT(GLuint program,GLint location,GLdouble x);
GEGL_EXPORT void glCallLists(GLsizei n,GLenum type,const GLvoid* lists);
GEGL_EXPORT void glNormal3hvNV(const GLhalfNV* v);
GEGL_EXPORT void glGetCombinerOutputParameterfvNV(GLenum stage,GLenum portion,GLenum pname,GLfloat* params);
GEGL_EXPORT void glVertexAttrib4sARB(GLuint index,GLshort x,GLshort y,GLshort z,GLshort w);
GEGL_EXPORT void glTexCoord3i(GLint s,GLint t,GLint r);
GEGL_EXPORT void glVertexAttribI3uiv(GLuint index,const GLuint* v);
GEGL_EXPORT void glPushDebugGroup(GLenum source,GLuint id,GLsizei length,const GLchar* message);
GEGL_EXPORT void glTexCoord3f(GLfloat s,GLfloat t,GLfloat r);
GEGL_EXPORT void glTexCoord3d(GLdouble s,GLdouble t,GLdouble r);
GEGL_EXPORT void glTexCoord2xOES(GLfixed s,GLfixed t);
GEGL_EXPORT GLushort glGetStageIndexNV(GLenum shadertype);
GEGL_EXPORT void glProgramUniform4i64vNV(GLuint program,GLint location,GLsizei count,const GLint64EXT* value);
GEGL_EXPORT void glGetNamedBufferPointervEXT(GLuint buffer,GLenum pname,void** params);
GEGL_EXPORT void glTextureBarrierNV();
GEGL_EXPORT void glColor4ubVertex3fvSUN(const GLubyte* c,const GLfloat* v);
GEGL_EXPORT GLuint glGetCommandHeaderNV(GLenum tokenID,GLuint size);
GEGL_EXPORT void glGetPerfMonitorCounterInfoAMD(GLuint group,GLuint counter,GLenum pname,void* data);
GEGL_EXPORT void glVertexAttrib1svARB(GLuint index,const GLshort* v);
GEGL_EXPORT void glCombinerParameteriNV(GLenum pname,GLint param);
GEGL_EXPORT void glMatrixMultTransposefEXT(GLenum mode,const GLfloat* m);
GEGL_EXPORT void glDetailTexFuncSGIS(GLenum target,GLsizei n,const GLfloat* points);
GEGL_EXPORT GLboolean glAreTexturesResident(GLsizei n,const GLuint* textures,GLboolean* residences);
GEGL_EXPORT void glProgramUniform2d(GLuint program,GLint location,GLdouble v0,GLdouble v1);
GEGL_EXPORT void glGetConvolutionParameterfvEXT(GLenum target,GLenum pname,GLfloat* params);
GEGL_EXPORT void glIndexPointerListIBM(GLenum type,GLint stride,const void** pointer,GLint ptrstride);
GEGL_EXPORT void glVertexAttribI4iEXT(GLuint index,GLint x,GLint y,GLint z,GLint w);
GEGL_EXPORT void glProgramUniform2f(GLuint program,GLint location,GLfloat v0,GLfloat v1);
GEGL_EXPORT void glRasterPos4sv(const GLshort* v);
GEGL_EXPORT void glColor4s(GLshort red,GLshort green,GLshort blue,GLshort alpha);
GEGL_EXPORT void glMulticastGetQueryObjectivNV(GLuint gpu,GLuint id,GLenum pname,GLint* params);
GEGL_EXPORT void glColorFragmentOp3ATI(GLenum op,GLuint dst,GLuint dstMask,GLuint dstMod,GLuint arg1,GLuint arg1Rep,GLuint arg1Mod,GLuint arg2,GLuint arg2Rep,GLuint arg2Mod,GLuint arg3,GLuint arg3Rep,GLuint arg3Mod);
GEGL_EXPORT void glResizeBuffersMESA();
GEGL_EXPORT void glGetMinmaxParameterfv(GLenum target,GLenum pname,GLfloat* params);
GEGL_EXPORT void glClientActiveTextureARB(GLenum texture);
GEGL_EXPORT void glBindVertexArray(GLuint array);
GEGL_EXPORT void glColor4b(GLbyte red,GLbyte green,GLbyte blue,GLbyte alpha);
GEGL_EXPORT void glColor4f(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha);
GEGL_EXPORT void glColor4d(GLdouble red,GLdouble green,GLdouble blue,GLdouble alpha);
GEGL_EXPORT void glColor4i(GLint red,GLint green,GLint blue,GLint alpha);
GEGL_EXPORT void glEdgeFlagFormatNV(GLsizei stride);
GEGL_EXPORT void glNamedBufferSubData(GLuint buffer,GLintptr offset,GLsizeiptr size,const void* data);
GEGL_EXPORT void glDrawElementsInstanced(GLenum mode,GLsizei count,GLenum type,const void* indices,GLsizei instancecount);
GEGL_EXPORT void glGetMultiTexParameterIivEXT(GLenum texunit,GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glVertex2dv(const GLdouble* v);
GEGL_EXPORT void glDisableVertexArrayAttribEXT(GLuint vaobj,GLuint index);
GEGL_EXPORT GLenum glObjectUnpurgeableAPPLE(GLenum objectType,GLuint name,GLenum option);
GEGL_EXPORT void glVertexAttribs2dvNV(GLuint index,GLsizei count,const GLdouble* v);
GEGL_EXPORT void glReplacementCodeuiTexCoord2fVertex3fSUN(GLuint rc,GLfloat s,GLfloat t,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glGetMapParameterfvNV(GLenum target,GLenum pname,GLfloat* params);
GEGL_EXPORT void glProgramUniform4ivEXT(GLuint program,GLint location,GLsizei count,const GLint* value);
GEGL_EXPORT void glProgramUniform3ui64vNV(GLuint program,GLint location,GLsizei count,const GLuint64EXT* value);
GEGL_EXPORT void glRectfv(const GLfloat* v1,const GLfloat* v2);
GEGL_EXPORT void glTexFilterFuncSGIS(GLenum target,GLenum filter,GLsizei n,const GLfloat* weights);
GEGL_EXPORT void glSpriteParameterfvSGIX(GLenum pname,const GLfloat* params);
GEGL_EXPORT void glCopyMultiTexImage1DEXT(GLenum texunit,GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLint border);
GEGL_EXPORT void glGetVertexAttribIuivEXT(GLuint index,GLenum pname,GLuint* params);
GEGL_EXPORT void glUniformMatrix2x4dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT GLint glGetProgramResourceLocationIndex(GLuint program,GLenum programInterface,const GLchar* name);
GEGL_EXPORT void glColor3hNV(GLhalfNV red,GLhalfNV green,GLhalfNV blue);
GEGL_EXPORT void glViewport(GLint x,GLint y,GLsizei width,GLsizei height);
GEGL_EXPORT void glProgramNamedParameter4fNV(GLuint id,GLsizei len,const GLubyte* name,GLfloat x,GLfloat y,GLfloat z,GLfloat w);
GEGL_EXPORT void glGetInvariantBooleanvEXT(GLuint id,GLenum value,GLboolean* data);
GEGL_EXPORT void glTexStorage2DMultisample(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLboolean fixedsamplelocations);
GEGL_EXPORT void glPixelStorex(GLenum pname,GLfixed param);
GEGL_EXPORT void glVertexAttribL1dvEXT(GLuint index,const GLdouble* v);
GEGL_EXPORT void glGetActiveSubroutineUniformiv(GLuint program,GLenum shadertype,GLuint index,GLenum pname,GLint* values);
GEGL_EXPORT void glVertexAttribPointerARB(GLuint index,GLint size,GLenum type,GLboolean normalized,GLsizei stride,const void* pointer);
GEGL_EXPORT void glCompressedTexSubImage2DARB(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,const void* data);
GEGL_EXPORT void glTexStorageMem1DEXT(GLenum target,GLsizei levels,GLenum internalFormat,GLsizei width,GLuint memory,GLuint64 offset);
GEGL_EXPORT void glVertex2hvNV(const GLhalfNV* v);
GEGL_EXPORT void glTexBuffer(GLenum target,GLenum internalformat,GLuint buffer);
GEGL_EXPORT void glArrayElement(GLint i);
GEGL_EXPORT void glValidateProgram(GLuint program);
GEGL_EXPORT void glPixelStoref(GLenum pname,GLfloat param);
GEGL_EXPORT void glWindowPos3dARB(GLdouble x,GLdouble y,GLdouble z);
GEGL_EXPORT void glEvalCoord1dv(const GLdouble* u);
GEGL_EXPORT void glVertexAttribs2fvNV(GLuint index,GLsizei count,const GLfloat* v);
GEGL_EXPORT void glRecti(GLint x1,GLint y1,GLint x2,GLint y2);
GEGL_EXPORT void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(const GLuint* rc,const GLfloat* tc,const GLfloat* c,const GLfloat* n,const GLfloat* v);
GEGL_EXPORT void glTexCoord1bOES(GLbyte s);
GEGL_EXPORT void glProgramUniform2i64vARB(GLuint program,GLint location,GLsizei count,const GLint64* value);
GEGL_EXPORT void glWindowPos2dARB(GLdouble x,GLdouble y);
GEGL_EXPORT void glGetProgramParameterdvNV(GLenum target,GLuint index,GLenum pname,GLdouble* params);
GEGL_EXPORT void glRectf(GLfloat x1,GLfloat y1,GLfloat x2,GLfloat y2);
GEGL_EXPORT void glRectd(GLdouble x1,GLdouble y1,GLdouble x2,GLdouble y2);
GEGL_EXPORT void glMap1xOES(GLenum target,GLfixed u1,GLfixed u2,GLint stride,GLint order,GLfixed points);
GEGL_EXPORT void glVertexAttrib3fvNV(GLuint index,const GLfloat* v);
GEGL_EXPORT void glReferencePlaneSGIX(const GLdouble* equation);
GEGL_EXPORT void glMulticastBlitFramebufferNV(GLuint srcGpu,GLuint dstGpu,GLint srcX0,GLint srcY0,GLint srcX1,GLint srcY1,GLint dstX0,GLint dstY0,GLint dstX1,GLint dstY1,GLbitfield mask,GLenum filter);
GEGL_EXPORT void glGetCombinerInputParameterfvNV(GLenum stage,GLenum portion,GLenum variable,GLenum pname,GLfloat* params);
GEGL_EXPORT GLuint64 glGetTextureSamplerHandleARB(GLuint texture,GLuint sampler);
GEGL_EXPORT void glBindTexture(GLenum target,GLuint texture);
GEGL_EXPORT void glRects(GLshort x1,GLshort y1,GLshort x2,GLshort y2);
GEGL_EXPORT void glGetActiveAttribARB(GLhandleARB programObj,GLuint index,GLsizei maxLength,GLsizei* length,GLint* size,GLenum* type,GLcharARB* name);
GEGL_EXPORT void glHistogramEXT(GLenum target,GLsizei width,GLenum internalformat,GLboolean sink);
GEGL_EXPORT GLuint64 glGetTextureSamplerHandleNV(GLuint texture,GLuint sampler);
GEGL_EXPORT void glDetachShader(GLuint program,GLuint shader);
GEGL_EXPORT void glFinishTextureSUNX();
GEGL_EXPORT void glUniformMatrix3x4dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT void glVertexAttrib4fARB(GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w);
GEGL_EXPORT void glGetPathColorGenivNV(GLenum color,GLenum pname,GLint* value);
GEGL_EXPORT GLint glGetProgramResourceLocation(GLuint program,GLenum programInterface,const GLchar* name);
GEGL_EXPORT void glVertexArrayAttribLFormat(GLuint vaobj,GLuint attribindex,GLint size,GLenum type,GLuint relativeoffset);
GEGL_EXPORT void glGetTexLevelParameterfv(GLenum target,GLint level,GLenum pname,GLfloat* params);
GEGL_EXPORT void glVertexArrayVertexAttribOffsetEXT(GLuint vaobj,GLuint buffer,GLuint index,GLint size,GLenum type,GLboolean normalized,GLsizei stride,GLintptr offset);
GEGL_EXPORT void glIndexFormatNV(GLenum type,GLsizei stride);
GEGL_EXPORT void glMultiTexCoord3i(GLenum target,GLint s,GLint t,GLint r);
GEGL_EXPORT void glReplacementCodeuiVertex3fvSUN(const GLuint* rc,const GLfloat* v);
GEGL_EXPORT void glViewportIndexedfv(GLuint index,const GLfloat* v);
GEGL_EXPORT void glBindBuffersBase(GLenum target,GLuint first,GLsizei count,const GLuint* buffers);
GEGL_EXPORT void glTexBumpParameterfvATI(GLenum pname,const GLfloat* param);
GEGL_EXPORT void glMatrixIndexuivARB(GLint size,const GLuint* indices);
GEGL_EXPORT void glVertexAttrib1hNV(GLuint index,GLhalfNV x);
GEGL_EXPORT void glWindowPos3svMESA(const GLshort* v);
GEGL_EXPORT void glStencilOpSeparateATI(GLenum face,GLenum sfail,GLenum dpfail,GLenum dppass);
GEGL_EXPORT void glDrawElementsBaseVertex(GLenum mode,GLsizei count,GLenum type,const void* indices,GLint basevertex);
GEGL_EXPORT void glBlendEquationSeparateiARB(GLuint buf,GLenum modeRGB,GLenum modeAlpha);
GEGL_EXPORT void glVertexAttrib1fNV(GLuint index,GLfloat x);
GEGL_EXPORT void glMapVertexAttrib2fAPPLE(GLuint index,GLuint size,GLfloat u1,GLfloat u2,GLint ustride,GLint uorder,GLfloat v1,GLfloat v2,GLint vstride,GLint vorder,const GLfloat* points);
GEGL_EXPORT void glCompressedTextureSubImage1DEXT(GLuint texture,GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLsizei imageSize,const void* bits);
GEGL_EXPORT void glClearBufferSubData(GLenum target,GLenum internalformat,GLintptr offset,GLsizeiptr size,GLenum format,GLenum type,const void* data);
GEGL_EXPORT void glTexStorage1D(GLenum target,GLsizei levels,GLenum internalformat,GLsizei width);
GEGL_EXPORT void glVertexAttribI3iEXT(GLuint index,GLint x,GLint y,GLint z);
GEGL_EXPORT void glMakeTextureHandleNonResidentARB(GLuint64 handle);
GEGL_EXPORT void glMultiDrawElementArrayAPPLE(GLenum mode,const GLint* first,const GLsizei* count,GLsizei primcount);
GEGL_EXPORT void glVertexStream4dATI(GLenum stream,GLdouble x,GLdouble y,GLdouble z,GLdouble w);
GEGL_EXPORT void glProgramUniformMatrix2dvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT void glVertexAttribs2hvNV(GLuint index,GLsizei n,const GLhalfNV* v);
GEGL_EXPORT void glGetUniformiv(GLuint program,GLint location,GLint* params);
GEGL_EXPORT void glClipPlanefOES(GLenum plane,const GLfloat* equation);
GEGL_EXPORT void glRenderbufferStorage(GLenum target,GLenum internalformat,GLsizei width,GLsizei height);
GEGL_EXPORT void glUniform4ui(GLint location,GLuint v0,GLuint v1,GLuint v2,GLuint v3);
GEGL_EXPORT void glBindFramebuffer(GLenum target,GLuint framebuffer);
GEGL_EXPORT void glValidateProgramARB(GLhandleARB programObj);
GEGL_EXPORT void glTexGenf(GLenum coord,GLenum pname,GLfloat param);
GEGL_EXPORT void glTexGend(GLenum coord,GLenum pname,GLdouble param);
GEGL_EXPORT void glTexGeni(GLenum coord,GLenum pname,GLint param);
GEGL_EXPORT void glDeleteFramebuffersEXT(GLsizei n,const GLuint* framebuffers);
GEGL_EXPORT void glResetMinmaxEXT(GLenum target);
GEGL_EXPORT void glVertexAttrib1fvNV(GLuint index,const GLfloat* v);
GEGL_EXPORT GLboolean glIsQueryARB(GLuint id);
GEGL_EXPORT void glEnableVariantClientStateEXT(GLuint id);
GEGL_EXPORT void glScissorIndexed(GLuint index,GLint left,GLint bottom,GLsizei width,GLsizei height);
GEGL_EXPORT void glGetInvariantIntegervEXT(GLuint id,GLenum value,GLint* data);
GEGL_EXPORT void glProgramLocalParameterI4uiNV(GLenum target,GLuint index,GLuint x,GLuint y,GLuint z,GLuint w);
GEGL_EXPORT void glConvolutionParameterxvOES(GLenum target,GLenum pname,const GLfixed* params);
GEGL_EXPORT void glGenFramebuffersEXT(GLsizei n,GLuint* framebuffers);
GEGL_EXPORT void glVertexArrayColorOffsetEXT(GLuint vaobj,GLuint buffer,GLint size,GLenum type,GLsizei stride,GLintptr offset);
GEGL_EXPORT void glMultiTexCoord3ivARB(GLenum target,const GLint* v);
GEGL_EXPORT void glVertexWeightfEXT(GLfloat weight);
GEGL_EXPORT void glRasterPos4dv(const GLdouble* v);
GEGL_EXPORT GLboolean glIsTextureHandleResidentARB(GLuint64 handle);
GEGL_EXPORT void glRasterPos2dv(const GLdouble* v);
GEGL_EXPORT void glWindowPos4ivMESA(const GLint* v);
GEGL_EXPORT void glGetVariantPointervEXT(GLuint id,GLenum value,void** data);
GEGL_EXPORT void* glMapNamedBufferRangeEXT(GLuint buffer,GLintptr offset,GLsizeiptr length,GLbitfield access);
GEGL_EXPORT void glGetnUniformui64vARB(GLuint program,GLint location,GLsizei bufSize,GLuint64* params);
GEGL_EXPORT GLuint glCreateShaderProgramv(GLenum type,GLsizei count,const GLchar*const* strings);
GEGL_EXPORT void glGetQueryObjectiv(GLuint id,GLenum pname,GLint* params);
GEGL_EXPORT void glMaxShaderCompilerThreadsKHR(GLuint count);
GEGL_EXPORT void glPNTrianglesfATI(GLenum pname,GLfloat param);
GEGL_EXPORT void glGlobalAlphaFactorusSUN(GLushort factor);
GEGL_EXPORT void glVertexAttrib3dvNV(GLuint index,const GLdouble* v);
GEGL_EXPORT void glMultiTexCoord3sARB(GLenum target,GLshort s,GLshort t,GLshort r);
GEGL_EXPORT void glGenerateMipmap(GLenum target);
GEGL_EXPORT void glCompressedTextureSubImage2D(GLuint texture,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,const void* data);
GEGL_EXPORT void glNamedRenderbufferStorageMultisampleEXT(GLuint renderbuffer,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height);
GEGL_EXPORT void glPolygonOffsetClampEXT(GLfloat factor,GLfloat units,GLfloat clamp);
GEGL_EXPORT void glTextureRangeAPPLE(GLenum target,GLsizei length,const void* pointer);
GEGL_EXPORT void glBlendEquationIndexedAMD(GLuint buf,GLenum mode);
GEGL_EXPORT void glTexCoord2d(GLdouble s,GLdouble t);
GEGL_EXPORT void glPointParameteri(GLenum pname,GLint param);
GEGL_EXPORT void glTexCoord2f(GLfloat s,GLfloat t);
GEGL_EXPORT void glGetUnsignedBytei_vEXT(GLenum target,GLuint index,GLubyte* data);
GEGL_EXPORT void glColor4iv(const GLint* v);
GEGL_EXPORT void* glMapNamedBufferRange(GLuint buffer,GLintptr offset,GLsizeiptr length,GLbitfield access);
GEGL_EXPORT GLboolean glUnmapBuffer(GLenum target);
GEGL_EXPORT void glSampleMaskEXT(GLclampf value,GLboolean invert);
GEGL_EXPORT void glTexCoord2i(GLint s,GLint t);
GEGL_EXPORT void glTexCoord1xvOES(const GLfixed* coords);
GEGL_EXPORT void glVertexAttrib1sARB(GLuint index,GLshort x);
GEGL_EXPORT void glGetVertexArrayiv(GLuint vaobj,GLenum pname,GLint* param);
GEGL_EXPORT void glProgramParameter4dvNV(GLenum target,GLuint index,const GLdouble* v);
GEGL_EXPORT void glTexCoord2s(GLshort s,GLshort t);
GEGL_EXPORT void glTextureParameterIuivEXT(GLuint texture,GLenum target,GLenum pname,const GLuint* params);
GEGL_EXPORT void glGetColorTableParameterfvSGI(GLenum target,GLenum pname,GLfloat* params);
GEGL_EXPORT void glTexCoord4dv(const GLdouble* v);
GEGL_EXPORT void glVertexAttrib1svNV(GLuint index,const GLshort* v);
GEGL_EXPORT void glNamedFramebufferTextureFaceEXT(GLuint framebuffer,GLenum attachment,GLuint texture,GLint level,GLenum face);
GEGL_EXPORT void glProgramUniform2ui64vNV(GLuint program,GLint location,GLsizei count,const GLuint64EXT* value);
GEGL_EXPORT void glStencilFillPathNV(GLuint path,GLenum fillMode,GLuint mask);
GEGL_EXPORT void glNormal3dv(const GLdouble* v);
GEGL_EXPORT void glReleaseShaderCompiler();
GEGL_EXPORT void glTexStorageMem3DEXT(GLenum target,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLuint memory,GLuint64 offset);
GEGL_EXPORT void glTexCoord3bvOES(const GLbyte* coords);
GEGL_EXPORT GLboolean glIsVertexAttribEnabledAPPLE(GLuint index,GLenum pname);
GEGL_EXPORT void glTexCoord1dv(const GLdouble* v);
GEGL_EXPORT void glReadPixels(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLvoid* pixels);
GEGL_EXPORT void glVertexAttribI3iv(GLuint index,const GLint* v);
GEGL_EXPORT void glSetFenceAPPLE(GLuint fence);
GEGL_EXPORT void glWeightsvARB(GLint size,const GLshort* weights);
GEGL_EXPORT void glShadeModel(GLenum mode);
GEGL_EXPORT void glTextureStorageMem3DMultisampleEXT(GLuint texture,GLsizei samples,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedSampleLocations,GLuint memory,GLuint64 offset);
GEGL_EXPORT void glMapGrid1d(GLint un,GLdouble u1,GLdouble u2);
GEGL_EXPORT void glGetHistogramParameterivEXT(GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glConservativeRasterParameteriNV(GLenum pname,GLint param);
GEGL_EXPORT void glClearNamedBufferData(GLuint buffer,GLenum internalformat,GLenum format,GLenum type,const void* data);
GEGL_EXPORT void glClearDepthf(GLfloat d);
GEGL_EXPORT void glCreatePerfQueryINTEL(GLuint queryId,GLuint* queryHandle);
GEGL_EXPORT void glFogCoordfEXT(GLfloat coord);
GEGL_EXPORT void glVertexAttrib2dARB(GLuint index,GLdouble x,GLdouble y);
GEGL_EXPORT void glMultiTexCoord4dARB(GLenum target,GLdouble s,GLdouble t,GLdouble r,GLdouble q);
GEGL_EXPORT void glReadnPixelsARB(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,void* data);
GEGL_EXPORT void glMultiTexBufferEXT(GLenum texunit,GLenum target,GLenum internalformat,GLuint buffer);
GEGL_EXPORT void glWindowPos4dvMESA(const GLdouble* v);
GEGL_EXPORT void glInvalidateNamedFramebufferData(GLuint framebuffer,GLsizei numAttachments,const GLenum* attachments);
GEGL_EXPORT void glSecondaryColorPointerListIBM(GLint size,GLenum type,GLint stride,const void** pointer,GLint ptrstride);
GEGL_EXPORT void glRectiv(const GLint* v1,const GLint* v2);
GEGL_EXPORT void glColorP4ui(GLenum type,GLuint color);
GEGL_EXPORT void glUseProgramStages(GLuint pipeline,GLbitfield stages,GLuint program);
GEGL_EXPORT void glRasterPos3dv(const GLdouble* v);
GEGL_EXPORT void glPathTexGenNV(GLenum texCoordSet,GLenum genMode,GLint components,const GLfloat* coeffs);
GEGL_EXPORT void glVertexBlendEnviATI(GLenum pname,GLint param);
GEGL_EXPORT void glUniform3i64ARB(GLint location,GLint64 x,GLint64 y,GLint64 z);
GEGL_EXPORT void glLoadMatrixf(const GLfloat* m);
GEGL_EXPORT void glProgramUniform2dEXT(GLuint program,GLint location,GLdouble x,GLdouble y);
GEGL_EXPORT void glVertexAttribI4iv(GLuint index,const GLint* v);
GEGL_EXPORT void glNamedFramebufferDrawBuffer(GLuint framebuffer,GLenum buf);
GEGL_EXPORT void glColor4ubv(const GLubyte* v);
GEGL_EXPORT void glColor3hvNV(const GLhalfNV* v);
GEGL_EXPORT void glGetMapAttribParameterfvNV(GLenum target,GLuint index,GLenum pname,GLfloat* params);
GEGL_EXPORT void glGetBufferSubData(GLenum target,GLintptr offset,GLsizeiptr size,void* data);
GEGL_EXPORT void glGetVertexAttribLdv(GLuint index,GLenum pname,GLdouble* params);
GEGL_EXPORT void glGetnUniformuiv(GLuint program,GLint location,GLsizei bufSize,GLuint* params);
GEGL_EXPORT void glGetUniformui64vNV(GLuint program,GLint location,GLuint64EXT* params);
GEGL_EXPORT void glNamedRenderbufferStorageEXT(GLuint renderbuffer,GLenum internalformat,GLsizei width,GLsizei height);
GEGL_EXPORT void glVertexAttrib3dNV(GLuint index,GLdouble x,GLdouble y,GLdouble z);
GEGL_EXPORT void glTextureStorage1DEXT(GLuint texture,GLenum target,GLsizei levels,GLenum internalformat,GLsizei width);
GEGL_EXPORT void glPixelTexGenParameteriSGIS(GLenum pname,GLint param);
GEGL_EXPORT void glColorTableEXT(GLenum target,GLenum internalFormat,GLsizei width,GLenum format,GLenum type,const void* table);
GEGL_EXPORT void glGenBuffers(GLsizei n,GLuint* buffers);
GEGL_EXPORT void glMultiTexCoord3xvOES(GLenum texture,const GLfixed* coords);
GEGL_EXPORT void glExecuteProgramNV(GLenum target,GLuint id,const GLfloat* params);
GEGL_EXPORT void glVariantArrayObjectATI(GLuint id,GLenum type,GLsizei stride,GLuint buffer,GLuint offset);
GEGL_EXPORT void glColor3xvOES(const GLfixed* components);
GEGL_EXPORT void glGetnConvolutionFilterARB(GLenum target,GLenum format,GLenum type,GLsizei bufSize,void* image);
GEGL_EXPORT void glNormalFormatNV(GLenum type,GLsizei stride);
GEGL_EXPORT void glGetInvariantFloatvEXT(GLuint id,GLenum value,GLfloat* data);
GEGL_EXPORT void glClearNamedFramebufferiv(GLuint framebuffer,GLenum buffer,GLint drawbuffer,const GLint* value);
GEGL_EXPORT void glTexImage3D(GLenum target,GLint level,GLint internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,const GLvoid* pixels);
GEGL_EXPORT void glGenSamplers(GLsizei count,GLuint* samplers);
GEGL_EXPORT GLboolean glIsFramebuffer(GLuint framebuffer);
GEGL_EXPORT void glProgramUniform3dvEXT(GLuint program,GLint location,GLsizei count,const GLdouble* value);
GEGL_EXPORT void glGetVertexAttribfvNV(GLuint index,GLenum pname,GLfloat* params);
GEGL_EXPORT void glDrawRangeElementArrayAPPLE(GLenum mode,GLuint start,GLuint end,GLint first,GLsizei count);
GEGL_EXPORT void glUniform3i64NV(GLint location,GLint64EXT x,GLint64EXT y,GLint64EXT z);
GEGL_EXPORT void glMatrixPopEXT(GLenum mode);
GEGL_EXPORT void glVertexStream1sATI(GLenum stream,GLshort x);
GEGL_EXPORT void glGetnPixelMapuivARB(GLenum map,GLsizei bufSize,GLuint* values);
GEGL_EXPORT void glMultiTexEnviEXT(GLenum texunit,GLenum target,GLenum pname,GLint param);
GEGL_EXPORT void glVertexAttribI2iEXT(GLuint index,GLint x,GLint y);
GEGL_EXPORT void glProgramParameter4fvNV(GLenum target,GLuint index,const GLfloat* v);
GEGL_EXPORT void glWaitSemaphoreEXT(GLuint semaphore,GLuint numBufferBarriers,const GLuint* buffers,GLuint numTextureBarriers,const GLuint* textures,const GLenum* srcLayouts);
GEGL_EXPORT void glNamedFramebufferSampleLocationsfvNV(GLuint framebuffer,GLuint start,GLsizei count,const GLfloat* v);
GEGL_EXPORT void glTexCoordP4uiv(GLenum type,const GLuint* coords);
GEGL_EXPORT void glRectxvOES(const GLfixed* v1,const GLfixed* v2);
GEGL_EXPORT void glGetVariantIntegervEXT(GLuint id,GLenum value,GLint* data);
GEGL_EXPORT void glDeleteLists(GLuint list,GLsizei range);
GEGL_EXPORT void glTexGendv(GLenum coord,GLenum pname,const GLdouble* params);
GEGL_EXPORT void glVertexP2uiv(GLenum type,const GLuint* value);
GEGL_EXPORT void glGetPerfMonitorGroupsAMD(GLint* numGroups,GLsizei groupsSize,GLuint* groups);
GEGL_EXPORT void glMultTransposeMatrixfARB(const GLfloat* m);
GEGL_EXPORT void glVertexAttribI2ivEXT(GLuint index,const GLint* v);
GEGL_EXPORT void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(const GLuint* rc,const GLfloat* c,const GLfloat* n,const GLfloat* v);
GEGL_EXPORT void glDeleteStatesNV(GLsizei n,const GLuint* states);
GEGL_EXPORT void glGetBufferParameteri64v(GLenum target,GLenum pname,GLint64* params);
GEGL_EXPORT void glProgramUniform4dv(GLuint program,GLint location,GLsizei count,const GLdouble* value);
GEGL_EXPORT void glEdgeFlagPointerEXT(GLsizei stride,GLsizei count,const GLboolean* pointer);
GEGL_EXPORT void glVideoCaptureStreamParameterivNV(GLuint video_capture_slot,GLuint stream,GLenum pname,const GLint* params);
GEGL_EXPORT void glVertexStream4iATI(GLenum stream,GLint x,GLint y,GLint z,GLint w);
GEGL_EXPORT void glVDPAUFiniNV();
GEGL_EXPORT void glMakeBufferNonResidentNV(GLenum target);
GEGL_EXPORT void glUniform1ui64ARB(GLint location,GLuint64 x);
GEGL_EXPORT void glStencilStrokePathNV(GLuint path,GLint reference,GLuint mask);
GEGL_EXPORT void glVariantuivEXT(GLuint id,const GLuint* addr);
GEGL_EXPORT void glCopyTexSubImage3DEXT(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height);
GEGL_EXPORT void glSpriteParameteriSGIX(GLenum pname,GLint param);
GEGL_EXPORT void glMultiTexCoord1sARB(GLenum target,GLshort s);
GEGL_EXPORT void glConvolutionParameterfv(GLenum target,GLenum pname,const GLfloat* params);
GEGL_EXPORT void glMakeTextureHandleResidentNV(GLuint64 handle);
GEGL_EXPORT void glMultMatrixxOES(const GLfixed* m);
GEGL_EXPORT void glTextureNormalEXT(GLenum mode);
GEGL_EXPORT void glGetQueryivARB(GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glCompressedMultiTexImage3DEXT(GLenum texunit,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,const void* bits);
GEGL_EXPORT GLint glGetInstrumentsSGIX();
GEGL_EXPORT void glProgramUniformMatrix4x3fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glPointParameterf(GLenum pname,GLfloat param);
GEGL_EXPORT void glProgramUniform3dEXT(GLuint program,GLint location,GLdouble x,GLdouble y,GLdouble z);
GEGL_EXPORT void glMultiTexCoord2hNV(GLenum target,GLhalfNV s,GLhalfNV t);
GEGL_EXPORT void glGetConvolutionFilterEXT(GLenum target,GLenum format,GLenum type,void* image);
GEGL_EXPORT void glVertexAttrib2hNV(GLuint index,GLhalfNV x,GLhalfNV y);
GEGL_EXPORT void glCurrentPaletteMatrixARB(GLint index);
GEGL_EXPORT void glFogxvOES(GLenum pname,const GLfixed* param);
GEGL_EXPORT void glCreateRenderbuffers(GLsizei n,GLuint* renderbuffers);
GEGL_EXPORT void glVertexAttrib4Nusv(GLuint index,const GLushort* v);
GEGL_EXPORT void glCombinerInputNV(GLenum stage,GLenum portion,GLenum variable,GLenum input,GLenum mapping,GLenum componentUsage);
GEGL_EXPORT void glDepthFunc(GLenum func);
GEGL_EXPORT void glWindowPos4fMESA(GLfloat x,GLfloat y,GLfloat z,GLfloat w);
GEGL_EXPORT void glEnableClientStateIndexedEXT(GLenum array,GLuint index);
GEGL_EXPORT void glTexCoord4iv(const GLint* v);
GEGL_EXPORT void glProgramUniform4i64ARB(GLuint program,GLint location,GLint64 x,GLint64 y,GLint64 z,GLint64 w);
GEGL_EXPORT void glBlendFunci(GLuint buf,GLenum src,GLenum dst);
GEGL_EXPORT void glResolveDepthValuesNV();
GEGL_EXPORT void glTextureColorMaskSGIS(GLboolean red,GLboolean green,GLboolean blue,GLboolean alpha);
GEGL_EXPORT GLuint glCreateShaderProgramEXT(GLenum type,const GLchar* string);
GEGL_EXPORT void glBufferStorage(GLenum target,GLsizeiptr size,const void* data,GLbitfield flags);
GEGL_EXPORT void glMakeNamedBufferNonResidentNV(GLuint buffer);
GEGL_EXPORT void glRenderbufferStorageMultisampleEXT(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height);
GEGL_EXPORT void glGetFloati_v(GLenum target,GLuint index,GLfloat* data);
GEGL_EXPORT void glUniform2ui64ARB(GLint location,GLuint64 x,GLuint64 y);
GEGL_EXPORT void glVertex3fv(const GLfloat* v);
GEGL_EXPORT GLint glGetUniformLocation(GLuint program,const GLchar* name);
GEGL_EXPORT void glVertexStream1svATI(GLenum stream,const GLshort* coords);
GEGL_EXPORT void glVertexStream3fATI(GLenum stream,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glNamedFramebufferDrawBuffers(GLuint framebuffer,GLsizei n,const GLenum* bufs);
GEGL_EXPORT void glUniform2ui64vNV(GLint location,GLsizei count,const GLuint64EXT* value);
GEGL_EXPORT void glTexCoordPointervINTEL(GLint size,GLenum type,const void** pointer);
GEGL_EXPORT void glUniform4fv(GLint location,GLsizei count,const GLfloat* value);
GEGL_EXPORT void glNormalPointerEXT(GLenum type,GLsizei stride,GLsizei count,const void* pointer);
GEGL_EXPORT void glVertexAttrib4hNV(GLuint index,GLhalfNV x,GLhalfNV y,GLhalfNV z,GLhalfNV w);
GEGL_EXPORT void glNormal3f(GLfloat nx,GLfloat ny,GLfloat nz);
GEGL_EXPORT void glVertexStream2iATI(GLenum stream,GLint x,GLint y);
GEGL_EXPORT void glVertexAttribP4uiv(GLuint index,GLenum type,GLboolean normalized,const GLuint* value);
GEGL_EXPORT void glCompressedTextureSubImage3D(GLuint texture,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,const void* data);
GEGL_EXPORT void glAsyncMarkerSGIX(GLuint marker);
GEGL_EXPORT void glTextureStorageSparseAMD(GLuint texture,GLenum target,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLsizei layers,GLbitfield flags);
GEGL_EXPORT void glGetConvolutionParameterivEXT(GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glEndPerfQueryINTEL(GLuint queryHandle);
GEGL_EXPORT void glFragmentLightModeliSGIX(GLenum pname,GLint param);
GEGL_EXPORT void glPrioritizeTexturesEXT(GLsizei n,const GLuint* textures,const GLclampf* priorities);
GEGL_EXPORT void glEndConditionalRender();
GEGL_EXPORT void glEnableClientState(GLenum cap);
GEGL_EXPORT void glResetHistogram(GLenum target);
GEGL_EXPORT void glGetOcclusionQueryivNV(GLuint id,GLenum pname,GLint* params);
GEGL_EXPORT void glUniform1uiEXT(GLint location,GLuint v0);
GEGL_EXPORT void glMultiTexCoord2sv(GLenum target,const GLshort* v);
GEGL_EXPORT void glTexSubImage2DEXT(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,const void* pixels);
GEGL_EXPORT void glProgramUniform2uiv(GLuint program,GLint location,GLsizei count,const GLuint* value);
GEGL_EXPORT void glMultiTexCoord2iARB(GLenum target,GLint s,GLint t);
GEGL_EXPORT void glGetQueryObjectuiv(GLuint id,GLenum pname,GLuint* params);
GEGL_EXPORT void glGenerateMultiTexMipmapEXT(GLenum texunit,GLenum target);
GEGL_EXPORT void glVertexAttrib4iv(GLuint index,const GLint* v);
GEGL_EXPORT void glWindowPos3dvMESA(const GLdouble* v);
GEGL_EXPORT void glLabelObjectEXT(GLenum type,GLuint object,GLsizei length,const GLchar* label);
GEGL_EXPORT void glProgramUniform1uiv(GLuint program,GLint location,GLsizei count,const GLuint* value);
GEGL_EXPORT void glFramebufferTexture(GLenum target,GLenum attachment,GLuint texture,GLint level);
GEGL_EXPORT void glMultiTexEnvfEXT(GLenum texunit,GLenum target,GLenum pname,GLfloat param);
GEGL_EXPORT void glGetTexGendv(GLenum coord,GLenum pname,GLdouble* params);
GEGL_EXPORT void glVertex4xOES(GLfixed x,GLfixed y,GLfixed z);
GEGL_EXPORT void glVertexAttribI2uivEXT(GLuint index,const GLuint* v);
GEGL_EXPORT void glNamedProgramLocalParameter4fvEXT(GLuint program,GLenum target,GLuint index,const GLfloat* params);
GEGL_EXPORT void glColor3usv(const GLushort* v);
GEGL_EXPORT void glGetPixelTransformParameterfvEXT(GLenum target,GLenum pname,GLfloat* params);
GEGL_EXPORT void glIndexxvOES(const GLfixed* component);
GEGL_EXPORT void glDepthMask(GLboolean flag);
GEGL_EXPORT void glProgramUniformMatrix2x4fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT GLboolean glAreProgramsResidentNV(GLsizei n,const GLuint* programs,GLboolean* residences);
GEGL_EXPORT void glColorTable(GLenum target,GLenum internalformat,GLsizei width,GLenum format,GLenum type,const GLvoid* table);
GEGL_EXPORT void glBeginQueryIndexed(GLenum target,GLuint index,GLuint id);
GEGL_EXPORT void glVertexStream1dvATI(GLenum stream,const GLdouble* coords);
GEGL_EXPORT void glGetMultiTexEnvfvEXT(GLenum texunit,GLenum target,GLenum pname,GLfloat* params);
GEGL_EXPORT void glDeleteFencesNV(GLsizei n,const GLuint* fences);
GEGL_EXPORT void glVertexAttribs1dvNV(GLuint index,GLsizei count,const GLdouble* v);
GEGL_EXPORT void glBufferStorageExternalEXT(GLenum target,GLintptr offset,GLsizeiptr size,GLeglClientBufferEXT clientBuffer,GLbitfield flags);
GEGL_EXPORT void glVertexStream2sATI(GLenum stream,GLshort x,GLshort y);
GEGL_EXPORT void glGetnSeparableFilterARB(GLenum target,GLenum format,GLenum type,GLsizei rowBufSize,void* row,GLsizei columnBufSize,void* column,void* span);
GEGL_EXPORT void glProgramUniform2dv(GLuint program,GLint location,GLsizei count,const GLdouble* value);
GEGL_EXPORT void glActiveStencilFaceEXT(GLenum face);
GEGL_EXPORT void glProgramUniform4dEXT(GLuint program,GLint location,GLdouble x,GLdouble y,GLdouble z,GLdouble w);
GEGL_EXPORT void glPointSizexOES(GLfixed size);
GEGL_EXPORT void glRasterPos2sv(const GLshort* v);
GEGL_EXPORT GLuint glBindParameterEXT(GLenum value);
GEGL_EXPORT void glTexCoord1sv(const GLshort* v);
GEGL_EXPORT void glBlendParameteriNV(GLenum pname,GLint value);
GEGL_EXPORT void glNamedProgramLocalParameter4dvEXT(GLuint program,GLenum target,GLuint index,const GLdouble* params);
GEGL_EXPORT void glProgramUniformHandleui64NV(GLuint program,GLint location,GLuint64 value);
GEGL_EXPORT void glGetTextureParameterfvEXT(GLuint texture,GLenum target,GLenum pname,GLfloat* params);
GEGL_EXPORT void glGetPathMetricsNV(GLbitfield metricQueryMask,GLsizei numPaths,GLenum pathNameType,const void* paths,GLuint pathBase,GLsizei stride,GLfloat* metrics);
GEGL_EXPORT void glVertex2i(GLint x,GLint y);
GEGL_EXPORT void glNewList(GLuint list,GLenum mode);
GEGL_EXPORT void glMatrixLoad3x3fNV(GLenum matrixMode,const GLfloat* m);
GEGL_EXPORT void glMultiTexCoord2fARB(GLenum target,GLfloat s,GLfloat t);
GEGL_EXPORT void glWeightdvARB(GLint size,const GLdouble* weights);
GEGL_EXPORT GLboolean glIsTransformFeedbackNV(GLuint id);
GEGL_EXPORT void glVertexAttribDivisorARB(GLuint index,GLuint divisor);
GEGL_EXPORT void glSecondaryColorP3uiv(GLenum type,const GLuint* color);
GEGL_EXPORT void glGetnCompressedTexImageARB(GLenum target,GLint lod,GLsizei bufSize,void* img);
GEGL_EXPORT void glGetIntegerv(GLenum pname,GLint* params);
GEGL_EXPORT void glMatrixLoaddEXT(GLenum mode,const GLdouble* m);
GEGL_EXPORT GLfloat glGetPathLengthNV(GLuint path,GLsizei startSegment,GLsizei numSegments);
GEGL_EXPORT void glProgramUniformMatrix3dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT void glUniform4i64NV(GLint location,GLint64EXT x,GLint64EXT y,GLint64EXT z,GLint64EXT w);
GEGL_EXPORT void glGetHistogramEXT(GLenum target,GLboolean reset,GLenum format,GLenum type,void* values);
GEGL_EXPORT void glVertexAttrib4NuivARB(GLuint index,const GLuint* v);
GEGL_EXPORT void glMapGrid2xOES(GLint n,GLfixed u1,GLfixed u2,GLfixed v1,GLfixed v2);
GEGL_EXPORT void glTexImage2D(GLenum target,GLint level,GLint internalFormat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,const GLvoid* pixels);
GEGL_EXPORT void glWindowPos2fvARB(const GLfloat* v);
GEGL_EXPORT void glEnableIndexedEXT(GLenum target,GLuint index);
GEGL_EXPORT void glTexCoord1bvOES(const GLbyte* coords);
GEGL_EXPORT void glDrawPixels(GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid* pixels);
GEGL_EXPORT void glMultMatrixd(const GLdouble* m);
GEGL_EXPORT void glMultMatrixf(const GLfloat* m);
GEGL_EXPORT void glReplacementCodePointerSUN(GLenum type,GLsizei stride,const void** pointer);
GEGL_EXPORT void glLoadTransposeMatrixdARB(const GLdouble* m);
GEGL_EXPORT void glVertexAttrib4Nubv(GLuint index,const GLubyte* v);
GEGL_EXPORT void glVertexArrayVertexAttribIOffsetEXT(GLuint vaobj,GLuint buffer,GLuint index,GLint size,GLenum type,GLsizei stride,GLintptr offset);
GEGL_EXPORT void glCompileShaderARB(GLhandleARB shaderObj);
GEGL_EXPORT void glWindowPos3dMESA(GLdouble x,GLdouble y,GLdouble z);
GEGL_EXPORT void glNormalStream3fvATI(GLenum stream,const GLfloat* coords);
GEGL_EXPORT void glColor4usv(const GLushort* v);
GEGL_EXPORT void glMapGrid1f(GLint un,GLfloat u1,GLfloat u2);
GEGL_EXPORT void glPolygonStipple(const GLubyte* mask);
GEGL_EXPORT void glUniform4ui64ARB(GLint location,GLuint64 x,GLuint64 y,GLuint64 z,GLuint64 w);
GEGL_EXPORT void glTextureRenderbufferEXT(GLuint texture,GLenum target,GLuint renderbuffer);
GEGL_EXPORT GLint glGetSubroutineUniformLocation(GLuint program,GLenum shadertype,const GLchar* name);
GEGL_EXPORT void glGetFramebufferParameteriv(GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glPixelMapusv(GLenum map,GLsizei mapsize,const GLushort* values);
GEGL_EXPORT void glGetSamplerParameteriv(GLuint sampler,GLenum pname,GLint* params);
GEGL_EXPORT void glVertexStream2fvATI(GLenum stream,const GLfloat* coords);
GEGL_EXPORT void glProgramStringARB(GLenum target,GLenum format,GLsizei len,const void* string);
GEGL_EXPORT void glProgramUniformMatrix3dvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT void glSeparableFilter2D(GLenum target,GLenum internalformat,GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid* row,const GLvoid* column);
GEGL_EXPORT void glVertexAttribI1uiv(GLuint index,const GLuint* v);
GEGL_EXPORT void glLGPUCopyImageSubDataNVX(GLuint sourceGpu,GLbitfield destinationGpuMask,GLuint srcName,GLenum srcTarget,GLint srcLevel,GLint srcX,GLint srxY,GLint srcZ,GLuint dstName,GLenum dstTarget,GLint dstLevel,GLint dstX,GLint dstY,GLint dstZ,GLsizei width,GLsizei height,GLsizei depth);
GEGL_EXPORT void glTexStorage2D(GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height);
GEGL_EXPORT void glColor3fv(const GLfloat* v);
GEGL_EXPORT void glGetMultiTexGendvEXT(GLenum texunit,GLenum coord,GLenum pname,GLdouble* params);
GEGL_EXPORT void glVertexAttribL4dvEXT(GLuint index,const GLdouble* v);
GEGL_EXPORT void glGetActiveUniform(GLuint program,GLuint index,GLsizei bufSize,GLsizei* length,GLint* size,GLenum* type,GLchar* name);
GEGL_EXPORT void glUniform2ui64vARB(GLint location,GLsizei count,const GLuint64* value);
GEGL_EXPORT void glMakeNamedBufferResidentNV(GLuint buffer,GLenum access);
GEGL_EXPORT GLenum glPathGlyphIndexRangeNV(GLenum fontTarget,const void* fontName,GLbitfield fontStyle,GLuint pathParameterTemplate,GLfloat emScale,GLuint baseAndCount[2]);
GEGL_EXPORT void glColorPointer(GLint size,GLenum type,GLsizei stride,const GLvoid* ptr);
GEGL_EXPORT void glProgramEnvParameterI4ivNV(GLenum target,GLuint index,const GLint* params);
GEGL_EXPORT void glMulticastGetQueryObjectui64vNV(GLuint gpu,GLuint id,GLenum pname,GLuint64* params);
GEGL_EXPORT void glMultiTexParameterfEXT(GLenum texunit,GLenum target,GLenum pname,GLfloat param);
GEGL_EXPORT void glNamedFramebufferTextureLayer(GLuint framebuffer,GLenum attachment,GLuint texture,GLint level,GLint layer);
GEGL_EXPORT void glGetVertexArrayIntegervEXT(GLuint vaobj,GLenum pname,GLint* param);
GEGL_EXPORT void glVertexAttrib3dARB(GLuint index,GLdouble x,GLdouble y,GLdouble z);
GEGL_EXPORT GLboolean glVDPAUIsSurfaceNV(GLvdpauSurfaceNV surface);
GEGL_EXPORT void glMultiTexImage1DEXT(GLenum texunit,GLenum target,GLint level,GLint internalformat,GLsizei width,GLint border,GLenum format,GLenum type,const void* pixels);
GEGL_EXPORT GLboolean glIsAsyncMarkerSGIX(GLuint marker);
GEGL_EXPORT void glGetDoublei_vEXT(GLenum pname,GLuint index,GLdouble* params);
GEGL_EXPORT void glUniform2i64NV(GLint location,GLint64EXT x,GLint64EXT y);
GEGL_EXPORT GLboolean glIsCommandListNV(GLuint list);
GEGL_EXPORT void glUniform3uiEXT(GLint location,GLuint v0,GLuint v1,GLuint v2);
GEGL_EXPORT void glTexParameterIuivEXT(GLenum target,GLenum pname,const GLuint* params);
GEGL_EXPORT void glProgramUniformMatrix4fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glVertex2fv(const GLfloat* v);
GEGL_EXPORT void glVertexAttribL3dEXT(GLuint index,GLdouble x,GLdouble y,GLdouble z);
GEGL_EXPORT void glFramebufferRenderbuffer(GLenum target,GLenum attachment,GLenum renderbuffertarget,GLuint renderbuffer);
GEGL_EXPORT GLint glGetUniformLocationARB(GLhandleARB programObj,const GLcharARB* name);
GEGL_EXPORT void glPathParameterfvNV(GLuint path,GLenum pname,const GLfloat* value);
GEGL_EXPORT void glVertexAttrib3sNV(GLuint index,GLshort x,GLshort y,GLshort z);
GEGL_EXPORT void glGetDoublei_v(GLenum target,GLuint index,GLdouble* data);
GEGL_EXPORT void glVertexAttrib1sv(GLuint index,const GLshort* v);
GEGL_EXPORT void glBindSampler(GLuint unit,GLuint sampler);
GEGL_EXPORT void glLineWidth(GLfloat width);
GEGL_EXPORT void glVertexArrayRangeAPPLE(GLsizei length,void* pointer);
GEGL_EXPORT void glBindBufferOffsetEXT(GLenum target,GLuint index,GLuint buffer,GLintptr offset);
GEGL_EXPORT void glWeightfvARB(GLint size,const GLfloat* weights);
GEGL_EXPORT void glGetIntegeri_v(GLenum target,GLuint index,GLint* data);
GEGL_EXPORT void glGetTransformFeedbackVarying(GLuint program,GLuint index,GLsizei bufSize,GLsizei* length,GLsizei* size,GLenum* type,GLchar* name);
GEGL_EXPORT void glProgramLocalParameter4fvARB(GLenum target,GLuint index,const GLfloat* params);
GEGL_EXPORT void glGetTransformFeedbackVaryingNV(GLuint program,GLuint index,GLint* location);
GEGL_EXPORT void glWindowPos2iv(const GLint* v);
GEGL_EXPORT void glVertexStream1dATI(GLenum stream,GLdouble x);
GEGL_EXPORT void glColorFragmentOp2ATI(GLenum op,GLuint dst,GLuint dstMask,GLuint dstMod,GLuint arg1,GLuint arg1Rep,GLuint arg1Mod,GLuint arg2,GLuint arg2Rep,GLuint arg2Mod);
GEGL_EXPORT void glFogiv(GLenum pname,const GLint* params);
GEGL_EXPORT GLuint64 glGetTextureHandleNV(GLuint texture);
GEGL_EXPORT void glLightModeliv(GLenum pname,const GLint* params);
GEGL_EXPORT void glDepthRangef(GLfloat n,GLfloat f);
GEGL_EXPORT void glGetFragmentMaterialivSGIX(GLenum face,GLenum pname,GLint* params);
GEGL_EXPORT void glVideoCaptureStreamParameterfvNV(GLuint video_capture_slot,GLuint stream,GLenum pname,const GLfloat* params);
GEGL_EXPORT void glDeleteProgramsARB(GLsizei n,const GLuint* programs);
GEGL_EXPORT void glWindowPos3fvARB(const GLfloat* v);
GEGL_EXPORT void glFeedbackBufferxOES(GLsizei n,GLenum type,const GLfixed* buffer);
GEGL_EXPORT void glGetTexBumpParameterfvATI(GLenum pname,GLfloat* param);
GEGL_EXPORT void glEnablei(GLenum target,GLuint index);
GEGL_EXPORT void glGetActiveSubroutineName(GLuint program,GLenum shadertype,GLuint index,GLsizei bufsize,GLsizei* length,GLchar* name);
GEGL_EXPORT void glDrawBuffersARB(GLsizei n,const GLenum* bufs);
GEGL_EXPORT void glBindProgramARB(GLenum target,GLuint program);
GEGL_EXPORT void glEvalCoord1fv(const GLfloat* u);
GEGL_EXPORT void glProgramUniform3ui64vARB(GLuint program,GLint location,GLsizei count,const GLuint64* value);
GEGL_EXPORT void glProgramUniformMatrix2dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT void glMultiTexCoord2hvNV(GLenum target,const GLhalfNV* v);
GEGL_EXPORT void glGetFloatIndexedvEXT(GLenum target,GLuint index,GLfloat* data);
GEGL_EXPORT void glSampleCoverageARB(GLfloat value,GLboolean invert);
GEGL_EXPORT void glProgramUniform2ui64vARB(GLuint program,GLint location,GLsizei count,const GLuint64* value);
GEGL_EXPORT void glPixelDataRangeNV(GLenum target,GLsizei length,const void* pointer);
GEGL_EXPORT void glVertexStream3svATI(GLenum stream,const GLshort* coords);
GEGL_EXPORT void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(const GLuint* rc,const GLfloat* tc,const GLfloat* n,const GLfloat* v);
GEGL_EXPORT void glTexCoord3hvNV(const GLhalfNV* v);
GEGL_EXPORT void glSampleMaski(GLuint maskNumber,GLbitfield mask);
GEGL_EXPORT void glIndexFuncEXT(GLenum func,GLclampf ref);
GEGL_EXPORT void glPointParameteriNV(GLenum pname,GLint param);
GEGL_EXPORT void glUniformMatrix3x2fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glGetFramebufferParameterivEXT(GLuint framebuffer,GLenum pname,GLint* params);
GEGL_EXPORT void glUniform2i64ARB(GLint location,GLint64 x,GLint64 y);
GEGL_EXPORT void glNamedBufferStorageEXT(GLuint buffer,GLsizeiptr size,const void* data,GLbitfield flags);
GEGL_EXPORT void glNamedFramebufferTexture3DEXT(GLuint framebuffer,GLenum attachment,GLenum textarget,GLuint texture,GLint level,GLint zoffset);
GEGL_EXPORT void glVertexAttrib2dv(GLuint index,const GLdouble* v);
GEGL_EXPORT void glGetVertexArrayPointervEXT(GLuint vaobj,GLenum pname,void** param);
GEGL_EXPORT void glGetVertexAttribArrayObjectivATI(GLuint index,GLenum pname,GLint* params);
GEGL_EXPORT void glProgramUniformMatrix3fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glEnableVertexArrayEXT(GLuint vaobj,GLenum array);
GEGL_EXPORT void glColorTableParameterfvSGI(GLenum target,GLenum pname,const GLfloat* params);
GEGL_EXPORT void glEdgeFlag(GLboolean flag);
GEGL_EXPORT void glFogCoordf(GLfloat coord);
GEGL_EXPORT void glVertex3d(GLdouble x,GLdouble y,GLdouble z);
GEGL_EXPORT void glVertex3f(GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glSpriteParameterivSGIX(GLenum pname,const GLint* params);
GEGL_EXPORT void glPathGlyphRangeNV(GLuint firstPathName,GLenum fontTarget,const void* fontName,GLbitfield fontStyle,GLuint firstGlyph,GLsizei numGlyphs,GLenum handleMissingGlyphs,GLuint pathParameterTemplate,GLfloat emScale);
GEGL_EXPORT void glPrimitiveBoundingBoxARB(GLfloat minX,GLfloat minY,GLfloat minZ,GLfloat minW,GLfloat maxX,GLfloat maxY,GLfloat maxZ,GLfloat maxW);
GEGL_EXPORT void glVertexAttribL3ui64vNV(GLuint index,const GLuint64EXT* v);
GEGL_EXPORT void glVertex3s(GLshort x,GLshort y,GLshort z);
GEGL_EXPORT void glTexCoordP2ui(GLenum type,GLuint coords);
GEGL_EXPORT void glProgramUniform2fvEXT(GLuint program,GLint location,GLsizei count,const GLfloat* value);
GEGL_EXPORT void glDeletePathsNV(GLuint path,GLsizei range);
GEGL_EXPORT void glPrimitiveRestartIndexNV(GLuint index);
GEGL_EXPORT void glTexCoord2fColor3fVertex3fvSUN(const GLfloat* tc,const GLfloat* c,const GLfloat* v);
GEGL_EXPORT void glTexCoordPointerListIBM(GLint size,GLenum type,GLint stride,const void** pointer,GLint ptrstride);
GEGL_EXPORT void glRectxOES(GLfixed x1,GLfixed y1,GLfixed x2,GLfixed y2);
GEGL_EXPORT void glCopyNamedBufferSubData(GLuint readBuffer,GLuint writeBuffer,GLintptr readOffset,GLintptr writeOffset,GLsizeiptr size);
GEGL_EXPORT void glGenProgramsNV(GLsizei n,GLuint* programs);
GEGL_EXPORT void glFragmentLightfSGIX(GLenum light,GLenum pname,GLfloat param);
GEGL_EXPORT void glTexStorage3D(GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth);
GEGL_EXPORT void glTextureParameteriv(GLuint texture,GLenum pname,const GLint* param);
GEGL_EXPORT void glNamedBufferDataEXT(GLuint buffer,GLsizeiptr size,const void* data,GLenum usage);
GEGL_EXPORT void glImportSemaphoreWin32NameEXT(GLuint semaphore,GLenum handleType,const void* name);
GEGL_EXPORT void glMultiTexCoord3fvARB(GLenum target,const GLfloat* v);
GEGL_EXPORT void glUniformMatrix3x4fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glSubpixelPrecisionBiasNV(GLuint xbits,GLuint ybits);
GEGL_EXPORT void glNormalPointer(GLenum type,GLsizei stride,const GLvoid* ptr);
GEGL_EXPORT void glNamedFramebufferTexture(GLuint framebuffer,GLenum attachment,GLuint texture,GLint level);
GEGL_EXPORT void glVertexAttrib4NsvARB(GLuint index,const GLshort* v);
GEGL_EXPORT void glPassThrough(GLfloat token);
GEGL_EXPORT void glSecondaryColorP3ui(GLenum type,GLuint color);
GEGL_EXPORT void glInvalidateTexSubImage(GLuint texture,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth);
GEGL_EXPORT GLboolean glIsImageHandleResidentARB(GLuint64 handle);
GEGL_EXPORT void glTangent3fvEXT(const GLfloat* v);
GEGL_EXPORT void glProgramUniformMatrix4x3fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glBegin(GLenum mode);
GEGL_EXPORT void glEvalCoord2dv(const GLdouble* u);
GEGL_EXPORT void glColor3ubv(const GLubyte* v);
GEGL_EXPORT void glFogCoordfvEXT(const GLfloat* coord);
GEGL_EXPORT void glVertexP3ui(GLenum type,GLuint value);
GEGL_EXPORT void glLightfv(GLenum light,GLenum pname,const GLfloat* params);
GEGL_EXPORT void glVertexAttribL3i64NV(GLuint index,GLint64EXT x,GLint64EXT y,GLint64EXT z);
GEGL_EXPORT void glStencilClearTagEXT(GLsizei stencilTagBits,GLuint stencilClearTag);
GEGL_EXPORT void glGetActiveUniformName(GLuint program,GLuint uniformIndex,GLsizei bufSize,GLsizei* length,GLchar* uniformName);
GEGL_EXPORT void glTangentPointerEXT(GLenum type,GLsizei stride,const void* pointer);
GEGL_EXPORT void glUniform4ui64vNV(GLint location,GLsizei count,const GLuint64EXT* value);
GEGL_EXPORT void glDebugMessageEnableAMD(GLenum category,GLenum severity,GLsizei count,const GLuint* ids,GLboolean enabled);
GEGL_EXPORT void glProgramUniform2ui(GLuint program,GLint location,GLuint v0,GLuint v1);
GEGL_EXPORT void glCopyTexSubImage2DEXT(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint x,GLint y,GLsizei width,GLsizei height);
GEGL_EXPORT void glGenRenderbuffersEXT(GLsizei n,GLuint* renderbuffers);
GEGL_EXPORT void glNamedProgramLocalParameterI4ivEXT(GLuint program,GLenum target,GLuint index,const GLint* params);
GEGL_EXPORT void glMultiTexCoord2f(GLenum target,GLfloat s,GLfloat t);
GEGL_EXPORT void glMapGrid2d(GLint un,GLdouble u1,GLdouble u2,GLint vn,GLdouble v1,GLdouble v2);
GEGL_EXPORT void glGetMultiTexParameterIuivEXT(GLenum texunit,GLenum target,GLenum pname,GLuint* params);
GEGL_EXPORT void glBlendEquationiARB(GLuint buf,GLenum mode);
GEGL_EXPORT void glTexParameteriv(GLenum target,GLenum pname,const GLint* params);
GEGL_EXPORT void glUniform4ivARB(GLint location,GLsizei count,const GLint* value);
GEGL_EXPORT void glMatrixOrthoEXT(GLenum mode,GLdouble left,GLdouble right,GLdouble bottom,GLdouble top,GLdouble zNear,GLdouble zFar);
GEGL_EXPORT void glVertexArrayVertexBuffer(GLuint vaobj,GLuint bindingindex,GLuint buffer,GLintptr offset,GLsizei stride);
GEGL_EXPORT void glProgramLocalParametersI4ivNV(GLenum target,GLuint index,GLsizei count,const GLint* params);
GEGL_EXPORT void glProgramUniform4ui64vNV(GLuint program,GLint location,GLsizei count,const GLuint64EXT* value);
GEGL_EXPORT void glGetNamedStringivARB(GLint namelen,const GLchar* name,GLenum pname,GLint* params);
GEGL_EXPORT void glVertexAttribL1i64vNV(GLuint index,const GLint64EXT* v);
GEGL_EXPORT void glTransformFeedbackBufferBase(GLuint xfb,GLuint index,GLuint buffer);
GEGL_EXPORT void glIndexsv(const GLshort* c);
GEGL_EXPORT void glPointParameterivNV(GLenum pname,const GLint* params);
GEGL_EXPORT void glGetDetailTexFuncSGIS(GLenum target,GLfloat* points);
GEGL_EXPORT void glReplacementCodeuiColor3fVertex3fvSUN(const GLuint* rc,const GLfloat* c,const GLfloat* v);
GEGL_EXPORT void glProgramLocalParameter4fARB(GLenum target,GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w);
GEGL_EXPORT void glBitmap(GLsizei width,GLsizei height,GLfloat xorig,GLfloat yorig,GLfloat xmove,GLfloat ymove,const GLubyte* bitmap);
GEGL_EXPORT void glNamedFramebufferTextureLayerEXT(GLuint framebuffer,GLenum attachment,GLuint texture,GLint level,GLint layer);
GEGL_EXPORT void glMultiTexGenfvEXT(GLenum texunit,GLenum coord,GLenum pname,const GLfloat* params);
GEGL_EXPORT void glGetNamedBufferSubData(GLuint buffer,GLintptr offset,GLsizeiptr size,void* data);
GEGL_EXPORT void glStencilFuncSeparateATI(GLenum frontfunc,GLenum backfunc,GLint ref,GLuint mask);
GEGL_EXPORT void glProgramUniform2iv(GLuint program,GLint location,GLsizei count,const GLint* value);
GEGL_EXPORT void glGetQueryiv(GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glTexCoord4f(GLfloat s,GLfloat t,GLfloat r,GLfloat q);
GEGL_EXPORT void glMapGrid2f(GLint un,GLfloat u1,GLfloat u2,GLint vn,GLfloat v1,GLfloat v2);
GEGL_EXPORT void glListParameterivSGIX(GLuint list,GLenum pname,const GLint* params);
GEGL_EXPORT void glCreateQueries(GLenum target,GLsizei n,GLuint* ids);
GEGL_EXPORT void glGetSamplerParameterfv(GLuint sampler,GLenum pname,GLfloat* params);
GEGL_EXPORT void glTexCoord4i(GLint s,GLint t,GLint r,GLint q);
GEGL_EXPORT void glObjectLabel(GLenum identifier,GLuint name,GLsizei length,const GLchar* label);
GEGL_EXPORT void glProgramUniform3i64NV(GLuint program,GLint location,GLint64EXT x,GLint64EXT y,GLint64EXT z);
GEGL_EXPORT GLuint64 glGetTextureHandleARB(GLuint texture);
GEGL_EXPORT void glTexCoord4s(GLshort s,GLshort t,GLshort r,GLshort q);
GEGL_EXPORT void glUniform4iARB(GLint location,GLint v0,GLint v1,GLint v2,GLint v3);
GEGL_EXPORT void glGetUniformIndices(GLuint program,GLsizei uniformCount,const GLchar*const* uniformNames,GLuint* uniformIndices);
GEGL_EXPORT void glMultiTexImage3DEXT(GLenum texunit,GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,const void* pixels);
GEGL_EXPORT void glCoverageModulationTableNV(GLsizei n,const GLfloat* v);
GEGL_EXPORT void glPointParameteriv(GLenum pname,const GLint* params);
GEGL_EXPORT void glMultiTexCoord4svARB(GLenum target,const GLshort* v);
GEGL_EXPORT void glNormal3fv(const GLfloat* v);
GEGL_EXPORT void glProgramUniformMatrix3x4dvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT void glTexCoord1fv(const GLfloat* v);
GEGL_EXPORT void glProgramUniformMatrix4x3dvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT void glGetActiveVaryingNV(GLuint program,GLuint index,GLsizei bufSize,GLsizei* length,GLsizei* size,GLenum* type,GLchar* name);
GEGL_EXPORT void glUniform1i64vARB(GLint location,GLsizei count,const GLint64* value);
GEGL_EXPORT void glMultiTexCoord1dv(GLenum target,const GLdouble* v);
GEGL_EXPORT void glTexCoord3fv(const GLfloat* v);
GEGL_EXPORT void glMatrixTranslatefEXT(GLenum mode,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glProgramUniform1ui64vNV(GLuint program,GLint location,GLsizei count,const GLuint64EXT* value);
GEGL_EXPORT void glTextureMaterialEXT(GLenum face,GLenum mode);
GEGL_EXPORT void glMultiTexCoordP3uiv(GLenum texture,GLenum type,const GLuint* coords);
GEGL_EXPORT void glVertexAttribP3ui(GLuint index,GLenum type,GLboolean normalized,GLuint value);
GEGL_EXPORT void glInterpolatePathsNV(GLuint resultPath,GLuint pathA,GLuint pathB,GLfloat weight);
GEGL_EXPORT void glTextureBufferRange(GLuint texture,GLenum internalformat,GLuint buffer,GLintptr offset,GLsizeiptr size);
GEGL_EXPORT void glVertexAttribL2dEXT(GLuint index,GLdouble x,GLdouble y);
GEGL_EXPORT void glGetPixelTransformParameterivEXT(GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glTexCoord4xvOES(const GLfixed* coords);
GEGL_EXPORT void glGetVariantBooleanvEXT(GLuint id,GLenum value,GLboolean* data);
GEGL_EXPORT void glDepthRange(GLclampd near_val,GLclampd far_val);
GEGL_EXPORT void glGetVertexAttribdvARB(GLuint index,GLenum pname,GLdouble* params);
GEGL_EXPORT void glGetColorTableParameterfv(GLenum target,GLenum pname,GLfloat* params);
GEGL_EXPORT void glDrawArraysInstancedEXT(GLenum mode,GLint start,GLsizei count,GLsizei primcount);
GEGL_EXPORT void glDisableClientStateIndexedEXT(GLenum array,GLuint index);
GEGL_EXPORT void glDrawBuffer(GLenum mode);
GEGL_EXPORT void glMultiDrawArraysIndirectBindlessNV(GLenum mode,const void* indirect,GLsizei drawCount,GLsizei stride,GLint vertexBufferCount);
GEGL_EXPORT void glGetnPixelMapusv(GLenum map,GLsizei bufSize,GLushort* values);
GEGL_EXPORT void glRasterPos3fv(const GLfloat* v);
GEGL_EXPORT void glClearBufferuiv(GLenum buffer,GLint drawbuffer,const GLuint* value);
GEGL_EXPORT void glGetInternalformati64v(GLenum target,GLenum internalformat,GLenum pname,GLsizei bufSize,GLint64* params);
GEGL_EXPORT void glShaderSourceARB(GLhandleARB shaderObj,GLsizei count,const GLcharARB** string,const GLint* length);
GEGL_EXPORT void glShaderOp3EXT(GLenum op,GLuint res,GLuint arg1,GLuint arg2,GLuint arg3);
GEGL_EXPORT void glWindowPos2dvMESA(const GLdouble* v);
GEGL_EXPORT void glClearIndex(GLfloat c);
GEGL_EXPORT void glProvokingVertexEXT(GLenum mode);
GEGL_EXPORT void glVariantubvEXT(GLuint id,const GLubyte* addr);
GEGL_EXPORT void glFlush();
GEGL_EXPORT void glFramebufferTexture2DEXT(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level);
GEGL_EXPORT void glGetColorTableParameterivEXT(GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glPresentFrameDualFillNV(GLuint video_slot,GLuint64EXT minPresentTime,GLuint beginPresentTimeId,GLuint presentDurationId,GLenum type,GLenum target0,GLuint fill0,GLenum target1,GLuint fill1,GLenum target2,GLuint fill2,GLenum target3,GLuint fill3);
GEGL_EXPORT GLuint glGenVertexShadersEXT(GLuint range);
GEGL_EXPORT void glSpecializeShaderARB(GLuint shader,const GLchar* pEntryPoint,GLuint numSpecializationConstants,const GLuint* pConstantIndex,const GLuint* pConstantValue);
GEGL_EXPORT void glProgramUniformHandleui64vARB(GLuint program,GLint location,GLsizei count,const GLuint64* values);
GEGL_EXPORT void glDepthRangefOES(GLclampf n,GLclampf f);
GEGL_EXPORT void glDeleteVertexArrays(GLsizei n,const GLuint* arrays);
GEGL_EXPORT void glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode,GLsizei count,GLenum type,const void* indices,GLsizei instancecount,GLint basevertex,GLuint baseinstance);
GEGL_EXPORT void glGetTexLevelParameteriv(GLenum target,GLint level,GLenum pname,GLint* params);
GEGL_EXPORT void glDrawVkImageNV(GLuint64 vkImage,GLuint sampler,GLfloat x0,GLfloat y0,GLfloat x1,GLfloat y1,GLfloat z,GLfloat s0,GLfloat t0,GLfloat s1,GLfloat t1);
GEGL_EXPORT void glWindowPos3iARB(GLint x,GLint y,GLint z);
GEGL_EXPORT void glPrioritizeTextures(GLsizei n,const GLuint* textures,const GLclampf* priorities);
GEGL_EXPORT void glWindowPos3fvMESA(const GLfloat* v);
GEGL_EXPORT void glProgramUniformMatrix3x2dvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT void glVertex4xvOES(const GLfixed* coords);
GEGL_EXPORT void glTexStorage3DMultisample(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedsamplelocations);
GEGL_EXPORT void glWindowPos2sARB(GLshort x,GLshort y);
GEGL_EXPORT void glStencilOpValueAMD(GLenum face,GLuint value);
GEGL_EXPORT void glProgramVertexLimitNV(GLenum target,GLint limit);
GEGL_EXPORT void glGetTexParameterPointervAPPLE(GLenum target,GLenum pname,void** params);
GEGL_EXPORT void glProgramUniform3uivEXT(GLuint program,GLint location,GLsizei count,const GLuint* value);
GEGL_EXPORT void glClampColor(GLenum target,GLenum clamp);
GEGL_EXPORT void glClearStencil(GLint s);
GEGL_EXPORT void glTexCoordP1uiv(GLenum type,const GLuint* coords);
GEGL_EXPORT void glVertexAttribs3svNV(GLuint index,GLsizei count,const GLshort* v);
GEGL_EXPORT void glMultiTexCoord3fv(GLenum target,const GLfloat* v);
GEGL_EXPORT void glVertexBlendEnvfATI(GLenum pname,GLfloat param);
GEGL_EXPORT GLboolean glIsFenceAPPLE(GLuint fence);
GEGL_EXPORT void glGetBufferParameterui64vNV(GLenum target,GLenum pname,GLuint64EXT* params);
GEGL_EXPORT void glVertexAttribI4bvEXT(GLuint index,const GLbyte* v);
GEGL_EXPORT void glUniform2fARB(GLint location,GLfloat v0,GLfloat v1);
GEGL_EXPORT void glStopInstrumentsSGIX(GLint marker);
GEGL_EXPORT void glVertexAttrib3fNV(GLuint index,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glMapVertexAttrib2dAPPLE(GLuint index,GLuint size,GLdouble u1,GLdouble u2,GLint ustride,GLint uorder,GLdouble v1,GLdouble v2,GLint vstride,GLint vorder,const GLdouble* points);
GEGL_EXPORT void glVertex2f(GLfloat x,GLfloat y);
GEGL_EXPORT void glCopyTextureImage2DEXT(GLuint texture,GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLsizei height,GLint border);
GEGL_EXPORT void glVertex2d(GLdouble x,GLdouble y);
GEGL_EXPORT void glSecondaryColor3bvEXT(const GLbyte* v);
GEGL_EXPORT void glMultiTexCoord4fARB(GLenum target,GLfloat s,GLfloat t,GLfloat r,GLfloat q);
GEGL_EXPORT void glPolygonOffset(GLfloat factor,GLfloat units);
GEGL_EXPORT void glTangent3bvEXT(const GLbyte* v);
GEGL_EXPORT void glHistogram(GLenum target,GLsizei width,GLenum internalformat,GLboolean sink);
GEGL_EXPORT void glGetProgramiv(GLuint program,GLenum pname,GLint* params);
GEGL_EXPORT void glMatrixIndexubvARB(GLint size,const GLubyte* indices);
GEGL_EXPORT void glVertex2s(GLshort x,GLshort y);
GEGL_EXPORT void glGetVertexAttribLui64vNV(GLuint index,GLenum pname,GLuint64EXT* params);
GEGL_EXPORT void glGetProgramStringARB(GLenum target,GLenum pname,void* string);
GEGL_EXPORT void glFlushMappedBufferRange(GLenum target,GLintptr offset,GLsizeiptr length);
GEGL_EXPORT void glVertexAttribI3uiEXT(GLuint index,GLuint x,GLuint y,GLuint z);
GEGL_EXPORT void glLineWidthxOES(GLfixed width);
GEGL_EXPORT void glProgramUniformMatrix2fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glGetTextureParameterIuivEXT(GLuint texture,GLenum target,GLenum pname,GLuint* params);
GEGL_EXPORT void glGetMultiTexEnvivEXT(GLenum texunit,GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glPixelTexGenParameterivSGIS(GLenum pname,const GLint* params);
GEGL_EXPORT void glGenQueries(GLsizei n,GLuint* ids);
GEGL_EXPORT void glGetPixelMapfv(GLenum map,GLfloat* values);
GEGL_EXPORT void glBlendColorEXT(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha);
GEGL_EXPORT void glResetMinmax(GLenum target);
GEGL_EXPORT void glGetnUniformivARB(GLuint program,GLint location,GLsizei bufSize,GLint* params);
GEGL_EXPORT void glVertexBlendARB(GLint count);
GEGL_EXPORT void glVertexAttrib4d(GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w);
GEGL_EXPORT GLint glGetVaryingLocationNV(GLuint program,const GLchar* name);
GEGL_EXPORT void glGetMapAttribParameterivNV(GLenum target,GLuint index,GLenum pname,GLint* params);
GEGL_EXPORT void glTexSubImage3D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,const GLvoid* pixels);
GEGL_EXPORT void glDeleteSamplers(GLsizei count,const GLuint* samplers);
GEGL_EXPORT void glGetLightxOES(GLenum light,GLenum pname,GLfixed* params);
GEGL_EXPORT void glGetVertexAttribArrayObjectfvATI(GLuint index,GLenum pname,GLfloat* params);
GEGL_EXPORT void glVertexArrayNormalOffsetEXT(GLuint vaobj,GLuint buffer,GLenum type,GLsizei stride,GLintptr offset);
GEGL_EXPORT void glGetBufferParameterivARB(GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glGetTextureParameterfv(GLuint texture,GLenum pname,GLfloat* params);
GEGL_EXPORT void glDrawMeshArraysSUN(GLenum mode,GLint first,GLsizei count,GLsizei width);
GEGL_EXPORT void glVertexAttrib4dNV(GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w);
GEGL_EXPORT void glGetMultisamplefvNV(GLenum pname,GLuint index,GLfloat* val);
GEGL_EXPORT void* glMapObjectBufferATI(GLuint buffer);
GEGL_EXPORT void glGetPathCommandsNV(GLuint path,GLubyte* commands);
GEGL_EXPORT void glVertexArrayTexCoordOffsetEXT(GLuint vaobj,GLuint buffer,GLint size,GLenum type,GLsizei stride,GLintptr offset);
GEGL_EXPORT void glGetHistogram(GLenum target,GLboolean reset,GLenum format,GLenum type,GLvoid* values);
GEGL_EXPORT void glMatrixMode(GLenum mode);
GEGL_EXPORT void glColorFormatNV(GLint size,GLenum type,GLsizei stride);
GEGL_EXPORT void glProgramUniformui64NV(GLuint program,GLint location,GLuint64EXT value);
GEGL_EXPORT void glProgramUniformMatrix4x2fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glLoadMatrixxOES(const GLfixed* m);
GEGL_EXPORT void glGetColorTableParameterfvEXT(GLenum target,GLenum pname,GLfloat* params);
GEGL_EXPORT void glRasterPos4i(GLint x,GLint y,GLint z,GLint w);
GEGL_EXPORT void glVertexAttribL2i64NV(GLuint index,GLint64EXT x,GLint64EXT y);
GEGL_EXPORT void glBindTextures(GLuint first,GLsizei count,const GLuint* textures);
GEGL_EXPORT void glMatrixRotatefEXT(GLenum mode,GLfloat angle,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glGetClipPlanexOES(GLenum plane,GLfixed* equation);
GEGL_EXPORT void glSecondaryColor3uivEXT(const GLuint* v);
GEGL_EXPORT void glGetPerfQueryInfoINTEL(GLuint queryId,GLuint queryNameLength,GLchar* queryName,GLuint* dataSize,GLuint* noCounters,GLuint* noInstances,GLuint* capsMask);
GEGL_EXPORT void glGetDoublev(GLenum pname,GLdouble* params);
GEGL_EXPORT void glBindBufferRangeEXT(GLenum target,GLuint index,GLuint buffer,GLintptr offset,GLsizeiptr size);
GEGL_EXPORT void glCompressedTexImage2D(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,const GLvoid* data);
GEGL_EXPORT void* glMapBufferARB(GLenum target,GLenum access);
GEGL_EXPORT void glGetPathSpacingNV(GLenum pathListMode,GLsizei numPaths,GLenum pathNameType,const void* paths,GLuint pathBase,GLfloat advanceScale,GLfloat kerningScale,GLenum transformType,GLfloat* returnedSpacing);
GEGL_EXPORT void glUniform4dv(GLint location,GLsizei count,const GLdouble* value);
GEGL_EXPORT void glGlobalAlphaFactordSUN(GLdouble factor);
GEGL_EXPORT void glProgramUniform3dv(GLuint program,GLint location,GLsizei count,const GLdouble* value);
GEGL_EXPORT void glGetShaderSourceARB(GLhandleARB obj,GLsizei maxLength,GLsizei* length,GLcharARB* source);
GEGL_EXPORT void glVertexAttrib3dvARB(GLuint index,const GLdouble* v);
GEGL_EXPORT void glInvalidateBufferData(GLuint buffer);
GEGL_EXPORT void glMatrixLoad3x2fNV(GLenum matrixMode,const GLfloat* m);
GEGL_EXPORT void glCompressedTextureSubImage1D(GLuint texture,GLint level,GLint xoffset,GLsizei width,GLenum format,GLsizei imageSize,const void* data);
GEGL_EXPORT void glTexCoord3xvOES(const GLfixed* coords);
GEGL_EXPORT void glGenTexturesEXT(GLsizei n,GLuint* textures);
GEGL_EXPORT void glTangent3iEXT(GLint tx,GLint ty,GLint tz);
GEGL_EXPORT void glClearTexImage(GLuint texture,GLint level,GLenum format,GLenum type,const void* data);
GEGL_EXPORT void glBinormal3bvEXT(const GLbyte* v);
GEGL_EXPORT void glUniform3fv(GLint location,GLsizei count,const GLfloat* value);
GEGL_EXPORT void glGetnPixelMapusvARB(GLenum map,GLsizei bufSize,GLushort* values);
GEGL_EXPORT void glMemoryObjectParameterivEXT(GLuint memoryObject,GLenum pname,const GLint* params);
GEGL_EXPORT void glGenSemaphoresEXT(GLsizei n,GLuint* semaphores);
GEGL_EXPORT void glMultiTexCoordP1ui(GLenum texture,GLenum type,GLuint coords);
GEGL_EXPORT void glClearNamedBufferDataEXT(GLuint buffer,GLenum internalformat,GLenum format,GLenum type,const void* data);
GEGL_EXPORT void glUniformMatrix4dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT void glWindowPos3fMESA(GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glDeleteRenderbuffers(GLsizei n,const GLuint* renderbuffers);
GEGL_EXPORT void glGetTextureLevelParameterfvEXT(GLuint texture,GLenum target,GLint level,GLenum pname,GLfloat* params);
GEGL_EXPORT void glGetHistogramParameterxvOES(GLenum target,GLenum pname,GLfixed* params);
GEGL_EXPORT void glMultiDrawElements(GLenum mode,const GLsizei* count,GLenum type,const void*const* indices,GLsizei drawcount);
GEGL_EXPORT void glMakeImageHandleNonResidentNV(GLuint64 handle);
GEGL_EXPORT void glTexSubImage1DEXT(GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLenum type,const void* pixels);
GEGL_EXPORT void glNormalStream3dATI(GLenum stream,GLdouble nx,GLdouble ny,GLdouble nz);
GEGL_EXPORT void glVertexAttribL4i64vNV(GLuint index,const GLint64EXT* v);
GEGL_EXPORT void glDrawBuffers(GLsizei n,const GLenum* bufs);
GEGL_EXPORT void glCopyTextureSubImage1DEXT(GLuint texture,GLenum target,GLint level,GLint xoffset,GLint x,GLint y,GLsizei width);
GEGL_EXPORT void glWindowRectanglesEXT(GLenum mode,GLsizei count,const GLint* box);
GEGL_EXPORT void glNamedFramebufferReadBuffer(GLuint framebuffer,GLenum src);
GEGL_EXPORT void glUniform2i64vARB(GLint location,GLsizei count,const GLint64* value);
GEGL_EXPORT void glVertexAttribI1uivEXT(GLuint index,const GLuint* v);
GEGL_EXPORT void glGetTexGenfv(GLenum coord,GLenum pname,GLfloat* params);
GEGL_EXPORT void glBeginQueryARB(GLenum target,GLuint id);
GEGL_EXPORT void glUniform1iARB(GLint location,GLint v0);
GEGL_EXPORT void glVertex4bvOES(const GLbyte* coords);
GEGL_EXPORT void glInvalidateSubFramebuffer(GLenum target,GLsizei numAttachments,const GLenum* attachments,GLint x,GLint y,GLsizei width,GLsizei height);
GEGL_EXPORT void glUniform1fvARB(GLint location,GLsizei count,const GLfloat* value);
GEGL_EXPORT GLboolean glTestFenceNV(GLuint fence);
GEGL_EXPORT void glBindTransformFeedback(GLenum target,GLuint id);
GEGL_EXPORT void glMultiTexCoord2iv(GLenum target,const GLint* v);
GEGL_EXPORT void glCopyMultiTexSubImage1DEXT(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLint x,GLint y,GLsizei width);
GEGL_EXPORT void glVariantbvEXT(GLuint id,const GLbyte* addr);
GEGL_EXPORT void glTexCoord1hNV(GLhalfNV s);
GEGL_EXPORT void glGenFencesNV(GLsizei n,GLuint* fences);
GEGL_EXPORT void glRasterPos3iv(const GLint* v);
GEGL_EXPORT void glVertexAttribL2ui64NV(GLuint index,GLuint64EXT x,GLuint64EXT y);
GEGL_EXPORT void glMultiTexCoord1hvNV(GLenum target,const GLhalfNV* v);
GEGL_EXPORT void glGetnConvolutionFilter(GLenum target,GLenum format,GLenum type,GLsizei bufSize,void* image);
GEGL_EXPORT void glNormal3bv(const GLbyte* v);
GEGL_EXPORT void glWeightbvARB(GLint size,const GLbyte* weights);
GEGL_EXPORT void glTexCoord4sv(const GLshort* v);
GEGL_EXPORT void glUniform2uiv(GLint location,GLsizei count,const GLuint* value);
GEGL_EXPORT void glBeginConditionalRenderNVX(GLuint id);
GEGL_EXPORT void glFinish();
GEGL_EXPORT void glColorTableParameterfv(GLenum target,GLenum pname,const GLfloat* params);
GEGL_EXPORT void glFragmentCoverageColorNV(GLuint color);
GEGL_EXPORT void glProgramUniform3ivEXT(GLuint program,GLint location,GLsizei count,const GLint* value);
GEGL_EXPORT void glVertexArrayVertexOffsetEXT(GLuint vaobj,GLuint buffer,GLint size,GLenum type,GLsizei stride,GLintptr offset);
GEGL_EXPORT void glViewportPositionWScaleNV(GLuint index,GLfloat xcoeff,GLfloat ycoeff);
GEGL_EXPORT void glGetProgramLocalParameterIuivNV(GLenum target,GLuint index,GLuint* params);
GEGL_EXPORT void glReplacementCodeuiTexCoord2fVertex3fvSUN(const GLuint* rc,const GLfloat* tc,const GLfloat* v);
GEGL_EXPORT void glUniform1uiv(GLint location,GLsizei count,const GLuint* value);
GEGL_EXPORT void glUniformMatrix2dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT void glIndexdv(const GLdouble* c);
GEGL_EXPORT void glSecondaryColor3ivEXT(const GLint* v);
GEGL_EXPORT void glTexCoord3iv(const GLint* v);
GEGL_EXPORT void glVertexStream4fvATI(GLenum stream,const GLfloat* coords);
GEGL_EXPORT void glDeformationMap3fSGIX(GLenum target,GLfloat u1,GLfloat u2,GLint ustride,GLint uorder,GLfloat v1,GLfloat v2,GLint vstride,GLint vorder,GLfloat w1,GLfloat w2,GLint wstride,GLint worder,const GLfloat* points);
GEGL_EXPORT void glClearDepth(GLclampd depth);
GEGL_EXPORT GLuint glGenAsyncMarkersSGIX(GLsizei range);
GEGL_EXPORT void glDisableIndexedEXT(GLenum target,GLuint index);
GEGL_EXPORT void glVertexWeightfvEXT(const GLfloat* weight);
GEGL_EXPORT void glGetProgramLocalParameterIivNV(GLenum target,GLuint index,GLint* params);
GEGL_EXPORT void glCompressedTexImage3DARB(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,const void* data);
GEGL_EXPORT void glProgramParameter4fNV(GLenum target,GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w);
GEGL_EXPORT void glConvolutionParameterxOES(GLenum target,GLenum pname,GLfixed param);
GEGL_EXPORT void glInsertComponentEXT(GLuint res,GLuint src,GLuint num);
GEGL_EXPORT void glCreateTextures(GLenum target,GLsizei n,GLuint* textures);
GEGL_EXPORT void glSecondaryColor3iv(const GLint* v);
GEGL_EXPORT void glCreateBuffers(GLsizei n,GLuint* buffers);
GEGL_EXPORT void glMultiTexCoord2xvOES(GLenum texture,const GLfixed* coords);
GEGL_EXPORT void glTexGenxvOES(GLenum coord,GLenum pname,const GLfixed* params);
GEGL_EXPORT void glMultTransposeMatrixf(const GLfloat m[16]);
GEGL_EXPORT void glBeginTransformFeedbackEXT(GLenum primitiveMode);
GEGL_EXPORT void glTexCoord2fColor3fVertex3fSUN(GLfloat s,GLfloat t,GLfloat r,GLfloat g,GLfloat b,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glNormal3sv(const GLshort* v);
GEGL_EXPORT void glFreeObjectBufferATI(GLuint buffer);
GEGL_EXPORT void glBlendBarrierNV();
GEGL_EXPORT void glUniform4i64vNV(GLint location,GLsizei count,const GLint64EXT* value);
GEGL_EXPORT void glGetnUniformuivARB(GLuint program,GLint location,GLsizei bufSize,GLuint* params);
GEGL_EXPORT void glAlphaFragmentOp3ATI(GLenum op,GLuint dst,GLuint dstMod,GLuint arg1,GLuint arg1Rep,GLuint arg1Mod,GLuint arg2,GLuint arg2Rep,GLuint arg2Mod,GLuint arg3,GLuint arg3Rep,GLuint arg3Mod);
GEGL_EXPORT void glProgramEnvParameters4fvEXT(GLenum target,GLuint index,GLsizei count,const GLfloat* params);
GEGL_EXPORT void glBlendFuncSeparateEXT(GLenum sfactorRGB,GLenum dfactorRGB,GLenum sfactorAlpha,GLenum dfactorAlpha);
GEGL_EXPORT void glConvolutionParameterivEXT(GLenum target,GLenum pname,const GLint* params);
GEGL_EXPORT void glPixelTexGenSGIX(GLenum mode);
GEGL_EXPORT void glDeleteProgram(GLuint program);
GEGL_EXPORT void glUniformMatrix4x3dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT void glGetVideoCaptureStreamivNV(GLuint video_capture_slot,GLuint stream,GLenum pname,GLint* params);
GEGL_EXPORT void glProgramUniform4uiEXT(GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2,GLuint v3);
GEGL_EXPORT void glMakeImageHandleNonResidentARB(GLuint64 handle);
GEGL_EXPORT void glSecondaryColor3dEXT(GLdouble red,GLdouble green,GLdouble blue);
GEGL_EXPORT void glDeleteQueries(GLsizei n,const GLuint* ids);
GEGL_EXPORT void glNormalP3uiv(GLenum type,const GLuint* coords);
GEGL_EXPORT void glRasterPos2d(GLdouble x,GLdouble y);
GEGL_EXPORT void glInitNames();
GEGL_EXPORT void glBinormal3fvEXT(const GLfloat* v);
GEGL_EXPORT void glColor3dv(const GLdouble* v);
GEGL_EXPORT void glVertexArrayVertexAttribDivisorEXT(GLuint vaobj,GLuint index,GLuint divisor);
GEGL_EXPORT void glArrayElementEXT(GLint i);
GEGL_EXPORT void glProgramParameter4dNV(GLenum target,GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w);
GEGL_EXPORT void glIndexxOES(GLfixed component);
GEGL_EXPORT void glUniform3uivEXT(GLint location,GLsizei count,const GLuint* value);
GEGL_EXPORT void glPopGroupMarkerEXT();
GEGL_EXPORT void glClearNamedFramebufferuiv(GLuint framebuffer,GLenum buffer,GLint drawbuffer,const GLuint* value);
GEGL_EXPORT void glSetLocalConstantEXT(GLuint id,GLenum type,const void* addr);
GEGL_EXPORT void glProgramUniform1ui64NV(GLuint program,GLint location,GLuint64EXT x);
GEGL_EXPORT void glColor4hvNV(const GLhalfNV* v);
GEGL_EXPORT void glGetVertexAttribfv(GLuint index,GLenum pname,GLfloat* params);
GEGL_EXPORT void glDispatchCompute(GLuint num_groups_x,GLuint num_groups_y,GLuint num_groups_z);
GEGL_EXPORT void glGetActiveAttrib(GLuint program,GLuint index,GLsizei bufSize,GLsizei* length,GLint* size,GLenum* type,GLchar* name);
GEGL_EXPORT void glFragmentColorMaterialSGIX(GLenum face,GLenum mode);
GEGL_EXPORT void glTexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid* pixels);
GEGL_EXPORT void glGetnMinmaxARB(GLenum target,GLboolean reset,GLenum format,GLenum type,GLsizei bufSize,void* values);
GEGL_EXPORT void glLogicOp(GLenum opcode);
GEGL_EXPORT void glProgramUniformMatrix3x4fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glWindowPos4iMESA(GLint x,GLint y,GLint z,GLint w);
GEGL_EXPORT void glPixelTransferf(GLenum pname,GLfloat param);
GEGL_EXPORT void glGetTextureParameterIuiv(GLuint texture,GLenum pname,GLuint* params);
GEGL_EXPORT void glMultiTexCoord1xOES(GLenum texture,GLfixed s);
GEGL_EXPORT void glProgramUniformMatrix4dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT void glGetnUniformiv(GLuint program,GLint location,GLsizei bufSize,GLint* params);
GEGL_EXPORT void glFramebufferTexture1DEXT(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level);
GEGL_EXPORT void glVertexPointervINTEL(GLint size,GLenum type,const void** pointer);
GEGL_EXPORT void glTextureParameterIiv(GLuint texture,GLenum pname,const GLint* params);
GEGL_EXPORT void glGetSeparableFilterEXT(GLenum target,GLenum format,GLenum type,void* row,void* column,void* span);
GEGL_EXPORT void glMultiTexCoord3iARB(GLenum target,GLint s,GLint t,GLint r);
GEGL_EXPORT void glRasterPos4xvOES(const GLfixed* coords);
GEGL_EXPORT void glDrawTransformFeedbackStream(GLenum mode,GLuint id,GLuint stream);
GEGL_EXPORT void glVertex3hvNV(const GLhalfNV* v);
GEGL_EXPORT void glVertexArrayMultiTexCoordOffsetEXT(GLuint vaobj,GLuint buffer,GLenum texunit,GLint size,GLenum type,GLsizei stride,GLintptr offset);
GEGL_EXPORT void glProvokingVertex(GLenum mode);
GEGL_EXPORT void glAccumxOES(GLenum op,GLfixed value);
GEGL_EXPORT void glShaderBinary(GLsizei count,const GLuint* shaders,GLenum binaryformat,const void* binary,GLsizei length);
GEGL_EXPORT void glGetMultiTexGenivEXT(GLenum texunit,GLenum coord,GLenum pname,GLint* params);
GEGL_EXPORT void glPointParameterxvOES(GLenum pname,const GLfixed* params);
GEGL_EXPORT void glCreateStatesNV(GLsizei n,GLuint* states);
GEGL_EXPORT void glClearDepthdNV(GLdouble depth);
GEGL_EXPORT void glClearColorIuiEXT(GLuint red,GLuint green,GLuint blue,GLuint alpha);
GEGL_EXPORT void glBindMultiTextureEXT(GLenum texunit,GLenum target,GLuint texture);
GEGL_EXPORT void glTexGeniv(GLenum coord,GLenum pname,const GLint* params);
GEGL_EXPORT void glDrawElements(GLenum mode,GLsizei count,GLenum type,const GLvoid* indices);
GEGL_EXPORT void glProgramUniform4iv(GLuint program,GLint location,GLsizei count,const GLint* value);
GEGL_EXPORT void glDisableVertexArrayEXT(GLuint vaobj,GLenum array);
GEGL_EXPORT void glProgramUniform3ui64NV(GLuint program,GLint location,GLuint64EXT x,GLuint64EXT y,GLuint64EXT z);
GEGL_EXPORT void glClientActiveTexture(GLenum texture);
GEGL_EXPORT void glMultiTexParameterIivEXT(GLenum texunit,GLenum target,GLenum pname,const GLint* params);
GEGL_EXPORT void glUniform1i64ARB(GLint location,GLint64 x);
GEGL_EXPORT void glUniform1iv(GLint location,GLsizei count,const GLint* value);
GEGL_EXPORT void glMulticastBarrierNV();
GEGL_EXPORT void glVertexAttribArrayObjectATI(GLuint index,GLint size,GLenum type,GLboolean normalized,GLsizei stride,GLuint buffer,GLuint offset);
GEGL_EXPORT void glUniform2iARB(GLint location,GLint v0,GLint v1);
GEGL_EXPORT void glDrawArraysInstanced(GLenum mode,GLint first,GLsizei count,GLsizei instancecount);
GEGL_EXPORT void glVertexAttrib2sNV(GLuint index,GLshort x,GLshort y);
GEGL_EXPORT void glTexBufferEXT(GLenum target,GLenum internalformat,GLuint buffer);
GEGL_EXPORT void glVertexStream2fATI(GLenum stream,GLfloat x,GLfloat y);
GEGL_EXPORT void glDebugMessageCallbackAMD(GLDEBUGPROCAMD callback,void* userParam);
GEGL_EXPORT void glSamplerParameteriv(GLuint sampler,GLenum pname,const GLint* param);
GEGL_EXPORT void glVertexAttrib4uiv(GLuint index,const GLuint* v);
GEGL_EXPORT void glEndQueryIndexed(GLenum target,GLuint index);
GEGL_EXPORT void glNormalStream3sATI(GLenum stream,GLshort nx,GLshort ny,GLshort nz);
GEGL_EXPORT void glProgramParameteriARB(GLuint program,GLenum pname,GLint value);
GEGL_EXPORT void glTexEnvxOES(GLenum target,GLenum pname,GLfixed param);
GEGL_EXPORT void glProgramUniform1iv(GLuint program,GLint location,GLsizei count,const GLint* value);
GEGL_EXPORT void glDisableVertexAttribAPPLE(GLuint index,GLenum pname);
GEGL_EXPORT void glBindRenderbuffer(GLenum target,GLuint renderbuffer);
GEGL_EXPORT void glMultiTexSubImage3DEXT(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,const void* pixels);
GEGL_EXPORT GLboolean glIsProgram(GLuint program);
GEGL_EXPORT void glMultiDrawElementsIndirectAMD(GLenum mode,GLenum type,const void* indirect,GLsizei primcount,GLsizei stride);
GEGL_EXPORT void glGetProgramInfoLog(GLuint program,GLsizei bufSize,GLsizei* length,GLchar* infoLog);
GEGL_EXPORT void glGetLocalConstantBooleanvEXT(GLuint id,GLenum value,GLboolean* data);
GEGL_EXPORT void glPixelTransformParameteriEXT(GLenum target,GLenum pname,GLint param);
GEGL_EXPORT void glTexCoord4bOES(GLbyte s,GLbyte t,GLbyte r,GLbyte q);
GEGL_EXPORT void glVertexAttrib4fv(GLuint index,const GLfloat* v);
GEGL_EXPORT void glProgramUniformMatrix2x3dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT void glProgramEnvParametersI4uivNV(GLenum target,GLuint index,GLsizei count,const GLuint* params);
GEGL_EXPORT void glTexCoord3xOES(GLfixed s,GLfixed t,GLfixed r);
GEGL_EXPORT void glLoadTransposeMatrixfARB(const GLfloat* m);
GEGL_EXPORT void glImageTransformParameteriHP(GLenum target,GLenum pname,GLint param);
GEGL_EXPORT void glMultiTexCoord4xOES(GLenum texture,GLfixed s,GLfixed t,GLfixed r,GLfixed q);
GEGL_EXPORT void glVertexAttribs3fvNV(GLuint index,GLsizei count,const GLfloat* v);
GEGL_EXPORT void glVertexAttrib2fv(GLuint index,const GLfloat* v);
GEGL_EXPORT void glUniform3ui64NV(GLint location,GLuint64EXT x,GLuint64EXT y,GLuint64EXT z);
GEGL_EXPORT void glCombinerParameterfvNV(GLenum pname,const GLfloat* params);
GEGL_EXPORT void glFragmentMaterialiSGIX(GLenum face,GLenum pname,GLint param);
GEGL_EXPORT void glGetBooleani_v(GLenum target,GLuint index,GLboolean* data);
GEGL_EXPORT GLuint glGetProgramResourceIndex(GLuint program,GLenum programInterface,const GLchar* name);
GEGL_EXPORT void glBeginConditionalRenderNV(GLuint id,GLenum mode);
GEGL_EXPORT void glDisableClientState(GLenum cap);
GEGL_EXPORT void glPathFogGenNV(GLenum genMode);
GEGL_EXPORT void glStencilThenCoverFillPathNV(GLuint path,GLenum fillMode,GLuint mask,GLenum coverMode);
GEGL_EXPORT void glVertexArrayIndexOffsetEXT(GLuint vaobj,GLuint buffer,GLenum type,GLsizei stride,GLintptr offset);
GEGL_EXPORT void glProgramBufferParametersIuivNV(GLenum target,GLuint bindingIndex,GLuint wordIndex,GLsizei count,const GLuint* params);
GEGL_EXPORT void glPixelTransformParameterivEXT(GLenum target,GLenum pname,const GLint* params);
GEGL_EXPORT void glDisableClientStateiEXT(GLenum array,GLuint index);
GEGL_EXPORT void glTexBufferARB(GLenum target,GLenum internalformat,GLuint buffer);
GEGL_EXPORT void glGetLocalConstantIntegervEXT(GLuint id,GLenum value,GLint* data);
GEGL_EXPORT void glColor4uiv(const GLuint* v);
GEGL_EXPORT void glProgramUniform3i(GLuint program,GLint location,GLint v0,GLint v1,GLint v2);
GEGL_EXPORT void glMultiDrawElementsIndirectBindlessCountNV(GLenum mode,GLenum type,const void* indirect,GLsizei drawCount,GLsizei maxDrawCount,GLsizei stride,GLint vertexBufferCount);
GEGL_EXPORT void glGetBufferPointervARB(GLenum target,GLenum pname,void** params);
GEGL_EXPORT void glMultiTexParameterIuivEXT(GLenum texunit,GLenum target,GLenum pname,const GLuint* params);
GEGL_EXPORT void glEvalMesh2(GLenum mode,GLint i1,GLint i2,GLint j1,GLint j2);
GEGL_EXPORT void glEvalMesh1(GLenum mode,GLint i1,GLint i2);
GEGL_EXPORT void glProgramUniform3f(GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2);
GEGL_EXPORT void glStencilThenCoverFillPathInstancedNV(GLsizei numPaths,GLenum pathNameType,const void* paths,GLuint pathBase,GLenum fillMode,GLuint mask,GLenum coverMode,GLenum transformType,const GLfloat* transformValues);
GEGL_EXPORT void glProgramUniform3d(GLuint program,GLint location,GLdouble v0,GLdouble v1,GLdouble v2);
GEGL_EXPORT void glMapVertexAttrib1dAPPLE(GLuint index,GLuint size,GLdouble u1,GLdouble u2,GLint stride,GLint order,const GLdouble* points);
GEGL_EXPORT void glEvalCoord2fv(const GLfloat* u);
GEGL_EXPORT void glGetUniformivARB(GLhandleARB programObj,GLint location,GLint* params);
GEGL_EXPORT void glLoadTransposeMatrixd(const GLdouble m[16]);
GEGL_EXPORT void glLoadTransposeMatrixf(const GLfloat m[16]);
GEGL_EXPORT void glGetPointervEXT(GLenum pname,void** params);
GEGL_EXPORT void glSignalVkSemaphoreNV(GLuint64 vkSemaphore);
GEGL_EXPORT void glEndConditionalRenderNV();
GEGL_EXPORT void glTexCoord2fNormal3fVertex3fSUN(GLfloat s,GLfloat t,GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glUniform3i64vARB(GLint location,GLsizei count,const GLint64* value);
GEGL_EXPORT void glProgramUniform2uiEXT(GLuint program,GLint location,GLuint v0,GLuint v1);
GEGL_EXPORT void glVertexAttribI1ui(GLuint index,GLuint x);
GEGL_EXPORT void glProgramNamedParameter4dvNV(GLuint id,GLsizei len,const GLubyte* name,const GLdouble* v);
GEGL_EXPORT void glCompileCommandListNV(GLuint list);
GEGL_EXPORT void glGetRenderbufferParameterivEXT(GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glGetnPolygonStipple(GLsizei bufSize,GLubyte* pattern);
GEGL_EXPORT GLboolean glIsBufferResidentNV(GLenum target);
GEGL_EXPORT void glSecondaryColor3ubvEXT(const GLubyte* v);
GEGL_EXPORT void glGetNamedRenderbufferParameterivEXT(GLuint renderbuffer,GLenum pname,GLint* params);
GEGL_EXPORT void glNamedFramebufferSampleLocationsfvARB(GLuint framebuffer,GLuint start,GLsizei count,const GLfloat* v);
GEGL_EXPORT void glMultiTexGendvEXT(GLenum texunit,GLenum coord,GLenum pname,const GLdouble* params);
GEGL_EXPORT void glVertexArrayRangeNV(GLsizei length,const void* pointer);
GEGL_EXPORT GLboolean glIsTextureHandleResidentNV(GLuint64 handle);
GEGL_EXPORT void glGetProgramEnvParameterdvARB(GLenum target,GLuint index,GLdouble* params);
GEGL_EXPORT GLboolean glIsNamedStringARB(GLint namelen,const GLchar* name);
GEGL_EXPORT void glSecondaryColorFormatNV(GLint size,GLenum type,GLsizei stride);
GEGL_EXPORT void glVertexAttrib4ubvNV(GLuint index,const GLubyte* v);
GEGL_EXPORT void glTagSampleBufferSGIX();
GEGL_EXPORT void glVDPAUUnregisterSurfaceNV(GLvdpauSurfaceNV surface);
GEGL_EXPORT void glGetPerfQueryIdByNameINTEL(GLchar* queryName,GLuint* queryId);
GEGL_EXPORT void glGetInteger64v(GLenum pname,GLint64* data);
GEGL_EXPORT void glClipPlane(GLenum plane,const GLdouble* equation);
GEGL_EXPORT void glColor4ubVertex3fSUN(GLubyte r,GLubyte g,GLubyte b,GLubyte a,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glIndexub(GLubyte c);
GEGL_EXPORT void glGetProgramEnvParameterfvARB(GLenum target,GLuint index,GLfloat* params);
GEGL_EXPORT void glVertexAttrib4usvARB(GLuint index,const GLushort* v);
GEGL_EXPORT void glNamedFramebufferRenderbuffer(GLuint framebuffer,GLenum attachment,GLenum renderbuffertarget,GLuint renderbuffer);
GEGL_EXPORT void glProgramUniformMatrix3x4dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT GLboolean glTestFenceAPPLE(GLuint fence);
GEGL_EXPORT void glVertexAttrib4Niv(GLuint index,const GLint* v);
GEGL_EXPORT void glVertexAttribL2i64vNV(GLuint index,const GLint64EXT* v);
GEGL_EXPORT void glColorP4uiv(GLenum type,const GLuint* color);
GEGL_EXPORT void glUniformMatrix2x3fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glCallCommandListNV(GLuint list);
GEGL_EXPORT void glClearBufferiv(GLenum buffer,GLint drawbuffer,const GLint* value);
GEGL_EXPORT void glNamedStringARB(GLenum type,GLint namelen,const GLchar* name,GLint stringlen,const GLchar* string);
GEGL_EXPORT void glMatrixMult3x2fNV(GLenum matrixMode,const GLfloat* m);
GEGL_EXPORT void glGetNamedProgramStringEXT(GLuint program,GLenum target,GLenum pname,void* string);
GEGL_EXPORT void glGetnHistogramARB(GLenum target,GLboolean reset,GLenum format,GLenum type,GLsizei bufSize,void* values);
GEGL_EXPORT void glGetTextureLevelParameterfv(GLuint texture,GLint level,GLenum pname,GLfloat* params);
GEGL_EXPORT void glMultiTexCoord1fv(GLenum target,const GLfloat* v);
GEGL_EXPORT void glBitmapxOES(GLsizei width,GLsizei height,GLfixed xorig,GLfixed yorig,GLfixed xmove,GLfixed ymove,const GLubyte* bitmap);
GEGL_EXPORT void glGetSamplerParameterIuiv(GLuint sampler,GLenum pname,GLuint* params);
GEGL_EXPORT void glTexCoordP3ui(GLenum type,GLuint coords);
GEGL_EXPORT void glTextureSubImage1D(GLuint texture,GLint level,GLint xoffset,GLsizei width,GLenum format,GLenum type,const void* pixels);
GEGL_EXPORT void glVertexAttribLPointerEXT(GLuint index,GLint size,GLenum type,GLsizei stride,const void* pointer);
GEGL_EXPORT void glFogCoordPointerEXT(GLenum type,GLsizei stride,const void* pointer);
GEGL_EXPORT void glWindowPos3s(GLshort x,GLshort y,GLshort z);
GEGL_EXPORT void glVertexAttribs2svNV(GLuint index,GLsizei count,const GLshort* v);
GEGL_EXPORT void glTextureImage3DEXT(GLuint texture,GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,const void* pixels);
GEGL_EXPORT void glWindowPos3i(GLint x,GLint y,GLint z);
GEGL_EXPORT void glWindowPos3d(GLdouble x,GLdouble y,GLdouble z);
GEGL_EXPORT void glWindowPos3f(GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT GLboolean glIsEnabledIndexedEXT(GLenum target,GLuint index);
GEGL_EXPORT void glGetNamedProgramivEXT(GLuint program,GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glVertex3xvOES(const GLfixed* coords);
GEGL_EXPORT void glColor3us(GLushort red,GLushort green,GLushort blue);
GEGL_EXPORT void glBeginPerfMonitorAMD(GLuint monitor);
GEGL_EXPORT void glProgramUniformMatrix4x3dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT void glGetNamedProgramLocalParameterIuivEXT(GLuint program,GLenum target,GLuint index,GLuint* params);
GEGL_EXPORT void glReadnPixels(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,void* data);
GEGL_EXPORT void glMultiTexCoord4f(GLenum target,GLfloat s,GLfloat t,GLfloat r,GLfloat q);
GEGL_EXPORT void glColor3ub(GLubyte red,GLubyte green,GLubyte blue);
GEGL_EXPORT void glMultiTexCoord4d(GLenum target,GLdouble s,GLdouble t,GLdouble r,GLdouble q);
GEGL_EXPORT void glVertexAttribL3ui64NV(GLuint index,GLuint64EXT x,GLuint64EXT y,GLuint64EXT z);
GEGL_EXPORT void glColor3ui(GLuint red,GLuint green,GLuint blue);
GEGL_EXPORT void glProgramUniform4fvEXT(GLuint program,GLint location,GLsizei count,const GLfloat* value);
GEGL_EXPORT void glVertexAttrib2sARB(GLuint index,GLshort x,GLshort y);
GEGL_EXPORT void glMultiTexCoord4i(GLenum target,GLint s,GLint t,GLint r,GLint q);
GEGL_EXPORT GLenum glCheckFramebufferStatusEXT(GLenum target);
GEGL_EXPORT void glGetnMapivARB(GLenum target,GLenum query,GLsizei bufSize,GLint* v);
GEGL_EXPORT void glMultiTexCoord1ivARB(GLenum target,const GLint* v);
GEGL_EXPORT void glDisableVertexAttribArrayARB(GLuint index);
GEGL_EXPORT void glGetPolygonStipple(GLubyte* mask);
GEGL_EXPORT void glVertexAttribI4ui(GLuint index,GLuint x,GLuint y,GLuint z,GLuint w);
GEGL_EXPORT void glGetPathDashArrayNV(GLuint path,GLfloat* dashArray);
GEGL_EXPORT void glMultiTexRenderbufferEXT(GLenum texunit,GLenum target,GLuint renderbuffer);
GEGL_EXPORT void glCopyTextureSubImage1D(GLuint texture,GLint level,GLint xoffset,GLint x,GLint y,GLsizei width);
GEGL_EXPORT void glDeleteOcclusionQueriesNV(GLsizei n,const GLuint* ids);
GEGL_EXPORT void glVertex4hvNV(const GLhalfNV* v);
GEGL_EXPORT void glGetnTexImage(GLenum target,GLint level,GLenum format,GLenum type,GLsizei bufSize,void* pixels);
GEGL_EXPORT void glProgramLocalParameter4dARB(GLenum target,GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w);
GEGL_EXPORT void glBlendEquation(GLenum mode);
GEGL_EXPORT void glUnlockArraysEXT();
GEGL_EXPORT void glGetQueryObjectui64vEXT(GLuint id,GLenum pname,GLuint64* params);
GEGL_EXPORT void glVertexAttribI4uivEXT(GLuint index,const GLuint* v);
GEGL_EXPORT void glUniform1i64vNV(GLint location,GLsizei count,const GLint64EXT* value);
GEGL_EXPORT void glMultiTexCoord3dv(GLenum target,const GLdouble* v);
GEGL_EXPORT void glColor4sv(const GLshort* v);
GEGL_EXPORT void glVertexStream4ivATI(GLenum stream,const GLint* coords);
GEGL_EXPORT void glPopClientAttrib();
GEGL_EXPORT void glClearBufferData(GLenum target,GLenum internalformat,GLenum format,GLenum type,const void* data);
GEGL_EXPORT void glGetProgramivNV(GLuint id,GLenum pname,GLint* params);
GEGL_EXPORT void glBeginTransformFeedback(GLenum primitiveMode);
GEGL_EXPORT void glFinishObjectAPPLE(GLenum object,GLint name);
GEGL_EXPORT void glGetMinmaxParameterivEXT(GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glColor3iv(const GLint* v);
GEGL_EXPORT void glVertexAttrib3sv(GLuint index,const GLshort* v);
GEGL_EXPORT void glCompressedTexImage1D(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLint border,GLsizei imageSize,const GLvoid* data);
GEGL_EXPORT void glDeleteTransformFeedbacks(GLsizei n,const GLuint* ids);
GEGL_EXPORT void glGetVideoi64vNV(GLuint video_slot,GLenum pname,GLint64EXT* params);
GEGL_EXPORT void glDrawRangeElementsBaseVertex(GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const void* indices,GLint basevertex);
GEGL_EXPORT void glUniform4i64vARB(GLint location,GLsizei count,const GLint64* value);
GEGL_EXPORT void glTextureStorage3DMultisampleEXT(GLuint texture,GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedsamplelocations);
GEGL_EXPORT void glGetTexParameterfv(GLenum target,GLenum pname,GLfloat* params);
GEGL_EXPORT void glProgramUniformui64vNV(GLuint program,GLint location,GLsizei count,const GLuint64EXT* value);
GEGL_EXPORT void glCompressedMultiTexImage1DEXT(GLenum texunit,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLint border,GLsizei imageSize,const void* bits);
GEGL_EXPORT void glProgramUniform2ivEXT(GLuint program,GLint location,GLsizei count,const GLint* value);
GEGL_EXPORT void glPushGroupMarkerEXT(GLsizei length,const GLchar* marker);
GEGL_EXPORT void glVertexAttrib1dv(GLuint index,const GLdouble* v);
GEGL_EXPORT void glMatrixLoadIdentityEXT(GLenum mode);
GEGL_EXPORT void glMultTransposeMatrixxOES(const GLfixed* m);
GEGL_EXPORT void glGetPixelMapxv(GLenum map,GLint size,GLfixed* values);
GEGL_EXPORT void glFramebufferSampleLocationsfvARB(GLenum target,GLuint start,GLsizei count,const GLfloat* v);
GEGL_EXPORT void glGetLightiv(GLenum light,GLenum pname,GLint* params);
GEGL_EXPORT void glBlendFuncSeparatei(GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha);
GEGL_EXPORT GLboolean glAcquireKeyedMutexWin32EXT(GLuint memory,GLuint64 key,GLuint timeout);
GEGL_EXPORT void glGetBooleanIndexedvEXT(GLenum target,GLuint index,GLboolean* data);
GEGL_EXPORT void glGetProgramSubroutineParameteruivNV(GLenum target,GLuint index,GLuint* param);
GEGL_EXPORT void glUniform2ui(GLint location,GLuint v0,GLuint v1);
GEGL_EXPORT void glApplyFramebufferAttachmentCMAAINTEL();
GEGL_EXPORT void glWindowPos2fv(const GLfloat* v);
GEGL_EXPORT void glWaitVkSemaphoreNV(GLuint64 vkSemaphore);
GEGL_EXPORT void glDisablei(GLenum target,GLuint index);
GEGL_EXPORT void glSelectPerfMonitorCountersAMD(GLuint monitor,GLboolean enable,GLuint group,GLint numCounters,GLuint* counterList);
GEGL_EXPORT void glGetVertexAttribLi64vNV(GLuint index,GLenum pname,GLint64EXT* params);
GEGL_EXPORT void glBlendFuncSeparateiARB(GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha);
GEGL_EXPORT void glWeightuivARB(GLint size,const GLuint* weights);
GEGL_EXPORT void glWindowPos2iARB(GLint x,GLint y);
GEGL_EXPORT void glGetProgramLocalParameterdvARB(GLenum target,GLuint index,GLdouble* params);
GEGL_EXPORT void glGetUniformui64vARB(GLuint program,GLint location,GLuint64* params);
GEGL_EXPORT void glSecondaryColor3us(GLushort red,GLushort green,GLushort blue);
GEGL_EXPORT void glGetSynciv(GLsync sync,GLenum pname,GLsizei bufSize,GLsizei* length,GLint* values);
GEGL_EXPORT void glMakeImageHandleResidentARB(GLuint64 handle,GLenum access);
GEGL_EXPORT void glGetProgramNamedParameterfvNV(GLuint id,GLsizei len,const GLubyte* name,GLfloat* params);
GEGL_EXPORT void glTextureStorage3D(GLuint texture,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth);
GEGL_EXPORT void glVertexAttrib4svNV(GLuint index,const GLshort* v);
GEGL_EXPORT void glProgramUniform2i(GLuint program,GLint location,GLint v0,GLint v1);
GEGL_EXPORT void glListDrawCommandsStatesClientNV(GLuint list,GLuint segment,const void** indirects,const GLsizei* sizes,const GLuint* states,const GLuint* fbos,GLuint count);
GEGL_EXPORT void glProgramLocalParametersI4uivNV(GLenum target,GLuint index,GLsizei count,const GLuint* params);
GEGL_EXPORT void glBeginTransformFeedbackNV(GLenum primitiveMode);
GEGL_EXPORT void glGetProgramBinary(GLuint program,GLsizei bufSize,GLsizei* length,GLenum* binaryFormat,void* binary);
GEGL_EXPORT void glBinormal3iEXT(GLint bx,GLint by,GLint bz);
GEGL_EXPORT void glEvalPoint1(GLint i);
GEGL_EXPORT void glEvalPoint2(GLint i,GLint j);
GEGL_EXPORT void glPauseTransformFeedback();
GEGL_EXPORT void glWindowPos2sMESA(GLshort x,GLshort y);
GEGL_EXPORT void glGlobalAlphaFactorbSUN(GLbyte factor);
GEGL_EXPORT void glCreateTransformFeedbacks(GLsizei n,GLuint* ids);
GEGL_EXPORT void glTexturePageCommitmentEXT(GLuint texture,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLboolean commit);
GEGL_EXPORT void glTransformFeedbackVaryingsNV(GLuint program,GLsizei count,const GLint* locations,GLenum bufferMode);
GEGL_EXPORT void glTexSubImage1D(GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLenum type,const GLvoid* pixels);
GEGL_EXPORT void glConvolutionParameterfvEXT(GLenum target,GLenum pname,const GLfloat* params);
GEGL_EXPORT void glBlitFramebufferEXT(GLint srcX0,GLint srcY0,GLint srcX1,GLint srcY1,GLint dstX0,GLint dstY0,GLint dstX1,GLint dstY1,GLbitfield mask,GLenum filter);
GEGL_EXPORT void glUniformMatrix4fvARB(GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glProgramEnvParameter4dvARB(GLenum target,GLuint index,const GLdouble* params);
GEGL_EXPORT void glTextureStorageMem2DEXT(GLuint texture,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,GLuint memory,GLuint64 offset);
GEGL_EXPORT void glVertexAttribP3uiv(GLuint index,GLenum type,GLboolean normalized,const GLuint* value);
GEGL_EXPORT void glFogCoordFormatNV(GLenum type,GLsizei stride);
GEGL_EXPORT void glGetMultiTexLevelParameterivEXT(GLenum texunit,GLenum target,GLint level,GLenum pname,GLint* params);
GEGL_EXPORT GLboolean glIsOcclusionQueryNV(GLuint id);
GEGL_EXPORT void glCompressedTexImage2DARB(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,const void* data);
GEGL_EXPORT void glGetProgramEnvParameterIuivNV(GLenum target,GLuint index,GLuint* params);
GEGL_EXPORT void glVertexAttrib4sv(GLuint index,const GLshort* v);
GEGL_EXPORT void glVertexAttrib4fvARB(GLuint index,const GLfloat* v);
GEGL_EXPORT void glLoadName(GLuint name);
GEGL_EXPORT void glBindVertexShaderEXT(GLuint id);
GEGL_EXPORT void glGetNamedProgramLocalParameterIivEXT(GLuint program,GLenum target,GLuint index,GLint* params);
GEGL_EXPORT void glProgramUniform3uiEXT(GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2);
GEGL_EXPORT void glProgramUniformMatrix4x2dvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT void glTexCoord1hvNV(const GLhalfNV* v);
GEGL_EXPORT void glLoadMatrixd(const GLdouble* m);
GEGL_EXPORT void glTexParameterfv(GLenum target,GLenum pname,const GLfloat* params);
GEGL_EXPORT void glVariantdvEXT(GLuint id,const GLdouble* addr);
GEGL_EXPORT void glCullParameterfvEXT(GLenum pname,GLfloat* params);
GEGL_EXPORT void glUniform3dv(GLint location,GLsizei count,const GLdouble* value);
GEGL_EXPORT void glProgramUniform3fv(GLuint program,GLint location,GLsizei count,const GLfloat* value);
GEGL_EXPORT GLboolean glIsBufferARB(GLuint buffer);
GEGL_EXPORT void glMultiTexCoord1bOES(GLenum texture,GLbyte s);
GEGL_EXPORT void glFogCoordhNV(GLhalfNV fog);
GEGL_EXPORT void glFramebufferSampleLocationsfvNV(GLenum target,GLuint start,GLsizei count,const GLfloat* v);
GEGL_EXPORT GLuint glGenSymbolsEXT(GLenum datatype,GLenum storagetype,GLenum range,GLuint components);
GEGL_EXPORT void glGetConvolutionFilter(GLenum target,GLenum format,GLenum type,GLvoid* image);
GEGL_EXPORT void glProgramUniform1fvEXT(GLuint program,GLint location,GLsizei count,const GLfloat* value);
GEGL_EXPORT void glGetNextPerfQueryIdINTEL(GLuint queryId,GLuint* nextQueryId);
GEGL_EXPORT void glCompressedTexImage1DARB(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLint border,GLsizei imageSize,const void* data);
GEGL_EXPORT void glBindSamplers(GLuint first,GLsizei count,const GLuint* samplers);
GEGL_EXPORT void glGetProgramEnvParameterIivNV(GLenum target,GLuint index,GLint* params);
GEGL_EXPORT void glGetQueryObjectui64v(GLuint id,GLenum pname,GLuint64* params);
GEGL_EXPORT void glVertexAttribL4ui64vNV(GLuint index,const GLuint64EXT* v);
GEGL_EXPORT void glGetVideoivNV(GLuint video_slot,GLenum pname,GLint* params);
GEGL_EXPORT void glGetTextureImage(GLuint texture,GLint level,GLenum format,GLenum type,GLsizei bufSize,void* pixels);
GEGL_EXPORT void glProgramUniform1fv(GLuint program,GLint location,GLsizei count,const GLfloat* value);
GEGL_EXPORT void glUniformMatrix4fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glColorMask(GLboolean red,GLboolean green,GLboolean blue,GLboolean alpha);
GEGL_EXPORT void glBeginFragmentShaderATI();
GEGL_EXPORT void glMultiDrawArraysEXT(GLenum mode,const GLint* first,const GLsizei* count,GLsizei primcount);
GEGL_EXPORT void glGenNamesAMD(GLenum identifier,GLuint num,GLuint* names);
GEGL_EXPORT void glPathParameteriNV(GLuint path,GLenum pname,GLint value);
GEGL_EXPORT void glCreateCommandListsNV(GLsizei n,GLuint* lists);
GEGL_EXPORT void glDeleteProgramPipelines(GLsizei n,const GLuint* pipelines);
GEGL_EXPORT void glCopyColorSubTableEXT(GLenum target,GLsizei start,GLint x,GLint y,GLsizei width);
GEGL_EXPORT void glVariantsvEXT(GLuint id,const GLshort* addr);
GEGL_EXPORT void glGenProgramPipelines(GLsizei n,GLuint* pipelines);
GEGL_EXPORT void glVertexArrayEdgeFlagOffsetEXT(GLuint vaobj,GLuint buffer,GLsizei stride,GLintptr offset);
GEGL_EXPORT void glWindowPos2s(GLshort x,GLshort y);
GEGL_EXPORT void glSecondaryColor3iEXT(GLint red,GLint green,GLint blue);
GEGL_EXPORT void glWindowPos2i(GLint x,GLint y);
GEGL_EXPORT void glWindowPos2f(GLfloat x,GLfloat y);
GEGL_EXPORT void glWindowPos2d(GLdouble x,GLdouble y);
GEGL_EXPORT void glUniform4uivEXT(GLint location,GLsizei count,const GLuint* value);
GEGL_EXPORT void glOrthoxOES(GLfixed l,GLfixed r,GLfixed b,GLfixed t,GLfixed n,GLfixed f);
GEGL_EXPORT void glUniformSubroutinesuiv(GLenum shadertype,GLsizei count,const GLuint* indices);
GEGL_EXPORT void glRectdv(const GLdouble* v1,const GLdouble* v2);
GEGL_EXPORT void glProgramUniform1i64vNV(GLuint program,GLint location,GLsizei count,const GLint64EXT* value);
GEGL_EXPORT void glVertexAttribI4uiEXT(GLuint index,GLuint x,GLuint y,GLuint z,GLuint w);
GEGL_EXPORT void glSecondaryColor3ubEXT(GLubyte red,GLubyte green,GLubyte blue);
GEGL_EXPORT void glCompressedMultiTexSubImage1DEXT(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLsizei imageSize,const void* bits);
GEGL_EXPORT void glMultiTexGendEXT(GLenum texunit,GLenum coord,GLenum pname,GLdouble param);
GEGL_EXPORT void glColorP3uiv(GLenum type,const GLuint* color);
GEGL_EXPORT void glFogCoordfv(const GLfloat* coord);
GEGL_EXPORT void glCompileShader(GLuint shader);
GEGL_EXPORT void glTexCoord2hNV(GLhalfNV s,GLhalfNV t);
GEGL_EXPORT void glUniform1uivEXT(GLint location,GLsizei count,const GLuint* value);
GEGL_EXPORT void glMatrixLoadTransposedEXT(GLenum mode,const GLdouble* m);
GEGL_EXPORT void glIndexfv(const GLfloat* c);
GEGL_EXPORT void glGetCompressedTextureImage(GLuint texture,GLint level,GLsizei bufSize,void* pixels);
GEGL_EXPORT void glGetUniformuivEXT(GLuint program,GLint location,GLuint* params);
GEGL_EXPORT void glGetnPixelMapfvARB(GLenum map,GLsizei bufSize,GLfloat* values);
GEGL_EXPORT void glFramebufferTextureEXT(GLenum target,GLenum attachment,GLuint texture,GLint level);
GEGL_EXPORT void glMultiDrawElementsIndirectCount(GLenum mode,GLenum type,const void* indirect,GLintptr drawcount,GLsizei maxdrawcount,GLsizei stride);
GEGL_EXPORT void glVertexAttribIPointer(GLuint index,GLint size,GLenum type,GLsizei stride,const void* pointer);
GEGL_EXPORT void glMultiTexCoordP3ui(GLenum texture,GLenum type,GLuint coords);
GEGL_EXPORT void glEvaluateDepthValuesARB();
GEGL_EXPORT void glGetNamedBufferParameteriv(GLuint buffer,GLenum pname,GLint* params);
GEGL_EXPORT void glGetNamedProgramLocalParameterfvEXT(GLuint program,GLenum target,GLuint index,GLfloat* params);
GEGL_EXPORT void glColor4fNormal3fVertex3fvSUN(const GLfloat* c,const GLfloat* n,const GLfloat* v);
GEGL_EXPORT void glSeparableFilter2DEXT(GLenum target,GLenum internalformat,GLsizei width,GLsizei height,GLenum format,GLenum type,const void* row,const void* column);
GEGL_EXPORT void glTexParameterxOES(GLenum target,GLenum pname,GLfixed param);
GEGL_EXPORT void glClearAccumxOES(GLfixed red,GLfixed green,GLfixed blue,GLfixed alpha);
GEGL_EXPORT void glInvalidateFramebuffer(GLenum target,GLsizei numAttachments,const GLenum* attachments);
GEGL_EXPORT void glWeightubvARB(GLint size,const GLubyte* weights);
GEGL_EXPORT void glVertexAttrib1d(GLuint index,GLdouble x);
GEGL_EXPORT void glVertexAttrib1f(GLuint index,GLfloat x);
GEGL_EXPORT void glVertex4fv(const GLfloat* v);
GEGL_EXPORT void glClearNamedFramebufferfi(GLuint framebuffer,GLenum buffer,GLint drawbuffer,GLfloat depth,GLint stencil);
GEGL_EXPORT void glGetQueryBufferObjectuiv(GLuint id,GLuint buffer,GLenum pname,GLintptr offset);
GEGL_EXPORT void glClearNamedFramebufferfv(GLuint framebuffer,GLenum buffer,GLint drawbuffer,const GLfloat* value);
GEGL_EXPORT void glEndVertexShaderEXT();
GEGL_EXPORT void glVertexAttrib1s(GLuint index,GLshort x);
GEGL_EXPORT void glMultiTexCoord4dvARB(GLenum target,const GLdouble* v);
GEGL_EXPORT void glMultiTexCoord1sv(GLenum target,const GLshort* v);
GEGL_EXPORT void glUniform1ui64vNV(GLint location,GLsizei count,const GLuint64EXT* value);
GEGL_EXPORT void glGetClipPlanefOES(GLenum plane,GLfloat* equation);
GEGL_EXPORT void glRasterPos2s(GLshort x,GLshort y);
GEGL_EXPORT void glWeightivARB(GLint size,const GLint* weights);
GEGL_EXPORT void glMultiTexCoord4hvNV(GLenum target,const GLhalfNV* v);
GEGL_EXPORT void glNormal3hNV(GLhalfNV nx,GLhalfNV ny,GLhalfNV nz);
GEGL_EXPORT void glGetSeparableFilter(GLenum target,GLenum format,GLenum type,GLvoid* row,GLvoid* column,GLvoid* span);
GEGL_EXPORT void glGetPathTexGenivNV(GLenum texCoordSet,GLenum pname,GLint* value);
GEGL_EXPORT void glColor4bv(const GLbyte* v);
GEGL_EXPORT void glRasterPos2f(GLfloat x,GLfloat y);
GEGL_EXPORT void glNamedBufferPageCommitmentARB(GLuint buffer,GLintptr offset,GLsizeiptr size,GLboolean commit);
GEGL_EXPORT void glLoadIdentity();
GEGL_EXPORT void glRasterPos2i(GLint x,GLint y);
GEGL_EXPORT void glRasterPos4iv(const GLint* v);
GEGL_EXPORT void glMultiTexCoord2fvARB(GLenum target,const GLfloat* v);
GEGL_EXPORT void glUniformMatrix4x3fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glClearBufferfv(GLenum buffer,GLint drawbuffer,const GLfloat* value);
GEGL_EXPORT void glMultiTexCoord4hNV(GLenum target,GLhalfNV s,GLhalfNV t,GLhalfNV r,GLhalfNV q);
GEGL_EXPORT void glTextureBarrier();
GEGL_EXPORT void glReplacementCodeuivSUN(const GLuint* code);
GEGL_EXPORT void glDeleteAsyncMarkersSGIX(GLuint marker,GLsizei range);
GEGL_EXPORT void glTexCoord2bvOES(const GLbyte* coords);
GEGL_EXPORT void glEvalCoord2xOES(GLfixed u,GLfixed v);
GEGL_EXPORT void glGetSharpenTexFuncSGIS(GLenum target,GLfloat* points);
GEGL_EXPORT void glProgramUniformHandleui64vNV(GLuint program,GLint location,GLsizei count,const GLuint64* values);
GEGL_EXPORT void glIglooInterfaceSGIX(GLenum pname,const void* params);
GEGL_EXPORT void glWindowPos2dvARB(const GLdouble* v);
GEGL_EXPORT void glClearBufferfi(GLenum buffer,GLint drawbuffer,GLfloat depth,GLint stencil);
GEGL_EXPORT void glDrawArraysIndirect(GLenum mode,const void* indirect);
GEGL_EXPORT void glGenVertexArrays(GLsizei n,GLuint* arrays);
GEGL_EXPORT void glGetTransformFeedbacki64_v(GLuint xfb,GLenum pname,GLuint index,GLint64* param);
GEGL_EXPORT void glEnableVertexArrayAttrib(GLuint vaobj,GLuint index);
GEGL_EXPORT void glProgramUniformMatrix3x2dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT void glVertexStream4fATI(GLenum stream,GLfloat x,GLfloat y,GLfloat z,GLfloat w);
GEGL_EXPORT void glVertexBindingDivisor(GLuint bindingindex,GLuint divisor);
GEGL_EXPORT void glGetSamplerParameterIiv(GLuint sampler,GLenum pname,GLint* params);
GEGL_EXPORT void glGetCoverageModulationTableNV(GLsizei bufsize,GLfloat* v);
GEGL_EXPORT void glDepthRangedNV(GLdouble zNear,GLdouble zFar);
GEGL_EXPORT void glVertexAttrib3f(GLuint index,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glMultiDrawRangeElementArrayAPPLE(GLenum mode,GLuint start,GLuint end,const GLint* first,const GLsizei* count,GLsizei primcount);
GEGL_EXPORT void glVertexAttribFormatNV(GLuint index,GLint size,GLenum type,GLboolean normalized,GLsizei stride);
GEGL_EXPORT void glGetQueryBufferObjecti64v(GLuint id,GLuint buffer,GLenum pname,GLintptr offset);
GEGL_EXPORT void glGetVertexAttribdv(GLuint index,GLenum pname,GLdouble* params);
GEGL_EXPORT void glGetUniformi64vARB(GLuint program,GLint location,GLint64* params);
GEGL_EXPORT GLboolean glAreTexturesResidentEXT(GLsizei n,const GLuint* textures,GLboolean* residences);
GEGL_EXPORT GLhandleARB glGetHandleARB(GLenum pname);
GEGL_EXPORT void glVideoCaptureStreamParameterdvNV(GLuint video_capture_slot,GLuint stream,GLenum pname,const GLdouble* params);
GEGL_EXPORT void glMapParameterivNV(GLenum target,GLenum pname,const GLint* params);
GEGL_EXPORT GLboolean glIsVertexArray(GLuint array);
GEGL_EXPORT void glSecondaryColor3sEXT(GLshort red,GLshort green,GLshort blue);
GEGL_EXPORT void glGetTexParameterIivEXT(GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glFrameTerminatorGREMEDY();
GEGL_EXPORT void glBlendBarrierKHR();
GEGL_EXPORT void glVertexAttrib4NubARB(GLuint index,GLubyte x,GLubyte y,GLubyte z,GLubyte w);
GEGL_EXPORT void glPrimitiveRestartNV();
GEGL_EXPORT void glVertexAttribL1ui64vARB(GLuint index,const GLuint64EXT* v);
GEGL_EXPORT void glVertexAttribI4ivEXT(GLuint index,const GLint* v);
GEGL_EXPORT void glVertexAttribs4svNV(GLuint index,GLsizei count,const GLshort* v);
GEGL_EXPORT void glUniform1ui(GLint location,GLuint v0);
GEGL_EXPORT void glVertexAttrib2fvARB(GLuint index,const GLfloat* v);
GEGL_EXPORT void glVertexAttribI4svEXT(GLuint index,const GLshort* v);
GEGL_EXPORT void glTextureImage3DMultisampleCoverageNV(GLuint texture,GLenum target,GLsizei coverageSamples,GLsizei colorSamples,GLint internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedSampleLocations);
GEGL_EXPORT void glMemoryBarrier(GLbitfield barriers);
GEGL_EXPORT void glGetVariantArrayObjectfvATI(GLuint id,GLenum pname,GLfloat* params);
GEGL_EXPORT void glTexCoord4fColor4fNormal3fVertex4fvSUN(const GLfloat* tc,const GLfloat* c,const GLfloat* n,const GLfloat* v);
GEGL_EXPORT GLboolean glIsProgramARB(GLuint program);
GEGL_EXPORT void glBindImageTextureEXT(GLuint index,GLuint texture,GLint level,GLboolean layered,GLint layer,GLenum access,GLint format);
GEGL_EXPORT GLint glGetFragDataLocation(GLuint program,const GLchar* name);
GEGL_EXPORT void glMultiTexCoord1svARB(GLenum target,const GLshort* v);
GEGL_EXPORT void glGetMapxvOES(GLenum target,GLenum query,GLfixed* v);
GEGL_EXPORT void glTextureStorage2DMultisampleEXT(GLuint texture,GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLboolean fixedsamplelocations);
GEGL_EXPORT void glGetMaterialfv(GLenum face,GLenum pname,GLfloat* params);
GEGL_EXPORT void glVertexAttrib4NbvARB(GLuint index,const GLbyte* v);
GEGL_EXPORT void glPixelMapuiv(GLenum map,GLsizei mapsize,const GLuint* values);
GEGL_EXPORT void glColorPointerEXT(GLint size,GLenum type,GLsizei stride,GLsizei count,const void* pointer);
GEGL_EXPORT void glEnableClientStateiEXT(GLenum array,GLuint index);
GEGL_EXPORT void glClearTexSubImage(GLuint texture,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,const void* data);
GEGL_EXPORT void glEvalCoord1xvOES(const GLfixed* coords);
GEGL_EXPORT void glDetachObjectARB(GLhandleARB containerObj,GLhandleARB attachedObj);
GEGL_EXPORT void glGetTextureParameterIiv(GLuint texture,GLenum pname,GLint* params);
GEGL_EXPORT void glVariantusvEXT(GLuint id,const GLushort* addr);
GEGL_EXPORT void glCompressedTextureImage3DEXT(GLuint texture,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,const void* bits);
GEGL_EXPORT void glMultiTexCoord1dARB(GLenum target,GLdouble s);
GEGL_EXPORT void glGetVertexArrayIntegeri_vEXT(GLuint vaobj,GLuint index,GLenum pname,GLint* param);
GEGL_EXPORT void glVertexAttribI4ubv(GLuint index,const GLubyte* v);
GEGL_EXPORT void glPixelTexGenParameterfSGIS(GLenum pname,GLfloat param);
GEGL_EXPORT void glProgramUniformMatrix4x2dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT void glUniform3fARB(GLint location,GLfloat v0,GLfloat v1,GLfloat v2);
GEGL_EXPORT GLboolean glIsShader(GLuint shader);
GEGL_EXPORT void glConvolutionParameteriv(GLenum target,GLenum pname,const GLint* params);
GEGL_EXPORT void glCopyMultiTexSubImage2DEXT(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint x,GLint y,GLsizei width,GLsizei height);
GEGL_EXPORT void glEnableVertexAttribArrayARB(GLuint index);
GEGL_EXPORT void glMulticastCopyBufferSubDataNV(GLuint readGpu,GLbitfield writeGpuMask,GLuint readBuffer,GLuint writeBuffer,GLintptr readOffset,GLintptr writeOffset,GLsizeiptr size);
GEGL_EXPORT void glEnable(GLenum cap);
GEGL_EXPORT void glGetActiveUniformsiv(GLuint program,GLsizei uniformCount,const GLuint* uniformIndices,GLenum pname,GLint* params);
GEGL_EXPORT void glGetVertexAttribivARB(GLuint index,GLenum pname,GLint* params);
GEGL_EXPORT void glTexCoord4hvNV(const GLhalfNV* v);
GEGL_EXPORT void glUseProgramObjectARB(GLhandleARB programObj);
GEGL_EXPORT GLint glGetAttribLocation(GLuint program,const GLchar* name);
GEGL_EXPORT void glVertexAttrib4dv(GLuint index,const GLdouble* v);
GEGL_EXPORT void glGetTextureParameteriv(GLuint texture,GLenum pname,GLint* params);
GEGL_EXPORT void glNamedBufferStorageMemEXT(GLuint buffer,GLsizeiptr size,GLuint memory,GLuint64 offset);
GEGL_EXPORT void glPathSubCoordsNV(GLuint path,GLsizei coordStart,GLsizei numCoords,GLenum coordType,const void* coords);
GEGL_EXPORT void glMatrixIndexusvARB(GLint size,const GLushort* indices);
GEGL_EXPORT void glGetVideouivNV(GLuint video_slot,GLenum pname,GLuint* params);
GEGL_EXPORT void glGetVideoCaptureivNV(GLuint video_capture_slot,GLenum pname,GLint* params);
GEGL_EXPORT void glProgramUniform3ui(GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2);
GEGL_EXPORT void glVertexAttrib3svARB(GLuint index,const GLshort* v);
GEGL_EXPORT void glGetNamedBufferParameterivEXT(GLuint buffer,GLenum pname,GLint* params);
GEGL_EXPORT void glMatrixScaledEXT(GLenum mode,GLdouble x,GLdouble y,GLdouble z);
GEGL_EXPORT void glProgramUniformMatrix2x3fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glGetFragmentLightivSGIX(GLenum light,GLenum pname,GLint* params);
GEGL_EXPORT const GLubyte* glGetStringi(GLenum name,GLuint index);
GEGL_EXPORT void glWindowPos2svARB(const GLshort* v);
GEGL_EXPORT void glVertexAttrib2svNV(GLuint index,const GLshort* v);
GEGL_EXPORT void glWindowPos2ivARB(const GLint* v);
GEGL_EXPORT void glGetVertexAttribPointervNV(GLuint index,GLenum pname,void** pointer);
GEGL_EXPORT void glPushMatrix();
GEGL_EXPORT void glEdgeFlagPointerListIBM(GLint stride,const GLboolean** pointer,GLint ptrstride);
GEGL_EXPORT void glGenerateMipmapEXT(GLenum target);
GEGL_EXPORT void glWindowPos3sv(const GLshort* v);
GEGL_EXPORT void glPathCoordsNV(GLuint path,GLsizei numCoords,GLenum coordType,const void* coords);
GEGL_EXPORT void glProgramUniform1i(GLuint program,GLint location,GLint v0);
GEGL_EXPORT void glProgramUniform1d(GLuint program,GLint location,GLdouble v0);
GEGL_EXPORT void glProgramUniform1f(GLuint program,GLint location,GLfloat v0);
GEGL_EXPORT void glProgramParameteriEXT(GLuint program,GLenum pname,GLint value);
GEGL_EXPORT void glCompressedMultiTexImage2DEXT(GLenum texunit,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,const void* bits);
GEGL_EXPORT void glProgramUniform3iv(GLuint program,GLint location,GLsizei count,const GLint* value);
GEGL_EXPORT void glIndexiv(const GLint* c);
GEGL_EXPORT void glMultiTexCoord4xvOES(GLenum texture,const GLfixed* coords);
GEGL_EXPORT void glEGLImageTargetTexture2DOES(GLenum target,GLeglImageOES image);
GEGL_EXPORT void glPixelZoom(GLfloat xfactor,GLfloat yfactor);
GEGL_EXPORT void glVertex3bvOES(const GLbyte* coords);
GEGL_EXPORT void glFramebufferReadBufferEXT(GLuint framebuffer,GLenum mode);
GEGL_EXPORT void glExtractComponentEXT(GLuint res,GLuint src,GLuint num);
GEGL_EXPORT void glCombinerParameterivNV(GLenum pname,const GLint* params);
GEGL_EXPORT void glMinmax(GLenum target,GLenum internalformat,GLboolean sink);
GEGL_EXPORT void glColorP3ui(GLenum type,GLuint color);
GEGL_EXPORT void glPointParameterfvSGIS(GLenum pname,const GLfloat* params);
GEGL_EXPORT void glBlendEquationi(GLuint buf,GLenum mode);
GEGL_EXPORT void glGetFogFuncSGIS(GLfloat* points);
GEGL_EXPORT void glVertexAttrib4fvNV(GLuint index,const GLfloat* v);
GEGL_EXPORT void glGetnMinmax(GLenum target,GLboolean reset,GLenum format,GLenum type,GLsizei bufSize,void* values);
GEGL_EXPORT void glFragmentLightiSGIX(GLenum light,GLenum pname,GLint param);
GEGL_EXPORT void glMultiTexCoord1bvOES(GLenum texture,const GLbyte* coords);
GEGL_EXPORT void glSecondaryColorPointerEXT(GLint size,GLenum type,GLsizei stride,const void* pointer);
GEGL_EXPORT void glMultiTexCoordP4uiv(GLenum texture,GLenum type,const GLuint* coords);
GEGL_EXPORT void glGetBufferSubDataARB(GLenum target,GLintptrARB offset,GLsizeiptrARB size,void* data);
GEGL_EXPORT void glSecondaryColor3hNV(GLhalfNV red,GLhalfNV green,GLhalfNV blue);
GEGL_EXPORT void glGetPathParameterivNV(GLuint path,GLenum pname,GLint* value);
GEGL_EXPORT void glFlushRasterSGIX();
GEGL_EXPORT void glElementPointerATI(GLenum type,const void* pointer);
GEGL_EXPORT void glGetAttachedObjectsARB(GLhandleARB containerObj,GLsizei maxCount,GLsizei* count,GLhandleARB* obj);
GEGL_EXPORT void glUniform4iv(GLint location,GLsizei count,const GLint* value);
GEGL_EXPORT void glFogxOES(GLenum pname,GLfixed param);
GEGL_EXPORT void glSharpenTexFuncSGIS(GLenum target,GLsizei n,const GLfloat* points);
GEGL_EXPORT void glClearDepthfOES(GLclampf depth);
GEGL_EXPORT void glDeleteCommandListsNV(GLsizei n,const GLuint* lists);
GEGL_EXPORT void glSpecializeShader(GLuint shader,const GLchar* pEntryPoint,GLuint numSpecializationConstants,const GLuint* pConstantIndex,const GLuint* pConstantValue);
GEGL_EXPORT void glVertex4hNV(GLhalfNV x,GLhalfNV y,GLhalfNV z,GLhalfNV w);
GEGL_EXPORT void glSecondaryColor3dvEXT(const GLdouble* v);
GEGL_EXPORT void glGenTextures(GLsizei n,GLuint* textures);
GEGL_EXPORT void glTextureStorage2DMultisample(GLuint texture,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLboolean fixedsamplelocations);
GEGL_EXPORT void glUniform3ui64vNV(GLint location,GLsizei count,const GLuint64EXT* value);
GEGL_EXPORT void glBlendFuncSeparateIndexedAMD(GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha);
GEGL_EXPORT void glMakeBufferResidentNV(GLenum target,GLenum access);
GEGL_EXPORT void glShaderOp2EXT(GLenum op,GLuint res,GLuint arg1,GLuint arg2);
GEGL_EXPORT void glGetVertexAttribivNV(GLuint index,GLenum pname,GLint* params);
GEGL_EXPORT void glTexParameterIivEXT(GLenum target,GLenum pname,const GLint* params);
GEGL_EXPORT void glGetPerfQueryDataINTEL(GLuint queryHandle,GLuint flags,GLsizei dataSize,GLvoid* data,GLuint* bytesWritten);
GEGL_EXPORT void glVertexAttrib4dvARB(GLuint index,const GLdouble* v);
GEGL_EXPORT void glTextureSubImage1DEXT(GLuint texture,GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLenum type,const void* pixels);
GEGL_EXPORT void glGetActiveUniformBlockName(GLuint program,GLuint uniformBlockIndex,GLsizei bufSize,GLsizei* length,GLchar* uniformBlockName);
GEGL_EXPORT void glVertexAttrib2dvARB(GLuint index,const GLdouble* v);
GEGL_EXPORT void glVertexAttribPointer(GLuint index,GLint size,GLenum type,GLboolean normalized,GLsizei stride,const void* pointer);
GEGL_EXPORT void glDepthBoundsdNV(GLdouble zmin,GLdouble zmax);
GEGL_EXPORT void glDeleteTexturesEXT(GLsizei n,const GLuint* textures);
GEGL_EXPORT void glDrawBuffersATI(GLsizei n,const GLenum* bufs);
GEGL_EXPORT void glLightModelxvOES(GLenum pname,const GLfixed* param);
GEGL_EXPORT void glApplyTextureEXT(GLenum mode);
GEGL_EXPORT GLuint64 glGetImageHandleNV(GLuint texture,GLint level,GLboolean layered,GLint layer,GLenum format);
GEGL_EXPORT void glGetMinmax(GLenum target,GLboolean reset,GLenum format,GLenum types,GLvoid* values);
GEGL_EXPORT void glGetFixedvOES(GLenum pname,GLfixed* params);
GEGL_EXPORT void glSamplePatternEXT(GLenum pattern);
GEGL_EXPORT void glUniform1f(GLint location,GLfloat v0);
GEGL_EXPORT void glColor4fNormal3fVertex3fSUN(GLfloat r,GLfloat g,GLfloat b,GLfloat a,GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glFogCoorddvEXT(const GLdouble* coord);
GEGL_EXPORT void glCopyTextureImage1DEXT(GLuint texture,GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLint border);
GEGL_EXPORT void glFlushMappedBufferRangeAPPLE(GLenum target,GLintptr offset,GLsizeiptr size);
GEGL_EXPORT void glVertex3sv(const GLshort* v);
GEGL_EXPORT void glFlushStaticDataIBM(GLenum target);
GEGL_EXPORT void glProgramUniform4ui64NV(GLuint program,GLint location,GLuint64EXT x,GLuint64EXT y,GLuint64EXT z,GLuint64EXT w);
GEGL_EXPORT void glRasterPos4xOES(GLfixed x,GLfixed y,GLfixed z,GLfixed w);
GEGL_EXPORT void glVertexAttribP1ui(GLuint index,GLenum type,GLboolean normalized,GLuint value);
GEGL_EXPORT void glProgramUniform4dvEXT(GLuint program,GLint location,GLsizei count,const GLdouble* value);
GEGL_EXPORT void glEndTransformFeedbackEXT();
GEGL_EXPORT void glBinormal3dEXT(GLdouble bx,GLdouble by,GLdouble bz);
GEGL_EXPORT void glGetTextureSubImage(GLuint texture,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,GLsizei bufSize,void* pixels);
GEGL_EXPORT void glGetNamedRenderbufferParameteriv(GLuint renderbuffer,GLenum pname,GLint* params);
GEGL_EXPORT void glBindBuffersRange(GLenum target,GLuint first,GLsizei count,const GLuint* buffers,const GLintptr* offsets,const GLsizeiptr* sizes);
GEGL_EXPORT GLint glFinishAsyncSGIX(GLuint* markerp);
GEGL_EXPORT void glBindFragDataLocationIndexed(GLuint program,GLuint colorNumber,GLuint index,const GLchar* name);
GEGL_EXPORT void glMultiTexCoord2dv(GLenum target,const GLdouble* v);
GEGL_EXPORT void glUniform2iv(GLint location,GLsizei count,const GLint* value);
GEGL_EXPORT void glProgramUniform2i64vNV(GLuint program,GLint location,GLsizei count,const GLint64EXT* value);
GEGL_EXPORT void glFlushVertexArrayRangeAPPLE(GLsizei length,void* pointer);
GEGL_EXPORT void glTextureParameterf(GLuint texture,GLenum pname,GLfloat param);
GEGL_EXPORT void glMultiTexCoord3dvARB(GLenum target,const GLdouble* v);
GEGL_EXPORT void glFeedbackBuffer(GLsizei size,GLenum type,GLfloat* buffer);
GEGL_EXPORT void glDebugMessageInsertARB(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar* buf);
GEGL_EXPORT void glMultiTexCoord2i(GLenum target,GLint s,GLint t);
GEGL_EXPORT void glTextureSubImage3D(GLuint texture,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,const void* pixels);
GEGL_EXPORT void glFramebufferTexture1D(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level);
GEGL_EXPORT void glGetShaderiv(GLuint shader,GLenum pname,GLint* params);
GEGL_EXPORT void glMultiTexCoord2d(GLenum target,GLdouble s,GLdouble t);
GEGL_EXPORT void glArrayObjectATI(GLenum array,GLint size,GLenum type,GLsizei stride,GLuint buffer,GLuint offset);
GEGL_EXPORT void glGetPointeri_vEXT(GLenum pname,GLuint index,void** params);
GEGL_EXPORT void glGetPerfMonitorCountersAMD(GLuint group,GLint* numCounters,GLint* maxActiveCounters,GLsizei counterSize,GLuint* counters);
GEGL_EXPORT void glNamedBufferStorage(GLuint buffer,GLsizeiptr size,const void* data,GLbitfield flags);
GEGL_EXPORT void glTexEnvxvOES(GLenum target,GLenum pname,const GLfixed* params);
GEGL_EXPORT void glProgramUniform2ui64NV(GLuint program,GLint location,GLuint64EXT x,GLuint64EXT y);
GEGL_EXPORT void glMultiTexCoord3bOES(GLenum texture,GLbyte s,GLbyte t,GLbyte r);
GEGL_EXPORT void glUniform1dv(GLint location,GLsizei count,const GLdouble* value);
GEGL_EXPORT void glPixelTransferi(GLenum pname,GLint param);
GEGL_EXPORT void glSecondaryColor3usvEXT(const GLushort* v);
GEGL_EXPORT void glProgramEnvParameterI4uivNV(GLenum target,GLuint index,const GLuint* params);
GEGL_EXPORT void glVertex2sv(const GLshort* v);
GEGL_EXPORT void glWindowPos4dMESA(GLdouble x,GLdouble y,GLdouble z,GLdouble w);
GEGL_EXPORT void glDebugMessageControlARB(GLenum source,GLenum type,GLenum severity,GLsizei count,const GLuint* ids,GLboolean enabled);
GEGL_EXPORT GLboolean glIsTextureEXT(GLuint texture);
GEGL_EXPORT void glFragmentMaterialivSGIX(GLenum face,GLenum pname,const GLint* params);
GEGL_EXPORT void glLinkProgramARB(GLhandleARB programObj);
GEGL_EXPORT void glFinishFenceAPPLE(GLuint fence);
GEGL_EXPORT void glVertexArrayVertexAttribBindingEXT(GLuint vaobj,GLuint attribindex,GLuint bindingindex);
GEGL_EXPORT void glTexStorageMem3DMultisampleEXT(GLenum target,GLsizei samples,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedSampleLocations,GLuint memory,GLuint64 offset);
GEGL_EXPORT void glUniform1ui64vARB(GLint location,GLsizei count,const GLuint64* value);
GEGL_EXPORT void glMultiTexCoord4fv(GLenum target,const GLfloat* v);
GEGL_EXPORT void glMulticastFramebufferSampleLocationsfvNV(GLuint gpu,GLuint framebuffer,GLuint start,GLsizei count,const GLfloat* v);
GEGL_EXPORT void glRasterPos3d(GLdouble x,GLdouble y,GLdouble z);
GEGL_EXPORT GLint glPollAsyncSGIX(GLuint* markerp);
GEGL_EXPORT void glRasterPos3f(GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glCompressedTexImage3D(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,const GLvoid* data);
GEGL_EXPORT void glVariantivEXT(GLuint id,const GLint* addr);
GEGL_EXPORT void glUnmapTexture2DINTEL(GLuint texture,GLint level);
GEGL_EXPORT void glMulticastWaitSyncNV(GLuint signalGpu,GLbitfield waitGpuMask);
GEGL_EXPORT void glGetVertexAttribiv(GLuint index,GLenum pname,GLint* params);
GEGL_EXPORT void glGetPathCoordsNV(GLuint path,GLfloat* coords);
GEGL_EXPORT void glColor4xvOES(const GLfixed* components);
GEGL_EXPORT void glVertexAttrib3fv(GLuint index,const GLfloat* v);
GEGL_EXPORT void glRasterPos3s(GLshort x,GLshort y,GLshort z);
GEGL_EXPORT void glVertex4bOES(GLbyte x,GLbyte y,GLbyte z,GLbyte w);
GEGL_EXPORT void glTransformFeedbackVaryingsEXT(GLuint program,GLsizei count,const GLchar*const* varyings,GLenum bufferMode);
GEGL_EXPORT void glCombinerOutputNV(GLenum stage,GLenum portion,GLenum abOutput,GLenum cdOutput,GLenum sumOutput,GLenum scale,GLenum bias,GLboolean abDotProduct,GLboolean cdDotProduct,GLboolean muxSum);
GEGL_EXPORT void glWindowPos4sMESA(GLshort x,GLshort y,GLshort z,GLshort w);
GEGL_EXPORT void glVertexAttrib4svARB(GLuint index,const GLshort* v);
GEGL_EXPORT GLboolean glIsList(GLuint list);
GEGL_EXPORT void glGetInfoLogARB(GLhandleARB obj,GLsizei maxLength,GLsizei* length,GLcharARB* infoLog);
GEGL_EXPORT void glUniformMatrix2fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glVertexAttribs3dvNV(GLuint index,GLsizei count,const GLdouble* v);
GEGL_EXPORT void glGlobalAlphaFactorsSUN(GLshort factor);
GEGL_EXPORT void glGetTrackMatrixivNV(GLenum target,GLuint address,GLenum pname,GLint* params);
GEGL_EXPORT void glTextureParameterfvEXT(GLuint texture,GLenum target,GLenum pname,const GLfloat* params);
GEGL_EXPORT GLboolean glIsNamedBufferResidentNV(GLuint buffer);
GEGL_EXPORT void glProgramUniform4ui64vARB(GLuint program,GLint location,GLsizei count,const GLuint64* value);
GEGL_EXPORT void glTbufferMask3DFX(GLuint mask);
GEGL_EXPORT void glCoverFillPathNV(GLuint path,GLenum coverMode);
GEGL_EXPORT void glVertexAttrib1fvARB(GLuint index,const GLfloat* v);
GEGL_EXPORT void glGenerateTextureMipmap(GLuint texture);
GEGL_EXPORT void glNamedProgramLocalParameterI4uivEXT(GLuint program,GLenum target,GLuint index,const GLuint* params);
GEGL_EXPORT void glMultiDrawElementsBaseVertex(GLenum mode,const GLsizei* count,GLenum type,const void*const* indices,GLsizei drawcount,const GLint* basevertex);
GEGL_EXPORT void glProgramSubroutineParametersuivNV(GLenum target,GLsizei count,const GLuint* params);
GEGL_EXPORT void glProgramUniformMatrix2x4dvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT void glRotatexOES(GLfixed angle,GLfixed x,GLfixed y,GLfixed z);
GEGL_EXPORT void glMemoryBarrierEXT(GLbitfield barriers);
GEGL_EXPORT void glVertexAttrib3svNV(GLuint index,const GLshort* v);
GEGL_EXPORT void glVertexStream3iATI(GLenum stream,GLint x,GLint y,GLint z);
GEGL_EXPORT void glCompressedTexSubImage1D(GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLsizei imageSize,const GLvoid* data);
GEGL_EXPORT void glSetFenceNV(GLuint fence,GLenum condition);
GEGL_EXPORT void glAttachObjectARB(GLhandleARB containerObj,GLhandleARB obj);
GEGL_EXPORT void glCopyConvolutionFilter1D(GLenum target,GLenum internalformat,GLint x,GLint y,GLsizei width);
GEGL_EXPORT void glTexStorageMem2DMultisampleEXT(GLenum target,GLsizei samples,GLenum internalFormat,GLsizei width,GLsizei height,GLboolean fixedSampleLocations,GLuint memory,GLuint64 offset);
GEGL_EXPORT void glProgramParameters4fvNV(GLenum target,GLuint index,GLsizei count,const GLfloat* v);
GEGL_EXPORT void glNamedFramebufferParameteriEXT(GLuint framebuffer,GLenum pname,GLint param);
GEGL_EXPORT void glVertexAttrib4Nsv(GLuint index,const GLshort* v);
GEGL_EXPORT void glVertexAttribI4usvEXT(GLuint index,const GLushort* v);
GEGL_EXPORT void glTextureBufferRangeEXT(GLuint texture,GLenum target,GLenum internalformat,GLuint buffer,GLintptr offset,GLsizeiptr size);
GEGL_EXPORT void glVertexP3uiv(GLenum type,const GLuint* value);
GEGL_EXPORT GLboolean glIsPathNV(GLuint path);
GEGL_EXPORT void glGetnUniformi64vARB(GLuint program,GLint location,GLsizei bufSize,GLint64* params);
GEGL_EXPORT void glFramebufferTextureMultiviewOVR(GLenum target,GLenum attachment,GLuint texture,GLint level,GLint baseViewIndex,GLsizei numViews);
GEGL_EXPORT void glCompressedMultiTexSubImage2DEXT(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,const void* bits);
GEGL_EXPORT void glGetnMapdv(GLenum target,GLenum query,GLsizei bufSize,GLdouble* v);
GEGL_EXPORT void glDebugMessageCallback(GLDEBUGPROC callback,const void* userParam);
GEGL_EXPORT void glTangent3svEXT(const GLshort* v);
GEGL_EXPORT void glVertexAttribParameteriAMD(GLuint index,GLenum pname,GLint param);
GEGL_EXPORT void glBufferSubDataARB(GLenum target,GLintptrARB offset,GLsizeiptrARB size,const void* data);
GEGL_EXPORT void glGetVertexAttribLui64vARB(GLuint index,GLenum pname,GLuint64EXT* params);
GEGL_EXPORT void glVertexAttribL4ui64NV(GLuint index,GLuint64EXT x,GLuint64EXT y,GLuint64EXT z,GLuint64EXT w);
GEGL_EXPORT void glReplacementCodeuiColor4ubVertex3fSUN(GLuint rc,GLubyte r,GLubyte g,GLubyte b,GLubyte a,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glImageTransformParameterfHP(GLenum target,GLenum pname,GLfloat param);
GEGL_EXPORT void glMap1f(GLenum target,GLfloat u1,GLfloat u2,GLint stride,GLint order,const GLfloat* points);
GEGL_EXPORT void glRasterPos4fv(const GLfloat* v);
GEGL_EXPORT void glVertex2bvOES(const GLbyte* coords);
GEGL_EXPORT void glGetMapControlPointsNV(GLenum target,GLuint index,GLenum type,GLsizei ustride,GLsizei vstride,GLboolean packed,void* points);
GEGL_EXPORT void glNamedProgramLocalParametersI4ivEXT(GLuint program,GLenum target,GLuint index,GLsizei count,const GLint* params);
GEGL_EXPORT void glBindBufferRangeNV(GLenum target,GLuint index,GLuint buffer,GLintptr offset,GLsizeiptr size);
GEGL_EXPORT void glVertexStream3dvATI(GLenum stream,const GLdouble* coords);
GEGL_EXPORT void glNormalPointerListIBM(GLenum type,GLint stride,const void** pointer,GLint ptrstride);
GEGL_EXPORT void glFogFuncSGIS(GLsizei n,const GLfloat* points);
GEGL_EXPORT void glMultiModeDrawArraysIBM(const GLenum* mode,const GLint* first,const GLsizei* count,GLsizei primcount,GLint modestride);
GEGL_EXPORT void glGetNamedFramebufferAttachmentParameterivEXT(GLuint framebuffer,GLenum attachment,GLenum pname,GLint* params);
GEGL_EXPORT void glGetFloatv(GLenum pname,GLfloat* params);
GEGL_EXPORT void glVertexArrayVertexAttribIFormatEXT(GLuint vaobj,GLuint attribindex,GLint size,GLenum type,GLuint relativeoffset);
GEGL_EXPORT void glHint(GLenum target,GLenum mode);
GEGL_EXPORT void glVertexStream2svATI(GLenum stream,const GLshort* coords);
GEGL_EXPORT void glMultiDrawArraysIndirect(GLenum mode,const void* indirect,GLsizei drawcount,GLsizei stride);
GEGL_EXPORT void glMultiTexEnvfvEXT(GLenum texunit,GLenum target,GLenum pname,const GLfloat* params);
GEGL_EXPORT void glVertexAttribP2uiv(GLuint index,GLenum type,GLboolean normalized,const GLuint* value);
GEGL_EXPORT void glProgramUniform1i64vARB(GLuint program,GLint location,GLsizei count,const GLint64* value);
GEGL_EXPORT void glFramebufferTextureARB(GLenum target,GLenum attachment,GLuint texture,GLint level);
GEGL_EXPORT void glPushClientAttribDefaultEXT(GLbitfield mask);
GEGL_EXPORT void glScalef(GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glScaled(GLdouble x,GLdouble y,GLdouble z);
GEGL_EXPORT void glGetConvolutionParameterxvOES(GLenum target,GLenum pname,GLfixed* params);
GEGL_EXPORT void glGetProgramResourceName(GLuint program,GLenum programInterface,GLuint index,GLsizei bufSize,GLsizei* length,GLchar* name);
GEGL_EXPORT void glCopyColorTable(GLenum target,GLenum internalformat,GLint x,GLint y,GLsizei width);
GEGL_EXPORT void glDepthRangeArrayv(GLuint first,GLsizei count,const GLdouble* v);
GEGL_EXPORT void glCoverFillPathInstancedNV(GLsizei numPaths,GLenum pathNameType,const void* paths,GLuint pathBase,GLenum coverMode,GLenum transformType,const GLfloat* transformValues);
GEGL_EXPORT void glMultiTexParameterivEXT(GLenum texunit,GLenum target,GLenum pname,const GLint* params);
GEGL_EXPORT void glGetActiveAtomicCounterBufferiv(GLuint program,GLuint bufferIndex,GLenum pname,GLint* params);
GEGL_EXPORT void glStencilOpSeparate(GLenum face,GLenum sfail,GLenum dpfail,GLenum dppass);
GEGL_EXPORT void glVertexAttrib4fNV(GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w);
GEGL_EXPORT void glGetColorTableParameterivSGI(GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glVertexArrayAttribBinding(GLuint vaobj,GLuint attribindex,GLuint bindingindex);
GEGL_EXPORT GLboolean glIsSemaphoreEXT(GLuint semaphore);
GEGL_EXPORT void glProgramParameters4dvNV(GLenum target,GLuint index,GLsizei count,const GLdouble* v);
GEGL_EXPORT void glVertexAttribL4dv(GLuint index,const GLdouble* v);
GEGL_EXPORT void glGetTexParameteriv(GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT GLintptr glGetUniformOffsetEXT(GLuint program,GLint location);
GEGL_EXPORT void glGetVertexAttribPointerv(GLuint index,GLenum pname,void** pointer);
GEGL_EXPORT void glResumeTransformFeedbackNV();
GEGL_EXPORT void glProgramUniform3i64vNV(GLuint program,GLint location,GLsizei count,const GLint64EXT* value);
GEGL_EXPORT void glTangent3fEXT(GLfloat tx,GLfloat ty,GLfloat tz);
GEGL_EXPORT void glGetPathMetricRangeNV(GLbitfield metricQueryMask,GLuint firstPathName,GLsizei numPaths,GLsizei stride,GLfloat* metrics);
GEGL_EXPORT void glWindowPos2iMESA(GLint x,GLint y);
GEGL_EXPORT void glVertex2xvOES(const GLfixed* coords);
GEGL_EXPORT void glGetnCompressedTexImage(GLenum target,GLint lod,GLsizei bufSize,void* pixels);
GEGL_EXPORT void glWindowPos2dv(const GLdouble* v);
GEGL_EXPORT void glReplacementCodeuiVertex3fSUN(GLuint rc,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glGetTransformFeedbackVaryingEXT(GLuint program,GLuint index,GLsizei bufSize,GLsizei* length,GLsizei* size,GLenum* type,GLchar* name);
GEGL_EXPORT void glWindowPos3fARB(GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void* glMapNamedBufferEXT(GLuint buffer,GLenum access);
GEGL_EXPORT void glDisable(GLenum cap);
GEGL_EXPORT GLboolean glIsPointInFillPathNV(GLuint path,GLuint mask,GLfloat x,GLfloat y);
GEGL_EXPORT void glVertexAttribI2uiEXT(GLuint index,GLuint x,GLuint y);
GEGL_EXPORT void glProgramUniform4uiv(GLuint program,GLint location,GLsizei count,const GLuint* value);
GEGL_EXPORT void glQueryCounter(GLuint id,GLenum target);
GEGL_EXPORT void glFramebufferRenderbufferEXT(GLenum target,GLenum attachment,GLenum renderbuffertarget,GLuint renderbuffer);
GEGL_EXPORT void glBinormal3svEXT(const GLshort* v);
GEGL_EXPORT void glBindBufferOffsetNV(GLenum target,GLuint index,GLuint buffer,GLintptr offset);
GEGL_EXPORT void glCopyTextureSubImage2D(GLuint texture,GLint level,GLint xoffset,GLint yoffset,GLint x,GLint y,GLsizei width,GLsizei height);
GEGL_EXPORT void glGetProgramResourcefvNV(GLuint program,GLenum programInterface,GLuint index,GLsizei propCount,const GLenum* props,GLsizei bufSize,GLsizei* length,GLfloat* params);
GEGL_EXPORT void glBinormalPointerEXT(GLenum type,GLsizei stride,const void* pointer);
GEGL_EXPORT void glGetLightfv(GLenum light,GLenum pname,GLfloat* params);
GEGL_EXPORT void glMulticastCopyImageSubDataNV(GLuint srcGpu,GLbitfield dstGpuMask,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);
GEGL_EXPORT void glVertex2bOES(GLbyte x,GLbyte y);
GEGL_EXPORT void glUniform2ivARB(GLint location,GLsizei count,const GLint* value);
GEGL_EXPORT void glMultiTexCoord3s(GLenum target,GLshort s,GLshort t,GLshort r);
GEGL_EXPORT void glGetHistogramParameterfvEXT(GLenum target,GLenum pname,GLfloat* params);
GEGL_EXPORT void glGetProgramStringNV(GLuint id,GLenum pname,GLubyte* program);
GEGL_EXPORT void glGetTexGenxvOES(GLenum coord,GLenum pname,GLfixed* params);
GEGL_EXPORT void glTextureSubImage2D(GLuint texture,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,const void* pixels);
GEGL_EXPORT GLenum glObjectPurgeableAPPLE(GLenum objectType,GLuint name,GLenum option);
GEGL_EXPORT void glColorTableSGI(GLenum target,GLenum internalformat,GLsizei width,GLenum format,GLenum type,const void* table);
GEGL_EXPORT void glCopyConvolutionFilter2DEXT(GLenum target,GLenum internalformat,GLint x,GLint y,GLsizei width,GLsizei height);
GEGL_EXPORT void glMultiTexCoord3f(GLenum target,GLfloat s,GLfloat t,GLfloat r);
GEGL_EXPORT void glMultiTexCoord3d(GLenum target,GLdouble s,GLdouble t,GLdouble r);
GEGL_EXPORT void glFogCoorddv(const GLdouble* coord);
GEGL_EXPORT void glGetBufferPointerv(GLenum target,GLenum pname,void** params);
GEGL_EXPORT void glProgramUniform1fEXT(GLuint program,GLint location,GLfloat v0);
GEGL_EXPORT void glWindowPos2fvMESA(const GLfloat* v);
GEGL_EXPORT void glAlphaToCoverageDitherControlNV(GLenum mode);
GEGL_EXPORT void glPolygonOffsetxOES(GLfixed factor,GLfixed units);
GEGL_EXPORT void glVertexAttrib4dARB(GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w);
GEGL_EXPORT void glUniformHandleui64vARB(GLint location,GLsizei count,const GLuint64* value);
GEGL_EXPORT void glFragmentLightModelfvSGIX(GLenum pname,const GLfloat* params);
GEGL_EXPORT void glSwizzleEXT(GLuint res,GLuint in,GLenum outX,GLenum outY,GLenum outZ,GLenum outW);
GEGL_EXPORT void glBindFragmentShaderATI(GLuint id);
GEGL_EXPORT void glVertexAttribs3hvNV(GLuint index,GLsizei n,const GLhalfNV* v);
GEGL_EXPORT void glGenBuffersARB(GLsizei n,GLuint* buffers);
GEGL_EXPORT void glTextureStorageMem2DMultisampleEXT(GLuint texture,GLsizei samples,GLenum internalFormat,GLsizei width,GLsizei height,GLboolean fixedSampleLocations,GLuint memory,GLuint64 offset);
GEGL_EXPORT void glListParameterfvSGIX(GLuint list,GLenum pname,const GLfloat* params);
GEGL_EXPORT void glNamedRenderbufferStorageMultisample(GLuint renderbuffer,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height);
GEGL_EXPORT void glVertexAttribI1iEXT(GLuint index,GLint x);
GEGL_EXPORT void glMultiTexCoord2ivARB(GLenum target,const GLint* v);
GEGL_EXPORT void glLightModelxOES(GLenum pname,GLfixed param);
GEGL_EXPORT void glColor3xOES(GLfixed red,GLfixed green,GLfixed blue);
GEGL_EXPORT void glReadBuffer(GLenum mode);
GEGL_EXPORT void glStencilFillPathInstancedNV(GLsizei numPaths,GLenum pathNameType,const void* paths,GLuint pathBase,GLenum fillMode,GLuint mask,GLenum transformType,const GLfloat* transformValues);
GEGL_EXPORT void glVDPAUUnmapSurfacesNV(GLsizei numSurface,const GLvdpauSurfaceNV* surfaces);
GEGL_EXPORT void glProgramUniform4i64NV(GLuint program,GLint location,GLint64EXT x,GLint64EXT y,GLint64EXT z,GLint64EXT w);
GEGL_EXPORT void glVertexStream4dvATI(GLenum stream,const GLdouble* coords);
GEGL_EXPORT GLboolean glIsQuery(GLuint id);
GEGL_EXPORT void glProgramUniformMatrix4fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glVertexAttrib3hNV(GLuint index,GLhalfNV x,GLhalfNV y,GLhalfNV z);
GEGL_EXPORT void glFlushMappedNamedBufferRange(GLuint buffer,GLintptr offset,GLsizeiptr length);
GEGL_EXPORT void glPushName(GLuint name);
GEGL_EXPORT void glGetClipPlane(GLenum plane,GLdouble* equation);
GEGL_EXPORT void glVertex4dv(const GLdouble* v);
GEGL_EXPORT void glVertexAttrib3d(GLuint index,GLdouble x,GLdouble y,GLdouble z);
GEGL_EXPORT void glBlendColor(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha);
GEGL_EXPORT void glBindTransformFeedbackNV(GLenum target,GLuint id);
GEGL_EXPORT void glSamplerParameterIuiv(GLuint sampler,GLenum pname,const GLuint* param);
GEGL_EXPORT void glIndexubv(const GLubyte* c);
GEGL_EXPORT void glNamedBufferPageCommitmentEXT(GLuint buffer,GLintptr offset,GLsizeiptr size,GLboolean commit);
GEGL_EXPORT GLenum glCheckNamedFramebufferStatus(GLuint framebuffer,GLenum target);
GEGL_EXPORT void glGetObjectBufferfvATI(GLuint buffer,GLenum pname,GLfloat* params);
GEGL_EXPORT void glRasterPos4d(GLdouble x,GLdouble y,GLdouble z,GLdouble w);
GEGL_EXPORT void glRasterPos4f(GLfloat x,GLfloat y,GLfloat z,GLfloat w);
GEGL_EXPORT void glGetPerfMonitorCounterStringAMD(GLuint group,GLuint counter,GLsizei bufSize,GLsizei* length,GLchar* counterString);
GEGL_EXPORT void glVertexAttrib3s(GLuint index,GLshort x,GLshort y,GLshort z);
GEGL_EXPORT void glDrawElementsInstancedEXT(GLenum mode,GLsizei count,GLenum type,const void* indices,GLsizei primcount);
GEGL_EXPORT void glNamedProgramLocalParameterI4iEXT(GLuint program,GLenum target,GLuint index,GLint x,GLint y,GLint z,GLint w);
GEGL_EXPORT void glRasterPos4s(GLshort x,GLshort y,GLshort z,GLshort w);
GEGL_EXPORT void glGetProgramStageiv(GLuint program,GLenum shadertype,GLenum pname,GLint* values);
GEGL_EXPORT void glGetMaterialxOES(GLenum face,GLenum pname,GLfixed param);
GEGL_EXPORT void glPopMatrix();
GEGL_EXPORT void glGetVideoui64vNV(GLuint video_slot,GLenum pname,GLuint64EXT* params);
GEGL_EXPORT void glTangent3bEXT(GLbyte tx,GLbyte ty,GLbyte tz);
GEGL_EXPORT GLenum glGetGraphicsResetStatusARB();
GEGL_EXPORT void glUniform4i(GLint location,GLint v0,GLint v1,GLint v2,GLint v3);
GEGL_EXPORT void glActiveTexture(GLenum texture);
GEGL_EXPORT void glEnableVertexAttribArray(GLuint index);
GEGL_EXPORT void glTexCoord4fVertex4fvSUN(const GLfloat* tc,const GLfloat* v);
GEGL_EXPORT void glUniform4d(GLint location,GLdouble x,GLdouble y,GLdouble z,GLdouble w);
GEGL_EXPORT void glUniform4f(GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3);
GEGL_EXPORT void glRenderbufferStorageMultisample(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height);
GEGL_EXPORT void glCreateProgramPipelines(GLsizei n,GLuint* pipelines);
GEGL_EXPORT void glVertexAttribLPointer(GLuint index,GLint size,GLenum type,GLsizei stride,const void* pointer);
GEGL_EXPORT void glUniform2uiEXT(GLint location,GLuint v0,GLuint v1);
GEGL_EXPORT void glMultiTexCoord3sv(GLenum target,const GLshort* v);
GEGL_EXPORT void glDrawElementsInstancedBaseVertex(GLenum mode,GLsizei count,GLenum type,const void* indices,GLsizei instancecount,GLint basevertex);
GEGL_EXPORT void glPixelTransformParameterfvEXT(GLenum target,GLenum pname,const GLfloat* params);
GEGL_EXPORT void glDrawTransformFeedbackNV(GLenum mode,GLuint id);
GEGL_EXPORT void glTextureImage2DMultisampleCoverageNV(GLuint texture,GLenum target,GLsizei coverageSamples,GLsizei colorSamples,GLint internalFormat,GLsizei width,GLsizei height,GLboolean fixedSampleLocations);
GEGL_EXPORT void glNamedRenderbufferStorageMultisampleCoverageEXT(GLuint renderbuffer,GLsizei coverageSamples,GLsizei colorSamples,GLenum internalformat,GLsizei width,GLsizei height);
GEGL_EXPORT GLboolean glIsTexture(GLuint texture);
GEGL_EXPORT void glMultiTexCoord4iv(GLenum target,const GLint* v);
GEGL_EXPORT void glTexEnvfv(GLenum target,GLenum pname,const GLfloat* params);
GEGL_EXPORT void glPopDebugGroup();
GEGL_EXPORT void glUniformBlockBinding(GLuint program,GLuint uniformBlockIndex,GLuint uniformBlockBinding);
GEGL_EXPORT void glWindowPos2svMESA(const GLshort* v);
GEGL_EXPORT void glGenerateTextureMipmapEXT(GLuint texture,GLenum target);
GEGL_EXPORT GLuint glBindLightParameterEXT(GLenum light,GLenum value);
GEGL_EXPORT void glTexCoord3bOES(GLbyte s,GLbyte t,GLbyte r);
GEGL_EXPORT void glTexCoordPointer(GLint size,GLenum type,GLsizei stride,const GLvoid* ptr);
GEGL_EXPORT void glProgramUniformMatrix3x2fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glUniform2fvARB(GLint location,GLsizei count,const GLfloat* value);
GEGL_EXPORT void glProgramLocalParameterI4uivNV(GLenum target,GLuint index,const GLuint* params);
GEGL_EXPORT void glFlushVertexArrayRangeNV();
GEGL_EXPORT void glSecondaryColor3svEXT(const GLshort* v);
GEGL_EXPORT void glGetBufferParameteriv(GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glGetQueryIndexediv(GLenum target,GLuint index,GLenum pname,GLint* params);
GEGL_EXPORT void glFramebufferTexture3DEXT(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level,GLint zoffset);
GEGL_EXPORT void glLoadTransposeMatrixxOES(const GLfixed* m);
GEGL_EXPORT void glDeleteTransformFeedbacksNV(GLsizei n,const GLuint* ids);
GEGL_EXPORT void glGetCompressedTextureImageEXT(GLuint texture,GLenum target,GLint lod,void* img);
GEGL_EXPORT void glIndexMaterialEXT(GLenum face,GLenum mode);
GEGL_EXPORT void glFogCoorddEXT(GLdouble coord);
GEGL_EXPORT void glTexCoord2hvNV(const GLhalfNV* v);
GEGL_EXPORT void glGetFramebufferParameterfvAMD(GLenum target,GLenum pname,GLuint numsamples,GLuint pixelindex,GLsizei size,GLfloat* values);
GEGL_EXPORT void glTexEnviv(GLenum target,GLenum pname,const GLint* params);
GEGL_EXPORT void glEndTransformFeedbackNV();
GEGL_EXPORT void glGlobalAlphaFactoruiSUN(GLuint factor);
GEGL_EXPORT void glSelectBuffer(GLsizei size,GLuint* buffer);
GEGL_EXPORT void glNamedBufferSubDataEXT(GLuint buffer,GLintptr offset,GLsizeiptr size,const void* data);
GEGL_EXPORT void glDisableVertexArrayAttrib(GLuint vaobj,GLuint index);
GEGL_EXPORT void glBlendFunc(GLenum sfactor,GLenum dfactor);
GEGL_EXPORT GLuint glCreateProgram();
GEGL_EXPORT void glVertexStream2dATI(GLenum stream,GLdouble x,GLdouble y);
GEGL_EXPORT void glUniform4ui64vARB(GLint location,GLsizei count,const GLuint64* value);
GEGL_EXPORT void glGetSemaphoreParameterui64vEXT(GLuint semaphore,GLenum pname,GLuint64* params);
GEGL_EXPORT void glPrimitiveRestartIndex(GLuint index);
GEGL_EXPORT void glNormalStream3fATI(GLenum stream,GLfloat nx,GLfloat ny,GLfloat nz);
GEGL_EXPORT void glProgramUniformMatrix2fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glVertexAttribs1hvNV(GLuint index,GLsizei n,const GLhalfNV* v);
GEGL_EXPORT void glWindowPos4svMESA(const GLshort* v);
GEGL_EXPORT void glDeleteFragmentShaderATI(GLuint id);
GEGL_EXPORT void glBindImageTextures(GLuint first,GLsizei count,const GLuint* textures);
GEGL_EXPORT void glMap2xOES(GLenum target,GLfixed u1,GLfixed u2,GLint ustride,GLint uorder,GLfixed v1,GLfixed v2,GLint vstride,GLint vorder,GLfixed points);
GEGL_EXPORT void glEnd();
GEGL_EXPORT void glMultiTexCoord2dARB(GLenum target,GLdouble s,GLdouble t);
GEGL_EXPORT void glUniform1i64NV(GLint location,GLint64EXT x);
GEGL_EXPORT void glPathStringNV(GLuint path,GLenum format,GLsizei length,const void* pathString);
GEGL_EXPORT void glGetNamedFramebufferParameterivEXT(GLuint framebuffer,GLenum pname,GLint* params);
GEGL_EXPORT void glGetProgramNamedParameterdvNV(GLuint id,GLsizei len,const GLubyte* name,GLdouble* params);
GEGL_EXPORT void glPathDashArrayNV(GLuint path,GLsizei dashCount,const GLfloat* dashArray);
GEGL_EXPORT void glUniform3uiv(GLint location,GLsizei count,const GLuint* value);
GEGL_EXPORT void glColor3fVertex3fvSUN(const GLfloat* c,const GLfloat* v);
GEGL_EXPORT void glMultTransposeMatrixd(const GLdouble m[16]);
GEGL_EXPORT void glClearColor(GLclampf red,GLclampf green,GLclampf blue,GLclampf alpha);
GEGL_EXPORT GLuint64 glGetImageHandleARB(GLuint texture,GLint level,GLboolean layered,GLint layer,GLenum format);
GEGL_EXPORT void glTangent3dEXT(GLdouble tx,GLdouble ty,GLdouble tz);
GEGL_EXPORT void glGetQueryObjectivARB(GLuint id,GLenum pname,GLint* params);
GEGL_EXPORT void glGetLocalConstantFloatvEXT(GLuint id,GLenum value,GLfloat* data);
GEGL_EXPORT void glUseShaderProgramEXT(GLenum type,GLuint program);
GEGL_EXPORT void glBindRenderbufferEXT(GLenum target,GLuint renderbuffer);
GEGL_EXPORT void glInterleavedArrays(GLenum format,GLsizei stride,const GLvoid* pointer);
GEGL_EXPORT void glGetPerfMonitorGroupStringAMD(GLuint group,GLsizei bufSize,GLsizei* length,GLchar* groupString);
GEGL_EXPORT void glUniform3ui(GLint location,GLuint v0,GLuint v1,GLuint v2);
GEGL_EXPORT void glGetNamedProgramLocalParameterdvEXT(GLuint program,GLenum target,GLuint index,GLdouble* params);
GEGL_EXPORT void glDeleteQueryResourceTagNV(GLsizei n,const GLint* tagIds);
GEGL_EXPORT void glVertexAttribI4uiv(GLuint index,const GLuint* v);
GEGL_EXPORT void glVertexAttrib4bv(GLuint index,const GLbyte* v);
GEGL_EXPORT void glMultiTexCoord3xOES(GLenum texture,GLfixed s,GLfixed t,GLfixed r);
GEGL_EXPORT void glSecondaryColor3ub(GLubyte red,GLubyte green,GLubyte blue);
GEGL_EXPORT void glFragmentMaterialfSGIX(GLenum face,GLenum pname,GLfloat param);
GEGL_EXPORT void glGetVariantArrayObjectivATI(GLuint id,GLenum pname,GLint* params);
GEGL_EXPORT void glSecondaryColor3ui(GLuint red,GLuint green,GLuint blue);
GEGL_EXPORT void glVertexAttrib1dARB(GLuint index,GLdouble x);
GEGL_EXPORT void glGetNamedBufferPointerv(GLuint buffer,GLenum pname,void** params);
GEGL_EXPORT void glLockArraysEXT(GLint first,GLsizei count);
GEGL_EXPORT void glVertexAttribPointerNV(GLuint index,GLint fsize,GLenum type,GLsizei stride,const void* pointer);
GEGL_EXPORT void glConvolutionParameterf(GLenum target,GLenum pname,GLfloat params);
GEGL_EXPORT void glBindBufferBaseEXT(GLenum target,GLuint index,GLuint buffer);
GEGL_EXPORT void glTexCoord2xvOES(const GLfixed* coords);
GEGL_EXPORT void glGetQueryBufferObjectui64v(GLuint id,GLuint buffer,GLenum pname,GLintptr offset);
GEGL_EXPORT void glSetMultisamplefvAMD(GLenum pname,GLuint index,const GLfloat* val);
GEGL_EXPORT void glPathColorGenNV(GLenum color,GLenum genMode,GLenum colorFormat,const GLfloat* coeffs);
GEGL_EXPORT void glVertexAttrib3sARB(GLuint index,GLshort x,GLshort y,GLshort z);
GEGL_EXPORT void glVertexAttrib4ivARB(GLuint index,const GLint* v);
GEGL_EXPORT void glGenTransformFeedbacks(GLsizei n,GLuint* ids);
GEGL_EXPORT void glGetVertexAttribIuiv(GLuint index,GLenum pname,GLuint* params);
GEGL_EXPORT void glPixelTransformParameterfEXT(GLenum target,GLenum pname,GLfloat param);
GEGL_EXPORT void glGetTexParameterIuivEXT(GLenum target,GLenum pname,GLuint* params);
GEGL_EXPORT void glGetObjectParameterivARB(GLhandleARB obj,GLenum pname,GLint* params);
GEGL_EXPORT void glVertexArraySecondaryColorOffsetEXT(GLuint vaobj,GLuint buffer,GLint size,GLenum type,GLsizei stride,GLintptr offset);
GEGL_EXPORT void glWindowPos2fARB(GLfloat x,GLfloat y);
GEGL_EXPORT void glCompressedTexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,const GLvoid* data);
GEGL_EXPORT void glCompressedTexSubImage3DARB(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,const void* data);
GEGL_EXPORT void glProgramBinary(GLuint program,GLenum binaryFormat,const void* binary,GLsizei length);
GEGL_EXPORT void glPresentFrameKeyedNV(GLuint video_slot,GLuint64EXT minPresentTime,GLuint beginPresentTimeId,GLuint presentDurationId,GLenum type,GLenum target0,GLuint fill0,GLuint key0,GLenum target1,GLuint fill1,GLuint key1);
GEGL_EXPORT void glVertexAttribI4bv(GLuint index,const GLbyte* v);
GEGL_EXPORT void glPathCoverDepthFuncNV(GLenum func);
GEGL_EXPORT void glTransformFeedbackStreamAttribsNV(GLsizei count,const GLint* attribs,GLsizei nbuffers,const GLint* bufstreams,GLenum bufferMode);
GEGL_EXPORT void glSecondaryColor3usEXT(GLushort red,GLushort green,GLushort blue);
GEGL_EXPORT void glCopyColorTableSGI(GLenum target,GLenum internalformat,GLint x,GLint y,GLsizei width);
GEGL_EXPORT void glProgramEnvParameter4fvARB(GLenum target,GLuint index,const GLfloat* params);
GEGL_EXPORT void glMultiTexCoord4sARB(GLenum target,GLshort s,GLshort t,GLshort r,GLshort q);
GEGL_EXPORT void glGetVertexArrayIndexed64iv(GLuint vaobj,GLuint index,GLenum pname,GLint64* param);
GEGL_EXPORT void glMatrixMultTranspose3x3fNV(GLenum matrixMode,const GLfloat* m);
GEGL_EXPORT void glTexParameterIiv(GLenum target,GLenum pname,const GLint* params);
GEGL_EXPORT void glVertexArrayAttribFormat(GLuint vaobj,GLuint attribindex,GLint size,GLenum type,GLboolean normalized,GLuint relativeoffset);
GEGL_EXPORT void glEndTransformFeedback();
GEGL_EXPORT void glDrawCommandsStatesAddressNV(const GLuint64* indirects,const GLsizei* sizes,const GLuint* states,const GLuint* fbos,GLuint count);
GEGL_EXPORT void glUniform4ui64NV(GLint location,GLuint64EXT x,GLuint64EXT y,GLuint64EXT z,GLuint64EXT w);
GEGL_EXPORT void glMaterialiv(GLenum face,GLenum pname,const GLint* params);
GEGL_EXPORT void glTexImage2DMultisample(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLboolean fixedsamplelocations);
GEGL_EXPORT void glBindTextureEXT(GLenum target,GLuint texture);
GEGL_EXPORT GLboolean glIsBuffer(GLuint buffer);
GEGL_EXPORT void glVertexAttribI1iv(GLuint index,const GLint* v);
GEGL_EXPORT void glGetFinalCombinerInputParameterfvNV(GLenum variable,GLenum pname,GLfloat* params);
GEGL_EXPORT void glMultiTexCoord3bvOES(GLenum texture,const GLbyte* coords);
GEGL_EXPORT void glVertexAttribDivisor(GLuint index,GLuint divisor);
GEGL_EXPORT void glCopyBufferSubData(GLenum readTarget,GLenum writeTarget,GLintptr readOffset,GLintptr writeOffset,GLsizeiptr size);
GEGL_EXPORT GLuint glBindTexGenParameterEXT(GLenum unit,GLenum coord,GLenum value);
GEGL_EXPORT void glNormalStream3bATI(GLenum stream,GLbyte nx,GLbyte ny,GLbyte nz);
GEGL_EXPORT void glTexStorageMem2DEXT(GLenum target,GLsizei levels,GLenum internalFormat,GLsizei width,GLsizei height,GLuint memory,GLuint64 offset);
GEGL_EXPORT void glTextureImage2DEXT(GLuint texture,GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,const void* pixels);
GEGL_EXPORT void glGetColorTableParameteriv(GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glActiveTextureARB(GLenum texture);
GEGL_EXPORT void glTexCoord4xOES(GLfixed s,GLfixed t,GLfixed r,GLfixed q);
GEGL_EXPORT void glNamedBufferStorageExternalEXT(GLuint buffer,GLintptr offset,GLsizeiptr size,GLeglClientBufferEXT clientBuffer,GLbitfield flags);
GEGL_EXPORT void glSecondaryColor3fvEXT(const GLfloat* v);
GEGL_EXPORT void glUniformMatrix4x2fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glStartInstrumentsSGIX();
GEGL_EXPORT void glProgramNamedParameter4fvNV(GLuint id,GLsizei len,const GLubyte* name,const GLfloat* v);
GEGL_EXPORT void glEndVideoCaptureNV(GLuint video_capture_slot);
GEGL_EXPORT GLuint glGenLists(GLsizei range);
GEGL_EXPORT void glUniform1fARB(GLint location,GLfloat v0);
GEGL_EXPORT void glNamedFramebufferTexture1DEXT(GLuint framebuffer,GLenum attachment,GLenum textarget,GLuint texture,GLint level);
GEGL_EXPORT void* glMapBufferRange(GLenum target,GLintptr offset,GLsizeiptr length,GLbitfield access);
GEGL_EXPORT void glMultiDrawElementsIndirectCountARB(GLenum mode,GLenum type,const void* indirect,GLintptr drawcount,GLsizei maxdrawcount,GLsizei stride);
GEGL_EXPORT void glProgramUniformMatrix4x2fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glGetTextureParameterIivEXT(GLuint texture,GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glMultiTexCoord3hNV(GLenum target,GLhalfNV s,GLhalfNV t,GLhalfNV r);
GEGL_EXPORT void glNamedProgramLocalParametersI4uivEXT(GLuint program,GLenum target,GLuint index,GLsizei count,const GLuint* params);
GEGL_EXPORT void glEndList();
GEGL_EXPORT void glTexCoord2fColor4fNormal3fVertex3fSUN(GLfloat s,GLfloat t,GLfloat r,GLfloat g,GLfloat b,GLfloat a,GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z);
GEGL_EXPORT void glGenTransformFeedbacksNV(GLsizei n,GLuint* ids);
GEGL_EXPORT void glEdgeFlagv(const GLboolean* flag);
GEGL_EXPORT void glVertexAttribI2iv(GLuint index,const GLint* v);
GEGL_EXPORT void glCopyMultiTexImage2DEXT(GLenum texunit,GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLsizei height,GLint border);
GEGL_EXPORT void glUniformMatrix3x2dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble* value);
GEGL_EXPORT void glTexImage3DMultisampleCoverageNV(GLenum target,GLsizei coverageSamples,GLsizei colorSamples,GLint internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedSampleLocations);
GEGL_EXPORT void glGetShaderPrecisionFormat(GLenum shadertype,GLenum precisiontype,GLint* range,GLint* precision);
GEGL_EXPORT void glTexSubImage4DSGIS(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint woffset,GLsizei width,GLsizei height,GLsizei depth,GLsizei size4d,GLenum format,GLenum type,const void* pixels);
GEGL_EXPORT void glRasterSamplesEXT(GLuint samples,GLboolean fixedsamplelocations);
GEGL_EXPORT void glTextureView(GLuint texture,GLenum target,GLuint origtexture,GLenum internalformat,GLuint minlevel,GLuint numlevels,GLuint minlayer,GLuint numlayers);
GEGL_EXPORT void glEvalMapsNV(GLenum target,GLenum mode);
GEGL_EXPORT GLint glGetFragDataLocationEXT(GLuint program,const GLchar* name);
GEGL_EXPORT void glGetCompressedMultiTexImageEXT(GLenum texunit,GLenum target,GLint lod,void* img);
GEGL_EXPORT void glIndexMask(GLuint mask);
GEGL_EXPORT void glPushClientAttrib(GLbitfield mask);
GEGL_EXPORT void glShaderSource(GLuint shader,GLsizei count,const GLchar*const* string,const GLint* length);
GEGL_EXPORT void glDispatchComputeGroupSizeARB(GLuint num_groups_x,GLuint num_groups_y,GLuint num_groups_z,GLuint group_size_x,GLuint group_size_y,GLuint group_size_z);
GEGL_EXPORT void glLGPUNamedBufferSubDataNVX(GLbitfield gpuMask,GLuint buffer,GLintptr offset,GLsizeiptr size,const void* data);
GEGL_EXPORT void glGetnPixelMapfv(GLenum map,GLsizei bufSize,GLfloat* values);
GEGL_EXPORT void glTexCoordP2uiv(GLenum type,const GLuint* coords);
GEGL_EXPORT void glUniform2f(GLint location,GLfloat v0,GLfloat v1);
GEGL_EXPORT void glGetNamedBufferParameteri64v(GLuint buffer,GLenum pname,GLint64* params);
GEGL_EXPORT void glCommandListSegmentsNV(GLuint list,GLuint segments);
GEGL_EXPORT void glTextureParameterIivEXT(GLuint texture,GLenum target,GLenum pname,const GLint* params);
GEGL_EXPORT void glMultiTexParameterfvEXT(GLenum texunit,GLenum target,GLenum pname,const GLfloat* params);
GEGL_EXPORT void glProgramUniform2ui64ARB(GLuint program,GLint location,GLuint64 x,GLuint64 y);
GEGL_EXPORT void glVertex4d(GLdouble x,GLdouble y,GLdouble z,GLdouble w);
GEGL_EXPORT GLuint glNewObjectBufferATI(GLsizei size,const void* pointer,GLenum usage);
GEGL_EXPORT void glViewportSwizzleNV(GLuint index,GLenum swizzlex,GLenum swizzley,GLenum swizzlez,GLenum swizzlew);
GEGL_EXPORT void glBufferData(GLenum target,GLsizeiptr size,const void* data,GLenum usage);
GEGL_EXPORT void glTextureImage1DEXT(GLuint texture,GLenum target,GLint level,GLint internalformat,GLsizei width,GLint border,GLenum format,GLenum type,const void* pixels);
GEGL_EXPORT void glGetTexParameterIiv(GLenum target,GLenum pname,GLint* params);
GEGL_EXPORT void glCopyTexSubImage1DEXT(GLenum target,GLint level,GLint xoffset,GLint x,GLint y,GLsizei width);
GEGL_EXPORT void glVertex4f(GLfloat x,GLfloat y,GLfloat z,GLfloat w);
GEGL_EXPORT void glUniformMatrix3fvARB(GLint location,GLsizei count,GLboolean transpose,const GLfloat* value);
GEGL_EXPORT void glTexCoordP1ui(GLenum type,GLuint coords);
GEGL_EXPORT void glPointParameterfvEXT(GLenum pname,const GLfloat* params);
GEGL_EXPORT void glUniform4fARB(GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3);
GEGL_EXPORT void glImportMemoryFdEXT(GLuint memory,GLuint64 size,GLenum handleType,GLint fd);
GEGL_EXPORT void glCopyTextureSubImage3D(GLuint texture,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height);
GEGL_EXPORT void glMultiTexCoord2fv(GLenum target,const GLfloat* v);
GEGL_EXPORT void glNamedFramebufferSamplePositionsfvAMD(GLuint framebuffer,GLuint numsamples,GLuint pixelindex,const GLfloat* values);
GEGL_EXPORT void glNormalP3ui(GLenum type,GLuint coords);
GEGL_EXPORT void glDrawRangeElementArrayATI(GLenum mode,GLuint start,GLuint end,GLsizei count);
GEGL_EXPORT void glVertexAttribI1i(GLuint index,GLint x);
GEGL_EXPORT void glDrawArraysInstancedARB(GLenum mode,GLint first,GLsizei count,GLsizei primcount);
GEGL_EXPORT void glEnableVertexAttribAPPLE(GLuint index,GLenum pname);
GEGL_EXPORT GLuint glGetDebugMessageLogARB(GLuint count,GLsizei bufSize,GLenum* sources,GLenum* types,GLuint* ids,GLenum* severities,GLsizei* lengths,GLchar* messageLog);
GEGL_EXPORT void glGetPathTexGenfvNV(GLenum texCoordSet,GLenum pname,GLfloat* value);
GEGL_EXPORT void glNamedProgramLocalParameters4fvEXT(GLuint program,GLenum target,GLuint index,GLsizei count,const GLfloat* params);
GEGL_EXPORT void glQueryResourceTagNV(GLint tagId,const GLchar* tagString);
GEGL_EXPORT void glVertexStream3fvATI(GLenum stream,const GLfloat* coords);
GEGL_EXPORT void glFramebufferTexture3D(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level,GLint zoffset);
GEGL_EXPORT void glCompressedTextureSubImage2DEXT(GLuint texture,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,const void* bits);
GEGL_EXPORT void glWindowPos3dv(const GLdouble* v);
GEGL_EXPORT void glCopyConvolutionFilter2D(GLenum target,GLenum internalformat,GLint x,GLint y,GLsizei width,GLsizei height);
GEGL_EXPORT void glReadInstrumentsSGIX(GLint marker);
GEGL_EXPORT void glProgramUniform2dvEXT(GLuint program,GLint location,GLsizei count,const GLdouble* value);
GEGL_EXPORT void glSamplerParameterfv(GLuint sampler,GLenum pname,const GLfloat* param);
GEGL_EXPORT void glBindBufferARB(GLenum target,GLuint buffer);
GEGL_EXPORT void glVertexAttrib1sNV(GLuint index,GLshort x);
GEGL_EXPORT void glGetMaterialiv(GLenum face,GLenum pname,GLint* params);
GEGL_EXPORT void glUniform1fv(GLint location,GLsizei count,const GLfloat* value);
GEGL_EXPORT void glBeginOcclusionQueryNV(GLuint id);
GEGL_EXPORT void glGenFencesAPPLE(GLsizei n,GLuint* fences);
GEGL_EXPORT void glScissorIndexedv(GLuint index,const GLint* v);
GEGL_EXPORT void glDisableVariantClientStateEXT(GLuint id);
GEGL_EXPORT void glMinmaxEXT(GLenum target,GLenum internalformat,GLboolean sink);
GEGL_EXPORT void glNormalPointervINTEL(GLenum type,const void** pointer);
GEGL_EXPORT void glNormal3s(GLshort nx,GLshort ny,GLshort nz);
GEGL_EXPORT void glGetnPixelMapuiv(GLenum map,GLsizei bufSize,GLuint* values);
GEGL_EXPORT void glNormalStream3bvATI(GLenum stream,const GLbyte* coords);
GEGL_EXPORT void glGetObjectParameterivAPPLE(GLenum objectType,GLuint name,GLenum pname,GLint* params);
GEGL_EXPORT void glNormal3i(GLint nx,GLint ny,GLint nz);
GEGL_EXPORT void glUniform1ivARB(GLint location,GLsizei count,const GLint* value);
GEGL_EXPORT void glNormal3d(GLdouble nx,GLdouble ny,GLdouble nz);
GEGL_EXPORT void glUpdateObjectBufferATI(GLuint buffer,GLuint offset,GLsizei size,const void* pointer,GLenum preserve);
GEGL_EXPORT void glNormal3b(GLbyte nx,GLbyte ny,GLbyte nz);
GEGL_EXPORT GLint glGetUniformBufferSizeEXT(GLuint program,GLint location);
GEGL_EXPORT void glMultiTexCoord4dv(GLenum target,const GLdouble* v);
GEGL_EXPORT void glProgramUniform3i64ARB(GLuint program,GLint location,GLint64 x,GLint64 y,GLint64 z);
GEGL_EXPORT void glVertexAttrib2d(GLuint index,GLdouble x,GLdouble y);
GEGL_EXPORT void glVertexAttrib2f(GLuint index,GLfloat x,GLfloat y);
GEGL_EXPORT void glMultiDrawElementsEXT(GLenum mode,const GLsizei* count,GLenum type,const void*const* indices,GLsizei primcount);
GEGL_EXPORT void glVertexAttrib3dv(GLuint index,const GLdouble* v);
GEGL_EXPORT void glMultiTexCoord2bOES(GLenum texture,GLbyte s,GLbyte t);
GEGL_EXPORT void glVertexAttrib2s(GLuint index,GLshort x,GLshort y);
GEGL_EXPORT void glTexImage3DMultisample(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedsamplelocations);
GEGL_EXPORT GLuint glGetUniformBlockIndex(GLuint program,const GLchar* uniformBlockName);
GEGL_EXPORT GLboolean glReleaseKeyedMutexWin32EXT(GLuint memory,GLuint64 key);
GEGL_EXPORT void glFrontFace(GLenum mode);
GEGL_EXPORT void glEvalCoord1xOES(GLfixed u);
GEGL_EXPORT void glDrawArraysInstancedBaseInstance(GLenum mode,GLint first,GLsizei count,GLsizei instancecount,GLuint baseinstance);
GEGL_EXPORT GLboolean glIsPointInStrokePathNV(GLuint path,GLfloat x,GLfloat y);
}
}
| 91.907231 | 300 | 0.819402 |
ad72c233db018aafed8c6e55fb859ed3ace8277d | 2,783 | c | C | VBoxCAPISample/framebuffer.c | ivanshchitov/VBoxCAPISample | decc9f951cac9e3acb8eda417045a54f7a80897b | [
"MIT"
] | 1 | 2020-12-04T07:56:14.000Z | 2020-12-04T07:56:14.000Z | VBoxCAPISample/framebuffer.c | ivanshchitov/VBoxCAPISample | decc9f951cac9e3acb8eda417045a54f7a80897b | [
"MIT"
] | null | null | null | VBoxCAPISample/framebuffer.c | ivanshchitov/VBoxCAPISample | decc9f951cac9e3acb8eda417045a54f7a80897b | [
"MIT"
] | null | null | null | #include "framebuffer.h"
#include "framebuffer_6_1.h"
#include <stdio.h>
ES_HRESULT fbGetWidth(VBoxEmptyFb *framebuffer, ES_PRUint32 *width)
{
printf("fbGetWidth\n");
UNUSED(framebuffer);
if (!width) {
printf("E_INVALIDARG\n");
return E_INVALIDARG;
}
*width = 0;
return 0;
}
ES_HRESULT fbGetHeight(VBoxEmptyFb *framebuffer, ES_PRUint32 *height)
{
printf("fbGetHeight\n");
UNUSED(framebuffer);
if (!height) {
printf("E_INVALIDARG\n");
return E_INVALIDARG;
}
*height = 0;
return 0;
}
ES_HRESULT fbGetBitsPerPixel(VBoxEmptyFb *framebuffer, ES_PRUint32 *bitsPerPixel)
{
UNUSED(framebuffer);
if (!bitsPerPixel) {
return E_INVALIDARG;
}
*bitsPerPixel = 32;
return 0;
}
ES_HRESULT fbGetBytesPerLine(VBoxEmptyFb *framebuffer, ES_PRUint32 *bytesPerLine)
{
UNUSED(framebuffer);
if (!bytesPerLine) {
return E_INVALIDARG;
}
*bytesPerLine = 0;
return 0;
}
ES_HRESULT fbGetPixelFormat(VBoxEmptyFb *framebuffer, ES_PRUint32 *pixelFormat)
{
UNUSED(framebuffer);
if (!pixelFormat) {
return E_INVALIDARG;
}
*pixelFormat = BitmapFormat_BGR;
return 0;
}
ES_HRESULT fbGetHeightReduction(VBoxEmptyFb *framebuffer, ES_PRUint32 *heightReduction)
{
UNUSED(framebuffer);
UNUSED(heightReduction);
return 0;
}
ES_HRESULT fbGetWinId(VBoxEmptyFb *framebuffer, ES_PRInt64 *winId)
{
UNUSED(framebuffer);
UNUSED(winId);
return 0;
}
ES_HRESULT fbNotifyUpdate(VBoxEmptyFb *framebuffer, ES_PRUint32 x, ES_PRUint32 y, ES_PRUint32 width,
ES_PRUint32 height)
{
printf("fbNotifyUpdate\n");
UNUSED(framebuffer);
UNUSED(x);
UNUSED(y);
UNUSED(width);
UNUSED(height);
return 0;
}
ES_HRESULT fbVideoModeSupported(VBoxEmptyFb *framebuffer, ES_PRUint32 width, ES_PRUint32 height,
ES_PRUint32 bpp, ES_PRBool *supported)
{
UNUSED(framebuffer);
UNUSED(width);
UNUSED(height);
UNUSED(bpp);
UNUSED(supported);
return 0;
}
ES_HRESULT fbGetVisibleRegion(VBoxEmptyFb *framebuffer, ES_PRUint8 *rectangles, ES_PRUint32 count,
ES_PRUint32 *countCopied)
{
UNUSED(framebuffer);
UNUSED(rectangles);
UNUSED(count);
UNUSED(countCopied);
return 0;
}
ES_HRESULT fbSetVisibleRegion(VBoxEmptyFb *framebuffer, ES_PRUint8 *rectangles, ES_PRUint32 count)
{
UNUSED(framebuffer);
UNUSED(rectangles);
UNUSED(count);
return 0;
}
ES_HRESULT fbProcessVHWACommand(VBoxEmptyFb *framebuffer, ES_PRUint8 *command, ES_PRUint32 enmCmd,
ES_PRBool fromGuest)
{
UNUSED(framebuffer);
UNUSED(command);
UNUSED(enmCmd);
UNUSED(fromGuest);
return 0;
}
ES_HRESULT fbNotify3DEvent(VBoxEmptyFb *framebuffer, ES_PRUint32 type, ES_PRUint32 dataSize, ES_PRUint8 *data)
{
UNUSED(framebuffer);
UNUSED(type);
UNUSED(dataSize);
UNUSED(data);
return 0;
}
| 20.924812 | 111 | 0.724039 |
21167a9df5e2e92601621ace2931fc3baa2d65eb | 1,184 | h | C | resources/american-archive-kaldi/sample_experiment/tools/CMUseg_0.5/src/lib/sphere/include/sp/wavpack/wavpack.h | AudiovisualMetadataPlatform/kaldi-pua-singularity | 0f0575466423c00c96ff86efc92f849e61e1193e | [
"Apache-2.0"
] | 83 | 2015-01-18T01:20:37.000Z | 2022-03-02T20:15:27.000Z | resources/american-archive-kaldi/sample_experiment/tools/CMUseg_0.5/src/lib/sphere/include/sp/wavpack/wavpack.h | AudiovisualMetadataPlatform/kaldi-pua-singularity | 0f0575466423c00c96ff86efc92f849e61e1193e | [
"Apache-2.0"
] | 4 | 2016-03-03T08:43:00.000Z | 2019-03-08T06:20:56.000Z | resources/american-archive-kaldi/sample_experiment/tools/CMUseg_0.5/src/lib/sphere/include/sp/wavpack/wavpack.h | AudiovisualMetadataPlatform/kaldi-pua-singularity | 0f0575466423c00c96ff86efc92f849e61e1193e | [
"Apache-2.0"
] | 59 | 2015-02-02T03:07:37.000Z | 2021-11-22T12:05:42.000Z | #ifndef _WAVPACK_H_
#define _WAVPACK_H_
#define WAVPACK_MAGIC "wavpack1.0"
#define RUNL 256 /* max run length <=256 */
/* compression format flags */
#define BYTE 0 /* 8 bit data format */
#define SHORT 0x20 /* 16 bit data format (else 8 bit) */
#define REV 0x10 /* byte reversed (SHORT only) */
#define OFFSET 0x8 /* 1 byte data offset */
#define DIFF 0x4 /* differential pcm */
#define STEREO 0x2 /* 2 channel */
#define CHAN1 0x1 /* channel nr (0 or 1) */
#define WAV 1 /* modes */
#define UNWAV 2
#define WCAT 3
#if defined(__STDC__) || defined(__GNUC__) || defined(sgi)
#define PROTO(ARGS) ARGS
#else
#define PROTO(ARGS) ()
#endif
void wavpack_set_monoflg PROTO((int val));
int wavpack_get_monoflg PROTO((void));
void wavpack_set_byteflg PROTO((int val));
int wavpack_get_byteflg PROTO((void));
int wavpack_set_vflg PROTO((int value));
int wavpack_set_oname PROTO((char *s));
void wavpack_set_oflg PROTO((int value));
int wavpack_set_progname PROTO((char *s));
int wavpack_free_progname PROTO((void));
void wavpack_dump_interface PROTO((FILE *fp));
int wavpack_pack PROTO((FOB *ifile, FOB *ofile));
int wavpack_unpack PROTO((FOB *ifile, FOB *ofile));
#endif
| 29.6 | 58 | 0.715372 |
516569270bacde390fbfdeecb1140ff7b1ab315d | 26,244 | h | C | source/kernel/drivers/gpu/drm/nouveau/nvkm/subdev/pmu/fuc/gt215.fuc3.h | mikedlowis-prototypes/albase | e441be370dce14b4c9210510d7e7a9b69c5eef20 | [
"BSD-2-Clause"
] | null | null | null | source/kernel/drivers/gpu/drm/nouveau/nvkm/subdev/pmu/fuc/gt215.fuc3.h | mikedlowis-prototypes/albase | e441be370dce14b4c9210510d7e7a9b69c5eef20 | [
"BSD-2-Clause"
] | null | null | null | source/kernel/drivers/gpu/drm/nouveau/nvkm/subdev/pmu/fuc/gt215.fuc3.h | mikedlowis-prototypes/albase | e441be370dce14b4c9210510d7e7a9b69c5eef20 | [
"BSD-2-Clause"
] | null | null | null | uint32_t gt215_pmu_data[] = {
/* 0x0000: proc_kern */
0x52544e49,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
/* 0x0058: proc_list_head */
0x54534f48,
0x00000507,
0x000004a4,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x584d454d,
0x00000837,
0x00000829,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x46524550,
0x0000083b,
0x00000839,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x5f433249,
0x00000c6b,
0x00000b0e,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x54534554,
0x00000c94,
0x00000c6d,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x454c4449,
0x00000ca0,
0x00000c9e,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
/* 0x0268: proc_list_tail */
/* 0x0268: time_prev */
0x00000000,
/* 0x026c: time_next */
0x00000000,
/* 0x0270: fifo_queue */
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
/* 0x02f0: rfifo_queue */
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
/* 0x0370: memx_func_head */
0x00000001,
0x00000000,
0x00000546,
/* 0x037c: memx_func_next */
0x00000002,
0x00000000,
0x0000059d,
0x00000003,
0x00000002,
0x0000062f,
0x00040004,
0x00000000,
0x0000064b,
0x00010005,
0x00000000,
0x00000668,
0x00010006,
0x00000000,
0x000005ed,
0x00000007,
0x00000000,
0x00000673,
/* 0x03c4: memx_func_tail */
/* 0x03c4: memx_ts_start */
0x00000000,
/* 0x03c8: memx_ts_end */
0x00000000,
/* 0x03cc: memx_data_head */
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
/* 0x0bcc: memx_data_tail */
/* 0x0bcc: memx_train_head */
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
/* 0x0ccc: memx_train_tail */
/* 0x0ccc: i2c_scl_map */
0x00001000,
0x00004000,
0x00010000,
0x00000100,
0x00040000,
0x00100000,
0x00400000,
0x01000000,
0x04000000,
0x10000000,
/* 0x0cf4: i2c_sda_map */
0x00002000,
0x00008000,
0x00020000,
0x00000200,
0x00080000,
0x00200000,
0x00800000,
0x02000000,
0x08000000,
0x20000000,
/* 0x0d1c: i2c_ctrl */
0x0000e138,
0x0000e150,
0x0000e168,
0x0000e180,
0x0000e254,
0x0000e274,
0x0000e764,
0x0000e780,
0x0000e79c,
0x0000e7b8,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
};
uint32_t gt215_pmu_code[] = {
0x03930ef5,
/* 0x0004: rd32 */
0x07a007f1,
0xd00604b6,
0x04bd000e,
0xf001d7f0,
0x07f101d3,
0x04b607ac,
0x000dd006,
/* 0x0022: rd32_wait */
0xd7f104bd,
0xd4b607ac,
0x00ddcf06,
0x7000d4f1,
0xf1f21bf4,
0xb607a4d7,
0xddcf06d4,
/* 0x003f: wr32 */
0xf100f800,
0xb607a007,
0x0ed00604,
0xf104bd00,
0xb607a407,
0x0dd00604,
0xf004bd00,
0xd5f002d7,
0x01d3f0f0,
0x07ac07f1,
0xd00604b6,
0x04bd000d,
/* 0x006c: wr32_wait */
0x07acd7f1,
0xcf06d4b6,
0xd4f100dd,
0x1bf47000,
/* 0x007f: nsec */
0xf900f8f2,
0xf080f990,
0x84b62c87,
0x0088cf06,
/* 0x008c: nsec_loop */
0xb62c97f0,
0x99cf0694,
0x0298bb00,
0xf4069eb8,
0x80fcf11e,
0x00f890fc,
/* 0x00a4: wait */
0x80f990f9,
0xb62c87f0,
0x88cf0684,
/* 0x00b1: wait_loop */
0x02eeb900,
0xb90421f4,
0xadfd02da,
0x06acb804,
0xf0150bf4,
0x94b62c97,
0x0099cf06,
0xb80298bb,
0x1ef4069b,
/* 0x00d5: wait_done */
0xfc80fcdf,
/* 0x00db: intr_watchdog */
0x9800f890,
0x96b003e9,
0x2a0bf400,
0xbb9a0a98,
0x1cf4029a,
0x01d7f00f,
0x02d221f5,
0x0ef494bd,
/* 0x00f9: intr_watchdog_next_time */
0x9b0a9815,
0xf400a6b0,
0x9ab8090b,
0x061cf406,
/* 0x0108: intr_watchdog_next_time_set */
/* 0x010b: intr_watchdog_next_proc */
0x809b0980,
0xe0b603e9,
0x68e6b158,
0xc61bf402,
/* 0x011a: intr */
0x00f900f8,
0x80f904bd,
0xa0f990f9,
0xc0f9b0f9,
0xe0f9d0f9,
0xf7f0f0f9,
0x0188fe00,
0x87f180f9,
0x84b605d0,
0x0088cf06,
0xf10180b6,
0xb605d007,
0x08d00604,
0xf004bd00,
0x84b60887,
0x0088cf06,
0xf40289c4,
0x0080230b,
0x58e7f09b,
0x98db21f4,
0x96b09b09,
0x110bf400,
0xb63407f0,
0x09d00604,
0x8004bd00,
/* 0x017e: intr_skip_watchdog */
0x89e49a09,
0x0bf40800,
0x8897f148,
0x0694b606,
0xc40099cf,
0x0bf4029a,
0xc0c7f12c,
0x06c4b604,
0xf900cccf,
0x48e7f1c0,
0x53e3f14f,
0x00d7f054,
0x033721f5,
0x07f1c0fc,
0x04b604c0,
0x000cd006,
/* 0x01be: intr_subintr_skip_fifo */
0x07f104bd,
0x04b60688,
0x0009d006,
/* 0x01ca: intr_skip_subintr */
0x97f104bd,
0x90bd00e0,
0xf00489fd,
0x04b60407,
0x0008d006,
0x80fc04bd,
0xfc0088fe,
0xfce0fcf0,
0xfcc0fcd0,
0xfca0fcb0,
0xfc80fc90,
0x0032f400,
/* 0x01fa: ticks_from_ns */
0xc0f901f8,
0xd7f1b0f9,
0xd3f000cb,
0x0821f500,
0xe8ccec04,
0x00b4b003,
0xec120bf4,
0xf103e8ee,
0xf000cbd7,
0x21f500d3,
/* 0x0222: ticks_from_ns_quit */
0xceb90408,
0xfcb0fc02,
/* 0x022b: ticks_from_us */
0xf900f8c0,
0xf1b0f9c0,
0xf000cbd7,
0x21f500d3,
0xceb90408,
0x00b4b002,
0xbd050bf4,
/* 0x0245: ticks_from_us_quit */
0xfcb0fce4,
/* 0x024b: ticks_to_us */
0xf100f8c0,
0xf000cbd7,
0xedff00d3,
/* 0x0257: timer */
0xf900f8ec,
0xf480f990,
0xf8981032,
0x0086b003,
0xbd651cf4,
0x3807f084,
0xd00604b6,
0x04bd0008,
0xb63487f0,
0x88cf0684,
0x9a099800,
0xbb0298bb,
0xfe8000e9,
0x0887f003,
0xcf0684b6,
0x84f00088,
0x261bf402,
0xb63487f0,
0x88cf0684,
0x06e0b800,
0xb8090bf4,
0x1cf406e8,
/* 0x02ad: timer_reset */
0x3407f011,
0xd00604b6,
0x04bd000e,
/* 0x02bb: timer_enable */
0xf09a0e80,
0x07f00187,
0x0604b638,
0xbd0008d0,
/* 0x02c9: timer_done */
0x1031f404,
0x90fc80fc,
/* 0x02d2: send_proc */
0x80f900f8,
0xe89890f9,
0x04e99805,
0xb80486f0,
0x0bf40689,
0x0398c42a,
0xb6048894,
0x8ebb1880,
0x00fa9800,
0x80008a80,
0x8c80018d,
0x038b8002,
0xf00190b6,
0xe9800794,
0x0231f404,
/* 0x030c: send_done */
0x80fc90fc,
/* 0x0312: find */
0x80f900f8,
0xf45887f0,
/* 0x031a: find_loop */
0x8a980131,
0x06aeb800,
0xb6100bf4,
0x86b15880,
0x1bf40268,
0x0132f4f0,
/* 0x0330: find_done */
0xfc028eb9,
/* 0x0337: send */
0xf500f880,
0xf4031221,
0x00f89701,
/* 0x0340: recv */
0x80f990f9,
0x9805e898,
0x32f404e9,
0x0689b801,
0xc43d0bf4,
0x80b60389,
0x0784f001,
0x9805e880,
0xf0f902ea,
0xf9018ffe,
0x02efb9f0,
0xbb049994,
0xe0b600e9,
0x03eb9818,
0x9802ec98,
0xee9801ed,
0xfca5f900,
0x00f8fef0,
0xfc0131f4,
/* 0x038d: recv_done */
0xfc80fcf0,
/* 0x0393: init */
0xf100f890,
0xb6010817,
0x11cf0614,
0x0911e700,
0x0814b601,
0xf10014fe,
0xf000e017,
0x07f00013,
0x0604b61c,
0xbd0001d0,
0xff17f004,
0xb61407f0,
0x01d00604,
0xf004bd00,
0x15f10217,
0x07f00800,
0x0604b610,
0xbd0001d0,
0x1a17f104,
0x0013f001,
0xf40010fe,
0x17f01031,
0x3807f001,
0xd00604b6,
0x04bd0001,
/* 0x03f7: init_proc */
0x9858f7f0,
0x16b001f1,
0xfa0bf400,
0xf0b615f9,
0xf20ef458,
/* 0x0408: mulu32_32_64 */
0x20f910f9,
0x40f930f9,
0x9510e195,
0xc4bd10d2,
0xedffb4bd,
0x301dffc0,
0xf10234b9,
0xb6ffff34,
0x45b61034,
0x00c3bb10,
0xff01b4bb,
0x34b930e2,
0xff34f102,
0x1034b6ff,
0xbb1045b6,
0xb4bb00c3,
0x3012ff01,
0xfc00b3bb,
0xfc30fc40,
0xf810fc20,
/* 0x0459: host_send */
0xb017f100,
0x0614b604,
0xf10011cf,
0xb604a027,
0x22cf0624,
0x0612b800,
0xc4320bf4,
0xee94071e,
0x70e0b704,
0x03eb9802,
0x9802ec98,
0xee9801ed,
0x3721f500,
0x0110b603,
0xf10f1ec4,
0xb604b007,
0x0ed00604,
0xf404bd00,
/* 0x04a2: host_send_done */
0x00f8ba0e,
/* 0x04a4: host_recv */
0x4e4917f1,
0x525413f1,
0xf406e1b8,
/* 0x04b2: host_recv_wait */
0x17f1aa0b,
0x14b604cc,
0x0011cf06,
0x04c827f1,
0xcf0624b6,
0x16f00022,
0x0612b808,
0xc4e60bf4,
0x34b60723,
0xf030b704,
0x033b8002,
0x80023c80,
0x3e80013d,
0x0120b600,
0xf10f24f0,
0xb604c807,
0x02d00604,
0xf004bd00,
0x07f04027,
0x0604b600,
0xbd0002d0,
/* 0x0507: host_init */
0xf100f804,
0xb6008017,
0x15f11014,
0x07f10270,
0x04b604d0,
0x0001d006,
0x17f104bd,
0x14b60080,
0xf015f110,
0xdc07f102,
0x0604b604,
0xbd0001d0,
0x0117f004,
0x04c407f1,
0xd00604b6,
0x04bd0001,
/* 0x0546: memx_func_enter */
0x87f100f8,
0x8eb91610,
0x0421f402,
0xf102d7b9,
0xf1fffc67,
0xfdffff63,
0x67f10476,
0x76fd0002,
0xf980f905,
0xfcd0fc70,
0x3f21f4e0,
0xf10467f0,
0xb607e007,
0x06d00604,
/* 0x057f: memx_func_enter_wait */
0xf104bd00,
0xb607c067,
0x66cf0664,
0x0464f000,
0xf0f30bf4,
0x64b62c67,
0x0066cf06,
0xf8f10680,
/* 0x059d: memx_func_leave */
0x2c67f000,
0xcf0664b6,
0x06800066,
0x0467f0f2,
0x07e407f1,
0xd00604b6,
0x04bd0006,
/* 0x05b8: memx_func_leave_wait */
0x07c067f1,
0xcf0664b6,
0x64f00066,
0xf31bf404,
0x161087f1,
0xf4028eb9,
0xd7b90421,
0xcc67f102,
0xff63f1ff,
0x0476fdff,
0x70f980f9,
0xe0fcd0fc,
0xf83f21f4,
/* 0x05ed: memx_func_wait_vblank */
0x00169800,
0xf40066b0,
0x66b0130b,
0x060bf401,
/* 0x05ff: memx_func_wait_vblank_head1 */
0xf12e0ef4,
0xf4002077,
/* 0x0606: memx_func_wait_vblank_head0 */
0x77f1070e,
/* 0x060a: memx_func_wait_vblank_0 */
0x67f10008,
0x64b607c4,
0x0066cf06,
0xf40467fd,
/* 0x061a: memx_func_wait_vblank_1 */
0x67f1f31b,
0x64b607c4,
0x0066cf06,
0xf40467fd,
/* 0x062a: memx_func_wait_vblank_fini */
0x10b6f30b,
/* 0x062f: memx_func_wr32 */
0x9800f804,
0x15980016,
0x0810b601,
0x50f960f9,
0xe0fcd0fc,
0xb63f21f4,
0x1bf40242,
/* 0x064b: memx_func_wait */
0xf000f8e9,
0x84b62c87,
0x0088cf06,
0x98001e98,
0x1c98011d,
0x031b9802,
0xf41010b6,
0x00f8a421,
/* 0x0668: memx_func_delay */
0xb6001e98,
0x21f40410,
/* 0x0673: memx_func_train */
0xf100f87f,
0xf1000357,
0xf1000077,
0xf0000097,
0x9eb97093,
0x0421f402,
0xf102d8b9,
0xf42710e7,
/* 0x0692: memx_func_train_loop_outer */
0x58e07f21,
0x83f10101,
0x97f10200,
0x93f011e0,
0xf990f911,
0xfcd0fc80,
0x3f21f4e0,
0x67f150f9,
/* 0x06b2: memx_func_train_loop_inner */
0x87f10000,
0x68ff1111,
0x10989490,
0xf10589fd,
0xf0072097,
0x90f91093,
0xd0fc80f9,
0x21f4e0fc,
0x8097f13f,
0x1093f000,
0xf4029eb9,
0xd8b90421,
0x2088c502,
0x80f990f9,
0xe0fcd0fc,
0xf13f21f4,
0xf0053c97,
0x87f11093,
0x83f13002,
0x90f98000,
0xd0fc80f9,
0x21f4e0fc,
0x60e7f13f,
0x10e3f005,
0x0000d7f1,
0x8000d3f1,
0xf100dc90,
0xf08480b7,
0x21f41eb3,
0x0057f1a4,
0xff97f100,
0x0093f1ff,
/* 0x0731: memx_func_train_loop_4x */
0x80a7f183,
0x10a3f000,
0xf402aeb9,
0xd8b90421,
0xdfb7f102,
0xffb3f1ff,
0x048bfdff,
0x80f9a0f9,
0xe0fcd0fc,
0xf13f21f4,
0xf0053ca7,
0x87f110a3,
0x83f13002,
0xa0f98000,
0xd0fc80f9,
0x21f4e0fc,
0x60e7f13f,
0x10e3f005,
0x0000d7f1,
0x8000d3f1,
0xf102dcb9,
0xf02710b7,
0x21f400b3,
0x02eeb9a4,
0xb90421f4,
0x9dff02dd,
0x0150b694,
0xf4045670,
0x7aa0921e,
0xa9800bcc,
0x0160b600,
0x700470b6,
0x1ef51066,
0x50fcff00,
0x700150b6,
0x1ef50756,
0x00f8fed4,
/* 0x07c4: memx_exec */
0xd0f9e0f9,
0xb902c1b9,
/* 0x07ce: memx_exec_next */
0x139802b2,
0x0410b600,
0x01f034e7,
0x01e033e7,
0xf00132b6,
0x35980c30,
0xb855f9de,
0x1ef40612,
0xf10b98e4,
0xbbf20c98,
0xb7f102cb,
0xb4b607c4,
0x00bbcf06,
0xe0fcd0fc,
0x033721f5,
/* 0x080a: memx_info */
0xc67000f8,
0x0e0bf401,
/* 0x0810: memx_info_data */
0x03ccc7f1,
0x0800b7f1,
/* 0x081b: memx_info_train */
0xf10b0ef4,
0xf10bccc7,
/* 0x0823: memx_info_send */
0xf50100b7,
0xf8033721,
/* 0x0829: memx_recv */
0x01d6b000,
0xb0980bf4,
0x0bf400d6,
/* 0x0837: memx_init */
0xf800f8d8,
/* 0x0839: perf_recv */
/* 0x083b: perf_init */
0xf800f800,
/* 0x083d: i2c_drive_scl */
0x0036b000,
0xf1110bf4,
0xb607e007,
0x01d00604,
0xf804bd00,
/* 0x0851: i2c_drive_scl_lo */
0xe407f100,
0x0604b607,
0xbd0001d0,
/* 0x085f: i2c_drive_sda */
0xb000f804,
0x0bf40036,
0xe007f111,
0x0604b607,
0xbd0002d0,
/* 0x0873: i2c_drive_sda_lo */
0xf100f804,
0xb607e407,
0x02d00604,
0xf804bd00,
/* 0x0881: i2c_sense_scl */
0x0132f400,
0x07c437f1,
0xcf0634b6,
0x31fd0033,
0x060bf404,
/* 0x0897: i2c_sense_scl_done */
0xf80131f4,
/* 0x0899: i2c_sense_sda */
0x0132f400,
0x07c437f1,
0xcf0634b6,
0x32fd0033,
0x060bf404,
/* 0x08af: i2c_sense_sda_done */
0xf80131f4,
/* 0x08b1: i2c_raise_scl */
0xf140f900,
0xf0089847,
0x21f50137,
/* 0x08be: i2c_raise_scl_wait */
0xe7f1083d,
0x21f403e8,
0x8121f57f,
0x0901f408,
0xf40142b6,
/* 0x08d2: i2c_raise_scl_done */
0x40fcef1b,
/* 0x08d6: i2c_start */
0x21f500f8,
0x11f40881,
0x9921f50d,
0x0611f408,
/* 0x08e7: i2c_start_rep */
0xf0300ef4,
0x21f50037,
0x37f0083d,
0x5f21f501,
0x0076bb08,
0xf90465b6,
0x04659450,
0xbd0256bb,
0x0475fd50,
0x21f550fc,
0x64b608b1,
0x1f11f404,
/* 0x0914: i2c_start_send */
0xf50037f0,
0xf1085f21,
0xf41388e7,
0x37f07f21,
0x3d21f500,
0x88e7f108,
0x7f21f413,
/* 0x0930: i2c_start_out */
/* 0x0932: i2c_stop */
0x37f000f8,
0x3d21f500,
0x0037f008,
0x085f21f5,
0x03e8e7f1,
0xf07f21f4,
0x21f50137,
0xe7f1083d,
0x21f41388,
0x0137f07f,
0x085f21f5,
0x1388e7f1,
0xf87f21f4,
/* 0x0965: i2c_bitw */
0x5f21f500,
0xe8e7f108,
0x7f21f403,
0xb60076bb,
0x50f90465,
0xbb046594,
0x50bd0256,
0xfc0475fd,
0xb121f550,
0x0464b608,
0xf11811f4,
0xf41388e7,
0x37f07f21,
0x3d21f500,
0x88e7f108,
0x7f21f413,
/* 0x09a4: i2c_bitw_out */
/* 0x09a6: i2c_bitr */
0x37f000f8,
0x5f21f501,
0xe8e7f108,
0x7f21f403,
0xb60076bb,
0x50f90465,
0xbb046594,
0x50bd0256,
0xfc0475fd,
0xb121f550,
0x0464b608,
0xf51b11f4,
0xf0089921,
0x21f50037,
0xe7f1083d,
0x21f41388,
0x013cf07f,
/* 0x09eb: i2c_bitr_done */
0xf80131f4,
/* 0x09ed: i2c_get_byte */
0x0057f000,
/* 0x09f3: i2c_get_byte_next */
0xb60847f0,
0x76bb0154,
0x0465b600,
0x659450f9,
0x0256bb04,
0x75fd50bd,
0xf550fc04,
0xb609a621,
0x11f40464,
0x0553fd2b,
0xf40142b6,
0x37f0d81b,
0x0076bb01,
0xf90465b6,
0x04659450,
0xbd0256bb,
0x0475fd50,
0x21f550fc,
0x64b60965,
/* 0x0a3d: i2c_get_byte_done */
/* 0x0a3f: i2c_put_byte */
0xf000f804,
/* 0x0a42: i2c_put_byte_next */
0x42b60847,
0x3854ff01,
0xb60076bb,
0x50f90465,
0xbb046594,
0x50bd0256,
0xfc0475fd,
0x6521f550,
0x0464b609,
0xb03411f4,
0x1bf40046,
0x0076bbd8,
0xf90465b6,
0x04659450,
0xbd0256bb,
0x0475fd50,
0x21f550fc,
0x64b609a6,
0x0f11f404,
0xb00076bb,
0x1bf40136,
0x0132f406,
/* 0x0a98: i2c_put_byte_done */
/* 0x0a9a: i2c_addr */
0x76bb00f8,
0x0465b600,
0x659450f9,
0x0256bb04,
0x75fd50bd,
0xf550fc04,
0xb608d621,
0x11f40464,
0x2ec3e729,
0x0134b601,
0xbb0553fd,
0x65b60076,
0x9450f904,
0x56bb0465,
0xfd50bd02,
0x50fc0475,
0x0a3f21f5,
/* 0x0adf: i2c_addr_done */
0xf80464b6,
/* 0x0ae1: i2c_acquire_addr */
0xf8cec700,
0xb702e4b6,
0x980d1ce0,
0x00f800ee,
/* 0x0af0: i2c_acquire */
0x0ae121f5,
0xf00421f4,
0x21f403d9,
/* 0x0aff: i2c_release */
0xf500f83f,
0xf40ae121,
0xdaf00421,
0x3f21f403,
/* 0x0b0e: i2c_recv */
0x32f400f8,
0xf8c1c701,
0xb00214b6,
0x1ff52816,
0x13a0013a,
0x32980cf4,
0xcc13a000,
0x0031980c,
0xf90231f4,
0xf9e0f9d0,
0x0067f1d0,
0x0063f100,
0x01679210,
0xb60076bb,
0x50f90465,
0xbb046594,
0x50bd0256,
0xfc0475fd,
0xf021f550,
0x0464b60a,
0xd6b0d0fc,
0xb31bf500,
0x0057f000,
0xb60076bb,
0x50f90465,
0xbb046594,
0x50bd0256,
0xfc0475fd,
0x9a21f550,
0x0464b60a,
0x00d011f5,
0xbbe0c5c7,
0x65b60076,
0x9450f904,
0x56bb0465,
0xfd50bd02,
0x50fc0475,
0x0a3f21f5,
0xf50464b6,
0xf000ad11,
0x76bb0157,
0x0465b600,
0x659450f9,
0x0256bb04,
0x75fd50bd,
0xf550fc04,
0xb60a9a21,
0x11f50464,
0x76bb008a,
0x0465b600,
0x659450f9,
0x0256bb04,
0x75fd50bd,
0xf550fc04,
0xb609ed21,
0x11f40464,
0xe05bcb6a,
0xb60076bb,
0x50f90465,
0xbb046594,
0x50bd0256,
0xfc0475fd,
0x3221f550,
0x0464b609,
0xbd025bb9,
0x430ef474,
/* 0x0c14: i2c_recv_not_rd08 */
0xf401d6b0,
0x57f03d1b,
0x9a21f500,
0x3311f40a,
0xf5e0c5c7,
0xf40a3f21,
0x57f02911,
0x9a21f500,
0x1f11f40a,
0xf5e0b5c7,
0xf40a3f21,
0x21f51511,
0x74bd0932,
0xf408c5c7,
0x32f4091b,
0x030ef402,
/* 0x0c54: i2c_recv_not_wr08 */
/* 0x0c54: i2c_recv_done */
0xf5f8cec7,
0xfc0aff21,
0xf4d0fce0,
0x7cb90a12,
0x3721f502,
/* 0x0c69: i2c_recv_exit */
/* 0x0c6b: i2c_init */
0xf800f803,
/* 0x0c6d: test_recv */
0xd817f100,
0x0614b605,
0xb60011cf,
0x07f10110,
0x04b605d8,
0x0001d006,
0xe7f104bd,
0xe3f1d900,
0x21f5134f,
0x00f80257,
/* 0x0c94: test_init */
0x0800e7f1,
0x025721f5,
/* 0x0c9e: idle_recv */
0x00f800f8,
/* 0x0ca0: idle */
0xf10031f4,
0xb605d417,
0x11cf0614,
0x0110b600,
0x05d407f1,
0xd00604b6,
0x04bd0001,
/* 0x0cbc: idle_loop */
0xf45817f0,
/* 0x0cc2: idle_proc */
/* 0x0cc2: idle_proc_exec */
0x10f90232,
0xf5021eb9,
0xfc034021,
0x0911f410,
0xf40231f4,
/* 0x0cd6: idle_proc_next */
0x10b6ef0e,
0x061fb858,
0xf4e61bf4,
0x28f4dd02,
0xbb0ef400,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
};
| 14.056776 | 41 | 0.755982 |
393e535300ec7a4dc7f39302f2c15dda7166f453 | 258 | h | C | controlpanel/controlpanel_global.h | vduseev/browspot | 0b3c2a83c76310e3b2f0edc6ab1e91167687ae7d | [
"MIT"
] | null | null | null | controlpanel/controlpanel_global.h | vduseev/browspot | 0b3c2a83c76310e3b2f0edc6ab1e91167687ae7d | [
"MIT"
] | null | null | null | controlpanel/controlpanel_global.h | vduseev/browspot | 0b3c2a83c76310e3b2f0edc6ab1e91167687ae7d | [
"MIT"
] | null | null | null | #ifndef CONTROLPANEL_GLOBAL_H
#define CONTROLPANEL_GLOBAL_H
#include <QtCore/qglobal.h>
#ifdef CONTROLPANEL_LIB
# define CONTROLPANEL_EXPORT Q_DECL_EXPORT
#else
# define CONTROLPANEL_EXPORT Q_DECL_IMPORT
#endif
#endif // CONTROLPANEL_GLOBAL_H
| 19.846154 | 43 | 0.802326 |
d776a69213489958cf82c56c5292e53d28a56512 | 5,148 | h | C | tests/attestation/common/host_verify/private/oe_header.h | harshanavkis/sgx-lkl | 539b65af777fb832031fa98a098d32575fac88f0 | [
"MIT"
] | 244 | 2018-01-08T19:11:43.000Z | 2022-03-24T06:11:32.000Z | tests/attestation/common/host_verify/private/oe_header.h | harshanavkis/sgx-lkl | 539b65af777fb832031fa98a098d32575fac88f0 | [
"MIT"
] | 614 | 2018-04-16T05:30:20.000Z | 2021-04-23T12:58:56.000Z | tests/attestation/common/host_verify/private/oe_header.h | harshanavkis/sgx-lkl | 539b65af777fb832031fa98a098d32575fac88f0 | [
"MIT"
] | 95 | 2018-02-05T03:41:50.000Z | 2022-01-06T23:09:49.000Z | #ifndef OE_HEADER_H
#define OE_HEADER_H
#include "oe_defs.h"
#define oe_memcpy_s(a,b,c,d) (memcpy((a),(c),(d)) ? OE_OK : OE_FAILURE)
/* Atomically increment **x** and return its new value */
OE_INLINE uint64_t oe_atomic_increment(volatile uint64_t* x)
{
#if defined(__GNUC__)
return __sync_add_and_fetch(x, 1);
#elif defined(_MSC_VER)
return _InterlockedIncrement64((__int64*)x);
#else
#error "unsupported"
#endif
}
/* Atomically decrement **x** and return its new value */
OE_INLINE uint64_t oe_atomic_decrement(volatile uint64_t* x)
{
#if defined(__GNUC__)
return __sync_sub_and_fetch(x, 1);
#elif defined(_MSC_VER)
return _InterlockedDecrement64((__int64*)x);
#else
#error "unsupported"
#endif
}
#define OE_CRL_MAGIC 0xf8cf8e04f4ed40f3
bool crl_is_valid(const crl_t* impl)
{
return impl && (impl->magic == OE_CRL_MAGIC) && impl->crl;
}
OE_INLINE void oe_secure_zero_fill(volatile void* ptr, size_t size)
{
volatile uint8_t* p = (volatile uint8_t*)ptr;
while (size--)
{
*p++ = 0;
}
}
OE_INLINE bool oe_is_rsa_key(const mbedtls_pk_context* pk)
{
return (pk->pk_info == mbedtls_pk_info_from_type(MBEDTLS_PK_RSA));
}
bool oe_public_key_is_valid(const oe_public_key_t* public_key, uint64_t magic)
{
return public_key && public_key->magic == magic;
}
oe_result_t oe_public_key_write_pem(
const oe_public_key_t* public_key,
uint8_t* pem_data,
size_t* pem_size,
uint64_t magic);
oe_result_t oe_ec_public_key_write_pem(
const oe_ec_public_key_t* private_key,
uint8_t* pem_data,
size_t* pem_size)
{
return oe_public_key_write_pem(
(const oe_public_key_t*)private_key,
pem_data,
pem_size,
_PUBLIC_KEY_MAGIC);
}
void oe_public_key_release(oe_public_key_t* public_key, uint64_t magic)
{
if (oe_public_key_is_valid(public_key, magic))
{
mbedtls_pk_free(&public_key->pk);
oe_secure_zero_fill(public_key, sizeof(oe_public_key_t));
}
}
oe_result_t oe_public_key_free(oe_public_key_t* public_key, uint64_t magic);
oe_result_t oe_ec_public_key_free(oe_ec_public_key_t* public_key)
{
return oe_public_key_free((oe_public_key_t*)public_key, _PUBLIC_KEY_MAGIC);
}
oe_result_t oe_rsa_public_key_free(oe_rsa_public_key_t* public_key)
{
return oe_public_key_free((oe_public_key_t*)public_key, _PUBLIC_KEY_MAGIC);
}
oe_result_t oe_public_key_init(
oe_public_key_t* public_key,
const mbedtls_pk_context* pk,
oe_copy_key copy_key,
uint64_t magic)
{
oe_result_t result = OE_UNEXPECTED;
if (!public_key || (pk && !copy_key) || (copy_key && !pk))
OE_RAISE(OE_INVALID_PARAMETER);
public_key->magic = 0;
if (pk && copy_key)
OE_CHECK(copy_key(&public_key->pk, pk, false));
else
mbedtls_pk_init(&public_key->pk);
public_key->magic = magic;
result = OE_OK;
done:
return result;
}
static oe_result_t _copy_key(
mbedtls_pk_context* dest,
const mbedtls_pk_context* src,
bool copy_private_fields)
{
oe_result_t result = OE_UNEXPECTED;
const mbedtls_pk_info_t* info;
int rc = 0;
if (dest)
mbedtls_pk_init(dest);
/* Check parameters */
if (!dest || !src)
OE_RAISE(OE_INVALID_PARAMETER);
/* Lookup the info for this key type */
if (!(info = mbedtls_pk_info_from_type(MBEDTLS_PK_ECKEY)))
OE_RAISE(OE_PUBLIC_KEY_NOT_FOUND);
/* Setup the context for this key type */
rc = mbedtls_pk_setup(dest, info);
if (rc != 0)
OE_RAISE_MSG(OE_CRYPTO_ERROR, "rc = 0x%x", rc);
/* Copy all fields of the key structure */
{
mbedtls_ecp_keypair* ec_dest = mbedtls_pk_ec(*dest);
const mbedtls_ecp_keypair* ec_src = mbedtls_pk_ec(*src);
if (!ec_dest || !ec_src)
OE_RAISE(OE_FAILURE);
if (mbedtls_ecp_group_copy(&ec_dest->grp, &ec_src->grp) != 0)
OE_RAISE(OE_CRYPTO_ERROR);
if (copy_private_fields)
{
if (mbedtls_mpi_copy(&ec_dest->d, &ec_src->d) != 0)
OE_RAISE(OE_CRYPTO_ERROR);
}
if (mbedtls_ecp_copy(&ec_dest->Q, &ec_src->Q) != 0)
OE_RAISE(OE_CRYPTO_ERROR);
}
result = OE_OK;
done:
if (result != OE_OK)
mbedtls_pk_free(dest);
return result;
}
oe_result_t oe_rsa_public_key_init(
oe_rsa_public_key_t* public_key,
const mbedtls_pk_context* pk)
{
return oe_public_key_init(
(oe_public_key_t*)public_key, pk, _copy_key, _PUBLIC_KEY_MAGIC);
}
OE_INLINE bool oe_is_ec_key(const mbedtls_pk_context* pk)
{
return (pk->pk_info == mbedtls_pk_info_from_type(MBEDTLS_PK_ECKEY));
}
oe_result_t oe_rsa_public_key_write_pem(
const oe_rsa_public_key_t* private_key,
uint8_t* pem_data,
size_t* pem_size)
{
return oe_public_key_write_pem(
(const oe_public_key_t*)private_key,
pem_data,
pem_size,
_PUBLIC_KEY_MAGIC);
}
oe_result_t oe_ec_public_key_init(
oe_ec_public_key_t* public_key,
const mbedtls_pk_context* pk)
{
return oe_public_key_init(
(oe_public_key_t*)public_key, pk, _copy_key, _PUBLIC_KEY_MAGIC);
}
#endif
| 24.283019 | 79 | 0.693279 |
baa919feb1f0847669efc2d0c1da93725eb92a72 | 1,482 | h | C | native/juce/Source/HostFileManager.h | philburk/hmsl | 6decc8c4022b590b6c41b081de231dba7907b1b6 | [
"Apache-2.0"
] | 76 | 2015-01-19T19:09:32.000Z | 2022-02-08T23:37:28.000Z | native/juce/Source/HostFileManager.h | philburk/hmsl | 6decc8c4022b590b6c41b081de231dba7907b1b6 | [
"Apache-2.0"
] | 81 | 2015-02-20T17:09:12.000Z | 2022-03-13T17:59:12.000Z | native/juce/Source/HostFileManager.h | philburk/hmsl | 6decc8c4022b590b6c41b081de231dba7907b1b6 | [
"Apache-2.0"
] | 9 | 2015-01-27T23:11:15.000Z | 2021-06-22T20:06:02.000Z | /*
==============================================================================
HostFileManager.h
Created: 26 May 2019 4:03:53pm
Author: Phil Burk
==============================================================================
*/
#pragma once
#include <memory>
#include "stdio.h"
class HostFileManager {
public:
static HostFileManager *getInstance() {
if (mInstance == nullptr) {
mInstance.reset(new HostFileManager());
}
return mInstance.get();
}
HostFileManager();
/**
* Set default directory for relative file paths.
*/
void setCurrentDirectory(const File &dir);
/**
* @return default directory for relative file paths.
*/
File getCurrentDirectory();
/**
* @return directory that contains the PForth "fth" files.
*/
File getPForthDirectory();
/**
* @return directory that contains HMSL source and the "fth/" folder.
*/
File getHmslDirectory();
/**
* @return path to file for compiling pForth
*/
const char *getSystemFileName();
/**
* @return current dictionary file, typically "{path}/pforth.dic".
*/
const char *getDictionaryFileName();
FILE *openFile( const char *fileName, const char *mode );
private:
static std::unique_ptr<HostFileManager> mInstance;
std::unique_ptr<File> mCurrentDirectory;
File mAppDir;
File mHMSLDir;
};
| 22.454545 | 80 | 0.536437 |
bfbb73cfb773baa533fd05c7c27cc4158be76278 | 720 | h | C | Pessoa/Pessoa/include/Pessoa.h | JLRocha-UFPB/Atividades-LP1 | 29c775859e29b3584b041ecdc1f193a0c0b96223 | [
"Apache-2.0"
] | null | null | null | Pessoa/Pessoa/include/Pessoa.h | JLRocha-UFPB/Atividades-LP1 | 29c775859e29b3584b041ecdc1f193a0c0b96223 | [
"Apache-2.0"
] | null | null | null | Pessoa/Pessoa/include/Pessoa.h | JLRocha-UFPB/Atividades-LP1 | 29c775859e29b3584b041ecdc1f193a0c0b96223 | [
"Apache-2.0"
] | null | null | null | #ifndef PESSOA_H
#define PESSOA_H
#include <iostream>
using namespace std;
class Pessoa
{
public:
Pessoa(string nome1); //Construtor que recebe apenas Nome
Pessoa(string nome = "JOAO",string telefone = "135487645",int idade = 19); //Construtor que recebe nome,telefone e idade
//Metodos --Get-- --Set-- para obter e setar valores para os atributos da classe;
string getNome();
string getTelefone();
int getIdade();
void setNome(string nome);
void setTelefone(string telefone);
void setIdade(int idade);
private:
//Atributos da Classe;
string nome;
string telefone;
int idade;
};
#endif // PESSOA_H
| 21.176471 | 128 | 0.626389 |
b58e2492ac6fa5f7e80435ec3c668bab2cb47b10 | 1,590 | h | C | examples/TestCrowd1/src/visualisation/GLUTInputController.h | Tumurtogtokh/FLAMEGPU | 466a2ddc34091b034bbfb968b2a3561c90b969f7 | [
"MIT"
] | 54 | 2015-03-11T14:13:07.000Z | 2022-02-10T17:16:16.000Z | examples/TestCrowd1/src/visualisation/GLUTInputController.h | Tumurtogtokh/FLAMEGPU | 466a2ddc34091b034bbfb968b2a3561c90b969f7 | [
"MIT"
] | 206 | 2015-06-01T16:11:46.000Z | 2021-12-14T18:17:41.000Z | examples/TestCrowd1/src/visualisation/GLUTInputController.h | Tumurtogtokh/FLAMEGPU | 466a2ddc34091b034bbfb968b2a3561c90b969f7 | [
"MIT"
] | 35 | 2015-06-01T15:32:54.000Z | 2021-12-13T22:35:54.000Z | /*
* Copyright 2011 University of Sheffield.
* Author: Dr Paul Richmond
* Contact: p.richmond@sheffield.ac.uk (http://www.paulrichmond.staff.shef.ac.uk)
*
* University of Sheffield retain all intellectual property and
* proprietary rights in and to this software and related documentation.
* Any use, reproduction, disclosure, or distribution of this software
* and related documentation without an express license agreement from
* University of Sheffield is strictly prohibited.
*
* For terms of licence agreement please attached licence or view licence
* on www.flamegpu.com website.
*
*/
#ifndef __GLUT_INPUT_CONTROLLER
#define __GLUT_INPUT_CONTROLLER
/** initInputConroller
* Initilises the input controller by setting the initial viewpoint vectors
*/
void initInputConroller();
/** mouse
* Function for controlling mouse input with GLUT
* @param button muse button state
* @param state mouse state (i.e. up down)
* @param x x screen position
* @param y y screen position
*/
void mouse(int button, int state, int x, int y);
/** keyboard
* Function for controlling keyboard input with GLUT
* @param key key pressed
* @param x
* @param y
*/
void keyboard( unsigned char key, int x, int y);
/** specialKeyboard
* Function for controlling special keyboard (arrow keys) input with GLUT
* @param key key pressed
* @param x
* @param y
*/
void specialKeyboard(int key, int x, int y);
//viewpoint vectors and eye distance
extern float eye[3];
extern float up[3];
extern float look[3];
extern float eye_distance;
#endif //__GLUT_INPUT_CONTROLLER
| 28.392857 | 81 | 0.742767 |
68d4f8e483e2df2cb539cb110be18be7bebfb4a7 | 23,806 | h | C | src/ttftable.h | 23468234/ttf-font-edit | d04a479b9278c08d5d3e246d533795159efd206d | [
"MIT"
] | null | null | null | src/ttftable.h | 23468234/ttf-font-edit | d04a479b9278c08d5d3e246d533795159efd206d | [
"MIT"
] | null | null | null | src/ttftable.h | 23468234/ttf-font-edit | d04a479b9278c08d5d3e246d533795159efd206d | [
"MIT"
] | null | null | null | #ifndef TTFTABLE_H
#define TTFTABLE_H
#include <QObject>
#include <QFile>
#include <QMap>
#include <ttfmodify.h>
/*字库文件头*/
#define TTF_HEAD_SIZE 12
typedef struct _ttf_head
{
quint32 sfntversion; //0x10000 for version 1.0
quint16 numTables;
quint16 searchRange;
quint16 entrySelector;
quint16 rangeShift;
bool combineTheByteToStruct(QByteArray data, struct _ttf_head * ttfHeadStruct);
}TTF_FILE_HEAD_S;
/*各个表的公共部分*/
#define TABLE_ENTYR_SIZE 16
class TableEntryAbstract
{
public:
qint8 tag[4];
quint32 checkSum;
quint32 offset;
quint32 length;
TableEntryAbstract(){}
virtual ~TableEntryAbstract(){}
virtual void combineBytesToStruct(QByteArray & data) = 0;
virtual QByteArray getDataForWriteFile() = 0;
virtual void setDataOffsetInfile(qint32 offset) = 0;
};
class CmapTable; //cmap
class GlyfTable; //glyf
class HeadTable; //head
class HheaTable; //hhea
class HmtxTable; //hmtx
class LocaTable; //loca
class MaxpTable; //maxp
class NameTable; //name
class PostTable; //post
class Os2Table; //os/2
class HdmxTable; //hdmx
class VheaTable; //vhea
class VmtxTable; //vmtx
class UnknowTable; //others
/*camp表*/
class CmapTable : public TableEntryAbstract
{
public:
typedef struct
{
quint16 PlatformID;
quint16 encodingID; //Platform-specific encoding ID.
quint32 byteOffset; // from beginning of table to thesubtable for this encoding.
quint16 format; // Format number is set to 0.
quint16 length; // This is the length in bytes of the subtable.
quint16 version; // Version number (starts at 0).
}FORMAT_ENCODING_BASE_S;
typedef struct
{
FORMAT_ENCODING_BASE_S base;
qint8 glyphIdArray[256]; // An array that maps character codes to glyph index values.
}FORMAT_0_ENCODING_S;
typedef struct
{
FORMAT_ENCODING_BASE_S base;
typedef struct
{
quint16 firstCode; //First valid low byte for this subHeader.
quint16 entryCount; //Number of valid low bytes for this subHeader.
qint16 idDelta; //See text below.
quint16 idRangeOffset;// See text below.
}SUB_HEAD_S;
quint16 subHeaderKeys[256]; // Array that maps high bytes to
//subHeaders: value is subHeader index * 8.
QByteArray subHeaderAndGlyhArray;
/*
SUB_HEAD_S *subHeaders; // Variable-length array of subHeader structures.
quint16 *glyphIndexArray;*/ // Variable-length array containing
//subarrays used for mapping
}FORMAT_2_ENCODING_S;
typedef struct
{
FORMAT_ENCODING_BASE_S base;
quint16 segCountX2; //2 x segCount.
quint16 searchRange; //2 x (2**floor(log2(segCount)))
quint16 entrySelector; //log2(searchRange/2)
quint16 rangeShift; //2 x segCount - searchRange
quint16 *endCount; //[segCount]; //End characterCode for each segment,last =0xFFFF.
quint16 reservedPad; //Set to 0.
quint16 *startCount; //[segCount]; //Start character code for each segment.
qint16 *idDelta; //[segCount]; //Delta for all character codes in segment.
QByteArray idRangeOffsetAndglyphIdArray; //两部分地址要连续存储
// quint16 *idRangeOffset; //[segCount]; //Offsets into glyphIdArray or 0
//quint16 *glyphIdArray;//Glyph index array (arbitrary length)
}FORMAT_4_ENCODING_S;
typedef struct
{
FORMAT_ENCODING_BASE_S base;
quint16 firstCode; //First character code of subrange.
quint16 entryCount; //Number of character codes in subrange.
quint16 *glyphIdArray; //[entryCount]; //Array of glyph index values for character codes in the range.
}FORMAT_6_ENCODING_S;
CmapTable(){}
virtual ~CmapTable();
virtual void combineBytesToStruct(QByteArray & data);
virtual QByteArray getDataForWriteFile();
virtual void setDataOffsetInfile(qint32 offset);
quint16 tableVersionNumber; // (0).
quint16 numberOfEncodingTables; //Number of encoding tables, n.
QList <FORMAT_ENCODING_BASE_S*> encodeList;
CmapTable & operator= (CmapTable & table);
FORMAT_ENCODING_BASE_S* createEncodeList(QByteArray encodeBase, QByteArray rawData);
QMap<quint16, quint16> getUnicodeGlyfIndexMap();
void createFormat4AndAddToList(QMap<quint16, qint32> & unicodeAndGlyf);
}; //camp
/*lgyf*/
class GlyfTable: public TableEntryAbstract
{
public:
#define ARG_1_AND_2_ARE_WORDS (1 << 0) //If this is set, the arguments are words; otherwise, they are bytes.
#define ARGS_ARE_XY_VALUES (1 << 1) //If this is set, the arguments are xy values; otherwise, they are points.
#define ROUND_XY_TO_GRID (1 << 2) //For the xy values if the preceding is true.
#define WE_HAVE_A_SCALE (1 << 3) //This indicates that there is a simple scale for the component. Otherwise, scale = 1.0.
#define RESERVED (1 << 4) //This bit is reserved. Set it to 0.
#define MORE_COMPONENTS (1 << 5) //Indicates at least one more glyph after this one.
#define WE_HAVE_AN_X_AND_Y_SCALE (1 << 6) //The x direction will use a different scale from the y direction.
#define WE_HAVE_A_TWO_BY_TWO (1 << 7) //There is a 2 by 2 transformation that will be used to scale the component.
#define WE_HAVE_INSTRUCTIONS (1 << 8) //Following the last component are instructions for the composite character.
#define USE_MY_METRICS (1 << 9) //If set, this forces the aw and lsb (and rsb) for the composite to be equal to those from this original glyph. This works for hinted and unhinted characters.
#define OVERLAP_COMPOUND (1 << 10) //Used by Apple in GX fonts.
#define SCALED_COMPONENT_OFFSET (1 << 11) //Composite designed to have the component offset scaled (designed for Apple rasterizer).
#define UNSCALED_COMPONENT_OFFSET (1 << 12) //Composite designed not to have the component offset scaled (designed for the Microsoft TrueType rasterizer).
QByteArray glyfData;
GlyfTable(){}
virtual ~GlyfTable();
virtual void combineBytesToStruct(QByteArray & data);
virtual QByteArray getDataForWriteFile();
virtual void setDataOffsetInfile(qint32 offset);
GlyfTable & operator= (GlyfTable & table);
quint32 addGlyf(QByteArray & data);
QByteArray getOneGlyfData(quint32 startAddr, quint32 endAddr);
}; //glyf
/*head*/
class HeadTable : public TableEntryAbstract
{
public:
qint32 tableVersionNumber; // 0x00010000 for version 1.0.
quint32 fontRevision; // Set by font manufacturer.
quint32 checkSumAdjustment; //To compute: set it to 0, sum the entire font
//as ULONG, then store 0xB1B0AFBA - sum.
quint32 magicNumber; //Set to 0x5F0F3CF5
quint16 flags; //Bit 0 - baseline for font at y=0;
//Bit 1 - left sidebearing at x=0;
//Bit 2 - instructions may depend on point size;
//Bit 3 - force ppem to integer values for all
//internal scaler math; may use fractional ppem
//sizes if this bit is clear;
//Bit 4 - instructions may alter advance width
//(the advance widths might not scale linearly);
//Note: All other bits must be zero.
quint16 unitsPerEm; //Valid range is from 16 to 16384
qint64 createdInternationalDate; //(8-byte field).
qint64 modifiedInternationalDate; //(8-byte field).
qint16 xMin; // For all glyph bounding boxes.
qint16 yMin; // For all glyph bounding boxes.
qint16 xMax; // For all glyph bounding boxes.
qint16 yMax; // For all glyph bounding boxes.
quint16 macStyle; // Bit 0 bold (if set to 1); Bit 1 italic (if set to 1)
//Bits 2-15 reserved (set to 0).
quint16 lowestRecPPEM; //Smallest readable size in pixels.
qint16 fontDirectionHint; //0 Fully mixed directional glyphs;
//1 Only strongly left to right;
//2 Like 1 but also contains neutrals1;
//-1 Only strongly right to left;
//-2 Like -1 but also contains neutrals.
qint16 indexToLocFormat; // 0 for short offsets, 1 for long.
qint16 glyphDataFormat; // 0 for current format.
HeadTable(){}
virtual ~HeadTable();
virtual void combineBytesToStruct(QByteArray & data);
virtual QByteArray getDataForWriteFile();
virtual void setDataOffsetInfile(qint32 offset);
HeadTable & operator= (HeadTable & table);
}; //head
class HheaTable : public TableEntryAbstract
{
public:
qint32 tableVersionNumber; // 0x00010000 for version 1.0.
qint16 Ascender; //Typographic ascent.
qint16 Descender; //Typographic descent.
qint16 LineGap; //Typographic line gap. Negative
//LineGap values are treated as zero
//in Windows 3.1, System 6, and System 7.
quint16 advanceWidthMax; //Maximum advance width value in ‘hmtx’ table.
qint16 minLeftSideBearing; //Minimum left sidebearing value in ‘hmtx’ table.
qint16 minRightSideBearing; //Minimum right sidebearing value;
//calculated as Min(aw - lsb - (xMax - xMin)).
qint16 xMaxExtent; //Max(lsb + (xMax - xMin)).
qint16 caretSlopeRise; //Used to calculate the slope of the cursor (rise/run); 1 for vertical.
qint16 caretSlopeRun; //0 for vertical.
qint16 reserved1; //set to 0
qint16 reserved2; //set to 0
qint16 reserved3; //set to 0
qint16 reserved4; //set to 0
qint16 reserved5; //set to 0
qint16 metricDataFormat; //0 for current format.
quint16 numberOfHMetrics; //Number of hMetric entries in
//‘hmtx’ table; may be smaller than the
//total number of glyphs in the font.
HheaTable(){}
virtual ~HheaTable();
virtual void combineBytesToStruct(QByteArray & data);
virtual QByteArray getDataForWriteFile();
virtual void setDataOffsetInfile(qint32 offset);
HheaTable & operator= (HheaTable & table);
}; //hhea
class HmtxTable:public TableEntryAbstract
{
public:
typedef struct _longHorMertric
{
quint16 advanceWidth;
qint16 lsb;
} LONG_HOR_MERTRIC_S;
QList<LONG_HOR_MERTRIC_S*> metricList; //numOfHMetrics comes from the ‘hhea’ table.
//If the font is monospaced, only one entry
//need be in the array, but that entry is required.
//The last entry applies to all subsequent glyphs.
HmtxTable(){}
virtual ~HmtxTable();
virtual void combineBytesToStruct(QByteArray & data);
virtual QByteArray getDataForWriteFile();
virtual void setDataOffsetInfile(qint32 offset);
HmtxTable & operator= (HmtxTable & table);
LONG_HOR_MERTRIC_S getOneMertric(quint16 glyfIndex);
void addOneMertric(LONG_HOR_MERTRIC_S mertric);
}; //hmtx
class LocaTable:public TableEntryAbstract
{
public:
QByteArray glyfOffsets; //There are two versions of this table, the short and the long. The version is
//specified in the indexToLocFormat entry in the ‘head’ table.
//value of n is numGlyphs + 1. The value for numGlyphs is found in the ‘maxp’ table
LocaTable(){}
virtual ~LocaTable();
virtual void combineBytesToStruct(QByteArray & data);
virtual QByteArray getDataForWriteFile();
virtual void setDataOffsetInfile(qint32 offset);
LocaTable & operator= (LocaTable & table);
quint32 getGlyfOffset(quint8 indexToLocFormat,quint16 glyphIndex); //head 表中indexToLocFormat确定数据的格式
void addGlyfOffset(quint8 indexToLocFormat, quint32 offset); //head 表中indexToLocFormat确定数据的格式
void debugInfo();
}; //loca
class MaxpTable:public TableEntryAbstract
{
public:
qint32 tableVersionNumber;// 0x00010000 for version 1.0.
quint16 numGlyphs; // The number of glyphs in the font.
quint16 maxPoints; // Maximum points in a non-composite glyph.
quint16 maxContours; // Maximum contours in a noncompositeglyph.
quint16 maxCompositePoints; // Maximum points in a composite glyph.
quint16 maxCompositeContours; // Maximum contours in a composite glyph.
quint16 maxZones; // 1 if instructions do not use the twilight zone (Z0),
//or 2 if instructions do use Z0; should be set to 2 in most cases.
quint16 maxTwilightPoints; //Maximum points used in Z0.
quint16 maxStorage; //Number of Storage Area locations.
quint16 maxFunctionDefs; //Number of FDEFs.
quint16 maxInstructionDefs; //Number of IDEFs.
quint16 maxStackElements; //Maximum stack depth2.
quint16 maxSizeOfInstructions; //Maximum byte count for glyph instructions.
quint16 maxComponentElements; //Maximum number of components referenced at “top level”
//for any composite glyph.
quint16 maxComponentDepth; //Maximum levels of recursion;
MaxpTable(){}
virtual ~MaxpTable();
virtual void combineBytesToStruct(QByteArray & data);
virtual QByteArray getDataForWriteFile();
virtual void setDataOffsetInfile(qint32 offset);
MaxpTable & operator= (MaxpTable & table);
}; //maxp
class NameTable:public TableEntryAbstract
{
public:
QByteArray nameArray;
NameTable(){}
virtual ~NameTable();
virtual void combineBytesToStruct(QByteArray & data);
virtual QByteArray getDataForWriteFile();
virtual void setDataOffsetInfile(qint32 offset);
NameTable & operator= (NameTable & table);
}; //name
class PostTable:public TableEntryAbstract
{
public:
#define FORMAT_1_0 0x10000
#define FORMAT_2_0 0x20000
#define FORMAT_2_5 0x25000
#define FORMAT_3_0 0x30000
struct
{
qint16 numberOfGlyphs; // (this is the same as numGlyphs in ‘maxp’ table).
QByteArray glyphNameIndex;
QByteArray glyphNames;
qint32 namesCount;
/*
qint16* glyphNameIndex; //[numGlyphs].
qint8* glyphNames; // with length bytes [variable] (a Pascal string).
*/
}format2p0;
struct
{
qint16 numberOfGlyphs;
QByteArray offset;
}format2p5;
quint32 Format; //Type 0x00010000 for format 1.0, 0x00020000 for format 2.0, and so on...
quint32 italicAngle; //Italic angle in counter-clockwise degrees from the
//vertical. Zero for upright text, negative for text that leans to the right (forward)
qint16 underlinePosition; //Suggested values for the underline position
//(negative values indicate below baseline).
qint16 underlineThickness; //Suggested values for the underline thickness.
quint32 isFixedPitch; //Set to 0 if the font is proportionally spaced, nonzero
//if the font is not proportionally spaced (i.e.monospaced).
quint32 minMemType42; //Minimum memory usage when a TrueType font is downloaded.
quint32 maxMemType42; //Maximum memory usage when a TrueType font is downloaded.
quint32 minMemType1; //Minimum memory usage when a TrueType font is
//downloaded as a Type 1 font.
quint32 maxMemType1; //Maximum memory usage when a TrueType font is
//downloaded as a Type 1 font.
PostTable(){}
virtual ~PostTable();
virtual void combineBytesToStruct(QByteArray & data);
virtual QByteArray getDataForWriteFile();
virtual void setDataOffsetInfile(qint32 offset);
PostTable & operator= (PostTable & table);
void changeToFormat2p0(quint16 numberGlyphs);
void changeNumberGlyphs(quint16 numberGlyphs);
QByteArray getGlyphName(quint16 glyfIndex);
qint32 getGlyphNameIndex(quint16 glyfIndex);
QByteArray format2p0GetGlyphName(quint16 index);
void addFormat2p0NameArray(quint16 glyfIndex, QByteArray & name);
void addFormat2p0NameIndex(quint16 glyfIndex, qint16 index);
void clear();
void debugOutAllInfo();
}; //post
class Os2Table : public TableEntryAbstract
{
public:
quint16 version;// 0x0001
qint16 xAvgCharWidth;
quint16 usWeightClass;
quint16 usWidthClass;
qint16 fsType;
qint16 ySubscriptXSize;
qint16 ySubscriptYSize;
qint16 ySubscriptXOffset;
qint16 ySubscriptYOffset;
qint16 ySuperscriptXSize;
qint16 ySuperscriptYSize;
qint16 ySuperscriptXOffset;
qint16 ySuperscriptYOffset;
qint16 yStrikeoutSize;
qint16 yStrikeoutPosition;
qint16 sFamilyClass;
quint8 panose[10];
quint32 ulUnicodeRange1;// Bits 0–31
quint32 ulUnicodeRange2;// Bits 32–63
quint32 ulUnicodeRange3;// Bits 64–95
quint32 ulUnicodeRange4;// Bits 96–127
qint8 achVendID[4];
quint16 fsSelection;
quint16 usFirstCharIndex;
quint16 usLastCharIndex;
quint16 sTypoAscender;
quint16 sTypoDescender;
quint16 sTypoLineGap;
quint16 usWinAscent;
quint16 usWinDescent;
/*version1 以及 以上*/
quint32 ulCodePageRange1; //Bits 0-31
quint32 ulCodePageRange2;// Bits 32-63
/*下面的verson2 以及 以上才有*/
qint16 sxHeight;
qint16 sCapHeight;
quint16 usDefaultChar;
quint16 usBreakChar;
/*version5 以及以上*/
quint16 usMaxContext;
quint16 usLowerOpticalPointSize;
quint16 usUpperOpticalPointSize;
Os2Table(){}
virtual ~Os2Table();
virtual void combineBytesToStruct(QByteArray & data);
virtual QByteArray getDataForWriteFile();
virtual void setDataOffsetInfile(qint32 offset);
Os2Table & operator= (Os2Table & table);
}; //os/2
class HdmxTable : public TableEntryAbstract
{
public:
typedef struct
{
quint8 pixelSize;// Pixel size for following widths (as ppem).
quint8 maxWidth; // Maximum width.
QByteArray widths;//[numGlyphs];// Array of widths (numGlyphs is from the 'maxp' table).
}HDMX_RECORDS_S;
quint16 version;
qint16 numRecords;
qint32 sizeDeviceRecord;
QList <HDMX_RECORDS_S* > recordsList;
HdmxTable(){}
virtual ~HdmxTable();
virtual void combineBytesToStruct(QByteArray & data);
virtual QByteArray getDataForWriteFile();
virtual void setDataOffsetInfile(qint32 offset);
HdmxTable & operator= (HdmxTable & table);
};
class VheaTable : public TableEntryAbstract
{
public:
quint32 version; //Version number of the vertical header table; 0x00010000 for version 1.0
qint16 ascent; //Distance in FUnits from the centerline to the previous line’s descent.
qint16 descent; //Distance in FUnits from the centerline to the next line’s ascent.
qint16 lineGap; //Reserved; set to 0
qint16 advanceHeightMax;// The maximum advance height measurement -in FUnits found in the font. This value must be consistent with the entries in the vertical metrics table.
qint16 minTop; //SideBearing The minimum top sidebearing measurement found in the font, in FUnits. This value must be consistent with the entries in the vertical metrics table.
qint16 minBottom; //SideBearing The minimum bottom sidebearing measurement found in the font,
//in FUnits. This value must be consistent with the entries in the vertical metrics table.
qint16 yMaxExtent; //Defined as yMaxExtent=minTopSideBearing+(yMax-yMin)
qint16 caretSlopeRise; //The value of the caretSlopeRise field divided by the value of the caretSlopeRun Field determines the slope of the caret. A value of 0 for the rise and a value of 1 for the run specifies a horizontal caret. A value of 1 for the rise and a value of 0 for the run specifies a vertical caret. Intermediate values are desirable for fonts whose glyphs are oblique or italic. For a vertical font, a horizontal caret is best.
qint16 caretSlopeRun; //See the caretSlopeRise field. Value=1 for nonslanted vertical fonts.
qint16 caretOffset; // The amount by which the highlight on a slanted glyph needs to be shifted away from the glyph in order to produce the best appearance. Set value equal to 0 for nonslanted fonts.
qint16 reserved1; //Set to 0.
qint16 reserved2; //Set to 0.
qint16 reserved3; //Set to 0.
qint16 reserved4; //Set to 0.
qint16 metricDataFormat; //Set to 0.
quint16 numOfLongVerMetrics; //Number of advance heights in the vertical metrics table.
VheaTable(){}
virtual ~VheaTable();
virtual void combineBytesToStruct(QByteArray & data);
virtual QByteArray getDataForWriteFile();
virtual void setDataOffsetInfile(qint32 offset);
VheaTable & operator= (VheaTable & table);
}; //vhea
class VmtxTable : public TableEntryAbstract
{
public:
QByteArray data;
QByteArray advanceHeight;
QByteArray topSideBearing;
VmtxTable(){}
virtual ~VmtxTable();
virtual void combineBytesToStruct(QByteArray & data);
virtual QByteArray getDataForWriteFile();
virtual void setDataOffsetInfile(qint32 offset);
VmtxTable & operator= (VmtxTable & table);
void parseData(quint16 numGlyphs);
};//vmtx
class UnknowTable:public TableEntryAbstract
{
public:
QByteArray data;
UnknowTable(){}
virtual ~UnknowTable();
virtual void combineBytesToStruct(QByteArray & data);
virtual QByteArray getDataForWriteFile();
virtual void setDataOffsetInfile(qint32 offset);
UnknowTable & operator= (UnknowTable & table);
}; //unknow
/*一个ttf文件的数据*/
typedef struct
{
TTF_FILE_HEAD_S ttfFileHead;
QMap <QString, TableEntryAbstract*> tableMap;
}TTF_INFO_S;
class TtfFile
{
Q_DECLARE_TR_FUNCTIONS(TtfFile);
public:
TtfFile();
TtfFile(TtfFile & ttfFile);
~TtfFile();
TtfFile & operator= (TtfFile & ttfile);
bool ttfFileOpen(QString fileName);
void ttfFileSave(QString fileName);
void newTtfFileCreate(QString & fileName, QMap<quint16, bool> & newFileUnicodeMap);
TableEntryAbstract * getTableEntry(QString tag);
void clear();
private:
TTF_INFO_S * ttfInfo;
void showMessageBoxBadFile(QString info);
TableEntryAbstract* createEntry(QString tag);
TableEntryAbstract* copyOneTable(QString tag, TableEntryAbstract * table);
void createTableMap(QByteArray data, QMap<QString, TableEntryAbstract*> & map);
qint32 readTableData(QFile & file, quint32 pos, QMap<QString, TableEntryAbstract*> & map);
void ttfFileHeadSetTableNums(quint16 nums);
friend class TtfModify;
};
#if defined (__cplusplus)
extern "C"
{
#endif
QByteArray splitU16toByteArray(quint32 data);
QByteArray splitU32toByteArray(quint32 data);
quint16 combineByteTo16(quint8 byte0, quint8 byte1);
quint32 combineByteTo32(quint8 byte0, quint8 byte1, quint8 byte2, quint8 byte3);
#if defined (__cplusplus)
}
#endif
#endif
| 39.02623 | 448 | 0.664832 |
412c6f792707fd455c1a4cae311a0e38cb9d8a7a | 423 | h | C | src/intrinsics/Comparisons.h | rigred/VC4C | 6c900c0e2fae2cbdd22c5adb044f385ae005468a | [
"MIT"
] | 111 | 2017-11-02T14:46:45.000Z | 2022-03-15T21:32:59.000Z | src/intrinsics/Comparisons.h | rigred/VC4C | 6c900c0e2fae2cbdd22c5adb044f385ae005468a | [
"MIT"
] | 139 | 2017-10-09T07:39:01.000Z | 2021-11-20T15:31:27.000Z | src/intrinsics/Comparisons.h | rigred/VC4C | 6c900c0e2fae2cbdd22c5adb044f385ae005468a | [
"MIT"
] | 33 | 2017-10-10T10:19:58.000Z | 2022-02-27T15:59:50.000Z | /*
* Author: doe300
*
* See the file "LICENSE" for the full license governing this code.
*/
#ifndef VC4C_COMPARISONS_H
#define VC4C_COMPARISONS_H
#include "../InstructionWalker.h"
namespace vc4c
{
namespace intrinsics
{
// relational operators
bool intrinsifyComparison(Method& method, InstructionWalker it);
} // namespace intrinsics
} // namespace vc4c
#endif /* VC4C_COMPARISONS_H */
| 19.227273 | 72 | 0.702128 |
02947ff5aba5db0e4f4a187be85779b22dd17526 | 1,529 | c | C | src/rrd/pretty.c | StyXman/kgt | c84b8c57fdccec5d961a1d39fa8763a1cee7e037 | [
"BSD-2-Clause"
] | 456 | 2017-02-01T13:54:41.000Z | 2022-03-26T18:28:49.000Z | src/rrd/pretty.c | StyXman/kgt | c84b8c57fdccec5d961a1d39fa8763a1cee7e037 | [
"BSD-2-Clause"
] | 33 | 2017-04-01T17:02:13.000Z | 2022-02-20T23:23:10.000Z | src/rrd/pretty.c | StyXman/kgt | c84b8c57fdccec5d961a1d39fa8763a1cee7e037 | [
"BSD-2-Clause"
] | 23 | 2019-03-09T13:28:42.000Z | 2022-03-04T15:09:01.000Z | /*
* Copyright 2014-2017 Katherine Flavel
*
* See LICENCE for the full copyright terms.
*/
/*
* Railroad diagram beautification
*/
#include <stddef.h>
#include <assert.h>
#include "../txt.h"
#include "../xalloc.h"
#include "node.h"
#include "list.h"
#include "pretty.h"
static void
node_walk(void (*f)(int *, struct node **),
int *changed, struct node **n)
{
assert(f != NULL);
f(changed, n);
if (*n == NULL) {
return;
}
switch ((*n)->type) {
struct list **p;
case NODE_ALT:
case NODE_ALT_SKIPPABLE:
for (p = &(*n)->u.alt; *p != NULL; p = &(**p).next) {
node_walk(f, changed, &(*p)->node);
}
break;
case NODE_SEQ:
for (p = &(*n)->u.seq; *p != NULL; p = &(**p).next) {
node_walk(f, changed, &(*p)->node);
}
break;
case NODE_LOOP:
node_walk(f, changed, &(*n)->u.loop.forward);
node_walk(f, changed, &(*n)->u.loop.backward);
break;
case NODE_RULE:
case NODE_PROSE:
case NODE_CI_LITERAL:
case NODE_CS_LITERAL:
break;
}
}
void
rrd_pretty(struct node **rrd)
{
int changed;
int limit;
size_t i;
void (*f[])(int *, struct node **) = {
rrd_pretty_collapse, rrd_pretty_skippable, rrd_pretty_redundant,
rrd_pretty_collapse, rrd_pretty_roll,
rrd_pretty_collapse, rrd_pretty_nested, rrd_pretty_ci,
rrd_pretty_collapse, rrd_pretty_affixes,
rrd_pretty_collapse, rrd_pretty_bottom,
rrd_pretty_collapse
};
limit = 20;
for (i = 0; i < sizeof f / sizeof *f; i++) {
do {
changed = 0;
node_walk(f[i], &changed, rrd);
} while (changed && !limit--);
}
}
| 17.375 | 66 | 0.633094 |
02a36c8b45907025f90d1203282e22a00977f7a5 | 1,520 | h | C | mcl/io/TSettingsReader.h | hasaranga/MCL | 498bb591de3467700c35b008389335c925d1f46e | [
"MIT"
] | 1 | 2019-10-04T05:12:21.000Z | 2019-10-04T05:12:21.000Z | mcl/io/TSettingsReader.h | hasaranga/MCL | 498bb591de3467700c35b008389335c925d1f46e | [
"MIT"
] | null | null | null | mcl/io/TSettingsReader.h | hasaranga/MCL | 498bb591de3467700c35b008389335c925d1f46e | [
"MIT"
] | null | null | null |
/*
MCL - TSettingsReader.h
Copyright (C) 2019 CrownSoft
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#pragma once
#include <windows.h>
#include "TFile.h"
#include "../containers/TLeakDetector.h"
/**
High performance configuration reading class.
*/
class TSettingsReader
{
protected:
TFile settingsFile;
public:
TSettingsReader();
virtual bool openFile(const TString& fileName, int formatID);
/**
read struct, array or whatever...
*/
virtual void readData(DWORD size, void* buffer);
virtual TString readString();
virtual int readInt();
virtual float readFloat();
virtual double readDouble();
virtual bool readBool();
virtual ~TSettingsReader();
private:
MCL_LEAK_DETECTOR(TSettingsReader)
};
| 24.126984 | 75 | 0.755263 |
2ac1dba73c5d01ab642a127034b93dd4b2e7525f | 910 | c | C | user/primes.c | OneMore14/MIT-6.S081-2021 | 732391999fec76f837fa5ddc5c8d233bba0274eb | [
"MIT-0"
] | null | null | null | user/primes.c | OneMore14/MIT-6.S081-2021 | 732391999fec76f837fa5ddc5c8d233bba0274eb | [
"MIT-0"
] | null | null | null | user/primes.c | OneMore14/MIT-6.S081-2021 | 732391999fec76f837fa5ddc5c8d233bba0274eb | [
"MIT-0"
] | null | null | null | #include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"
void primes(int* in) {
close(in[1]);
int prime;
if (read(in[0], &prime, sizeof(int)) <= 0) {
close(in[0]);
exit(0);
}
printf("prime %d\n", prime);
int out[2]; pipe(out);
int pid = fork();
if (pid == 0) {
primes(out);
exit(0);
}
close(out[0]);
int number;
while (read(in[0], &number, sizeof(int)) > 0)
{
if (number % prime) {
write(out[1], &number, sizeof(int));
}
}
close(in[0]);
close(out[1]);
wait(0);
}
int
main(int argc, char *argv[])
{
int fd[2];
pipe(fd);
int pid = fork();
if (pid == 0) {
primes(fd);
exit(0);
}
close(fd[0]);
for (int i = 2; i <= 35;i++) {
write(fd[1], &i, sizeof(int));
}
close(fd[1]);
wait(0);
exit(0);
}
| 15.964912 | 49 | 0.447253 |
4673568cd0b5193ef4dc7c6c3393688647f8fb7a | 849 | h | C | classes/UI/AGSSUIShareActionSheetItem.h | appgame-sdk/AGSharedSDK | 16b8e374fb06735ff840fa83b0232c487ebcaaca | [
"MIT"
] | null | null | null | classes/UI/AGSSUIShareActionSheetItem.h | appgame-sdk/AGSharedSDK | 16b8e374fb06735ff840fa83b0232c487ebcaaca | [
"MIT"
] | null | null | null | classes/UI/AGSSUIShareActionSheetItem.h | appgame-sdk/AGSharedSDK | 16b8e374fb06735ff840fa83b0232c487ebcaaca | [
"MIT"
] | null | null | null | //
// AGSSUIShareActionSheetItem.h
// AGSharedSDK
//
// Created by 覃凤姣 on 16/5/5.
// Copyright © 2016年 覃凤姣. All rights reserved.
//
#import <Foundation/Foundation.h>
#import <UIKit/UIKit.h>
#import "AGSSDKTypeDefine.h"
@interface AGSSUIShareActionSheetItem : NSObject
{
UIImage *_icon;
NSString *_label;
}
/**
* 图标
*/
@property (nonatomic, strong) UIImage *icon;
/**
* 标签
*/
@property (nonatomic, copy) NSString *label;
/**
* 创建平台分享菜单项
*
* @param platformType 平台类型
* @param index 数组下标
*
* @return 分享菜单项
*/
+ (instancetype)itemWithPlatformType:(SSDKPlatformType)platformType;
/**
* 创建自定义分享菜单项
*
* @param icon 图标
* @param label 标签
* @param clickHandler 点击事件处理
*
* @return 分享菜单项
*/
+ (instancetype)itemWithIcon:(UIImage *)icon label:(NSString *)label onClick:(void(^)())clickHandler;
@end
| 16.98 | 101 | 0.658422 |
f29ab38304f86898755f6880eee4e838ed4e2add | 1,820 | h | C | src/include/smol/smol_log.h | marciovmf/smol | d3ed1fef92557b162d7048639f6be5b24547a95a | [
"Apache-2.0"
] | 26 | 2020-08-13T21:02:38.000Z | 2022-03-31T15:44:16.000Z | src/include/smol/smol_log.h | marciovmf/smol | d3ed1fef92557b162d7048639f6be5b24547a95a | [
"Apache-2.0"
] | 13 | 2021-03-26T22:54:11.000Z | 2021-11-04T10:57:40.000Z | src/include/smol/smol_log.h | marciovmf/smol | d3ed1fef92557b162d7048639f6be5b24547a95a | [
"Apache-2.0"
] | 2 | 2020-09-13T14:57:34.000Z | 2021-02-14T20:02:04.000Z | #ifndef SMOL_LOG
#define SMOL_LOG
#include <smol/smol_engine.h>
#include <stdarg.h>
#include <stdio.h>
#ifdef SMOL_RELEASE
#define debugLogError(fmt, ...)
#define debugLogFatal(fmt, ...)
#define debugLogInfo(fmt, ...)
#define debugLogWarning(fmt, ...)
#define SMOL_ASSERT(condition, fmt, ...)
#else
#define STRNOEXPAND(a) #a
#define STR(a) STRNOEXPAND(a)
#define SMOLCONTEXT STR(__FILE__) ## ":" ## STR(__LINE__)
#define SMOLASSERTIONCONTEXT "Assertion failed at " ## __FILE__ ## ":" ## STR(__LINE__)
#define debugLogError(fmt, ...) smol::Log::print(smol::Log::LogType::LOG_ERROR, SMOLCONTEXT, fmt, __VA_ARGS__)
#define debugLogFatal(fmt, ...) smol::Log::print(smol::Log::LogType::LOG_FATAL, SMOLCONTEXT, fmt, __VA_ARGS__)
#define debugLogInfo(fmt, ...) smol::Log::print(smol::Log::LogType::LOG_INFO, nullptr, fmt, __VA_ARGS__)
#define debugLogWarning(fmt, ...) smol::Log::print(smol::Log::LogType::LOG_WARNING, SMOLCONTEXT, fmt, __VA_ARGS__)
#define SMOL_ASSERT(condition, fmt, ...) do{ if (!(condition)) {smol::Log::print(smol::Log::LogType::LOG_FATAL, SMOLASSERTIONCONTEXT, fmt, __VA_ARGS__); *((int*)0) = 0;}} while(0)
#endif
namespace smol
{
struct SMOL_ENGINE_API Log
{
enum LogType : int
{
LOG_INFO = 1,
LOG_WARNING = 1 << 1,
LOG_ERROR = 1 << 2,
LOG_FATAL = 1 << 3,
LOG_ALL = LOG_INFO | LOG_WARNING | LOG_ERROR | LOG_FATAL,
};
static void toFile(const char* fileName);
static void toStdout();
static Log::LogType verbosity(int maxLogLevel);
static void error(const char* format, ...);
static void info(const char* format, ...);
static void warning(const char* format, ...);
static void fatal(const char* format, ...);
static void print(Log::LogType type, const char* context, const char* format, ...);
};
}
#endif // SMOL_LOG
| 35 | 179 | 0.678571 |
f16cabc027094d62e704091095d78d759d74a8e6 | 25,378 | c | C | third_party/mesa/MesaLib/src/gallium/drivers/cell/spu/spu_command.c | Scopetta197/chromium | b7bf8e39baadfd9089de2ebdc0c5d982de4a9820 | [
"BSD-3-Clause"
] | 212 | 2015-01-31T11:55:58.000Z | 2022-02-22T06:35:11.000Z | third_party/mesa/MesaLib/src/gallium/drivers/cell/spu/spu_command.c | 1065672644894730302/Chromium | 239dd49e906be4909e293d8991e998c9816eaa35 | [
"BSD-3-Clause"
] | 5 | 2015-03-27T14:29:23.000Z | 2019-09-25T13:23:12.000Z | third_party/mesa/MesaLib/src/gallium/drivers/cell/spu/spu_command.c | 1065672644894730302/Chromium | 239dd49e906be4909e293d8991e998c9816eaa35 | [
"BSD-3-Clause"
] | 221 | 2015-01-07T06:21:24.000Z | 2022-02-11T02:51:12.000Z | /**************************************************************************
*
* Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
* IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
/**
* SPU command processing code
*/
#include <stdio.h>
#include <libmisc.h>
#include "pipe/p_defines.h"
#include "spu_command.h"
#include "spu_main.h"
#include "spu_render.h"
#include "spu_per_fragment_op.h"
#include "spu_texture.h"
#include "spu_tile.h"
#include "spu_vertex_shader.h"
#include "spu_dcache.h"
#include "cell/common.h"
struct spu_vs_context draw;
/**
* Buffers containing dynamically generated SPU code:
*/
PIPE_ALIGN_VAR(16) static unsigned char attribute_fetch_code_buffer[136 * PIPE_MAX_ATTRIBS];
static INLINE int
align(int value, int alignment)
{
return (value + alignment - 1) & ~(alignment - 1);
}
/**
* Tell the PPU that this SPU has finished copying a buffer to
* local store and that it may be reused by the PPU.
* This is done by writting a 16-byte batch-buffer-status block back into
* main memory (in cell_context->buffer_status[]).
*/
static void
release_buffer(uint buffer)
{
/* Evidently, using less than a 16-byte status doesn't work reliably */
static const vector unsigned int status = {CELL_BUFFER_STATUS_FREE,
CELL_BUFFER_STATUS_FREE,
CELL_BUFFER_STATUS_FREE,
CELL_BUFFER_STATUS_FREE};
const uint index = 4 * (spu.init.id * CELL_NUM_BUFFERS + buffer);
uint *dst = spu.init.buffer_status + index;
ASSERT(buffer < CELL_NUM_BUFFERS);
mfc_put((void *) &status, /* src in local memory */
(unsigned int) dst, /* dst in main memory */
sizeof(status), /* size */
TAG_MISC, /* tag is unimportant */
0, /* tid */
0 /* rid */);
}
/**
* Write CELL_FENCE_SIGNALLED back to the fence status qword in main memory.
* There's a qword of status per SPU.
*/
static void
cmd_fence(struct cell_command_fence *fence_cmd)
{
static const vector unsigned int status = {CELL_FENCE_SIGNALLED,
CELL_FENCE_SIGNALLED,
CELL_FENCE_SIGNALLED,
CELL_FENCE_SIGNALLED};
uint *dst = (uint *) fence_cmd->fence;
dst += 4 * spu.init.id; /* main store/memory address, not local store */
ASSERT_ALIGN16(dst);
mfc_put((void *) &status, /* src in local memory */
(unsigned int) dst, /* dst in main memory */
sizeof(status), /* size */
TAG_FENCE, /* tag */
0, /* tid */
0 /* rid */);
}
static void
cmd_clear_surface(const struct cell_command_clear_surface *clear)
{
D_PRINTF(CELL_DEBUG_CMD, "CLEAR SURF %u to 0x%08x\n", clear->surface, clear->value);
if (clear->surface == 0) {
spu.fb.color_clear_value = clear->value;
if (spu.init.debug_flags & CELL_DEBUG_CHECKER) {
uint x = (spu.init.id << 4) | (spu.init.id << 12) |
(spu.init.id << 20) | (spu.init.id << 28);
spu.fb.color_clear_value ^= x;
}
}
else {
spu.fb.depth_clear_value = clear->value;
}
#define CLEAR_OPT 1
#if CLEAR_OPT
/* Simply set all tiles' status to CLEAR.
* When we actually begin rendering into a tile, we'll initialize it to
* the clear value. If any tiles go untouched during the frame,
* really_clear_tiles() will set them to the clear value.
*/
if (clear->surface == 0) {
memset(spu.ctile_status, TILE_STATUS_CLEAR, sizeof(spu.ctile_status));
}
else {
memset(spu.ztile_status, TILE_STATUS_CLEAR, sizeof(spu.ztile_status));
}
#else
/*
* This path clears the whole framebuffer to the clear color right now.
*/
/*
printf("SPU: %s num=%d w=%d h=%d\n",
__FUNCTION__, num_tiles, spu.fb.width_tiles, spu.fb.height_tiles);
*/
/* init a single tile to the clear value */
if (clear->surface == 0) {
clear_c_tile(&spu.ctile);
}
else {
clear_z_tile(&spu.ztile);
}
/* walk over my tiles, writing the 'clear' tile's data */
{
const uint num_tiles = spu.fb.width_tiles * spu.fb.height_tiles;
uint i;
for (i = spu.init.id; i < num_tiles; i += spu.init.num_spus) {
uint tx = i % spu.fb.width_tiles;
uint ty = i / spu.fb.width_tiles;
if (clear->surface == 0)
put_tile(tx, ty, &spu.ctile, TAG_SURFACE_CLEAR, 0);
else
put_tile(tx, ty, &spu.ztile, TAG_SURFACE_CLEAR, 1);
}
}
if (spu.init.debug_flags & CELL_DEBUG_SYNC) {
wait_on_mask(1 << TAG_SURFACE_CLEAR);
}
#endif /* CLEAR_OPT */
D_PRINTF(CELL_DEBUG_CMD, "CLEAR SURF done\n");
}
static void
cmd_release_verts(const struct cell_command_release_verts *release)
{
D_PRINTF(CELL_DEBUG_CMD, "RELEASE VERTS %u\n", release->vertex_buf);
ASSERT(release->vertex_buf != ~0U);
release_buffer(release->vertex_buf);
}
/**
* Process a CELL_CMD_STATE_FRAGMENT_OPS command.
* This involves installing new fragment ops SPU code.
* If this function is never called, we'll use a regular C fallback function
* for fragment processing.
*/
static void
cmd_state_fragment_ops(const struct cell_command_fragment_ops *fops)
{
D_PRINTF(CELL_DEBUG_CMD, "CMD_STATE_FRAGMENT_OPS\n");
/* Copy state info (for fallback case only - this will eventually
* go away when the fallback case goes away)
*/
memcpy(&spu.depth_stencil_alpha, &fops->dsa, sizeof(fops->dsa));
memcpy(&spu.blend, &fops->blend, sizeof(fops->blend));
memcpy(&spu.blend_color, &fops->blend_color, sizeof(fops->blend_color));
/* Make sure the SPU knows which buffers it's expected to read when
* it's told to pull tiles.
*/
spu.read_depth_stencil = (spu.depth_stencil_alpha.depth.enabled || spu.depth_stencil_alpha.stencil[0].enabled);
/* If we're forcing the fallback code to be used (for debug purposes),
* install that. Otherwise install the incoming SPU code.
*/
if ((spu.init.debug_flags & CELL_DEBUG_FRAGMENT_OP_FALLBACK) != 0) {
static unsigned int warned = 0;
if (!warned) {
fprintf(stderr, "Cell Warning: using fallback per-fragment code\n");
warned = 1;
}
/* The following two lines aren't really necessary if you
* know the debug flags won't change during a run, and if you
* know that the function pointers are initialized correctly.
* We set them here to allow a person to change the debug
* flags during a run (from inside a debugger).
*/
spu.fragment_ops[CELL_FACING_FRONT] = spu_fallback_fragment_ops;
spu.fragment_ops[CELL_FACING_BACK] = spu_fallback_fragment_ops;
return;
}
/* Make sure the SPU code buffer is large enough to hold the incoming code.
* Note that we *don't* use align_malloc() and align_free(), because
* those utility functions are *not* available in SPU code.
* */
if (spu.fragment_ops_code_size < fops->total_code_size) {
if (spu.fragment_ops_code != NULL) {
free(spu.fragment_ops_code);
}
spu.fragment_ops_code_size = fops->total_code_size;
spu.fragment_ops_code = malloc(fops->total_code_size);
if (spu.fragment_ops_code == NULL) {
/* Whoops. */
fprintf(stderr, "CELL Warning: failed to allocate fragment ops code (%d bytes) - using fallback\n", fops->total_code_size);
spu.fragment_ops_code = NULL;
spu.fragment_ops_code_size = 0;
spu.fragment_ops[CELL_FACING_FRONT] = spu_fallback_fragment_ops;
spu.fragment_ops[CELL_FACING_BACK] = spu_fallback_fragment_ops;
return;
}
}
/* Copy the SPU code from the command buffer to the spu buffer */
memcpy(spu.fragment_ops_code, fops->code, fops->total_code_size);
/* Set the pointers for the front-facing and back-facing fragments
* to the specified offsets within the code. Note that if the
* front-facing and back-facing code are the same, they'll have
* the same offset.
*/
spu.fragment_ops[CELL_FACING_FRONT] = (spu_fragment_ops_func) &spu.fragment_ops_code[fops->front_code_index];
spu.fragment_ops[CELL_FACING_BACK] = (spu_fragment_ops_func) &spu.fragment_ops_code[fops->back_code_index];
}
static void
cmd_state_fragment_program(const struct cell_command_fragment_program *fp)
{
D_PRINTF(CELL_DEBUG_CMD, "CMD_STATE_FRAGMENT_PROGRAM\n");
/* Copy SPU code from batch buffer to spu buffer */
memcpy(spu.fragment_program_code, fp->code,
SPU_MAX_FRAGMENT_PROGRAM_INSTS * 4);
#if 01
/* Point function pointer at new code */
spu.fragment_program = (spu_fragment_program_func)spu.fragment_program_code;
#endif
}
static uint
cmd_state_fs_constants(const qword *buffer, uint pos)
{
const uint num_const = spu_extract((vector unsigned int)buffer[pos+1], 0);
const float *constants = (const float *) &buffer[pos+2];
uint i;
D_PRINTF(CELL_DEBUG_CMD, "CMD_STATE_FS_CONSTANTS (%u)\n", num_const);
/* Expand each float to float[4] for SOA execution */
for (i = 0; i < num_const; i++) {
D_PRINTF(CELL_DEBUG_CMD, " const[%u] = %f\n", i, constants[i]);
spu.constants[i] = spu_splats(constants[i]);
}
/* return new buffer pos (in 16-byte words) */
return pos + 2 + (ROUNDUP16(num_const * sizeof(float)) / 16);
}
static void
cmd_state_framebuffer(const struct cell_command_framebuffer *cmd)
{
D_PRINTF(CELL_DEBUG_CMD, "FRAMEBUFFER: %d x %d at %p, cformat 0x%x zformat 0x%x\n",
cmd->width,
cmd->height,
cmd->color_start,
cmd->color_format,
cmd->depth_format);
ASSERT_ALIGN16(cmd->color_start);
ASSERT_ALIGN16(cmd->depth_start);
spu.fb.color_start = cmd->color_start;
spu.fb.depth_start = cmd->depth_start;
spu.fb.color_format = cmd->color_format;
spu.fb.depth_format = cmd->depth_format;
spu.fb.width = cmd->width;
spu.fb.height = cmd->height;
spu.fb.width_tiles = (spu.fb.width + TILE_SIZE - 1) / TILE_SIZE;
spu.fb.height_tiles = (spu.fb.height + TILE_SIZE - 1) / TILE_SIZE;
switch (spu.fb.depth_format) {
case PIPE_FORMAT_Z32_UNORM:
spu.fb.zsize = 4;
spu.fb.zscale = (float) 0xffffffffu;
break;
case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
case PIPE_FORMAT_X8Z24_UNORM:
case PIPE_FORMAT_Z24X8_UNORM:
spu.fb.zsize = 4;
spu.fb.zscale = (float) 0x00ffffffu;
break;
case PIPE_FORMAT_Z16_UNORM:
spu.fb.zsize = 2;
spu.fb.zscale = (float) 0xffffu;
break;
default:
spu.fb.zsize = 0;
break;
}
}
/**
* Tex texture mask_s/t and scale_s/t fields depend on the texture size and
* sampler wrap modes.
*/
static void
update_tex_masks(struct spu_texture *texture,
const struct pipe_sampler_state *sampler)
{
uint i;
for (i = 0; i < CELL_MAX_TEXTURE_LEVELS; i++) {
int width = texture->level[i].width;
int height = texture->level[i].height;
if (sampler->wrap_s == PIPE_TEX_WRAP_REPEAT)
texture->level[i].mask_s = spu_splats(width - 1);
else
texture->level[i].mask_s = spu_splats(~0);
if (sampler->wrap_t == PIPE_TEX_WRAP_REPEAT)
texture->level[i].mask_t = spu_splats(height - 1);
else
texture->level[i].mask_t = spu_splats(~0);
if (sampler->normalized_coords) {
texture->level[i].scale_s = spu_splats((float) width);
texture->level[i].scale_t = spu_splats((float) height);
}
else {
texture->level[i].scale_s = spu_splats(1.0f);
texture->level[i].scale_t = spu_splats(1.0f);
}
}
}
static void
cmd_state_sampler(const struct cell_command_sampler *sampler)
{
uint unit = sampler->unit;
D_PRINTF(CELL_DEBUG_CMD, "SAMPLER [%u]\n", unit);
spu.sampler[unit] = sampler->state;
switch (spu.sampler[unit].min_img_filter) {
case PIPE_TEX_FILTER_LINEAR:
spu.min_sample_texture_2d[unit] = sample_texture_2d_bilinear;
break;
case PIPE_TEX_FILTER_NEAREST:
spu.min_sample_texture_2d[unit] = sample_texture_2d_nearest;
break;
default:
ASSERT(0);
}
switch (spu.sampler[sampler->unit].mag_img_filter) {
case PIPE_TEX_FILTER_LINEAR:
spu.mag_sample_texture_2d[unit] = sample_texture_2d_bilinear;
break;
case PIPE_TEX_FILTER_NEAREST:
spu.mag_sample_texture_2d[unit] = sample_texture_2d_nearest;
break;
default:
ASSERT(0);
}
switch (spu.sampler[sampler->unit].min_mip_filter) {
case PIPE_TEX_MIPFILTER_NEAREST:
case PIPE_TEX_MIPFILTER_LINEAR:
spu.sample_texture_2d[unit] = sample_texture_2d_lod;
break;
case PIPE_TEX_MIPFILTER_NONE:
spu.sample_texture_2d[unit] = spu.mag_sample_texture_2d[unit];
break;
default:
ASSERT(0);
}
update_tex_masks(&spu.texture[unit], &spu.sampler[unit]);
}
static void
cmd_state_texture(const struct cell_command_texture *texture)
{
const uint unit = texture->unit;
uint i;
D_PRINTF(CELL_DEBUG_CMD, "TEXTURE [%u]\n", texture->unit);
spu.texture[unit].max_level = 0;
spu.texture[unit].target = texture->target;
for (i = 0; i < CELL_MAX_TEXTURE_LEVELS; i++) {
uint width = texture->width[i];
uint height = texture->height[i];
uint depth = texture->depth[i];
D_PRINTF(CELL_DEBUG_CMD, " LEVEL %u: at %p size[0] %u x %u\n", i,
texture->start[i], texture->width[i], texture->height[i]);
spu.texture[unit].level[i].start = texture->start[i];
spu.texture[unit].level[i].width = width;
spu.texture[unit].level[i].height = height;
spu.texture[unit].level[i].depth = depth;
spu.texture[unit].level[i].tiles_per_row =
(width + TILE_SIZE - 1) / TILE_SIZE;
spu.texture[unit].level[i].bytes_per_image =
4 * align(width, TILE_SIZE) * align(height, TILE_SIZE) * depth;
spu.texture[unit].level[i].max_s = spu_splats((int) width - 1);
spu.texture[unit].level[i].max_t = spu_splats((int) height - 1);
if (texture->start[i])
spu.texture[unit].max_level = i;
}
update_tex_masks(&spu.texture[unit], &spu.sampler[unit]);
}
static void
cmd_state_vertex_info(const struct vertex_info *vinfo)
{
D_PRINTF(CELL_DEBUG_CMD, "VERTEX_INFO num_attribs=%u\n", vinfo->num_attribs);
ASSERT(vinfo->num_attribs >= 1);
ASSERT(vinfo->num_attribs <= 8);
memcpy(&spu.vertex_info, vinfo, sizeof(*vinfo));
}
static void
cmd_state_vs_array_info(const struct cell_array_info *vs_info)
{
const unsigned attr = vs_info->attr;
ASSERT(attr < PIPE_MAX_ATTRIBS);
draw.vertex_fetch.src_ptr[attr] = vs_info->base;
draw.vertex_fetch.pitch[attr] = vs_info->pitch;
draw.vertex_fetch.size[attr] = vs_info->size;
draw.vertex_fetch.code_offset[attr] = vs_info->function_offset;
draw.vertex_fetch.dirty = 1;
}
static void
cmd_state_attrib_fetch(const struct cell_attribute_fetch_code *code)
{
mfc_get(attribute_fetch_code_buffer,
(unsigned int) code->base, /* src */
code->size,
TAG_BATCH_BUFFER,
0, /* tid */
0 /* rid */);
wait_on_mask(1 << TAG_BATCH_BUFFER);
draw.vertex_fetch.code = attribute_fetch_code_buffer;
}
static void
cmd_finish(void)
{
D_PRINTF(CELL_DEBUG_CMD, "FINISH\n");
really_clear_tiles(0);
/* wait for all outstanding DMAs to finish */
mfc_write_tag_mask(~0);
mfc_read_tag_status_all();
/* send mbox message to PPU */
spu_write_out_mbox(CELL_CMD_FINISH);
}
/**
* Execute a batch of commands which was sent to us by the PPU.
* See the cell_emit_state.c code to see where the commands come from.
*
* The opcode param encodes the location of the buffer and its size.
*/
static void
cmd_batch(uint opcode)
{
const uint buf = (opcode >> 8) & 0xff;
uint size = (opcode >> 16);
PIPE_ALIGN_VAR(16) qword buffer[CELL_BUFFER_SIZE / 16];
const unsigned usize = ROUNDUP16(size) / sizeof(buffer[0]);
uint pos;
D_PRINTF(CELL_DEBUG_CMD, "BATCH buffer %u, len %u, from %p\n",
buf, size, spu.init.buffers[buf]);
ASSERT((opcode & CELL_CMD_OPCODE_MASK) == CELL_CMD_BATCH);
ASSERT_ALIGN16(spu.init.buffers[buf]);
size = ROUNDUP16(size);
ASSERT_ALIGN16(spu.init.buffers[buf]);
mfc_get(buffer, /* dest */
(unsigned int) spu.init.buffers[buf], /* src */
size,
TAG_BATCH_BUFFER,
0, /* tid */
0 /* rid */);
wait_on_mask(1 << TAG_BATCH_BUFFER);
/* Tell PPU we're done copying the buffer to local store */
D_PRINTF(CELL_DEBUG_CMD, "release batch buf %u\n", buf);
release_buffer(buf);
/*
* Loop over commands in the batch buffer
*/
for (pos = 0; pos < usize; /* no incr */) {
switch (si_to_uint(buffer[pos])) {
/*
* rendering commands
*/
case CELL_CMD_CLEAR_SURFACE:
{
struct cell_command_clear_surface *clr
= (struct cell_command_clear_surface *) &buffer[pos];
cmd_clear_surface(clr);
pos += sizeof(*clr) / 16;
}
break;
case CELL_CMD_RENDER:
{
struct cell_command_render *render
= (struct cell_command_render *) &buffer[pos];
uint pos_incr;
cmd_render(render, &pos_incr);
pos += ((pos_incr+1)&~1) / 2; // should 'fix' cmd_render return
}
break;
/*
* state-update commands
*/
case CELL_CMD_STATE_FRAMEBUFFER:
{
struct cell_command_framebuffer *fb
= (struct cell_command_framebuffer *) &buffer[pos];
cmd_state_framebuffer(fb);
pos += sizeof(*fb) / 16;
}
break;
case CELL_CMD_STATE_FRAGMENT_OPS:
{
struct cell_command_fragment_ops *fops
= (struct cell_command_fragment_ops *) &buffer[pos];
cmd_state_fragment_ops(fops);
/* This is a variant-sized command */
pos += ROUNDUP16(sizeof(*fops) + fops->total_code_size) / 16;
}
break;
case CELL_CMD_STATE_FRAGMENT_PROGRAM:
{
struct cell_command_fragment_program *fp
= (struct cell_command_fragment_program *) &buffer[pos];
cmd_state_fragment_program(fp);
pos += sizeof(*fp) / 16;
}
break;
case CELL_CMD_STATE_FS_CONSTANTS:
pos = cmd_state_fs_constants(buffer, pos);
break;
case CELL_CMD_STATE_RASTERIZER:
{
struct cell_command_rasterizer *rast =
(struct cell_command_rasterizer *) &buffer[pos];
spu.rasterizer = rast->rasterizer;
pos += sizeof(*rast) / 16;
}
break;
case CELL_CMD_STATE_SAMPLER:
{
struct cell_command_sampler *sampler
= (struct cell_command_sampler *) &buffer[pos];
cmd_state_sampler(sampler);
pos += sizeof(*sampler) / 16;
}
break;
case CELL_CMD_STATE_TEXTURE:
{
struct cell_command_texture *texture
= (struct cell_command_texture *) &buffer[pos];
cmd_state_texture(texture);
pos += sizeof(*texture) / 16;
}
break;
case CELL_CMD_STATE_VERTEX_INFO:
cmd_state_vertex_info((struct vertex_info *) &buffer[pos+1]);
pos += 1 + ROUNDUP16(sizeof(struct vertex_info)) / 16;
break;
case CELL_CMD_STATE_VIEWPORT:
(void) memcpy(& draw.viewport, &buffer[pos+1],
sizeof(struct pipe_viewport_state));
pos += 1 + ROUNDUP16(sizeof(struct pipe_viewport_state)) / 16;
break;
case CELL_CMD_STATE_UNIFORMS:
draw.constants = (const float (*)[4]) (uintptr_t)spu_extract((vector unsigned int)buffer[pos+1],0);
pos += 2;
break;
case CELL_CMD_STATE_VS_ARRAY_INFO:
cmd_state_vs_array_info((struct cell_array_info *) &buffer[pos+1]);
pos += 1 + ROUNDUP16(sizeof(struct cell_array_info)) / 16;
break;
case CELL_CMD_STATE_BIND_VS:
#if 0
spu_bind_vertex_shader(&draw,
(struct cell_shader_info *) &buffer[pos+1]);
#endif
pos += 1 + ROUNDUP16(sizeof(struct cell_shader_info)) / 16;
break;
case CELL_CMD_STATE_ATTRIB_FETCH:
cmd_state_attrib_fetch((struct cell_attribute_fetch_code *)
&buffer[pos+1]);
pos += 1 + ROUNDUP16(sizeof(struct cell_attribute_fetch_code)) / 16;
break;
/*
* misc commands
*/
case CELL_CMD_FINISH:
cmd_finish();
pos += 1;
break;
case CELL_CMD_FENCE:
{
struct cell_command_fence *fence_cmd =
(struct cell_command_fence *) &buffer[pos];
cmd_fence(fence_cmd);
pos += sizeof(*fence_cmd) / 16;
}
break;
case CELL_CMD_RELEASE_VERTS:
{
struct cell_command_release_verts *release
= (struct cell_command_release_verts *) &buffer[pos];
cmd_release_verts(release);
pos += sizeof(*release) / 16;
}
break;
case CELL_CMD_FLUSH_BUFFER_RANGE: {
struct cell_buffer_range *br = (struct cell_buffer_range *)
&buffer[pos+1];
spu_dcache_mark_dirty((unsigned) br->base, br->size);
pos += 1 + ROUNDUP16(sizeof(struct cell_buffer_range)) / 16;
break;
}
default:
printf("SPU %u: bad opcode: 0x%x\n", spu.init.id, si_to_uint(buffer[pos]));
ASSERT(0);
break;
}
}
D_PRINTF(CELL_DEBUG_CMD, "BATCH complete\n");
}
#define PERF 0
/**
* Main loop for SPEs: Get a command, execute it, repeat.
*/
void
command_loop(void)
{
int exitFlag = 0;
uint t0, t1;
D_PRINTF(CELL_DEBUG_CMD, "Enter command loop\n");
while (!exitFlag) {
unsigned opcode;
D_PRINTF(CELL_DEBUG_CMD, "Wait for cmd...\n");
if (PERF)
spu_write_decrementer(~0);
/* read/wait from mailbox */
opcode = (unsigned int) spu_read_in_mbox();
D_PRINTF(CELL_DEBUG_CMD, "got cmd 0x%x\n", opcode);
if (PERF)
t0 = spu_read_decrementer();
switch (opcode & CELL_CMD_OPCODE_MASK) {
case CELL_CMD_EXIT:
D_PRINTF(CELL_DEBUG_CMD, "EXIT\n");
exitFlag = 1;
break;
case CELL_CMD_VS_EXECUTE:
#if 0
spu_execute_vertex_shader(&draw, &cmd.vs);
#endif
break;
case CELL_CMD_BATCH:
cmd_batch(opcode);
break;
default:
printf("Bad opcode 0x%x!\n", opcode & CELL_CMD_OPCODE_MASK);
}
if (PERF) {
t1 = spu_read_decrementer();
printf("wait mbox time: %gms batch time: %gms\n",
(~0u - t0) * spu.init.inv_timebase,
(t0 - t1) * spu.init.inv_timebase);
}
}
D_PRINTF(CELL_DEBUG_CMD, "Exit command loop\n");
if (spu.init.debug_flags & CELL_DEBUG_CACHE)
spu_dcache_report();
}
/* Initialize this module; we manage the fragment ops buffer here. */
void
spu_command_init(void)
{
/* Install default/fallback fragment processing function.
* This will normally be overriden by a code-gen'd function
* unless CELL_FORCE_FRAGMENT_OPS_FALLBACK is set.
*/
spu.fragment_ops[CELL_FACING_FRONT] = spu_fallback_fragment_ops;
spu.fragment_ops[CELL_FACING_BACK] = spu_fallback_fragment_ops;
/* Set up the basic empty buffer for code-gen'ed fragment ops */
spu.fragment_ops_code = NULL;
spu.fragment_ops_code_size = 0;
}
void
spu_command_close(void)
{
/* Deallocate the code-gen buffer for fragment ops, and reset the
* fragment ops functions to their initial setting (just to leave
* things in a good state).
*/
if (spu.fragment_ops_code != NULL) {
free(spu.fragment_ops_code);
}
spu_command_init();
}
| 31.292232 | 132 | 0.632832 |
fa980495ab42c6fc2fb8c9073bd5360c0ba9b2cb | 1,030 | h | C | usr/libexec/speechmodeltrainingd/SMTGlobalNNLM.h | lechium/tvOS145Headers | 9940da19adb0017f8037853e9cfccbe01b290dd5 | [
"MIT"
] | 5 | 2021-04-29T04:31:43.000Z | 2021-08-19T18:59:58.000Z | usr/libexec/speechmodeltrainingd/SMTGlobalNNLM.h | lechium/tvOS145Headers | 9940da19adb0017f8037853e9cfccbe01b290dd5 | [
"MIT"
] | null | null | null | usr/libexec/speechmodeltrainingd/SMTGlobalNNLM.h | lechium/tvOS145Headers | 9940da19adb0017f8037853e9cfccbe01b290dd5 | [
"MIT"
] | 1 | 2022-03-19T11:16:23.000Z | 2022-03-19T11:16:23.000Z | //
// Generated by classdumpios 1.0.1 (64 bit) (iOS port by DreamDevLost)(Debug version compiled Sep 26 2020 13:48:20).
//
// Copyright (C) 1997-2019 Steve Nygard.
//
#import <objc/NSObject.h>
@protocol OS_dispatch_queue;
@interface SMTGlobalNNLM : NSObject
{
NSObject<OS_dispatch_queue> *_queue; // 8 = 0x8
_Bool _shouldStop; // 16 = 0x10
}
+ (void)initialize; // IMP=0x0000000100007868
- (void).cxx_destruct; // IMP=0x0000000100007c4c
@property _Bool shouldStop; // @synthesize shouldStop=_shouldStop;
- (void)trainModelWithRecipe:(id)arg1 attachments:(id)arg2 coreduetData:(id)arg3 completion:(CDUnknownBlockType)arg4; // IMP=0x0000000100007aac
- (void)cancel; // IMP=0x0000000100007a34
- (void)readCoreDuetData:(id)arg1 completion:(CDUnknownBlockType)arg2; // IMP=0x00000001000079dc
- (id)deviceFormattedlanguage:(id)arg1; // IMP=0x000000010000795c
- (id)compressedAttachmentURLFromRecipe:(id)arg1 attachments:(id)arg2; // IMP=0x0000000100007958
- (id)initWithQueue:(id)arg1; // IMP=0x00000001000078c8
@end
| 35.517241 | 143 | 0.754369 |
7a8b43978da8ca560a21ad4f33c6110afc355d09 | 113 | h | C | JobExplorer/SecurityHelper.h | IMULMUL/JobExplorer | 15702eef6a8c3d588d51138b923cc433b9352b64 | [
"MIT"
] | 56 | 2019-08-23T23:02:52.000Z | 2022-03-31T16:11:18.000Z | JobExplorer/SecurityHelper.h | IMULMUL/JobExplorer | 15702eef6a8c3d588d51138b923cc433b9352b64 | [
"MIT"
] | 1 | 2021-10-09T10:41:15.000Z | 2021-10-09T10:41:15.000Z | JobExplorer/SecurityHelper.h | IMULMUL/JobExplorer | 15702eef6a8c3d588d51138b923cc433b9352b64 | [
"MIT"
] | 17 | 2019-08-24T01:10:09.000Z | 2022-03-07T04:18:08.000Z | #pragma once
struct SecurityHelper final {
static bool IsRunningElevated();
static HICON GetShieldIcon();
};
| 14.125 | 33 | 0.761062 |
a3f73a1ef9727c2cfda74b2f3c56fff502f5f82d | 227 | h | C | src/ios/PushEnabled.h | antonfire/cordova-push-enabled | 887f07479266694d903add7a44038cdf3448c1ac | [
"MIT"
] | null | null | null | src/ios/PushEnabled.h | antonfire/cordova-push-enabled | 887f07479266694d903add7a44038cdf3448c1ac | [
"MIT"
] | null | null | null | src/ios/PushEnabled.h | antonfire/cordova-push-enabled | 887f07479266694d903add7a44038cdf3448c1ac | [
"MIT"
] | null | null | null | //
// PushEnabled.h
//
#import <Cordova/CDVPlugin.h>
#import <Foundation/Foundation.h>
@interface PushEnabled : CDVPlugin
@property (copy) NSString* callbackId;
- (void) checkStatus:(CDVInvokedUrlCommand *)command;
@end
| 16.214286 | 53 | 0.731278 |
d8d96c8a670426a9aaf06f42d39105e3fa6a335b | 224 | h | C | CMSIS/NN/Tests/UnitTest/TestCases/TestData/kernel1x1/output_shift_data.h | shosakam/CMSIS_5 | 18205c6c2b68e7e96f40dc941c47efdbdd9f7d01 | [
"Apache-2.0"
] | 2 | 2021-12-14T02:15:35.000Z | 2021-12-14T02:16:12.000Z | CMSIS/NN/Tests/UnitTest/TestCases/TestData/kernel1x1/output_shift_data.h | shosakam/CMSIS_5 | 18205c6c2b68e7e96f40dc941c47efdbdd9f7d01 | [
"Apache-2.0"
] | null | null | null | CMSIS/NN/Tests/UnitTest/TestCases/TestData/kernel1x1/output_shift_data.h | shosakam/CMSIS_5 | 18205c6c2b68e7e96f40dc941c47efdbdd9f7d01 | [
"Apache-2.0"
] | null | null | null | // Generated by generate_test_data.py using TFL version 2.6.0 as reference.
#pragma once
#include <stdint.h>
const int32_t kernel1x1_output_shift[17] = {-10, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9};
| 37.333333 | 113 | 0.616071 |
1a648980ba4339e805a4738a2227d9a613919c83 | 260 | h | C | LineChart/LineViewController.h | fanfan19920219/ScrollviewZoom | 625486b838e95376b13daa366fb944cb803f16ba | [
"Apache-2.0"
] | null | null | null | LineChart/LineViewController.h | fanfan19920219/ScrollviewZoom | 625486b838e95376b13daa366fb944cb803f16ba | [
"Apache-2.0"
] | null | null | null | LineChart/LineViewController.h | fanfan19920219/ScrollviewZoom | 625486b838e95376b13daa366fb944cb803f16ba | [
"Apache-2.0"
] | null | null | null | //
// LineViewController.h
// NewMedSci
//
// Created by M-SJ077 on 16/7/6.
// Copyright © 2016年 MedSci. All rights reserved.
//
#import <UIKit/UIKit.h>
@interface LineViewController : UIViewController
@property (nonatomic , strong)NSString *jid;
@end
| 16.25 | 50 | 0.703846 |
94f7f109e9529033fa1ce55d32bf0f767e91fa5e | 717 | h | C | arduino/main/ui.h | asemchenko/PassToken | 890a2491be1422bec203c1b3cb374e3e5a1bd55f | [
"Apache-2.0"
] | null | null | null | arduino/main/ui.h | asemchenko/PassToken | 890a2491be1422bec203c1b3cb374e3e5a1bd55f | [
"Apache-2.0"
] | null | null | null | arduino/main/ui.h | asemchenko/PassToken | 890a2491be1422bec203c1b3cb374e3e5a1bd55f | [
"Apache-2.0"
] | null | null | null | #ifndef UI_H
#define UI_H
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include "persistent.h"
extern Adafruit_SSD1306 display;
/**
* @brief User interface with display and three buttons (up, down & ok).
*/
class UI
{
public:
UI();
void init_display();
size_t show_menu(const char **entries, size_t number, size_t selected = 0);
unsigned long prompt_number(const char *prompt);
void show_message(const char *title, const char *detailed = nullptr, int duration = 2000);
void turn_over();
private:
enum class Button { Ok, Up, Down };
PersistentScalar<int> right_oriented = PersistentScalar<int>(0x0a);
Button wait_click();
};
#endif // UI_H
| 17.925 | 94 | 0.67643 |
b1406c4646ec5ea4aee2a3146c3e0ad5cc20fe72 | 2,997 | h | C | src/dev/rtcreg.h | volnxebec/CC_Fused | e2b805e3475bd275409379c41eaeeb1a565cbdef | [
"BSD-3-Clause"
] | 11 | 2015-03-21T13:35:06.000Z | 2022-01-27T07:31:52.000Z | src/dev/rtcreg.h | volnxebec/CC_Fused | e2b805e3475bd275409379c41eaeeb1a565cbdef | [
"BSD-3-Clause"
] | 4 | 2015-01-13T18:27:31.000Z | 2015-01-13T18:27:57.000Z | src/dev/rtcreg.h | volnxebec/CC_Fused | e2b805e3475bd275409379c41eaeeb1a565cbdef | [
"BSD-3-Clause"
] | 4 | 2015-03-21T13:35:24.000Z | 2020-06-30T02:09:36.000Z | /*
* Copyright (c) 2005 The Regents of The University of Michigan
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Authors: Ali Saidi
* Miguel Serrano
* Nathan Binkert
*/
static const int RTC_SEC = 0x00;
static const int RTC_SEC_ALRM = 0x01;
static const int RTC_MIN = 0x02;
static const int RTC_MIN_ALRM = 0x03;
static const int RTC_HR = 0x04;
static const int RTC_HR_ALRM = 0x05;
static const int RTC_DOW = 0x06;
static const int RTC_DOM = 0x07;
static const int RTC_MON = 0x08;
static const int RTC_YEAR = 0x09;
static const int RTC_STAT_REGA = 0x0A;
static const int RTCA_1024HZ = 0x06; /* 1024Hz periodic interrupt frequency */
static const int RTCA_32768HZ = 0x20; /* 22-stage divider, 32.768KHz timebase */
static const int RTCA_UIP = 0x80; /* 1 = date and time update in progress */
static const int RTC_STAT_REGB = 0x0B;
static const int RTCB_DST = 0x01; /* USA Daylight Savings Time enable */
static const int RTCB_24HR = 0x02; /* 0 = 12 hours, 1 = 24 hours */
static const int RTCB_BIN = 0x04; /* 0 = BCD, 1 = Binary coded time */
static const int RTCB_SQWE = 0x08; /* 1 = output sqare wave at SQW pin */
static const int RTCB_UPDT_IE = 0x10; /* 1 = enable update-ended interrupt */
static const int RTCB_ALRM_IE = 0x20; /* 1 = enable alarm interrupt */
static const int RTCB_PRDC_IE = 0x40; /* 1 = enable periodic clock interrupt */
static const int RTCB_NO_UPDT = 0x80; /* stop clock updates */
static const int RTC_STAT_REGC = 0x0C;
static const int RTC_STAT_REGD = 0x0D;
| 48.33871 | 80 | 0.748749 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.