diff --git a/docs/dochack.js b/docs/dochack.js new file mode 100644 index 0000000..6f0a993 --- /dev/null +++ b/docs/dochack.js @@ -0,0 +1,1961 @@ +/* Generated by the Nim Compiler v1.3.1 */ +var framePtr = null; +var excHandler = 0; +var lastJSError = null; +if (typeof Int8Array === 'undefined') Int8Array = Array; +if (typeof Int16Array === 'undefined') Int16Array = Array; +if (typeof Int32Array === 'undefined') Int32Array = Array; +if (typeof Uint8Array === 'undefined') Uint8Array = Array; +if (typeof Uint16Array === 'undefined') Uint16Array = Array; +if (typeof Uint32Array === 'undefined') Uint32Array = Array; +if (typeof Float32Array === 'undefined') Float32Array = Array; +if (typeof Float64Array === 'undefined') Float64Array = Array; +var NTI1163065 = {size: 0,kind: 1,base: null,node: null,finalizer: null}; +var NTI10846058 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI1169053 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI11000571 = {size: 0,kind: 24,base: null,node: null,finalizer: null}; +var NTI1787454 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787450 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787446 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787442 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787438 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787434 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787430 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787426 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787422 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787418 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787414 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787410 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787406 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787402 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787398 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787394 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787390 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787386 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787382 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787378 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787205 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI1787289 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI1787287 = {size: 0,kind: 22,base: null,node: null,finalizer: null}; +var NTI1787229 = {size: 0, kind: 14, base: null, node: null, finalizer: null}; +var NTI1787574 = {size: 0,kind: 24,base: null,node: null,finalizer: null}; +var NTI1787572 = {size: 0,kind: 24,base: null,node: null,finalizer: null}; +var NTI1787570 = {size: 0,kind: 24,base: null,node: null,finalizer: null}; +var NTI1787233 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI1787231 = {size: 0,kind: 22,base: null,node: null,finalizer: null}; +var NTI1789105 = {size: 0,kind: 24,base: null,node: null,finalizer: null}; +var NTI1169041 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI1169049 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI1163045 = {size: 0,kind: 31,base: null,node: null,finalizer: null}; +var NTI1325043 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI1168808 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI1169086 = {size: 0,kind: 22,base: null,node: null,finalizer: null}; +var NTI1163014 = {size: 0,kind: 28,base: null,node: null,finalizer: null}; +var NTI1163016 = {size: 0,kind: 29,base: null,node: null,finalizer: null}; +var NTI1169081 = {size: 0,kind: 22,base: null,node: null,finalizer: null}; +var NTI1169017 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI1169019 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI1169033 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI1169037 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NNI1169037 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI1169037.node = NNI1169037; +var NNI1169033 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI1169033.node = NNI1169033; +var NNI1169019 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI1169019.node = NNI1169019; +NTI1169081.base = NTI1169017; +NTI1169086.base = NTI1169017; +var NNI1169017 = {kind: 2, len: 5, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "parent", len: 0, typ: NTI1169081, name: "parent", sons: null}, +{kind: 1, offset: "name", len: 0, typ: NTI1163016, name: "name", sons: null}, +{kind: 1, offset: "message", len: 0, typ: NTI1163014, name: "msg", sons: null}, +{kind: 1, offset: "trace", len: 0, typ: NTI1163014, name: "trace", sons: null}, +{kind: 1, offset: "up", len: 0, typ: NTI1169086, name: "up", sons: null}]}; +NTI1169017.node = NNI1169017; +var NNI1168808 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI1168808.node = NNI1168808; +NTI1169017.base = NTI1168808; +NTI1169019.base = NTI1169017; +NTI1169033.base = NTI1169019; +NTI1169037.base = NTI1169033; +var NNI1325043 = {kind: 2, len: 2, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "Field0", len: 0, typ: NTI1163016, name: "Field0", sons: null}, +{kind: 1, offset: "Field1", len: 0, typ: NTI1163045, name: "Field1", sons: null}]}; +NTI1325043.node = NNI1325043; +var NNI1169049 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI1169049.node = NNI1169049; +NTI1169049.base = NTI1169019; +var NNI1169041 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI1169041.node = NNI1169041; +NTI1169041.base = NTI1169019; +NTI1787570.base = NTI1787231; +NTI1787572.base = NTI1787231; +NTI1787574.base = NTI1787231; +var NNI1787229 = {kind: 2, offset: 0, typ: null, name: null, len: 12, sons: {"1": {kind: 1, offset: 1, typ: NTI1787229, name: "ElementNode", len: 0, sons: null}, +"2": {kind: 1, offset: 2, typ: NTI1787229, name: "AttributeNode", len: 0, sons: null}, +"3": {kind: 1, offset: 3, typ: NTI1787229, name: "TextNode", len: 0, sons: null}, +"4": {kind: 1, offset: 4, typ: NTI1787229, name: "CDATANode", len: 0, sons: null}, +"5": {kind: 1, offset: 5, typ: NTI1787229, name: "EntityRefNode", len: 0, sons: null}, +"6": {kind: 1, offset: 6, typ: NTI1787229, name: "EntityNode", len: 0, sons: null}, +"7": {kind: 1, offset: 7, typ: NTI1787229, name: "ProcessingInstructionNode", len: 0, sons: null}, +"8": {kind: 1, offset: 8, typ: NTI1787229, name: "CommentNode", len: 0, sons: null}, +"9": {kind: 1, offset: 9, typ: NTI1787229, name: "DocumentNode", len: 0, sons: null}, +"10": {kind: 1, offset: 10, typ: NTI1787229, name: "DocumentTypeNode", len: 0, sons: null}, +"11": {kind: 1, offset: 11, typ: NTI1787229, name: "DocumentFragmentNode", len: 0, sons: null}, +"12": {kind: 1, offset: 12, typ: NTI1787229, name: "NotationNode", len: 0, sons: null}}}; +NTI1787229.node = NNI1787229; +var NNI1787289 = {kind: 2, len: 100, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "background", len: 0, typ: NTI1163016, name: "background", sons: null}, +{kind: 1, offset: "backgroundAttachment", len: 0, typ: NTI1163016, name: "backgroundAttachment", sons: null}, +{kind: 1, offset: "backgroundColor", len: 0, typ: NTI1163016, name: "backgroundColor", sons: null}, +{kind: 1, offset: "backgroundImage", len: 0, typ: NTI1163016, name: "backgroundImage", sons: null}, +{kind: 1, offset: "backgroundPosition", len: 0, typ: NTI1163016, name: "backgroundPosition", sons: null}, +{kind: 1, offset: "backgroundRepeat", len: 0, typ: NTI1163016, name: "backgroundRepeat", sons: null}, +{kind: 1, offset: "backgroundSize", len: 0, typ: NTI1163016, name: "backgroundSize", sons: null}, +{kind: 1, offset: "border", len: 0, typ: NTI1163016, name: "border", sons: null}, +{kind: 1, offset: "borderBottom", len: 0, typ: NTI1163016, name: "borderBottom", sons: null}, +{kind: 1, offset: "borderBottomColor", len: 0, typ: NTI1163016, name: "borderBottomColor", sons: null}, +{kind: 1, offset: "borderBottomStyle", len: 0, typ: NTI1163016, name: "borderBottomStyle", sons: null}, +{kind: 1, offset: "borderBottomWidth", len: 0, typ: NTI1163016, name: "borderBottomWidth", sons: null}, +{kind: 1, offset: "borderColor", len: 0, typ: NTI1163016, name: "borderColor", sons: null}, +{kind: 1, offset: "borderLeft", len: 0, typ: NTI1163016, name: "borderLeft", sons: null}, +{kind: 1, offset: "borderLeftColor", len: 0, typ: NTI1163016, name: "borderLeftColor", sons: null}, +{kind: 1, offset: "borderLeftStyle", len: 0, typ: NTI1163016, name: "borderLeftStyle", sons: null}, +{kind: 1, offset: "borderLeftWidth", len: 0, typ: NTI1163016, name: "borderLeftWidth", sons: null}, +{kind: 1, offset: "borderRadius", len: 0, typ: NTI1163016, name: "borderRadius", sons: null}, +{kind: 1, offset: "borderRight", len: 0, typ: NTI1163016, name: "borderRight", sons: null}, +{kind: 1, offset: "borderRightColor", len: 0, typ: NTI1163016, name: "borderRightColor", sons: null}, +{kind: 1, offset: "borderRightStyle", len: 0, typ: NTI1163016, name: "borderRightStyle", sons: null}, +{kind: 1, offset: "borderRightWidth", len: 0, typ: NTI1163016, name: "borderRightWidth", sons: null}, +{kind: 1, offset: "borderStyle", len: 0, typ: NTI1163016, name: "borderStyle", sons: null}, +{kind: 1, offset: "borderTop", len: 0, typ: NTI1163016, name: "borderTop", sons: null}, +{kind: 1, offset: "borderTopColor", len: 0, typ: NTI1163016, name: "borderTopColor", sons: null}, +{kind: 1, offset: "borderTopStyle", len: 0, typ: NTI1163016, name: "borderTopStyle", sons: null}, +{kind: 1, offset: "borderTopWidth", len: 0, typ: NTI1163016, name: "borderTopWidth", sons: null}, +{kind: 1, offset: "borderWidth", len: 0, typ: NTI1163016, name: "borderWidth", sons: null}, +{kind: 1, offset: "bottom", len: 0, typ: NTI1163016, name: "bottom", sons: null}, +{kind: 1, offset: "boxSizing", len: 0, typ: NTI1163016, name: "boxSizing", sons: null}, +{kind: 1, offset: "boxShadow", len: 0, typ: NTI1163016, name: "boxShadow", sons: null}, +{kind: 1, offset: "captionSide", len: 0, typ: NTI1163016, name: "captionSide", sons: null}, +{kind: 1, offset: "clear", len: 0, typ: NTI1163016, name: "clear", sons: null}, +{kind: 1, offset: "clip", len: 0, typ: NTI1163016, name: "clip", sons: null}, +{kind: 1, offset: "color", len: 0, typ: NTI1163016, name: "color", sons: null}, +{kind: 1, offset: "cursor", len: 0, typ: NTI1163016, name: "cursor", sons: null}, +{kind: 1, offset: "direction", len: 0, typ: NTI1163016, name: "direction", sons: null}, +{kind: 1, offset: "display", len: 0, typ: NTI1163016, name: "display", sons: null}, +{kind: 1, offset: "emptyCells", len: 0, typ: NTI1163016, name: "emptyCells", sons: null}, +{kind: 1, offset: "cssFloat", len: 0, typ: NTI1163016, name: "cssFloat", sons: null}, +{kind: 1, offset: "font", len: 0, typ: NTI1163016, name: "font", sons: null}, +{kind: 1, offset: "fontFamily", len: 0, typ: NTI1163016, name: "fontFamily", sons: null}, +{kind: 1, offset: "fontSize", len: 0, typ: NTI1163016, name: "fontSize", sons: null}, +{kind: 1, offset: "fontStretch", len: 0, typ: NTI1163016, name: "fontStretch", sons: null}, +{kind: 1, offset: "fontStyle", len: 0, typ: NTI1163016, name: "fontStyle", sons: null}, +{kind: 1, offset: "fontVariant", len: 0, typ: NTI1163016, name: "fontVariant", sons: null}, +{kind: 1, offset: "fontWeight", len: 0, typ: NTI1163016, name: "fontWeight", sons: null}, +{kind: 1, offset: "height", len: 0, typ: NTI1163016, name: "height", sons: null}, +{kind: 1, offset: "left", len: 0, typ: NTI1163016, name: "left", sons: null}, +{kind: 1, offset: "letterSpacing", len: 0, typ: NTI1163016, name: "letterSpacing", sons: null}, +{kind: 1, offset: "lineHeight", len: 0, typ: NTI1163016, name: "lineHeight", sons: null}, +{kind: 1, offset: "listStyle", len: 0, typ: NTI1163016, name: "listStyle", sons: null}, +{kind: 1, offset: "listStyleImage", len: 0, typ: NTI1163016, name: "listStyleImage", sons: null}, +{kind: 1, offset: "listStylePosition", len: 0, typ: NTI1163016, name: "listStylePosition", sons: null}, +{kind: 1, offset: "listStyleType", len: 0, typ: NTI1163016, name: "listStyleType", sons: null}, +{kind: 1, offset: "margin", len: 0, typ: NTI1163016, name: "margin", sons: null}, +{kind: 1, offset: "marginBottom", len: 0, typ: NTI1163016, name: "marginBottom", sons: null}, +{kind: 1, offset: "marginLeft", len: 0, typ: NTI1163016, name: "marginLeft", sons: null}, +{kind: 1, offset: "marginRight", len: 0, typ: NTI1163016, name: "marginRight", sons: null}, +{kind: 1, offset: "marginTop", len: 0, typ: NTI1163016, name: "marginTop", sons: null}, +{kind: 1, offset: "maxHeight", len: 0, typ: NTI1163016, name: "maxHeight", sons: null}, +{kind: 1, offset: "maxWidth", len: 0, typ: NTI1163016, name: "maxWidth", sons: null}, +{kind: 1, offset: "minHeight", len: 0, typ: NTI1163016, name: "minHeight", sons: null}, +{kind: 1, offset: "minWidth", len: 0, typ: NTI1163016, name: "minWidth", sons: null}, +{kind: 1, offset: "opacity", len: 0, typ: NTI1163016, name: "opacity", sons: null}, +{kind: 1, offset: "outline", len: 0, typ: NTI1163016, name: "outline", sons: null}, +{kind: 1, offset: "overflow", len: 0, typ: NTI1163016, name: "overflow", sons: null}, +{kind: 1, offset: "overflowX", len: 0, typ: NTI1163016, name: "overflowX", sons: null}, +{kind: 1, offset: "overflowY", len: 0, typ: NTI1163016, name: "overflowY", sons: null}, +{kind: 1, offset: "padding", len: 0, typ: NTI1163016, name: "padding", sons: null}, +{kind: 1, offset: "paddingBottom", len: 0, typ: NTI1163016, name: "paddingBottom", sons: null}, +{kind: 1, offset: "paddingLeft", len: 0, typ: NTI1163016, name: "paddingLeft", sons: null}, +{kind: 1, offset: "paddingRight", len: 0, typ: NTI1163016, name: "paddingRight", sons: null}, +{kind: 1, offset: "paddingTop", len: 0, typ: NTI1163016, name: "paddingTop", sons: null}, +{kind: 1, offset: "pageBreakAfter", len: 0, typ: NTI1163016, name: "pageBreakAfter", sons: null}, +{kind: 1, offset: "pageBreakBefore", len: 0, typ: NTI1163016, name: "pageBreakBefore", sons: null}, +{kind: 1, offset: "pointerEvents", len: 0, typ: NTI1163016, name: "pointerEvents", sons: null}, +{kind: 1, offset: "position", len: 0, typ: NTI1163016, name: "position", sons: null}, +{kind: 1, offset: "resize", len: 0, typ: NTI1163016, name: "resize", sons: null}, +{kind: 1, offset: "right", len: 0, typ: NTI1163016, name: "right", sons: null}, +{kind: 1, offset: "scrollbar3dLightColor", len: 0, typ: NTI1163016, name: "scrollbar3dLightColor", sons: null}, +{kind: 1, offset: "scrollbarArrowColor", len: 0, typ: NTI1163016, name: "scrollbarArrowColor", sons: null}, +{kind: 1, offset: "scrollbarBaseColor", len: 0, typ: NTI1163016, name: "scrollbarBaseColor", sons: null}, +{kind: 1, offset: "scrollbarDarkshadowColor", len: 0, typ: NTI1163016, name: "scrollbarDarkshadowColor", sons: null}, +{kind: 1, offset: "scrollbarFaceColor", len: 0, typ: NTI1163016, name: "scrollbarFaceColor", sons: null}, +{kind: 1, offset: "scrollbarHighlightColor", len: 0, typ: NTI1163016, name: "scrollbarHighlightColor", sons: null}, +{kind: 1, offset: "scrollbarShadowColor", len: 0, typ: NTI1163016, name: "scrollbarShadowColor", sons: null}, +{kind: 1, offset: "scrollbarTrackColor", len: 0, typ: NTI1163016, name: "scrollbarTrackColor", sons: null}, +{kind: 1, offset: "tableLayout", len: 0, typ: NTI1163016, name: "tableLayout", sons: null}, +{kind: 1, offset: "textAlign", len: 0, typ: NTI1163016, name: "textAlign", sons: null}, +{kind: 1, offset: "textDecoration", len: 0, typ: NTI1163016, name: "textDecoration", sons: null}, +{kind: 1, offset: "textIndent", len: 0, typ: NTI1163016, name: "textIndent", sons: null}, +{kind: 1, offset: "textTransform", len: 0, typ: NTI1163016, name: "textTransform", sons: null}, +{kind: 1, offset: "transform", len: 0, typ: NTI1163016, name: "transform", sons: null}, +{kind: 1, offset: "top", len: 0, typ: NTI1163016, name: "top", sons: null}, +{kind: 1, offset: "verticalAlign", len: 0, typ: NTI1163016, name: "verticalAlign", sons: null}, +{kind: 1, offset: "visibility", len: 0, typ: NTI1163016, name: "visibility", sons: null}, +{kind: 1, offset: "width", len: 0, typ: NTI1163016, name: "width", sons: null}, +{kind: 1, offset: "wordSpacing", len: 0, typ: NTI1163016, name: "wordSpacing", sons: null}, +{kind: 1, offset: "zIndex", len: 0, typ: NTI1163045, name: "zIndex", sons: null}]}; +NTI1787289.node = NNI1787289; +NTI1787289.base = NTI1168808; +NTI1787287.base = NTI1787289; +var NNI1787233 = {kind: 2, len: 16, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "attributes", len: 0, typ: NTI1787570, name: "attributes", sons: null}, +{kind: 1, offset: "childNodes", len: 0, typ: NTI1787572, name: "childNodes", sons: null}, +{kind: 1, offset: "children", len: 0, typ: NTI1787574, name: "children", sons: null}, +{kind: 1, offset: "data", len: 0, typ: NTI1163016, name: "data", sons: null}, +{kind: 1, offset: "firstChild", len: 0, typ: NTI1787231, name: "firstChild", sons: null}, +{kind: 1, offset: "lastChild", len: 0, typ: NTI1787231, name: "lastChild", sons: null}, +{kind: 1, offset: "nextSibling", len: 0, typ: NTI1787231, name: "nextSibling", sons: null}, +{kind: 1, offset: "nodeName", len: 0, typ: NTI1163016, name: "nodeName", sons: null}, +{kind: 1, offset: "nodeType", len: 0, typ: NTI1787229, name: "nodeType", sons: null}, +{kind: 1, offset: "nodeValue", len: 0, typ: NTI1163016, name: "nodeValue", sons: null}, +{kind: 1, offset: "parentNode", len: 0, typ: NTI1787231, name: "parentNode", sons: null}, +{kind: 1, offset: "previousSibling", len: 0, typ: NTI1787231, name: "previousSibling", sons: null}, +{kind: 1, offset: "innerHTML", len: 0, typ: NTI1163016, name: "innerHTML", sons: null}, +{kind: 1, offset: "innerText", len: 0, typ: NTI1163016, name: "innerText", sons: null}, +{kind: 1, offset: "textContent", len: 0, typ: NTI1163016, name: "textContent", sons: null}, +{kind: 1, offset: "style", len: 0, typ: NTI1787287, name: "style", sons: null}]}; +NTI1787233.node = NNI1787233; +var NNI1787205 = {kind: 2, len: 20, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "onabort", len: 0, typ: NTI1787378, name: "onabort", sons: null}, +{kind: 1, offset: "onblur", len: 0, typ: NTI1787382, name: "onblur", sons: null}, +{kind: 1, offset: "onchange", len: 0, typ: NTI1787386, name: "onchange", sons: null}, +{kind: 1, offset: "onclick", len: 0, typ: NTI1787390, name: "onclick", sons: null}, +{kind: 1, offset: "ondblclick", len: 0, typ: NTI1787394, name: "ondblclick", sons: null}, +{kind: 1, offset: "onerror", len: 0, typ: NTI1787398, name: "onerror", sons: null}, +{kind: 1, offset: "onfocus", len: 0, typ: NTI1787402, name: "onfocus", sons: null}, +{kind: 1, offset: "onkeydown", len: 0, typ: NTI1787406, name: "onkeydown", sons: null}, +{kind: 1, offset: "onkeypress", len: 0, typ: NTI1787410, name: "onkeypress", sons: null}, +{kind: 1, offset: "onkeyup", len: 0, typ: NTI1787414, name: "onkeyup", sons: null}, +{kind: 1, offset: "onload", len: 0, typ: NTI1787418, name: "onload", sons: null}, +{kind: 1, offset: "onmousedown", len: 0, typ: NTI1787422, name: "onmousedown", sons: null}, +{kind: 1, offset: "onmousemove", len: 0, typ: NTI1787426, name: "onmousemove", sons: null}, +{kind: 1, offset: "onmouseout", len: 0, typ: NTI1787430, name: "onmouseout", sons: null}, +{kind: 1, offset: "onmouseover", len: 0, typ: NTI1787434, name: "onmouseover", sons: null}, +{kind: 1, offset: "onmouseup", len: 0, typ: NTI1787438, name: "onmouseup", sons: null}, +{kind: 1, offset: "onreset", len: 0, typ: NTI1787442, name: "onreset", sons: null}, +{kind: 1, offset: "onselect", len: 0, typ: NTI1787446, name: "onselect", sons: null}, +{kind: 1, offset: "onsubmit", len: 0, typ: NTI1787450, name: "onsubmit", sons: null}, +{kind: 1, offset: "onunload", len: 0, typ: NTI1787454, name: "onunload", sons: null}]}; +NTI1787205.node = NNI1787205; +NTI1787205.base = NTI1168808; +NTI1787233.base = NTI1787205; +NTI1787231.base = NTI1787233; +NTI1789105.base = NTI1787231; +NTI11000571.base = NTI1163016; +var NNI1169053 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI1169053.node = NNI1169053; +NTI1169053.base = NTI1169019; +var NNI10846058 = {kind: 2, len: 2, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "Field0", len: 0, typ: NTI1163045, name: "Field0", sons: null}, +{kind: 1, offset: "Field1", len: 0, typ: NTI1163065, name: "Field1", sons: null}]}; +NTI10846058.node = NNI10846058; +function makeNimstrLit(c_1390062) { + var ln = c_1390062.length; + var result = new Array(ln); + for (var i = 0; i < ln; ++i) { + result[i] = c_1390062.charCodeAt(i); + } + return result; + + + +} +function arrayConstr(len_1415067, value_1415068, typ_1415069) { + var result = new Array(len_1415067); + for (var i = 0; i < len_1415067; ++i) result[i] = nimCopy(null, value_1415068, typ_1415069); + return result; + + + +} +function setConstr() { + var result = {}; + for (var i = 0; i < arguments.length; ++i) { + var x = arguments[i]; + if (typeof(x) == "object") { + for (var j = x[0]; j <= x[1]; ++j) { + result[j] = true; + } + } else { + result[x] = true; + } + } + return result; + + + +} +var ConstSet1 = setConstr(17, 16, 4, 18, 27, 19, 23, 22, 21); +function nimCopy(dest_1405023, src_1405024, ti_1405025) { + var result_1410219 = null; + + switch (ti_1405025.kind) { + case 21: + case 22: + case 23: + case 5: + if (!(is_fat_pointer_1400401(ti_1405025))) { + result_1410219 = src_1405024; + } + else { + result_1410219 = [src_1405024[0], src_1405024[1]]; + } + + break; + case 19: + if (dest_1405023 === null || dest_1405023 === undefined) { + dest_1405023 = {}; + } + else { + for (var key in dest_1405023) { delete dest_1405023[key]; } + } + for (var key in src_1405024) { dest_1405023[key] = src_1405024[key]; } + result_1410219 = dest_1405023; + + break; + case 18: + case 17: + if (!((ti_1405025.base == null))) { + result_1410219 = nimCopy(dest_1405023, src_1405024, ti_1405025.base); + } + else { + if ((ti_1405025.kind == 17)) { + result_1410219 = (dest_1405023 === null || dest_1405023 === undefined) ? {m_type: ti_1405025} : dest_1405023; + } + else { + result_1410219 = (dest_1405023 === null || dest_1405023 === undefined) ? {} : dest_1405023; + } + } + nimCopyAux(result_1410219, src_1405024, ti_1405025.node); + break; + case 24: + case 4: + case 27: + case 16: + if (src_1405024 === null) { + result_1410219 = null; + } + else { + if (dest_1405023 === null || dest_1405023 === undefined) { + dest_1405023 = new Array(src_1405024.length); + } + else { + dest_1405023.length = src_1405024.length; + } + result_1410219 = dest_1405023; + for (var i = 0; i < src_1405024.length; ++i) { + result_1410219[i] = nimCopy(result_1410219[i], src_1405024[i], ti_1405025.base); + } + } + + break; + case 28: + if (src_1405024 !== null) { + result_1410219 = src_1405024.slice(0); + } + + break; + default: + result_1410219 = src_1405024; + break; + } + + return result_1410219; + +} +function cstrToNimstr(c_1390079) { + var ln = c_1390079.length; + var result = new Array(ln); + var r = 0; + for (var i = 0; i < ln; ++i) { + var ch = c_1390079.charCodeAt(i); + + if (ch < 128) { + result[r] = ch; + } + else { + if (ch < 2048) { + result[r] = (ch >> 6) | 192; + } + else { + if (ch < 55296 || ch >= 57344) { + result[r] = (ch >> 12) | 224; + } + else { + ++i; + ch = 65536 + (((ch & 1023) << 10) | (c_1390079.charCodeAt(i) & 1023)); + result[r] = (ch >> 18) | 240; + ++r; + result[r] = ((ch >> 12) & 63) | 128; + } + ++r; + result[r] = ((ch >> 6) & 63) | 128; + } + ++r; + result[r] = (ch & 63) | 128; + } + ++r; + } + return result; + + + +} +function toJSStr(s_1390096) { + var Tmp5; + var Tmp7; + + var result_1390097 = null; + + var res_1390170 = new_seq_1390128((s_1390096 != null ? s_1390096.length : 0)); + var i_1390172 = 0; + var j_1390174 = 0; + L1: do { + L2: while (true) { + if (!(i_1390172 < (s_1390096 != null ? s_1390096.length : 0))) break L2; + var c_1390175 = s_1390096[i_1390172]; + if ((c_1390175 < 128)) { + res_1390170[j_1390174] = String.fromCharCode(c_1390175); + i_1390172 += 1; + } + else { + var helper_1390198 = new_seq_1390128(0); + L3: do { + L4: while (true) { + if (!true) break L4; + var code_1390199 = c_1390175.toString(16); + if (((code_1390199 != null ? code_1390199.length : 0) == 1)) { + if (helper_1390198 != null) { helper_1390198.push("%0"); } else { helper_1390198 = ["%0"]; }; + } + else { + if (helper_1390198 != null) { helper_1390198.push("%"); } else { helper_1390198 = ["%"]; }; + } + + if (helper_1390198 != null) { helper_1390198.push(code_1390199); } else { helper_1390198 = [code_1390199]; }; + i_1390172 += 1; + if (((s_1390096 != null ? s_1390096.length : 0) <= i_1390172)) Tmp5 = true; else { Tmp5 = (s_1390096[i_1390172] < 128); } if (Tmp5) { + break L3; + } + + c_1390175 = s_1390096[i_1390172]; + } + } while(false); +++excHandler; + Tmp7 = framePtr; + try { + res_1390170[j_1390174] = decodeURIComponent(helper_1390198.join("")); +--excHandler; +} catch (EXC) { + var prevJSError = lastJSError; + lastJSError = EXC; + --excHandler; + framePtr = Tmp7; + res_1390170[j_1390174] = helper_1390198.join(""); + lastJSError = prevJSError; + } finally { + framePtr = Tmp7; + } + } + + j_1390174 += 1; + } + } while(false); + if (res_1390170 === null) res_1390170 = []; + if (res_1390170.length < j_1390174) { for (var i=res_1390170.length;i 2147483647 || result < -2147483648) raiseOverflow(); + return result; + + + +} +function chckIndx(i_1415086, a_1415087, b_1415088) { + var Tmp1; + + var result_1415089 = 0; + + BeforeRet: do { + if (!(a_1415087 <= i_1415086)) Tmp1 = false; else { Tmp1 = (i_1415086 <= b_1415088); } if (Tmp1) { + result_1415089 = i_1415086; + break BeforeRet; + } + else { + raiseIndexError(i_1415086, a_1415087, b_1415088); + } + + } while (false); + + return result_1415089; + +} +function subInt(a_1395421, b_1395422) { + var result = a_1395421 - b_1395422; + if (result > 2147483647 || result < -2147483648) raiseOverflow(); + return result; + + + +} +var ConstSet2 = setConstr([65, 90]); +function chckRange(i_1420016, a_1420017, b_1420018) { + var Tmp1; + + var result_1420019 = 0; + + BeforeRet: do { + if (!(a_1420017 <= i_1420016)) Tmp1 = false; else { Tmp1 = (i_1420016 <= b_1420018); } if (Tmp1) { + result_1420019 = i_1420016; + break BeforeRet; + } + else { + raiseRangeError(); + } + + } while (false); + + return result_1420019; + +} +var ConstSet3 = setConstr(95, 32, 46); +var ConstSet4 = setConstr(95, 32, 46); +function mulInt(a_1395439, b_1395440) { + var result = a_1395439 * b_1395440; + if (result > 2147483647 || result < -2147483648) raiseOverflow(); + return result; + + + +} +var ConstSet5 = setConstr([97, 122]); +var ConstSet6 = setConstr([65, 90], [97, 122]); +var ConstSet7 = setConstr([97, 122]); +var ConstSet8 = setConstr([65, 90]); +function nimMax(a_1395821, b_1395822) { + var Tmp1; + + var result_1395823 = 0; + + BeforeRet: do { + if ((b_1395822 <= a_1395821)) { + Tmp1 = a_1395821; + } + else { + Tmp1 = b_1395822; + } + + result_1395823 = Tmp1; + break BeforeRet; + } while (false); + + return result_1395823; + +} +function nimMin(a_1395803, b_1395804) { + var Tmp1; + + var result_1395805 = 0; + + BeforeRet: do { + if ((a_1395803 <= b_1395804)) { + Tmp1 = a_1395803; + } + else { + Tmp1 = b_1395804; + } + + result_1395805 = Tmp1; + break BeforeRet; + } while (false); + + return result_1395805; + +} +var nim_program_result = 0; +var global_raise_hook_1307018 = [null]; +var local_raise_hook_1307023 = [null]; +var out_of_mem_hook_1307026 = [null]; +var unhandled_exception_hook_1307031 = [null]; +if (!Math.trunc) { + Math.trunc = function(v) { + v = +v; + if (!isFinite(v)) return v; + return (v - v % 1) || (v < 0 ? -0 : v === 0 ? v : 0); + }; +} + +var alternative_11000319 = [null]; +function add_1307042(x_1307045, x_1307045_Idx, y_1307046) { + if (x_1307045[x_1307045_Idx] === null) { x_1307045[x_1307045_Idx] = []; } + var off = x_1307045[x_1307045_Idx].length; + x_1307045[x_1307045_Idx].length += y_1307046.length; + for (var i = 0; i < y_1307046.length; ++i) { + x_1307045[x_1307045_Idx][off+i] = y_1307046.charCodeAt(i); + } + + + +} +function is_fat_pointer_1400401(ti_1400403) { + var result_1400404 = false; + + BeforeRet: do { + result_1400404 = !((ConstSet1[ti_1400403.base.kind] != undefined)); + break BeforeRet; + } while (false); + + return result_1400404; + +} +function nimCopyAux(dest_1405028, src_1405029, n_1405031) { + switch (n_1405031.kind) { + case 0: + break; + case 1: + dest_1405028[n_1405031.offset] = nimCopy(dest_1405028[n_1405031.offset], src_1405029[n_1405031.offset], n_1405031.typ); + + break; + case 2: + for (var i = 0; i < n_1405031.sons.length; i++) { + nimCopyAux(dest_1405028, src_1405029, n_1405031.sons[i]); + } + + break; + case 3: + dest_1405028[n_1405031.offset] = nimCopy(dest_1405028[n_1405031.offset], src_1405029[n_1405031.offset], n_1405031.typ); + for (var i = 0; i < n_1405031.sons.length; ++i) { + nimCopyAux(dest_1405028, src_1405029, n_1405031.sons[i][1]); + } + + break; + } + + +} +function aux_write_stack_trace_1325038(f_1325040) { + var Tmp3; + + var result_1325041 = [null]; + + var it_1325049 = f_1325040; + var i_1325051 = 0; + var total_1325053 = 0; + var temp_frames_1325060 = arrayConstr(64, {Field0: null, Field1: 0}, NTI1325043); + L1: do { + L2: while (true) { + if (!!((it_1325049 == null))) Tmp3 = false; else { Tmp3 = (i_1325051 <= 63); } if (!Tmp3) break L2; + temp_frames_1325060[i_1325051].Field0 = it_1325049.procname; + temp_frames_1325060[i_1325051].Field1 = it_1325049.line; + i_1325051 += 1; + total_1325053 += 1; + it_1325049 = it_1325049.prev; + } + } while(false); + L4: do { + L5: while (true) { + if (!!((it_1325049 == null))) break L5; + total_1325053 += 1; + it_1325049 = it_1325049.prev; + } + } while(false); + result_1325041[0] = nimCopy(null, [], NTI1163014); + if (!((total_1325053 == i_1325051))) { + if (result_1325041[0] != null) { result_1325041[0] = (result_1325041[0]).concat(makeNimstrLit("(")); } else { result_1325041[0] = makeNimstrLit("("); }; + if (result_1325041[0] != null) { result_1325041[0] = (result_1325041[0]).concat(cstrToNimstr(((total_1325053 - i_1325051))+"")); } else { result_1325041[0] = cstrToNimstr(((total_1325053 - i_1325051))+"").slice(); }; + if (result_1325041[0] != null) { result_1325041[0] = (result_1325041[0]).concat(makeNimstrLit(" calls omitted) ...\x0A")); } else { result_1325041[0] = makeNimstrLit(" calls omitted) ...\x0A"); }; + } + + L6: do { + var j_1340236 = 0; + var colontmp__11000463 = 0; + colontmp__11000463 = (i_1325051 - 1); + var res_11000468 = colontmp__11000463; + L7: do { + L8: while (true) { + if (!(0 <= res_11000468)) break L8; + j_1340236 = res_11000468; + add_1307042(result_1325041, 0, temp_frames_1325060[j_1340236].Field0); + if ((0 < temp_frames_1325060[j_1340236].Field1)) { + if (result_1325041[0] != null) { result_1325041[0] = (result_1325041[0]).concat(makeNimstrLit(", line: ")); } else { result_1325041[0] = makeNimstrLit(", line: "); }; + if (result_1325041[0] != null) { result_1325041[0] = (result_1325041[0]).concat(cstrToNimstr((temp_frames_1325060[j_1340236].Field1)+"")); } else { result_1325041[0] = cstrToNimstr((temp_frames_1325060[j_1340236].Field1)+"").slice(); }; + } + + if (result_1325041[0] != null) { result_1325041[0] = (result_1325041[0]).concat(makeNimstrLit("\x0A")); } else { result_1325041[0] = makeNimstrLit("\x0A"); }; + res_11000468 -= 1; + } + } while(false); + } while(false); + + return result_1325041[0]; + +} +function raw_write_stack_trace_1345059() { + var result_1345061 = null; + + if (!((framePtr == null))) { + result_1345061 = nimCopy(null, (makeNimstrLit("Traceback (most recent call last)\x0A") || []).concat(aux_write_stack_trace_1325038(framePtr) || []), NTI1163014); + } + else { + result_1345061 = nimCopy(null, makeNimstrLit("No stack traceback available\x0A"), NTI1163014); + } + + + return result_1345061; + +} +function new_seq_1390128(len_1390131) { + var result_1390133 = null; + + var F={procname:"newSeq.newSeq",prev:framePtr,filename:"system.nim",line:0}; + framePtr = F; + F.line = 643; + result_1390133 = new Array(len_1390131); for (var i=0;i", "text/html"); + + stuff_11000556 = doc.documentElement; + + F.line = 286; + db_11000528[0] = nimCopy(null, stuff_11000556.getElementsByClassName("reference"), NTI1789105); + F.line = 287; + contents_11000530[0] = nimCopy(null, [], NTI11000571); + L1: do { + F.line = 288; + var ahref_11010214 = null; + F.line = 184; + var i_11020040 = 0; + F.line = 185; + var l_11020041 = (db_11000528[0] != null ? db_11000528[0].length : 0); + L2: do { + F.line = 186; + L3: while (true) { + if (!(i_11020040 < l_11020041)) break L3; + F.line = 288; + ahref_11010214 = db_11000528[0][chckIndx(i_11020040, 0, (db_11000528[0] != null ? db_11000528[0].length : 0)+0-1)-0]; + F.line = 289; + if (contents_11000530[0] != null) { contents_11000530[0].push(ahref_11010214.getAttribute("data-doc-search-tag")); } else { contents_11000530[0] = [ahref_11010214.getAttribute("data-doc-search-tag")]; }; + F.line = 188; + i_11020040 = addInt(i_11020040, 1); + if (!(((db_11000528[0] != null ? db_11000528[0].length : 0) == l_11020041))) { + F.line = 189; + failed_assert_impl_1267680(makeNimstrLit("/Users/joey/Nim/lib/system/iterators.nim(189, 11) `len(a) == L` the length of the seq changed while iterating over it")); + } + + } + } while(false); + } while(false); + } + + F.line = 290; + var ul_11010225 = tree_10921020(makeNimstrLit("UL"), []); + F.line = 291; + result_11000550 = tree_10921020(makeNimstrLit("DIV"), []); + F.line = 292; + set_class_10921118(result_11000550, makeNimstrLit("search_results")); + F.line = 293; + var matches_11010246 = []; + L4: do { + F.line = 294; + var i_11010259 = 0; + F.line = 104; + var colontmp__11020047 = 0; + F.line = 294; + colontmp__11020047 = (db_11000528[0] != null ? db_11000528[0].length : 0); + F.line = 106; + var i_11020048 = 0; + L5: do { + F.line = 107; + L6: while (true) { + if (!(i_11020048 < colontmp__11020047)) break L6; + F.line = 294; + i_11010259 = i_11020048; + L7: do { + F.line = 295; + var c_11010260 = contents_11000530[0][chckIndx(i_11010259, 0, (contents_11000530[0] != null ? contents_11000530[0].length : 0)+0-1)-0]; + if (((c_11010260 == "Examples") || (c_11010260 == "PEG construction"))) { + F.line = 300; + break L7; + } + + F.line = 301; + var colontmp__11020055 = fuzzy_match_10846054(value_11000549, c_11010260); + F.line = 301; + var score_11010261 = colontmp__11020055["Field0"]; + F.line = 301; + var matched_11010262 = colontmp__11020055["Field1"]; + if (matched_11010262) { + F.line = 303; + if (matches_11010246 != null) { matches_11010246.push({Field0: db_11000528[0][chckIndx(i_11010259, 0, (db_11000528[0] != null ? db_11000528[0].length : 0)+0-1)-0], Field1: score_11010261}); } else { matches_11010246 = [{Field0: db_11000528[0][chckIndx(i_11010259, 0, (db_11000528[0] != null ? db_11000528[0].length : 0)+0-1)-0], Field1: score_11010261}]; }; + } + + } while(false); + F.line = 109; + i_11020048 = addInt(i_11020048, 1); + } + } while(false); + } while(false); + F.line = 305; + matches_11010246.sort(HEX3Aanonymous_11010273); + L8: do { + F.line = 306; + var i_11010326 = 0; + F.line = 104; + var colontmp__11020052 = 0; + F.line = 306; + colontmp__11020052 = nimMin((matches_11010246 != null ? matches_11010246.length : 0), 19); + F.line = 106; + var i_11020053 = 0; + L9: do { + F.line = 107; + L10: while (true) { + if (!(i_11020053 < colontmp__11020052)) break L10; + F.line = 306; + i_11010326 = i_11020053; + F.line = 307; + matches_11010246[chckIndx(i_11010326, 0, (matches_11010246 != null ? matches_11010246.length : 0)+0-1)-0]["Field0"].innerHTML = matches_11010246[chckIndx(i_11010326, 0, (matches_11010246 != null ? matches_11010246.length : 0)+0-1)-0]["Field0"].getAttribute("data-doc-search-tag"); + F.line = 308; + add_10921100(ul_11010225, tree_10921020(makeNimstrLit("LI"), [matches_11010246[chckIndx(i_11010326, 0, (matches_11010246 != null ? matches_11010246.length : 0)+0-1)-0]["Field0"]])); + F.line = 109; + i_11020053 = addInt(i_11020053, 1); + } + } while(false); + } while(false); + if ((ul_11010225.childNodes.length == 0)) { + F.line = 310; + add_10921100(result_11000550, tree_10921020(makeNimstrLit("B"), [text_10921135(makeNimstrLit("no search results"))])); + } + else { + F.line = 312; + add_10921100(result_11000550, tree_10921020(makeNimstrLit("B"), [text_10921135(makeNimstrLit("search results"))])); + F.line = 313; + add_10921100(result_11000550, ul_11010225); + } + + framePtr = F.prev; + + return result_11000550; + +} +function search() { + function wrapper_11010435() { + var F={procname:"search.wrapper",prev:framePtr,filename:"dochack.nim",line:0}; + framePtr = F; + F.line = 320; + var elem_11010437 = document.getElementById("searchInput"); + F.line = 321; + var value_11010438 = elem_11010437.value; + if (!(((value_11010438 != null ? value_11010438.length : 0) == 0))) { + if ((oldtoc_11010403[0] == null)) { + F.line = 324; + oldtoc_11010403[0] = document.getElementById("tocRoot"); + } + + F.line = 325; + var results_11015006 = dosearch_11000547(value_11010438); + F.line = 326; + replace_by_id_10921172("tocRoot", results_11015006); + } + else { + if (!((oldtoc_11010403[0] == null))) { + F.line = 328; + replace_by_id_10921172("tocRoot", oldtoc_11010403[0]); + } + } + framePtr = F.prev; + + + } + + var F={procname:"dochack.search",prev:framePtr,filename:"dochack.nim",line:0}; + framePtr = F; + if (!((timer_11010404[0] == null))) { + F.line = 330; + clearTimeout(timer_11010404[0]); + } + + F.line = 331; + timer_11010404[0] = setTimeout(wrapper_11010435, 400); + framePtr = F.prev; + + +} diff --git a/docs/index.html b/docs/index.html new file mode 100644 index 0000000..35418e1 --- /dev/null +++ b/docs/index.html @@ -0,0 +1,17128 @@ + + + + + + + + + + + + + + + + + + +Index + + + + + + + + +
+
+

Index

+ Modules: sdl2, sdl2/sdl2, sdl2/sdl2_gfx, sdl2/sdl2_image, sdl2/sdl2_mixer, sdl2/sdl2_net, sdl2/sdl2_ttf, sdl2_gpu.

API symbols

+
aacircleColor:
+
aacircleRGBA:
+
aaellipseColor:
+
aaellipseRGBA:
+
aalineColor:
+
aalineRGBA:
+
aapolygonColor:
+
aapolygonRGBA:
+
aatrigonColor:
+
aatrigonRGBA:
+
abs:
+
acos:
+
acosf:
+
activateShaderProgram:
+
addDepthBuffer:
+
ADDEVENT:
+
addEventWatch:
+
addHintCallback:
+
addSocket:
+
addTimer:
+
allocateChannels:
+
allocFormat:
+
allocPacket:
+
allocPacketV:
+
allocPalette:
+
allocRW:
+
allocSocketSet:
+
ALPHA_OPAQUE:
+
ALPHA_TRANSPARENT:
+
ALWAYS:
+
arc:
+
arcColor:
+
arcFilled:
+
arcRGBA:
+
ArrayOrder:
+
ARRAYORDER_ABGR:
+
ARRAYORDER_ARGB:
+
ARRAYORDER_BGR:
+
ARRAYORDER_BGRA:
+
ARRAYORDER_NONE:
+
ARRAYORDER_RGB:
+
ARRAYORDER_RGBA:
+
asin:
+
asinf:
+
ASSEMBLY_ROUTINES:
+
AssertData:
+
ASSERTION_ABORT:
+
ASSERTION_ALWAYS_IGNORE:
+
ASSERTION_BREAK:
+
AssertionHandler:
+
ASSERTION_IGNORE:
+
ASSERTION_RETRY:
+
ASSERT_LEVEL:
+
AssertState:
+
atan:
+
atan2:
+
atan2f:
+
atanf:
+
atof:
+
atoi:
+
atomicAdd:
+
atomicCAS:
+
atomicCASPtr:
+
atomicGet:
+
atomicGetPtr:
+
atomicLock:
+
atomicSet:
+
atomicSetPtr:
+
atomic_t:
+
atomicTryLock:
+
atomicUnlock:
+
attachShader:
+
Attribute:
+
AttributeFormat:
+
AttributeSource:
+
AUDIO_ALLOW_ANY_CHANGE:
+
AUDIO_ALLOW_CHANNELS_CHANGE:
+
AUDIO_ALLOW_FORMAT_CHANGE:
+
AUDIO_ALLOW_FREQUENCY_CHANGE:
+
AUDIO_ALLOW_SAMPLES_CHANGE:
+
AudioCallback:
+
AudioCVT:
+
AUDIOCVT_MAX_FILTERS:
+
AudioDeviceEvent:
+
AudioDeviceID:
+
AUDIO_DRIVER_COREAUDIO:
+
AUDIO_DRIVER_DISK:
+
AUDIO_DRIVER_DUMMY:
+
AUDIO_F32:
+
AUDIO_F32LSB:
+
AUDIO_F32MSB:
+
AUDIO_F32SYS:
+
AudioFilter:
+
AudioFormat:
+
audioInit:
+
AUDIO_MASK_BITSIZE:
+
AUDIO_MASK_DATATYPE:
+
AUDIO_MASK_ENDIAN:
+
AUDIO_MASK_SIGNED:
+
AUDIO_PAUSED:
+
AUDIO_PLAYING:
+
audioQuit:
+
AUDIO_S16:
+
AUDIO_S16LSB:
+
AUDIO_S16MSB:
+
AUDIO_S16SYS:
+
AUDIO_S32:
+
AUDIO_S32LSB:
+
AUDIO_S32MSB:
+
AUDIO_S32SYS:
+
AUDIO_S8:
+
AudioSpec:
+
AudioStatus:
+
AUDIO_STOPPED:
+
AudioStream:
+
audioStreamAvailable:
+
audioStreamClear:
+
audioStreamFlush:
+
audioStreamGet:
+
audioStreamPut:
+
AUDIO_U16:
+
AUDIO_U16LSB:
+
AUDIO_U16MSB:
+
AUDIO_U16SYS:
+
AUDIO_U8:
+
BatchFlagEnum:
+
BATCH_RGB:
+
BATCH_RGB8:
+
BATCH_RGBA:
+
BATCH_RGBA8:
+
BATCH_ST:
+
BATCH_XY:
+
BATCH_XY_RGB:
+
BATCH_XY_RGB8:
+
BATCH_XY_RGBA:
+
BATCH_XY_RGBA8:
+
BATCH_XY_ST:
+
BATCH_XY_ST_RGBA:
+
BATCH_XY_ST_RGBA8:
+
BATCH_XYZ:
+
BATCH_XYZ_RGB:
+
BATCH_XYZ_RGB8:
+
BATCH_XYZ_RGBA:
+
BATCH_XYZ_RGBA8:
+
BATCH_XYZ_ST:
+
BATCH_XYZ_ST_RGBA:
+
BATCH_XYZ_ST_RGBA8:
+
bezierColor:
+
bezierRGBA:
+
BIG_ENDIAN:
+
BitmapOrder:
+
BITMAPORDER_1234:
+
BITMAPORDER_4321:
+
BITMAPORDER_NONE:
+
BLEND_ADD:
+
BlendEqEnum:
+
BlendFactor:
+
BLENDFACTOR_DST_ALPHA:
+
BLENDFACTOR_DST_COLOR:
+
BLENDFACTOR_ONE:
+
BLENDFACTOR_ONE_MINUS_DST_ALPHA:
+
BLENDFACTOR_ONE_MINUS_DST_COLOR:
+
BLENDFACTOR_ONE_MINUS_SRC_ALPHA:
+
BLENDFACTOR_ONE_MINUS_SRC_COLOR:
+
BLENDFACTOR_SRC_ALPHA:
+
BLENDFACTOR_SRC_COLOR:
+
BLENDFACTOR_ZERO:
+
BlendFuncEnum:
+
BLEND_MOD_ALPHA:
+
BlendMode:
+
BLENDMODE_ADD:
+
BLENDMODE_BLEND:
+
BLENDMODE_INVALID:
+
BLENDMODE_MOD:
+
BLENDMODE_MUL:
+
BLENDMODE_NONE:
+
BLEND_MULTIPLY:
+
BLEND_NORMAL:
+
BLEND_NORMAL_ADD_ALPHA:
+
BLEND_NORMAL_FACTOR_ALPHA:
+
BLEND_NORMAL_KEEP_ALPHA:
+
BlendOperation:
+
BLENDOPERATION_ADD:
+
BLENDOPERATION_MAXIMUM:
+
BLENDOPERATION_MINIMUM:
+
BLENDOPERATION_REV_SUBTRACT:
+
BLENDOPERATION_SUBTRACT:
+
BLEND_PREMULTIPLIED_ALPHA:
+
BlendPresetEnum:
+
BLEND_SET:
+
BLEND_SET_ALPHA:
+
BLEND_SUBTRACT:
+
blit:
+
BlitMap:
+
blitRect:
+
blitRectX:
+
blitRotate:
+
blitScale:
+
BlitScaled:
+
BlitSurface:
+
blitTransform:
+
blitTransformX:
+
Bool:
+
boxColor:
+
boxRGBA:
+
buildAudioCVT:
+
ButtonBindHat:
+
BUTTON_LEFT:
+
BUTTON_LMASK:
+
BUTTON_MIDDLE:
+
BUTTON_MMASK:
+
BUTTON_RIGHT:
+
BUTTON_RMASK:
+
BUTTON_X1:
+
BUTTON_X1MASK:
+
BUTTON_X2:
+
BUTTON_X2MASK:
+
BYTEORDER:
+
byteSwappedUNICODE:
+
CACHELINE_SIZE:
+
calculateGammaRamp:
+
calloc:
+
calloc_func:
+
Camera:
+
captureMouse:
+
ceil:
+
ceilf:
+
channelFinished:
+
characterColor:
+
characterRGBA:
+
checkSockets:
+
Chunk:
+
circle:
+
circleColor:
+
circleFilled:
+
circleRGBA:
+
clear:
+
clearColor:
+
clearError:
+
ClearError:
+
clearHints:
+
clearMatrixStack:
+
clearQueuedAudio:
+
clearRGB:
+
clearRGBA:
+
closeAudio:
+
closeAudioDevice:
+
closeCurrentRenderer:
+
closeFont:
+
Color:
+
Colour:
+
CommonEvent:
+
ComparisonEnum:
+
compileShader:
+
compileShader_RW:
+
composeCustomBlendMode:
+
cond:
+
condBroadcast:
+
condSignal:
+
condWait:
+
condWaitTimeout:
+
Context:
+
ControllerAxisEvent:
+
CONTROLLER_AXIS_INVALID:
+
CONTROLLER_AXIS_LEFTX:
+
CONTROLLER_AXIS_LEFTY:
+
CONTROLLER_AXIS_MAX:
+
CONTROLLER_AXIS_RIGHTX:
+
CONTROLLER_AXIS_RIGHTY:
+
CONTROLLER_AXIS_TRIGGERLEFT:
+
CONTROLLER_AXIS_TRIGGERRIGHT:
+
CONTROLLER_BINDTYPE_AXIS:
+
CONTROLLER_BINDTYPE_BUTTON:
+
CONTROLLER_BINDTYPE_HAT:
+
CONTROLLER_BINDTYPE_NONE:
+
CONTROLLER_BUTTON_A:
+
CONTROLLER_BUTTON_B:
+
CONTROLLER_BUTTON_BACK:
+
CONTROLLER_BUTTON_DPAD_DOWN:
+
CONTROLLER_BUTTON_DPAD_LEFT:
+
CONTROLLER_BUTTON_DPAD_RIGHT:
+
CONTROLLER_BUTTON_DPAD_UP:
+
ControllerButtonEvent:
+
CONTROLLER_BUTTON_GUIDE:
+
CONTROLLER_BUTTON_INVALID:
+
CONTROLLER_BUTTON_LEFTSHOULDER:
+
CONTROLLER_BUTTON_LEFTSTICK:
+
CONTROLLER_BUTTON_MAX:
+
CONTROLLER_BUTTON_RIGHTSHOULDER:
+
CONTROLLER_BUTTON_RIGHTSTICK:
+
CONTROLLER_BUTTON_START:
+
CONTROLLER_BUTTON_X:
+
CONTROLLER_BUTTON_Y:
+
ControllerDeviceEvent:
+
CONTROLLER_TYPE_NINTENDO_SWITCH_PRO:
+
CONTROLLER_TYPE_PS3:
+
CONTROLLER_TYPE_PS4:
+
CONTROLLER_TYPE_UNKNOWN:
+
CONTROLLER_TYPE_XBOX360:
+
CONTROLLER_TYPE_XBOXONE:
+
convertAudio:
+
convertPixels:
+
convertSurface:
+
convertSurfaceFormat:
+
copyImage:
+
copyImageFromSurface:
+
copyImageFromTarget:
+
copyMatrixStack:
+
copysign:
+
copysignf:
+
copySurfaceFromImage:
+
copySurfaceFromTarget:
+
cos:
+
cosf:
+
createAliasImage:
+
createAliasTarget:
+
createColorCursor:
+
createCond:
+
createCursor:
+
createImage:
+
createImageUsingTexture:
+
createMatrixStack:
+
createMutex:
+
createRenderer:
+
createRGBSurface:
+
createRGBSurfaceFrom:
+
createRGBSurfaceWithFormat:
+
createRGBSurfaceWithFormatFrom:
+
createSemaphore:
+
createShaderProgram:
+
createShapedWindow:
+
createSoftwareRenderer:
+
createSystemCursor:
+
createTargetFromWindow:
+
createTexture:
+
createTextureFromSurface:
+
createThread:
+
createThreadWithStackSize:
+
createWindow:
+
createWindowAndRenderer:
+
createWindowFrom:
+
Cursor:
+
DATA_ALIGNED:
+
deactivateShaderProgram:
+
DEBUG_LEVEL_0:
+
DEBUG_LEVEL_1:
+
DEBUG_LEVEL_2:
+
DEBUG_LEVEL_3:
+
DebugLevelEnum:
+
DEBUG_LEVEL_MAX:
+
DEFAULT_INIT_FLAGS:
+
delay:
+
delEventWatch:
+
delHintCallback:
+
delSocket:
+
dequeueAudio:
+
destroyCond:
+
destroyMutex:
+
destroyRenderer:
+
destroySemaphore:
+
destroyTexture:
+
destroyWindow:
+
detachShader:
+
detachThread:
+
DISABLE:
+
disableScreenSaver:
+
DisplayEvent:
+
DisplayEventID:
+
DISPLAYEVENT_NONE:
+
DISPLAYEVENT_ORIENTATION:
+
DisplayMode:
+
DisplayOrientation:
+
DollarGestureEvent:
+
DONTFREE:
+
DropEvent:
+
duplicateSurface:
+
eachSoundFont:
+
EffectDone_t:
+
EffectFunc_t:
+
EFREAD:
+
EFSEEK:
+
EFWRITE:
+
ellipse:
+
ellipseColor:
+
ellipseFilled:
+
ellipseRGBA:
+
ENABLE:
+
enableCamera:
+
enableScreenSaver:
+
enclosePoints:
+
ENOMEM:
+
EQ_ADD:
+
EQ_REVERSE_SUBTRACT:
+
EQ_SUBTRACT:
+
EQUAL:
+
error:
+
ERROR_BACKEND_ERROR:
+
errorcode:
+
ERROR_DATA_ERROR:
+
ErrorEnum:
+
ERROR_FILE_NOT_FOUND:
+
ERROR_NONE:
+
ERROR_NULL_ARGUMENT:
+
ErrorObject:
+
ERROR_UNSUPPORTED_FUNCTION:
+
ERROR_USER_ERROR:
+
Event:
+
eventaction:
+
EVENT_APP_DIDENTERBACKGROUND:
+
EVENT_APP_DIDENTERFOREGROUND:
+
EVENT_APP_LOWMEMORY:
+
EVENT_APP_TERMINATING:
+
EVENT_APP_WILLENTERBACKGROUND:
+
EVENT_APP_WILLENTERFOREGROUND:
+
EVENT_AUDIODEVICEADDED:
+
EVENT_AUDIODEVICEREMOVED:
+
EVENT_CLIPBOARDUPDATE:
+
EVENT_CONTROLLERAXISMOTION:
+
EVENT_CONTROLLERBUTTONDOWN:
+
EVENT_CONTROLLERBUTTONUP:
+
EVENT_CONTROLLERDEVICEADDED:
+
EVENT_CONTROLLERDEVICEREMAPPED:
+
EVENT_CONTROLLERDEVICEREMOVED:
+
EVENT_DISPLAYEVENT:
+
EVENT_DOLLARGESTURE:
+
EVENT_DOLLARRECORD:
+
EVENT_DROPBEGIN:
+
EVENT_DROPCOMPLETE:
+
EVENT_DROPFILE:
+
EVENT_DROPTEXT:
+
EventFilter:
+
EVENT_FINGERDOWN:
+
EVENT_FINGERMOTION:
+
EVENT_FINGERUP:
+
EVENT_FIRSTEVENT:
+
EVENT_JOYAXISMOTION:
+
EVENT_JOYBALLMOTION:
+
EVENT_JOYBUTTONDOWN:
+
EVENT_JOYBUTTONUP:
+
EVENT_JOYDEVICEADDED:
+
EVENT_JOYDEVICEREMOVED:
+
EVENT_JOYHATMOTION:
+
EVENT_KEYDOWN:
+
EVENT_KEYMAPCHANGED:
+
EVENT_KEYUP:
+
EVENT_LASTEVENT:
+
EVENT_MOUSEBUTTONDOWN:
+
EVENT_MOUSEBUTTONUP:
+
EVENT_MOUSEMOTION:
+
EVENT_MOUSEWHEEL:
+
EVENT_MULTIGESTURE:
+
EVENT_QUIT:
+
EVENT_RENDER_DEVICE_RESET:
+
EVENT_RENDER_TARGETS_RESET:
+
EVENT_SENSORUPDATE:
+
eventState:
+
EVENT_SYSWMEVENT:
+
EVENT_TEXTEDITING:
+
EVENT_TEXTINPUT:
+
EventType:
+
EVENT_USEREVENT:
+
EVENT_WINDOWEVENT:
+
exp:
+
expf:
+
expireChannel:
+
fabs:
+
fabsf:
+
fadeInChannelTimed:
+
fadeInMusic:
+
fadeInMusicPos:
+
fadeOutChannel:
+
fadeOutGroup:
+
fadeOutMusic:
+
Fading:
+
fadingChannel:
+
fadingMusic:
+
false:
+
FALSE:
+
FEATURE_ALL_BASE:
+
FEATURE_ALL_BLEND_PRESETS:
+
FEATURE_ALL_GL_FORMATS:
+
FEATURE_ALL_SHADERS:
+
FEATURE_BASIC_SHADERS:
+
FEATURE_BLEND_EQUATIONS:
+
FEATURE_BLEND_EQUATIONS_SEPARATE:
+
FEATURE_BLEND_FUNC_SEPARATE:
+
FEATURE_CORE_FRAMEBUFFER_OBJECTS:
+
FeatureEnum:
+
FEATURE_FRAGMENT_SHADER:
+
FEATURE_GEOMETRY_SHADER:
+
FEATURE_GL_ABGR:
+
FEATURE_GL_BGR:
+
FEATURE_GL_BGRA:
+
FEATURE_NON_POWER_OF_TWO:
+
FEATURE_PIXEL_SHADER:
+
FEATURE_RENDER_TARGETS:
+
FEATURE_VERTEX_SHADER:
+
FEATURE_WRAP_REPEAT_MIRRORED:
+
FILE_AUTO:
+
FILE_BMP:
+
FileFormatEnum:
+
FILE_PNG:
+
FILESYSTEM_COCOA:
+
FILE_TGA:
+
filledCircleColor:
+
filledCircleRGBA:
+
filledEllipseColor:
+
filledEllipseRGBA:
+
filledPieColor:
+
filledPieRGBA:
+
filledPolygonColor:
+
filledPolygonRGBA:
+
filledTrigonColor:
+
filledTrigonRGBA:
+
fillRect:
+
fillRects:
+
FilterEnum:
+
filterEvents:
+
FILTER_LINEAR:
+
FILTER_LINEAR_MIPMAP:
+
FILTER_NEAREST:
+
Finger:
+
FingerID:
+
flip:
+
FlipEnum:
+
FLIP_HORIZONTAL:
+
FLIP_NONE:
+
FLIP_VERTICAL:
+
floor:
+
floorf:
+
flushBlitBuffer:
+
flushEvent:
+
flushEvents:
+
fmod:
+
fmodf:
+
Font:
+
fontAscent:
+
fontDescent:
+
fontFaceFamilyName:
+
fontFaceIsFixedWidth:
+
fontFaces:
+
fontFaceStyleName:
+
fontHeight:
+
fontLineSkip:
+
FORMAT_ABGR:
+
FORMAT_ALPHA:
+
FORMAT_BGR:
+
FORMAT_BGRA:
+
FormatEnum:
+
FORMAT_LUMINANCE:
+
FORMAT_LUMINANCE_ALPHA:
+
FORMAT_RG:
+
FORMAT_RGB:
+
FORMAT_RGBA:
+
FORMAT_YCbCr420P:
+
FORMAT_YCbCr422:
+
FPoint:
+
FPS_DEFAULT:
+
FPS_LOWER_LIMIT:
+
FPSmanager:
+
FPS_UPPER_LIMIT:
+
FRAGMENT_SHADER:
+
framerateDelay:
+
FRect:
+
free:
+
freeAudioStream:
+
freeChunk:
+
freeCursor:
+
freeFormat:
+
free_func:
+
freeImage:
+
freeMatrixStack:
+
freeMusic:
+
freePacket:
+
freePacketV:
+
freePalette:
+
freeRenderer:
+
freeRW:
+
freeShader:
+
freeShaderProgram:
+
freeSocketSet:
+
freeSurface:
+
freeTarget:
+
freeWAV:
+
frustum:
+
FUNC_DST_ALPHA:
+
FUNC_DST_COLOR:
+
FUNC_ONE:
+
FUNC_ONE_MINUS_DST:
+
FUNC_ONE_MINUS_DST_ALPHA:
+
FUNC_ONE_MINUS_SRC:
+
FUNC_ONE_MINUS_SRC_ALPHA:
+
FUNC_SRC_ALPHA:
+
FUNC_SRC_COLOR:
+
FUNC_ZERO:
+
GameController:
+
gameControllerAddMapping:
+
gameControllerAddMappingsFromRW:
+
GameControllerAxis:
+
GameControllerBindType:
+
GameControllerButton:
+
GameControllerButtonBind:
+
gameControllerClose:
+
gameControllerEventState:
+
gameControllerFromInstanceID:
+
gameControllerFromPlayerIndex:
+
gameControllerGetAttached:
+
gameControllerGetAxis:
+
gameControllerGetAxisFromString:
+
gameControllerGetBindForAxis:
+
gameControllerGetBindForButton:
+
gameControllerGetButton:
+
gameControllerGetButtonFromString:
+
gameControllerGetJoystick:
+
gameControllerGetPlayerIndex:
+
gameControllerGetProduct:
+
gameControllerGetProductVersion:
+
gameControllerGetStringForAxis:
+
gameControllerGetStringForButton:
+
gameControllerGetType:
+
gameControllerGetVendor:
+
gameControllerMapping:
+
gameControllerMappingForDeviceIndex:
+
gameControllerMappingForGUID:
+
gameControllerMappingForIndex:
+
gameControllerName:
+
gameControllerNameForIndex:
+
gameControllerNumMappings:
+
gameControllerOpen:
+
gameControllerRumble:
+
gameControllerSetPlayerIndex:
+
GameControllerType:
+
gameControllerTypeForIndex:
+
gameControllerUpdate:
+
generateMipmaps:
+
GenericSocket:
+
GEOMETRY_SHADER:
+
GEQUAL:
+
GestureID:
+
getActiveRendererList:
+
getActiveTarget:
+
getAnchor:
+
getAssertionHandler:
+
getAssertionReport:
+
getAttributeLocation:
+
getAudioDeviceName:
+
getAudioDeviceStatus:
+
getAudioDriver:
+
getAudioStatus:
+
getBasePath:
+
getBlending:
+
getBlendModeFromPreset:
+
getCamera:
+
getChunk:
+
getChunkDecoder:
+
getClipboardText:
+
getClipRect:
+
getClosestDisplayMode:
+
getColorKey:
+
getContextTarget:
+
getCoordinateMode:
+
getCPUCacheLineSize:
+
getCPUCount:
+
getCurrentAudioDriver:
+
getCurrentDisplayMode:
+
getCurrentMatrix:
+
getCurrentRenderer:
+
getCurrentShaderProgram:
+
getCurrentVideoDriver:
+
getCursor:
+
getDebugLevel:
+
getDefaultAnchor:
+
getDefaultAssertionHandler:
+
getDefaultCamera:
+
getDefaultCursor:
+
getDefaultRendererOrder:
+
getDesktopDisplayMode:
+
getDisplayBounds:
+
getDisplayDPI:
+
getDisplayMode:
+
getDisplayName:
+
getDisplayOrientation:
+
getDisplayUsableBounds:
+
getenv:
+
getError:
+
GetError:
+
getError:
+
GetError:
+
getErrorString:
+
GETEVENT:
+
getEventFilter:
+
getFontHinting:
+
getFontKerning:
+
getFontKerningSize:
+
getFontKerningSizeGlyphs:
+
getFontOutline:
+
getFontStyle:
+
getFramecount:
+
getFramerate:
+
getFullscreen:
+
getGlobalMouseState:
+
getGrabbedWindow:
+
getHint:
+
getHintBoolean:
+
getInitWindow:
+
getKeyboardFocus:
+
getKeyboardState:
+
getKeyFromName:
+
getKeyFromScancode:
+
getKeyName:
+
getLastError:
+
getLineThickness:
+
getLinkedVersion:
+
getLocalAddresses:
+
getMatrixString:
+
getMemoryFunctions:
+
getModel:
+
getModelViewProjection:
+
getModState:
+
getMouseFocus:
+
getMouseState:
+
getMusicDecoder:
+
getMusicHookData:
+
getMusicType:
+
getNumActiveRenderers:
+
getNumAllocations:
+
getNumAudioDevices:
+
getNumAudioDrivers:
+
getNumChunkDecoders:
+
getNumDisplayModes:
+
getNumMusicDecoders:
+
getNumRegisteredRenderers:
+
getNumRenderDrivers:
+
getNumTouchDevices:
+
getNumTouchFingers:
+
getNumVideoDisplays:
+
getNumVideoDrivers:
+
getPerformanceCounter:
+
getPerformanceFrequency:
+
getPixel:
+
getPixelFormatName:
+
getPlatform:
+
getPowerInfo:
+
getPrefPath:
+
getPreInitFlags:
+
getProjection:
+
getQueuedAudioSize:
+
getRegisteredRendererList:
+
getRelativeMouseMode:
+
getRelativeMouseState:
+
getRenderDrawBlendMode:
+
getRenderDrawColor:
+
getRenderDriverInfo:
+
getRenderer:
+
getRendererID:
+
getRendererInfo:
+
getRendererOrder:
+
getRendererOutputSize:
+
getRenderTarget:
+
getRequiredFeatures:
+
getRevision:
+
getRevisionNumber:
+
getRGB:
+
getRGBA:
+
getScancodeFromKey:
+
getScancodeFromName:
+
getScancodeName:
+
getShaderBlock:
+
getShaderMessage:
+
getShapedWindowMode:
+
getSnapMode:
+
getSoundFonts:
+
getSurfaceAlphaMod:
+
getSurfaceBlendMode:
+
getSurfaceColorMod:
+
getSynchroValue:
+
getSystemRAM:
+
getTarget:
+
getTextureAlphaMod:
+
getTextureBlendMode:
+
getTextureColorMod:
+
getTextureHandle:
+
getTextureScaleMode:
+
getThreadID:
+
getThreadName:
+
getTicks:
+
getTopMatrix:
+
getTouchDevice:
+
getTouchDeviceType:
+
getTouchFinger:
+
getUniformfv:
+
getUniformiv:
+
getUniformLocation:
+
getUniformMatrixfv:
+
getUniformuiv:
+
getVersion:
+
getVideoDriver:
+
getView:
+
getVirtualCoords:
+
getVirtualResolution:
+
getWindowBordersSize:
+
getWindowBrightness:
+
getWindowData:
+
getWindowDisplayIndex:
+
getWindowDisplayMode:
+
getWindowFlags:
+
getWindowFromID:
+
getWindowGammaRamp:
+
getWindowGrab:
+
getWindowID:
+
getWindowMaximumSize:
+
getWindowMinimumSize:
+
getWindowOpacity:
+
getWindowPixelFormat:
+
getWindowPosition:
+
getWindowSize:
+
getWindowSurface:
+
getWindowTarget:
+
getWindowTitle:
+
getYUVConversionMode:
+
getYUVConversionModeForResolution:
+
gfxPrimitivesSetFont:
+
gfxPrimitivesSetFontRotation:
+
GL_ACCELERATED_VISUAL:
+
GL_ACCUM_ALPHA_SIZE:
+
GL_ACCUM_BLUE_SIZE:
+
GL_ACCUM_GREEN_SIZE:
+
GL_ACCUM_RED_SIZE:
+
GL_ALPHA_SIZE:
+
GLattr:
+
gL_BindTexture:
+
GL_BLUE_SIZE:
+
GL_BUFFER_SIZE:
+
GLContext:
+
GL_CONTEXT_DEBUG_FLAG:
+
GL_CONTEXT_EGL:
+
GLcontextFlag:
+
GL_CONTEXT_FLAGS:
+
GL_CONTEXT_FORWARD_COMPATIBLE_FLAG:
+
GL_CONTEXT_MAJOR_VERSION:
+
GL_CONTEXT_MINOR_VERSION:
+
GL_CONTEXT_NO_ERROR:
+
GL_CONTEXT_PROFILE_COMPATIBILITY:
+
GL_CONTEXT_PROFILE_CORE:
+
GL_CONTEXT_PROFILE_ES:
+
GL_CONTEXT_PROFILE_MASK:
+
GL_CONTEXT_RELEASE_BEHAVIOR:
+
GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH:
+
GL_CONTEXT_RELEASE_BEHAVIOR_NONE:
+
GLcontextReleaseFlag:
+
GL_CONTEXT_RESET_ISOLATION_FLAG:
+
GL_CONTEXT_RESET_LOSE_CONTEXT:
+
GL_CONTEXT_RESET_NO_NOTIFICATION:
+
GL_CONTEXT_RESET_NOTIFICATION:
+
GLContextResetNotificationEnum:
+
GL_CONTEXT_ROBUST_ACCESS_FLAG:
+
gL_CreateContext:
+
gL_DeleteContext:
+
GL_DEPTH_SIZE:
+
GL_DOUBLEBUFFER:
+
gL_ExtensionSupported:
+
GL_FRAMEBUFFER_SRGB_CAPABLE:
+
gL_GetAttribute:
+
gL_GetCurrentContext:
+
gL_GetCurrentWindow:
+
gL_GetDrawableSize:
+
gL_GetProcAddress:
+
gL_GetSwapInterval:
+
GL_GREEN_SIZE:
+
gL_LoadLibrary:
+
gL_MakeCurrent:
+
GL_MULTISAMPLEBUFFERS:
+
GL_MULTISAMPLESAMPLES:
+
GLprofile:
+
GL_RED_SIZE:
+
gL_ResetAttributes:
+
GL_RETAINED_BACKING:
+
gL_SetAttribute:
+
gL_SetSwapInterval:
+
GL_SHARE_WITH_CURRENT_CONTEXT:
+
GL_STENCIL_SIZE:
+
GL_STEREO:
+
gL_SwapWindow:
+
gL_UnbindTexture:
+
gL_UnloadLibrary:
+
glyphIsProvided:
+
glyphMetrics:
+
GPU_VERSION_MAJOR:
+
GPU_VERSION_MINOR:
+
GPU_VERSION_PATCH:
+
GREATER:
+
groupAvailable:
+
groupChannel:
+
groupChannels:
+
groupCount:
+
groupNewer:
+
groupOldest:
+
haltChannel:
+
haltGroup:
+
haltMusic:
+
Haptic:
+
hapticClose:
+
HapticCondition:
+
HapticConstant:
+
HapticCustom:
+
hapticDestroyEffect:
+
HapticDirection:
+
HapticEffect:
+
hapticEffectSupported:
+
hapticGetEffectStatus:
+
hapticIndex:
+
HapticLeftRight:
+
hapticName:
+
hapticNewEffect:
+
hapticNumAxes:
+
hapticNumEffects:
+
hapticNumEffectsPlaying:
+
hapticOpen:
+
hapticOpened:
+
hapticOpenFromJoystick:
+
hapticOpenFromMouse:
+
hapticPause:
+
HapticPeriodic:
+
hapticQuery:
+
HapticRamp:
+
hapticRumbleInit:
+
hapticRumblePlay:
+
hapticRumbleStop:
+
hapticRumbleSupported:
+
hapticRunEffect:
+
hapticSetAutocenter:
+
hapticSetGain:
+
hapticStopAll:
+
hapticStopEffect:
+
HAPTIC_TYPE_AUTOCENTER:
+
HAPTIC_TYPE_CARTESIAN:
+
HAPTIC_TYPE_CONSTANT:
+
HAPTIC_TYPE_CUSTOM:
+
HAPTIC_TYPE_DAMPER:
+
HAPTIC_TYPE_FRICTION:
+
HAPTIC_TYPE_GAIN:
+
HAPTIC_TYPE_INERTIA:
+
HAPTIC_TYPE_INFINITY:
+
HAPTIC_TYPE_IOKIT:
+
HAPTIC_TYPE_LEFTRIGHT:
+
HAPTIC_TYPE_PAUSE:
+
HAPTIC_TYPE_POLAR:
+
HAPTIC_TYPE_RAMP:
+
HAPTIC_TYPE_SAWTOOTHDOWN:
+
HAPTIC_TYPE_SAWTOOTHUP:
+
HAPTIC_TYPE_SINE:
+
HAPTIC_TYPE_SPHERICAL:
+
HAPTIC_TYPE_SPRING:
+
HAPTIC_TYPE_STATUS:
+
HAPTIC_TYPE_TRIANGLE:
+
hapticUnpause:
+
hapticUpdateEffect:
+
has3DNow:
+
hasAltiVec:
+
hasARMSIMD:
+
hasAVX:
+
hasAVX2:
+
hasAVX512F:
+
hasChunkDecoder:
+
hasClipboardText:
+
hasColorKey:
+
hasEvent:
+
hasEvents:
+
hasIntersection:
+
hasMMX:
+
hasMusicDecoder:
+
hasNEON:
+
hasRDTSC:
+
hasScreenKeyboardSupport:
+
hasSSE:
+
hasSSE2:
+
hasSSE3:
+
hasSSE41:
+
hasSSE42:
+
HAT_CENTERED:
+
HAT_DOWN:
+
HAT_LEFT:
+
HAT_LEFTDOWN:
+
HAT_LEFTUP:
+
HAT_RIGHT:
+
HAT_RIGHTDOWN:
+
HAT_RIGHTUP:
+
HAT_UP:
+
HAVE_ABS:
+
HAVE_ACOS:
+
HAVE_ACOSF:
+
HAVE_ALLOCA:
+
HAVE_ALLOCA_H:
+
HAVE_ASIN:
+
HAVE_ASINF:
+
HAVE_ATAN:
+
HAVE_ATAN2:
+
HAVE_ATAN2F:
+
HAVE_ATANF:
+
HAVE_ATOF:
+
HAVE_ATOI:
+
HAVE_BCOPY:
+
HAVE_CALLOC:
+
HAVE_CEIL:
+
HAVE_CEILF:
+
HAVE_COPYSIGN:
+
HAVE_COPYSIGNF:
+
HAVE_COS:
+
HAVE_COSF:
+
HAVE_CTYPE_H:
+
HAVE_EXIT:
+
HAVE_EXP:
+
HAVE_EXPF:
+
HAVE_FABS:
+
HAVE_FABSF:
+
HAVE_FLOAT_H:
+
HAVE_FLOOR:
+
HAVE_FLOORF:
+
HAVE_FMOD:
+
HAVE_FMODF:
+
HAVE_FREE:
+
HAVE_FSEEKO:
+
HAVE_GCC_ATOMICS:
+
HAVE_GETENV:
+
HAVE_GNUC:
+
HAVE_ICONV:
+
HAVE_ICONV_H:
+
HAVE_IMMINTRIN_H:
+
HAVE_INTTYPES_H:
+
HAVE_LIBC:
+
HAVE_LIBUNWIND_H:
+
HAVE_LIMITS_H:
+
HAVE_LOG:
+
HAVE_LOG10:
+
HAVE_LOG10F:
+
HAVE_LOGF:
+
HAVE_MALLOC:
+
HAVE_MATH_H:
+
HAVE_MEMCMP:
+
HAVE_MEMCPY:
+
HAVE_MEMMOVE:
+
HAVE_MEMORY_H:
+
HAVE_MEMSET:
+
HAVE_MPROTECT:
+
HAVE_MSVC:
+
HAVE_NANOSLEEP:
+
HAVE_POLL:
+
HAVE_POW:
+
HAVE_POWF:
+
HAVE_PTHREAD_SETNAME_NP:
+
HAVE_PUTENV:
+
HAVE_QSORT:
+
HAVE_REALLOC:
+
HAVE_SA_SIGACTION:
+
HAVE_SCALBN:
+
HAVE_SCALBNF:
+
HAVE_SETENV:
+
HAVE_SETJMP:
+
HAVE_SIGACTION:
+
HAVE_SIGNAL_H:
+
HAVE_SIN:
+
HAVE_SINF:
+
HAVE_SQRT:
+
HAVE_SQRTF:
+
HAVE_STDARG_H:
+
HAVE_STDC:
+
HAVE_STDINT_H:
+
HAVE_STDIO_H:
+
HAVE_STDLIB_H:
+
HAVE_STRCASECMP:
+
HAVE_STRCHR:
+
HAVE_STRCMP:
+
HAVE_STRING_H:
+
HAVE_STRINGS_H:
+
HAVE_STRLCAT:
+
HAVE_STRLCPY:
+
HAVE_STRLEN:
+
HAVE_STRNCASECMP:
+
HAVE_STRNCMP:
+
HAVE_STRRCHR:
+
HAVE_STRSTR:
+
HAVE_STRTOD:
+
HAVE_STRTOK_R:
+
HAVE_STRTOL:
+
HAVE_STRTOLL:
+
HAVE_STRTOUL:
+
HAVE_STRTOULL:
+
HAVE_SYSCONF:
+
HAVE_SYSCTLBYNAME:
+
HAVE_SYS_TYPES_H:
+
HAVE_TAN:
+
HAVE_TANF:
+
HAVE_UNSETENV:
+
HAVE_VSNPRINTF:
+
HAVE_VSSCANF:
+
HAVE_WCHAR_H:
+
HAVE_WCSCMP:
+
HAVE_WCSDUP:
+
HAVE_WCSLCAT:
+
HAVE_WCSLCPY:
+
HAVE_WCSLEN:
+
HAVE_WCSNCMP:
+
HAVE_WCSSTR:
+
hideWindow:
+
HINT_ACCELEROMETER_AS_JOYSTICK:
+
HINT_ALLOW_TOPMOST:
+
HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION:
+
HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION:
+
HINT_ANDROID_BLOCK_ON_PAUSE:
+
HINT_ANDROID_TRAP_BACK_BUTTON:
+
HINT_APPLE_TV_CONTROLLER_UI_EVENTS:
+
HINT_APPLE_TV_REMOTE_ALLOW_ROTATION:
+
HINT_AUDIO_CATEGORY:
+
HINT_AUDIO_RESAMPLING_MODE:
+
HINT_BMP_SAVE_LEGACY_FORMAT:
+
HintCallback:
+
HINT_DEFAULT:
+
HINT_DISPLAY_USABLE_BOUNDS:
+
HINT_EMSCRIPTEN_KEYBOARD_ELEMENT:
+
HINT_ENABLE_STEAM_CONTROLLERS:
+
HINT_EVENT_LOGGING:
+
HINT_FRAMEBUFFER_ACCELERATION:
+
HINT_GAMECONTROLLERCONFIG:
+
HINT_GAMECONTROLLERCONFIG_FILE:
+
HINT_GAMECONTROLLER_IGNORE_DEVICES:
+
HINT_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT:
+
HINT_GAMECONTROLLERTYPE:
+
HINT_GAMECONTROLLER_USE_BUTTON_LABELS:
+
HINT_GRAB_KEYBOARD:
+
HINT_IDLE_TIMER_DISABLED:
+
HINT_IME_INTERNAL_EDITING:
+
HINTING_LIGHT:
+
HINTING_MONO:
+
HINTING_NONE:
+
HINTING_NORMAL:
+
HINT_IOS_HIDE_HOME_INDICATOR:
+
HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS:
+
HINT_JOYSTICK_HIDAPI:
+
HINT_JOYSTICK_HIDAPI_GAMECUBE:
+
HINT_JOYSTICK_HIDAPI_PS4:
+
HINT_JOYSTICK_HIDAPI_PS4_RUMBLE:
+
HINT_JOYSTICK_HIDAPI_STEAM:
+
HINT_JOYSTICK_HIDAPI_SWITCH:
+
HINT_JOYSTICK_HIDAPI_XBOX:
+
HINT_MAC_BACKGROUND_APP:
+
HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK:
+
HINT_MOUSE_DOUBLE_CLICK_RADIUS:
+
HINT_MOUSE_DOUBLE_CLICK_TIME:
+
HINT_MOUSE_FOCUS_CLICKTHROUGH:
+
HINT_MOUSE_NORMAL_SPEED_SCALE:
+
HINT_MOUSE_RELATIVE_MODE_WARP:
+
HINT_MOUSE_RELATIVE_SPEED_SCALE:
+
HINT_MOUSE_TOUCH_EVENTS:
+
HINT_NORMAL:
+
HINT_NO_SIGNAL_HANDLERS:
+
HINT_OPENGL_ES_DRIVER:
+
HINT_ORIENTATIONS:
+
HINT_OVERRIDE:
+
HintPriority:
+
HINT_QTWAYLAND_CONTENT_ORIENTATION:
+
HINT_QTWAYLAND_WINDOW_FLAGS:
+
HINT_RENDER_BATCHING:
+
HINT_RENDER_DIRECT3D11_DEBUG:
+
HINT_RENDER_DIRECT3D_THREADSAFE:
+
HINT_RENDER_DRIVER:
+
HINT_RENDER_LOGICAL_SIZE_MODE:
+
HINT_RENDER_OPENGL_SHADERS:
+
HINT_RENDER_SCALE_QUALITY:
+
HINT_RENDER_VSYNC:
+
HINT_RETURN_KEY_HIDES_IME:
+
HINT_RPI_VIDEO_LAYER:
+
HINT_THREAD_STACK_SIZE:
+
HINT_TIMER_RESOLUTION:
+
HINT_TOUCH_MOUSE_EVENTS:
+
HINT_TV_REMOTE_AS_JOYSTICK:
+
HINT_VIDEO_ALLOW_SCREENSAVER:
+
HINT_VIDEO_DOUBLE_BUFFER:
+
HINT_VIDEO_EXTERNAL_CONTEXT:
+
HINT_VIDEO_HIGHDPI_DISABLED:
+
HINT_VIDEO_MAC_FULLSCREEN_SPACES:
+
HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS:
+
HINT_VIDEO_WIN_D3DCOMPILER:
+
HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT:
+
HINT_VIDEO_X11_FORCE_EGL:
+
HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR:
+
HINT_VIDEO_X11_NET_WM_PING:
+
HINT_VIDEO_X11_WINDOW_VISUALID:
+
HINT_VIDEO_X11_XINERAMA:
+
HINT_VIDEO_X11_XRANDR:
+
HINT_VIDEO_X11_XVIDMODE:
+
HINT_WAVE_FACT_CHUNK:
+
HINT_WAVE_RIFF_CHUNK_SIZE:
+
HINT_WAVE_TRUNCATION:
+
HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN:
+
HINT_WINDOWS_DISABLE_THREAD_NAMING:
+
HINT_WINDOWS_ENABLE_MESSAGELOOP:
+
HINT_WINDOWS_INTRESOURCE_ICON:
+
HINT_WINDOWS_INTRESOURCE_ICON_SMALL:
+
HINT_WINDOWS_NO_CLOSE_ON_ALT_F4:
+
HINT_WINRT_HANDLE_BACK_BUTTON:
+
HINT_WINRT_PRIVACY_POLICY_LABEL:
+
HINT_WINRT_PRIVACY_POLICY_URL:
+
HINT_XINPUT_ENABLED:
+
HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING:
+
HitTest:
+
HITTEST_DRAGGABLE:
+
HITTEST_NORMAL:
+
HITTEST_RESIZE_BOTTOM:
+
HITTEST_RESIZE_BOTTOMLEFT:
+
HITTEST_RESIZE_BOTTOMRIGHT:
+
HITTEST_RESIZE_LEFT:
+
HITTEST_RESIZE_RIGHT:
+
HITTEST_RESIZE_TOP:
+
HITTEST_RESIZE_TOPLEFT:
+
HITTEST_RESIZE_TOPRIGHT:
+
HitTestResult:
+
hlineColor:
+
hlineRGBA:
+
hookMusic:
+
hookMusicFinished:
+
iconv:
+
iconv_close:
+
ICONV_E2BIG:
+
ICONV_EILSEQ:
+
ICONV_EINVAL:
+
ICONV_ERROR:
+
iconv_open:
+
iconv_string:
+
iconv_t:
+
IGNORE:
+
Image:
+
imageFilterAbsDiff:
+
imageFilterAdd:
+
imageFilterAddByte:
+
imageFilterAddByteToHalf:
+
imageFilterAddUint:
+
imageFilterBinarizeUsingThreshold:
+
imageFilterBitAnd:
+
imageFilterBitNegation:
+
imageFilterBitOr:
+
imageFilterClipToRange:
+
imageFilterDiv:
+
imageFilterMean:
+
imageFilterMMXdetect:
+
imageFilterMMXoff:
+
imageFilterMMXon:
+
imageFilterMult:
+
imageFilterMultByByte:
+
imageFilterMultDivby2:
+
imageFilterMultDivby4:
+
imageFilterMultNor:
+
imageFilterNormalizeLinear:
+
imageFilterShiftLeft:
+
imageFilterShiftLeftByte:
+
imageFilterShiftLeftUint:
+
imageFilterShiftRight:
+
imageFilterShiftRightAndMultByByte:
+
imageFilterShiftRightUint:
+
imageFilterSub:
+
imageFilterSubByte:
+
imageFilterSubUint:
+
IMAGE_MAJOR_VERSION:
+
IMAGE_MINOR_VERSION:
+
IMAGE_PATCHLEVEL:
+
INADDR_ANY:
+
INADDR_BROADCAST:
+
INADDR_LOOPBACK:
+
INADDR_NONE:
+
init:
+
INIT_AUDIO:
+
INIT_DISABLE_AUTO_VIRTUAL_RESOLUTION:
+
INIT_DISABLE_DOUBLE_BUFFER:
+
INIT_DISABLE_VSYNC:
+
INIT_ENABLE_VSYNC:
+
INIT_EVENTS:
+
INIT_EVERYTHING:
+
InitFlagEnum:
+
InitFlags:
+
initFramerate:
+
INIT_GAMECONTROLLER:
+
INIT_HAPTIC:
+
INIT_JOYSTICK:
+
INIT_JPG:
+
initMatrixStack:
+
INIT_NOPARACHUTE:
+
INIT_PNG:
+
initRenderer:
+
initRendererByID:
+
INIT_REQUEST_COMPATIBILITY_PROFILE:
+
INIT_SENSOR:
+
initSubSystem:
+
INIT_TIF:
+
INIT_TIMER:
+
INIT_USE_COPY_TEXTURE_UPLOAD_FALLBACK:
+
INIT_USE_ROW_BY_ROW_TEXTURE_UPLOAD_FALLBACK:
+
INIT_VIDEO:
+
INIT_WEBP:
+
intersectClipRect:
+
intersectRect:
+
intersectRectAndLine:
+
INVALID_SHAPE_ARGUMENT:
+
INVALID_SOCKET:
+
IPaddress:
+
isBMP:
+
isCameraEnabled:
+
isCUR:
+
isDefaultShaderProgram:
+
isdigit:
+
isFeatureEnabled:
+
isGameController:
+
isGIF:
+
isICO:
+
isJPG:
+
isLBM:
+
islower:
+
isPCX:
+
isPNG:
+
isPNM:
+
isScreenKeyboardShown:
+
isScreenSaverEnabled:
+
isShapedWindow:
+
isspace:
+
isSVG:
+
isTablet:
+
isTextInputActive:
+
isTIF:
+
isupper:
+
isWEBP:
+
isXCF:
+
isXPM:
+
isXV:
+
itoa:
+
JoyAxisEvent:
+
JoyBallEvent:
+
JoyButtonEvent:
+
JoyDeviceEvent:
+
JoyHatEvent:
+
Joystick:
+
JOYSTICK_AXIS_MAX:
+
JOYSTICK_AXIS_MIN:
+
joystickClose:
+
joystickCurrentPowerLevel:
+
joystickEventState:
+
joystickFromInstanceID:
+
joystickFromPlayerIndex:
+
joystickGetAttached:
+
joystickGetAxis:
+
joystickGetAxisInitialState:
+
joystickGetBall:
+
joystickGetButton:
+
joystickGetDeviceGUID:
+
joystickGetDeviceInstanceID:
+
joystickGetDevicePlayerIndex:
+
joystickGetDeviceProduct:
+
joystickGetDeviceProductVersion:
+
joystickGetDeviceType:
+
joystickGetDeviceVendor:
+
joystickGetGUID:
+
joystickGetGUIDFromString:
+
joystickGetGUIDString:
+
joystickGetHat:
+
joystickGetPlayerIndex:
+
joystickGetProduct:
+
joystickGetProductVersion:
+
joystickGetType:
+
joystickGetVendor:
+
JoystickGUID:
+
JoystickID:
+
joystickInstanceID:
+
JOYSTICK_IOKIT:
+
joystickIsHaptic:
+
joystickName:
+
joystickNameForIndex:
+
joystickNumAxes:
+
joystickNumBalls:
+
joystickNumButtons:
+
joystickNumHats:
+
joystickOpen:
+
JOYSTICK_POWER_EMPTY:
+
JOYSTICK_POWER_FULL:
+
JoystickPowerLevel:
+
JOYSTICK_POWER_LOW:
+
JOYSTICK_POWER_MAX:
+
JOYSTICK_POWER_MEDIUM:
+
JOYSTICK_POWER_UNKNOWN:
+
JOYSTICK_POWER_WIRED:
+
joystickRumble:
+
joystickSetPlayerIndex:
+
JoystickType:
+
JOYSTICK_TYPE_ARCADE_PAD:
+
JOYSTICK_TYPE_ARCADE_STICK:
+
JOYSTICK_TYPE_DANCE_PAD:
+
JOYSTICK_TYPE_DRUM_KIT:
+
JOYSTICK_TYPE_FLIGHT_STICK:
+
JOYSTICK_TYPE_GAMECONTROLLER:
+
JOYSTICK_TYPE_GUITAR:
+
JOYSTICK_TYPE_THROTTLE:
+
JOYSTICK_TYPE_UNKNOWN:
+
JOYSTICK_TYPE_WHEEL:
+
joystickUpdate:
+
KeyboardEvent:
+
Keycode:
+
KEYCODE_0:
+
KEYCODE_1:
+
KEYCODE_2:
+
KEYCODE_3:
+
KEYCODE_4:
+
KEYCODE_5:
+
KEYCODE_6:
+
KEYCODE_7:
+
KEYCODE_8:
+
KEYCODE_9:
+
KEYCODE_a:
+
KEYCODE_AC_BACK:
+
KEYCODE_AC_BOOKMARKS:
+
KEYCODE_AC_FORWARD:
+
KEYCODE_AC_HOME:
+
KEYCODE_AC_REFRESH:
+
KEYCODE_AC_SEARCH:
+
KEYCODE_AC_STOP:
+
KEYCODE_AGAIN:
+
KEYCODE_ALTERASE:
+
KEYCODE_AMPERSAND:
+
KEYCODE_APP1:
+
KEYCODE_APP2:
+
KEYCODE_APPLICATION:
+
KEYCODE_ASTERISK:
+
KEYCODE_AT:
+
KEYCODE_AUDIOFASTFORWARD:
+
KEYCODE_AUDIOMUTE:
+
KEYCODE_AUDIONEXT:
+
KEYCODE_AUDIOPLAY:
+
KEYCODE_AUDIOPREV:
+
KEYCODE_AUDIOREWIND:
+
KEYCODE_AUDIOSTOP:
+
KEYCODE_b:
+
KEYCODE_BACKQUOTE:
+
KEYCODE_BACKSLASH:
+
KEYCODE_BACKSPACE:
+
KEYCODE_BRIGHTNESSDOWN:
+
KEYCODE_BRIGHTNESSUP:
+
KEYCODE_c:
+
KEYCODE_CALCULATOR:
+
KEYCODE_CANCEL:
+
KEYCODE_CAPSLOCK:
+
KEYCODE_CARET:
+
KEYCODE_CLEAR:
+
KEYCODE_CLEARAGAIN:
+
KEYCODE_COLON:
+
KEYCODE_COMMA:
+
KEYCODE_COMPUTER:
+
KEYCODE_COPY:
+
KEYCODE_CRSEL:
+
KEYCODE_CURRENCYSUBUNIT:
+
KEYCODE_CURRENCYUNIT:
+
KEYCODE_CUT:
+
KEYCODE_d:
+
KEYCODE_DECIMALSEPARATOR:
+
KEYCODE_DELETE:
+
KEYCODE_DISPLAYSWITCH:
+
KEYCODE_DOLLAR:
+
KEYCODE_DOWN:
+
KEYCODE_e:
+
KEYCODE_EJECT:
+
KEYCODE_END:
+
KeyCodeEnum:
+
KEYCODE_EQUALS:
+
KEYCODE_ESCAPE:
+
KEYCODE_EXCLAIM:
+
KEYCODE_EXECUTE:
+
KEYCODE_EXSEL:
+
KEYCODE_f:
+
KEYCODE_F1:
+
KEYCODE_F10:
+
KEYCODE_F11:
+
KEYCODE_F12:
+
KEYCODE_F13:
+
KEYCODE_F14:
+
KEYCODE_F15:
+
KEYCODE_F16:
+
KEYCODE_F17:
+
KEYCODE_F18:
+
KEYCODE_F19:
+
KEYCODE_F2:
+
KEYCODE_F20:
+
KEYCODE_F21:
+
KEYCODE_F22:
+
KEYCODE_F23:
+
KEYCODE_F24:
+
KEYCODE_F3:
+
KEYCODE_F4:
+
KEYCODE_F5:
+
KEYCODE_F6:
+
KEYCODE_F7:
+
KEYCODE_F8:
+
KEYCODE_F9:
+
KEYCODE_FIND:
+
KEYCODE_g:
+
KEYCODE_GREATER:
+
KEYCODE_h:
+
KEYCODE_HASH:
+
KEYCODE_HELP:
+
KEYCODE_HOME:
+
KEYCODE_i:
+
KEYCODE_INSERT:
+
KEYCODE_j:
+
KEYCODE_k:
+
KEYCODE_KBDILLUMDOWN:
+
KEYCODE_KBDILLUMTOGGLE:
+
KEYCODE_KBDILLUMUP:
+
KEYCODE_KP_0:
+
KEYCODE_KP_00:
+
KEYCODE_KP_000:
+
KEYCODE_KP_1:
+
KEYCODE_KP_2:
+
KEYCODE_KP_3:
+
KEYCODE_KP_4:
+
KEYCODE_KP_5:
+
KEYCODE_KP_6:
+
KEYCODE_KP_7:
+
KEYCODE_KP_8:
+
KEYCODE_KP_9:
+
KEYCODE_KP_A:
+
KEYCODE_KP_AMPERSAND:
+
KEYCODE_KP_AT:
+
KEYCODE_KP_B:
+
KEYCODE_KP_BACKSPACE:
+
KEYCODE_KP_BINARY:
+
KEYCODE_KP_C:
+
KEYCODE_KP_CLEAR:
+
KEYCODE_KP_CLEARENTRY:
+
KEYCODE_KP_COLON:
+
KEYCODE_KP_COMMA:
+
KEYCODE_KP_D:
+
KEYCODE_KP_DBLAMPERSAND:
+
KEYCODE_KP_DBLVERTICALBAR:
+
KEYCODE_KP_DECIMAL:
+
KEYCODE_KP_DIVIDE:
+
KEYCODE_KP_E:
+
KEYCODE_KP_ENTER:
+
KEYCODE_KP_EQUALS:
+
KEYCODE_KP_EQUALSAS400:
+
KEYCODE_KP_EXCLAM:
+
KEYCODE_KP_F:
+
KEYCODE_KP_GREATER:
+
KEYCODE_KP_HASH:
+
KEYCODE_KP_HEXADECIMAL:
+
KEYCODE_KP_LEFTBRACE:
+
KEYCODE_KP_LEFTPAREN:
+
KEYCODE_KP_LESS:
+
KEYCODE_KP_MEMADD:
+
KEYCODE_KP_MEMCLEAR:
+
KEYCODE_KP_MEMDIVIDE:
+
KEYCODE_KP_MEMMULTIPLY:
+
KEYCODE_KP_MEMRECALL:
+
KEYCODE_KP_MEMSTORE:
+
KEYCODE_KP_MEMSUBTRACT:
+
KEYCODE_KP_MINUS:
+
KEYCODE_KP_MULTIPLY:
+
KEYCODE_KP_OCTAL:
+
KEYCODE_KP_PERCENT:
+
KEYCODE_KP_PERIOD:
+
KEYCODE_KP_PLUS:
+
KEYCODE_KP_PLUSMINUS:
+
KEYCODE_KP_POWER:
+
KEYCODE_KP_RIGHTBRACE:
+
KEYCODE_KP_RIGHTPAREN:
+
KEYCODE_KP_SPACE:
+
KEYCODE_KP_TAB:
+
KEYCODE_KP_VERTICALBAR:
+
KEYCODE_KP_XOR:
+
KEYCODE_l:
+
KEYCODE_LALT:
+
KEYCODE_LCTRL:
+
KEYCODE_LEFT:
+
KEYCODE_LEFTBRACKET:
+
KEYCODE_LEFTPAREN:
+
KEYCODE_LESS:
+
KEYCODE_LGUI:
+
KEYCODE_LSHIFT:
+
KEYCODE_m:
+
KEYCODE_MAIL:
+
KEYCODE_MEDIASELECT:
+
KEYCODE_MENU:
+
KEYCODE_MINUS:
+
KEYCODE_MODE:
+
KEYCODE_MUTE:
+
KEYCODE_n:
+
KEYCODE_NUMLOCKCLEAR:
+
KEYCODE_o:
+
KEYCODE_OPER:
+
KEYCODE_OUT:
+
KEYCODE_p:
+
KEYCODE_PAGEDOWN:
+
KEYCODE_PAGEUP:
+
KEYCODE_PASTE:
+
KEYCODE_PAUSE:
+
KEYCODE_PERCENT:
+
KEYCODE_PERIOD:
+
KEYCODE_PLUS:
+
KEYCODE_POWER:
+
KEYCODE_PRINTSCREEN:
+
KEYCODE_PRIOR:
+
KEYCODE_q:
+
KEYCODE_QUESTION:
+
KEYCODE_QUOTE:
+
KEYCODE_QUOTEDBL:
+
KEYCODE_r:
+
KEYCODE_RALT:
+
KEYCODE_RCTRL:
+
KEYCODE_RETURN:
+
KEYCODE_RETURN2:
+
KEYCODE_RGUI:
+
KEYCODE_RIGHT:
+
KEYCODE_RIGHTBRACKET:
+
KEYCODE_RIGHTPAREN:
+
KEYCODE_RSHIFT:
+
KEYCODE_s:
+
KEYCODE_SCANCODE_MASK:
+
KEYCODE_SCROLLLOCK:
+
KEYCODE_SELECT:
+
KEYCODE_SEMICOLON:
+
KEYCODE_SEPARATOR:
+
KEYCODE_SLASH:
+
KEYCODE_SLEEP:
+
KEYCODE_SPACE:
+
KEYCODE_STOP:
+
KEYCODE_SYSREQ:
+
KEYCODE_t:
+
KEYCODE_TAB:
+
KEYCODE_THOUSANDSSEPARATOR:
+
KEYCODE_u:
+
KEYCODE_UNDERSCORE:
+
KEYCODE_UNDO:
+
KEYCODE_UNKNOWN:
+
KEYCODE_UP:
+
KEYCODE_v:
+
KEYCODE_VOLUMEDOWN:
+
KEYCODE_VOLUMEUP:
+
KEYCODE_w:
+
KEYCODE_WWW:
+
KEYCODE_x:
+
KEYCODE_y:
+
KEYCODE_z:
+
Keymod:
+
Keysym:
+
KMOD_ALT:
+
KMOD_CAPS:
+
KMOD_CTRL:
+
KMOD_GUI:
+
KMOD_LALT:
+
KMOD_LCTRL:
+
KMOD_LGUI:
+
KMOD_LSHIFT:
+
KMOD_MODE:
+
KMOD_NONE:
+
KMOD_NUM:
+
KMOD_RALT:
+
KMOD_RCTRL:
+
KMOD_RESERVED:
+
KMOD_RGUI:
+
KMOD_RSHIFT:
+
KMOD_SHIFT:
+
LANGUAGE_ARB_ASSEMBLY:
+
LANGUAGE_CG:
+
LANGUAGE_GLSL:
+
LANGUAGE_GLSLES:
+
LANGUAGE_HLSL:
+
LANGUAGE_NONE:
+
LASTERROR:
+
LEQUAL:
+
LESS:
+
LIL_ENDIAN:
+
line:
+
lineColor:
+
LINE_LOOP:
+
lineRGBA:
+
LINES:
+
LINE_STRIP:
+
linked_Version:
+
linkManyShaders:
+
linkShaderProgram:
+
linkShaders:
+
lltoa:
+
load:
+
loadBMP_RW:
+
loadCUR_RW:
+
loadDollarTemplates:
+
loadFile:
+
loadFile_RW:
+
loadFunction:
+
loadGIF_RW:
+
loadICO_RW:
+
loadIdentity:
+
loadImage:
+
loadImage_RW:
+
loadJPG_RW:
+
loadLBM_RW:
+
loadMatrix:
+
loadMUS:
+
loadMUS_RW:
+
loadMUSType_RW:
+
loadObject:
+
loadPCX_RW:
+
loadPNG_RW:
+
loadPNM_RW:
+
load_RW:
+
loadShader:
+
loadShaderBlock:
+
LOADSO_DLOPEN:
+
loadSurface:
+
loadSurface_RW:
+
loadSVG_RW:
+
loadTarget:
+
loadTexture:
+
loadTexture_RW:
+
loadTextureTyped_RW:
+
loadTGA_RW:
+
loadTIF_RW:
+
loadTyped_RW:
+
loadWAV_RW:
+
loadWEBP_RW:
+
loadXCF_RW:
+
loadXPM_RW:
+
loadXV_RW:
+
lockAudio:
+
lockAudioDevice:
+
lockJoysticks:
+
lockMutex:
+
lockSurface:
+
lockTexture:
+
lockTextureToSurface:
+
log:
+
log10:
+
log10f:
+
LogCategory:
+
LOG_CATEGORY_APPLICATION:
+
LOG_CATEGORY_ASSERT:
+
LOG_CATEGORY_AUDIO:
+
LOG_CATEGORY_CUSTOM:
+
LOG_CATEGORY_ERROR:
+
LOG_CATEGORY_INPUT:
+
LOG_CATEGORY_RENDER:
+
LOG_CATEGORY_RESERVED1:
+
LOG_CATEGORY_RESERVED10:
+
LOG_CATEGORY_RESERVED2:
+
LOG_CATEGORY_RESERVED3:
+
LOG_CATEGORY_RESERVED4:
+
LOG_CATEGORY_RESERVED5:
+
LOG_CATEGORY_RESERVED6:
+
LOG_CATEGORY_RESERVED7:
+
LOG_CATEGORY_RESERVED8:
+
LOG_CATEGORY_RESERVED9:
+
LOG_CATEGORY_SYSTEM:
+
LOG_CATEGORY_TEST:
+
LOG_CATEGORY_VIDEO:
+
logCritical:
+
logDebug:
+
logError:
+
logf:
+
logGetOutputFunction:
+
logGetPriority:
+
logInfo:
+
LogLevelEnum:
+
LOG_LEVEL_ERROR:
+
LOG_LEVEL_INFO:
+
LOG_LEVEL_WARNING:
+
logMessage:
+
logMessageV:
+
LogOutputFunction:
+
LogPriority:
+
LOG_PRIORITY_CRITICAL:
+
LOG_PRIORITY_DEBUG:
+
LOG_PRIORITY_ERROR:
+
LOG_PRIORITY_INFO:
+
LOG_PRIORITY_VERBOSE:
+
LOG_PRIORITY_WARN:
+
logResetPriorities:
+
logSetAllPriority:
+
logSetOutputFunction:
+
logSetPriority:
+
logVerbose:
+
logWarn:
+
logWarning:
+
lookAt:
+
lowerBlit:
+
lowerBlitScaled:
+
ltoa:
+
MACOSX:
+
main:
+
main_func:
+
MAJOR_VERSION:
+
makeAttribute:
+
makeAttributeFormat:
+
makeColor:
+
makeCurrent:
+
makeRect:
+
makeRendererID:
+
malloc:
+
malloc_func:
+
mapRGB:
+
mapRGBA:
+
masksToPixelFormatEnum:
+
matrixCopy:
+
matrixFrustum:
+
matrixIdentity:
+
matrixLookAt:
+
matrixMode:
+
matrixMultiply:
+
matrixOrtho:
+
matrixPerspective:
+
matrixRotate:
+
matrixScale:
+
MatrixStack:
+
matrixTranslate:
+
maximizeWindow:
+
MAX_LOG_MESSAGE:
+
MAX_SINT16:
+
MAX_SINT32:
+
MAX_SINT64:
+
MAX_SINT8:
+
MAX_UINT16:
+
MAX_UINT32:
+
MAX_UINT64:
+
MAX_UINT8:
+
memcmp:
+
memcpy:
+
memmove:
+
memoryBarrierAcquireFunction:
+
memoryBarrierReleaseFunction:
+
memset:
+
MessageBoxButtonData:
+
MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT:
+
MessageBoxButtonFlags:
+
MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT:
+
MESSAGEBOX_BUTTONS_LEFT_TO_RIGHT:
+
MESSAGEBOX_BUTTONS_RIGHT_TO_LEFT:
+
MessageBoxColor:
+
MESSAGEBOX_COLOR_BACKGROUND:
+
MESSAGEBOX_COLOR_BUTTON_BACKGROUND:
+
MESSAGEBOX_COLOR_BUTTON_BORDER:
+
MESSAGEBOX_COLOR_BUTTON_SELECTED:
+
MESSAGEBOX_COLOR_MAX:
+
MessageBoxColorScheme:
+
MESSAGEBOX_COLOR_TEXT:
+
MessageBoxColorType:
+
MessageBoxData:
+
MESSAGEBOX_ERROR:
+
MessageBoxFlags:
+
MESSAGEBOX_INFORMATION:
+
MESSAGEBOX_WARNING:
+
metal_CreateView:
+
metal_DestroyView:
+
MetalView:
+
minimizeWindow:
+
MINOR_VERSION:
+
MIN_SINT16:
+
MIN_SINT32:
+
MIN_SINT8:
+
MIN_UINT16:
+
MIN_UINT32:
+
MIN_UINT64:
+
MIN_UINT8:
+
mixAudio:
+
mixAudioFormat:
+
MIX_CHANNEL_POST:
+
MIX_CHANNELS:
+
MIX_DEFAULT_CHANNELS:
+
MIX_DEFAULT_FREQUENCY:
+
MIX_EFFECTSMAXSPEED:
+
MIXER_MAJOR_VERSION:
+
MIXER_MINOR_VERSION:
+
MIXER_PATCHLEVEL:
+
MIX_FADING_IN:
+
MIX_FADING_OUT:
+
MIX_INIT_FLAC:
+
MIX_InitFlags:
+
MIX_INIT_MID:
+
MIX_INIT_MOD:
+
MIX_INIT_MP3:
+
MIX_INIT_OGG:
+
MIX_INIT_OPUS:
+
MIX_MAJOR_VERSION:
+
MIX_MAXVOLUME:
+
MIX_MINOR_VERSION:
+
MIX_NO_FADING:
+
MIX_PATCHLEVEL:
+
MODEL:
+
MouseButtonEvent:
+
mouseIsHaptic:
+
MouseMotionEvent:
+
MOUSE_TOUCHID:
+
MouseWheelDirection:
+
MouseWheelEvent:
+
MOUSEWHEEL_FLIPPED:
+
MOUSEWHEEL_NORMAL:
+
MultiGestureEvent:
+
multiplyAndAssign:
+
multMatrix:
+
MUS_CMD:
+
MUS_FLAC:
+
Music:
+
MusicType:
+
MUS_MID:
+
MUS_MOD:
+
MUS_MODPLUG_UNUSED:
+
MUS_MP3:
+
MUS_MP3_MAD_UNUSED:
+
MUS_NONE:
+
MUS_OGG:
+
MUS_OPUS:
+
MUS_WAV:
+
mutex:
+
MUTEX_MAXWAIT:
+
MUTEX_TIMEDOUT:
+
NET_MAJOR_VERSION:
+
NET_MINOR_VERSION:
+
NET_PATCHLEVEL:
+
NEVER:
+
newAudioStream:
+
NONE:
+
NONSHAPEABLE_WINDOW:
+
NOTEQUAL:
+
NULL_WHILE_LOOP_CONDITION:
+
numHaptics:
+
numJoysticks:
+
NUM_LOG_PRIORITIES:
+
NUM_SCANCODES:
+
numSensors:
+
NUM_SYSTEM_CURSORS:
+
onApplicationDidBecomeActive:
+
onApplicationDidEnterBackground:
+
onApplicationDidReceiveMemoryWarning:
+
onApplicationWillEnterForeground:
+
onApplicationWillResignActive:
+
onApplicationWillTerminate:
+
openAudio:
+
openAudioDevice:
+
openFont:
+
openFontIndex:
+
openFontIndexRW:
+
openFontRW:
+
ORIENTATION_LANDSCAPE:
+
ORIENTATION_LANDSCAPE_FLIPPED:
+
ORIENTATION_PORTRAIT:
+
ORIENTATION_PORTRAIT_FLIPPED:
+
ORIENTATION_UNKNOWN:
+
ortho:
+
OSEvent:
+
PackedLayout:
+
PACKEDLAYOUT_1010102:
+
PACKEDLAYOUT_1555:
+
PACKEDLAYOUT_2101010:
+
PACKEDLAYOUT_332:
+
PACKEDLAYOUT_4444:
+
PACKEDLAYOUT_5551:
+
PACKEDLAYOUT_565:
+
PACKEDLAYOUT_8888:
+
PACKEDLAYOUT_NONE:
+
PackedOrder:
+
PACKEDORDER_ABGR:
+
PACKEDORDER_ARGB:
+
PACKEDORDER_BGRA:
+
PACKEDORDER_BGRX:
+
PACKEDORDER_NONE:
+
PACKEDORDER_RGBA:
+
PACKEDORDER_RGBX:
+
PACKEDORDER_XBGR:
+
PACKEDORDER_XRGB:
+
Palette:
+
PATCHLEVEL:
+
pause:
+
pauseAudio:
+
pauseAudioDevice:
+
paused:
+
pausedMusic:
+
pauseMusic:
+
PEEKEVENT:
+
peepEvents:
+
perspective:
+
PHaptic:
+
pieColor:
+
pieRGBA:
+
pixel:
+
pixelColor:
+
PixelFormat:
+
PIXELFORMAT_ABGR1555:
+
PIXELFORMAT_ABGR32:
+
PIXELFORMAT_ABGR4444:
+
PIXELFORMAT_ABGR8888:
+
PIXELFORMAT_ARGB1555:
+
PIXELFORMAT_ARGB2101010:
+
PIXELFORMAT_ARGB32:
+
PIXELFORMAT_ARGB4444:
+
PIXELFORMAT_ARGB8888:
+
PIXELFORMAT_BGR24:
+
PIXELFORMAT_BGR444:
+
PIXELFORMAT_BGR555:
+
PIXELFORMAT_BGR565:
+
PIXELFORMAT_BGR888:
+
PIXELFORMAT_BGRA32:
+
PIXELFORMAT_BGRA4444:
+
PIXELFORMAT_BGRA5551:
+
PIXELFORMAT_BGRA8888:
+
PIXELFORMAT_BGRX8888:
+
PixelFormatEnum:
+
pixelFormatEnumToMasks:
+
PIXELFORMAT_EXTERNAL_OES:
+
PIXELFORMAT_INDEX1LSB:
+
PIXELFORMAT_INDEX1MSB:
+
PIXELFORMAT_INDEX4LSB:
+
PIXELFORMAT_INDEX4MSB:
+
PIXELFORMAT_INDEX8:
+
PIXELFORMAT_IYUV:
+
PIXELFORMAT_NV12:
+
PIXELFORMAT_NV21:
+
PIXELFORMAT_RGB24:
+
PIXELFORMAT_RGB332:
+
PIXELFORMAT_RGB444:
+
PIXELFORMAT_RGB555:
+
PIXELFORMAT_RGB565:
+
PIXELFORMAT_RGB888:
+
PIXELFORMAT_RGBA32:
+
PIXELFORMAT_RGBA4444:
+
PIXELFORMAT_RGBA5551:
+
PIXELFORMAT_RGBA8888:
+
PIXELFORMAT_RGBX8888:
+
PIXELFORMAT_UNKNOWN:
+
PIXELFORMAT_UYVY:
+
PIXELFORMAT_YUY2:
+
PIXELFORMAT_YV12:
+
PIXELFORMAT_YVYU:
+
pixelRGBA:
+
PIXEL_SHADER:
+
PixelType:
+
PIXELTYPE_ARRAYF16:
+
PIXELTYPE_ARRAYF32:
+
PIXELTYPE_ARRAYU16:
+
PIXELTYPE_ARRAYU32:
+
PIXELTYPE_ARRAYU8:
+
PIXELTYPE_INDEX1:
+
PIXELTYPE_INDEX4:
+
PIXELTYPE_INDEX8:
+
PIXELTYPE_PACKED16:
+
PIXELTYPE_PACKED32:
+
PIXELTYPE_PACKED8:
+
PIXELTYPE_UNKNOWN:
+
playChannelTimed:
+
playing:
+
playingMusic:
+
playMusic:
+
Point:
+
POINTS:
+
pollEvent:
+
polygon:
+
polygonColor:
+
polygonFilled:
+
polygonRGBA:
+
polyline:
+
popErrorCode:
+
popMatrix:
+
pow:
+
POWER_MACOSX:
+
PowerState:
+
POWERSTATE_CHARGED:
+
POWERSTATE_CHARGING:
+
POWERSTATE_NO_BATTERY:
+
POWERSTATE_ON_BATTERY:
+
POWERSTATE_UNKNOWN:
+
powf:
+
PREALLOC:
+
PRESSED:
+
primitiveBatch:
+
primitiveBatchV:
+
PrimitiveEnum:
+
PRIs64:
+
PROJECTION:
+
pumpEvents:
+
pushErrorCode:
+
pushEvent:
+
pushMatrix:
+
qsort:
+
QUERY:
+
querySpec:
+
queryTexture:
+
queueAudio:
+
quickLoad_RAW:
+
quickLoad_WAV:
+
quit:
+
QuitEvent:
+
quitSubSystem:
+
raiseWindow:
+
readBE16:
+
readBE32:
+
readBE64:
+
readLE16:
+
readLE32:
+
readLE64:
+
readU8:
+
readXPMFromArray:
+
realloc:
+
realloc_func:
+
recordGesture:
+
Rect:
+
rectangle:
+
rectangle2:
+
rectangleColor:
+
rectangleFilled:
+
rectangleFilled2:
+
rectangleRGBA:
+
rectangleRound:
+
rectangleRound2:
+
rectangleRoundFilled:
+
rectangleRoundFilled2:
+
registerEffect:
+
registerEvents:
+
registerRenderer:
+
RELEASED:
+
removeTimer:
+
renderClear:
+
renderCopy:
+
renderCopyEx:
+
renderCopyExF:
+
renderCopyF:
+
renderDrawLine:
+
renderDrawLineF:
+
renderDrawLines:
+
renderDrawLinesF:
+
renderDrawPoint:
+
renderDrawPointF:
+
renderDrawPoints:
+
renderDrawPointsF:
+
renderDrawRect:
+
renderDrawRectF:
+
renderDrawRects:
+
renderDrawRectsF:
+
Renderer:
+
RENDERER_ACCELERATED:
+
RENDERER_CUSTOM_0:
+
RENDERER_D3D10:
+
RENDERER_D3D11:
+
RENDERER_D3D9:
+
RendererEnum:
+
RendererFlags:
+
RendererFlip:
+
RENDERER_GLES_1:
+
RENDERER_GLES_2:
+
RENDERER_GLES_3:
+
RendererID:
+
RendererImpl:
+
RendererInfo:
+
RENDERER_OPENGL_1:
+
RENDERER_OPENGL_1_BASE:
+
RENDERER_OPENGL_2:
+
RENDERER_OPENGL_3:
+
RENDERER_OPENGL_4:
+
RENDERER_ORDER_MAX:
+
RENDERER_PRESENTVSYNC:
+
RENDERER_SOFTWARE:
+
RENDERER_TARGETTEXTURE:
+
RENDERER_UNKNOWN:
+
renderFillRect:
+
renderFillRectF:
+
renderFillRects:
+
renderFillRectsF:
+
renderFlush:
+
renderGetClipRect:
+
renderGetIntegerScale:
+
renderGetLogicalSize:
+
renderGetMetalCommandEncoder:
+
renderGetMetalLayer:
+
renderGetScale:
+
renderGetViewport:
+
renderGlyph_Blended:
+
renderGlyph_Shaded:
+
renderGlyph_Solid:
+
renderIsClipEnabled:
+
renderPresent:
+
renderReadPixels:
+
renderSetClipRect:
+
renderSetIntegerScale:
+
renderSetLogicalSize:
+
renderSetScale:
+
renderSetViewport:
+
renderTargetSupported:
+
renderText_Blended:
+
renderText_Blended_Wrapped:
+
renderText_Shaded:
+
renderText_Solid:
+
renderUNICODE_Blended:
+
renderUNICODE_Blended_Wrapped:
+
renderUNICODE_Shaded:
+
renderUNICODE_Solid:
+
renderUTF8_Blended:
+
renderUTF8_Blended_Wrapped:
+
renderUTF8_Shaded:
+
renderUTF8_Solid:
+
replaceImage:
+
reportAssertion:
+
reserveChannels:
+
reserveNextRendererEnum:
+
resetAssertionReport:
+
resetProjection:
+
resetRendererState:
+
resizePacket:
+
resolveHost:
+
resolveIP:
+
restoreWindow:
+
resume:
+
resumeMusic:
+
rewindMusic:
+
RLEACCEL:
+
rotate:
+
rotateSurface90Degrees:
+
rotozoomSurface:
+
rotozoomSurfaceSize:
+
rotozoomSurfaceSizeXY:
+
rotozoomSurfaceXY:
+
roundedBoxColor:
+
roundedBoxRGBA:
+
roundedRectangleColor:
+
roundedRectangleRGBA:
+
rWclose:
+
rWFromConstMem:
+
rWFromFile:
+
rWFromFP:
+
rWFromMem:
+
RWops:
+
RWOPS_JNIFILE:
+
RWOPS_MEMORY:
+
RWOPS_MEMORY_RO:
+
RWOPS_STDFILE:
+
RWOPS_UNKNOWN:
+
RWOPS_WINFILE:
+
rWread:
+
rWseek:
+
RW_SEEK_CUR:
+
RW_SEEK_END:
+
RW_SEEK_SET:
+
rWsize:
+
rWtell:
+
rWwrite:
+
saveAllDollarTemplates:
+
saveBMP_RW:
+
saveDollarTemplate:
+
saveImage:
+
saveImage_RW:
+
saveJPG:
+
saveJPG_RW:
+
savePNG:
+
savePNG_RW:
+
saveSurface:
+
saveSurface_RW:
+
scalbn:
+
scalbnf:
+
scale:
+
ScaleMode:
+
ScaleModeBest:
+
ScaleModeLinear:
+
ScaleModeNearest:
+
Scancode:
+
SCANCODE_0:
+
SCANCODE_1:
+
SCANCODE_2:
+
SCANCODE_3:
+
SCANCODE_4:
+
SCANCODE_5:
+
SCANCODE_6:
+
SCANCODE_7:
+
SCANCODE_8:
+
SCANCODE_9:
+
SCANCODE_A:
+
SCANCODE_AC_BACK:
+
SCANCODE_AC_BOOKMARKS:
+
SCANCODE_AC_FORWARD:
+
SCANCODE_AC_HOME:
+
SCANCODE_AC_REFRESH:
+
SCANCODE_AC_SEARCH:
+
SCANCODE_AC_STOP:
+
SCANCODE_AGAIN:
+
SCANCODE_ALTERASE:
+
SCANCODE_APOSTROPHE:
+
SCANCODE_APP1:
+
SCANCODE_APP2:
+
SCANCODE_APPLICATION:
+
SCANCODE_AUDIOFASTFORWARD:
+
SCANCODE_AUDIOMUTE:
+
SCANCODE_AUDIONEXT:
+
SCANCODE_AUDIOPLAY:
+
SCANCODE_AUDIOPREV:
+
SCANCODE_AUDIOREWIND:
+
SCANCODE_AUDIOSTOP:
+
SCANCODE_B:
+
SCANCODE_BACKSLASH:
+
SCANCODE_BACKSPACE:
+
SCANCODE_BRIGHTNESSDOWN:
+
SCANCODE_BRIGHTNESSUP:
+
SCANCODE_C:
+
SCANCODE_CALCULATOR:
+
SCANCODE_CANCEL:
+
SCANCODE_CAPSLOCK:
+
SCANCODE_CLEAR:
+
SCANCODE_CLEARAGAIN:
+
SCANCODE_COMMA:
+
SCANCODE_COMPUTER:
+
SCANCODE_COPY:
+
SCANCODE_CRSEL:
+
SCANCODE_CURRENCYSUBUNIT:
+
SCANCODE_CURRENCYUNIT:
+
SCANCODE_CUT:
+
SCANCODE_D:
+
SCANCODE_DECIMALSEPARATOR:
+
SCANCODE_DELETE:
+
SCANCODE_DISPLAYSWITCH:
+
SCANCODE_DOWN:
+
SCANCODE_E:
+
SCANCODE_EJECT:
+
SCANCODE_END:
+
SCANCODE_EQUALS:
+
SCANCODE_ESCAPE:
+
SCANCODE_EXECUTE:
+
SCANCODE_EXSEL:
+
SCANCODE_F:
+
SCANCODE_F1:
+
SCANCODE_F10:
+
SCANCODE_F11:
+
SCANCODE_F12:
+
SCANCODE_F13:
+
SCANCODE_F14:
+
SCANCODE_F15:
+
SCANCODE_F16:
+
SCANCODE_F17:
+
SCANCODE_F18:
+
SCANCODE_F19:
+
SCANCODE_F2:
+
SCANCODE_F20:
+
SCANCODE_F21:
+
SCANCODE_F22:
+
SCANCODE_F23:
+
SCANCODE_F24:
+
SCANCODE_F3:
+
SCANCODE_F4:
+
SCANCODE_F5:
+
SCANCODE_F6:
+
SCANCODE_F7:
+
SCANCODE_F8:
+
SCANCODE_F9:
+
SCANCODE_FIND:
+
SCANCODE_G:
+
SCANCODE_GRAVE:
+
SCANCODE_H:
+
SCANCODE_HELP:
+
SCANCODE_HOME:
+
SCANCODE_I:
+
SCANCODE_INSERT:
+
SCANCODE_INTERNATIONAL1:
+
SCANCODE_INTERNATIONAL2:
+
SCANCODE_INTERNATIONAL3:
+
SCANCODE_INTERNATIONAL4:
+
SCANCODE_INTERNATIONAL5:
+
SCANCODE_INTERNATIONAL6:
+
SCANCODE_INTERNATIONAL7:
+
SCANCODE_INTERNATIONAL8:
+
SCANCODE_INTERNATIONAL9:
+
SCANCODE_J:
+
SCANCODE_K:
+
SCANCODE_KBDILLUMDOWN:
+
SCANCODE_KBDILLUMTOGGLE:
+
SCANCODE_KBDILLUMUP:
+
SCANCODE_KP_0:
+
SCANCODE_KP_00:
+
SCANCODE_KP_000:
+
SCANCODE_KP_1:
+
SCANCODE_KP_2:
+
SCANCODE_KP_3:
+
SCANCODE_KP_4:
+
SCANCODE_KP_5:
+
SCANCODE_KP_6:
+
SCANCODE_KP_7:
+
SCANCODE_KP_8:
+
SCANCODE_KP_9:
+
SCANCODE_KP_A:
+
SCANCODE_KP_AMPERSAND:
+
SCANCODE_KP_AT:
+
SCANCODE_KP_B:
+
SCANCODE_KP_BACKSPACE:
+
SCANCODE_KP_BINARY:
+
SCANCODE_KP_C:
+
SCANCODE_KP_CLEAR:
+
SCANCODE_KP_CLEARENTRY:
+
SCANCODE_KP_COLON:
+
SCANCODE_KP_COMMA:
+
SCANCODE_KP_D:
+
SCANCODE_KP_DBLAMPERSAND:
+
SCANCODE_KP_DBLVERTICALBAR:
+
SCANCODE_KP_DECIMAL:
+
SCANCODE_KP_DIVIDE:
+
SCANCODE_KP_E:
+
SCANCODE_KP_ENTER:
+
SCANCODE_KP_EQUALS:
+
SCANCODE_KP_EQUALSAS400:
+
SCANCODE_KP_EXCLAM:
+
SCANCODE_KP_F:
+
SCANCODE_KP_GREATER:
+
SCANCODE_KP_HASH:
+
SCANCODE_KP_HEXADECIMAL:
+
SCANCODE_KP_LEFTBRACE:
+
SCANCODE_KP_LEFTPAREN:
+
SCANCODE_KP_LESS:
+
SCANCODE_KP_MEMADD:
+
SCANCODE_KP_MEMCLEAR:
+
SCANCODE_KP_MEMDIVIDE:
+
SCANCODE_KP_MEMMULTIPLY:
+
SCANCODE_KP_MEMRECALL:
+
SCANCODE_KP_MEMSTORE:
+
SCANCODE_KP_MEMSUBTRACT:
+
SCANCODE_KP_MINUS:
+
SCANCODE_KP_MULTIPLY:
+
SCANCODE_KP_OCTAL:
+
SCANCODE_KP_PERCENT:
+
SCANCODE_KP_PERIOD:
+
SCANCODE_KP_PLUS:
+
SCANCODE_KP_PLUSMINUS:
+
SCANCODE_KP_POWER:
+
SCANCODE_KP_RIGHTBRACE:
+
SCANCODE_KP_RIGHTPAREN:
+
SCANCODE_KP_SPACE:
+
SCANCODE_KP_TAB:
+
SCANCODE_KP_VERTICALBAR:
+
SCANCODE_KP_XOR:
+
SCANCODE_L:
+
SCANCODE_LALT:
+
SCANCODE_LANG1:
+
SCANCODE_LANG2:
+
SCANCODE_LANG3:
+
SCANCODE_LANG4:
+
SCANCODE_LANG5:
+
SCANCODE_LANG6:
+
SCANCODE_LANG7:
+
SCANCODE_LANG8:
+
SCANCODE_LANG9:
+
SCANCODE_LCTRL:
+
SCANCODE_LEFT:
+
SCANCODE_LEFTBRACKET:
+
SCANCODE_LGUI:
+
SCANCODE_LSHIFT:
+
SCANCODE_M:
+
SCANCODE_MAIL:
+
SCANCODE_MASK:
+
SCANCODE_MEDIASELECT:
+
SCANCODE_MENU:
+
SCANCODE_MINUS:
+
SCANCODE_MODE:
+
SCANCODE_MUTE:
+
SCANCODE_N:
+
SCANCODE_NONUSBACKSLASH:
+
SCANCODE_NONUSHASH:
+
SCANCODE_NUMLOCKCLEAR:
+
SCANCODE_O:
+
SCANCODE_OPER:
+
SCANCODE_OUT:
+
SCANCODE_P:
+
SCANCODE_PAGEDOWN:
+
SCANCODE_PAGEUP:
+
SCANCODE_PASTE:
+
SCANCODE_PAUSE:
+
SCANCODE_PERIOD:
+
SCANCODE_POWER:
+
SCANCODE_PRINTSCREEN:
+
SCANCODE_PRIOR:
+
SCANCODE_Q:
+
SCANCODE_R:
+
SCANCODE_RALT:
+
SCANCODE_RCTRL:
+
SCANCODE_RETURN:
+
SCANCODE_RETURN2:
+
SCANCODE_RGUI:
+
SCANCODE_RIGHT:
+
SCANCODE_RIGHTBRACKET:
+
SCANCODE_RSHIFT:
+
SCANCODE_S:
+
SCANCODE_SCROLLLOCK:
+
SCANCODE_SELECT:
+
SCANCODE_SEMICOLON:
+
SCANCODE_SEPARATOR:
+
SCANCODE_SLASH:
+
SCANCODE_SLEEP:
+
SCANCODE_SPACE:
+
SCANCODE_STOP:
+
SCANCODE_SYSREQ:
+
SCANCODE_T:
+
SCANCODE_TAB:
+
SCANCODE_THOUSANDSSEPARATOR:
+
SCANCODE_U:
+
SCANCODE_UNDO:
+
SCANCODE_UNKNOWN:
+
SCANCODE_UP:
+
SCANCODE_V:
+
SCANCODE_VOLUMEDOWN:
+
SCANCODE_VOLUMEUP:
+
SCANCODE_W:
+
SCANCODE_WWW:
+
SCANCODE_X:
+
SCANCODE_Y:
+
SCANCODE_Z:
+
SDL2gfxPrimitivesDL:
+
SDL2gfxPrimitivesGit:
+
SDL2gfxPrimitivesLPath:
+
SDL2_GFXPRIMITIVES_MAJOR:
+
SDL2_GFXPRIMITIVES_MICRO:
+
SDL2_GFXPRIMITIVES_MINOR:
+
SDL2gfxPrimitivesPath:
+
SDL2gfxPrimitivesSetVer:
+
SDL2gfxPrimitivesStatic:
+
SDL2gfxPrimitivesStd:
+
sdl_button:
+
SDLCacheDir:
+
SDLDL:
+
SDLDyLibPath:
+
SDLGit:
+
SDLgpuDL:
+
SDLgpuGit:
+
SDLgpuLPath:
+
SDLgpuPath:
+
SDLgpuSetVer:
+
SDLgpuStatic:
+
SDLgpuStd:
+
SDLimageDL:
+
SDLimageGit:
+
SDLimageLPath:
+
SDLimagePath:
+
SDLimageSetVer:
+
SDLimageStatic:
+
SDLimageStd:
+
SDLLPath:
+
SDLMainLib:
+
SDLmixerDL:
+
SDLmixerGit:
+
SDLmixerLPath:
+
SDLmixerPath:
+
SDLmixerSetVer:
+
SDLmixerStatic:
+
SDLmixerStd:
+
SDLnetDL:
+
SDLnetGit:
+
SDLnetLPath:
+
SDLNET_MAX_UDPADDRESSES:
+
SDLNET_MAX_UDPCHANNELS:
+
SDLnetPath:
+
SDLnetSetVer:
+
SDLnetStatic:
+
SDLnetStd:
+
SDLPath:
+
SDLSetVer:
+
SDLStatic:
+
SDLStaticLib:
+
SDLStd:
+
SDLttfDL:
+
SDLttfGit:
+
SDLttfLPath:
+
SDLttfPath:
+
SDLttfSetVer:
+
SDLttfStatic:
+
SDLttfStd:
+
sector:
+
sectorFilled:
+
sem:
+
semaphore:
+
semPost:
+
semTryWait:
+
semValue:
+
semWait:
+
semWaitTimeout:
+
Sensor:
+
SENSOR_ACCEL:
+
sensorClose:
+
SENSOR_DUMMY:
+
SensorEvent:
+
sensorFromInstanceID:
+
sensorGetData:
+
sensorGetDeviceInstanceID:
+
sensorGetDeviceName:
+
sensorGetDeviceNonPortableType:
+
sensorGetDeviceType:
+
sensorGetInstanceID:
+
sensorGetName:
+
sensorGetNonPortableType:
+
sensorGetType:
+
SENSOR_GYRO:
+
SensorID:
+
SENSOR_INVALID:
+
sensorOpen:
+
SensorType:
+
SENSOR_UNKNOWN:
+
sensorUpdate:
+
setActiveTarget:
+
setAnchor:
+
setAssertionHandler:
+
setAttributef:
+
setAttributefv:
+
setAttributei:
+
setAttributeiv:
+
setAttributeSource:
+
setAttributeui:
+
setAttributeuiv:
+
setBlendEquation:
+
setBlendFunction:
+
setBlending:
+
setBlendMode:
+
setCamera:
+
setClip:
+
setClipboardText:
+
setClipRect:
+
setColor:
+
setColorKey:
+
setCoordinateMode:
+
setCurrentRenderer:
+
setCursor:
+
setDebugLevel:
+
setDefaultAnchor:
+
setDepthFunction:
+
setDepthTest:
+
setDepthWrite:
+
setDistance:
+
setenv:
+
setError:
+
SetError:
+
setError:
+
SetError:
+
setErrorQueueMax:
+
setEventFilter:
+
setFontHinting:
+
setFontKerning:
+
setFontOutline:
+
setFontStyle:
+
setFramerate:
+
setFullscreen:
+
setHint:
+
setHintWithPriority:
+
setImageFilter:
+
setImageVirtualResolution:
+
setInitWindow:
+
setLastError:
+
setLineThickness:
+
setLogCallback:
+
setMainReady:
+
setMemoryFunctions:
+
setModel:
+
setModelFromStack:
+
setModState:
+
setMusicCMD:
+
setMusicPosition:
+
setPaletteColors:
+
setPanning:
+
setPixelFormatPalette:
+
setPosition:
+
setPostMix:
+
setPreInitFlags:
+
setProjection:
+
setProjectionFromStack:
+
setRelativeMouseMode:
+
setRenderDrawBlendMode:
+
setRenderDrawColor:
+
setRendererOrder:
+
setRenderTarget:
+
setRequiredFeatures:
+
setReverseStereo:
+
setRGB:
+
setRGBA:
+
setShaderBlock:
+
setShaderImage:
+
setShapeBlendEquation:
+
setShapeBlendFunction:
+
setShapeBlending:
+
setShapeBlendMode:
+
setSnapMode:
+
setSoundFonts:
+
setSurfaceAlphaMod:
+
setSurfaceBlendMode:
+
setSurfaceColorMod:
+
setSurfacePalette:
+
setSurfaceRLE:
+
setSynchroValue:
+
setTargetColor:
+
setTargetRGB:
+
setTargetRGBA:
+
setTextInputRect:
+
setTextureAlphaMod:
+
setTextureBlendMode:
+
setTextureColorMod:
+
setTextureScaleMode:
+
setThreadPriority:
+
setUniformf:
+
setUniformfv:
+
setUniformi:
+
setUniformiv:
+
setUniformMatrixfv:
+
setUniformui:
+
setUniformuiv:
+
setView:
+
setViewFromStack:
+
setViewport:
+
setVirtualResolution:
+
setWindowBordered:
+
setWindowBrightness:
+
setWindowData:
+
setWindowDisplayMode:
+
setWindowFullscreen:
+
setWindowGammaRamp:
+
setWindowGrab:
+
setWindowHitTest:
+
setWindowIcon:
+
setWindowInputFocus:
+
setWindowMaximumSize:
+
setWindowMinimumSize:
+
setWindowModalFor:
+
setWindowOpacity:
+
setWindowPosition:
+
setWindowResizable:
+
setWindowResolution:
+
setWindowShape:
+
setWindowSize:
+
setWindowTitle:
+
setWrapMode:
+
setYUVConversionMode:
+
ShaderBlock:
+
ShaderEnum:
+
ShaderLanguageEnum:
+
ShapeModeBinarizeAlpha:
+
ShapeModeColorKey:
+
ShapeModeDefault:
+
ShapeModeReverseBinarizeAlpha:
+
showCursor:
+
showMessageBox:
+
showSimpleMessageBox:
+
showWindow:
+
shrinkSurface:
+
SIMD_ALIGNED:
+
sIMDAlloc:
+
sIMDFree:
+
sIMDGetAlignment:
+
sin:
+
sinf:
+
Sint16:
+
Sint32:
+
Sint64:
+
Sint8:
+
SIZEOF_VOIDP:
+
sizeText:
+
sizeUNICODE:
+
sizeUTF8:
+
SMOOTHING_OFF:
+
SMOOTHING_ON:
+
SNAP_DIMENSIONS:
+
SnapEnum:
+
SNAP_NONE:
+
SNAP_POSITION:
+
SNAP_POSITION_AND_DIMENSIONS:
+
snprintf:
+
SOCKET_ERROR:
+
SocketSet:
+
softStretch:
+
SpinLock:
+
sqrt:
+
sqrtf:
+
sscanf:
+
STANDARD_GRAVITY:
+
startTextInput:
+
STDC_HEADERS:
+
stopTextInput:
+
strcasecmp:
+
strchr:
+
strcmp:
+
strdup:
+
stringColor:
+
stringRGBA:
+
strlcat:
+
strlcpy:
+
strlen:
+
strlwr:
+
strncasecmp:
+
strncmp:
+
strrchr:
+
strrev:
+
strstr:
+
strtod:
+
strtokr:
+
strtol:
+
strtoll:
+
strtoul:
+
strtoull:
+
strupr:
+
STYLE_BOLD:
+
STYLE_ITALIC:
+
STYLE_NORMAL:
+
STYLE_STRIKETHROUGH:
+
STYLE_UNDERLINE:
+
Surface:
+
SWSURFACE:
+
SystemCursor:
+
SYSTEM_CURSOR_ARROW:
+
SYSTEM_CURSOR_CROSSHAIR:
+
SYSTEM_CURSOR_HAND:
+
SYSTEM_CURSOR_IBEAM:
+
SYSTEM_CURSOR_NO:
+
SYSTEM_CURSOR_SIZEALL:
+
SYSTEM_CURSOR_SIZENESW:
+
SYSTEM_CURSOR_SIZENS:
+
SYSTEM_CURSOR_SIZENWSE:
+
SYSTEM_CURSOR_SIZEWE:
+
SYSTEM_CURSOR_WAIT:
+
SYSTEM_CURSOR_WAITARROW:
+
SysWMEvent:
+
SysWMmsg:
+
tan:
+
tanf:
+
Target:
+
tCP_Accept:
+
tCP_Close:
+
tCP_GetPeerAddress:
+
tCP_Open:
+
tCP_Recv:
+
tCP_Send:
+
TCPsocket:
+
TextEditingEvent:
+
TEXTEDITINGEVENT_TEXT_SIZE:
+
TextInputEvent:
+
TEXTINPUTEVENT_TEXT_SIZE:
+
Texture:
+
TextureAccess:
+
TEXTUREACCESS_STATIC:
+
TEXTUREACCESS_STREAMING:
+
TEXTUREACCESS_TARGET:
+
texturedPolygon:
+
TextureHandle:
+
TextureModulate:
+
TEXTUREMODULATE_ALPHA:
+
TEXTUREMODULATE_COLOR:
+
TEXTUREMODULATE_NONE:
+
thickLineColor:
+
thickLineRGBA:
+
Thread:
+
ThreadFunction:
+
threadID:
+
ThreadPriority:
+
THREAD_PRIORITY_HIGH:
+
THREAD_PRIORITY_LOW:
+
THREAD_PRIORITY_NORMAL:
+
THREAD_PRIORITY_TIME_CRITICAL:
+
THREAD_PTHREAD:
+
THREAD_PTHREAD_RECURSIVE_MUTEX:
+
TimerCallback:
+
TimerID:
+
TIMER_UNIX:
+
tLSCreate:
+
tLSGet:
+
TLSID:
+
tLSSet:
+
tolower:
+
TOUCH_DEVICE_DIRECT:
+
TOUCH_DEVICE_INDIRECT_ABSOLUTE:
+
TOUCH_DEVICE_INDIRECT_RELATIVE:
+
TOUCH_DEVICE_INVALID:
+
TouchDeviceType:
+
TouchFingerEvent:
+
TouchID:
+
TOUCH_MOUSEID:
+
toupper:
+
translate:
+
tri:
+
triangleBatch:
+
triangleBatchX:
+
TRIANGLE_FAN:
+
TRIANGLES:
+
TRIANGLE_STRIP:
+
triFilled:
+
trigonColor:
+
trigonRGBA:
+
true:
+
TRUE:
+
tryLockMutex:
+
TYPE_BYTE:
+
TYPE_DOUBLE:
+
TypeEnum:
+
TYPE_FLOAT:
+
TYPE_INT:
+
TYPE_SHORT:
+
TYPE_UNSIGNED_BYTE:
+
TYPE_UNSIGNED_INT:
+
TYPE_UNSIGNED_SHORT:
+
uDP_Bind:
+
uDP_Close:
+
uDP_GetPeerAddress:
+
uDP_Open:
+
UDPpacket:
+
uDP_Recv:
+
uDP_RecvV:
+
uDP_Send:
+
uDP_SendV:
+
uDP_SetPacketLoss:
+
UDPsocket:
+
uDP_Unbind:
+
Uint16:
+
Uint32:
+
Uint64:
+
Uint8:
+
uitoa:
+
ulltoa:
+
ultoa:
+
UNICODE_BOM_NATIVE:
+
UNICODE_BOM_SWAPPED:
+
unionRect:
+
unloadObject:
+
unlockAudio:
+
unlockAudioDevice:
+
unlockJoysticks:
+
unlockMutex:
+
unlockSurface:
+
unlockTexture:
+
unregisterAllEffects:
+
unregisterEffect:
+
unsetClip:
+
unsetColor:
+
unsetImageVirtualResolution:
+
unsetTargetColor:
+
unsetViewport:
+
unsetVirtualResolution:
+
UNSUPPORTED:
+
updateImage:
+
updateImageBytes:
+
updateTexture:
+
updateWindowSurface:
+
updateWindowSurfaceRects:
+
updateYUVTexture:
+
upperBlit:
+
upperBlitScaled:
+
UserEvent:
+
utf8strlcpy:
+
utf8strlen:
+
vector4ApplyMatrix:
+
vectorApplyMatrix:
+
vectorCopy:
+
vectorCross:
+
vectorDot:
+
vectorLength:
+
vectorNormalize:
+
Version:
+
VERTEX_SHADER:
+
VIDEO_DRIVER_COCOA:
+
VIDEO_DRIVER_DUMMY:
+
videoInit:
+
VIDEO_METAL:
+
VIDEO_OPENGL:
+
VIDEO_OPENGL_CGL:
+
VIDEO_OPENGL_EGL:
+
VIDEO_OPENGL_ES2:
+
videoQuit:
+
VIDEO_RENDER_METAL:
+
VIDEO_RENDER_OGL:
+
VIDEO_RENDER_OGL_ES2:
+
VIDEO_VULKAN:
+
VIEW:
+
vlineColor:
+
vlineRGBA:
+
volume:
+
volumeChunk:
+
volumeMusic:
+
vsnprintf:
+
vsscanf:
+
waitEvent:
+
waitEventTimeout:
+
waitThread:
+
warpMouseGlobal:
+
warpMouseInWindow:
+
wasInit:
+
wcscmp:
+
wcsdup:
+
wcslcat:
+
wcslcpy:
+
wcslen:
+
wcsncmp:
+
wcsstr:
+
Window:
+
WINDOW_ALLOW_HIGHDPI:
+
WINDOW_ALWAYS_ON_TOP:
+
WINDOW_BORDERLESS:
+
WindowEvent:
+
WINDOWEVENT_CLOSE:
+
WINDOWEVENT_ENTER:
+
WINDOWEVENT_EXPOSED:
+
WINDOWEVENT_FOCUS_GAINED:
+
WINDOWEVENT_FOCUS_LOST:
+
WINDOWEVENT_HIDDEN:
+
WINDOWEVENT_HIT_TEST:
+
WindowEventID:
+
WINDOWEVENT_LEAVE:
+
WINDOWEVENT_MAXIMIZED:
+
WINDOWEVENT_MINIMIZED:
+
WINDOWEVENT_MOVED:
+
WINDOWEVENT_NONE:
+
WINDOWEVENT_RESIZED:
+
WINDOWEVENT_RESTORED:
+
WINDOWEVENT_SHOWN:
+
WINDOWEVENT_SIZE_CHANGED:
+
WINDOWEVENT_TAKE_FOCUS:
+
WindowFlagEnum:
+
WindowFlags:
+
WINDOW_FOREIGN:
+
WINDOW_FULLSCREEN:
+
WINDOW_FULLSCREEN_DESKTOP:
+
WINDOW_HIDDEN:
+
WINDOW_INPUT_FOCUS:
+
WINDOW_INPUT_GRABBED:
+
WINDOW_LACKS_SHAPE:
+
WINDOW_MAXIMIZED:
+
WINDOW_MINIMIZED:
+
WINDOW_MOUSE_CAPTURE:
+
WINDOW_MOUSE_FOCUS:
+
WINDOW_OPENGL:
+
WINDOW_POPUP_MENU:
+
WINDOWPOS_CENTERED:
+
WINDOWPOS_CENTERED_DISPLAY:
+
WINDOWPOS_CENTERED_MASK:
+
WINDOWPOS_ISCENTERED:
+
WINDOWPOS_ISUNDEFINED:
+
WINDOWPOS_UNDEFINED:
+
WINDOWPOS_UNDEFINED_DISPLAY:
+
WINDOWPOS_UNDEFINED_MASK:
+
WINDOW_RESIZABLE:
+
WindowShapeMode:
+
WindowShapeParams:
+
WINDOW_SHOWN:
+
WINDOW_SKIP_TASKBAR:
+
WINDOW_TOOLTIP:
+
WINDOW_UTILITY:
+
WINDOW_VULKAN:
+
WrapEnum:
+
WRAP_MIRRORED:
+
WRAP_NONE:
+
WRAP_REPEAT:
+
writeBE16:
+
writeBE32:
+
writeBE64:
+
writeLE16:
+
writeLE32:
+
writeLE64:
+
writeU8:
+
YUV_CONVERSION_AUTOMATIC:
+
YUV_CONVERSION_BT601:
+
YUV_CONVERSION_BT709:
+
YUV_CONVERSION_JPEG:
+
YUV_CONVERSION_MODE:
+
zoomSurface:
+
zoomSurfaceSize:
+
+
+ +
+
+
+ + + diff --git a/docs/nimdoc.out.css b/docs/nimdoc.out.css new file mode 100644 index 0000000..4ee73ea --- /dev/null +++ b/docs/nimdoc.out.css @@ -0,0 +1,891 @@ +/* +Stylesheet for use with Docutils/rst2html. + +See http://docutils.sf.net/docs/howto/html-stylesheets.html for how to +customize this style sheet. + +Modified from Chad Skeeters' rst2html-style +https://bitbucket.org/cskeeters/rst2html-style/ + +Modified by Boyd Greenfield and narimiran +*/ + +:root { + --primary-background: #fff; + --secondary-background: ghostwhite; + --third-background: #e8e8e8; + --border: #dde; + --text: #222; + --anchor: #07b; + --anchor-focus: #607c9f; + --input-focus: #1fa0eb; + --strong: #3c3c3c; + --hint: #9A9A9A; + --nim-sprite-base64: url("data:image/png;base64,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"); + + --keyword: #5e8f60; + --identifier: #222; + --comment: #484a86; + --operator: #155da4; + --punctuation: black; + --other: black; + --escapeSequence: #c4891b; + --number: #252dbe; + --literal: #a4255b; + --raw-data: #a4255b; +} + +[data-theme="dark"] { + --primary-background: #171921; + --secondary-background: #1e202a; + --third-background: #2b2e3b; + --border: #0e1014; + --text: #fff; + --anchor: #8be9fd; + --anchor-focus: #8be9fd; + --input-focus: #8be9fd; + --strong: #bd93f9; + --hint: #7A7C85; + --nim-sprite-base64: url("data:image/png;base64,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"); + + --keyword: #ff79c6; + --identifier: #f8f8f2; + --comment: #6272a4; + --operator: #ff79c6; + --punctuation: #f8f8f2; + --other: #f8f8f2; + --escapeSequence: #bd93f9; + --number: #bd93f9; + --literal: #f1fa8c; + --raw-data: #8be9fd; +} + +.theme-switch-wrapper { + display: flex; + align-items: center; + + em { + margin-left: 10px; + font-size: 1rem; + } +} +.theme-switch { + display: inline-block; + height: 22px; + position: relative; + width: 50px; +} + +.theme-switch input { + display: none; +} + +.slider { + background-color: #ccc; + bottom: 0; + cursor: pointer; + left: 0; + position: absolute; + right: 0; + top: 0; + transition: .4s; +} + +.slider:before { + background-color: #fff; + bottom: 4px; + content: ""; + height: 13px; + left: 4px; + position: absolute; + transition: .4s; + width: 13px; +} + +input:checked + .slider { + background-color: #66bb6a; +} + +input:checked + .slider:before { + transform: translateX(26px); +} + +.slider.round { + border-radius: 17px; +} + +.slider.round:before { + border-radius: 50%; +} + +html { + font-size: 100%; + -webkit-text-size-adjust: 100%; + -ms-text-size-adjust: 100%; } + +body { + font-family: "Lato", "Helvetica Neue", "HelveticaNeue", Helvetica, Arial, sans-serif; + font-weight: 400; + font-size: 1.125em; + line-height: 1.5; + color: var(--text); + background-color: var(--primary-background); } + +/* Skeleton grid */ +.container { + position: relative; + width: 100%; + max-width: 1050px; + margin: 0 auto; + padding: 0; + box-sizing: border-box; } + +.column, +.columns { + width: 100%; + float: left; + box-sizing: border-box; + margin-left: 1%; +} + +.column:first-child, +.columns:first-child { + margin-left: 0; } + +.three.columns { + width: 19%; } + +.nine.columns { + width: 80.0%; } + +.twelve.columns { + width: 100%; + margin-left: 0; } + +@media screen and (max-width: 860px) { + .three.columns { + display: none; + } + .nine.columns { + width: 98.0%; + } + body { + font-size: 1em; + line-height: 1.35; + } +} + +cite { + font-style: italic !important; } + + +/* Nim search input */ +div#searchInputDiv { + margin-bottom: 1em; +} +input#searchInput { + width: 80%; +} + +/* + * Some custom formatting for input forms. + * This also fixes input form colors on Firefox with a dark system theme on Linux. + */ +input { + -moz-appearance: none; + background-color: var(--secondary-background); + color: var(--text); + border: 1px solid var(--border); + font-family: "Lato", "Helvetica Neue", "HelveticaNeue", Helvetica, Arial, sans-serif; + font-size: 0.9em; + padding: 6px; +} + +input:focus { + border: 1px solid var(--input-focus); + box-shadow: 0 0 3px var(--input-focus); +} + +select { + -moz-appearance: none; + background-color: var(--secondary-background); + color: var(--text); + border: 1px solid var(--border); + font-family: "Lato", "Helvetica Neue", "HelveticaNeue", Helvetica, Arial, sans-serif; + font-size: 0.9em; + padding: 6px; +} + +select:focus { + border: 1px solid var(--input-focus); + box-shadow: 0 0 3px var(--input-focus); +} + +/* Docgen styles */ +/* Links */ +a { + color: var(--anchor); + text-decoration: none; +} + +a span.Identifier { + text-decoration: underline; + text-decoration-color: #aab; +} + +a.reference-toplevel { + font-weight: bold; +} + +a.toc-backref { + text-decoration: none; + color: var(--text); } + +a.link-seesrc { + color: #607c9f; + font-size: 0.9em; + font-style: italic; } + +a:hover, +a:focus { + color: var(--anchor-focus); + text-decoration: underline; } + +a:hover span.Identifier { + color: var(--anchor); +} + + +sub, +sup { + position: relative; + font-size: 75%; + line-height: 0; + vertical-align: baseline; } + +sup { + top: -0.5em; } + +sub { + bottom: -0.25em; } + +img { + width: auto; + height: auto; + max-width: 100%; + vertical-align: middle; + border: 0; + -ms-interpolation-mode: bicubic; } + +@media print { + * { + color: black !important; + text-shadow: none !important; + background: transparent !important; + box-shadow: none !important; } + + a, + a:visited { + text-decoration: underline; } + + a[href]:after { + content: " (" attr(href) ")"; } + + abbr[title]:after { + content: " (" attr(title) ")"; } + + .ir a:after, + a[href^="javascript:"]:after, + a[href^="#"]:after { + content: ""; } + + pre, + blockquote { + border: 1px solid #999; + page-break-inside: avoid; } + + thead { + display: table-header-group; } + + tr, + img { + page-break-inside: avoid; } + + img { + max-width: 100% !important; } + + @page { + margin: 0.5cm; } + + h1 { + page-break-before: always; } + + h1.title { + page-break-before: avoid; } + + p, + h2, + h3 { + orphans: 3; + widows: 3; } + + h2, + h3 { + page-break-after: avoid; } +} + + +p { + margin-top: 0.5em; + margin-bottom: 0.5em; +} + +small { + font-size: 85%; } + +strong { + font-weight: 600; + font-size: 0.95em; + color: var(--strong); +} + +em { + font-style: italic; } + +h1 { + font-size: 1.8em; + font-weight: 400; + padding-bottom: .25em; + border-bottom: 6px solid var(--third-background); + margin-top: 2.5em; + margin-bottom: 1em; + line-height: 1.2em; } + +h1.title { + padding-bottom: 1em; + border-bottom: 0px; + font-size: 2.5em; + text-align: center; + font-weight: 900; + margin-top: 0.75em; + margin-bottom: 0em; +} + +h2 { + font-size: 1.3em; + margin-top: 2em; } + +h2.subtitle { + text-align: center; } + +h3 { + font-size: 1.125em; + font-style: italic; + margin-top: 1.5em; } + +h4 { + font-size: 1.125em; + margin-top: 1em; } + +h5 { + font-size: 1.125em; + margin-top: 0.75em; } + +h6 { + font-size: 1.1em; } + + +ul, +ol { + padding: 0; + margin-top: 0.5em; + margin-left: 0.75em; } + +ul ul, +ul ol, +ol ol, +ol ul { + margin-bottom: 0; + margin-left: 1.25em; } + +li { + list-style-type: circle; +} + +ul.simple-boot li { + list-style-type: none; + margin-left: 0em; + margin-bottom: 0.5em; +} + +ol.simple > li, ul.simple > li { + margin-bottom: 0.25em; + margin-left: 0.4em } + +ul.simple.simple-toc > li { + margin-top: 1em; +} + +ul.simple-toc { + list-style: none; + font-size: 0.9em; + margin-left: -0.3em; + margin-top: 1em; } + +ul.simple-toc > li { + list-style-type: none; +} + +ul.simple-toc-section { + list-style-type: circle; + margin-left: 1em; + color: #6c9aae; } + + +ol.arabic { + list-style: decimal; } + +ol.loweralpha { + list-style: lower-alpha; } + +ol.upperalpha { + list-style: upper-alpha; } + +ol.lowerroman { + list-style: lower-roman; } + +ol.upperroman { + list-style: upper-roman; } + +ul.auto-toc { + list-style-type: none; } + + +dl { + margin-bottom: 1.5em; } + +dt { + margin-bottom: -0.5em; + margin-left: 0.0em; } + +dd { + margin-left: 2.0em; + margin-bottom: 3.0em; + margin-top: 0.5em; } + + +hr { + margin: 2em 0; + border: 0; + border-top: 1px solid #aaa; } + +blockquote { + font-size: 0.9em; + font-style: italic; + padding-left: 0.5em; + margin-left: 0; + border-left: 5px solid #bbc; +} + +.pre { + font-family: "Source Code Pro", Monaco, Menlo, Consolas, "Courier New", monospace; + font-weight: 500; + font-size: 0.85em; + color: var(--text); + background-color: var(--third-background); + padding-left: 3px; + padding-right: 3px; + border-radius: 4px; +} + +pre { + font-family: "Source Code Pro", Monaco, Menlo, Consolas, "Courier New", monospace; + color: var(--text); + font-weight: 500; + display: inline-block; + box-sizing: border-box; + min-width: 100%; + padding: 0.5em; + margin-top: 0.5em; + margin-bottom: 0.5em; + font-size: 0.85em; + white-space: pre !important; + overflow-y: hidden; + overflow-x: visible; + background-color: var(--secondary-background); + border: 1px solid var(--border); + -webkit-border-radius: 6px; + -moz-border-radius: 6px; + border-radius: 6px; } + +.pre-scrollable { + max-height: 340px; + overflow-y: scroll; } + + +/* Nim line-numbered tables */ +.line-nums-table { + width: 100%; + table-layout: fixed; } + +table.line-nums-table { + border-radius: 4px; + border: 1px solid #cccccc; + background-color: ghostwhite; + border-collapse: separate; + margin-top: 15px; + margin-bottom: 25px; } + +.line-nums-table tbody { + border: none; } + +.line-nums-table td pre { + border: none; + background-color: transparent; } + +.line-nums-table td.blob-line-nums { + width: 28px; } + +.line-nums-table td.blob-line-nums pre { + color: #b0b0b0; + -webkit-filter: opacity(75%); + text-align: right; + border-color: transparent; + background-color: transparent; + padding-left: 0px; + margin-left: 0px; + padding-right: 0px; + margin-right: 0px; } + + +table { + max-width: 100%; + background-color: transparent; + margin-top: 0.5em; + margin-bottom: 1.5em; + border-collapse: collapse; + border-color: var(--third-background); + border-spacing: 0; + font-size: 0.9em; +} + +table th, table td { + padding: 0px 0.5em 0px; + border-color: var(--third-background); +} + +table th { + background-color: var(--third-background); + border-color: var(--third-background); + font-weight: bold; } + +table th.docinfo-name { + background-color: transparent; +} + +table tr:hover { + background-color: var(--third-background); } + + +/* rst2html default used to remove borders from tables and images */ +.borderless, table.borderless td, table.borderless th { + border: 0; } + +table.borderless td, table.borderless th { + /* Override padding for "table.docutils td" with "! important". + The right padding separates the table cells. */ + padding: 0 0.5em 0 0 !important; } + +.first { + /* Override more specific margin styles with "! important". */ + margin-top: 0 !important; } + +.last, .with-subtitle { + margin-bottom: 0 !important; } + +.hidden { + display: none; } + +blockquote.epigraph { + margin: 2em 5em; } + +dl.docutils dd { + margin-bottom: 0.5em; } + +object[type="image/svg+xml"], object[type="application/x-shockwave-flash"] { + overflow: hidden; } + + +div.figure { + margin-left: 2em; + margin-right: 2em; } + +div.footer, div.header { + clear: both; + text-align: center; + color: #666; + font-size: smaller; } + +div.footer { + padding-top: 5em; +} + +div.line-block { + display: block; + margin-top: 1em; + margin-bottom: 1em; } + +div.line-block div.line-block { + margin-top: 0; + margin-bottom: 0; + margin-left: 1.5em; } + +div.topic { + margin: 2em; } + +div.search_results { + background-color: antiquewhite; + margin: 3em; + padding: 1em; + border: 1px solid #4d4d4d; +} + +div#global-links ul { + margin-left: 0; + list-style-type: none; +} + +div#global-links > simple-boot { + margin-left: 3em; +} + +hr.docutils { + width: 75%; } + +img.align-left, .figure.align-left, object.align-left { + clear: left; + float: left; + margin-right: 1em; } + +img.align-right, .figure.align-right, object.align-right { + clear: right; + float: right; + margin-left: 1em; } + +img.align-center, .figure.align-center, object.align-center { + display: block; + margin-left: auto; + margin-right: auto; } + +.align-left { + text-align: left; } + +.align-center { + clear: both; + text-align: center; } + +.align-right { + text-align: right; } + +/* reset inner alignment in figures */ +div.align-right { + text-align: inherit; } + +p.attribution { + text-align: right; + margin-left: 50%; } + +p.caption { + font-style: italic; } + +p.credits { + font-style: italic; + font-size: smaller; } + +p.label { + white-space: nowrap; } + +p.rubric { + font-weight: bold; + font-size: larger; + color: maroon; + text-align: center; } + +p.topic-title { + font-weight: bold; } + +pre.address { + margin-bottom: 0; + margin-top: 0; + font: inherit; } + +pre.literal-block, pre.doctest-block, pre.math, pre.code { + margin-left: 2em; + margin-right: 2em; } + +pre.code .ln { + color: grey; } + +/* line numbers */ +pre.code, code { + background-color: #eeeeee; } + +pre.code .comment, code .comment { + color: #5c6576; } + +pre.code .keyword, code .keyword { + color: #3B0D06; + font-weight: bold; } + +pre.code .literal.string, code .literal.string { + color: #0c5404; } + +pre.code .name.builtin, code .name.builtin { + color: #352b84; } + +pre.code .deleted, code .deleted { + background-color: #DEB0A1; } + +pre.code .inserted, code .inserted { + background-color: #A3D289; } + +span.classifier { + font-style: oblique; } + +span.classifier-delimiter { + font-weight: bold; } + +span.option { + white-space: nowrap; } + +span.problematic { + color: #b30000; } + +span.section-subtitle { + /* font-size relative to parent (h1..h6 element) */ + font-size: 80%; } + +span.DecNumber { + color: var(--number); } + +span.BinNumber { + color: var(--number); } + +span.HexNumber { + color: var(--number); } + +span.OctNumber { + color: var(--number); } + +span.FloatNumber { + color: var(--number); } + +span.Identifier { + color: var(--identifier); } + +span.Keyword { + font-weight: 600; + color: var(--keyword); } + +span.StringLit { + color: var(--literal); } + +span.LongStringLit { + color: var(--literal); } + +span.CharLit { + color: var(--literal); } + +span.EscapeSequence { + color: var(--escapeSequence); } + +span.Operator { + color: var(--operator); } + +span.Punctuation { + color: var(--punctuation); } + +span.Comment, span.LongComment { + font-style: italic; + font-weight: 400; + color: var(--comment); } + +span.RegularExpression { + color: darkviolet; } + +span.TagStart { + color: darkviolet; } + +span.TagEnd { + color: darkviolet; } + +span.Key { + color: #252dbe; } + +span.Value { + color: #252dbe; } + +span.RawData { + color: var(--raw-data); } + +span.Assembler { + color: #252dbe; } + +span.Preprocessor { + color: #252dbe; } + +span.Directive { + color: #252dbe; } + +span.Command, span.Rule, span.Hyperlink, span.Label, span.Reference, +span.Other { + color: var(--other); } + +/* Pop type, const, proc, and iterator defs in nim def blocks */ +dt pre > span.Identifier, dt pre > span.Operator { + color: var(--identifier); + font-weight: 700; } + +dt pre > span.Keyword ~ span.Identifier, dt pre > span.Identifier ~ span.Identifier, +dt pre > span.Operator ~ span.Identifier, dt pre > span.Other ~ span.Identifier { + color: var(--identifier); + font-weight: inherit; } + +/* Nim sprite for the footer (taken from main page favicon) */ +.nim-sprite { + display: inline-block; + width: 51px; + height: 14px; + background-position: 0 0; + background-size: 51px 14px; + -webkit-filter: opacity(50%); + background-repeat: no-repeat; + background-image: var(--nim-sprite-base64); + margin-bottom: 5px; } + +span.pragmadots { + /* Position: relative frees us up to make the dots + look really nice without fucking up the layout and + causing bulging in the parent container */ + position: relative; + /* 1px down looks slightly nicer */ + top: 1px; + padding: 2px; + background-color: var(--third-background); + border-radius: 4px; + margin: 0 2px; + cursor: pointer; + font-size: 0.8em; +} + +span.pragmadots:hover { + background-color: var(--hint); +} +span.pragmawrap { + display: none; +} + +span.attachedType { + display: none; + visibility: hidden; +} \ No newline at end of file diff --git a/docs/sdl2.html b/docs/sdl2.html new file mode 100644 index 0000000..9af3efd --- /dev/null +++ b/docs/sdl2.html @@ -0,0 +1,26102 @@ + + + + + + + + + + + + + + + + + + +sdl2 + + + + + + + + +
+
+

sdl2

+
+
+
+ +     Dark Mode +
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+ +

+
+

Types

+
+ +
AssertState = distinct cint
+
+ + + +
+ +
errorcode = distinct cint
+
+ + + +
+ +
ThreadPriority = distinct cint
+
+ + + +
+ +
AudioStatus = distinct cint
+
+ + + +
+ +
PixelType = distinct cint
+
+ + + +
+ +
BitmapOrder = distinct cint
+
+ + + +
+ +
PackedOrder = distinct cint
+
+ + + +
+ +
ArrayOrder = distinct cint
+
+ + + +
+ +
PackedLayout = distinct cint
+
+ + + +
+ +
PixelFormatEnum = distinct cint
+
+ + + +
+ +
BlendMode = distinct cint
+
+ + + +
+ +
BlendOperation = distinct cint
+
+ + + +
+ +
BlendFactor = distinct cint
+
+ + + +
+ +
YUV_CONVERSION_MODE = distinct cint
+
+ + + +
+ +
WindowFlags = distinct cint
+
+ + + +
+ +
WindowEventID = distinct cint
+
+ + + +
+ +
DisplayEventID = distinct cint
+
+ + + +
+ +
DisplayOrientation = distinct cint
+
+ + + +
+ +
GLattr = distinct cint
+
+ + + +
+ +
GLprofile = distinct cint
+
+ + + +
+ +
GLcontextFlag = distinct cint
+
+ + + +
+ +
GLcontextReleaseFlag = distinct cint
+
+ + + +
+ +
GLContextResetNotificationEnum = distinct cint
+
+ + + +
+ +
HitTestResult = distinct cint
+
+ + + +
+ +
Scancode = distinct cint
+
+ + + +
+ +
KeyCodeEnum = distinct cint
+
+ + + +
+ +
Keymod = distinct cint
+
+ + + +
+ +
SystemCursor = distinct cint
+
+ + + +
+ +
MouseWheelDirection = distinct cint
+
+ + + +
+ +
JoystickType = distinct cint
+
+ + + +
+ +
JoystickPowerLevel = distinct cint
+
+ + + +
+ +
GameControllerType = distinct cint
+
+ + + +
+ +
GameControllerAxis = distinct cint
+
+ + + +
+ +
GameControllerButton = distinct cint
+
+ + + +
+ +
TouchDeviceType = distinct cint
+
+ + + +
+ +
EventType = distinct cint
+
+ + + +
+ +
eventaction = distinct cint
+
+ + + +
+ +
HintPriority = distinct cint
+
+ + + +
+ +
LogCategory = distinct cint
+
+ + + +
+ +
LogPriority = distinct cint
+
+ + + +
+ +
MessageBoxFlags = distinct cint
+
+ + + +
+ +
MessageBoxButtonFlags = distinct cint
+
+ + + +
+ +
MessageBoxColorType = distinct cint
+
+ + + +
+ +
PowerState = distinct cint
+
+ + + +
+ +
RendererFlags = distinct cint
+
+ + + +
+ +
ScaleMode = distinct cint
+
+ + + +
+ +
TextureAccess = distinct cint
+
+ + + +
+ +
TextureModulate = distinct cint
+
+ + + +
+ +
RendererFlip = distinct cint
+
+ + + +
+ +
SensorType = distinct cint
+
+ + + +
+ +
WindowShapeMode = distinct cint
+
+ + + +
+ +
RWops {...}{.incompleteStruct.} = object
+
+ + + +
+ +
BlitMap {...}{.incompleteStruct.} = object
+
+ + + +
+ +
GameControllerBindType = enum
+  CONTROLLER_BINDTYPE_NONE = 0, CONTROLLER_BINDTYPE_BUTTON,
+  CONTROLLER_BINDTYPE_AXIS, CONTROLLER_BINDTYPE_HAT
+
+ + + +
+ +
Bool = bool
+
+ + + +
+ +
GameControllerButtonBind = object
+  case bindType*: GameControllerBindType
+  of CONTROLLER_BINDTYPE_BUTTON:
+      button*: cint
+
+  of CONTROLLER_BINDTYPE_AXIS:
+      axis*: cint
+
+  of CONTROLLER_BINDTYPE_HAT:
+      hat*: ButtonBindHat
+
+  of CONTROLLER_BINDTYPE_NONE:
+      nil
+
+  
+
+ + + +
+ +
ButtonBindHat = object
+  hat*: int
+  hatMask*: int
+
+
+ + + +
+ +
Sint8 = int8
+
+ + + +
+ +
Uint8 = uint8
+
+ + + +
+ +
Sint16 = int16
+
+ + + +
+ +
Uint16 = uint16
+
+ + + +
+ +
Sint32 = int32
+
+ + + +
+ +
Uint32 = uint32
+
+ + + +
+ +
Sint64 = int64
+
+ + + +
+ +
Uint64 = uint64
+
+ + + +
+ +
malloc_func = proc (size: uint): pointer {...}{.cdecl.}
+
+ + + +
+ +
calloc_func = proc (nmemb: uint; size: uint): pointer {...}{.cdecl.}
+
+ + + +
+ +
realloc_func = proc (mem: pointer; size: uint): pointer {...}{.cdecl.}
+
+ + + +
+ +
free_func = proc (mem: pointer) {...}{.cdecl.}
+
+ + + +
+ +
iconv_t {...}{.incompleteStruct.} = object
+
+ + + +
+ +
main_func = proc (argc: cint; argv: UncheckedArray[cstring]): cint {...}{.cdecl.}
+
+ + + +
+ +
AssertData {...}{.bycopy.} = object
+  alwaysIgnore*: cint
+  triggerCount*: cuint
+  condition*: cstring
+  filename*: cstring
+  linenum*: cint
+  function*: cstring
+  next*: ptr AssertData
+
+
+ + + +
+ +
AssertionHandler = proc (data: ptr AssertData; userdata: pointer): AssertState {...}{.cdecl.}
+
+ + + +
+ +
SpinLock = cint
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+\name SDL AtomicLock
+ 
+ The atomic locks are efficient spinlocks using CPU instructions,
+ but are vulnerable to starvation and can spin forever if a thread
+ holding a lock has been terminated.  For this reason you should
+ minimize the code executed inside an atomic lock and never do
+ expensive things like API or system calls while holding them.
+ 
+ The atomic locks are not safe to lock recursively.
+ 
+ Porting Note:
+ The spin lock functions and type are required and can not be
+ emulated because they are used in the atomic emulation code.
+@{
+ + +
+ +
atomic_t {...}{.bycopy.} = object
+  value*: cint
+
+
+ +
\brief A type representing an atomic integer value.  It is a struct
+        so people don't accidentally use numeric operations on it.
+ + +
+ +
mutex {...}{.incompleteStruct.} = object
+
+ + + +
+ +
semaphore {...}{.incompleteStruct.} = object
+
+ + + +
+ +
sem = semaphore
+
+ + + +
+ +
cond {...}{.incompleteStruct.} = object
+
+ + + +
+ +
Thread {...}{.incompleteStruct.} = object
+
+ + + +
+ +
threadID = culong
+
+ +
The SDL thread ID
+ + +
+ +
TLSID = cuint
+
+ +
Thread local storage ID, 0 is the invalid ID
+ + +
+ +
ThreadFunction = proc (data: pointer): cint {...}{.cdecl.}
+
+ + + +
+ +
AudioFormat = Uint16
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+\brief Audio format flags.
+  
+  These are what the 16 bits in SDL_AudioFormat currently mean...
+  (Unspecified bits are always zero).
+  
+  \verbatim
+    ++-----------------------sample is signed if set
+    ||
+    ||       ++-----------sample is bigendian if set
+    ||       ||
+    ||       ||          ++---sample is float if set
+    ||       ||          ||
+    ||       ||          || +---sample bit size---+
+    ||       ||          || |                     |
+    15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
+    \endverbatim
+  
+  There are macros in SDL 2.0 and later to query these bits.
+ + +
+ +
AudioCallback = proc (userdata: pointer; stream: ptr Uint8; len: cint) {...}{.cdecl.}
+
+ + + +
+ +
AudioSpec {...}{.bycopy.} = object
+  freq*: cint                  ## ::
+            ##   < DSP frequency -- samples per second
+  format*: AudioFormat         ## ::
+                     ##   < Audio data format
+  channels*: Uint8             ## ::
+                 ##   < Number of channels: 1 mono, 2 stereo
+  silence*: Uint8              ## ::
+                ##   < Audio buffer silence value (calculated)
+  samples*: Uint16             ## ::
+                 ##   < Audio buffer size in sample FRAMES (total samples divided by channel count)
+  padding*: Uint16             ## ::
+                 ##   < Necessary for some compile environments
+  size*: Uint32                ## ::
+              ##   < Audio buffer size in bytes (calculated)
+  callback*: AudioCallback     ## ::
+                         ##   < Callback that feeds the audio device (NULL to use SDL_QueueAudio()).
+  userdata*: pointer           ## ::
+                   ##   < Userdata passed to callback (ignored for NULL callbacks).
+  
+
+ +
The calculated values in this structure are calculated by SDL_OpenAudio().
+  
+  For multi-channel audio, the default SDL channel mapping is:
+  2:  FL FR                       (stereo)
+  3:  FL FR LFE                   (2.1 surround)
+  4:  FL FR BL BR                 (quad)
+  5:  FL FR FC BL BR              (quad + center)
+  6:  FL FR FC LFE SL SR          (5.1 surround - last two can also be BL BR)
+  7:  FL FR FC LFE BC SL SR       (6.1 surround)
+  8:  FL FR FC LFE BL BR SL SR    (7.1 surround)
+ + +
+ +
AudioCVT {...}{.bycopy.} = object
+  needed*: cint                ## ::
+              ##   < Set to 1 if conversion possible
+  srcFormat*: AudioFormat      ## ::
+                        ##   < Source audio format
+  dstFormat*: AudioFormat      ## ::
+                        ##   < Target audio format
+  rateIncr*: cdouble           ## ::
+                   ##   < Rate conversion increment
+  buf*: ptr Uint8               ## ::
+               ##   < Buffer to hold entire audio data
+  len*: cint                   ## ::
+           ##   < Length of original audio buffer
+  lenCvt*: cint                ## ::
+              ##   < Length of converted audio buffer
+  lenMult*: cint               ## ::
+               ##   < buffer must be lenlen_mult big
+  lenRatio*: cdouble           ## ::
+                   ##   < Given len, final size is lenlen_ratio
+  filters*: array[9 + typeof(9)(1), AudioFilter] ## ::
+                                            ##   < NULL-terminated list of filter functions
+  filterIndex*: cint           ## ::
+                   ##   < Current audio conversion function
+  
+
+ + + +
+ +
AudioFilter = proc (cvt: ptr AudioCVT; format: AudioFormat) {...}{.cdecl.}
+
+ + + +
+ +
AudioDeviceID = Uint32
+
+ +
SDL Audio Device IDs.
+  
+  A successful call to SDL_OpenAudio() is always device id 1, and legacy
+  SDL audio APIs assume you want this device ID. SDL_OpenAudioDevice() calls
+  always returns devices >= 2 on success. The legacy calls are good both
+  for backwards compatibility and when you don't care about multiple,
+  specific, or capture devices.
+ + +
+ +
AudioStream {...}{.incompleteStruct.} = object
+
+ + + +
+ +
Color {...}{.bycopy.} = object
+  r*: Uint8
+  g*: Uint8
+  b*: Uint8
+  a*: Uint8
+
+
+ + + +
+ +
Palette {...}{.bycopy.} = object
+  ncolors*: cint
+  colors*: ptr Color
+  Version*: Uint32
+  refcount*: cint
+
+
+ + + +
+ +
PixelFormat {...}{.bycopy.} = object
+  format*: Uint32
+  palette*: ptr Palette
+  BitsPerPixel*: Uint8
+  BytesPerPixel*: Uint8
+  padding*: array[2, Uint8]
+  Rmask*: Uint32
+  Gmask*: Uint32
+  Bmask*: Uint32
+  Amask*: Uint32
+  Rloss*: Uint8
+  Gloss*: Uint8
+  Bloss*: Uint8
+  Aloss*: Uint8
+  Rshift*: Uint8
+  Gshift*: Uint8
+  Bshift*: Uint8
+  Ashift*: Uint8
+  refcount*: cint
+  next*: ptr PixelFormat
+
+
+ +
\note Everything in the pixel format structure is read-only.
+ + +
+ +
Point {...}{.bycopy.} = object
+  x*: cint
+  y*: cint
+
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+\brief  The structure that defines a point (integer)
+  
+  \sa SDL_EnclosePoints
+  \sa SDL_PointInRect
+ + +
+ +
FPoint {...}{.bycopy.} = object
+  x*: cfloat
+  y*: cfloat
+
+
+ +
\brief  The structure that defines a point (floating point)
+  
+  \sa SDL_EnclosePoints
+  \sa SDL_PointInRect
+ + +
+ +
Rect {...}{.bycopy.} = object
+  x*: cint
+  y*: cint
+  w*: cint
+  h*: cint
+
+
+ +
\brief A rectangle, with the origin at the upper left (integer).
+  
+  \sa SDL_RectEmpty
+  \sa SDL_RectEquals
+  \sa SDL_HasIntersection
+  \sa SDL_IntersectRect
+  \sa SDL_UnionRect
+  \sa SDL_EnclosePoints
+ + +
+ +
FRect {...}{.bycopy.} = object
+  x*: cfloat
+  y*: cfloat
+  w*: cfloat
+  h*: cfloat
+
+
+ +
\brief A rectangle, with the origin at the upper left (floating point).
+ + +
+ +
Surface {...}{.bycopy.} = object
+  flags*: Uint32               ## ::
+               ##   < Read-only
+  format*: ptr PixelFormat      ## ::
+                        ##   < Read-only
+  w*: cint                     ## ::
+         ##   < Read-only
+  h*: cint                     ## ::
+         ##   < Read-only
+  pitch*: cint                 ## ::
+             ##   < Read-only
+  pixels*: pointer             ## ::
+                 ##   < Read-write
+  userdata*: pointer           ## ::
+                   ##   < Read-write
+  locked*: cint                ## ::
+              ##   < Read-only
+  lockData*: pointer           ## ::
+                   ##   < Read-only
+  clipRect*: Rect              ## ::
+                ##   < Read-only
+  map*: ptr BlitMap             ## ::
+                 ##   < Private
+  refcount*: cint              ## ::
+                ##   < Read-mostly
+  
+
+ +
\brief A collection of pixels used in software blitting.
+ 
+ \note  This structure should be treated as read-only, except for \c pixels,
+        which, if not NULL, contains the raw pixel data for the surface.
+ + +
+ +
blit = proc (src: ptr Surface; srcrect: ptr Rect; dst: ptr Surface; dstrect: ptr Rect): cint {...}{.
+    cdecl.}
+
+ + + +
+ +
DisplayMode {...}{.bycopy.} = object
+  format*: Uint32              ## ::
+                ##   < pixel format
+  w*: cint                     ## ::
+         ##   < width, in screen coordinates
+  h*: cint                     ## ::
+         ##   < height, in screen coordinates
+  refreshRate*: cint           ## ::
+                   ##   < refresh rate (or zero for unspecified)
+  driverdata*: pointer         ## ::
+                     ##   < driver-specific data, initialize to 0
+  
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+\brief  The structure that defines a display mode
+  
+  \sa SDL_GetNumDisplayModes()
+  \sa SDL_GetDisplayMode()
+  \sa SDL_GetDesktopDisplayMode()
+  \sa SDL_GetCurrentDisplayMode()
+  \sa SDL_GetClosestDisplayMode()
+  \sa SDL_SetWindowDisplayMode()
+  \sa SDL_GetWindowDisplayMode()
+ + +
+ +
Window {...}{.incompleteStruct.} = object
+
+ + + +
+ +
GLContext = pointer
+
+ +
\brief An opaque handle to an OpenGL context.
+ + +
+ +
HitTest = proc (win: ptr Window; area: ptr Point; data: pointer): HitTestResult {...}{.cdecl.}
+
+ + + +
+ +
Keycode = Sint32
+
+ +
vi: set ts=4 sw=4 expandtab:
+\brief The SDL virtual key representation.
+  
+  Values of this type are used to represent keyboard keys using the current
+  layout of the keyboard.  These values include Unicode values representing
+  the unmodified character that would be generated by pressing the key, or
+  an SDLK_ constant for those keys that do not generate characters.
+  
+  A special exception is the number keys at the top of the keyboard which
+  always map to SDLK_0...SDLK_9, regardless of layout.
+ + +
+ +
Keysym {...}{.bycopy.} = object
+  scancode*: Scancode          ## ::
+                    ##   < SDL physical key code - see ::SDL_Scancode for details
+  sym*: Keycode                ## ::
+              ##   < SDL virtual key code - see ::SDL_Keycode for details
+  `mod`*: Uint16               ## ::
+               ##   < current key modifiers
+  unused*: Uint32
+
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+\brief The SDL keysym structure, used in key events.
+  
+  \note  If you are looking for translated character input, see the ::SDL_TEXTINPUT event.
+ + +
+ +
Cursor {...}{.incompleteStruct.} = object
+
+ + + +
+ +
Joystick {...}{.incompleteStruct.} = object
+
+ + + +
+ +
JoystickGUID {...}{.bycopy.} = object
+  data*: array[16, Uint8]
+
+
+ +
A structure that encodes the stable unique id for a joystick device
+ + +
+ +
JoystickID = Sint32
+
+ +
This is a unique ID for a joystick for the time it is connected to the system,
+ and is never reused for the lifetime of the application. If the joystick is
+ disconnected and reconnected, it will get a new ID.
+ 
+ The ID value starts at 0 and increments from there. The value -1 is an invalid ID.
+ + +
+ +
GameController {...}{.incompleteStruct.} = object
+
+ + + +
+ +
TouchID = Sint64
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+ + +
+ +
FingerID = Sint64
+
+ + + +
+ +
Finger {...}{.bycopy.} = object
+  id*: FingerID
+  x*: cfloat
+  y*: cfloat
+  pressure*: cfloat
+
+
+ + + +
+ +
GestureID = Sint64
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+ + +
+ +
CommonEvent {...}{.bycopy.} = object
+  kind*: Uint32
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  
+
+ +
\brief Fields shared by every event
+ + +
+ +
DisplayEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_DISPLAYEVENT
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  display*: Uint32             ## ::
+                 ##   < The associated display index
+  event*: Uint8                ## ::
+              ##   < ::SDL_DisplayEventID
+  padding1*: Uint8
+  padding2*: Uint8
+  padding3*: Uint8
+  data1*: Sint32               ## ::
+               ##   < event dependent data
+  
+
+ +
\brief Display state change event data (event.display.)
+ + +
+ +
WindowEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_WINDOWEVENT
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  windowID*: Uint32            ## ::
+                  ##   < The associated window
+  event*: Uint8                ## ::
+              ##   < ::SDL_WindowEventID
+  padding1*: Uint8
+  padding2*: Uint8
+  padding3*: Uint8
+  data1*: Sint32               ## ::
+               ##   < event dependent data
+  data2*: Sint32               ## ::
+               ##   < event dependent data
+  
+
+ +
\brief Window state change event data (event.window.)
+ + +
+ +
KeyboardEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_KEYDOWN or ::SDL_KEYUP
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  windowID*: Uint32            ## ::
+                  ##   < The window with keyboard focus, if any
+  state*: Uint8                ## ::
+              ##   < ::SDL_PRESSED or ::SDL_RELEASED
+  repeat*: Uint8               ## ::
+               ##   < Non-zero if this is a key repeat
+  padding2*: Uint8
+  padding3*: Uint8
+  keysym*: Keysym              ## ::
+                ##   < The key that was pressed or released
+  
+
+ +
\brief Keyboard button event structure (event.key.)
+ + +
+ +
TextEditingEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_TEXTEDITING
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  windowID*: Uint32            ## ::
+                  ##   < The window with keyboard focus, if any
+  text*: array[(32), cchar]     ## ::
+                         ##   < The editing text
+  start*: Sint32               ## ::
+               ##   < The start cursor of selected editing text
+  length*: Sint32              ## ::
+                ##   < The length of selected editing text
+  
+
+ +
\brief Keyboard text editing event structure (event.edit.)
+ + +
+ +
TextInputEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_TEXTINPUT
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  windowID*: Uint32            ## ::
+                  ##   < The window with keyboard focus, if any
+  text*: array[(32), cchar]     ## ::
+                         ##   < The input text
+  
+
+ +
\brief Keyboard text input event structure (event.text.)
+ + +
+ +
MouseMotionEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_MOUSEMOTION
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  windowID*: Uint32            ## ::
+                  ##   < The window with mouse focus, if any
+  which*: Uint32               ## ::
+               ##   < The mouse instance id, or SDL_TOUCH_MOUSEID
+  state*: Uint32               ## ::
+               ##   < The current button state
+  x*: Sint32                   ## ::
+           ##   < X coordinate, relative to window
+  y*: Sint32                   ## ::
+           ##   < Y coordinate, relative to window
+  xrel*: Sint32                ## ::
+              ##   < The relative motion in the X direction
+  yrel*: Sint32                ## ::
+              ##   < The relative motion in the Y direction
+  
+
+ +
\brief Mouse motion event structure (event.motion.)
+ + +
+ +
MouseButtonEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_MOUSEBUTTONDOWN or ::SDL_MOUSEBUTTONUP
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  windowID*: Uint32            ## ::
+                  ##   < The window with mouse focus, if any
+  which*: Uint32               ## ::
+               ##   < The mouse instance id, or SDL_TOUCH_MOUSEID
+  button*: Uint8               ## ::
+               ##   < The mouse button index
+  state*: Uint8                ## ::
+              ##   < ::SDL_PRESSED or ::SDL_RELEASED
+  clicks*: Uint8               ## ::
+               ##   < 1 for single-click, 2 for double-click, etc.
+  padding1*: Uint8
+  x*: Sint32                   ## ::
+           ##   < X coordinate, relative to window
+  y*: Sint32                   ## ::
+           ##   < Y coordinate, relative to window
+  
+
+ +
\brief Mouse button event structure (event.button.)
+ + +
+ +
MouseWheelEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_MOUSEWHEEL
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  windowID*: Uint32            ## ::
+                  ##   < The window with mouse focus, if any
+  which*: Uint32               ## ::
+               ##   < The mouse instance id, or SDL_TOUCH_MOUSEID
+  x*: Sint32                   ## ::
+           ##   < The amount scrolled horizontally, positive to the right and negative to the left
+  y*: Sint32                   ## ::
+           ##   < The amount scrolled vertically, positive away from the user and negative toward the user
+  direction*: Uint32           ## ::
+                   ##   < Set to one of the SDL_MOUSEWHEEL_ defines. When FLIPPED the values in X and Y will be opposite. Multiply by -1 to change them back
+  
+
+ +
\brief Mouse wheel event structure (event.wheel.)
+ + +
+ +
JoyAxisEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_JOYAXISMOTION
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  which*: JoystickID           ## ::
+                   ##   < The joystick instance id
+  axis*: Uint8                 ## ::
+             ##   < The joystick axis index
+  padding1*: Uint8
+  padding2*: Uint8
+  padding3*: Uint8
+  value*: Sint16               ## ::
+               ##   < The axis value (range: -32768 to 32767)
+  padding4*: Uint16
+
+
+ +
\brief Joystick axis motion event structure (event.jaxis.)
+ + +
+ +
JoyBallEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_JOYBALLMOTION
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  which*: JoystickID           ## ::
+                   ##   < The joystick instance id
+  ball*: Uint8                 ## ::
+             ##   < The joystick trackball index
+  padding1*: Uint8
+  padding2*: Uint8
+  padding3*: Uint8
+  xrel*: Sint16                ## ::
+              ##   < The relative motion in the X direction
+  yrel*: Sint16                ## ::
+              ##   < The relative motion in the Y direction
+  
+
+ +
\brief Joystick trackball motion event structure (event.jball.)
+ + +
+ +
JoyHatEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_JOYHATMOTION
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  which*: JoystickID           ## ::
+                   ##   < The joystick instance id
+  hat*: Uint8                  ## ::
+            ##   < The joystick hat index
+  value*: Uint8 ## ::
+              ##   < The hat position value.
+              ##      \sa ::SDL_HAT_LEFTUP ::SDL_HAT_UP ::SDL_HAT_RIGHTUP
+              ##      \sa ::SDL_HAT_LEFT ::SDL_HAT_CENTERED ::SDL_HAT_RIGHT
+              ##      \sa ::SDL_HAT_LEFTDOWN ::SDL_HAT_DOWN ::SDL_HAT_RIGHTDOWN
+              ##   
+              ##      Note that zero means the POV is centered.
+  padding1*: Uint8
+  padding2*: Uint8
+
+
+ +
\brief Joystick hat position change event structure (event.jhat.)
+ + +
+ +
JoyButtonEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_JOYBUTTONDOWN or ::SDL_JOYBUTTONUP
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  which*: JoystickID           ## ::
+                   ##   < The joystick instance id
+  button*: Uint8               ## ::
+               ##   < The joystick button index
+  state*: Uint8                ## ::
+              ##   < ::SDL_PRESSED or ::SDL_RELEASED
+  padding1*: Uint8
+  padding2*: Uint8
+
+
+ +
\brief Joystick button event structure (event.jbutton.)
+ + +
+ +
JoyDeviceEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_JOYDEVICEADDED or ::SDL_JOYDEVICEREMOVED
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  which*: Sint32               ## ::
+               ##   < The joystick device index for the ADDED event, instance id for the REMOVED event
+  
+
+ +
\brief Joystick device event structure (event.jdevice.)
+ + +
+ +
ControllerAxisEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_CONTROLLERAXISMOTION
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  which*: JoystickID           ## ::
+                   ##   < The joystick instance id
+  axis*: Uint8                 ## ::
+             ##   < The controller axis (SDL_GameControllerAxis)
+  padding1*: Uint8
+  padding2*: Uint8
+  padding3*: Uint8
+  value*: Sint16               ## ::
+               ##   < The axis value (range: -32768 to 32767)
+  padding4*: Uint16
+
+
+ +
\brief Game controller axis motion event structure (event.caxis.)
+ + +
+ +
ControllerButtonEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_CONTROLLERBUTTONDOWN or ::SDL_CONTROLLERBUTTONUP
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  which*: JoystickID           ## ::
+                   ##   < The joystick instance id
+  button*: Uint8               ## ::
+               ##   < The controller button (SDL_GameControllerButton)
+  state*: Uint8                ## ::
+              ##   < ::SDL_PRESSED or ::SDL_RELEASED
+  padding1*: Uint8
+  padding2*: Uint8
+
+
+ +
\brief Game controller button event structure (event.cbutton.)
+ + +
+ +
ControllerDeviceEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_CONTROLLERDEVICEADDED, ::SDL_CONTROLLERDEVICEREMOVED, or ::SDL_CONTROLLERDEVICEREMAPPED
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  which*: Sint32               ## ::
+               ##   < The joystick device index for the ADDED event, instance id for the REMOVED or REMAPPED event
+  
+
+ +
\brief Controller device event structure (event.cdevice.)
+ + +
+ +
AudioDeviceEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_AUDIODEVICEADDED, or ::SDL_AUDIODEVICEREMOVED
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  which*: Uint32               ## ::
+               ##   < The audio device index for the ADDED event (valid until next SDL_GetNumAudioDevices() call), SDL_AudioDeviceID for the REMOVED event
+  iscapture*: Uint8            ## ::
+                  ##   < zero if an output device, non-zero if a capture device.
+  padding1*: Uint8
+  padding2*: Uint8
+  padding3*: Uint8
+
+
+ +
\brief Audio device event structure (event.adevice.)
+ + +
+ +
TouchFingerEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_FINGERMOTION or ::SDL_FINGERDOWN or ::SDL_FINGERUP
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  touchId*: TouchID            ## ::
+                  ##   < The touch device id
+  fingerId*: FingerID
+  x*: cfloat                   ## ::
+           ##   < Normalized in the range 0...1
+  y*: cfloat                   ## ::
+           ##   < Normalized in the range 0...1
+  dx*: cfloat                  ## ::
+            ##   < Normalized in the range -1...1
+  dy*: cfloat                  ## ::
+            ##   < Normalized in the range -1...1
+  pressure*: cfloat            ## ::
+                  ##   < Normalized in the range 0...1
+  windowID*: Uint32            ## ::
+                  ##   < The window underneath the finger, if any
+  
+
+ +
\brief Touch finger event structure (event.tfinger.)
+ + +
+ +
MultiGestureEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_MULTIGESTURE
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  touchId*: TouchID            ## ::
+                  ##   < The touch device id
+  dTheta*: cfloat
+  dDist*: cfloat
+  x*: cfloat
+  y*: cfloat
+  numFingers*: Uint16
+  padding*: Uint16
+
+
+ +
\brief Multiple Finger Gesture Event (event.mgesture.)
+ + +
+ +
DollarGestureEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_DOLLARGESTURE or ::SDL_DOLLARRECORD
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  touchId*: TouchID            ## ::
+                  ##   < The touch device id
+  gestureId*: GestureID
+  numFingers*: Uint32
+  error*: cfloat
+  x*: cfloat                   ## ::
+           ##   < Normalized center of gesture
+  y*: cfloat                   ## ::
+           ##   < Normalized center of gesture
+  
+
+ +
\brief Dollar Gesture Event (event.dgesture.)
+ + +
+ +
DropEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_DROPBEGIN or ::SDL_DROPFILE or ::SDL_DROPTEXT or ::SDL_DROPCOMPLETE
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  file*: cstring               ## ::
+               ##   < The file name, which should be freed with SDL_free(), is NULL on begin/complete
+  windowID*: Uint32            ## ::
+                  ##   < The window that was dropped on, if any
+  
+
+ +
\brief An event used to request a file open by the system (event.drop.)
+         This event is enabled by default, you can disable it with SDL_EventState().
+  \note If this event is enabled, you must free the filename in the event.
+ + +
+ +
SensorEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_SENSORUPDATE
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  which*: Sint32               ## ::
+               ##   < The instance ID of the sensor
+  data*: array[6, cfloat]       ## ::
+                       ##   < Up to 6 values from the sensor - additional values can be queried using SDL_SensorGetData()
+  
+
+ +
\brief Sensor event structure (event.sensor.)
+ + +
+ +
QuitEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_QUIT
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  
+
+ +
\brief The "quit requested" event
+ + +
+ +
OSEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_QUIT
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  
+
+ +
\brief OS Specific event
+ + +
+ +
UserEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_USEREVENT through ::SDL_LASTEVENT-1
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  windowID*: Uint32            ## ::
+                  ##   < The associated window if any
+  code*: Sint32                ## ::
+              ##   < User defined event code
+  data1*: pointer              ## ::
+                ##   < User defined data pointer
+  data2*: pointer              ## ::
+                ##   < User defined data pointer
+  
+
+ +
\brief A user-defined event type (event.user.)
+ + +
+ +
SysWMmsg {...}{.incompleteStruct.} = object
+
+ + + +
+ +
SysWMEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_SYSWMEVENT
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  msg*: ptr SysWMmsg            ## ::
+                  ##   < driver dependent data, defined in SDL_syswm.h
+  
+
+ +
\brief A video driver dependent system event (event.syswm.)
+         This event is disabled by default, you can enable it with SDL_EventState()
+  
+  \note If you want to use this event, you should include SDL_syswm.h.
+ + +
+ +
Event {...}{.union, bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < Event type, shared with all events
+  common*: CommonEvent         ## ::
+                     ##   < Common event data
+  display*: DisplayEvent       ## ::
+                       ##   < Display event data
+  window*: WindowEvent         ## ::
+                     ##   < Window event data
+  key*: KeyboardEvent          ## ::
+                    ##   < Keyboard event data
+  edit*: TextEditingEvent      ## ::
+                        ##   < Text editing event data
+  text*: TextInputEvent        ## ::
+                      ##   < Text input event data
+  motion*: MouseMotionEvent    ## ::
+                          ##   < Mouse motion event data
+  button*: MouseButtonEvent    ## ::
+                          ##   < Mouse button event data
+  wheel*: MouseWheelEvent      ## ::
+                        ##   < Mouse wheel event data
+  jaxis*: JoyAxisEvent         ## ::
+                     ##   < Joystick axis event data
+  jball*: JoyBallEvent         ## ::
+                     ##   < Joystick ball event data
+  jhat*: JoyHatEvent           ## ::
+                   ##   < Joystick hat event data
+  jbutton*: JoyButtonEvent     ## ::
+                         ##   < Joystick button event data
+  jdevice*: JoyDeviceEvent     ## ::
+                         ##   < Joystick device change event data
+  caxis*: ControllerAxisEvent  ## ::
+                            ##   < Game Controller axis event data
+  cbutton*: ControllerButtonEvent ## ::
+                                ##   < Game Controller button event data
+  cdevice*: ControllerDeviceEvent ## ::
+                                ##   < Game Controller device event data
+  adevice*: AudioDeviceEvent   ## ::
+                           ##   < Audio device event data
+  sensor*: SensorEvent         ## ::
+                     ##   < Sensor event data
+  quit*: QuitEvent             ## ::
+                 ##   < Quit request event data
+  user*: UserEvent             ## ::
+                 ##   < Custom event data
+  syswm*: SysWMEvent           ## ::
+                   ##   < System dependent window event data
+  tfinger*: TouchFingerEvent   ## ::
+                           ##   < Touch finger event data
+  mgesture*: MultiGestureEvent ## ::
+                             ##   < Gesture event data
+  dgesture*: DollarGestureEvent ## ::
+                              ##   < Gesture event data
+  drop*: DropEvent             ## ::
+                 ##   < Drag and drop event data
+  padding*: array[56, Uint8]
+
+
+ +
\brief General event structure
+ + +
+ +
EventFilter = proc (userdata: pointer; event: ptr Event): cint {...}{.cdecl.}
+
+ + + +
+ +
PHaptic {...}{.incompleteStruct.} = object
+
+ + + +
+ +
Haptic = PHaptic
+
+ + + +
+ +
HapticDirection {...}{.bycopy.} = object
+  kind*: Uint8                 ## ::
+             ##   < The type of encoding.
+  dir*: array[3, Sint32]        ## ::
+                      ##   < The encoded direction.
+  
+
+ +
\brief Structure that represents a haptic direction.
+  
+  This is the direction where the force comes from,
+  instead of the direction in which the force is exerted.
+  
+  Directions can be specified by:
+   - ::SDL_HAPTIC_POLAR : Specified by polar coordinates.
+   - ::SDL_HAPTIC_CARTESIAN : Specified by cartesian coordinates.
+   - ::SDL_HAPTIC_SPHERICAL : Specified by spherical coordinates.
+  
+  Cardinal directions of the haptic device are relative to the positioning
+  of the device.  North is considered to be away from the user.
+  
+  The following diagram represents the cardinal directions:
+  \verbatim
+                 .--.
+                 |__| .-------.
+                 |=.| |.-----.|
+                 |--| ||     ||
+                 |  | |'-----'|
+                 |__|~')_____('
+                   [ COMPUTER ]
+                     North (0,-1)
+                         ^
+                         |
+                         |
+   (-1,0)  West <----[ HAPTIC ]----> East (1,0)
+                         |
+                         |
+                         v
+                      South (0,1)
+                      [ USER ]
+                        \|||/
+                        (o o)
+                  ---ooO-(_)-Ooo---
+    \endverbatim
+  
+  If type is ::SDL_HAPTIC_POLAR, direction is encoded by hundredths of a
+  degree starting north and turning clockwise.  ::SDL_HAPTIC_POLAR only uses
+  the first \c dir parameter.  The cardinal directions would be:
+   - North: 0 (0 degrees)
+   - East: 9000 (90 degrees)
+   - South: 18000 (180 degrees)
+   - West: 27000 (270 degrees)
+  
+  If type is ::SDL_HAPTIC_CARTESIAN, direction is encoded by three positions
+  (X axis, Y axis and Z axis (with 3 axes)).  ::SDL_HAPTIC_CARTESIAN uses
+  the first three \c dir parameters.  The cardinal directions would be:
+   - North:  0,-1, 0
+   - East:   1, 0, 0
+   - South:  0, 1, 0
+   - West:  -1, 0, 0
+  
+  The Z axis represents the height of the effect if supported, otherwise
+  it's unused.  In cartesian encoding (1, 2) would be the same as (2, 4), you
+  can use any multiple you want, only the direction matters.
+  
+  If type is ::SDL_HAPTIC_SPHERICAL, direction is encoded by two rotations.
+  The first two \c dir parameters are used.  The \c dir parameters are as
+  follows (all values are in hundredths of degrees):
+   - Degrees from (1, 0) rotated towards (0, 1).
+   - Degrees towards (0, 0, 1) (device needs at least 3 axes).
+  
+  
+  Example of force coming from the south with all encodings (force coming
+  from the south means the user will have to pull the stick to counteract):
+  \code
+  SDL_HapticDirection direction;
+ 
+ Cartesian directions
+  direction.type = SDL_HAPTIC_CARTESIAN; Using cartesian direction encoding.
+  direction.dir[0] = 0; X position
+  direction.dir[1] = 1; Y position
+ Assuming the device has 2 axes, we don't need to specify third parameter.
+ 
+ Polar directions
+  direction.type = SDL_HAPTIC_POLAR; We'll be using polar direction encoding.
+  direction.dir[0] = 18000; Polar only uses first parameter
+ 
+ Spherical coordinates
+  direction.type = SDL_HAPTIC_SPHERICAL; Spherical encoding
+  direction.dir[0] = 9000; Since we only have two axes we don't need more parameters.
+  \endcode
+  
+  \sa SDL_HAPTIC_POLAR
+  \sa SDL_HAPTIC_CARTESIAN
+  \sa SDL_HAPTIC_SPHERICAL
+  \sa SDL_HapticEffect
+  \sa SDL_HapticNumAxes
+ + +
+ +
HapticConstant {...}{.bycopy.} = object
+  kind*: Uint16                ## ::
+              ##   < ::SDL_HAPTIC_CONSTANT
+  direction*: HapticDirection  ## ::
+                            ##   < Direction of the effect.
+  length*: Uint32              ## ::
+                ##   < Duration of the effect.
+  delay*: Uint16               ## ::
+               ##   < Delay before starting the effect.
+  button*: Uint16              ## ::
+                ##   < Button that triggers the effect.
+  interval*: Uint16            ## ::
+                  ##   < How soon it can be triggered again after button.
+  level*: Sint16               ## ::
+               ##   < Strength of the constant effect.
+  attackLength*: Uint16        ## ::
+                      ##   < Duration of the attack.
+  attackLevel*: Uint16         ## ::
+                     ##   < Level at the start of the attack.
+  fadeLength*: Uint16          ## ::
+                    ##   < Duration of the fade.
+  fadeLevel*: Uint16           ## ::
+                   ##   < Level at the end of the fade.
+  
+
+ +
\brief A structure containing a template for a Constant effect.
+  
+  This struct is exclusively for the ::SDL_HAPTIC_CONSTANT effect.
+  
+  A constant effect applies a constant force in the specified direction
+  to the joystick.
+  
+  \sa SDL_HAPTIC_CONSTANT
+  \sa SDL_HapticEffect
+ + +
+ +
HapticPeriodic {...}{.bycopy.} = object
+  kind*: Uint16 ## ::
+              ##   < ::SDL_HAPTIC_SINE, ::SDL_HAPTIC_LEFTRIGHT,
+              ##                                ::SDL_HAPTIC_TRIANGLE, ::SDL_HAPTIC_SAWTOOTHUP or
+              ##                                ::SDL_HAPTIC_SAWTOOTHDOWN
+  direction*: HapticDirection  ## ::
+                            ##   < Direction of the effect.
+  length*: Uint32              ## ::
+                ##   < Duration of the effect.
+  delay*: Uint16               ## ::
+               ##   < Delay before starting the effect.
+  button*: Uint16              ## ::
+                ##   < Button that triggers the effect.
+  interval*: Uint16            ## ::
+                  ##   < How soon it can be triggered again after button.
+  period*: Uint16              ## ::
+                ##   < Period of the wave.
+  magnitude*: Sint16           ## ::
+                   ##   < Peak value; if negative, equivalent to 180 degrees extra phase shift.
+  offset*: Sint16              ## ::
+                ##   < Mean value of the wave.
+  phase*: Uint16               ## ::
+               ##   < Positive phase shift given by hundredth of a degree.
+  attackLength*: Uint16        ## ::
+                      ##   < Duration of the attack.
+  attackLevel*: Uint16         ## ::
+                     ##   < Level at the start of the attack.
+  fadeLength*: Uint16          ## ::
+                    ##   < Duration of the fade.
+  fadeLevel*: Uint16           ## ::
+                   ##   < Level at the end of the fade.
+  
+
+ +
\brief A structure containing a template for a Periodic effect.
+  
+  The struct handles the following effects:
+   - ::SDL_HAPTIC_SINE
+   - ::SDL_HAPTIC_LEFTRIGHT
+   - ::SDL_HAPTIC_TRIANGLE
+   - ::SDL_HAPTIC_SAWTOOTHUP
+   - ::SDL_HAPTIC_SAWTOOTHDOWN
+  
+  A periodic effect consists in a wave-shaped effect that repeats itself
+  over time.  The type determines the shape of the wave and the parameters
+  determine the dimensions of the wave.
+  
+  Phase is given by hundredth of a degree meaning that giving the phase a value
+  of 9000 will displace it 25% of its period.  Here are sample values:
+   -     0: No phase displacement.
+   -  9000: Displaced 25% of its period.
+   - 18000: Displaced 50% of its period.
+   - 27000: Displaced 75% of its period.
+   - 36000: Displaced 100% of its period, same as 0, but 0 is preferred.
+  
+  Examples:
+  \verbatim
+    SDL_HAPTIC_SINE
+      __      __      __      __
+     /  \    /  \    /  \    /
+    /    \__/    \__/    \__/
+    SDL_HAPTIC_SQUARE
+     __    __    __    __    __
+    |  |  |  |  |  |  |  |  |  |
+    |  |__|  |__|  |__|  |__|  |
+    SDL_HAPTIC_TRIANGLE
+      /\    /\    /\    /\    /\
+     /  \  /  \  /  \  /  \  /
+    /    \/    \/    \/    \/
+    SDL_HAPTIC_SAWTOOTHUP
+      /|  /|  /|  /|  /|  /|  /|
+     / | / | / | / | / | / | / |
+    /  |/  |/  |/  |/  |/  |/  |
+    SDL_HAPTIC_SAWTOOTHDOWN
+    \  |\  |\  |\  |\  |\  |\  |
+     \ | \ | \ | \ | \ | \ | \ |
+      \|  \|  \|  \|  \|  \|  \|
+    \endverbatim
+  
+  \sa SDL_HAPTIC_SINE
+  \sa SDL_HAPTIC_LEFTRIGHT
+  \sa SDL_HAPTIC_TRIANGLE
+  \sa SDL_HAPTIC_SAWTOOTHUP
+  \sa SDL_HAPTIC_SAWTOOTHDOWN
+  \sa SDL_HapticEffect
+ + +
+ +
HapticCondition {...}{.bycopy.} = object
+  kind*: Uint16                ## ::
+              ##   < ::SDL_HAPTIC_SPRING, ::SDL_HAPTIC_DAMPER,
+              ##                                    ::SDL_HAPTIC_INERTIA or ::SDL_HAPTIC_FRICTION
+  direction*: HapticDirection  ## ::
+                            ##   < Direction of the effect - Not used ATM.
+  length*: Uint32              ## ::
+                ##   < Duration of the effect.
+  delay*: Uint16               ## ::
+               ##   < Delay before starting the effect.
+  button*: Uint16              ## ::
+                ##   < Button that triggers the effect.
+  interval*: Uint16            ## ::
+                  ##   < How soon it can be triggered again after button.
+  rightSat*: array[3, Uint16]   ## ::
+                           ##   < Level when joystick is to the positive side; max 0xFFFF.
+  leftSat*: array[3, Uint16]    ## ::
+                          ##   < Level when joystick is to the negative side; max 0xFFFF.
+  rightCoeff*: array[3, Sint16] ## ::
+                             ##   < How fast to increase the force towards the positive side.
+  leftCoeff*: array[3, Sint16]  ## ::
+                            ##   < How fast to increase the force towards the negative side.
+  deadband*: array[3, Uint16]   ## ::
+                           ##   < Size of the dead zone; max 0xFFFF: whole axis-range when 0-centered.
+  center*: array[3, Sint16]     ## ::
+                         ##   < Position of the dead zone.
+  
+
+ +
\brief A structure containing a template for a Condition effect.
+  
+  The struct handles the following effects:
+   - ::SDL_HAPTIC_SPRING: Effect based on axes position.
+   - ::SDL_HAPTIC_DAMPER: Effect based on axes velocity.
+   - ::SDL_HAPTIC_INERTIA: Effect based on axes acceleration.
+   - ::SDL_HAPTIC_FRICTION: Effect based on axes movement.
+  
+  Direction is handled by condition internals instead of a direction member.
+  The condition effect specific members have three parameters.  The first
+  refers to the X axis, the second refers to the Y axis and the third
+  refers to the Z axis.  The right terms refer to the positive side of the
+  axis and the left terms refer to the negative side of the axis.  Please
+  refer to the ::SDL_HapticDirection diagram for which side is positive and
+  which is negative.
+  
+  \sa SDL_HapticDirection
+  \sa SDL_HAPTIC_SPRING
+  \sa SDL_HAPTIC_DAMPER
+  \sa SDL_HAPTIC_INERTIA
+  \sa SDL_HAPTIC_FRICTION
+  \sa SDL_HapticEffect
+ + +
+ +
HapticRamp {...}{.bycopy.} = object
+  kind*: Uint16                ## ::
+              ##   < ::SDL_HAPTIC_RAMP
+  direction*: HapticDirection  ## ::
+                            ##   < Direction of the effect.
+  length*: Uint32              ## ::
+                ##   < Duration of the effect.
+  delay*: Uint16               ## ::
+               ##   < Delay before starting the effect.
+  button*: Uint16              ## ::
+                ##   < Button that triggers the effect.
+  interval*: Uint16            ## ::
+                  ##   < How soon it can be triggered again after button.
+  start*: Sint16               ## ::
+               ##   < Beginning strength level.
+  `end`*: Sint16               ## ::
+               ##   < Ending strength level.
+  attackLength*: Uint16        ## ::
+                      ##   < Duration of the attack.
+  attackLevel*: Uint16         ## ::
+                     ##   < Level at the start of the attack.
+  fadeLength*: Uint16          ## ::
+                    ##   < Duration of the fade.
+  fadeLevel*: Uint16           ## ::
+                   ##   < Level at the end of the fade.
+  
+
+ +
\brief A structure containing a template for a Ramp effect.
+  
+  This struct is exclusively for the ::SDL_HAPTIC_RAMP effect.
+  
+  The ramp effect starts at start strength and ends at end strength.
+  It augments in linear fashion.  If you use attack and fade with a ramp
+  the effects get added to the ramp effect making the effect become
+  quadratic instead of linear.
+  
+  \sa SDL_HAPTIC_RAMP
+  \sa SDL_HapticEffect
+ + +
+ +
HapticLeftRight {...}{.bycopy.} = object
+  kind*: Uint16                ## ::
+              ##   < ::SDL_HAPTIC_LEFTRIGHT
+  length*: Uint32              ## ::
+                ##   < Duration of the effect in milliseconds.
+  largeMagnitude*: Uint16      ## ::
+                        ##   < Control of the large controller motor.
+  smallMagnitude*: Uint16      ## ::
+                        ##   < Control of the small controller motor.
+  
+
+ +
\brief A structure containing a template for a Left/Right effect.
+ 
+ This struct is exclusively for the ::SDL_HAPTIC_LEFTRIGHT effect.
+ 
+ The Left/Right effect is used to explicitly control the large and small
+ motors, commonly found in modern game controllers. The small (right) motor
+ is high frequency, and the large (left) motor is low frequency.
+ 
+ \sa SDL_HAPTIC_LEFTRIGHT
+ \sa SDL_HapticEffect
+ + +
+ +
HapticCustom {...}{.bycopy.} = object
+  kind*: Uint16                ## ::
+              ##   < ::SDL_HAPTIC_CUSTOM
+  direction*: HapticDirection  ## ::
+                            ##   < Direction of the effect.
+  length*: Uint32              ## ::
+                ##   < Duration of the effect.
+  delay*: Uint16               ## ::
+               ##   < Delay before starting the effect.
+  button*: Uint16              ## ::
+                ##   < Button that triggers the effect.
+  interval*: Uint16            ## ::
+                  ##   < How soon it can be triggered again after button.
+  channels*: Uint8             ## ::
+                 ##   < Axes to use, minimum of one.
+  period*: Uint16              ## ::
+                ##   < Sample periods.
+  samples*: Uint16             ## ::
+                 ##   < Amount of samples.
+  data*: ptr Uint16             ## ::
+                 ##   < Should contain channelssamples items.
+  attackLength*: Uint16        ## ::
+                      ##   < Duration of the attack.
+  attackLevel*: Uint16         ## ::
+                     ##   < Level at the start of the attack.
+  fadeLength*: Uint16          ## ::
+                    ##   < Duration of the fade.
+  fadeLevel*: Uint16           ## ::
+                   ##   < Level at the end of the fade.
+  
+
+ +
\brief A structure containing a template for the ::SDL_HAPTIC_CUSTOM effect.
+  
+  This struct is exclusively for the ::SDL_HAPTIC_CUSTOM effect.
+  
+  A custom force feedback effect is much like a periodic effect, where the
+  application can define its exact shape.  You will have to allocate the
+  data yourself.  Data should consist of channels samples Uint16 samples.
+  
+  If channels is one, the effect is rotated using the defined direction.
+  Otherwise it uses the samples in data for the different axes.
+  
+  \sa SDL_HAPTIC_CUSTOM
+  \sa SDL_HapticEffect
+ + +
+ +
HapticEffect {...}{.union, bycopy.} = object
+  kind*: Uint16                ## ::
+              ##   < Effect type.
+  constant*: HapticConstant    ## ::
+                          ##   < Constant effect.
+  periodic*: HapticPeriodic    ## ::
+                          ##   < Periodic effect.
+  condition*: HapticCondition  ## ::
+                            ##   < Condition effect.
+  ramp*: HapticRamp            ## ::
+                  ##   < Ramp effect.
+  leftright*: HapticLeftRight  ## ::
+                            ##   < Left/Right effect.
+  custom*: HapticCustom        ## ::
+                      ##   < Custom effect.
+  
+
+ +
\brief The generic template for any haptic effect.
+  
+  All values max at 32767 (0x7FFF).  Signed values also can be negative.
+  Time values unless specified otherwise are in milliseconds.
+  
+  You can also pass ::SDL_HAPTIC_INFINITY to length instead of a 0-32767
+  value.  Neither delay, interval, attack_length nor fade_length support
+  ::SDL_HAPTIC_INFINITY.  Fade will also not be used since effect never ends.
+  
+  Additionally, the ::SDL_HAPTIC_RAMP effect does not support a duration of
+  ::SDL_HAPTIC_INFINITY.
+  
+  Button triggers may not be supported on all devices, it is advised to not
+  use them if possible.  Buttons start at index 1 instead of index 0 like
+  the joystick.
+  
+  If both attack_length and fade_level are 0, the envelope is not used,
+  otherwise both values are used.
+  
+  Common parts:
+  \code
+ Replay - All effects have this
+  Uint32 length; Duration of effect (ms).
+  Uint16 delay; Delay before starting effect.
+ 
+ Trigger - All effects have this
+  Uint16 button; Button that triggers effect.
+  Uint16 interval; How soon before effect can be triggered again.
+ 
+ Envelope - All effects except condition effects have this
+  Uint16 attack_length; Duration of the attack (ms).
+  Uint16 attack_level; Level at the start of the attack.
+  Uint16 fade_length; Duration of the fade out (ms).
+  Uint16 fade_level; Level at the end of the fade.
+  \endcode
+  
+  
+  Here we have an example of a constant effect evolution in time:
+  \verbatim
+    Strength
+    ^
+    |
+    |    effect level -->  _________________
+    |                     /                 \
+    |                    /                   \
+    |                   /                     \
+    |                  /                       \
+    | attack_level --> |                        \
+    |                  |                        |  <---  fade_level
+    |
+    +--------------------------------------------------> Time
+                       [--]                 [---]
+                       attack_length        fade_length
+    [------------------][-----------------------]
+    delay               length
+    \endverbatim
+  
+  Note either the attack_level or the fade_level may be above the actual
+  effect level.
+  
+  \sa SDL_HapticConstant
+  \sa SDL_HapticPeriodic
+  \sa SDL_HapticCondition
+  \sa SDL_HapticRamp
+  \sa SDL_HapticLeftRight
+  \sa SDL_HapticCustom
+ + +
+ +
HintCallback = proc (userdata: pointer; name: cstring; oldValue: cstring;
+                  newValue: cstring) {...}{.cdecl.}
+
+ + + +
+ +
LogOutputFunction = proc (userdata: pointer; category: cint; priority: LogPriority;
+                       message: cstring) {...}{.cdecl.}
+
+ + + +
+ +
MessageBoxButtonData {...}{.bycopy.} = object
+  flags*: Uint32               ## ::
+               ##   < ::SDL_MessageBoxButtonFlags
+  buttonid*: cint              ## ::
+                ##   < User defined button id (value returned via SDL_ShowMessageBox)
+  text*: cstring               ## ::
+               ##   < The UTF-8 button text
+  
+
+ +
\brief Individual button data.
+ + +
+ +
MessageBoxColor {...}{.bycopy.} = object
+  r*: Uint8
+  g*: Uint8
+  b*: Uint8
+
+
+ +
\brief RGB value used in a message box color scheme
+ + +
+ +
MessageBoxColorScheme {...}{.bycopy.} = object
+  colors*: array[MESSAGEBOX_COLOR_MAX, MessageBoxColor]
+
+
+ +
\brief A set of colors to use for message box dialogs
+ + +
+ +
MessageBoxData {...}{.bycopy.} = object
+  flags*: Uint32               ## ::
+               ##   < ::SDL_MessageBoxFlags
+  window*: ptr Window           ## ::
+                   ##   < Parent window, can be NULL
+  title*: cstring              ## ::
+                ##   < UTF-8 title
+  message*: cstring            ## ::
+                  ##   < UTF-8 message text
+  numbuttons*: cint
+  buttons*: ptr MessageBoxButtonData
+  colorScheme*: ptr MessageBoxColorScheme ## ::
+                                       ##   < ::SDL_MessageBoxColorScheme, can be NULL to use system settings
+  
+
+ +
\brief MessageBox structure containing title, text, window, etc.
+ + +
+ +
MetalView = pointer
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+\brief A handle to a CAMetalLayer-backed NSView (macOS) or UIView (iOS/tvOS).
+  
+  \note This can be cast directly to an NSView or UIView.
+ + +
+ +
RendererInfo {...}{.bycopy.} = object
+  name*: cstring               ## ::
+               ##   < The name of the renderer
+  flags*: Uint32               ## ::
+               ##   < Supported ::SDL_RendererFlags
+  numTextureFormats*: Uint32   ## ::
+                           ##   < The number of available texture formats
+  textureFormats*: array[16, Uint32] ## ::
+                                  ##   < The available texture formats
+  maxTextureWidth*: cint       ## ::
+                       ##   < The maximum texture width
+  maxTextureHeight*: cint      ## ::
+                        ##   < The maximum texture height
+  
+
+ +
\brief Information on the capabilities of a render driver or context.
+ + +
+ +
Renderer {...}{.incompleteStruct.} = object
+
+ + + +
+ +
Texture {...}{.incompleteStruct.} = object
+
+ + + +
+ +
Sensor {...}{.incompleteStruct.} = object
+
+ + + +
+ +
SensorID = Sint32
+
+ +
This is a unique ID for a sensor for the time it is connected to the system,
+ and is never reused for the lifetime of the application.
+ 
+ The ID value starts at 0 and increments from there. The value -1 is an invalid ID.
+ + +
+ +
WindowShapeParams {...}{.union, bycopy.} = object
+  binarizationCutoff*: Uint8
+  colorKey*: Color
+
+
+ +
\brief A union containing parameters for shaped windows.
+ + +
+ +
TimerCallback = proc (interval: Uint32; param: pointer): Uint32 {...}{.cdecl.}
+
+ + + +
+ +
TimerID = cint
+
+ +
Definition of the timer ID type.
+ + +
+ +
Version {...}{.bycopy.} = object
+  major*: Uint8                ## ::
+              ##   < major version
+  minor*: Uint8                ## ::
+              ##   < minor version
+  patch*: Uint8                ## ::
+              ##   < update version
+  
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+\brief Information the version of SDL in use.
+  
+  Represents the library's version as three levels: major revision
+  (increments with massive changes, additions, and enhancements),
+  minor revision (increments with backwards-compatible changes to the
+  major revision), and patchlevel (increments with fixes to the minor
+  revision).
+  
+  \sa SDL_VERSION
+  \sa SDL_GetVersion
+ + +
+ +
+
+

Consts

+
+ +
SDLCacheDir = "/Users/joey/Projects/nim-sdl2/src/build"
+
+ + + +
+ +
SDLStd = false
+
+ + + +
+ +
SDLGit = false
+
+ + + +
+ +
SDLDL = true
+
+ + + +
+ +
SDLStatic = true
+
+ + + +
+ +
SDLSetVer = ""
+
+ + + +
+ +
SDLLPath = "/Users/joey/Projects/nim-sdl2/src/build/sdl2/buildcache/libSDL2.a"
+
+ + + +
+ +
SDLPath = "/Users/joey/Projects/nim-sdl2/src/build/sdl2/include/SDL.h"
+
+ + + +
+ +
MIN_UINT8 = 0'u8
+
+ + + +
+ +
MIN_UINT64 = 0'u64
+
+ + + +
+ +
MAX_SINT16 = 32767'i16
+
+ + + +
+ +
MAX_SINT32 = 2147483647'i32
+
+ + + +
+ +
Colour = ""
+
+ + + +
+ +
MOUSE_TOUCHID = -1'i64
+
+ + + +
+ +
WINDOWPOS_CENTERED_MASK = 805240832'u
+
+ + + +
+ +
MAX_UINT8 = 255'u8
+
+ + + +
+ +
BlitScaled = ""
+
+ + + +
+ +
MIN_SINT8 = -128'i8
+
+ + + +
+ +
MIN_UINT16 = 0'u16
+
+ + + +
+ +
MIN_UINT32 = 0'u32
+
+ + + +
+ +
TOUCH_MOUSEID = 4294967295
+
+ + + +
+ +
BlitSurface = ""
+
+ + + +
+ +
WINDOWPOS_UNDEFINED_MASK = 536805376'u
+
+ + + +
+ +
MIN_SINT32 = -2147483648'i32
+
+ + + +
+ +
MUTEX_MAXWAIT = 4294967295
+
+ + + +
+ +
MAX_SINT8 = 127'i8
+
+ + + +
+ +
MAX_UINT16 = 65535'u16
+
+ + + +
+ +
MAX_UINT32 = 4294967295'u32
+
+ + + +
+ +
MIN_SINT16 = -32768'i16
+
+ + + +
+ +
MAX_UINT64 = 18446744073709551615'u64
+
+ + + +
+ +
MAX_SINT64 = 9223372036854775807'i64
+
+ + + +
+ +
MACOSX = 1
+
+ + + +
+ +
SIZEOF_VOIDP = 8
+
+ + + +
+ +
HAVE_GCC_ATOMICS = 1
+
+ + + +
+ +
HAVE_LIBC = 1
+
+ + + +
+ +
STDC_HEADERS = 1
+
+ + + +
+ +
HAVE_ALLOCA_H = 1
+
+ + + +
+ +
HAVE_CTYPE_H = 1
+
+ + + +
+ +
HAVE_FLOAT_H = 1
+
+ + + +
+ +
HAVE_ICONV_H = 1
+
+ + + +
+ +
HAVE_INTTYPES_H = 1
+
+ + + +
+ +
HAVE_LIMITS_H = 1
+
+ + + +
+ +
HAVE_MATH_H = 1
+
+ + + +
+ +
HAVE_MEMORY_H = 1
+
+ + + +
+ +
HAVE_SIGNAL_H = 1
+
+ + + +
+ +
HAVE_STDARG_H = 1
+
+ + + +
+ +
HAVE_STDINT_H = 1
+
+ + + +
+ +
HAVE_STDIO_H = 1
+
+ + + +
+ +
HAVE_STDLIB_H = 1
+
+ + + +
+ +
HAVE_STRINGS_H = 1
+
+ + + +
+ +
HAVE_STRING_H = 1
+
+ + + +
+ +
HAVE_SYS_TYPES_H = 1
+
+ + + +
+ +
HAVE_WCHAR_H = 1
+
+ + + +
+ +
HAVE_LIBUNWIND_H = 1
+
+ + + +
+ +
HAVE_MALLOC = 1
+
+ + + +
+ +
HAVE_CALLOC = 1
+
+ + + +
+ +
HAVE_REALLOC = 1
+
+ + + +
+ +
HAVE_FREE = 1
+
+ + + +
+ +
HAVE_ALLOCA = 1
+
+ + + +
+ +
HAVE_GETENV = 1
+
+ + + +
+ +
HAVE_SETENV = 1
+
+ + + +
+ +
HAVE_PUTENV = 1
+
+ + + +
+ +
HAVE_UNSETENV = 1
+
+ + + +
+ +
HAVE_QSORT = 1
+
+ + + +
+ +
HAVE_ABS = 1
+
+ + + +
+ +
HAVE_BCOPY = 1
+
+ + + +
+ +
HAVE_MEMSET = 1
+
+ + + +
+ +
HAVE_MEMCPY = 1
+
+ + + +
+ +
HAVE_MEMMOVE = 1
+
+ + + +
+ +
HAVE_MEMCMP = 1
+
+ + + +
+ +
HAVE_WCSLEN = 1
+
+ + + +
+ +
HAVE_WCSLCPY = 1
+
+ + + +
+ +
HAVE_WCSLCAT = 1
+
+ + + +
+ +
HAVE_WCSDUP = 1
+
+ + + +
+ +
HAVE_WCSSTR = 1
+
+ + + +
+ +
HAVE_WCSCMP = 1
+
+ + + +
+ +
HAVE_WCSNCMP = 1
+
+ + + +
+ +
HAVE_STRLEN = 1
+
+ + + +
+ +
HAVE_STRLCPY = 1
+
+ + + +
+ +
HAVE_STRLCAT = 1
+
+ + + +
+ +
HAVE_STRCHR = 1
+
+ + + +
+ +
HAVE_STRRCHR = 1
+
+ + + +
+ +
HAVE_STRSTR = 1
+
+ + + +
+ +
HAVE_STRTOK_R = 1
+
+ + + +
+ +
HAVE_STRTOL = 1
+
+ + + +
+ +
HAVE_STRTOUL = 1
+
+ + + +
+ +
HAVE_STRTOLL = 1
+
+ + + +
+ +
HAVE_STRTOULL = 1
+
+ + + +
+ +
HAVE_STRTOD = 1
+
+ + + +
+ +
HAVE_ATOI = 1
+
+ + + +
+ +
HAVE_ATOF = 1
+
+ + + +
+ +
HAVE_STRCMP = 1
+
+ + + +
+ +
HAVE_STRNCMP = 1
+
+ + + +
+ +
HAVE_STRCASECMP = 1
+
+ + + +
+ +
HAVE_STRNCASECMP = 1
+
+ + + +
+ +
HAVE_VSSCANF = 1
+
+ + + +
+ +
HAVE_VSNPRINTF = 1
+
+ + + +
+ +
HAVE_ACOS = 1
+
+ + + +
+ +
HAVE_ACOSF = 1
+
+ + + +
+ +
HAVE_ASIN = 1
+
+ + + +
+ +
HAVE_ASINF = 1
+
+ + + +
+ +
HAVE_ATAN = 1
+
+ + + +
+ +
HAVE_ATANF = 1
+
+ + + +
+ +
HAVE_ATAN2 = 1
+
+ + + +
+ +
HAVE_ATAN2F = 1
+
+ + + +
+ +
HAVE_CEIL = 1
+
+ + + +
+ +
HAVE_CEILF = 1
+
+ + + +
+ +
HAVE_COPYSIGN = 1
+
+ + + +
+ +
HAVE_COPYSIGNF = 1
+
+ + + +
+ +
HAVE_COS = 1
+
+ + + +
+ +
HAVE_COSF = 1
+
+ + + +
+ +
HAVE_EXP = 1
+
+ + + +
+ +
HAVE_EXPF = 1
+
+ + + +
+ +
HAVE_FABS = 1
+
+ + + +
+ +
HAVE_FABSF = 1
+
+ + + +
+ +
HAVE_FLOOR = 1
+
+ + + +
+ +
HAVE_FLOORF = 1
+
+ + + +
+ +
HAVE_FMOD = 1
+
+ + + +
+ +
HAVE_FMODF = 1
+
+ + + +
+ +
HAVE_LOG = 1
+
+ + + +
+ +
HAVE_LOGF = 1
+
+ + + +
+ +
HAVE_LOG10 = 1
+
+ + + +
+ +
HAVE_LOG10F = 1
+
+ + + +
+ +
HAVE_POW = 1
+
+ + + +
+ +
HAVE_POWF = 1
+
+ + + +
+ +
HAVE_SCALBN = 1
+
+ + + +
+ +
HAVE_SCALBNF = 1
+
+ + + +
+ +
HAVE_SIN = 1
+
+ + + +
+ +
HAVE_SINF = 1
+
+ + + +
+ +
HAVE_SQRT = 1
+
+ + + +
+ +
HAVE_SQRTF = 1
+
+ + + +
+ +
HAVE_TAN = 1
+
+ + + +
+ +
HAVE_TANF = 1
+
+ + + +
+ +
HAVE_FSEEKO = 1
+
+ + + +
+ +
HAVE_SIGACTION = 1
+
+ + + +
+ +
HAVE_SA_SIGACTION = 1
+
+ + + +
+ +
HAVE_SETJMP = 1
+
+ + + +
+ +
HAVE_NANOSLEEP = 1
+
+ + + +
+ +
HAVE_SYSCONF = 1
+
+ + + +
+ +
HAVE_SYSCTLBYNAME = 1
+
+ + + +
+ +
HAVE_MPROTECT = 1
+
+ + + +
+ +
HAVE_ICONV = 1
+
+ + + +
+ +
HAVE_PTHREAD_SETNAME_NP = 1
+
+ + + +
+ +
HAVE_POLL = 1
+
+ + + +
+ +
HAVE_EXIT = 1
+
+ + + +
+ +
HAVE_IMMINTRIN_H = 1
+
+ + + +
+ +
AUDIO_DRIVER_COREAUDIO = 1
+
+ + + +
+ +
AUDIO_DRIVER_DISK = 1
+
+ + + +
+ +
AUDIO_DRIVER_DUMMY = 1
+
+ + + +
+ +
JOYSTICK_IOKIT = 1
+
+ + + +
+ +
HAPTIC_TYPE_IOKIT = 1
+
+ + + +
+ +
SENSOR_DUMMY = 1
+
+ + + +
+ +
LOADSO_DLOPEN = 1
+
+ + + +
+ +
THREAD_PTHREAD = 1
+
+ + + +
+ +
THREAD_PTHREAD_RECURSIVE_MUTEX = 1
+
+ + + +
+ +
TIMER_UNIX = 1
+
+ + + +
+ +
VIDEO_DRIVER_COCOA = 1
+
+ + + +
+ +
VIDEO_DRIVER_DUMMY = 1
+
+ + + +
+ +
VIDEO_RENDER_OGL = 1
+
+ + + +
+ +
VIDEO_RENDER_OGL_ES2 = 1
+
+ + + +
+ +
VIDEO_RENDER_METAL = 1
+
+ + + +
+ +
VIDEO_OPENGL = 1
+
+ + + +
+ +
VIDEO_OPENGL_ES2 = 1
+
+ + + +
+ +
VIDEO_OPENGL_CGL = 1
+
+ + + +
+ +
VIDEO_OPENGL_EGL = 1
+
+ + + +
+ +
VIDEO_VULKAN = 1
+
+ + + +
+ +
VIDEO_METAL = 1
+
+ + + +
+ +
POWER_MACOSX = 1
+
+ + + +
+ +
FILESYSTEM_COCOA = 1
+
+ + + +
+ +
ASSEMBLY_ROUTINES = 1
+
+ + + +
+ +
PRIs64 = "lld"
+
+ + + +
+ +
ICONV_ERROR = -1
+
+ + + +
+ +
ICONV_E2BIG = -2
+
+ + + +
+ +
ICONV_EILSEQ = -3
+
+ + + +
+ +
ICONV_EINVAL = -4
+
+ + + +
+ +
ASSERT_LEVEL = 2
+
+ + + +
+ +
NULL_WHILE_LOOP_CONDITION = 0
+
+ + + +
+ +
ASSERTION_RETRY = 0'i32
+
+ +
< Retry the assert immediately.
+ + +
+ +
ASSERTION_BREAK = 1
+
+ +
< Make the debugger trigger a breakpoint.
+ + +
+ +
ASSERTION_ABORT = 2
+
+ +
< Terminate the program.
+ + +
+ +
ASSERTION_IGNORE = 3
+
+ +
< Ignore the assert.
+ + +
+ +
ASSERTION_ALWAYS_IGNORE = 4
+
+ +
< Ignore the assert from now on.
+ + +
+ +
ENOMEM = 0'i32
+
+ + + +
+ +
EFREAD = 1
+
+ + + +
+ +
EFWRITE = 2
+
+ + + +
+ +
EFSEEK = 3
+
+ + + +
+ +
UNSUPPORTED = 4
+
+ + + +
+ +
LASTERROR = 5
+
+ + + +
+ +
LIL_ENDIAN = 1234
+
+ + + +
+ +
BIG_ENDIAN = 4321
+
+ + + +
+ +
BYTEORDER = 1234
+
+ + + +
+ +
MUTEX_TIMEDOUT = 1
+
+ + + +
+ +
THREAD_PRIORITY_LOW = 0'i32
+
+ + + +
+ +
THREAD_PRIORITY_NORMAL = 1
+
+ + + +
+ +
THREAD_PRIORITY_HIGH = 2
+
+ + + +
+ +
THREAD_PRIORITY_TIME_CRITICAL = 3
+
+ + + +
+ +
RWOPS_UNKNOWN = 0'u
+
+ + + +
+ +
RWOPS_WINFILE = 1'u
+
+ + + +
+ +
RWOPS_STDFILE = 2'u
+
+ + + +
+ +
RWOPS_JNIFILE = 3'u
+
+ + + +
+ +
RWOPS_MEMORY = 4'u
+
+ + + +
+ +
RWOPS_MEMORY_RO = 5'u
+
+ + + +
+ +
RW_SEEK_SET = 0
+
+ + + +
+ +
RW_SEEK_CUR = 1
+
+ + + +
+ +
RW_SEEK_END = 2
+
+ + + +
+ +
AUDIO_MASK_BITSIZE = 0x000000FF
+
+ + + +
+ +
AUDIO_MASK_DATATYPE = 256
+
+ + + +
+ +
AUDIO_MASK_ENDIAN = 4096
+
+ + + +
+ +
AUDIO_MASK_SIGNED = 32768
+
+ + + +
+ +
AUDIO_U8 = 0x00000008
+
+ + + +
+ +
AUDIO_S8 = 0x00008008
+
+ + + +
+ +
AUDIO_U16LSB = 0x00000010
+
+ + + +
+ +
AUDIO_S16LSB = 0x00008010
+
+ + + +
+ +
AUDIO_U16MSB = 0x00001010
+
+ + + +
+ +
AUDIO_S16MSB = 0x00009010
+
+ + + +
+ +
AUDIO_U16 = 0x00000010
+
+ + + +
+ +
AUDIO_S16 = 0x00008010
+
+ + + +
+ +
AUDIO_S32LSB = 0x00008020
+
+ + + +
+ +
AUDIO_S32MSB = 0x00009020
+
+ + + +
+ +
AUDIO_S32 = 0x00008020
+
+ + + +
+ +
AUDIO_F32LSB = 0x00008120
+
+ + + +
+ +
AUDIO_F32MSB = 0x00009120
+
+ + + +
+ +
AUDIO_F32 = 0x00008120
+
+ + + +
+ +
AUDIO_U16SYS = 0x00000010
+
+ + + +
+ +
AUDIO_S16SYS = 0x00008010
+
+ + + +
+ +
AUDIO_S32SYS = 0x00008020
+
+ + + +
+ +
AUDIO_F32SYS = 0x00008120
+
+ + + +
+ +
AUDIO_ALLOW_FREQUENCY_CHANGE = 0x00000001
+
+ + + +
+ +
AUDIO_ALLOW_FORMAT_CHANGE = 0x00000002
+
+ + + +
+ +
AUDIO_ALLOW_CHANNELS_CHANGE = 0x00000004
+
+ + + +
+ +
AUDIO_ALLOW_SAMPLES_CHANGE = 0x00000008
+
+ + + +
+ +
AUDIO_ALLOW_ANY_CHANGE = 15
+
+ + + +
+ +
AUDIOCVT_MAX_FILTERS = 9
+
+ + + +
+ +
AUDIO_STOPPED = 0'i32
+
+ + + +
+ +
AUDIO_PLAYING = 1
+
+ + + +
+ +
AUDIO_PAUSED = 2
+
+ + + +
+ +
MIX_MAXVOLUME = 128
+
+ + + +
+ +
CACHELINE_SIZE = 128
+
+ + + +
+ +
ALPHA_OPAQUE = 255
+
+ + + +
+ +
ALPHA_TRANSPARENT = 0
+
+ + + +
+ +
PIXELTYPE_UNKNOWN = 0'i32
+
+ + + +
+ +
PIXELTYPE_INDEX1 = 1
+
+ + + +
+ +
PIXELTYPE_INDEX4 = 2
+
+ + + +
+ +
PIXELTYPE_INDEX8 = 3
+
+ + + +
+ +
PIXELTYPE_PACKED8 = 4
+
+ + + +
+ +
PIXELTYPE_PACKED16 = 5
+
+ + + +
+ +
PIXELTYPE_PACKED32 = 6
+
+ + + +
+ +
PIXELTYPE_ARRAYU8 = 7
+
+ + + +
+ +
PIXELTYPE_ARRAYU16 = 8
+
+ + + +
+ +
PIXELTYPE_ARRAYU32 = 9
+
+ + + +
+ +
PIXELTYPE_ARRAYF16 = 10
+
+ + + +
+ +
PIXELTYPE_ARRAYF32 = 11
+
+ + + +
+ +
BITMAPORDER_NONE = 0'i32
+
+ + + +
+ +
BITMAPORDER_4321 = 1
+
+ + + +
+ +
BITMAPORDER_1234 = 2
+
+ + + +
+ +
PACKEDORDER_NONE = 0'i32
+
+ + + +
+ +
PACKEDORDER_XRGB = 1
+
+ + + +
+ +
PACKEDORDER_RGBX = 2
+
+ + + +
+ +
PACKEDORDER_ARGB = 3
+
+ + + +
+ +
PACKEDORDER_RGBA = 4
+
+ + + +
+ +
PACKEDORDER_XBGR = 5
+
+ + + +
+ +
PACKEDORDER_BGRX = 6
+
+ + + +
+ +
PACKEDORDER_ABGR = 7
+
+ + + +
+ +
PACKEDORDER_BGRA = 8
+
+ + + +
+ +
ARRAYORDER_NONE = 0'i32
+
+ + + +
+ +
ARRAYORDER_RGB = 1
+
+ + + +
+ +
ARRAYORDER_RGBA = 2
+
+ + + +
+ +
ARRAYORDER_ARGB = 3
+
+ + + +
+ +
ARRAYORDER_BGR = 4
+
+ + + +
+ +
ARRAYORDER_BGRA = 5
+
+ + + +
+ +
ARRAYORDER_ABGR = 6
+
+ + + +
+ +
PACKEDLAYOUT_NONE = 0'i32
+
+ + + +
+ +
PACKEDLAYOUT_332 = 1
+
+ + + +
+ +
PACKEDLAYOUT_4444 = 2
+
+ + + +
+ +
PACKEDLAYOUT_1555 = 3
+
+ + + +
+ +
PACKEDLAYOUT_5551 = 4
+
+ + + +
+ +
PACKEDLAYOUT_565 = 5
+
+ + + +
+ +
PACKEDLAYOUT_8888 = 6
+
+ + + +
+ +
PACKEDLAYOUT_2101010 = 7
+
+ + + +
+ +
PACKEDLAYOUT_1010102 = 8
+
+ + + +
+ +
PIXELFORMAT_UNKNOWN = 0'i32
+
+ + + +
+ +
PIXELFORMAT_INDEX1LSB = 286261504'i32
+
+ + + +
+ +
PIXELFORMAT_INDEX1MSB = 287310080'i32
+
+ + + +
+ +
PIXELFORMAT_INDEX4LSB = 303039488'i32
+
+ + + +
+ +
PIXELFORMAT_INDEX4MSB = 304088064'i32
+
+ + + +
+ +
PIXELFORMAT_INDEX8 = 318769153'i32
+
+ + + +
+ +
PIXELFORMAT_RGB332 = 336660481'i32
+
+ + + +
+ +
PIXELFORMAT_RGB444 = 353504258'i32
+
+ + + +
+ +
PIXELFORMAT_BGR444 = 357698562'i32
+
+ + + +
+ +
PIXELFORMAT_RGB555 = 353570562'i32
+
+ + + +
+ +
PIXELFORMAT_BGR555 = 357764866'i32
+
+ + + +
+ +
PIXELFORMAT_ARGB4444 = 355602434'i32
+
+ + + +
+ +
PIXELFORMAT_RGBA4444 = 356651010'i32
+
+ + + +
+ +
PIXELFORMAT_ABGR4444 = 359796738'i32
+
+ + + +
+ +
PIXELFORMAT_BGRA4444 = 360845314'i32
+
+ + + +
+ +
PIXELFORMAT_ARGB1555 = 355667970'i32
+
+ + + +
+ +
PIXELFORMAT_RGBA5551 = 356782082'i32
+
+ + + +
+ +
PIXELFORMAT_ABGR1555 = 359862274'i32
+
+ + + +
+ +
PIXELFORMAT_BGRA5551 = 360976386'i32
+
+ + + +
+ +
PIXELFORMAT_RGB565 = 353701890'i32
+
+ + + +
+ +
PIXELFORMAT_BGR565 = 357896194'i32
+
+ + + +
+ +
PIXELFORMAT_RGB24 = 386930691'i32
+
+ + + +
+ +
PIXELFORMAT_BGR24 = 390076419'i32
+
+ + + +
+ +
PIXELFORMAT_RGB888 = 370546692'i32
+
+ + + +
+ +
PIXELFORMAT_RGBX8888 = 371595268'i32
+
+ + + +
+ +
PIXELFORMAT_BGR888 = 374740996'i32
+
+ + + +
+ +
PIXELFORMAT_BGRX8888 = 375789572'i32
+
+ + + +
+ +
PIXELFORMAT_ARGB8888 = 372645892'i32
+
+ + + +
+ +
PIXELFORMAT_RGBA8888 = 373694468'i32
+
+ + + +
+ +
PIXELFORMAT_ABGR8888 = 376840196'i32
+
+ + + +
+ +
PIXELFORMAT_BGRA8888 = 377888772'i32
+
+ + + +
+ +
PIXELFORMAT_ARGB2101010 = 372711428'i32
+
+ +
Aliases for RGBA byte arrays of color data, for the current platform
+ + +
+ +
PIXELFORMAT_RGBA32 = 376840196'i32
+
+ + + +
+ +
PIXELFORMAT_ARGB32 = 377888772'i32
+
+ + + +
+ +
PIXELFORMAT_BGRA32 = 372645892'i32
+
+ + + +
+ +
PIXELFORMAT_ABGR32 = 373694468'i32
+
+ + + +
+ +
PIXELFORMAT_YV12 = 373694469
+
+ + + +
+ +
PIXELFORMAT_IYUV = 373694470
+
+ + + +
+ +
PIXELFORMAT_YUY2 = 373694471
+
+ + + +
+ +
PIXELFORMAT_UYVY = 373694472
+
+ + + +
+ +
PIXELFORMAT_YVYU = 373694473
+
+ + + +
+ +
PIXELFORMAT_NV12 = 373694474
+
+ + + +
+ +
PIXELFORMAT_NV21 = 373694475
+
+ + + +
+ +
PIXELFORMAT_EXTERNAL_OES = 373694476
+
+ + + +
+ +
BLENDMODE_NONE = 0'i32
+
+ +
< no blending
+                                              dstRGBA = srcRGBA
+ + +
+ +
BLENDMODE_BLEND = 1'i32
+
+ +
< alpha blending
+                                              dstRGB = (srcRGB srcA) + (dstRGB (1-srcA))
+                                              dstA = srcA + (dstA (1-srcA))
+ + +
+ +
BLENDMODE_ADD = 2'i32
+
+ +
< additive blending
+                                              dstRGB = (srcRGB srcA) + dstRGB
+                                              dstA = dstA
+ + +
+ +
BLENDMODE_MOD = 4'i32
+
+ +
< color modulate
+                                              dstRGB = srcRGB dstRGB
+                                              dstA = dstA
+ + +
+ +
BLENDMODE_MUL = 8'i32
+
+ +
< color multiply
+                                              dstRGB = (srcRGB dstRGB) + (dstRGB (1-srcA))
+                                              dstA = (srcA dstA) + (dstA (1-srcA))
+ + +
+ +
BLENDMODE_INVALID = 2147483647'i32
+
+ +
Additional custom blend modes can be returned by SDL_ComposeCustomBlendMode()
+ + +
+ +
BLENDOPERATION_ADD = 1'i32
+
+ +
< dst + src: supported by all renderers
+ + +
+ +
BLENDOPERATION_SUBTRACT = 2'i32
+
+ +
< dst - src : supported by D3D9, D3D11, OpenGL, OpenGLES
+ + +
+ +
BLENDOPERATION_REV_SUBTRACT = 3'i32
+
+ +
< src - dst : supported by D3D9, D3D11, OpenGL, OpenGLES
+ + +
+ +
BLENDOPERATION_MINIMUM = 4'i32
+
+ +
< min(dst, src) : supported by D3D11
+ + +
+ +
BLENDOPERATION_MAXIMUM = 5'i32
+
+ +
< max(dst, src) : supported by D3D11
+ + +
+ +
BLENDFACTOR_ZERO = 1'i32
+
+ +
< 0, 0, 0, 0
+ + +
+ +
BLENDFACTOR_ONE = 2'i32
+
+ +
< 1, 1, 1, 1
+ + +
+ +
BLENDFACTOR_SRC_COLOR = 3'i32
+
+ +
< srcR, srcG, srcB, srcA
+ + +
+ +
BLENDFACTOR_ONE_MINUS_SRC_COLOR = 4'i32
+
+ +
< 1-srcR, 1-srcG, 1-srcB, 1-srcA
+ + +
+ +
BLENDFACTOR_SRC_ALPHA = 5'i32
+
+ +
< srcA, srcA, srcA, srcA
+ + +
+ +
BLENDFACTOR_ONE_MINUS_SRC_ALPHA = 6'i32
+
+ +
< 1-srcA, 1-srcA, 1-srcA, 1-srcA
+ + +
+ +
BLENDFACTOR_DST_COLOR = 7'i32
+
+ +
< dstR, dstG, dstB, dstA
+ + +
+ +
BLENDFACTOR_ONE_MINUS_DST_COLOR = 8'i32
+
+ +
< 1-dstR, 1-dstG, 1-dstB, 1-dstA
+ + +
+ +
BLENDFACTOR_DST_ALPHA = 9'i32
+
+ +
< dstA, dstA, dstA, dstA
+ + +
+ +
BLENDFACTOR_ONE_MINUS_DST_ALPHA = 10'i32
+
+ +
< 1-dstA, 1-dstA, 1-dstA, 1-dstA
+ + +
+ +
SWSURFACE = 0
+
+ + + +
+ +
PREALLOC = 0x00000001
+
+ + + +
+ +
RLEACCEL = 0x00000002
+
+ + + +
+ +
DONTFREE = 0x00000004
+
+ + + +
+ +
SIMD_ALIGNED = 0x00000008
+
+ + + +
+ +
YUV_CONVERSION_JPEG = 0'i32
+
+ +
< Full range JPEG
+ + +
+ +
YUV_CONVERSION_BT601 = 1
+
+ +
< BT.601 (the default)
+ + +
+ +
YUV_CONVERSION_BT709 = 2
+
+ +
< BT.709
+ + +
+ +
YUV_CONVERSION_AUTOMATIC = 3
+
+ +
< BT.601 for SD content, BT.709 for HD content
+ + +
+ +
WINDOW_FULLSCREEN = 1'i32
+
+ +
< fullscreen window
+ + +
+ +
WINDOW_OPENGL = 2'i32
+
+ +
< window usable with OpenGL context
+ + +
+ +
WINDOW_SHOWN = 4'i32
+
+ +
< window is visible
+ + +
+ +
WINDOW_HIDDEN = 8'i32
+
+ +
< window is not visible
+ + +
+ +
WINDOW_BORDERLESS = 16'i32
+
+ +
< no window decoration
+ + +
+ +
WINDOW_RESIZABLE = 32'i32
+
+ +
< window can be resized
+ + +
+ +
WINDOW_MINIMIZED = 64'i32
+
+ +
< window is minimized
+ + +
+ +
WINDOW_MAXIMIZED = 128'i32
+
+ +
< window is maximized
+ + +
+ +
WINDOW_INPUT_GRABBED = 256'i32
+
+ +
< window has grabbed input focus
+ + +
+ +
WINDOW_INPUT_FOCUS = 512'i32
+
+ +
< window has input focus
+ + +
+ +
WINDOW_MOUSE_FOCUS = 1024'i32
+
+ +
< window has mouse focus
+ + +
+ +
WINDOW_FULLSCREEN_DESKTOP = 4097'i32
+
+ + + +
+ +
WINDOW_FOREIGN = 2048'i32
+
+ +
< window not created by SDL
+ + +
+ +
WINDOW_ALLOW_HIGHDPI = 8192'i32
+
+ +
< window should be created in high-DPI mode if supported.
+                                                     On macOS NSHighResolutionCapable must be set true in the
+                                                     application's Info.plist for this to have any effect.
+ + +
+ +
WINDOW_MOUSE_CAPTURE = 16384'i32
+
+ +
< window has mouse captured (unrelated to INPUT_GRABBED)
+ + +
+ +
WINDOW_ALWAYS_ON_TOP = 32768'i32
+
+ +
< window should always be above others
+ + +
+ +
WINDOW_SKIP_TASKBAR = 65536'i32
+
+ +
< window should not be added to the taskbar
+ + +
+ +
WINDOW_UTILITY = 131072'i32
+
+ +
< window should be treated as a utility window
+ + +
+ +
WINDOW_TOOLTIP = 262144'i32
+
+ +
< window should be treated as a tooltip
+ + +
+ +
WINDOW_POPUP_MENU = 524288'i32
+
+ +
< window should be treated as a popup menu
+ + +
+ +
WINDOW_VULKAN = 268435456'i32
+
+ +
< window usable for Vulkan surface
+ + +
+ +
WINDOWEVENT_NONE = 0'i32
+
+ +
< Never used
+ + +
+ +
WINDOWEVENT_SHOWN = 1
+
+ +
< Window has been shown
+ + +
+ +
WINDOWEVENT_HIDDEN = 2
+
+ +
< Window has been hidden
+ + +
+ +
WINDOWEVENT_EXPOSED = 3
+
+ +
< Window has been exposed and should be
+                                         redrawn
+ + +
+ +
WINDOWEVENT_MOVED = 4
+
+ +
< Window has been moved to data1, data2
+ + +
+ +
WINDOWEVENT_RESIZED = 5
+
+ +
< Window has been resized to data1xdata2
+ + +
+ +
WINDOWEVENT_SIZE_CHANGED = 6
+
+ +
< The window size has changed, either as
+                                         a result of an API call or through the
+                                         system or user changing the window size.
+ + +
+ +
WINDOWEVENT_MINIMIZED = 7
+
+ +
< Window has been minimized
+ + +
+ +
WINDOWEVENT_MAXIMIZED = 8
+
+ +
< Window has been maximized
+ + +
+ +
WINDOWEVENT_RESTORED = 9
+
+ +
< Window has been restored to normal size
+                                         and position
+ + +
+ +
WINDOWEVENT_ENTER = 10
+
+ +
< Window has gained mouse focus
+ + +
+ +
WINDOWEVENT_LEAVE = 11
+
+ +
< Window has lost mouse focus
+ + +
+ +
WINDOWEVENT_FOCUS_GAINED = 12
+
+ +
< Window has gained keyboard focus
+ + +
+ +
WINDOWEVENT_FOCUS_LOST = 13
+
+ +
< Window has lost keyboard focus
+ + +
+ +
WINDOWEVENT_CLOSE = 14
+
+ +
< The window manager requests that the window be closed
+ + +
+ +
WINDOWEVENT_TAKE_FOCUS = 15
+
+ +
< Window is being offered a focus (should SetWindowInputFocus() on itself or a subwindow, or ignore)
+ + +
+ +
WINDOWEVENT_HIT_TEST = 16
+
+ +
< Window had a hit test that wasn't SDL_HITTEST_NORMAL.
+ + +
+ +
DISPLAYEVENT_NONE = 0'i32
+
+ +
< Never used
+ + +
+ +
DISPLAYEVENT_ORIENTATION = 1
+
+ +
< Display orientation has changed to data1
+ + +
+ +
ORIENTATION_UNKNOWN = 0'i32
+
+ +
< The display orientation can't be determined
+ + +
+ +
ORIENTATION_LANDSCAPE = 1
+
+ +
< The display is in landscape mode, with the right side up, relative to portrait mode
+ + +
+ +
ORIENTATION_LANDSCAPE_FLIPPED = 2
+
+ +
< The display is in landscape mode, with the left side up, relative to portrait mode
+ + +
+ +
ORIENTATION_PORTRAIT = 3
+
+ +
< The display is in portrait mode
+ + +
+ +
ORIENTATION_PORTRAIT_FLIPPED = 4
+
+ +
< The display is in portrait mode, upside down
+ + +
+ +
GL_RED_SIZE = 0'i32
+
+ + + +
+ +
GL_GREEN_SIZE = 1
+
+ + + +
+ +
GL_BLUE_SIZE = 2
+
+ + + +
+ +
GL_ALPHA_SIZE = 3
+
+ + + +
+ +
GL_BUFFER_SIZE = 4
+
+ + + +
+ +
GL_DOUBLEBUFFER = 5
+
+ + + +
+ +
GL_DEPTH_SIZE = 6
+
+ + + +
+ +
GL_STENCIL_SIZE = 7
+
+ + + +
+ +
GL_ACCUM_RED_SIZE = 8
+
+ + + +
+ +
GL_ACCUM_GREEN_SIZE = 9
+
+ + + +
+ +
GL_ACCUM_BLUE_SIZE = 10
+
+ + + +
+ +
GL_ACCUM_ALPHA_SIZE = 11
+
+ + + +
+ +
GL_STEREO = 12
+
+ + + +
+ +
GL_MULTISAMPLEBUFFERS = 13
+
+ + + +
+ +
GL_MULTISAMPLESAMPLES = 14
+
+ + + +
+ +
GL_ACCELERATED_VISUAL = 15
+
+ + + +
+ +
GL_RETAINED_BACKING = 16
+
+ + + +
+ +
GL_CONTEXT_MAJOR_VERSION = 17
+
+ + + +
+ +
GL_CONTEXT_MINOR_VERSION = 18
+
+ + + +
+ +
GL_CONTEXT_EGL = 19
+
+ + + +
+ +
GL_CONTEXT_FLAGS = 20
+
+ + + +
+ +
GL_CONTEXT_PROFILE_MASK = 21
+
+ + + +
+ +
GL_SHARE_WITH_CURRENT_CONTEXT = 22
+
+ + + +
+ +
GL_FRAMEBUFFER_SRGB_CAPABLE = 23
+
+ + + +
+ +
GL_CONTEXT_RELEASE_BEHAVIOR = 24
+
+ + + +
+ +
GL_CONTEXT_RESET_NOTIFICATION = 25
+
+ + + +
+ +
GL_CONTEXT_NO_ERROR = 26
+
+ + + +
+ +
GL_CONTEXT_PROFILE_CORE = 1'i32
+
+ + + +
+ +
GL_CONTEXT_PROFILE_COMPATIBILITY = 2'i32
+
+ + + +
+ +
GL_CONTEXT_PROFILE_ES = 4'i32
+
+ +
< GLX_CONTEXT_ES2_PROFILE_BIT_EXT
+ + +
+ +
GL_CONTEXT_DEBUG_FLAG = 1'i32
+
+ + + +
+ +
GL_CONTEXT_FORWARD_COMPATIBLE_FLAG = 2'i32
+
+ + + +
+ +
GL_CONTEXT_ROBUST_ACCESS_FLAG = 4'i32
+
+ + + +
+ +
GL_CONTEXT_RESET_ISOLATION_FLAG = 8'i32
+
+ + + +
+ +
GL_CONTEXT_RELEASE_BEHAVIOR_NONE = 0'i32
+
+ + + +
+ +
GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH = 1'i32
+
+ + + +
+ +
GL_CONTEXT_RESET_NO_NOTIFICATION = 0'i32
+
+ + + +
+ +
GL_CONTEXT_RESET_LOSE_CONTEXT = 1'i32
+
+ + + +
+ +
HITTEST_NORMAL = 0'i32
+
+ +
< Region is normal. No special properties.
+ + +
+ +
HITTEST_DRAGGABLE = 1
+
+ +
< Region can drag entire window.
+ + +
+ +
HITTEST_RESIZE_TOPLEFT = 2
+
+ + + +
+ +
HITTEST_RESIZE_TOP = 3
+
+ + + +
+ +
HITTEST_RESIZE_TOPRIGHT = 4
+
+ + + +
+ +
HITTEST_RESIZE_RIGHT = 5
+
+ + + +
+ +
HITTEST_RESIZE_BOTTOMRIGHT = 6
+
+ + + +
+ +
HITTEST_RESIZE_BOTTOM = 7
+
+ + + +
+ +
HITTEST_RESIZE_BOTTOMLEFT = 8
+
+ + + +
+ +
HITTEST_RESIZE_LEFT = 9
+
+ + + +
+ +
SCANCODE_UNKNOWN = 0'i32
+
+ +
\name Usage page 0x07
+  
+  These values are from usage page 0x07 (USB keyboard page).
+ + +
+ +
SCANCODE_A = 4'i32
+
+ + + +
+ +
SCANCODE_B = 5'i32
+
+ + + +
+ +
SCANCODE_C = 6'i32
+
+ + + +
+ +
SCANCODE_D = 7'i32
+
+ + + +
+ +
SCANCODE_E = 8'i32
+
+ + + +
+ +
SCANCODE_F = 9'i32
+
+ + + +
+ +
SCANCODE_G = 10'i32
+
+ + + +
+ +
SCANCODE_H = 11'i32
+
+ + + +
+ +
SCANCODE_I = 12'i32
+
+ + + +
+ +
SCANCODE_J = 13'i32
+
+ + + +
+ +
SCANCODE_K = 14'i32
+
+ + + +
+ +
SCANCODE_L = 15'i32
+
+ + + +
+ +
SCANCODE_M = 16'i32
+
+ + + +
+ +
SCANCODE_N = 17'i32
+
+ + + +
+ +
SCANCODE_O = 18'i32
+
+ + + +
+ +
SCANCODE_P = 19'i32
+
+ + + +
+ +
SCANCODE_Q = 20'i32
+
+ + + +
+ +
SCANCODE_R = 21'i32
+
+ + + +
+ +
SCANCODE_S = 22'i32
+
+ + + +
+ +
SCANCODE_T = 23'i32
+
+ + + +
+ +
SCANCODE_U = 24'i32
+
+ + + +
+ +
SCANCODE_V = 25'i32
+
+ + + +
+ +
SCANCODE_W = 26'i32
+
+ + + +
+ +
SCANCODE_X = 27'i32
+
+ + + +
+ +
SCANCODE_Y = 28'i32
+
+ + + +
+ +
SCANCODE_Z = 29'i32
+
+ + + +
+ +
SCANCODE_1 = 30'i32
+
+ + + +
+ +
SCANCODE_2 = 31'i32
+
+ + + +
+ +
SCANCODE_3 = 32'i32
+
+ + + +
+ +
SCANCODE_4 = 33'i32
+
+ + + +
+ +
SCANCODE_5 = 34'i32
+
+ + + +
+ +
SCANCODE_6 = 35'i32
+
+ + + +
+ +
SCANCODE_7 = 36'i32
+
+ + + +
+ +
SCANCODE_8 = 37'i32
+
+ + + +
+ +
SCANCODE_9 = 38'i32
+
+ + + +
+ +
SCANCODE_0 = 39'i32
+
+ + + +
+ +
SCANCODE_RETURN = 40'i32
+
+ + + +
+ +
SCANCODE_ESCAPE = 41'i32
+
+ + + +
+ +
SCANCODE_BACKSPACE = 42'i32
+
+ + + +
+ +
SCANCODE_TAB = 43'i32
+
+ + + +
+ +
SCANCODE_SPACE = 44'i32
+
+ + + +
+ +
SCANCODE_MINUS = 45'i32
+
+ + + +
+ +
SCANCODE_EQUALS = 46'i32
+
+ + + +
+ +
SCANCODE_LEFTBRACKET = 47'i32
+
+ + + +
+ +
SCANCODE_RIGHTBRACKET = 48'i32
+
+ + + +
+ +
SCANCODE_BACKSLASH = 49'i32
+
+ +
< Located at the lower left of the return
+   key on ISO keyboards and at the right end
+   of the QWERTY row on ANSI keyboards.
+   Produces REVERSE SOLIDUS (backslash) and
+   VERTICAL LINE in a US layout, REVERSE
+   SOLIDUS and VERTICAL LINE in a UK Mac
+   layout, NUMBER SIGN and TILDE in a UK
+   Windows layout, DOLLAR SIGN and POUND SIGN
+   in a Swiss German layout, NUMBER SIGN and
+   APOSTROPHE in a German layout, GRAVE
+   ACCENT and POUND SIGN in a French Mac
+   layout, and ASTERISK and MICRO SIGN in a
+   French Windows layout.
+ + +
+ +
SCANCODE_NONUSHASH = 50'i32
+
+ +
< ISO USB keyboards actually use this code
+   instead of 49 for the same key, but all
+   OSes I've seen treat the two codes
+   identically. So, as an implementor, unless
+   your keyboard generates both of those
+   codes and your OS treats them differently,
+   you should generate SDL_SCANCODE_BACKSLASH
+   instead of this code. As a user, you
+   should not rely on this code because SDL
+   will never generate it with most (all?)
+   keyboards.
+ + +
+ +
SCANCODE_SEMICOLON = 51'i32
+
+ + + +
+ +
SCANCODE_APOSTROPHE = 52'i32
+
+ + + +
+ +
SCANCODE_GRAVE = 53'i32
+
+ +
< Located in the top left corner (on both ANSI
+   and ISO keyboards). Produces GRAVE ACCENT and
+   TILDE in a US Windows layout and in US and UK
+   Mac layouts on ANSI keyboards, GRAVE ACCENT
+   and NOT SIGN in a UK Windows layout, SECTION
+   SIGN and PLUS-MINUS SIGN in US and UK Mac
+   layouts on ISO keyboards, SECTION SIGN and
+   DEGREE SIGN in a Swiss German layout (Mac:
+   only on ISO keyboards), CIRCUMFLEX ACCENT and
+   DEGREE SIGN in a German layout (Mac: only on
+   ISO keyboards), SUPERSCRIPT TWO and TILDE in a
+   French Windows layout, COMMERCIAL AT and
+   NUMBER SIGN in a French Mac layout on ISO
+   keyboards, and LESS-THAN SIGN and GREATER-THAN
+   SIGN in a Swiss German, German, or French Mac
+   layout on ANSI keyboards.
+ + +
+ +
SCANCODE_COMMA = 54'i32
+
+ + + +
+ +
SCANCODE_PERIOD = 55'i32
+
+ + + +
+ +
SCANCODE_SLASH = 56'i32
+
+ + + +
+ +
SCANCODE_CAPSLOCK = 57'i32
+
+ + + +
+ +
SCANCODE_F1 = 58'i32
+
+ + + +
+ +
SCANCODE_F2 = 59'i32
+
+ + + +
+ +
SCANCODE_F3 = 60'i32
+
+ + + +
+ +
SCANCODE_F4 = 61'i32
+
+ + + +
+ +
SCANCODE_F5 = 62'i32
+
+ + + +
+ +
SCANCODE_F6 = 63'i32
+
+ + + +
+ +
SCANCODE_F7 = 64'i32
+
+ + + +
+ +
SCANCODE_F8 = 65'i32
+
+ + + +
+ +
SCANCODE_F9 = 66'i32
+
+ + + +
+ +
SCANCODE_F10 = 67'i32
+
+ + + +
+ +
SCANCODE_F11 = 68'i32
+
+ + + +
+ +
SCANCODE_F12 = 69'i32
+
+ + + +
+ +
SCANCODE_PRINTSCREEN = 70'i32
+
+ + + +
+ +
SCANCODE_SCROLLLOCK = 71'i32
+
+ + + +
+ +
SCANCODE_PAUSE = 72'i32
+
+ + + +
+ +
SCANCODE_INSERT = 73'i32
+
+ +
< insert on PC, help on some Mac keyboards (but
+                                   does send code 73, not 117)
+ + +
+ +
SCANCODE_HOME = 74'i32
+
+ + + +
+ +
SCANCODE_PAGEUP = 75'i32
+
+ + + +
+ +
SCANCODE_DELETE = 76'i32
+
+ + + +
+ +
SCANCODE_END = 77'i32
+
+ + + +
+ +
SCANCODE_PAGEDOWN = 78'i32
+
+ + + +
+ +
SCANCODE_RIGHT = 79'i32
+
+ + + +
+ +
SCANCODE_LEFT = 80'i32
+
+ + + +
+ +
SCANCODE_DOWN = 81'i32
+
+ + + +
+ +
SCANCODE_UP = 82'i32
+
+ + + +
+ +
SCANCODE_NUMLOCKCLEAR = 83'i32
+
+ +
< num lock on PC, clear on Mac keyboards
+ + +
+ +
SCANCODE_KP_DIVIDE = 84'i32
+
+ + + +
+ +
SCANCODE_KP_MULTIPLY = 85'i32
+
+ + + +
+ +
SCANCODE_KP_MINUS = 86'i32
+
+ + + +
+ +
SCANCODE_KP_PLUS = 87'i32
+
+ + + +
+ +
SCANCODE_KP_ENTER = 88'i32
+
+ + + +
+ +
SCANCODE_KP_1 = 89'i32
+
+ + + +
+ +
SCANCODE_KP_2 = 90'i32
+
+ + + +
+ +
SCANCODE_KP_3 = 91'i32
+
+ + + +
+ +
SCANCODE_KP_4 = 92'i32
+
+ + + +
+ +
SCANCODE_KP_5 = 93'i32
+
+ + + +
+ +
SCANCODE_KP_6 = 94'i32
+
+ + + +
+ +
SCANCODE_KP_7 = 95'i32
+
+ + + +
+ +
SCANCODE_KP_8 = 96'i32
+
+ + + +
+ +
SCANCODE_KP_9 = 97'i32
+
+ + + +
+ +
SCANCODE_KP_0 = 98'i32
+
+ + + +
+ +
SCANCODE_KP_PERIOD = 99'i32
+
+ + + +
+ +
SCANCODE_NONUSBACKSLASH = 100'i32
+
+ +
< This is the additional key that ISO
+   keyboards have over ANSI ones,
+   located between left shift and Y.
+   Produces GRAVE ACCENT and TILDE in a
+   US or UK Mac layout, REVERSE SOLIDUS
+   (backslash) and VERTICAL LINE in a
+   US or UK Windows layout, and
+   LESS-THAN SIGN and GREATER-THAN SIGN
+   in a Swiss German, German, or French
+   layout.
+ + +
+ +
SCANCODE_APPLICATION = 101'i32
+
+ +
< windows contextual menu, compose
+ + +
+ +
SCANCODE_POWER = 102'i32
+
+ +
< The USB document says this is a status flag,
+   not a physical key - but some Mac keyboards
+   do have a power key.
+ + +
+ +
SCANCODE_KP_EQUALS = 103'i32
+
+ + + +
+ +
SCANCODE_F13 = 104'i32
+
+ + + +
+ +
SCANCODE_F14 = 105'i32
+
+ + + +
+ +
SCANCODE_F15 = 106'i32
+
+ + + +
+ +
SCANCODE_F16 = 107'i32
+
+ + + +
+ +
SCANCODE_F17 = 108'i32
+
+ + + +
+ +
SCANCODE_F18 = 109'i32
+
+ + + +
+ +
SCANCODE_F19 = 110'i32
+
+ + + +
+ +
SCANCODE_F20 = 111'i32
+
+ + + +
+ +
SCANCODE_F21 = 112'i32
+
+ + + +
+ +
SCANCODE_F22 = 113'i32
+
+ + + +
+ +
SCANCODE_F23 = 114'i32
+
+ + + +
+ +
SCANCODE_F24 = 115'i32
+
+ + + +
+ +
SCANCODE_EXECUTE = 116'i32
+
+ + + +
+ +
SCANCODE_HELP = 117'i32
+
+ + + +
+ +
SCANCODE_MENU = 118'i32
+
+ + + +
+ +
SCANCODE_SELECT = 119'i32
+
+ + + +
+ +
SCANCODE_STOP = 120'i32
+
+ + + +
+ +
SCANCODE_AGAIN = 121'i32
+
+ +
< redo
+ + +
+ +
SCANCODE_UNDO = 122'i32
+
+ + + +
+ +
SCANCODE_CUT = 123'i32
+
+ + + +
+ +
SCANCODE_COPY = 124'i32
+
+ + + +
+ +
SCANCODE_PASTE = 125'i32
+
+ + + +
+ +
SCANCODE_FIND = 126'i32
+
+ + + +
+ +
SCANCODE_MUTE = 127'i32
+
+ + + +
+ +
SCANCODE_VOLUMEUP = 128'i32
+
+ + + +
+ +
SCANCODE_VOLUMEDOWN = 129'i32
+
+ +
not sure whether there's a reason to enable these
+ + +
+ +
SCANCODE_KP_COMMA = 133'i32
+
+ + + +
+ +
SCANCODE_KP_EQUALSAS400 = 134'i32
+
+ + + +
+ +
SCANCODE_INTERNATIONAL1 = 135'i32
+
+ +
< used on Asian keyboards, see
+                                            footnotes in USB doc
+ + +
+ +
SCANCODE_INTERNATIONAL2 = 136'i32
+
+ + + +
+ +
SCANCODE_INTERNATIONAL3 = 137'i32
+
+ +
< Yen
+ + +
+ +
SCANCODE_INTERNATIONAL4 = 138'i32
+
+ + + +
+ +
SCANCODE_INTERNATIONAL5 = 139'i32
+
+ + + +
+ +
SCANCODE_INTERNATIONAL6 = 140'i32
+
+ + + +
+ +
SCANCODE_INTERNATIONAL7 = 141'i32
+
+ + + +
+ +
SCANCODE_INTERNATIONAL8 = 142'i32
+
+ + + +
+ +
SCANCODE_INTERNATIONAL9 = 143'i32
+
+ + + +
+ +
SCANCODE_LANG1 = 144'i32
+
+ +
< Hangul/English toggle
+ + +
+ +
SCANCODE_LANG2 = 145'i32
+
+ +
< Hanja conversion
+ + +
+ +
SCANCODE_LANG3 = 146'i32
+
+ +
< Katakana
+ + +
+ +
SCANCODE_LANG4 = 147'i32
+
+ +
< Hiragana
+ + +
+ +
SCANCODE_LANG5 = 148'i32
+
+ +
< Zenkaku/Hankaku
+ + +
+ +
SCANCODE_LANG6 = 149'i32
+
+ +
< reserved
+ + +
+ +
SCANCODE_LANG7 = 150'i32
+
+ +
< reserved
+ + +
+ +
SCANCODE_LANG8 = 151'i32
+
+ +
< reserved
+ + +
+ +
SCANCODE_LANG9 = 152'i32
+
+ +
< reserved
+ + +
+ +
SCANCODE_ALTERASE = 153'i32
+
+ +
< Erase-Eaze
+ + +
+ +
SCANCODE_SYSREQ = 154'i32
+
+ + + +
+ +
SCANCODE_CANCEL = 155'i32
+
+ + + +
+ +
SCANCODE_CLEAR = 156'i32
+
+ + + +
+ +
SCANCODE_PRIOR = 157'i32
+
+ + + +
+ +
SCANCODE_RETURN2 = 158'i32
+
+ + + +
+ +
SCANCODE_SEPARATOR = 159'i32
+
+ + + +
+ +
SCANCODE_OUT = 160'i32
+
+ + + +
+ +
SCANCODE_OPER = 161'i32
+
+ + + +
+ +
SCANCODE_CLEARAGAIN = 162'i32
+
+ + + +
+ +
SCANCODE_CRSEL = 163'i32
+
+ + + +
+ +
SCANCODE_EXSEL = 164'i32
+
+ + + +
+ +
SCANCODE_KP_00 = 176'i32
+
+ + + +
+ +
SCANCODE_KP_000 = 177'i32
+
+ + + +
+ +
SCANCODE_THOUSANDSSEPARATOR = 178'i32
+
+ + + +
+ +
SCANCODE_DECIMALSEPARATOR = 179'i32
+
+ + + +
+ +
SCANCODE_CURRENCYUNIT = 180'i32
+
+ + + +
+ +
SCANCODE_CURRENCYSUBUNIT = 181'i32
+
+ + + +
+ +
SCANCODE_KP_LEFTPAREN = 182'i32
+
+ + + +
+ +
SCANCODE_KP_RIGHTPAREN = 183'i32
+
+ + + +
+ +
SCANCODE_KP_LEFTBRACE = 184'i32
+
+ + + +
+ +
SCANCODE_KP_RIGHTBRACE = 185'i32
+
+ + + +
+ +
SCANCODE_KP_TAB = 186'i32
+
+ + + +
+ +
SCANCODE_KP_BACKSPACE = 187'i32
+
+ + + +
+ +
SCANCODE_KP_A = 188'i32
+
+ + + +
+ +
SCANCODE_KP_B = 189'i32
+
+ + + +
+ +
SCANCODE_KP_C = 190'i32
+
+ + + +
+ +
SCANCODE_KP_D = 191'i32
+
+ + + +
+ +
SCANCODE_KP_E = 192'i32
+
+ + + +
+ +
SCANCODE_KP_F = 193'i32
+
+ + + +
+ +
SCANCODE_KP_XOR = 194'i32
+
+ + + +
+ +
SCANCODE_KP_POWER = 195'i32
+
+ + + +
+ +
SCANCODE_KP_PERCENT = 196'i32
+
+ + + +
+ +
SCANCODE_KP_LESS = 197'i32
+
+ + + +
+ +
SCANCODE_KP_GREATER = 198'i32
+
+ + + +
+ +
SCANCODE_KP_AMPERSAND = 199'i32
+
+ + + +
+ +
SCANCODE_KP_DBLAMPERSAND = 200'i32
+
+ + + +
+ +
SCANCODE_KP_VERTICALBAR = 201'i32
+
+ + + +
+ +
SCANCODE_KP_DBLVERTICALBAR = 202'i32
+
+ + + +
+ +
SCANCODE_KP_COLON = 203'i32
+
+ + + +
+ +
SCANCODE_KP_HASH = 204'i32
+
+ + + +
+ +
SCANCODE_KP_SPACE = 205'i32
+
+ + + +
+ +
SCANCODE_KP_AT = 206'i32
+
+ + + +
+ +
SCANCODE_KP_EXCLAM = 207'i32
+
+ + + +
+ +
SCANCODE_KP_MEMSTORE = 208'i32
+
+ + + +
+ +
SCANCODE_KP_MEMRECALL = 209'i32
+
+ + + +
+ +
SCANCODE_KP_MEMCLEAR = 210'i32
+
+ + + +
+ +
SCANCODE_KP_MEMADD = 211'i32
+
+ + + +
+ +
SCANCODE_KP_MEMSUBTRACT = 212'i32
+
+ + + +
+ +
SCANCODE_KP_MEMMULTIPLY = 213'i32
+
+ + + +
+ +
SCANCODE_KP_MEMDIVIDE = 214'i32
+
+ + + +
+ +
SCANCODE_KP_PLUSMINUS = 215'i32
+
+ + + +
+ +
SCANCODE_KP_CLEAR = 216'i32
+
+ + + +
+ +
SCANCODE_KP_CLEARENTRY = 217'i32
+
+ + + +
+ +
SCANCODE_KP_BINARY = 218'i32
+
+ + + +
+ +
SCANCODE_KP_OCTAL = 219'i32
+
+ + + +
+ +
SCANCODE_KP_DECIMAL = 220'i32
+
+ + + +
+ +
SCANCODE_KP_HEXADECIMAL = 221'i32
+
+ + + +
+ +
SCANCODE_LCTRL = 224'i32
+
+ + + +
+ +
SCANCODE_LSHIFT = 225'i32
+
+ + + +
+ +
SCANCODE_LALT = 226'i32
+
+ +
< alt, option
+ + +
+ +
SCANCODE_LGUI = 227'i32
+
+ +
< windows, command (apple), meta
+ + +
+ +
SCANCODE_RCTRL = 228'i32
+
+ + + +
+ +
SCANCODE_RSHIFT = 229'i32
+
+ + + +
+ +
SCANCODE_RALT = 230'i32
+
+ +
< alt gr, option
+ + +
+ +
SCANCODE_RGUI = 231'i32
+
+ +
< windows, command (apple), meta
+ + +
+ +
SCANCODE_MODE = 257'i32
+
+ +
< I'm not sure if this is really not covered
+   by any of the above, but since there's a
+   special KMOD_MODE for it I'm adding it here
+ + +
+ +
SCANCODE_AUDIONEXT = 258'i32
+
+ + + +
+ +
SCANCODE_AUDIOPREV = 259'i32
+
+ + + +
+ +
SCANCODE_AUDIOSTOP = 260'i32
+
+ + + +
+ +
SCANCODE_AUDIOPLAY = 261'i32
+
+ + + +
+ +
SCANCODE_AUDIOMUTE = 262'i32
+
+ + + +
+ +
SCANCODE_MEDIASELECT = 263'i32
+
+ + + +
+ +
SCANCODE_WWW = 264'i32
+
+ + + +
+ +
SCANCODE_MAIL = 265'i32
+
+ + + +
+ +
SCANCODE_CALCULATOR = 266'i32
+
+ + + +
+ +
SCANCODE_COMPUTER = 267'i32
+
+ + + +
+ +
SCANCODE_AC_SEARCH = 268'i32
+
+ + + +
+ +
SCANCODE_AC_HOME = 269'i32
+
+ + + +
+ +
SCANCODE_AC_BACK = 270'i32
+
+ + + +
+ +
SCANCODE_AC_FORWARD = 271'i32
+
+ + + +
+ +
SCANCODE_AC_STOP = 272'i32
+
+ + + +
+ +
SCANCODE_AC_REFRESH = 273'i32
+
+ + + +
+ +
SCANCODE_AC_BOOKMARKS = 274'i32
+
+ +
@}
+ + +
+ +
SCANCODE_BRIGHTNESSDOWN = 275'i32
+
+ + + +
+ +
SCANCODE_BRIGHTNESSUP = 276'i32
+
+ + + +
+ +
SCANCODE_DISPLAYSWITCH = 277'i32
+
+ +
< display mirroring/dual display
+                                           switch, video mode switch
+ + +
+ +
SCANCODE_KBDILLUMTOGGLE = 278'i32
+
+ + + +
+ +
SCANCODE_KBDILLUMDOWN = 279'i32
+
+ + + +
+ +
SCANCODE_KBDILLUMUP = 280'i32
+
+ + + +
+ +
SCANCODE_EJECT = 281'i32
+
+ + + +
+ +
SCANCODE_SLEEP = 282'i32
+
+ + + +
+ +
SCANCODE_APP1 = 283'i32
+
+ + + +
+ +
SCANCODE_APP2 = 284'i32
+
+ +
@}
+ + +
+ +
SCANCODE_AUDIOREWIND = 285'i32
+
+ + + +
+ +
SCANCODE_AUDIOFASTFORWARD = 286'i32
+
+ +
@}
+ + +
+ +
NUM_SCANCODES = 512'i32
+
+ +
< not a key, just marks the number of scancodes
+                                 for array bounds
+ + +
+ +
KEYCODE_SCANCODE_MASK = 1073741824
+
+ + + +
+ +
KEYCODE_UNKNOWN = 0'i32
+
+ + + +
+ +
KEYCODE_RETURN = 13'i32
+
+ + + +
+ +
KEYCODE_ESCAPE = 27'i32
+
+ + + +
+ +
KEYCODE_BACKSPACE = 8'i32
+
+ + + +
+ +
KEYCODE_TAB = 9'i32
+
+ + + +
+ +
KEYCODE_SPACE = 32'i32
+
+ + + +
+ +
KEYCODE_EXCLAIM = 33'i32
+
+ + + +
+ +
KEYCODE_QUOTEDBL = 34'i32
+
+ + + +
+ +
KEYCODE_HASH = 35'i32
+
+ + + +
+ +
KEYCODE_PERCENT = 37'i32
+
+ + + +
+ +
KEYCODE_DOLLAR = 36'i32
+
+ + + +
+ +
KEYCODE_AMPERSAND = 38'i32
+
+ + + +
+ +
KEYCODE_QUOTE = 39'i32
+
+ + + +
+ +
KEYCODE_LEFTPAREN = 40'i32
+
+ + + +
+ +
KEYCODE_RIGHTPAREN = 41'i32
+
+ + + +
+ +
KEYCODE_ASTERISK = 42'i32
+
+ + + +
+ +
KEYCODE_PLUS = 43'i32
+
+ + + +
+ +
KEYCODE_COMMA = 44'i32
+
+ + + +
+ +
KEYCODE_MINUS = 45'i32
+
+ + + +
+ +
KEYCODE_PERIOD = 46'i32
+
+ + + +
+ +
KEYCODE_SLASH = 47'i32
+
+ + + +
+ +
KEYCODE_0 = 48'i32
+
+ + + +
+ +
KEYCODE_1 = 49'i32
+
+ + + +
+ +
KEYCODE_2 = 50'i32
+
+ + + +
+ +
KEYCODE_3 = 51'i32
+
+ + + +
+ +
KEYCODE_4 = 52'i32
+
+ + + +
+ +
KEYCODE_5 = 53'i32
+
+ + + +
+ +
KEYCODE_6 = 54'i32
+
+ + + +
+ +
KEYCODE_7 = 55'i32
+
+ + + +
+ +
KEYCODE_8 = 56'i32
+
+ + + +
+ +
KEYCODE_9 = 57'i32
+
+ + + +
+ +
KEYCODE_COLON = 58'i32
+
+ + + +
+ +
KEYCODE_SEMICOLON = 59'i32
+
+ + + +
+ +
KEYCODE_LESS = 60'i32
+
+ + + +
+ +
KEYCODE_EQUALS = 61'i32
+
+ + + +
+ +
KEYCODE_GREATER = 62'i32
+
+ + + +
+ +
KEYCODE_QUESTION = 63'i32
+
+ + + +
+ +
KEYCODE_AT = 64'i32
+
+ +
Skip uppercase letters
+ + +
+ +
KEYCODE_LEFTBRACKET = 91'i32
+
+ + + +
+ +
KEYCODE_BACKSLASH = 92'i32
+
+ + + +
+ +
KEYCODE_RIGHTBRACKET = 93'i32
+
+ + + +
+ +
KEYCODE_CARET = 94'i32
+
+ + + +
+ +
KEYCODE_UNDERSCORE = 95'i32
+
+ + + +
+ +
KEYCODE_BACKQUOTE = 96'i32
+
+ + + +
+ +
KEYCODE_a = 97'i32
+
+ + + +
+ +
KEYCODE_b = 98'i32
+
+ + + +
+ +
KEYCODE_c = 99'i32
+
+ + + +
+ +
KEYCODE_d = 100'i32
+
+ + + +
+ +
KEYCODE_e = 101'i32
+
+ + + +
+ +
KEYCODE_f = 102'i32
+
+ + + +
+ +
KEYCODE_g = 103'i32
+
+ + + +
+ +
KEYCODE_h = 104'i32
+
+ + + +
+ +
KEYCODE_i = 105'i32
+
+ + + +
+ +
KEYCODE_j = 106'i32
+
+ + + +
+ +
KEYCODE_k = 107'i32
+
+ + + +
+ +
KEYCODE_l = 108'i32
+
+ + + +
+ +
KEYCODE_m = 109'i32
+
+ + + +
+ +
KEYCODE_n = 110'i32
+
+ + + +
+ +
KEYCODE_o = 111'i32
+
+ + + +
+ +
KEYCODE_p = 112'i32
+
+ + + +
+ +
KEYCODE_q = 113'i32
+
+ + + +
+ +
KEYCODE_r = 114'i32
+
+ + + +
+ +
KEYCODE_s = 115'i32
+
+ + + +
+ +
KEYCODE_t = 116'i32
+
+ + + +
+ +
KEYCODE_u = 117'i32
+
+ + + +
+ +
KEYCODE_v = 118'i32
+
+ + + +
+ +
KEYCODE_w = 119'i32
+
+ + + +
+ +
KEYCODE_x = 120'i32
+
+ + + +
+ +
KEYCODE_y = 121'i32
+
+ + + +
+ +
KEYCODE_z = 122'i32
+
+ + + +
+ +
KEYCODE_CAPSLOCK = 1073741881'i32
+
+ + + +
+ +
KEYCODE_F1 = 1073741882'i32
+
+ + + +
+ +
KEYCODE_F2 = 1073741883'i32
+
+ + + +
+ +
KEYCODE_F3 = 1073741884'i32
+
+ + + +
+ +
KEYCODE_F4 = 1073741885'i32
+
+ + + +
+ +
KEYCODE_F5 = 1073741886'i32
+
+ + + +
+ +
KEYCODE_F6 = 1073741887'i32
+
+ + + +
+ +
KEYCODE_F7 = 1073741888'i32
+
+ + + +
+ +
KEYCODE_F8 = 1073741889'i32
+
+ + + +
+ +
KEYCODE_F9 = 1073741890'i32
+
+ + + +
+ +
KEYCODE_F10 = 1073741891'i32
+
+ + + +
+ +
KEYCODE_F11 = 1073741892'i32
+
+ + + +
+ +
KEYCODE_F12 = 1073741893'i32
+
+ + + +
+ +
KEYCODE_PRINTSCREEN = 1073741894'i32
+
+ + + +
+ +
KEYCODE_SCROLLLOCK = 1073741895'i32
+
+ + + +
+ +
KEYCODE_PAUSE = 1073741896'i32
+
+ + + +
+ +
KEYCODE_INSERT = 1073741897'i32
+
+ + + +
+ +
KEYCODE_HOME = 1073741898'i32
+
+ + + +
+ +
KEYCODE_PAGEUP = 1073741899'i32
+
+ + + +
+ +
KEYCODE_DELETE = 127'i32
+
+ + + +
+ +
KEYCODE_END = 1073741901'i32
+
+ + + +
+ +
KEYCODE_PAGEDOWN = 1073741902'i32
+
+ + + +
+ +
KEYCODE_RIGHT = 1073741903'i32
+
+ + + +
+ +
KEYCODE_LEFT = 1073741904'i32
+
+ + + +
+ +
KEYCODE_DOWN = 1073741905'i32
+
+ + + +
+ +
KEYCODE_UP = 1073741906'i32
+
+ + + +
+ +
KEYCODE_NUMLOCKCLEAR = 1073741907'i32
+
+ + + +
+ +
KEYCODE_KP_DIVIDE = 1073741908'i32
+
+ + + +
+ +
KEYCODE_KP_MULTIPLY = 1073741909'i32
+
+ + + +
+ +
KEYCODE_KP_MINUS = 1073741910'i32
+
+ + + +
+ +
KEYCODE_KP_PLUS = 1073741911'i32
+
+ + + +
+ +
KEYCODE_KP_ENTER = 1073741912'i32
+
+ + + +
+ +
KEYCODE_KP_1 = 1073741913'i32
+
+ + + +
+ +
KEYCODE_KP_2 = 1073741914'i32
+
+ + + +
+ +
KEYCODE_KP_3 = 1073741915'i32
+
+ + + +
+ +
KEYCODE_KP_4 = 1073741916'i32
+
+ + + +
+ +
KEYCODE_KP_5 = 1073741917'i32
+
+ + + +
+ +
KEYCODE_KP_6 = 1073741918'i32
+
+ + + +
+ +
KEYCODE_KP_7 = 1073741919'i32
+
+ + + +
+ +
KEYCODE_KP_8 = 1073741920'i32
+
+ + + +
+ +
KEYCODE_KP_9 = 1073741921'i32
+
+ + + +
+ +
KEYCODE_KP_0 = 1073741922'i32
+
+ + + +
+ +
KEYCODE_KP_PERIOD = 1073741923'i32
+
+ + + +
+ +
KEYCODE_APPLICATION = 1073741925'i32
+
+ + + +
+ +
KEYCODE_POWER = 1073741926'i32
+
+ + + +
+ +
KEYCODE_KP_EQUALS = 1073741927'i32
+
+ + + +
+ +
KEYCODE_F13 = 1073741928'i32
+
+ + + +
+ +
KEYCODE_F14 = 1073741929'i32
+
+ + + +
+ +
KEYCODE_F15 = 1073741930'i32
+
+ + + +
+ +
KEYCODE_F16 = 1073741931'i32
+
+ + + +
+ +
KEYCODE_F17 = 1073741932'i32
+
+ + + +
+ +
KEYCODE_F18 = 1073741933'i32
+
+ + + +
+ +
KEYCODE_F19 = 1073741934'i32
+
+ + + +
+ +
KEYCODE_F20 = 1073741935'i32
+
+ + + +
+ +
KEYCODE_F21 = 1073741936'i32
+
+ + + +
+ +
KEYCODE_F22 = 1073741937'i32
+
+ + + +
+ +
KEYCODE_F23 = 1073741938'i32
+
+ + + +
+ +
KEYCODE_F24 = 1073741939'i32
+
+ + + +
+ +
KEYCODE_EXECUTE = 1073741940'i32
+
+ + + +
+ +
KEYCODE_HELP = 1073741941'i32
+
+ + + +
+ +
KEYCODE_MENU = 1073741942'i32
+
+ + + +
+ +
KEYCODE_SELECT = 1073741943'i32
+
+ + + +
+ +
KEYCODE_STOP = 1073741944'i32
+
+ + + +
+ +
KEYCODE_AGAIN = 1073741945'i32
+
+ + + +
+ +
KEYCODE_UNDO = 1073741946'i32
+
+ + + +
+ +
KEYCODE_CUT = 1073741947'i32
+
+ + + +
+ +
KEYCODE_COPY = 1073741948'i32
+
+ + + +
+ +
KEYCODE_PASTE = 1073741949'i32
+
+ + + +
+ +
KEYCODE_FIND = 1073741950'i32
+
+ + + +
+ +
KEYCODE_MUTE = 1073741951'i32
+
+ + + +
+ +
KEYCODE_VOLUMEUP = 1073741952'i32
+
+ + + +
+ +
KEYCODE_VOLUMEDOWN = 1073741953'i32
+
+ + + +
+ +
KEYCODE_KP_COMMA = 1073741957'i32
+
+ + + +
+ +
KEYCODE_KP_EQUALSAS400 = 1073741958'i32
+
+ + + +
+ +
KEYCODE_ALTERASE = 1073741977'i32
+
+ + + +
+ +
KEYCODE_SYSREQ = 1073741978'i32
+
+ + + +
+ +
KEYCODE_CANCEL = 1073741979'i32
+
+ + + +
+ +
KEYCODE_CLEAR = 1073741980'i32
+
+ + + +
+ +
KEYCODE_PRIOR = 1073741981'i32
+
+ + + +
+ +
KEYCODE_RETURN2 = 1073741982'i32
+
+ + + +
+ +
KEYCODE_SEPARATOR = 1073741983'i32
+
+ + + +
+ +
KEYCODE_OUT = 1073741984'i32
+
+ + + +
+ +
KEYCODE_OPER = 1073741985'i32
+
+ + + +
+ +
KEYCODE_CLEARAGAIN = 1073741986'i32
+
+ + + +
+ +
KEYCODE_CRSEL = 1073741987'i32
+
+ + + +
+ +
KEYCODE_EXSEL = 1073741988'i32
+
+ + + +
+ +
KEYCODE_KP_00 = 1073742000'i32
+
+ + + +
+ +
KEYCODE_KP_000 = 1073742001'i32
+
+ + + +
+ +
KEYCODE_THOUSANDSSEPARATOR = 1073742002'i32
+
+ + + +
+ +
KEYCODE_DECIMALSEPARATOR = 1073742003'i32
+
+ + + +
+ +
KEYCODE_CURRENCYUNIT = 1073742004'i32
+
+ + + +
+ +
KEYCODE_CURRENCYSUBUNIT = 1073742005'i32
+
+ + + +
+ +
KEYCODE_KP_LEFTPAREN = 1073742006'i32
+
+ + + +
+ +
KEYCODE_KP_RIGHTPAREN = 1073742007'i32
+
+ + + +
+ +
KEYCODE_KP_LEFTBRACE = 1073742008'i32
+
+ + + +
+ +
KEYCODE_KP_RIGHTBRACE = 1073742009'i32
+
+ + + +
+ +
KEYCODE_KP_TAB = 1073742010'i32
+
+ + + +
+ +
KEYCODE_KP_BACKSPACE = 1073742011'i32
+
+ + + +
+ +
KEYCODE_KP_A = 1073742012'i32
+
+ + + +
+ +
KEYCODE_KP_B = 1073742013'i32
+
+ + + +
+ +
KEYCODE_KP_C = 1073742014'i32
+
+ + + +
+ +
KEYCODE_KP_D = 1073742015'i32
+
+ + + +
+ +
KEYCODE_KP_E = 1073742016'i32
+
+ + + +
+ +
KEYCODE_KP_F = 1073742017'i32
+
+ + + +
+ +
KEYCODE_KP_XOR = 1073742018'i32
+
+ + + +
+ +
KEYCODE_KP_POWER = 1073742019'i32
+
+ + + +
+ +
KEYCODE_KP_PERCENT = 1073742020'i32
+
+ + + +
+ +
KEYCODE_KP_LESS = 1073742021'i32
+
+ + + +
+ +
KEYCODE_KP_GREATER = 1073742022'i32
+
+ + + +
+ +
KEYCODE_KP_AMPERSAND = 1073742023'i32
+
+ + + +
+ +
KEYCODE_KP_DBLAMPERSAND = 1073742024'i32
+
+ + + +
+ +
KEYCODE_KP_VERTICALBAR = 1073742025'i32
+
+ + + +
+ +
KEYCODE_KP_DBLVERTICALBAR = 1073742026'i32
+
+ + + +
+ +
KEYCODE_KP_COLON = 1073742027'i32
+
+ + + +
+ +
KEYCODE_KP_HASH = 1073742028'i32
+
+ + + +
+ +
KEYCODE_KP_SPACE = 1073742029'i32
+
+ + + +
+ +
KEYCODE_KP_AT = 1073742030'i32
+
+ + + +
+ +
KEYCODE_KP_EXCLAM = 1073742031'i32
+
+ + + +
+ +
KEYCODE_KP_MEMSTORE = 1073742032'i32
+
+ + + +
+ +
KEYCODE_KP_MEMRECALL = 1073742033'i32
+
+ + + +
+ +
KEYCODE_KP_MEMCLEAR = 1073742034'i32
+
+ + + +
+ +
KEYCODE_KP_MEMADD = 1073742035'i32
+
+ + + +
+ +
KEYCODE_KP_MEMSUBTRACT = 1073742036'i32
+
+ + + +
+ +
KEYCODE_KP_MEMMULTIPLY = 1073742037'i32
+
+ + + +
+ +
KEYCODE_KP_MEMDIVIDE = 1073742038'i32
+
+ + + +
+ +
KEYCODE_KP_PLUSMINUS = 1073742039'i32
+
+ + + +
+ +
KEYCODE_KP_CLEAR = 1073742040'i32
+
+ + + +
+ +
KEYCODE_KP_CLEARENTRY = 1073742041'i32
+
+ + + +
+ +
KEYCODE_KP_BINARY = 1073742042'i32
+
+ + + +
+ +
KEYCODE_KP_OCTAL = 1073742043'i32
+
+ + + +
+ +
KEYCODE_KP_DECIMAL = 1073742044'i32
+
+ + + +
+ +
KEYCODE_KP_HEXADECIMAL = 1073742045'i32
+
+ + + +
+ +
KEYCODE_LCTRL = 1073742048'i32
+
+ + + +
+ +
KEYCODE_LSHIFT = 1073742049'i32
+
+ + + +
+ +
KEYCODE_LALT = 1073742050'i32
+
+ + + +
+ +
KEYCODE_LGUI = 1073742051'i32
+
+ + + +
+ +
KEYCODE_RCTRL = 1073742052'i32
+
+ + + +
+ +
KEYCODE_RSHIFT = 1073742053'i32
+
+ + + +
+ +
KEYCODE_RALT = 1073742054'i32
+
+ + + +
+ +
KEYCODE_RGUI = 1073742055'i32
+
+ + + +
+ +
KEYCODE_MODE = 1073742081'i32
+
+ + + +
+ +
KEYCODE_AUDIONEXT = 1073742082'i32
+
+ + + +
+ +
KEYCODE_AUDIOPREV = 1073742083'i32
+
+ + + +
+ +
KEYCODE_AUDIOSTOP = 1073742084'i32
+
+ + + +
+ +
KEYCODE_AUDIOPLAY = 1073742085'i32
+
+ + + +
+ +
KEYCODE_AUDIOMUTE = 1073742086'i32
+
+ + + +
+ +
KEYCODE_MEDIASELECT = 1073742087'i32
+
+ + + +
+ +
KEYCODE_WWW = 1073742088'i32
+
+ + + +
+ +
KEYCODE_MAIL = 1073742089'i32
+
+ + + +
+ +
KEYCODE_CALCULATOR = 1073742090'i32
+
+ + + +
+ +
KEYCODE_COMPUTER = 1073742091'i32
+
+ + + +
+ +
KEYCODE_AC_SEARCH = 1073742092'i32
+
+ + + +
+ +
KEYCODE_AC_HOME = 1073742093'i32
+
+ + + +
+ +
KEYCODE_AC_BACK = 1073742094'i32
+
+ + + +
+ +
KEYCODE_AC_FORWARD = 1073742095'i32
+
+ + + +
+ +
KEYCODE_AC_STOP = 1073742096'i32
+
+ + + +
+ +
KEYCODE_AC_REFRESH = 1073742097'i32
+
+ + + +
+ +
KEYCODE_AC_BOOKMARKS = 1073742098'i32
+
+ + + +
+ +
KEYCODE_BRIGHTNESSDOWN = 1073742099'i32
+
+ + + +
+ +
KEYCODE_BRIGHTNESSUP = 1073742100'i32
+
+ + + +
+ +
KEYCODE_DISPLAYSWITCH = 1073742101'i32
+
+ + + +
+ +
KEYCODE_KBDILLUMTOGGLE = 1073742102'i32
+
+ + + +
+ +
KEYCODE_KBDILLUMDOWN = 1073742103'i32
+
+ + + +
+ +
KEYCODE_KBDILLUMUP = 1073742104'i32
+
+ + + +
+ +
KEYCODE_EJECT = 1073742105'i32
+
+ + + +
+ +
KEYCODE_SLEEP = 1073742106'i32
+
+ + + +
+ +
KEYCODE_APP1 = 1073742107'i32
+
+ + + +
+ +
KEYCODE_APP2 = 1073742108'i32
+
+ + + +
+ +
KEYCODE_AUDIOREWIND = 1073742109'i32
+
+ + + +
+ +
KEYCODE_AUDIOFASTFORWARD = 1073742110'i32
+
+ + + +
+ +
KMOD_NONE = 0'i32
+
+ + + +
+ +
KMOD_LSHIFT = 1'i32
+
+ + + +
+ +
KMOD_RSHIFT = 2'i32
+
+ + + +
+ +
KMOD_LCTRL = 64'i32
+
+ + + +
+ +
KMOD_RCTRL = 128'i32
+
+ + + +
+ +
KMOD_LALT = 256'i32
+
+ + + +
+ +
KMOD_RALT = 512'i32
+
+ + + +
+ +
KMOD_LGUI = 1024'i32
+
+ + + +
+ +
KMOD_RGUI = 2048'i32
+
+ + + +
+ +
KMOD_NUM = 4096'i32
+
+ + + +
+ +
KMOD_CAPS = 8192'i32
+
+ + + +
+ +
KMOD_MODE = 16384'i32
+
+ + + +
+ +
KMOD_RESERVED = 32768'i32
+
+ + + +
+ +
KMOD_CTRL = 192'i32
+
+ + + +
+ +
KMOD_SHIFT = 3'i32
+
+ + + +
+ +
KMOD_ALT = 768'i32
+
+ + + +
+ +
KMOD_GUI = 3072'i32
+
+ + + +
+ +
SYSTEM_CURSOR_ARROW = 0'i32
+
+ +
< Arrow
+ + +
+ +
SYSTEM_CURSOR_IBEAM = 1
+
+ +
< I-beam
+ + +
+ +
SYSTEM_CURSOR_WAIT = 2
+
+ +
< Wait
+ + +
+ +
SYSTEM_CURSOR_CROSSHAIR = 3
+
+ +
< Crosshair
+ + +
+ +
SYSTEM_CURSOR_WAITARROW = 4
+
+ +
< Small wait cursor (or Wait if not available)
+ + +
+ +
SYSTEM_CURSOR_SIZENWSE = 5
+
+ +
< Double arrow pointing northwest and southeast
+ + +
+ +
SYSTEM_CURSOR_SIZENESW = 6
+
+ +
< Double arrow pointing northeast and southwest
+ + +
+ +
SYSTEM_CURSOR_SIZEWE = 7
+
+ +
< Double arrow pointing west and east
+ + +
+ +
SYSTEM_CURSOR_SIZENS = 8
+
+ +
< Double arrow pointing north and south
+ + +
+ +
SYSTEM_CURSOR_SIZEALL = 9
+
+ +
< Four pointed arrow pointing north, south, east, and west
+ + +
+ +
SYSTEM_CURSOR_NO = 10
+
+ +
< Slashed circle or crossbones
+ + +
+ +
SYSTEM_CURSOR_HAND = 11
+
+ +
< Hand
+ + +
+ +
NUM_SYSTEM_CURSORS = 12
+
+ + + +
+ +
MOUSEWHEEL_NORMAL = 0'i32
+
+ +
< The scroll direction is normal
+ + +
+ +
MOUSEWHEEL_FLIPPED = 1
+
+ +
< The scroll direction is flipped / natural
+ + +
+ +
BUTTON_LEFT = 1
+
+ + + +
+ +
BUTTON_MIDDLE = 2
+
+ + + +
+ +
BUTTON_RIGHT = 3
+
+ + + +
+ +
BUTTON_X1 = 4
+
+ + + +
+ +
BUTTON_X2 = 5
+
+ + + +
+ +
JOYSTICK_TYPE_UNKNOWN = 0'i32
+
+ + + +
+ +
JOYSTICK_TYPE_GAMECONTROLLER = 1
+
+ + + +
+ +
JOYSTICK_TYPE_WHEEL = 2
+
+ + + +
+ +
JOYSTICK_TYPE_ARCADE_STICK = 3
+
+ + + +
+ +
JOYSTICK_TYPE_FLIGHT_STICK = 4
+
+ + + +
+ +
JOYSTICK_TYPE_DANCE_PAD = 5
+
+ + + +
+ +
JOYSTICK_TYPE_GUITAR = 6
+
+ + + +
+ +
JOYSTICK_TYPE_DRUM_KIT = 7
+
+ + + +
+ +
JOYSTICK_TYPE_ARCADE_PAD = 8
+
+ + + +
+ +
JOYSTICK_TYPE_THROTTLE = 9
+
+ + + +
+ +
JOYSTICK_POWER_UNKNOWN = -1'i32
+
+ + + +
+ +
JOYSTICK_POWER_EMPTY = 0
+
+ +
<= 5%
+ + +
+ +
JOYSTICK_POWER_LOW = 1
+
+ +
<= 20%
+ + +
+ +
JOYSTICK_POWER_MEDIUM = 2
+
+ +
<= 70%
+ + +
+ +
JOYSTICK_POWER_FULL = 3
+
+ +
<= 100%
+ + +
+ +
JOYSTICK_POWER_WIRED = 4
+
+ + + +
+ +
JOYSTICK_POWER_MAX = 5
+
+ + + +
+ +
JOYSTICK_AXIS_MAX = 32767
+
+ + + +
+ +
JOYSTICK_AXIS_MIN = -32768
+
+ + + +
+ +
HAT_CENTERED = 0x00000000
+
+ + + +
+ +
HAT_UP = 0x00000001
+
+ + + +
+ +
HAT_RIGHT = 0x00000002
+
+ + + +
+ +
HAT_DOWN = 0x00000004
+
+ + + +
+ +
HAT_LEFT = 0x00000008
+
+ + + +
+ +
HAT_RIGHTUP = 3
+
+ + + +
+ +
HAT_RIGHTDOWN = 6
+
+ + + +
+ +
HAT_LEFTUP = 9
+
+ + + +
+ +
HAT_LEFTDOWN = 12
+
+ + + +
+ +
CONTROLLER_TYPE_UNKNOWN = 0'i32
+
+ + + +
+ +
CONTROLLER_TYPE_XBOX360 = 1
+
+ + + +
+ +
CONTROLLER_TYPE_XBOXONE = 2
+
+ + + +
+ +
CONTROLLER_TYPE_PS3 = 3
+
+ + + +
+ +
CONTROLLER_TYPE_PS4 = 4
+
+ + + +
+ +
CONTROLLER_TYPE_NINTENDO_SWITCH_PRO = 5
+
+ + + +
+ +
CONTROLLER_AXIS_INVALID = -1'i32
+
+ + + +
+ +
CONTROLLER_AXIS_LEFTX = 0
+
+ + + +
+ +
CONTROLLER_AXIS_LEFTY = 1
+
+ + + +
+ +
CONTROLLER_AXIS_RIGHTX = 2
+
+ + + +
+ +
CONTROLLER_AXIS_RIGHTY = 3
+
+ + + +
+ +
CONTROLLER_AXIS_TRIGGERLEFT = 4
+
+ + + +
+ +
CONTROLLER_AXIS_TRIGGERRIGHT = 5
+
+ + + +
+ +
CONTROLLER_AXIS_MAX = 6
+
+ + + +
+ +
CONTROLLER_BUTTON_INVALID = -1'i32
+
+ + + +
+ +
CONTROLLER_BUTTON_A = 0
+
+ + + +
+ +
CONTROLLER_BUTTON_B = 1
+
+ + + +
+ +
CONTROLLER_BUTTON_X = 2
+
+ + + +
+ +
CONTROLLER_BUTTON_Y = 3
+
+ + + +
+ +
CONTROLLER_BUTTON_BACK = 4
+
+ + + +
+ +
CONTROLLER_BUTTON_GUIDE = 5
+
+ + + +
+ +
CONTROLLER_BUTTON_START = 6
+
+ + + +
+ +
CONTROLLER_BUTTON_LEFTSTICK = 7
+
+ + + +
+ +
CONTROLLER_BUTTON_RIGHTSTICK = 8
+
+ + + +
+ +
CONTROLLER_BUTTON_LEFTSHOULDER = 9
+
+ + + +
+ +
CONTROLLER_BUTTON_RIGHTSHOULDER = 10
+
+ + + +
+ +
CONTROLLER_BUTTON_DPAD_UP = 11
+
+ + + +
+ +
CONTROLLER_BUTTON_DPAD_DOWN = 12
+
+ + + +
+ +
CONTROLLER_BUTTON_DPAD_LEFT = 13
+
+ + + +
+ +
CONTROLLER_BUTTON_DPAD_RIGHT = 14
+
+ + + +
+ +
CONTROLLER_BUTTON_MAX = 15
+
+ + + +
+ +
TOUCH_DEVICE_INVALID = -1'i32
+
+ + + +
+ +
TOUCH_DEVICE_DIRECT = 0
+
+ +
touch screen with window-relative coordinates
+ + +
+ +
TOUCH_DEVICE_INDIRECT_ABSOLUTE = 1
+
+ +
trackpad with absolute device coordinates
+ + +
+ +
TOUCH_DEVICE_INDIRECT_RELATIVE = 2
+
+ +
trackpad with screen cursor-relative coordinates
+ + +
+ +
RELEASED = 0
+
+ + + +
+ +
PRESSED = 1
+
+ + + +
+ +
EVENT_FIRSTEVENT = 0'i32
+
+ +
< Unused (do not remove)
+ + +
+ +
EVENT_QUIT = 256'i32
+
+ +
< User-requested quit
+ + +
+ +
EVENT_APP_TERMINATING = 257
+
+ +
< The application is being terminated by the OS
+                                     Called on iOS in applicationWillTerminate()
+                                     Called on Android in onDestroy()
+ + +
+ +
EVENT_APP_LOWMEMORY = 258
+
+ +
< The application is low on memory, free memory if possible.
+                                     Called on iOS in applicationDidReceiveMemoryWarning()
+                                     Called on Android in onLowMemory()
+ + +
+ +
EVENT_APP_WILLENTERBACKGROUND = 259
+
+ +
< The application is about to enter the background
+                                     Called on iOS in applicationWillResignActive()
+                                     Called on Android in onPause()
+ + +
+ +
EVENT_APP_DIDENTERBACKGROUND = 260
+
+ +
< The application did enter the background and may not get CPU for some time
+                                     Called on iOS in applicationDidEnterBackground()
+                                     Called on Android in onPause()
+ + +
+ +
EVENT_APP_WILLENTERFOREGROUND = 261
+
+ +
< The application is about to enter the foreground
+                                     Called on iOS in applicationWillEnterForeground()
+                                     Called on Android in onResume()
+ + +
+ +
EVENT_APP_DIDENTERFOREGROUND = 262
+
+ +
< The application is now interactive
+                                     Called on iOS in applicationDidBecomeActive()
+                                     Called on Android in onResume()
+ + +
+ +
EVENT_DISPLAYEVENT = 336'i32
+
+ +
< Display state change
+ + +
+ +
EVENT_WINDOWEVENT = 512'i32
+
+ +
< Window state change
+ + +
+ +
EVENT_SYSWMEVENT = 513
+
+ +
< System specific event
+ + +
+ +
EVENT_KEYDOWN = 768'i32
+
+ +
< Key pressed
+ + +
+ +
EVENT_KEYUP = 769
+
+ +
< Key released
+ + +
+ +
EVENT_TEXTEDITING = 770
+
+ +
< Keyboard text editing (composition)
+ + +
+ +
EVENT_TEXTINPUT = 771
+
+ +
< Keyboard text input
+ + +
+ +
EVENT_KEYMAPCHANGED = 772
+
+ +
< Keymap changed due to a system event such as an
+                                     input language or keyboard layout change.
+ + +
+ +
EVENT_MOUSEMOTION = 1024'i32
+
+ +
< Mouse moved
+ + +
+ +
EVENT_MOUSEBUTTONDOWN = 1025
+
+ +
< Mouse button pressed
+ + +
+ +
EVENT_MOUSEBUTTONUP = 1026
+
+ +
< Mouse button released
+ + +
+ +
EVENT_MOUSEWHEEL = 1027
+
+ +
< Mouse wheel motion
+ + +
+ +
EVENT_JOYAXISMOTION = 1536'i32
+
+ +
< Joystick axis motion
+ + +
+ +
EVENT_JOYBALLMOTION = 1537
+
+ +
< Joystick trackball motion
+ + +
+ +
EVENT_JOYHATMOTION = 1538
+
+ +
< Joystick hat position change
+ + +
+ +
EVENT_JOYBUTTONDOWN = 1539
+
+ +
< Joystick button pressed
+ + +
+ +
EVENT_JOYBUTTONUP = 1540
+
+ +
< Joystick button released
+ + +
+ +
EVENT_JOYDEVICEADDED = 1541
+
+ +
< A new joystick has been inserted into the system
+ + +
+ +
EVENT_JOYDEVICEREMOVED = 1542
+
+ +
< An opened joystick has been removed
+ + +
+ +
EVENT_CONTROLLERAXISMOTION = 1616'i32
+
+ +
< Game controller axis motion
+ + +
+ +
EVENT_CONTROLLERBUTTONDOWN = 1617
+
+ +
< Game controller button pressed
+ + +
+ +
EVENT_CONTROLLERBUTTONUP = 1618
+
+ +
< Game controller button released
+ + +
+ +
EVENT_CONTROLLERDEVICEADDED = 1619
+
+ +
< A new Game controller has been inserted into the system
+ + +
+ +
EVENT_CONTROLLERDEVICEREMOVED = 1620
+
+ +
< An opened Game controller has been removed
+ + +
+ +
EVENT_CONTROLLERDEVICEREMAPPED = 1621
+
+ +
< The controller mapping was updated
+ + +
+ +
EVENT_FINGERDOWN = 1792'i32
+
+ + + +
+ +
EVENT_FINGERUP = 1793
+
+ + + +
+ +
EVENT_FINGERMOTION = 1794
+
+ +
Gesture events
+ + +
+ +
EVENT_DOLLARGESTURE = 2048'i32
+
+ + + +
+ +
EVENT_DOLLARRECORD = 2049
+
+ + + +
+ +
EVENT_MULTIGESTURE = 2050
+
+ +
Clipboard events
+ + +
+ +
EVENT_CLIPBOARDUPDATE = 2304'i32
+
+ +
< The clipboard changed
+ + +
+ +
EVENT_DROPFILE = 4096'i32
+
+ +
< The system requests a file open
+ + +
+ +
EVENT_DROPTEXT = 4097
+
+ +
< text/plain drag-and-drop event
+ + +
+ +
EVENT_DROPBEGIN = 4098
+
+ +
< A new set of drops is beginning (NULL filename)
+ + +
+ +
EVENT_DROPCOMPLETE = 4099
+
+ +
< Current set of drops is now complete (NULL filename)
+ + +
+ +
EVENT_AUDIODEVICEADDED = 4352'i32
+
+ +
< A new audio device is available
+ + +
+ +
EVENT_AUDIODEVICEREMOVED = 4353
+
+ +
< An audio device has been removed.
+ + +
+ +
EVENT_SENSORUPDATE = 4608'i32
+
+ +
< A sensor was updated
+ + +
+ +
EVENT_RENDER_TARGETS_RESET = 8192'i32
+
+ +
< The render targets have been reset and their contents need to be updated
+ + +
+ +
EVENT_RENDER_DEVICE_RESET = 8193
+
+ +
< The device has been reset and all textures need to be recreated
+ + +
+ +
EVENT_USEREVENT = 32768'i32
+
+ +
This last event is only for bounding internal arrays
+ + +
+ +
EVENT_LASTEVENT = 65535'i32
+
+ + + +
+ +
TEXTEDITINGEVENT_TEXT_SIZE = 32
+
+ + + +
+ +
TEXTINPUTEVENT_TEXT_SIZE = 32
+
+ + + +
+ +
ADDEVENT = 0'i32
+
+ + + +
+ +
PEEKEVENT = 1
+
+ + + +
+ +
GETEVENT = 2
+
+ + + +
+ +
QUERY = -1
+
+ + + +
+ +
IGNORE = 0
+
+ + + +
+ +
DISABLE = 0
+
+ + + +
+ +
ENABLE = 1
+
+ + + +
+ +
HAPTIC_TYPE_CONSTANT = 1'u
+
+ + + +
+ +
HAPTIC_TYPE_SINE = 2'u
+
+ + + +
+ +
HAPTIC_TYPE_LEFTRIGHT = 4'u
+
+ + + +
+ +
HAPTIC_TYPE_TRIANGLE = 8'u
+
+ + + +
+ +
HAPTIC_TYPE_SAWTOOTHUP = 16'u
+
+ + + +
+ +
HAPTIC_TYPE_SAWTOOTHDOWN = 32'u
+
+ + + +
+ +
HAPTIC_TYPE_RAMP = 64'u
+
+ + + +
+ +
HAPTIC_TYPE_SPRING = 128'u
+
+ + + +
+ +
HAPTIC_TYPE_DAMPER = 256'u
+
+ + + +
+ +
HAPTIC_TYPE_INERTIA = 512'u
+
+ + + +
+ +
HAPTIC_TYPE_FRICTION = 1024'u
+
+ + + +
+ +
HAPTIC_TYPE_CUSTOM = 2048'u
+
+ + + +
+ +
HAPTIC_TYPE_GAIN = 4096'u
+
+ + + +
+ +
HAPTIC_TYPE_AUTOCENTER = 8192'u
+
+ + + +
+ +
HAPTIC_TYPE_STATUS = 16384'u
+
+ + + +
+ +
HAPTIC_TYPE_PAUSE = 32768'u
+
+ + + +
+ +
HAPTIC_TYPE_POLAR = 0
+
+ + + +
+ +
HAPTIC_TYPE_CARTESIAN = 1
+
+ + + +
+ +
HAPTIC_TYPE_SPHERICAL = 2
+
+ + + +
+ +
HAPTIC_TYPE_INFINITY = 4294967295'u
+
+ + + +
+ +
HINT_FRAMEBUFFER_ACCELERATION = "SDL_FRAMEBUFFER_ACCELERATION"
+
+ + + +
+ +
HINT_RENDER_DRIVER = "SDL_RENDER_DRIVER"
+
+ + + +
+ +
HINT_RENDER_OPENGL_SHADERS = "SDL_RENDER_OPENGL_SHADERS"
+
+ + + +
+ +
HINT_RENDER_DIRECT3D_THREADSAFE = "SDL_RENDER_DIRECT3D_THREADSAFE"
+
+ + + +
+ +
HINT_RENDER_DIRECT3D11_DEBUG = "SDL_RENDER_DIRECT3D11_DEBUG"
+
+ + + +
+ +
HINT_RENDER_LOGICAL_SIZE_MODE = "SDL_RENDER_LOGICAL_SIZE_MODE"
+
+ + + +
+ +
HINT_RENDER_SCALE_QUALITY = "SDL_RENDER_SCALE_QUALITY"
+
+ + + +
+ +
HINT_RENDER_VSYNC = "SDL_RENDER_VSYNC"
+
+ + + +
+ +
HINT_VIDEO_ALLOW_SCREENSAVER = "SDL_VIDEO_ALLOW_SCREENSAVER"
+
+ + + +
+ +
HINT_VIDEO_EXTERNAL_CONTEXT = "SDL_VIDEO_EXTERNAL_CONTEXT"
+
+ + + +
+ +
HINT_VIDEO_X11_XVIDMODE = "SDL_VIDEO_X11_XVIDMODE"
+
+ + + +
+ +
HINT_VIDEO_X11_XINERAMA = "SDL_VIDEO_X11_XINERAMA"
+
+ + + +
+ +
HINT_VIDEO_X11_XRANDR = "SDL_VIDEO_X11_XRANDR"
+
+ + + +
+ +
HINT_VIDEO_X11_WINDOW_VISUALID = "SDL_VIDEO_X11_WINDOW_VISUALID"
+
+ + + +
+ +
HINT_VIDEO_X11_NET_WM_PING = "SDL_VIDEO_X11_NET_WM_PING"
+
+ + + +
+ +
HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR = "SDL_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR"
+
+ + + +
+ +
HINT_VIDEO_X11_FORCE_EGL = "SDL_VIDEO_X11_FORCE_EGL"
+
+ + + +
+ +
HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN = "SDL_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN"
+
+ + + +
+ +
HINT_WINDOWS_INTRESOURCE_ICON = "SDL_WINDOWS_INTRESOURCE_ICON"
+
+ + + +
+ +
HINT_WINDOWS_INTRESOURCE_ICON_SMALL = "SDL_WINDOWS_INTRESOURCE_ICON_SMALL"
+
+ + + +
+ +
HINT_WINDOWS_ENABLE_MESSAGELOOP = "SDL_WINDOWS_ENABLE_MESSAGELOOP"
+
+ + + +
+ +
HINT_GRAB_KEYBOARD = "SDL_GRAB_KEYBOARD"
+
+ + + +
+ +
HINT_MOUSE_DOUBLE_CLICK_TIME = "SDL_MOUSE_DOUBLE_CLICK_TIME"
+
+ + + +
+ +
HINT_MOUSE_DOUBLE_CLICK_RADIUS = "SDL_MOUSE_DOUBLE_CLICK_RADIUS"
+
+ + + +
+ +
HINT_MOUSE_NORMAL_SPEED_SCALE = "SDL_MOUSE_NORMAL_SPEED_SCALE"
+
+ + + +
+ +
HINT_MOUSE_RELATIVE_SPEED_SCALE = "SDL_MOUSE_RELATIVE_SPEED_SCALE"
+
+ + + +
+ +
HINT_MOUSE_RELATIVE_MODE_WARP = "SDL_MOUSE_RELATIVE_MODE_WARP"
+
+ + + +
+ +
HINT_MOUSE_FOCUS_CLICKTHROUGH = "SDL_MOUSE_FOCUS_CLICKTHROUGH"
+
+ + + +
+ +
HINT_TOUCH_MOUSE_EVENTS = "SDL_TOUCH_MOUSE_EVENTS"
+
+ + + +
+ +
HINT_MOUSE_TOUCH_EVENTS = "SDL_MOUSE_TOUCH_EVENTS"
+
+ + + +
+ +
HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS = "SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS"
+
+ + + +
+ +
HINT_IDLE_TIMER_DISABLED = "SDL_IOS_IDLE_TIMER_DISABLED"
+
+ + + +
+ +
HINT_ORIENTATIONS = "SDL_IOS_ORIENTATIONS"
+
+ + + +
+ +
HINT_APPLE_TV_CONTROLLER_UI_EVENTS = "SDL_APPLE_TV_CONTROLLER_UI_EVENTS"
+
+ + + +
+ +
HINT_APPLE_TV_REMOTE_ALLOW_ROTATION = "SDL_APPLE_TV_REMOTE_ALLOW_ROTATION"
+
+ + + +
+ +
HINT_IOS_HIDE_HOME_INDICATOR = "SDL_IOS_HIDE_HOME_INDICATOR"
+
+ + + +
+ +
HINT_ACCELEROMETER_AS_JOYSTICK = "SDL_ACCELEROMETER_AS_JOYSTICK"
+
+ + + +
+ +
HINT_TV_REMOTE_AS_JOYSTICK = "SDL_TV_REMOTE_AS_JOYSTICK"
+
+ + + +
+ +
HINT_XINPUT_ENABLED = "SDL_XINPUT_ENABLED"
+
+ + + +
+ +
HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING = "SDL_XINPUT_USE_OLD_JOYSTICK_MAPPING"
+
+ + + +
+ +
HINT_GAMECONTROLLERTYPE = "SDL_GAMECONTROLLERTYPE"
+
+ + + +
+ +
HINT_GAMECONTROLLERCONFIG = "SDL_GAMECONTROLLERCONFIG"
+
+ + + +
+ +
HINT_GAMECONTROLLERCONFIG_FILE = "SDL_GAMECONTROLLERCONFIG_FILE"
+
+ + + +
+ +
HINT_GAMECONTROLLER_IGNORE_DEVICES = "SDL_GAMECONTROLLER_IGNORE_DEVICES"
+
+ + + +
+ +
HINT_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT = "SDL_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT"
+
+ + + +
+ +
HINT_GAMECONTROLLER_USE_BUTTON_LABELS = "SDL_GAMECONTROLLER_USE_BUTTON_LABELS"
+
+ + + +
+ +
HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS = "SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS"
+
+ + + +
+ +
HINT_JOYSTICK_HIDAPI = "SDL_JOYSTICK_HIDAPI"
+
+ + + +
+ +
HINT_JOYSTICK_HIDAPI_PS4 = "SDL_JOYSTICK_HIDAPI_PS4"
+
+ + + +
+ +
HINT_JOYSTICK_HIDAPI_PS4_RUMBLE = "SDL_JOYSTICK_HIDAPI_PS4_RUMBLE"
+
+ + + +
+ +
HINT_JOYSTICK_HIDAPI_STEAM = "SDL_JOYSTICK_HIDAPI_STEAM"
+
+ + + +
+ +
HINT_JOYSTICK_HIDAPI_SWITCH = "SDL_JOYSTICK_HIDAPI_SWITCH"
+
+ + + +
+ +
HINT_JOYSTICK_HIDAPI_XBOX = "SDL_JOYSTICK_HIDAPI_XBOX"
+
+ + + +
+ +
HINT_JOYSTICK_HIDAPI_GAMECUBE = "SDL_JOYSTICK_HIDAPI_GAMECUBE"
+
+ + + +
+ +
HINT_ENABLE_STEAM_CONTROLLERS = "SDL_ENABLE_STEAM_CONTROLLERS"
+
+ + + +
+ +
HINT_ALLOW_TOPMOST = "SDL_ALLOW_TOPMOST"
+
+ + + +
+ +
HINT_TIMER_RESOLUTION = "SDL_TIMER_RESOLUTION"
+
+ + + +
+ +
HINT_QTWAYLAND_CONTENT_ORIENTATION = "SDL_QTWAYLAND_CONTENT_ORIENTATION"
+
+ + + +
+ +
HINT_QTWAYLAND_WINDOW_FLAGS = "SDL_QTWAYLAND_WINDOW_FLAGS"
+
+ + + +
+ +
HINT_THREAD_STACK_SIZE = "SDL_THREAD_STACK_SIZE"
+
+ + + +
+ +
HINT_VIDEO_HIGHDPI_DISABLED = "SDL_VIDEO_HIGHDPI_DISABLED"
+
+ + + +
+ +
HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK = "SDL_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK"
+
+ + + +
+ +
HINT_VIDEO_WIN_D3DCOMPILER = "SDL_VIDEO_WIN_D3DCOMPILER"
+
+ + + +
+ +
HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT = "SDL_VIDEO_WINDOW_SHARE_PIXEL_FORMAT"
+
+ + + +
+ +
HINT_WINRT_PRIVACY_POLICY_URL = "SDL_WINRT_PRIVACY_POLICY_URL"
+
+ + + +
+ +
HINT_WINRT_PRIVACY_POLICY_LABEL = "SDL_WINRT_PRIVACY_POLICY_LABEL"
+
+ + + +
+ +
HINT_WINRT_HANDLE_BACK_BUTTON = "SDL_WINRT_HANDLE_BACK_BUTTON"
+
+ + + +
+ +
HINT_VIDEO_MAC_FULLSCREEN_SPACES = "SDL_VIDEO_MAC_FULLSCREEN_SPACES"
+
+ + + +
+ +
HINT_MAC_BACKGROUND_APP = "SDL_MAC_BACKGROUND_APP"
+
+ + + +
+ +
HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION = "SDL_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION"
+
+ + + +
+ +
HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION = "SDL_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION"
+
+ + + +
+ +
HINT_IME_INTERNAL_EDITING = "SDL_IME_INTERNAL_EDITING"
+
+ + + +
+ +
HINT_ANDROID_TRAP_BACK_BUTTON = "SDL_ANDROID_TRAP_BACK_BUTTON"
+
+ + + +
+ +
HINT_ANDROID_BLOCK_ON_PAUSE = "SDL_ANDROID_BLOCK_ON_PAUSE"
+
+ + + +
+ +
HINT_RETURN_KEY_HIDES_IME = "SDL_RETURN_KEY_HIDES_IME"
+
+ + + +
+ +
HINT_EMSCRIPTEN_KEYBOARD_ELEMENT = "SDL_EMSCRIPTEN_KEYBOARD_ELEMENT"
+
+ + + +
+ +
HINT_NO_SIGNAL_HANDLERS = "SDL_NO_SIGNAL_HANDLERS"
+
+ + + +
+ +
HINT_WINDOWS_NO_CLOSE_ON_ALT_F4 = "SDL_WINDOWS_NO_CLOSE_ON_ALT_F4"
+
+ + + +
+ +
HINT_BMP_SAVE_LEGACY_FORMAT = "SDL_BMP_SAVE_LEGACY_FORMAT"
+
+ + + +
+ +
HINT_WINDOWS_DISABLE_THREAD_NAMING = "SDL_WINDOWS_DISABLE_THREAD_NAMING"
+
+ + + +
+ +
HINT_RPI_VIDEO_LAYER = "SDL_RPI_VIDEO_LAYER"
+
+ + + +
+ +
HINT_VIDEO_DOUBLE_BUFFER = "SDL_VIDEO_DOUBLE_BUFFER"
+
+ + + +
+ +
HINT_OPENGL_ES_DRIVER = "SDL_OPENGL_ES_DRIVER"
+
+ + + +
+ +
HINT_AUDIO_RESAMPLING_MODE = "SDL_AUDIO_RESAMPLING_MODE"
+
+ + + +
+ +
HINT_AUDIO_CATEGORY = "SDL_AUDIO_CATEGORY"
+
+ + + +
+ +
HINT_RENDER_BATCHING = "SDL_RENDER_BATCHING"
+
+ + + +
+ +
HINT_EVENT_LOGGING = "SDL_EVENT_LOGGING"
+
+ + + +
+ +
HINT_WAVE_RIFF_CHUNK_SIZE = "SDL_WAVE_RIFF_CHUNK_SIZE"
+
+ + + +
+ +
HINT_WAVE_TRUNCATION = "SDL_WAVE_TRUNCATION"
+
+ + + +
+ +
HINT_WAVE_FACT_CHUNK = "SDL_WAVE_FACT_CHUNK"
+
+ + + +
+ +
HINT_DISPLAY_USABLE_BOUNDS = "SDL_DISPLAY_USABLE_BOUNDS"
+
+ + + +
+ +
HINT_DEFAULT = 0'i32
+
+ + + +
+ +
HINT_NORMAL = 1
+
+ + + +
+ +
HINT_OVERRIDE = 2
+
+ + + +
+ +
MAX_LOG_MESSAGE = 4096
+
+ + + +
+ +
LOG_CATEGORY_APPLICATION = 0'i32
+
+ + + +
+ +
LOG_CATEGORY_ERROR = 1
+
+ + + +
+ +
LOG_CATEGORY_ASSERT = 2
+
+ + + +
+ +
LOG_CATEGORY_SYSTEM = 3
+
+ + + +
+ +
LOG_CATEGORY_AUDIO = 4
+
+ + + +
+ +
LOG_CATEGORY_VIDEO = 5
+
+ + + +
+ +
LOG_CATEGORY_RENDER = 6
+
+ + + +
+ +
LOG_CATEGORY_INPUT = 7
+
+ + + +
+ +
LOG_CATEGORY_TEST = 8
+
+ +
Reserved for future SDL library use
+ + +
+ +
LOG_CATEGORY_RESERVED1 = 9
+
+ + + +
+ +
LOG_CATEGORY_RESERVED2 = 10
+
+ + + +
+ +
LOG_CATEGORY_RESERVED3 = 11
+
+ + + +
+ +
LOG_CATEGORY_RESERVED4 = 12
+
+ + + +
+ +
LOG_CATEGORY_RESERVED5 = 13
+
+ + + +
+ +
LOG_CATEGORY_RESERVED6 = 14
+
+ + + +
+ +
LOG_CATEGORY_RESERVED7 = 15
+
+ + + +
+ +
LOG_CATEGORY_RESERVED8 = 16
+
+ + + +
+ +
LOG_CATEGORY_RESERVED9 = 17
+
+ + + +
+ +
LOG_CATEGORY_RESERVED10 = 18
+
+ +
Beyond this point is reserved for application use, e.g.
+       enum {
+           MYAPP_CATEGORY_AWESOME1 = SDL_LOG_CATEGORY_CUSTOM,
+           MYAPP_CATEGORY_AWESOME2,
+           MYAPP_CATEGORY_AWESOME3,
+           ...
+       };
+ + +
+ +
LOG_CATEGORY_CUSTOM = 19
+
+ + + +
+ +
LOG_PRIORITY_VERBOSE = 1'i32
+
+ + + +
+ +
LOG_PRIORITY_DEBUG = 2
+
+ + + +
+ +
LOG_PRIORITY_INFO = 3
+
+ + + +
+ +
LOG_PRIORITY_WARN = 4
+
+ + + +
+ +
LOG_PRIORITY_ERROR = 5
+
+ + + +
+ +
LOG_PRIORITY_CRITICAL = 6
+
+ + + +
+ +
NUM_LOG_PRIORITIES = 7
+
+ + + +
+ +
MESSAGEBOX_ERROR = 16'i32
+
+ +
< error dialog
+ + +
+ +
MESSAGEBOX_WARNING = 32'i32
+
+ +
< warning dialog
+ + +
+ +
MESSAGEBOX_INFORMATION = 64'i32
+
+ +
< informational dialog
+ + +
+ +
MESSAGEBOX_BUTTONS_LEFT_TO_RIGHT = 128'i32
+
+ +
< buttons placed left to right
+ + +
+ +
MESSAGEBOX_BUTTONS_RIGHT_TO_LEFT = 256'i32
+
+ +
< buttons placed right to left
+ + +
+ +
MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT = 1'i32
+
+ +
< Marks the default button when return is hit
+ + +
+ +
MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT = 2'i32
+
+ +
< Marks the default button when escape is hit
+ + +
+ +
MESSAGEBOX_COLOR_BACKGROUND = 0'i32
+
+ + + +
+ +
MESSAGEBOX_COLOR_TEXT = 1
+
+ + + +
+ +
MESSAGEBOX_COLOR_BUTTON_BORDER = 2
+
+ + + +
+ +
MESSAGEBOX_COLOR_BUTTON_BACKGROUND = 3
+
+ + + +
+ +
MESSAGEBOX_COLOR_BUTTON_SELECTED = 4
+
+ + + +
+ +
MESSAGEBOX_COLOR_MAX = 5
+
+ + + +
+ +
POWERSTATE_UNKNOWN = 0'i32
+
+ +
< cannot determine power status
+ + +
+ +
POWERSTATE_ON_BATTERY = 1
+
+ +
< Not plugged in, running on the battery
+ + +
+ +
POWERSTATE_NO_BATTERY = 2
+
+ +
< Plugged in, no battery available
+ + +
+ +
POWERSTATE_CHARGING = 3
+
+ +
< Plugged in, charging battery
+ + +
+ +
POWERSTATE_CHARGED = 4
+
+ +
< Plugged in, battery charged
+ + +
+ +
RENDERER_SOFTWARE = 1'i32
+
+ +
< The renderer is a software fallback
+ + +
+ +
RENDERER_ACCELERATED = 2'i32
+
+ +
< The renderer uses hardware
+                                                     acceleration
+ + +
+ +
RENDERER_PRESENTVSYNC = 4'i32
+
+ +
< Present is synchronized
+                                                     with the refresh rate
+ + +
+ +
RENDERER_TARGETTEXTURE = 8'i32
+
+ +
< The renderer supports
+                                                     rendering to texture
+ + +
+ +
ScaleModeNearest = 0'i32
+
+ +
< nearest pixel sampling
+ + +
+ +
ScaleModeLinear = 1
+
+ +
< linear filtering
+ + +
+ +
ScaleModeBest = 2
+
+ +
< anisotropic filtering
+ + +
+ +
TEXTUREACCESS_STATIC = 0'i32
+
+ +
< Changes rarely, not lockable
+ + +
+ +
TEXTUREACCESS_STREAMING = 1
+
+ +
< Changes frequently, lockable
+ + +
+ +
TEXTUREACCESS_TARGET = 2
+
+ +
< Texture can be used as a render target
+ + +
+ +
TEXTUREMODULATE_NONE = 0'i32
+
+ +
< No modulation
+ + +
+ +
TEXTUREMODULATE_COLOR = 1'i32
+
+ +
< srcC = srcC color
+ + +
+ +
TEXTUREMODULATE_ALPHA = 2'i32
+
+ +
< srcA = srcA alpha
+ + +
+ +
FLIP_NONE = 0'i32
+
+ +
< Do not flip
+ + +
+ +
FLIP_HORIZONTAL = 1'i32
+
+ +
< flip horizontally
+ + +
+ +
FLIP_VERTICAL = 2'i32
+
+ +
< flip vertically
+ + +
+ +
SENSOR_INVALID = -1'i32
+
+ +
< Returned for an invalid sensor
+ + +
+ +
SENSOR_UNKNOWN = 0
+
+ +
< Unknown sensor type
+ + +
+ +
SENSOR_ACCEL = 1
+
+ +
< Accelerometer
+ + +
+ +
SENSOR_GYRO = 2
+
+ +
< Gyroscope
+ + +
+ +
STANDARD_GRAVITY = 9.806649999999999'f64
+
+ + + +
+ +
NONSHAPEABLE_WINDOW = -1
+
+ + + +
+ +
INVALID_SHAPE_ARGUMENT = -2
+
+ + + +
+ +
WINDOW_LACKS_SHAPE = -3
+
+ + + +
+ +
ShapeModeDefault = 0'i32
+
+ +
\brief A binarized alpha cutoff with a given integer value.
+ + +
+ +
ShapeModeBinarizeAlpha = 1
+
+ +
\brief A binarized alpha cutoff with a given integer value, but with the opposite comparison.
+ + +
+ +
ShapeModeReverseBinarizeAlpha = 2
+
+ +
\brief A color key is applied.
+ + +
+ +
ShapeModeColorKey = 3
+
+ + + +
+ +
MAJOR_VERSION = 2
+
+ + + +
+ +
MINOR_VERSION = 0
+
+ + + +
+ +
PATCHLEVEL = 12
+
+ + + +
+ +
INIT_TIMER = 0x00000001'u
+
+ + + +
+ +
INIT_AUDIO = 0x00000010'u
+
+ + + +
+ +
INIT_VIDEO = 0x00000020'u
+
+ + + +
+ +
INIT_JOYSTICK = 0x00000200'u
+
+ + + +
+ +
INIT_HAPTIC = 0x00001000'u
+
+ + + +
+ +
INIT_GAMECONTROLLER = 0x00002000'u
+
+ + + +
+ +
INIT_EVENTS = 0x00004000'u
+
+ + + +
+ +
INIT_SENSOR = 0x00008000'u
+
+ + + +
+ +
INIT_NOPARACHUTE = 0x00100000'u
+
+ + + +
+ +
INIT_EVERYTHING = 62001'u
+
+ + + +
+ +
SDLDyLibPath = "/Users/joey/Projects/nim-sdl2/src/build/sdl2/buildcache/libSDL2-2.0.dylib"
+
+ + + +
+ +
SDLMainLib = "/Users/joey/Projects/nim-sdl2/src/build/sdl2/buildcache/libSDL2main.a"
+
+ + + +
+ +
SDLStaticLib = "/Users/joey/Projects/nim-sdl2/src/build/sdl2/buildcache/libSDL2.a"
+
+ + + +
+ +
WINDOWPOS_UNDEFINED = 536805376'u
+
+ + + +
+ +
WINDOWPOS_CENTERED = 805240832'u
+
+ + + +
+ +
SCANCODE_MASK = 1073741824
+
+ + + +
+ +
BUTTON_LMASK = 1
+
+ + + +
+ +
BUTTON_MMASK = 2
+
+ + + +
+ +
BUTTON_RMASK = 4
+
+ + + +
+ +
BUTTON_X1MASK = 8
+
+ + + +
+ +
BUTTON_X2MASK = 16
+
+ + + +
+ +
+
+

Procs

+
+ +
proc getPlatform(): cstring {...}{.importc: "SDL_GetPlatform", cdecl.}
+
+ +
Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+\brief Gets the name of the platform.
+ + +
+ +
proc malloc(size: uint): pointer {...}{.importc: "SDL_malloc", cdecl.}
+
+ + + +
+ +
proc calloc(nmemb: uint; size: uint): pointer {...}{.importc: "SDL_calloc", cdecl.}
+
+ + + +
+ +
proc realloc(mem: pointer; size: uint): pointer {...}{.importc: "SDL_realloc", cdecl.}
+
+ + + +
+ +
proc free(mem: pointer) {...}{.importc: "SDL_free", cdecl.}
+
+ + + +
+ +
proc getMemoryFunctions(mallocFunc: ptr malloc_func; callocFunc: ptr calloc_func;
+                       reallocFunc: ptr realloc_func; freeFunc: ptr free_func) {...}{.
+    importc: "SDL_GetMemoryFunctions", cdecl.}
+
+ +
\brief Get the current set of SDL memory functions
+ + +
+ +
proc setMemoryFunctions(mallocFunc: malloc_func; callocFunc: calloc_func;
+                       reallocFunc: realloc_func; freeFunc: free_func): cint {...}{.
+    importc: "SDL_SetMemoryFunctions", cdecl.}
+
+ +
\brief Replace SDL's memory allocation functions with a custom set
+  
+  \note If you are replacing SDL's memory functions, you should call
+        SDL_GetNumAllocations() and be very careful if it returns non-zero.
+        That means that your free function will be called with memory
+        allocated by the previous memory allocation functions.
+ + +
+ +
proc getNumAllocations(): cint {...}{.importc: "SDL_GetNumAllocations", cdecl.}
+
+ +
\brief Get the number of outstanding (unfreed) allocations
+ + +
+ +
proc getenv(name: cstring): cstring {...}{.importc: "SDL_getenv", cdecl.}
+
+ + + +
+ +
proc setenv(name: cstring; value: cstring; overwrite: cint): cint {...}{.
+    importc: "SDL_setenv", cdecl.}
+
+ + + +
+ +
proc qsort(base: pointer; nmemb: uint; size: uint;
+          compare: proc (a1: pointer; a2: pointer): cint {...}{.cdecl.}) {...}{.
+    importc: "SDL_qsort", cdecl.}
+
+ + + +
+ +
proc abs(x: cint): cint {...}{.importc: "SDL_abs", cdecl.}
+
+ + + +
+ +
proc isdigit(x: cint): cint {...}{.importc: "SDL_isdigit", cdecl.}
+
+ + + +
+ +
proc isspace(x: cint): cint {...}{.importc: "SDL_isspace", cdecl.}
+
+ + + +
+ +
proc isupper(x: cint): cint {...}{.importc: "SDL_isupper", cdecl.}
+
+ + + +
+ +
proc islower(x: cint): cint {...}{.importc: "SDL_islower", cdecl.}
+
+ + + +
+ +
proc toupper(x: cint): cint {...}{.importc: "SDL_toupper", cdecl.}
+
+ + + +
+ +
proc tolower(x: cint): cint {...}{.importc: "SDL_tolower", cdecl.}
+
+ + + +
+ +
proc memset(dst: pointer; c: cint; len: uint): pointer {...}{.importc: "SDL_memset", cdecl.}
+
+ + + +
+ +
proc memcpy(dst: pointer; src: pointer; len: uint): pointer {...}{.importc: "SDL_memcpy", cdecl.}
+
+ + + +
+ +
proc memmove(dst: pointer; src: pointer; len: uint): pointer {...}{.importc: "SDL_memmove",
+    cdecl.}
+
+ + + +
+ +
proc memcmp(s1: pointer; s2: pointer; len: uint): cint {...}{.importc: "SDL_memcmp", cdecl.}
+
+ + + +
+ +
proc wcslen(wstr: ptr wchar_t): uint {...}{.importc: "SDL_wcslen", cdecl.}
+
+ + + +
+ +
proc wcslcpy(dst: ptr wchar_t; src: ptr wchar_t; maxlen: uint): uint {...}{.
+    importc: "SDL_wcslcpy", cdecl.}
+
+ + + +
+ +
proc wcslcat(dst: ptr wchar_t; src: ptr wchar_t; maxlen: uint): uint {...}{.
+    importc: "SDL_wcslcat", cdecl.}
+
+ + + +
+ +
proc wcsdup(wstr: ptr wchar_t): ptr wchar_t {...}{.importc: "SDL_wcsdup", cdecl.}
+
+ + + +
+ +
proc wcsstr(haystack: ptr wchar_t; needle: ptr wchar_t): ptr wchar_t {...}{.
+    importc: "SDL_wcsstr", cdecl.}
+
+ + + +
+ +
proc wcscmp(str1: ptr wchar_t; str2: ptr wchar_t): cint {...}{.importc: "SDL_wcscmp", cdecl.}
+
+ + + +
+ +
proc wcsncmp(str1: ptr wchar_t; str2: ptr wchar_t; maxlen: uint): cint {...}{.
+    importc: "SDL_wcsncmp", cdecl.}
+
+ + + +
+ +
proc strlen(str: cstring): uint {...}{.importc: "SDL_strlen", cdecl.}
+
+ + + +
+ +
proc strlcpy(dst: cstring; src: cstring; maxlen: uint): uint {...}{.importc: "SDL_strlcpy",
+    cdecl.}
+
+ + + +
+ +
proc utf8strlcpy(dst: cstring; src: cstring; dstBytes: uint): uint {...}{.
+    importc: "SDL_utf8strlcpy", cdecl.}
+
+ + + +
+ +
proc strlcat(dst: cstring; src: cstring; maxlen: uint): uint {...}{.importc: "SDL_strlcat",
+    cdecl.}
+
+ + + +
+ +
proc strdup(str: cstring): cstring {...}{.importc: "SDL_strdup", cdecl.}
+
+ + + +
+ +
proc strrev(str: cstring): cstring {...}{.importc: "SDL_strrev", cdecl.}
+
+ + + +
+ +
proc strupr(str: cstring): cstring {...}{.importc: "SDL_strupr", cdecl.}
+
+ + + +
+ +
proc strlwr(str: cstring): cstring {...}{.importc: "SDL_strlwr", cdecl.}
+
+ + + +
+ +
proc strchr(str: cstring; c: cint): cstring {...}{.importc: "SDL_strchr", cdecl.}
+
+ + + +
+ +
proc strrchr(str: cstring; c: cint): cstring {...}{.importc: "SDL_strrchr", cdecl.}
+
+ + + +
+ +
proc strstr(haystack: cstring; needle: cstring): cstring {...}{.importc: "SDL_strstr", cdecl.}
+
+ + + +
+ +
proc strtokr(s1: cstring; s2: cstring; saveptr: ptr cstring): cstring {...}{.
+    importc: "SDL_strtokr", cdecl.}
+
+ + + +
+ +
proc utf8strlen(str: cstring): uint {...}{.importc: "SDL_utf8strlen", cdecl.}
+
+ + + +
+ +
proc itoa(value: cint; str: cstring; radix: cint): cstring {...}{.importc: "SDL_itoa", cdecl.}
+
+ + + +
+ +
proc uitoa(value: cuint; str: cstring; radix: cint): cstring {...}{.importc: "SDL_uitoa", cdecl.}
+
+ + + +
+ +
proc ltoa(value: clong; str: cstring; radix: cint): cstring {...}{.importc: "SDL_ltoa", cdecl.}
+
+ + + +
+ +
proc ultoa(value: culong; str: cstring; radix: cint): cstring {...}{.importc: "SDL_ultoa",
+    cdecl.}
+
+ + + +
+ +
proc lltoa(value: Sint64; str: cstring; radix: cint): cstring {...}{.importc: "SDL_lltoa",
+    cdecl.}
+
+ + + +
+ +
proc ulltoa(value: Uint64; str: cstring; radix: cint): cstring {...}{.importc: "SDL_ulltoa",
+    cdecl.}
+
+ + + +
+ +
proc atoi(str: cstring): cint {...}{.importc: "SDL_atoi", cdecl.}
+
+ + + +
+ +
proc atof(str: cstring): cdouble {...}{.importc: "SDL_atof", cdecl.}
+
+ + + +
+ +
proc strtol(str: cstring; endp: ptr cstring; base: cint): clong {...}{.importc: "SDL_strtol",
+    cdecl.}
+
+ + + +
+ +
proc strtoul(str: cstring; endp: ptr cstring; base: cint): culong {...}{.
+    importc: "SDL_strtoul", cdecl.}
+
+ + + +
+ +
proc strtoll(str: cstring; endp: ptr cstring; base: cint): Sint64 {...}{.
+    importc: "SDL_strtoll", cdecl.}
+
+ + + +
+ +
proc strtoull(str: cstring; endp: ptr cstring; base: cint): Uint64 {...}{.
+    importc: "SDL_strtoull", cdecl.}
+
+ + + +
+ +
proc strtod(str: cstring; endp: ptr cstring): cdouble {...}{.importc: "SDL_strtod", cdecl.}
+
+ + + +
+ +
proc strcmp(str1: cstring; str2: cstring): cint {...}{.importc: "SDL_strcmp", cdecl.}
+
+ + + +
+ +
proc strncmp(str1: cstring; str2: cstring; maxlen: uint): cint {...}{.importc: "SDL_strncmp",
+    cdecl.}
+
+ + + +
+ +
proc strcasecmp(str1: cstring; str2: cstring): cint {...}{.importc: "SDL_strcasecmp", cdecl.}
+
+ + + +
+ +
proc strncasecmp(str1: cstring; str2: cstring; len: uint): cint {...}{.
+    importc: "SDL_strncasecmp", cdecl.}
+
+ + + +
+ +
proc sscanf(text: cstring; fmt: cstring): cint {...}{.importc: "SDL_sscanf", cdecl, varargs.}
+
+ + + +
+ +
proc vsscanf(text: cstring; fmt: cstring; ap: va_list): cint {...}{.importc: "SDL_vsscanf",
+    cdecl.}
+
+ + + +
+ +
proc snprintf(text: cstring; maxlen: uint; fmt: cstring): cint {...}{.
+    importc: "SDL_snprintf", cdecl, varargs.}
+
+ + + +
+ +
proc vsnprintf(text: cstring; maxlen: uint; fmt: cstring; ap: va_list): cint {...}{.
+    importc: "SDL_vsnprintf", cdecl.}
+
+ + + +
+ +
proc acos(x: cdouble): cdouble {...}{.importc: "SDL_acos", cdecl.}
+
+ + + +
+ +
proc acosf(x: cfloat): cfloat {...}{.importc: "SDL_acosf", cdecl.}
+
+ + + +
+ +
proc asin(x: cdouble): cdouble {...}{.importc: "SDL_asin", cdecl.}
+
+ + + +
+ +
proc asinf(x: cfloat): cfloat {...}{.importc: "SDL_asinf", cdecl.}
+
+ + + +
+ +
proc atan(x: cdouble): cdouble {...}{.importc: "SDL_atan", cdecl.}
+
+ + + +
+ +
proc atanf(x: cfloat): cfloat {...}{.importc: "SDL_atanf", cdecl.}
+
+ + + +
+ +
proc atan2(x: cdouble; y: cdouble): cdouble {...}{.importc: "SDL_atan2", cdecl.}
+
+ + + +
+ +
proc atan2f(x: cfloat; y: cfloat): cfloat {...}{.importc: "SDL_atan2f", cdecl.}
+
+ + + +
+ +
proc ceil(x: cdouble): cdouble {...}{.importc: "SDL_ceil", cdecl.}
+
+ + + +
+ +
proc ceilf(x: cfloat): cfloat {...}{.importc: "SDL_ceilf", cdecl.}
+
+ + + +
+ +
proc copysign(x: cdouble; y: cdouble): cdouble {...}{.importc: "SDL_copysign", cdecl.}
+
+ + + +
+ +
proc copysignf(x: cfloat; y: cfloat): cfloat {...}{.importc: "SDL_copysignf", cdecl.}
+
+ + + +
+ +
proc cos(x: cdouble): cdouble {...}{.importc: "SDL_cos", cdecl.}
+
+ + + +
+ +
proc cosf(x: cfloat): cfloat {...}{.importc: "SDL_cosf", cdecl.}
+
+ + + +
+ +
proc exp(x: cdouble): cdouble {...}{.importc: "SDL_exp", cdecl.}
+
+ + + +
+ +
proc expf(x: cfloat): cfloat {...}{.importc: "SDL_expf", cdecl.}
+
+ + + +
+ +
proc fabs(x: cdouble): cdouble {...}{.importc: "SDL_fabs", cdecl.}
+
+ + + +
+ +
proc fabsf(x: cfloat): cfloat {...}{.importc: "SDL_fabsf", cdecl.}
+
+ + + +
+ +
proc floor(x: cdouble): cdouble {...}{.importc: "SDL_floor", cdecl.}
+
+ + + +
+ +
proc floorf(x: cfloat): cfloat {...}{.importc: "SDL_floorf", cdecl.}
+
+ + + +
+ +
proc fmod(x: cdouble; y: cdouble): cdouble {...}{.importc: "SDL_fmod", cdecl.}
+
+ + + +
+ +
proc fmodf(x: cfloat; y: cfloat): cfloat {...}{.importc: "SDL_fmodf", cdecl.}
+
+ + + +
+ +
proc log(x: cdouble): cdouble {...}{.importc: "SDL_log", cdecl.}
+
+ + + +
+ +
proc logf(x: cfloat): cfloat {...}{.importc: "SDL_logf", cdecl.}
+
+ + + +
+ +
proc log10(x: cdouble): cdouble {...}{.importc: "SDL_log10", cdecl.}
+
+ + + +
+ +
proc log10f(x: cfloat): cfloat {...}{.importc: "SDL_log10f", cdecl.}
+
+ + + +
+ +
proc pow(x: cdouble; y: cdouble): cdouble {...}{.importc: "SDL_pow", cdecl.}
+
+ + + +
+ +
proc powf(x: cfloat; y: cfloat): cfloat {...}{.importc: "SDL_powf", cdecl.}
+
+ + + +
+ +
proc scalbn(x: cdouble; n: cint): cdouble {...}{.importc: "SDL_scalbn", cdecl.}
+
+ + + +
+ +
proc scalbnf(x: cfloat; n: cint): cfloat {...}{.importc: "SDL_scalbnf", cdecl.}
+
+ + + +
+ +
proc sin(x: cdouble): cdouble {...}{.importc: "SDL_sin", cdecl.}
+
+ + + +
+ +
proc sinf(x: cfloat): cfloat {...}{.importc: "SDL_sinf", cdecl.}
+
+ + + +
+ +
proc sqrt(x: cdouble): cdouble {...}{.importc: "SDL_sqrt", cdecl.}
+
+ + + +
+ +
proc sqrtf(x: cfloat): cfloat {...}{.importc: "SDL_sqrtf", cdecl.}
+
+ + + +
+ +
proc tan(x: cdouble): cdouble {...}{.importc: "SDL_tan", cdecl.}
+
+ + + +
+ +
proc tanf(x: cfloat): cfloat {...}{.importc: "SDL_tanf", cdecl.}
+
+ + + +
+ +
proc iconv_open(tocode: cstring; fromcode: cstring): iconv_t {...}{.
+    importc: "SDL_iconv_open", cdecl.}
+
+ + + +
+ +
proc iconv_close(cd: iconv_t): cint {...}{.importc: "SDL_iconv_close", cdecl.}
+
+ + + +
+ +
proc iconv(cd: iconv_t; inbuf: ptr cstring; inbytesleft: ptr uint; outbuf: ptr cstring;
+          outbytesleft: ptr uint): uint {...}{.importc: "SDL_iconv", cdecl.}
+
+ + + +
+ +
proc iconv_string(tocode: cstring; fromcode: cstring; inbuf: cstring; inbytesleft: uint): cstring {...}{.
+    importc: "SDL_iconv_string", cdecl.}
+
+ +
This function converts a string between encodings in one pass, returning a
+  string that must be freed with SDL_free() or NULL on error.
+ + +
+ +
proc main(argc: cint; argv: UncheckedArray[cstring]): cint {...}{.importc: "SDL_main", cdecl.}
+
+ + + +
+ +
proc setMainReady() {...}{.importc: "SDL_SetMainReady", cdecl.}
+
+ +
This is called by the real SDL main function to let the rest of the
+  library know that initialization was done properly.
+  
+  Calling this yourself without knowing what you're doing can cause
+  crashes and hard to diagnose problems with your application.
+ + +
+ +
proc reportAssertion(a1: ptr AssertData; a2: cstring; a3: cstring; a4: cint): AssertState {...}{.
+    importc: "SDL_ReportAssertion", cdecl.}
+
+ +
Never call this directly. Use the SDL_assert macros.
+ + +
+ +
proc setAssertionHandler(handler: AssertionHandler; userdata: pointer) {...}{.
+    importc: "SDL_SetAssertionHandler", cdecl.}
+
+ +
\brief Set an application-defined assertion handler.
+  
+  This allows an app to show its own assertion UI and/or force the
+  response to an assertion failure. If the app doesn't provide this, SDL
+  will try to do the right thing, popping up a system-specific GUI dialog,
+  and probably minimizing any fullscreen windows.
+  
+  This callback may fire from any thread, but it runs wrapped in a mutex, so
+  it will only fire from one thread at a time.
+  
+  Setting the callback to NULL restores SDL's original internal handler.
+  
+  This callback is NOT reset to SDL's internal handler upon SDL_Quit()!
+  
+  Return SDL_AssertState value of how to handle the assertion failure.
+  
+  \param handler Callback function, called when an assertion fails.
+  \param userdata A pointer passed to the callback as-is.
+ + +
+ +
proc getDefaultAssertionHandler(): AssertionHandler {...}{.
+    importc: "SDL_GetDefaultAssertionHandler", cdecl.}
+
+ +
\brief Get the default assertion handler.
+  
+  This returns the function pointer that is called by default when an
+   assertion is triggered. This is an internal function provided by SDL,
+   that is used for assertions when SDL_SetAssertionHandler() hasn't been
+   used to provide a different function.
+  
+  \return The default SDL_AssertionHandler that is called when an assert triggers.
+ + +
+ +
proc getAssertionHandler(puserdata: ptr pointer): AssertionHandler {...}{.
+    importc: "SDL_GetAssertionHandler", cdecl.}
+
+ +
\brief Get the current assertion handler.
+  
+  This returns the function pointer that is called when an assertion is
+   triggered. This is either the value last passed to
+   SDL_SetAssertionHandler(), or if no application-specified function is
+   set, is equivalent to calling SDL_GetDefaultAssertionHandler().
+   
+   \param puserdata Pointer to a void, which will store the "userdata"
+                    pointer that was passed to SDL_SetAssertionHandler().
+                    This value will always be NULL for the default handler.
+                    If you don't care about this data, it is safe to pass
+                    a NULL pointer to this function to ignore it.
+  \return The SDL_AssertionHandler that is called when an assert triggers.
+ + +
+ +
proc getAssertionReport(): ptr AssertData {...}{.importc: "SDL_GetAssertionReport", cdecl.}
+
+ +
\brief Get a list of all assertion failures.
+  
+  Get all assertions triggered since last call to SDL_ResetAssertionReport(),
+  or the start of the program.
+  
+  The proper way to examine this data looks something like this:
+  
+  <code>
+  const SDL_AssertDataitem = SDL_GetAssertionReport();
+  while (item) {
+      printf("'%s', %s (%s:%d), triggered %u times, always ignore: %s.\\n",
+             item->condition, item->function, item->filename,
+             item->linenum, item->trigger_count,
+             item->always_ignore ? "yes" : "no");
+      item = item->next;
+  }
+  </code>
+  
+  \return List of all assertions.
+  \sa SDL_ResetAssertionReport
+ + +
+ +
proc resetAssertionReport() {...}{.importc: "SDL_ResetAssertionReport", cdecl.}
+
+ +
\brief Reset the list of all assertion failures.
+  
+  Reset list of all assertions triggered.
+  
+  \sa SDL_GetAssertionReport
+ + +
+ +
proc atomicTryLock(lock: ptr SpinLock): bool {...}{.importc: "SDL_AtomicTryLock", cdecl.}
+
+ +
\brief Try to lock a spin lock by setting it to a non-zero value.
+ 
+ \param lock Points to the lock.
+ 
+ \return SDL_TRUE if the lock succeeded, SDL_FALSE if the lock is already held.
+ + +
+ +
proc atomicLock(lock: ptr SpinLock) {...}{.importc: "SDL_AtomicLock", cdecl.}
+
+ +
\brief Lock a spin lock by setting it to a non-zero value.
+ 
+ \param lock Points to the lock.
+ + +
+ +
proc atomicUnlock(lock: ptr SpinLock) {...}{.importc: "SDL_AtomicUnlock", cdecl.}
+
+ +
\brief Unlock a spin lock by setting it to 0. Always returns immediately
+ 
+ \param lock Points to the lock.
+ + +
+ +
proc memoryBarrierReleaseFunction() {...}{.importc: "SDL_MemoryBarrierReleaseFunction",
+                                    cdecl.}
+
+ +
Memory barriers are designed to prevent reads and writes from being
+ reordered by the compiler and being seen out of order on multi-core CPUs.
+ 
+ A typical pattern would be for thread A to write some data and a flag,
+ and for thread B to read the flag and get the data. In this case you
+ would insert a release barrier between writing the data and the flag,
+ guaranteeing that the data write completes no later than the flag is
+ written, and you would insert an acquire barrier between reading the
+ flag and reading the data, to ensure that all the reads associated
+ with the flag have completed.
+ 
+ In this pattern you should always see a release barrier paired with
+ an acquire barrier and you should gate the data reads/writes with a
+ single flag variable.
+ 
+ For more information on these semantics, take a look at the blog post:
+ http:preshing.com/20120913/acquire-and-release-semantics
+ + +
+ +
proc memoryBarrierAcquireFunction() {...}{.importc: "SDL_MemoryBarrierAcquireFunction",
+                                    cdecl.}
+
+ + + +
+ +
proc atomicCAS(a: ptr atomic_t; oldval: cint; newval: cint): bool {...}{.
+    importc: "SDL_AtomicCAS", cdecl.}
+
+ +
\brief Set an atomic variable to a new value if it is currently an old value.
+ 
+ \return SDL_TRUE if the atomic variable was set, SDL_FALSE otherwise.
+ 
+ \note If you don't know what this function is for, you shouldn't use it!
+ + +
+ +
proc atomicSet(a: ptr atomic_t; v: cint): cint {...}{.importc: "SDL_AtomicSet", cdecl.}
+
+ +
\brief Set an atomic variable to a value.
+ 
+ \return The previous value of the atomic variable.
+ + +
+ +
proc atomicGet(a: ptr atomic_t): cint {...}{.importc: "SDL_AtomicGet", cdecl.}
+
+ +
\brief Get the value of an atomic variable
+ + +
+ +
proc atomicAdd(a: ptr atomic_t; v: cint): cint {...}{.importc: "SDL_AtomicAdd", cdecl.}
+
+ +
\brief Add to an atomic variable.
+ 
+ \return The previous value of the atomic variable.
+ 
+ \note This same style can be used for any number operation
+ + +
+ +
proc atomicCASPtr(a: ptr pointer; oldval: pointer; newval: pointer): bool {...}{.
+    importc: "SDL_AtomicCASPtr", cdecl.}
+
+ +
\brief Set a pointer to a new value if it is currently an old value.
+ 
+ \return SDL_TRUE if the pointer was set, SDL_FALSE otherwise.
+ 
+ \note If you don't know what this function is for, you shouldn't use it!
+ + +
+ +
proc atomicSetPtr(a: ptr pointer; v: pointer): pointer {...}{.importc: "SDL_AtomicSetPtr",
+    cdecl.}
+
+ +
\brief Set a pointer to a value atomically.
+ 
+ \return The previous value of the pointer.
+ + +
+ +
proc atomicGetPtr(a: ptr pointer): pointer {...}{.importc: "SDL_AtomicGetPtr", cdecl.}
+
+ +
\brief Get the value of a pointer atomically.
+ + +
+ +
proc setError(fmt: cstring): cint {...}{.importc: "SDL_SetError", cdecl, varargs.}
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+Public functions
+SDL_SetError() unconditionally returns -1.
+ + +
+ +
proc getError(): cstring {...}{.importc: "SDL_GetError", cdecl.}
+
+ + + +
+ +
proc clearError() {...}{.importc: "SDL_ClearError", cdecl.}
+
+ + + +
+ +
proc error(code: errorcode): cint {...}{.importc: "SDL_Error", cdecl.}
+
+ +
SDL_Error() unconditionally returns -1.
+ + +
+ +
proc createMutex(): ptr mutex {...}{.importc: "SDL_CreateMutex", cdecl.}
+
+ +
Create a mutex, initialized unlocked.
+ + +
+ +
proc lockMutex(mutex: ptr mutex): cint {...}{.importc: "SDL_LockMutex", cdecl.}
+
+ + + +
+ +
proc tryLockMutex(mutex: ptr mutex): cint {...}{.importc: "SDL_TryLockMutex", cdecl.}
+
+ +
Try to lock the mutex
+  
+  \return 0, SDL_MUTEX_TIMEDOUT, or -1 on error
+ + +
+ +
proc unlockMutex(mutex: ptr mutex): cint {...}{.importc: "SDL_UnlockMutex", cdecl.}
+
+ + + +
+ +
proc destroyMutex(mutex: ptr mutex) {...}{.importc: "SDL_DestroyMutex", cdecl.}
+
+ +
Destroy a mutex.
+ + +
+ +
proc createSemaphore(initialValue: Uint32): ptr sem {...}{.importc: "SDL_CreateSemaphore",
+    cdecl.}
+
+ +
Create a semaphore, initialized with value, returns NULL on failure.
+ + +
+ +
proc destroySemaphore(sem: ptr sem) {...}{.importc: "SDL_DestroySemaphore", cdecl.}
+
+ +
Destroy a semaphore.
+ + +
+ +
proc semWait(sem: ptr sem): cint {...}{.importc: "SDL_SemWait", cdecl.}
+
+ +
This function suspends the calling thread until the semaphore pointed
+  to by \c sem has a positive count. It then atomically decreases the
+  semaphore count.
+ + +
+ +
proc semTryWait(sem: ptr sem): cint {...}{.importc: "SDL_SemTryWait", cdecl.}
+
+ +
Non-blocking variant of SDL_SemWait().
+  
+  \return 0 if the wait succeeds, ::SDL_MUTEX_TIMEDOUT if the wait would
+          block, and -1 on error.
+ + +
+ +
proc semWaitTimeout(sem: ptr sem; ms: Uint32): cint {...}{.importc: "SDL_SemWaitTimeout",
+    cdecl.}
+
+ +
Variant of SDL_SemWait() with a timeout in milliseconds.
+  
+  \return 0 if the wait succeeds, ::SDL_MUTEX_TIMEDOUT if the wait does not
+          succeed in the allotted time, and -1 on error.
+  
+  \warning On some platforms this function is implemented by looping with a
+           delay of 1 ms, and so should be avoided if possible.
+ + +
+ +
proc semPost(sem: ptr sem): cint {...}{.importc: "SDL_SemPost", cdecl.}
+
+ +
Atomically increases the semaphore's count (not blocking).
+  
+  \return 0, or -1 on error.
+ + +
+ +
proc semValue(sem: ptr sem): Uint32 {...}{.importc: "SDL_SemValue", cdecl.}
+
+ +
Returns the current count of the semaphore.
+ + +
+ +
proc createCond(): ptr cond {...}{.importc: "SDL_CreateCond", cdecl.}
+
+ +
Create a condition variable.
+  
+  Typical use of condition variables:
+  
+  Thread A:
+    SDL_LockMutex(lock);
+    while ( ! condition ) {
+        SDL_CondWait(cond, lock);
+    }
+    SDL_UnlockMutex(lock);
+  
+  Thread B:
+    SDL_LockMutex(lock);
+    ...
+    condition = true;
+    ...
+    SDL_CondSignal(cond);
+    SDL_UnlockMutex(lock);
+  
+  There is some discussion whether to signal the condition variable
+  with the mutex locked or not.  There is some potential performance
+  benefit to unlocking first on some platforms, but there are some
+  potential race conditions depending on how your code is structured.
+  
+  In general it's safer to signal the condition variable while the
+  mutex is locked.
+ + +
+ +
proc destroyCond(cond: ptr cond) {...}{.importc: "SDL_DestroyCond", cdecl.}
+
+ +
Destroy a condition variable.
+ + +
+ +
proc condSignal(cond: ptr cond): cint {...}{.importc: "SDL_CondSignal", cdecl.}
+
+ +
Restart one of the threads that are waiting on the condition variable.
+  
+  \return 0 or -1 on error.
+ + +
+ +
proc condBroadcast(cond: ptr cond): cint {...}{.importc: "SDL_CondBroadcast", cdecl.}
+
+ +
Restart all threads that are waiting on the condition variable.
+  
+  \return 0 or -1 on error.
+ + +
+ +
proc condWait(cond: ptr cond; mutex: ptr mutex): cint {...}{.importc: "SDL_CondWait", cdecl.}
+
+ +
Wait on the condition variable, unlocking the provided mutex.
+  
+  \warning The mutex must be locked before entering this function!
+  
+  The mutex is re-locked once the condition variable is signaled.
+  
+  \return 0 when it is signaled, or -1 on error.
+ + +
+ +
proc condWaitTimeout(cond: ptr cond; mutex: ptr mutex; ms: Uint32): cint {...}{.
+    importc: "SDL_CondWaitTimeout", cdecl.}
+
+ +
Waits for at most \c ms milliseconds, and returns 0 if the condition
+  variable is signaled, ::SDL_MUTEX_TIMEDOUT if the condition is not
+  signaled in the allotted time, and -1 on error.
+  
+  \warning On some platforms this function is implemented by looping with a
+           delay of 1 ms, and so should be avoided if possible.
+ + +
+ +
proc createThread(fn: ThreadFunction; name: cstring; data: pointer): ptr Thread {...}{.
+    importc: "SDL_CreateThread", cdecl.}
+
+ +
Create a thread with a default stack size.
+  
+  This is equivalent to calling:
+  SDL_CreateThreadWithStackSize(fn, name, 0, data);
+ + +
+ +
proc createThreadWithStackSize(fn: ThreadFunction; name: cstring; stacksize: uint;
+                              data: pointer): ptr Thread {...}{.
+    importc: "SDL_CreateThreadWithStackSize", cdecl.}
+
+ +
Create a thread.
+   
+   Thread naming is a little complicated: Most systems have very small
+    limits for the string length (Haiku has 32 bytes, Linux currently has 16,
+    Visual C++ 6.0 has nine!), and possibly other arbitrary rules. You'll
+    have to see what happens with your system's debugger. The name should be
+    UTF-8 (but using the naming limits of C identifiers is a better bet).
+   There are no requirements for thread naming conventions, so long as the
+    string is null-terminated UTF-8, but these guidelines are helpful in
+    choosing a name:
+    
+    http:stackoverflow.com/questions/149932/naming-conventions-for-threads
+   
+   If a system imposes requirements, SDL will try to munge the string for
+    it (truncate, etc), but the original string contents will be available
+    from SDL_GetThreadName().
+   
+   The size (in bytes) of the new stack can be specified. Zero means "use
+    the system default" which might be wildly different between platforms
+    (x86 Linux generally defaults to eight megabytes, an embedded device
+    might be a few kilobytes instead).
+   
+   In SDL 2.1, stacksize will be folded into the original SDL_CreateThread
+    function.
+ + +
+ +
proc getThreadName(thread: ptr Thread): cstring {...}{.importc: "SDL_GetThreadName", cdecl.}
+
+ +
Get the thread name, as it was specified in SDL_CreateThread().
+  This function returns a pointer to a UTF-8 string that names the
+  specified thread, or NULL if it doesn't have a name. This is internal
+  memory, not to be free()'d by the caller, and remains valid until the
+  specified thread is cleaned up by SDL_WaitThread().
+ + +
+ +
proc getThreadID(thread: ptr Thread): threadID {...}{.importc: "SDL_GetThreadID", cdecl.}
+
+ +
Get the thread identifier for the specified thread.
+  
+  Equivalent to SDL_ThreadID() if the specified thread is NULL.
+ + +
+ +
proc setThreadPriority(priority: ThreadPriority): cint {...}{.
+    importc: "SDL_SetThreadPriority", cdecl.}
+
+ +
Set the priority for the current thread
+ + +
+ +
proc waitThread(thread: ptr Thread; status: ptr cint) {...}{.importc: "SDL_WaitThread", cdecl.}
+
+ +
Wait for a thread to finish. Threads that haven't been detached will
+  remain (as a "zombie") until this function cleans them up. Not doing so
+  is a resource leak.
+  
+  Once a thread has been cleaned up through this function, the SDL_Thread
+  that references it becomes invalid and should not be referenced again.
+  As such, only one thread may call SDL_WaitThread() on another.
+  
+  The return code for the thread function is placed in the area
+  pointed to by \c status, if \c status is not NULL.
+  
+  You may not wait on a thread that has been used in a call to
+  SDL_DetachThread(). Use either that function or this one, but not
+  both, or behavior is undefined.
+  
+  It is safe to pass NULL to this function; it is a no-op.
+ + +
+ +
proc detachThread(thread: ptr Thread) {...}{.importc: "SDL_DetachThread", cdecl.}
+
+ +
A thread may be "detached" to signify that it should not remain until
+  another thread has called SDL_WaitThread() on it. Detaching a thread
+  is useful for long-running threads that nothing needs to synchronize
+  with or further manage. When a detached thread is done, it simply
+  goes away.
+  
+  There is no way to recover the return code of a detached thread. If you
+  need this, don't detach the thread and instead use SDL_WaitThread().
+  
+  Once a thread is detached, you should usually assume the SDL_Thread isn't
+  safe to reference again, as it will become invalid immediately upon
+  the detached thread's exit, instead of remaining until someone has called
+  SDL_WaitThread() to finally clean it up. As such, don't detach the same
+  thread more than once.
+  
+  If a thread has already exited when passed to SDL_DetachThread(), it will
+  stop waiting for a call to SDL_WaitThread() and clean up immediately.
+  It is not safe to detach a thread that might be used with SDL_WaitThread().
+  
+  You may not call SDL_WaitThread() on a thread that has been detached.
+  Use either that function or this one, but not both, or behavior is
+  undefined.
+  
+  It is safe to pass NULL to this function; it is a no-op.
+ + +
+ +
proc tLSCreate(): TLSID {...}{.importc: "SDL_TLSCreate", cdecl.}
+
+ +
\brief Create an identifier that is globally visible to all threads but refers to data that is thread-specific.
+  
+  \return The newly created thread local storage identifier, or 0 on error
+  
+  \code
+  static SDL_SpinLock tls_lock;
+  static SDL_TLSID thread_local_storage;
+  
+  void SetMyThreadData(voidvalue)
+  {
+      if (!thread_local_storage) {
+          SDL_AtomicLock(&tls_lock);
+          if (!thread_local_storage) {
+              thread_local_storage = SDL_TLSCreate();
+          }
+          SDL_AtomicUnlock(&tls_lock);
+      }
+      SDL_TLSSet(thread_local_storage, value, 0);
+  }
+  
+  voidGetMyThreadData(void)
+  {
+      return SDL_TLSGet(thread_local_storage);
+  }
+  \endcode
+  
+  \sa SDL_TLSGet()
+  \sa SDL_TLSSet()
+ + +
+ +
proc tLSGet(id: TLSID): pointer {...}{.importc: "SDL_TLSGet", cdecl.}
+
+ +
\brief Get the value associated with a thread local storage ID for the current thread.
+  
+  \param id The thread local storage ID
+  
+  \return The value associated with the ID for the current thread, or NULL if no value has been set.
+  
+  \sa SDL_TLSCreate()
+  \sa SDL_TLSSet()
+ + +
+ +
proc tLSSet(id: TLSID; value: pointer; destructor: proc (a1: pointer) {...}{.cdecl.}): cint {...}{.
+    importc: "SDL_TLSSet", cdecl.}
+
+ +
\brief Set the value associated with a thread local storage ID for the current thread.
+  
+  \param id The thread local storage ID
+  \param value The value to associate with the ID for the current thread
+  \param destructor A function called when the thread exits, to free the value.
+  
+  \return 0 on success, -1 on error
+  
+  \sa SDL_TLSCreate()
+  \sa SDL_TLSGet()
+ + +
+ +
proc rWFromFile(file: cstring; mode: cstring): ptr RWops {...}{.importc: "SDL_RWFromFile",
+    cdecl.}
+
+ +
\name RWFrom functions
+  
+  Functions to create SDL_RWops structures from various data streams.
+@{
+ + +
+ +
proc rWFromFP(fp: File; autoclose: bool): ptr RWops {...}{.importc: "SDL_RWFromFP", cdecl.}
+
+ + + +
+ +
proc rWFromMem(mem: pointer; size: cint): ptr RWops {...}{.importc: "SDL_RWFromMem", cdecl.}
+
+ + + +
+ +
proc rWFromConstMem(mem: pointer; size: cint): ptr RWops {...}{.
+    importc: "SDL_RWFromConstMem", cdecl.}
+
+ + + +
+ +
proc allocRW(): ptr RWops {...}{.importc: "SDL_AllocRW", cdecl.}
+
+ +
@}
+RWFrom functions
+ + +
+ +
proc freeRW(area: ptr RWops) {...}{.importc: "SDL_FreeRW", cdecl.}
+
+ + + +
+ +
proc rWsize(context: ptr RWops): Sint64 {...}{.importc: "SDL_RWsize", cdecl.}
+
+ +
Return the size of the file in this rwops, or -1 if unknown
+ + +
+ +
proc rWseek(context: ptr RWops; offset: Sint64; whence: cint): Sint64 {...}{.
+    importc: "SDL_RWseek", cdecl.}
+
+ +
Seek to \c offset relative to \c whence, one of stdio's whence values:
+  RW_SEEK_SET, RW_SEEK_CUR, RW_SEEK_END
+  
+  \return the final offset in the data stream, or -1 on error.
+ + +
+ +
proc rWtell(context: ptr RWops): Sint64 {...}{.importc: "SDL_RWtell", cdecl.}
+
+ +
Return the current offset in the data stream, or -1 on error.
+ + +
+ +
proc rWread(context: ptr RWops; `ptr`: pointer; size: uint; maxnum: uint): uint {...}{.
+    importc: "SDL_RWread", cdecl.}
+
+ +
Read up to \c maxnum objects each of size \c size from the data
+  stream to the area pointed at by \c ptr.
+  
+  \return the number of objects read, or 0 at error or end of file.
+ + +
+ +
proc rWwrite(context: ptr RWops; `ptr`: pointer; size: uint; num: uint): uint {...}{.
+    importc: "SDL_RWwrite", cdecl.}
+
+ +
Write exactly \c num objects each of size \c size from the area
+  pointed at by \c ptr to data stream.
+  
+  \return the number of objects written, or 0 at error or end of file.
+ + +
+ +
proc rWclose(context: ptr RWops): cint {...}{.importc: "SDL_RWclose", cdecl.}
+
+ +
Close and free an allocated SDL_RWops structure.
+  
+  \return 0 if successful or -1 on write error when flushing data.
+ + +
+ +
proc loadFile_RW(src: ptr RWops; datasize: ptr uint; freesrc: cint): pointer {...}{.
+    importc: "SDL_LoadFile_RW", cdecl.}
+
+ +
Load all the data from an SDL data stream.
+  
+  The data is allocated with a zero byte at the end (null terminated)
+  
+  If \c datasize is not NULL, it is filled with the size of the data read.
+  
+  If \c freesrc is non-zero, the stream will be closed after being read.
+  
+  The data should be freed with SDL_free().
+  
+  \return the data, or NULL if there was an error.
+ + +
+ +
proc loadFile(file: cstring; datasize: ptr uint): pointer {...}{.importc: "SDL_LoadFile",
+    cdecl.}
+
+ +
Load an entire file.
+  
+  The data is allocated with a zero byte at the end (null terminated)
+  
+  If \c datasize is not NULL, it is filled with the size of the data read.
+  
+  If \c freesrc is non-zero, the stream will be closed after being read.
+  
+  The data should be freed with SDL_free().
+  
+  \return the data, or NULL if there was an error.
+ + +
+ +
proc readU8(src: ptr RWops): Uint8 {...}{.importc: "SDL_ReadU8", cdecl.}
+
+ +
\name Read endian functions
+  
+  Read an item of the specified endianness and return in native format.
+@{
+ + +
+ +
proc readLE16(src: ptr RWops): Uint16 {...}{.importc: "SDL_ReadLE16", cdecl.}
+
+ + + +
+ +
proc readBE16(src: ptr RWops): Uint16 {...}{.importc: "SDL_ReadBE16", cdecl.}
+
+ + + +
+ +
proc readLE32(src: ptr RWops): Uint32 {...}{.importc: "SDL_ReadLE32", cdecl.}
+
+ + + +
+ +
proc readBE32(src: ptr RWops): Uint32 {...}{.importc: "SDL_ReadBE32", cdecl.}
+
+ + + +
+ +
proc readLE64(src: ptr RWops): Uint64 {...}{.importc: "SDL_ReadLE64", cdecl.}
+
+ + + +
+ +
proc readBE64(src: ptr RWops): Uint64 {...}{.importc: "SDL_ReadBE64", cdecl.}
+
+ + + +
+ +
proc writeU8(dst: ptr RWops; value: Uint8): uint {...}{.importc: "SDL_WriteU8", cdecl.}
+
+ +
@}
+Read endian functions
+\name Write endian functions
+  
+  Write an item of native format to the specified endianness.
+@{
+ + +
+ +
proc writeLE16(dst: ptr RWops; value: Uint16): uint {...}{.importc: "SDL_WriteLE16", cdecl.}
+
+ + + +
+ +
proc writeBE16(dst: ptr RWops; value: Uint16): uint {...}{.importc: "SDL_WriteBE16", cdecl.}
+
+ + + +
+ +
proc writeLE32(dst: ptr RWops; value: Uint32): uint {...}{.importc: "SDL_WriteLE32", cdecl.}
+
+ + + +
+ +
proc writeBE32(dst: ptr RWops; value: Uint32): uint {...}{.importc: "SDL_WriteBE32", cdecl.}
+
+ + + +
+ +
proc writeLE64(dst: ptr RWops; value: Uint64): uint {...}{.importc: "SDL_WriteLE64", cdecl.}
+
+ + + +
+ +
proc writeBE64(dst: ptr RWops; value: Uint64): uint {...}{.importc: "SDL_WriteBE64", cdecl.}
+
+ + + +
+ +
proc getNumAudioDrivers(): cint {...}{.importc: "SDL_GetNumAudioDrivers", cdecl.}
+
+ +
Function prototypes
+\name Driver discovery functions
+  
+  These functions return the list of built in audio drivers, in the
+  order that they are normally initialized by default.
+@{
+ + +
+ +
proc getAudioDriver(index: cint): cstring {...}{.importc: "SDL_GetAudioDriver", cdecl.}
+
+ + + +
+ +
proc audioInit(driverName: cstring): cint {...}{.importc: "SDL_AudioInit", cdecl.}
+
+ +
@}
+\name Initialization and cleanup
+  
+  \internal These functions are used internally, and should not be used unless
+            you have a specific need to specify the audio driver you want to
+            use.  You should normally use SDL_Init() or SDL_InitSubSystem().
+@{
+ + +
+ +
proc audioQuit() {...}{.importc: "SDL_AudioQuit", cdecl.}
+
+ + + +
+ +
proc getCurrentAudioDriver(): cstring {...}{.importc: "SDL_GetCurrentAudioDriver", cdecl.}
+
+ +
@}
+This function returns the name of the current audio driver, or NULL
+  if no driver has been initialized.
+ + +
+ +
proc openAudio(desired: ptr AudioSpec; obtained: ptr AudioSpec): cint {...}{.
+    importc: "SDL_OpenAudio", cdecl.}
+
+ +
This function opens the audio device with the desired parameters, and
+  returns 0 if successful, placing the actual hardware parameters in the
+  structure pointed to by \c obtained.  If \c obtained is NULL, the audio
+  data passed to the callback function will be guaranteed to be in the
+  requested format, and will be automatically converted to the hardware
+  audio format if necessary.  This function returns -1 if it failed
+  to open the audio device, or couldn't set up the audio thread.
+  
+  When filling in the desired audio spec structure,
+    - \c desired->freq should be the desired audio frequency in samples-per-
+      second.
+    - \c desired->format should be the desired audio format.
+    - \c desired->samples is the desired size of the audio buffer, in
+      samples.  This number should be a power of two, and may be adjusted by
+      the audio driver to a value more suitable for the hardware.  Good values
+      seem to range between 512 and 8096 inclusive, depending on the
+      application and CPU speed.  Smaller values yield faster response time,
+      but can lead to underflow if the application is doing heavy processing
+      and cannot fill the audio buffer in time.  A stereo sample consists of
+      both right and left channels in LR ordering.
+      Note that the number of samples is directly related to time by the
+      following formula:  \code ms = (samples1000)/freq \endcode
+    - \c desired->size is the size in bytes of the audio buffer, and is
+      calculated by SDL_OpenAudio().
+    - \c desired->silence is the value used to set the buffer to silence,
+      and is calculated by SDL_OpenAudio().
+    - \c desired->callback should be set to a function that will be called
+      when the audio device is ready for more data.  It is passed a pointer
+      to the audio buffer, and the length in bytes of the audio buffer.
+      This function usually runs in a separate thread, and so you should
+      protect data structures that it accesses by calling SDL_LockAudio()
+      and SDL_UnlockAudio() in your code. Alternately, you may pass a NULL
+      pointer here, and call SDL_QueueAudio() with some frequency, to queue
+      more audio samples to be played (or for capture devices, call
+      SDL_DequeueAudio() with some frequency, to obtain audio samples).
+    - \c desired->userdata is passed as the first parameter to your callback
+      function. If you passed a NULL callback, this value is ignored.
+  
+  The audio device starts out playing silence when it's opened, and should
+  be enabled for playing by calling \c SDL_PauseAudio(0) when you are ready
+  for your audio callback function to be called.  Since the audio driver
+  may modify the requested size of the audio buffer, you should allocate
+  any local mixing buffers after you open the audio device.
+ + +
+ +
proc getNumAudioDevices(iscapture: cint): cint {...}{.importc: "SDL_GetNumAudioDevices",
+    cdecl.}
+
+ +
Get the number of available devices exposed by the current driver.
+  Only valid after a successfully initializing the audio subsystem.
+  Returns -1 if an explicit list of devices can't be determined; this is
+  not an error. For example, if SDL is set up to talk to a remote audio
+  server, it can't list every one available on the Internet, but it will
+  still allow a specific host to be specified to SDL_OpenAudioDevice().
+  
+  In many common cases, when this function returns a value <= 0, it can still
+  successfully open the default device (NULL for first argument of
+  SDL_OpenAudioDevice()).
+ + +
+ +
proc getAudioDeviceName(index: cint; iscapture: cint): cstring {...}{.
+    importc: "SDL_GetAudioDeviceName", cdecl.}
+
+ +
Get the human-readable name of a specific audio device.
+  Must be a value between 0 and (number of audio devices-1).
+  Only valid after a successfully initializing the audio subsystem.
+  The values returned by this function reflect the latest call to
+  SDL_GetNumAudioDevices(); recall that function to redetect available
+  hardware.
+  
+  The string returned by this function is UTF-8 encoded, read-only, and
+  managed internally. You are not to free it. If you need to keep the
+  string for any length of time, you should make your own copy of it, as it
+  will be invalid next time any of several other SDL functions is called.
+ + +
+ +
proc openAudioDevice(device: cstring; iscapture: cint; desired: ptr AudioSpec;
+                    obtained: ptr AudioSpec; allowedChanges: cint): AudioDeviceID {...}{.
+    importc: "SDL_OpenAudioDevice", cdecl.}
+
+ +
Open a specific audio device. Passing in a device name of NULL requests
+  the most reasonable default (and is equivalent to calling SDL_OpenAudio()).
+  
+  The device name is a UTF-8 string reported by SDL_GetAudioDeviceName(), but
+  some drivers allow arbitrary and driver-specific strings, such as a
+  hostname/IP address for a remote audio server, or a filename in the
+  diskaudio driver.
+  
+  \return 0 on error, a valid device ID that is >= 2 on success.
+  
+  SDL_OpenAudio(), unlike this function, always acts on device ID 1.
+ + +
+ +
proc getAudioStatus(): AudioStatus {...}{.importc: "SDL_GetAudioStatus", cdecl.}
+
+ + + +
+ +
proc getAudioDeviceStatus(dev: AudioDeviceID): AudioStatus {...}{.
+    importc: "SDL_GetAudioDeviceStatus", cdecl.}
+
+ + + +
+ +
proc pauseAudio(pauseOn: cint) {...}{.importc: "SDL_PauseAudio", cdecl.}
+
+ +
@}
+Audio State
+\name Pause audio functions
+  
+  These functions pause and unpause the audio callback processing.
+  They should be called with a parameter of 0 after opening the audio
+  device to start playing sound.  This is so you can safely initialize
+  data for your callback function after opening the audio device.
+  Silence will be written to the audio device during the pause.
+@{
+ + +
+ +
proc pauseAudioDevice(dev: AudioDeviceID; pauseOn: cint) {...}{.
+    importc: "SDL_PauseAudioDevice", cdecl.}
+
+ + + +
+ +
proc loadWAV_RW(src: ptr RWops; freesrc: cint; spec: ptr AudioSpec;
+               audioBuf: ptr ptr Uint8; audioLen: ptr Uint32): ptr AudioSpec {...}{.
+    importc: "SDL_LoadWAV_RW", cdecl.}
+
+ +
@}
+Pause audio functions
+\brief Load the audio data of a WAVE file into memory
+  
+  Loading a WAVE file requires \c src, \c spec, \c audio_buf and \c audio_len
+  to be valid pointers. The entire data portion of the file is then loaded
+  into memory and decoded if necessary.
+  
+  If \c freesrc is non-zero, the data source gets automatically closed and
+  freed before the function returns.
+  
+  Supported are RIFF WAVE files with the formats PCM (8, 16, 24, and 32 bits),
+  IEEE Float (32 bits), Microsoft ADPCM and IMA ADPCM (4 bits), and A-law and
+  µ-law (8 bits). Other formats are currently unsupported and cause an error.
+  
+  If this function succeeds, the pointer returned by it is equal to \c spec
+  and the pointer to the audio data allocated by the function is written to
+  \c audio_buf and its length in bytes to \c audio_len. The \ref SDL_AudioSpec
+  members \c freq, \c channels, and \c format are set to the values of the
+  audio data in the buffer. The \c samples member is set to a sane default and
+  all others are set to zero.
+  
+  It's necessary to use SDL_FreeWAV() to free the audio data returned in
+  \c audio_buf when it is no longer used.
+  
+  Because of the underspecification of the Waveform format, there are many
+  problematic files in the wild that cause issues with strict decoders. To
+  provide compatibility with these files, this decoder is lenient in regards
+  to the truncation of the file, the fact chunk, and the size of the RIFF
+  chunk. The hints SDL_HINT_WAVE_RIFF_CHUNK_SIZE, SDL_HINT_WAVE_TRUNCATION,
+  and SDL_HINT_WAVE_FACT_CHUNK can be used to tune the behavior of the
+  loading process.
+  
+  Any file that is invalid (due to truncation, corruption, or wrong values in
+  the headers), too big, or unsupported causes an error. Additionally, any
+  critical I/O error from the data source will terminate the loading process
+  with an error. The function returns NULL on error and in all cases (with the
+  exception of \c src being NULL), an appropriate error message will be set.
+  
+  It is required that the data source supports seeking.
+  
+  Example:
+  \code
+      SDL_LoadWAV_RW(SDL_RWFromFile("sample.wav", "rb"), 1, ...);
+  \endcode
+  
+  \param src The data source with the WAVE data
+  \param freesrc A integer value that makes the function close the data source if non-zero
+  \param spec A pointer filled with the audio format of the audio data
+  \param audio_buf A pointer filled with the audio data allocated by the function
+  \param audio_len A pointer filled with the length of the audio data buffer in bytes
+  \return NULL on error, or non-NULL on success.
+ + +
+ +
proc freeWAV(audioBuf: ptr Uint8) {...}{.importc: "SDL_FreeWAV", cdecl.}
+
+ +
This function frees data previously allocated with SDL_LoadWAV_RW()
+ + +
+ +
proc buildAudioCVT(cvt: ptr AudioCVT; srcFormat: AudioFormat; srcChannels: Uint8;
+                  srcRate: cint; dstFormat: AudioFormat; dstChannels: Uint8;
+                  dstRate: cint): cint {...}{.importc: "SDL_BuildAudioCVT", cdecl.}
+
+ +
This function takes a source format and rate and a destination format
+  and rate, and initializes the \c cvt structure with information needed
+  by SDL_ConvertAudio() to convert a buffer of audio data from one format
+  to the other. An unsupported format causes an error and -1 will be returned.
+  
+  \return 0 if no conversion is needed, 1 if the audio filter is set up,
+  or -1 on error.
+ + +
+ +
proc convertAudio(cvt: ptr AudioCVT): cint {...}{.importc: "SDL_ConvertAudio", cdecl.}
+
+ +
Once you have initialized the \c cvt structure using SDL_BuildAudioCVT(),
+  created an audio buffer \c cvt->buf, and filled it with \c cvt->len bytes of
+  audio data in the source format, this function will convert it in-place
+  to the desired format.
+  
+  The data conversion may expand the size of the audio data, so the buffer
+  \c cvt->buf should be allocated after the \c cvt structure is initialized by
+  SDL_BuildAudioCVT(), and should be \c cvt->lencvt->len_mult bytes long.
+  
+  \return 0 on success or -1 if \c cvt->buf is NULL.
+ + +
+ +
proc newAudioStream(srcFormat: AudioFormat; srcChannels: Uint8; srcRate: cint;
+                   dstFormat: AudioFormat; dstChannels: Uint8; dstRate: cint): ptr AudioStream {...}{.
+    importc: "SDL_NewAudioStream", cdecl.}
+
+ +
Create a new audio stream
+  
+  \param src_format The format of the source audio
+  \param src_channels The number of channels of the source audio
+  \param src_rate The sampling rate of the source audio
+  \param dst_format The format of the desired audio output
+  \param dst_channels The number of channels of the desired audio output
+  \param dst_rate The sampling rate of the desired audio output
+  \return 0 on success, or -1 on error.
+  
+  \sa SDL_AudioStreamPut
+  \sa SDL_AudioStreamGet
+  \sa SDL_AudioStreamAvailable
+  \sa SDL_AudioStreamFlush
+  \sa SDL_AudioStreamClear
+  \sa SDL_FreeAudioStream
+ + +
+ +
proc audioStreamPut(stream: ptr AudioStream; buf: pointer; len: cint): cint {...}{.
+    importc: "SDL_AudioStreamPut", cdecl.}
+
+ +
Add data to be converted/resampled to the stream
+  
+  \param stream The stream the audio data is being added to
+  \param buf A pointer to the audio data to add
+  \param len The number of bytes to write to the stream
+  \return 0 on success, or -1 on error.
+  
+  \sa SDL_NewAudioStream
+  \sa SDL_AudioStreamGet
+  \sa SDL_AudioStreamAvailable
+  \sa SDL_AudioStreamFlush
+  \sa SDL_AudioStreamClear
+  \sa SDL_FreeAudioStream
+ + +
+ +
proc audioStreamGet(stream: ptr AudioStream; buf: pointer; len: cint): cint {...}{.
+    importc: "SDL_AudioStreamGet", cdecl.}
+
+ +
Get converted/resampled data from the stream
+  
+  \param stream The stream the audio is being requested from
+  \param buf A buffer to fill with audio data
+  \param len The maximum number of bytes to fill
+  \return The number of bytes read from the stream, or -1 on error
+  
+  \sa SDL_NewAudioStream
+  \sa SDL_AudioStreamPut
+  \sa SDL_AudioStreamAvailable
+  \sa SDL_AudioStreamFlush
+  \sa SDL_AudioStreamClear
+  \sa SDL_FreeAudioStream
+ + +
+ +
proc audioStreamAvailable(stream: ptr AudioStream): cint {...}{.
+    importc: "SDL_AudioStreamAvailable", cdecl.}
+
+ +
Get the number of converted/resampled bytes available. The stream may be
+  buffering data behind the scenes until it has enough to resample
+  correctly, so this number might be lower than what you expect, or even
+  be zero. Add more data or flush the stream if you need the data now.
+  
+  \sa SDL_NewAudioStream
+  \sa SDL_AudioStreamPut
+  \sa SDL_AudioStreamGet
+  \sa SDL_AudioStreamFlush
+  \sa SDL_AudioStreamClear
+  \sa SDL_FreeAudioStream
+ + +
+ +
proc audioStreamFlush(stream: ptr AudioStream): cint {...}{.
+    importc: "SDL_AudioStreamFlush", cdecl.}
+
+ +
Tell the stream that you're done sending data, and anything being buffered
+  should be converted/resampled and made available immediately.
+ 
+ It is legal to add more data to a stream after flushing, but there will
+  be audio gaps in the output. Generally this is intended to signal the
+  end of input, so the complete output becomes available.
+  
+  \sa SDL_NewAudioStream
+  \sa SDL_AudioStreamPut
+  \sa SDL_AudioStreamGet
+  \sa SDL_AudioStreamAvailable
+  \sa SDL_AudioStreamClear
+  \sa SDL_FreeAudioStream
+ + +
+ +
proc audioStreamClear(stream: ptr AudioStream) {...}{.importc: "SDL_AudioStreamClear",
+    cdecl.}
+
+ +
Clear any pending data in the stream without converting it
+  
+  \sa SDL_NewAudioStream
+  \sa SDL_AudioStreamPut
+  \sa SDL_AudioStreamGet
+  \sa SDL_AudioStreamAvailable
+  \sa SDL_AudioStreamFlush
+  \sa SDL_FreeAudioStream
+ + +
+ +
proc freeAudioStream(stream: ptr AudioStream) {...}{.importc: "SDL_FreeAudioStream", cdecl.}
+
+ +
Free an audio stream
+  
+  \sa SDL_NewAudioStream
+  \sa SDL_AudioStreamPut
+  \sa SDL_AudioStreamGet
+  \sa SDL_AudioStreamAvailable
+  \sa SDL_AudioStreamFlush
+  \sa SDL_AudioStreamClear
+ + +
+ +
proc mixAudio(dst: ptr Uint8; src: ptr Uint8; len: Uint32; volume: cint) {...}{.
+    importc: "SDL_MixAudio", cdecl.}
+
+ +
This takes two audio buffers of the playing audio format and mixes
+  them, performing addition, volume adjustment, and overflow clipping.
+  The volume ranges from 0 - 128, and should be set to ::SDL_MIX_MAXVOLUME
+  for full audio volume.  Note this does not change hardware volume.
+  This is provided for convenience -- you can mix your own audio data.
+ + +
+ +
proc mixAudioFormat(dst: ptr Uint8; src: ptr Uint8; format: AudioFormat; len: Uint32;
+                   volume: cint) {...}{.importc: "SDL_MixAudioFormat", cdecl.}
+
+ +
This works like SDL_MixAudio(), but you specify the audio format instead of
+  using the format of audio device 1. Thus it can be used when no audio
+  device is open at all.
+ + +
+ +
proc queueAudio(dev: AudioDeviceID; data: pointer; len: Uint32): cint {...}{.
+    importc: "SDL_QueueAudio", cdecl.}
+
+ +
Queue more audio on non-callback devices.
+  
+  (If you are looking to retrieve queued audio from a non-callback capture
+  device, you want SDL_DequeueAudio() instead. This will return -1 to
+  signify an error if you use it with capture devices.)
+  
+  SDL offers two ways to feed audio to the device: you can either supply a
+  callback that SDL triggers with some frequency to obtain more audio
+  (pull method), or you can supply no callback, and then SDL will expect
+  you to supply data at regular intervals (push method) with this function.
+  
+  There are no limits on the amount of data you can queue, short of
+  exhaustion of address space. Queued data will drain to the device as
+  necessary without further intervention from you. If the device needs
+  audio but there is not enough queued, it will play silence to make up
+  the difference. This means you will have skips in your audio playback
+  if you aren't routinely queueing sufficient data.
+  
+  This function copies the supplied data, so you are safe to free it when
+  the function returns. This function is thread-safe, but queueing to the
+  same device from two threads at once does not promise which buffer will
+  be queued first.
+  
+  You may not queue audio on a device that is using an application-supplied
+  callback; doing so returns an error. You have to use the audio callback
+  or queue audio with this function, but not both.
+  
+  You should not call SDL_LockAudio() on the device before queueing; SDL
+  handles locking internally for this function.
+  
+  \param dev The device ID to which we will queue audio.
+  \param data The data to queue to the device for later playback.
+  \param len The number of bytes (not samples!) to which (data) points.
+  \return 0 on success, or -1 on error.
+  
+  \sa SDL_GetQueuedAudioSize
+  \sa SDL_ClearQueuedAudio
+ + +
+ +
proc dequeueAudio(dev: AudioDeviceID; data: pointer; len: Uint32): Uint32 {...}{.
+    importc: "SDL_DequeueAudio", cdecl.}
+
+ +
Dequeue more audio on non-callback devices.
+  
+  (If you are looking to queue audio for output on a non-callback playback
+  device, you want SDL_QueueAudio() instead. This will always return 0
+  if you use it with playback devices.)
+  
+  SDL offers two ways to retrieve audio from a capture device: you can
+  either supply a callback that SDL triggers with some frequency as the
+  device records more audio data, (push method), or you can supply no
+  callback, and then SDL will expect you to retrieve data at regular
+  intervals (pull method) with this function.
+  
+  There are no limits on the amount of data you can queue, short of
+  exhaustion of address space. Data from the device will keep queuing as
+  necessary without further intervention from you. This means you will
+  eventually run out of memory if you aren't routinely dequeueing data.
+  
+  Capture devices will not queue data when paused; if you are expecting
+  to not need captured audio for some length of time, use
+  SDL_PauseAudioDevice() to stop the capture device from queueing more
+  data. This can be useful during, say, level loading times. When
+  unpaused, capture devices will start queueing data from that point,
+  having flushed any capturable data available while paused.
+  
+  This function is thread-safe, but dequeueing from the same device from
+  two threads at once does not promise which thread will dequeued data
+  first.
+  
+  You may not dequeue audio from a device that is using an
+  application-supplied callback; doing so returns an error. You have to use
+  the audio callback, or dequeue audio with this function, but not both.
+  
+  You should not call SDL_LockAudio() on the device before queueing; SDL
+  handles locking internally for this function.
+  
+  \param dev The device ID from which we will dequeue audio.
+  \param data A pointer into where audio data should be copied.
+  \param len The number of bytes (not samples!) to which (data) points.
+  \return number of bytes dequeued, which could be less than requested.
+  
+  \sa SDL_GetQueuedAudioSize
+  \sa SDL_ClearQueuedAudio
+ + +
+ +
proc getQueuedAudioSize(dev: AudioDeviceID): Uint32 {...}{.
+    importc: "SDL_GetQueuedAudioSize", cdecl.}
+
+ +
Get the number of bytes of still-queued audio.
+  
+  For playback device:
+    
+    This is the number of bytes that have been queued for playback with
+    SDL_QueueAudio(), but have not yet been sent to the hardware. This
+    number may shrink at any time, so this only informs of pending data.
+    
+    Once we've sent it to the hardware, this function can not decide the
+    exact byte boundary of what has been played. It's possible that we just
+    gave the hardware several kilobytes right before you called this
+    function, but it hasn't played any of it yet, or maybe half of it, etc.
+  
+  For capture devices:
+    
+    This is the number of bytes that have been captured by the device and
+    are waiting for you to dequeue. This number may grow at any time, so
+    this only informs of the lower-bound of available data.
+  
+  You may not queue audio on a device that is using an application-supplied
+  callback; calling this function on such a device always returns 0.
+  You have to queue audio with SDL_QueueAudio()/SDL_DequeueAudio(), or use
+  the audio callback, but not both.
+  
+  You should not call SDL_LockAudio() on the device before querying; SDL
+  handles locking internally for this function.
+  
+  \param dev The device ID of which we will query queued audio size.
+  \return Number of bytes (not samples!) of queued audio.
+  
+  \sa SDL_QueueAudio
+  \sa SDL_ClearQueuedAudio
+ + +
+ +
proc clearQueuedAudio(dev: AudioDeviceID) {...}{.importc: "SDL_ClearQueuedAudio", cdecl.}
+
+ +
Drop any queued audio data. For playback devices, this is any queued data
+  still waiting to be submitted to the hardware. For capture devices, this
+  is any data that was queued by the device that hasn't yet been dequeued by
+  the application.
+  
+  Immediately after this call, SDL_GetQueuedAudioSize() will return 0. For
+  playback devices, the hardware will start playing silence if more audio
+  isn't queued. Unpaused capture devices will start filling the queue again
+  as soon as they have more data available (which, depending on the state
+  of the hardware and the thread, could be before this function call
+  returns!).
+  
+  This will not prevent playback of queued audio that's already been sent
+  to the hardware, as we can not undo that, so expect there to be some
+  fraction of a second of audio that might still be heard. This can be
+  useful if you want to, say, drop any pending music during a level change
+  in your game.
+  
+  You may not queue audio on a device that is using an application-supplied
+  callback; calling this function on such a device is always a no-op.
+  You have to queue audio with SDL_QueueAudio()/SDL_DequeueAudio(), or use
+  the audio callback, but not both.
+  
+  You should not call SDL_LockAudio() on the device before clearing the
+  queue; SDL handles locking internally for this function.
+  
+  This function always succeeds and thus returns void.
+  
+  \param dev The device ID of which to clear the audio queue.
+  
+  \sa SDL_QueueAudio
+  \sa SDL_GetQueuedAudioSize
+ + +
+ +
proc lockAudio() {...}{.importc: "SDL_LockAudio", cdecl.}
+
+ +
\name Audio lock functions
+  
+  The lock manipulated by these functions protects the callback function.
+  During a SDL_LockAudio()/SDL_UnlockAudio() pair, you can be guaranteed that
+  the callback function is not running.  Do not call these from the callback
+  function or you will cause deadlock.
+@{
+ + +
+ +
proc lockAudioDevice(dev: AudioDeviceID) {...}{.importc: "SDL_LockAudioDevice", cdecl.}
+
+ + + +
+ +
proc unlockAudio() {...}{.importc: "SDL_UnlockAudio", cdecl.}
+
+ + + +
+ +
proc unlockAudioDevice(dev: AudioDeviceID) {...}{.importc: "SDL_UnlockAudioDevice", cdecl.}
+
+ + + +
+ +
proc closeAudio() {...}{.importc: "SDL_CloseAudio", cdecl.}
+
+ +
@}
+Audio lock functions
+This function shuts down audio processing and closes the audio device.
+ + +
+ +
proc closeAudioDevice(dev: AudioDeviceID) {...}{.importc: "SDL_CloseAudioDevice", cdecl.}
+
+ + + +
+ +
proc setClipboardText(text: cstring): cint {...}{.importc: "SDL_SetClipboardText", cdecl.}
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+Function prototypes
+\brief Put UTF-8 text into the clipboard
+ 
+ \sa SDL_GetClipboardText()
+ + +
+ +
proc getClipboardText(): cstring {...}{.importc: "SDL_GetClipboardText", cdecl.}
+
+ +
\brief Get UTF-8 text from the clipboard, which must be freed with SDL_free()
+ 
+ \sa SDL_SetClipboardText()
+ + +
+ +
proc hasClipboardText(): bool {...}{.importc: "SDL_HasClipboardText", cdecl.}
+
+ +
\brief Returns a flag indicating whether the clipboard exists and contains a text string that is non-empty
+ 
+ \sa SDL_GetClipboardText()
+ + +
+ +
proc getCPUCount(): cint {...}{.importc: "SDL_GetCPUCount", cdecl.}
+
+ +
This function returns the number of CPU cores available.
+ + +
+ +
proc getCPUCacheLineSize(): cint {...}{.importc: "SDL_GetCPUCacheLineSize", cdecl.}
+
+ +
This function returns the L1 cache line size of the CPU
+  
+  This is useful for determining multi-threaded structure padding
+  or SIMD prefetch sizes.
+ + +
+ +
proc hasRDTSC(): bool {...}{.importc: "SDL_HasRDTSC", cdecl.}
+
+ +
This function returns true if the CPU has the RDTSC instruction.
+ + +
+ +
proc hasAltiVec(): bool {...}{.importc: "SDL_HasAltiVec", cdecl.}
+
+ +
This function returns true if the CPU has AltiVec features.
+ + +
+ +
proc hasMMX(): bool {...}{.importc: "SDL_HasMMX", cdecl.}
+
+ +
This function returns true if the CPU has MMX features.
+ + +
+ +
proc has3DNow(): bool {...}{.importc: "SDL_Has3DNow", cdecl.}
+
+ +
This function returns true if the CPU has 3DNow! features.
+ + +
+ +
proc hasSSE(): bool {...}{.importc: "SDL_HasSSE", cdecl.}
+
+ +
This function returns true if the CPU has SSE features.
+ + +
+ +
proc hasSSE2(): bool {...}{.importc: "SDL_HasSSE2", cdecl.}
+
+ +
This function returns true if the CPU has SSE2 features.
+ + +
+ +
proc hasSSE3(): bool {...}{.importc: "SDL_HasSSE3", cdecl.}
+
+ +
This function returns true if the CPU has SSE3 features.
+ + +
+ +
proc hasSSE41(): bool {...}{.importc: "SDL_HasSSE41", cdecl.}
+
+ +
This function returns true if the CPU has SSE4.1 features.
+ + +
+ +
proc hasSSE42(): bool {...}{.importc: "SDL_HasSSE42", cdecl.}
+
+ +
This function returns true if the CPU has SSE4.2 features.
+ + +
+ +
proc hasAVX(): bool {...}{.importc: "SDL_HasAVX", cdecl.}
+
+ +
This function returns true if the CPU has AVX features.
+ + +
+ +
proc hasAVX2(): bool {...}{.importc: "SDL_HasAVX2", cdecl.}
+
+ +
This function returns true if the CPU has AVX2 features.
+ + +
+ +
proc hasAVX512F(): bool {...}{.importc: "SDL_HasAVX512F", cdecl.}
+
+ +
This function returns true if the CPU has AVX-512F (foundation) features.
+ + +
+ +
proc hasARMSIMD(): bool {...}{.importc: "SDL_HasARMSIMD", cdecl.}
+
+ +
This function returns true if the CPU has ARM SIMD (ARMv6) features.
+ + +
+ +
proc hasNEON(): bool {...}{.importc: "SDL_HasNEON", cdecl.}
+
+ +
This function returns true if the CPU has NEON (ARM SIMD) features.
+ + +
+ +
proc getSystemRAM(): cint {...}{.importc: "SDL_GetSystemRAM", cdecl.}
+
+ +
This function returns the amount of RAM configured in the system, in MB.
+ + +
+ +
proc sIMDGetAlignment(): uint {...}{.importc: "SDL_SIMDGetAlignment", cdecl.}
+
+ +
\brief Report the alignment this system needs for SIMD allocations.
+ 
+ This will return the minimum number of bytes to which a pointer must be
+  aligned to be compatible with SIMD instructions on the current machine.
+  For example, if the machine supports SSE only, it will return 16, but if
+  it supports AVX-512F, it'll return 64 (etc). This only reports values for
+  instruction sets SDL knows about, so if your SDL build doesn't have
+  SDL_HasAVX512F(), then it might return 16 for the SSE support it sees and
+  not 64 for the AVX-512 instructions that exist but SDL doesn't know about.
+  Plan accordingly.
+ + +
+ +
proc sIMDAlloc(len: uint): pointer {...}{.importc: "SDL_SIMDAlloc", cdecl.}
+
+ +
\brief Allocate memory in a SIMD-friendly way.
+ 
+ This will allocate a block of memory that is suitable for use with SIMD
+  instructions. Specifically, it will be properly aligned and padded for
+  the system's supported vector instructions.
+ 
+ The memory returned will be padded such that it is safe to read or write
+  an incomplete vector at the end of the memory block. This can be useful
+  so you don't have to drop back to a scalar fallback at the end of your
+  SIMD processing loop to deal with the final elements without overflowing
+  the allocated buffer.
+ 
+ You must free this memory with SDL_FreeSIMD(), not free() or SDL_free()
+  or delete[], etc.
+ 
+ Note that SDL will only deal with SIMD instruction sets it is aware of;
+  for example, SDL 2.0.8 knows that SSE wants 16-byte vectors
+  (SDL_HasSSE()), and AVX2 wants 32 bytes (SDL_HasAVX2()), but doesn't
+  know that AVX-512 wants 64. To be clear: if you can't decide to use an
+  instruction set with an SDL_Has() function, don't use that instruction
+  set with memory allocated through here.
+ 
+ SDL_AllocSIMD(0) will return a non-NULL pointer, assuming the system isn't
+  out of memory.
+  
+  \param len The length, in bytes, of the block to allocated. The actual
+             allocated block might be larger due to padding, etc.
+ \return Pointer to newly-allocated block, NULL if out of memory.
+ 
+ \sa SDL_SIMDAlignment
+ \sa SDL_SIMDFree
+ + +
+ +
proc sIMDFree(`ptr`: pointer) {...}{.importc: "SDL_SIMDFree", cdecl.}
+
+ +
\brief Deallocate memory obtained from SDL_SIMDAlloc
+ 
+ It is not valid to use this function on a pointer from anything but
+  SDL_SIMDAlloc(). It can't be used on pointers from malloc, realloc,
+  SDL_malloc, memalign, new[], etc.
+ 
+ However, SDL_SIMDFree(NULL) is a legal no-op.
+ 
+ \sa SDL_SIMDAlloc
+ + +
+ +
proc getPixelFormatName(format: Uint32): cstring {...}{.
+    importc: "SDL_GetPixelFormatName", cdecl.}
+
+ +
\brief Get the human readable name of a pixel format
+ + +
+ +
proc pixelFormatEnumToMasks(format: Uint32; bpp: ptr cint; Rmask: ptr Uint32;
+                           Gmask: ptr Uint32; Bmask: ptr Uint32; Amask: ptr Uint32): bool {...}{.
+    importc: "SDL_PixelFormatEnumToMasks", cdecl.}
+
+ +
\brief Convert one of the enumerated pixel formats to a bpp and RGBA masks.
+  
+  \return SDL_TRUE, or SDL_FALSE if the conversion wasn't possible.
+  
+  \sa SDL_MasksToPixelFormatEnum()
+ + +
+ +
proc masksToPixelFormatEnum(bpp: cint; Rmask: Uint32; Gmask: Uint32; Bmask: Uint32;
+                           Amask: Uint32): Uint32 {...}{.
+    importc: "SDL_MasksToPixelFormatEnum", cdecl.}
+
+ +
\brief Convert a bpp and RGBA masks to an enumerated pixel format.
+  
+  \return The pixel format, or ::SDL_PIXELFORMAT_UNKNOWN if the conversion
+          wasn't possible.
+  
+  \sa SDL_PixelFormatEnumToMasks()
+ + +
+ +
proc allocFormat(pixelFormat: Uint32): ptr PixelFormat {...}{.importc: "SDL_AllocFormat",
+    cdecl.}
+
+ +
\brief Create an SDL_PixelFormat structure from a pixel format enum.
+ + +
+ +
proc freeFormat(format: ptr PixelFormat) {...}{.importc: "SDL_FreeFormat", cdecl.}
+
+ +
\brief Free an SDL_PixelFormat structure.
+ + +
+ +
proc allocPalette(ncolors: cint): ptr Palette {...}{.importc: "SDL_AllocPalette", cdecl.}
+
+ +
\brief Create a palette structure with the specified number of color
+         entries.
+  
+  \return A new palette, or NULL if there wasn't enough memory.
+  
+  \note The palette entries are initialized to white.
+  
+  \sa SDL_FreePalette()
+ + +
+ +
proc setPixelFormatPalette(format: ptr PixelFormat; palette: ptr Palette): cint {...}{.
+    importc: "SDL_SetPixelFormatPalette", cdecl.}
+
+ +
\brief Set the palette for a pixel format structure.
+ + +
+ +
proc setPaletteColors(palette: ptr Palette; colors: ptr Color; firstcolor: cint;
+                     ncolors: cint): cint {...}{.importc: "SDL_SetPaletteColors", cdecl.}
+
+ +
\brief Set a range of colors in a palette.
+  
+  \param palette    The palette to modify.
+  \param colors     An array of colors to copy into the palette.
+  \param firstcolor The index of the first palette entry to modify.
+  \param ncolors    The number of entries to modify.
+  
+  \return 0 on success, or -1 if not all of the colors could be set.
+ + +
+ +
proc freePalette(palette: ptr Palette) {...}{.importc: "SDL_FreePalette", cdecl.}
+
+ +
\brief Free a palette created with SDL_AllocPalette().
+  
+  \sa SDL_AllocPalette()
+ + +
+ +
proc mapRGB(format: ptr PixelFormat; r: Uint8; g: Uint8; b: Uint8): Uint32 {...}{.
+    importc: "SDL_MapRGB", cdecl.}
+
+ +
\brief Maps an RGB triple to an opaque pixel value for a given pixel format.
+  
+  \sa SDL_MapRGBA
+ + +
+ +
proc mapRGBA(format: ptr PixelFormat; r: Uint8; g: Uint8; b: Uint8; a: Uint8): Uint32 {...}{.
+    importc: "SDL_MapRGBA", cdecl.}
+
+ +
\brief Maps an RGBA quadruple to a pixel value for a given pixel format.
+  
+  \sa SDL_MapRGB
+ + +
+ +
proc getRGB(pixel: Uint32; format: ptr PixelFormat; r: ptr Uint8; g: ptr Uint8; b: ptr Uint8) {...}{.
+    importc: "SDL_GetRGB", cdecl.}
+
+ +
\brief Get the RGB components from a pixel of the specified format.
+  
+  \sa SDL_GetRGBA
+ + +
+ +
proc getRGBA(pixel: Uint32; format: ptr PixelFormat; r: ptr Uint8; g: ptr Uint8;
+            b: ptr Uint8; a: ptr Uint8) {...}{.importc: "SDL_GetRGBA", cdecl.}
+
+ +
\brief Get the RGBA components from a pixel of the specified format.
+  
+  \sa SDL_GetRGB
+ + +
+ +
proc calculateGammaRamp(gamma: cfloat; ramp: ptr Uint16) {...}{.
+    importc: "SDL_CalculateGammaRamp", cdecl.}
+
+ +
\brief Calculate a 256 entry gamma ramp for a gamma value.
+ + +
+ +
proc hasIntersection(A: ptr Rect; B: ptr Rect): bool {...}{.importc: "SDL_HasIntersection",
+    cdecl.}
+
+ +
\brief Determine whether two rectangles intersect.
+  
+  \return SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
+ + +
+ +
proc intersectRect(A: ptr Rect; B: ptr Rect; result: ptr Rect): bool {...}{.
+    importc: "SDL_IntersectRect", cdecl.}
+
+ +
\brief Calculate the intersection of two rectangles.
+  
+  \return SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
+ + +
+ +
proc unionRect(A: ptr Rect; B: ptr Rect; result: ptr Rect) {...}{.importc: "SDL_UnionRect", cdecl.}
+
+ +
\brief Calculate the union of two rectangles.
+ + +
+ +
proc enclosePoints(points: ptr Point; count: cint; clip: ptr Rect; result: ptr Rect): bool {...}{.
+    importc: "SDL_EnclosePoints", cdecl.}
+
+ +
\brief Calculate a minimal rectangle enclosing a set of points
+  
+  \return SDL_TRUE if any points were within the clipping rect
+ + +
+ +
proc intersectRectAndLine(rect: ptr Rect; X1: ptr cint; Y1: ptr cint; X2: ptr cint;
+                         Y2: ptr cint): bool {...}{.importc: "SDL_IntersectRectAndLine",
+    cdecl.}
+
+ +
\brief Calculate the intersection of a rectangle and line segment.
+  
+  \return SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
+ + +
+ +
proc composeCustomBlendMode(srcColorFactor: BlendFactor;
+                           dstColorFactor: BlendFactor;
+                           colorOperation: BlendOperation;
+                           srcAlphaFactor: BlendFactor;
+                           dstAlphaFactor: BlendFactor;
+                           alphaOperation: BlendOperation): BlendMode {...}{.
+    importc: "SDL_ComposeCustomBlendMode", cdecl.}
+
+ +
\brief Create a custom blend mode, which may or may not be supported by a given renderer
+  
+  \param srcColorFactor source color factor
+  \param dstColorFactor destination color factor
+  \param colorOperation color operation
+  \param srcAlphaFactor source alpha factor
+  \param dstAlphaFactor destination alpha factor
+  \param alphaOperation alpha operation
+  
+  The result of the blend mode operation will be:
+      dstRGB = dstRGB dstColorFactor colorOperation srcRGB srcColorFactor
+  and
+      dstA = dstA dstAlphaFactor alphaOperation srcA srcAlphaFactor
+ + +
+ +
proc createRGBSurface(flags: Uint32; width: cint; height: cint; depth: cint;
+                     Rmask: Uint32; Gmask: Uint32; Bmask: Uint32; Amask: Uint32): ptr Surface {...}{.
+    importc: "SDL_CreateRGBSurface", cdecl.}
+
+ +
Allocate and free an RGB surface.
+  
+  If the depth is 4 or 8 bits, an empty palette is allocated for the surface.
+  If the depth is greater than 8 bits, the pixel format is set using the
+  flags '[RGB]mask'.
+  
+  If the function runs out of memory, it will return NULL.
+  
+  \param flags The \c flags are obsolete and should be set to 0.
+  \param width The width in pixels of the surface to create.
+  \param height The height in pixels of the surface to create.
+  \param depth The depth in bits of the surface to create.
+  \param Rmask The red mask of the surface to create.
+  \param Gmask The green mask of the surface to create.
+  \param Bmask The blue mask of the surface to create.
+  \param Amask The alpha mask of the surface to create.
+ + +
+ +
proc createRGBSurfaceWithFormat(flags: Uint32; width: cint; height: cint; depth: cint;
+                               format: Uint32): ptr Surface {...}{.
+    importc: "SDL_CreateRGBSurfaceWithFormat", cdecl.}
+
+ +
!!! FIXME for 2.1: why does this ask for depth? Format provides that.
+ + +
+ +
proc createRGBSurfaceFrom(pixels: pointer; width: cint; height: cint; depth: cint;
+                         pitch: cint; Rmask: Uint32; Gmask: Uint32; Bmask: Uint32;
+                         Amask: Uint32): ptr Surface {...}{.
+    importc: "SDL_CreateRGBSurfaceFrom", cdecl.}
+
+ + + +
+ +
proc createRGBSurfaceWithFormatFrom(pixels: pointer; width: cint; height: cint;
+                                   depth: cint; pitch: cint; format: Uint32): ptr Surface {...}{.
+    importc: "SDL_CreateRGBSurfaceWithFormatFrom", cdecl.}
+
+ + + +
+ +
proc freeSurface(surface: ptr Surface) {...}{.importc: "SDL_FreeSurface", cdecl.}
+
+ + + +
+ +
proc setSurfacePalette(surface: ptr Surface; palette: ptr Palette): cint {...}{.
+    importc: "SDL_SetSurfacePalette", cdecl.}
+
+ +
\brief Set the palette used by a surface.
+  
+  \return 0, or -1 if the surface format doesn't use a palette.
+  
+  \note A single palette can be shared with many surfaces.
+ + +
+ +
proc lockSurface(surface: ptr Surface): cint {...}{.importc: "SDL_LockSurface", cdecl.}
+
+ +
\brief Sets up a surface for directly accessing the pixels.
+  
+  Between calls to SDL_LockSurface() / SDL_UnlockSurface(), you can write
+  to and read from \c surface->pixels, using the pixel format stored in
+  \c surface->format.  Once you are done accessing the surface, you should
+  use SDL_UnlockSurface() to release it.
+  
+  Not all surfaces require locking.  If SDL_MUSTLOCK(surface) evaluates
+  to 0, then you can read and write to the surface at any time, and the
+  pixel format of the surface will not change.
+  
+  No operating system or library calls should be made between lock/unlock
+  pairs, as critical system locks may be held during this time.
+  
+  SDL_LockSurface() returns 0, or -1 if the surface couldn't be locked.
+  
+  \sa SDL_UnlockSurface()
+ + +
+ +
proc unlockSurface(surface: ptr Surface) {...}{.importc: "SDL_UnlockSurface", cdecl.}
+
+ +
\sa SDL_LockSurface()
+ + +
+ +
proc loadBMP_RW(src: ptr RWops; freesrc: cint): ptr Surface {...}{.importc: "SDL_LoadBMP_RW",
+    cdecl.}
+
+ +
Load a surface from a seekable SDL data stream (memory or file).
+  
+  If \c freesrc is non-zero, the stream will be closed after being read.
+  
+  The new surface should be freed with SDL_FreeSurface().
+  
+  \return the new surface, or NULL if there was an error.
+ + +
+ +
proc saveBMP_RW(surface: ptr Surface; dst: ptr RWops; freedst: cint): cint {...}{.
+    importc: "SDL_SaveBMP_RW", cdecl.}
+
+ +
Save a surface to a seekable SDL data stream (memory or file).
+  
+  Surfaces with a 24-bit, 32-bit and paletted 8-bit format get saved in the
+  BMP directly. Other RGB formats with 8-bit or higher get converted to a
+  24-bit surface or, if they have an alpha mask or a colorkey, to a 32-bit
+  surface before they are saved. YUV and paletted 1-bit and 4-bit formats are
+  not supported.
+  
+  If \c freedst is non-zero, the stream will be closed after being written.
+  
+  \return 0 if successful or -1 if there was an error.
+ + +
+ +
proc setSurfaceRLE(surface: ptr Surface; flag: cint): cint {...}{.
+    importc: "SDL_SetSurfaceRLE", cdecl.}
+
+ +
\brief Sets the RLE acceleration hint for a surface.
+  
+  \return 0 on success, or -1 if the surface is not valid
+  
+  \note If RLE is enabled, colorkey and alpha blending blits are much faster,
+        but the surface must be locked before directly accessing the pixels.
+ + +
+ +
proc setColorKey(surface: ptr Surface; flag: cint; key: Uint32): cint {...}{.
+    importc: "SDL_SetColorKey", cdecl.}
+
+ +
\brief Sets the color key (transparent pixel) in a blittable surface.
+  
+  \param surface The surface to update
+  \param flag Non-zero to enable colorkey and 0 to disable colorkey
+  \param key The transparent pixel in the native surface format
+  
+  \return 0 on success, or -1 if the surface is not valid
+  
+  You can pass SDL_RLEACCEL to enable RLE accelerated blits.
+ + +
+ +
proc hasColorKey(surface: ptr Surface): bool {...}{.importc: "SDL_HasColorKey", cdecl.}
+
+ +
\brief Returns whether the surface has a color key
+  
+  \return SDL_TRUE if the surface has a color key, or SDL_FALSE if the surface is NULL or has no color key
+ + +
+ +
proc getColorKey(surface: ptr Surface; key: ptr Uint32): cint {...}{.
+    importc: "SDL_GetColorKey", cdecl.}
+
+ +
\brief Gets the color key (transparent pixel) in a blittable surface.
+  
+  \param surface The surface to update
+  \param key A pointer filled in with the transparent pixel in the native
+             surface format
+  
+  \return 0 on success, or -1 if the surface is not valid or colorkey is not
+          enabled.
+ + +
+ +
proc setSurfaceColorMod(surface: ptr Surface; r: Uint8; g: Uint8; b: Uint8): cint {...}{.
+    importc: "SDL_SetSurfaceColorMod", cdecl.}
+
+ +
\brief Set an additional color value used in blit operations.
+  
+  \param surface The surface to update.
+  \param r The red color value multiplied into blit operations.
+  \param g The green color value multiplied into blit operations.
+  \param b The blue color value multiplied into blit operations.
+  
+  \return 0 on success, or -1 if the surface is not valid.
+  
+  \sa SDL_GetSurfaceColorMod()
+ + +
+ +
proc getSurfaceColorMod(surface: ptr Surface; r: ptr Uint8; g: ptr Uint8; b: ptr Uint8): cint {...}{.
+    importc: "SDL_GetSurfaceColorMod", cdecl.}
+
+ +
\brief Get the additional color value used in blit operations.
+  
+  \param surface The surface to query.
+  \param r A pointer filled in with the current red color value.
+  \param g A pointer filled in with the current green color value.
+  \param b A pointer filled in with the current blue color value.
+  
+  \return 0 on success, or -1 if the surface is not valid.
+  
+  \sa SDL_SetSurfaceColorMod()
+ + +
+ +
proc setSurfaceAlphaMod(surface: ptr Surface; alpha: Uint8): cint {...}{.
+    importc: "SDL_SetSurfaceAlphaMod", cdecl.}
+
+ +
\brief Set an additional alpha value used in blit operations.
+  
+  \param surface The surface to update.
+  \param alpha The alpha value multiplied into blit operations.
+  
+  \return 0 on success, or -1 if the surface is not valid.
+  
+  \sa SDL_GetSurfaceAlphaMod()
+ + +
+ +
proc getSurfaceAlphaMod(surface: ptr Surface; alpha: ptr Uint8): cint {...}{.
+    importc: "SDL_GetSurfaceAlphaMod", cdecl.}
+
+ +
\brief Get the additional alpha value used in blit operations.
+  
+  \param surface The surface to query.
+  \param alpha A pointer filled in with the current alpha value.
+  
+  \return 0 on success, or -1 if the surface is not valid.
+  
+  \sa SDL_SetSurfaceAlphaMod()
+ + +
+ +
proc setSurfaceBlendMode(surface: ptr Surface; blendMode: BlendMode): cint {...}{.
+    importc: "SDL_SetSurfaceBlendMode", cdecl.}
+
+ +
\brief Set the blend mode used for blit operations.
+  
+  \param surface The surface to update.
+  \param blendMode ::SDL_BlendMode to use for blit blending.
+  
+  \return 0 on success, or -1 if the parameters are not valid.
+  
+  \sa SDL_GetSurfaceBlendMode()
+ + +
+ +
proc getSurfaceBlendMode(surface: ptr Surface; blendMode: ptr BlendMode): cint {...}{.
+    importc: "SDL_GetSurfaceBlendMode", cdecl.}
+
+ +
\brief Get the blend mode used for blit operations.
+  
+  \param surface   The surface to query.
+  \param blendMode A pointer filled in with the current blend mode.
+  
+  \return 0 on success, or -1 if the surface is not valid.
+  
+  \sa SDL_SetSurfaceBlendMode()
+ + +
+ +
proc setClipRect(surface: ptr Surface; rect: ptr Rect): bool {...}{.
+    importc: "SDL_SetClipRect", cdecl.}
+
+ +
Sets the clipping rectangle for the destination surface in a blit.
+  
+  If the clip rectangle is NULL, clipping will be disabled.
+  
+  If the clip rectangle doesn't intersect the surface, the function will
+  return SDL_FALSE and blits will be completely clipped.  Otherwise the
+  function returns SDL_TRUE and blits to the surface will be clipped to
+  the intersection of the surface area and the clipping rectangle.
+  
+  Note that blits are automatically clipped to the edges of the source
+  and destination surfaces.
+ + +
+ +
proc getClipRect(surface: ptr Surface; rect: ptr Rect) {...}{.importc: "SDL_GetClipRect",
+    cdecl.}
+
+ +
Gets the clipping rectangle for the destination surface in a blit.
+  
+  \c rect must be a pointer to a valid rectangle which will be filled
+  with the correct values.
+ + +
+ +
proc duplicateSurface(surface: ptr Surface): ptr Surface {...}{.
+    importc: "SDL_DuplicateSurface", cdecl.}
+
+ +
Creates a new surface identical to the existing surface
+ + +
+ +
proc convertSurface(src: ptr Surface; fmt: ptr PixelFormat; flags: Uint32): ptr Surface {...}{.
+    importc: "SDL_ConvertSurface", cdecl.}
+
+ +
Creates a new surface of the specified format, and then copies and maps
+  the given surface to it so the blit of the converted surface will be as
+  fast as possible.  If this function fails, it returns NULL.
+  
+  The \c flags parameter is passed to SDL_CreateRGBSurface() and has those
+  semantics.  You can also pass ::SDL_RLEACCEL in the flags parameter and
+  SDL will try to RLE accelerate colorkey and alpha blits in the resulting
+  surface.
+ + +
+ +
proc convertSurfaceFormat(src: ptr Surface; pixelFormat: Uint32; flags: Uint32): ptr Surface {...}{.
+    importc: "SDL_ConvertSurfaceFormat", cdecl.}
+
+ + + +
+ +
proc convertPixels(width: cint; height: cint; srcFormat: Uint32; src: pointer;
+                  srcPitch: cint; dstFormat: Uint32; dst: pointer; dstPitch: cint): cint {...}{.
+    importc: "SDL_ConvertPixels", cdecl.}
+
+ +
\brief Copy a block of pixels of one format to another format
+  
+  \return 0 on success, or -1 if there was an error
+ + +
+ +
proc fillRect(dst: ptr Surface; rect: ptr Rect; color: Uint32): cint {...}{.
+    importc: "SDL_FillRect", cdecl.}
+
+ +
Performs a fast fill of the given rectangle with \c color.
+  
+  If \c rect is NULL, the whole surface will be filled with \c color.
+  
+  The color should be a pixel of the format used by the surface, and
+  can be generated by the SDL_MapRGB() function.
+  
+  \return 0 on success, or -1 on error.
+ + +
+ +
proc fillRects(dst: ptr Surface; rects: ptr Rect; count: cint; color: Uint32): cint {...}{.
+    importc: "SDL_FillRects", cdecl.}
+
+ + + +
+ +
proc upperBlit(src: ptr Surface; srcrect: ptr Rect; dst: ptr Surface; dstrect: ptr Rect): cint {...}{.
+    importc: "SDL_UpperBlit", cdecl.}
+
+ +
This is the public blit function, SDL_BlitSurface(), and it performs
+  rectangle validation and clipping before passing it to SDL_LowerBlit()
+ + +
+ +
proc lowerBlit(src: ptr Surface; srcrect: ptr Rect; dst: ptr Surface; dstrect: ptr Rect): cint {...}{.
+    importc: "SDL_LowerBlit", cdecl.}
+
+ +
This is a semi-private blit function and it performs low-level surface
+  blitting only.
+ + +
+ +
proc softStretch(src: ptr Surface; srcrect: ptr Rect; dst: ptr Surface; dstrect: ptr Rect): cint {...}{.
+    importc: "SDL_SoftStretch", cdecl.}
+
+ +
\brief Perform a fast, low quality, stretch blit between two surfaces of the
+         same pixel format.
+  
+  \note This function uses a static buffer, and is not thread-safe.
+ + +
+ +
proc upperBlitScaled(src: ptr Surface; srcrect: ptr Rect; dst: ptr Surface;
+                    dstrect: ptr Rect): cint {...}{.importc: "SDL_UpperBlitScaled", cdecl.}
+
+ +
This is the public scaled blit function, SDL_BlitScaled(), and it performs
+  rectangle validation and clipping before passing it to SDL_LowerBlitScaled()
+ + +
+ +
proc lowerBlitScaled(src: ptr Surface; srcrect: ptr Rect; dst: ptr Surface;
+                    dstrect: ptr Rect): cint {...}{.importc: "SDL_LowerBlitScaled", cdecl.}
+
+ +
This is a semi-private blit function and it performs low-level surface
+  scaled blitting only.
+ + +
+ +
proc setYUVConversionMode(mode: YUV_CONVERSION_MODE) {...}{.
+    importc: "SDL_SetYUVConversionMode", cdecl.}
+
+ +
\brief Set the YUV conversion mode
+ + +
+ +
proc getYUVConversionMode(): YUV_CONVERSION_MODE {...}{.
+    importc: "SDL_GetYUVConversionMode", cdecl.}
+
+ +
\brief Get the YUV conversion mode
+ + +
+ +
proc getYUVConversionModeForResolution(width: cint; height: cint): YUV_CONVERSION_MODE {...}{.
+    importc: "SDL_GetYUVConversionModeForResolution", cdecl.}
+
+ +
\brief Get the YUV conversion mode, returning the correct mode for the resolution when the current conversion mode is SDL_YUV_CONVERSION_AUTOMATIC
+ + +
+ +
proc getNumVideoDrivers(): cint {...}{.importc: "SDL_GetNumVideoDrivers", cdecl.}
+
+ +
Function prototypes
+\brief Get the number of video drivers compiled into SDL
+  
+  \sa SDL_GetVideoDriver()
+ + +
+ +
proc getVideoDriver(index: cint): cstring {...}{.importc: "SDL_GetVideoDriver", cdecl.}
+
+ +
\brief Get the name of a built in video driver.
+  
+  \note The video drivers are presented in the order in which they are
+        normally checked during initialization.
+  
+  \sa SDL_GetNumVideoDrivers()
+ + +
+ +
proc videoInit(driverName: cstring): cint {...}{.importc: "SDL_VideoInit", cdecl.}
+
+ +
\brief Initialize the video subsystem, optionally specifying a video driver.
+  
+  \param driver_name Initialize a specific driver by name, or NULL for the
+                     default video driver.
+  
+  \return 0 on success, -1 on error
+  
+  This function initializes the video subsystem; setting up a connection
+  to the window manager, etc, and determines the available display modes
+  and pixel formats, but does not initialize a window or graphics mode.
+  
+  \sa SDL_VideoQuit()
+ + +
+ +
proc videoQuit() {...}{.importc: "SDL_VideoQuit", cdecl.}
+
+ +
\brief Shuts down the video subsystem.
+  
+  This function closes all windows, and restores the original video mode.
+  
+  \sa SDL_VideoInit()
+ + +
+ +
proc getCurrentVideoDriver(): cstring {...}{.importc: "SDL_GetCurrentVideoDriver", cdecl.}
+
+ +
\brief Returns the name of the currently initialized video driver.
+  
+  \return The name of the current video driver or NULL if no driver
+          has been initialized
+  
+  \sa SDL_GetNumVideoDrivers()
+  \sa SDL_GetVideoDriver()
+ + +
+ +
proc getNumVideoDisplays(): cint {...}{.importc: "SDL_GetNumVideoDisplays", cdecl.}
+
+ +
\brief Returns the number of available video displays.
+  
+  \sa SDL_GetDisplayBounds()
+ + +
+ +
proc getDisplayName(displayIndex: cint): cstring {...}{.importc: "SDL_GetDisplayName",
+    cdecl.}
+
+ +
\brief Get the name of a display in UTF-8 encoding
+  
+  \return The name of a display, or NULL for an invalid display index.
+  
+  \sa SDL_GetNumVideoDisplays()
+ + +
+ +
proc getDisplayBounds(displayIndex: cint; rect: ptr Rect): cint {...}{.
+    importc: "SDL_GetDisplayBounds", cdecl.}
+
+ +
\brief Get the desktop area represented by a display, with the primary
+         display located at 0,0
+  
+  \return 0 on success, or -1 if the index is out of range.
+  
+  \sa SDL_GetNumVideoDisplays()
+ + +
+ +
proc getDisplayUsableBounds(displayIndex: cint; rect: ptr Rect): cint {...}{.
+    importc: "SDL_GetDisplayUsableBounds", cdecl.}
+
+ +
\brief Get the usable desktop area represented by a display, with the
+         primary display located at 0,0
+  
+  This is the same area as SDL_GetDisplayBounds() reports, but with portions
+  reserved by the system removed. For example, on Mac OS X, this subtracts
+  the area occupied by the menu bar and dock.
+  
+  Setting a window to be fullscreen generally bypasses these unusable areas,
+  so these are good guidelines for the maximum space available to a
+  non-fullscreen window.
+  
+  \return 0 on success, or -1 if the index is out of range.
+  
+  \sa SDL_GetDisplayBounds()
+  \sa SDL_GetNumVideoDisplays()
+ + +
+ +
proc getDisplayDPI(displayIndex: cint; ddpi: ptr cfloat; hdpi: ptr cfloat;
+                  vdpi: ptr cfloat): cint {...}{.importc: "SDL_GetDisplayDPI", cdecl.}
+
+ +
\brief Get the dots/pixels-per-inch for a display
+  
+  \note Diagonal, horizontal and vertical DPI can all be optionally
+        returned if the parameter is non-NULL.
+  
+  \return 0 on success, or -1 if no DPI information is available or the index is out of range.
+  
+  \sa SDL_GetNumVideoDisplays()
+ + +
+ +
proc getDisplayOrientation(displayIndex: cint): DisplayOrientation {...}{.
+    importc: "SDL_GetDisplayOrientation", cdecl.}
+
+ +
\brief Get the orientation of a display
+  
+  \return The orientation of the display, or SDL_ORIENTATION_UNKNOWN if it isn't available.
+  
+  \sa SDL_GetNumVideoDisplays()
+ + +
+ +
proc getNumDisplayModes(displayIndex: cint): cint {...}{.
+    importc: "SDL_GetNumDisplayModes", cdecl.}
+
+ +
\brief Returns the number of available display modes.
+  
+  \sa SDL_GetDisplayMode()
+ + +
+ +
proc getDisplayMode(displayIndex: cint; modeIndex: cint; mode: ptr DisplayMode): cint {...}{.
+    importc: "SDL_GetDisplayMode", cdecl.}
+
+ +
\brief Fill in information about a specific display mode.
+  
+  \note The display modes are sorted in this priority:
+        \li bits per pixel -> more colors to fewer colors
+        \li width -> largest to smallest
+        \li height -> largest to smallest
+        \li refresh rate -> highest to lowest
+  
+  \sa SDL_GetNumDisplayModes()
+ + +
+ +
proc getDesktopDisplayMode(displayIndex: cint; mode: ptr DisplayMode): cint {...}{.
+    importc: "SDL_GetDesktopDisplayMode", cdecl.}
+
+ +
\brief Fill in information about the desktop display mode.
+ + +
+ +
proc getCurrentDisplayMode(displayIndex: cint; mode: ptr DisplayMode): cint {...}{.
+    importc: "SDL_GetCurrentDisplayMode", cdecl.}
+
+ +
\brief Fill in information about the current display mode.
+ + +
+ +
proc getClosestDisplayMode(displayIndex: cint; mode: ptr DisplayMode;
+                          closest: ptr DisplayMode): ptr DisplayMode {...}{.
+    importc: "SDL_GetClosestDisplayMode", cdecl.}
+
+ +
\brief Get the closest match to the requested display mode.
+  
+  \param displayIndex The index of display from which mode should be queried.
+  \param mode The desired display mode
+  \param closest A pointer to a display mode to be filled in with the closest
+                 match of the available display modes.
+  
+  \return The passed in value \c closest, or NULL if no matching video mode
+          was available.
+  
+  The available display modes are scanned, and \c closest is filled in with the
+  closest mode matching the requested mode and returned.  The mode format and
+  refresh_rate default to the desktop mode if they are 0.  The modes are
+  scanned with size being first priority, format being second priority, and
+  finally checking the refresh_rate.  If all the available modes are too
+  small, then NULL is returned.
+  
+  \sa SDL_GetNumDisplayModes()
+  \sa SDL_GetDisplayMode()
+ + +
+ +
proc getWindowDisplayIndex(window: ptr Window): cint {...}{.
+    importc: "SDL_GetWindowDisplayIndex", cdecl.}
+
+ +
\brief Get the display index associated with a window.
+  
+  \return the display index of the display containing the center of the
+          window, or -1 on error.
+ + +
+ +
proc setWindowDisplayMode(window: ptr Window; mode: ptr DisplayMode): cint {...}{.
+    importc: "SDL_SetWindowDisplayMode", cdecl.}
+
+ +
\brief Set the display mode used when a fullscreen window is visible.
+  
+  By default the window's dimensions and the desktop format and refresh rate
+  are used.
+  
+  \param window The window for which the display mode should be set.
+  \param mode The mode to use, or NULL for the default mode.
+  
+  \return 0 on success, or -1 if setting the display mode failed.
+  
+  \sa SDL_GetWindowDisplayMode()
+  \sa SDL_SetWindowFullscreen()
+ + +
+ +
proc getWindowDisplayMode(window: ptr Window; mode: ptr DisplayMode): cint {...}{.
+    importc: "SDL_GetWindowDisplayMode", cdecl.}
+
+ +
\brief Fill in information about the display mode used when a fullscreen
+         window is visible.
+  
+  \sa SDL_SetWindowDisplayMode()
+  \sa SDL_SetWindowFullscreen()
+ + +
+ +
proc getWindowPixelFormat(window: ptr Window): Uint32 {...}{.
+    importc: "SDL_GetWindowPixelFormat", cdecl.}
+
+ +
\brief Get the pixel format associated with the window.
+ + +
+ +
proc createWindow(title: cstring; x: cint; y: cint; w: cint; h: cint; flags: Uint32): ptr Window {...}{.
+    importc: "SDL_CreateWindow", cdecl.}
+
+ +
\brief Create a window with the specified position, dimensions, and flags.
+  
+  \param title The title of the window, in UTF-8 encoding.
+  \param x     The x position of the window, ::SDL_WINDOWPOS_CENTERED, or
+               ::SDL_WINDOWPOS_UNDEFINED.
+  \param y     The y position of the window, ::SDL_WINDOWPOS_CENTERED, or
+               ::SDL_WINDOWPOS_UNDEFINED.
+  \param w     The width of the window, in screen coordinates.
+  \param h     The height of the window, in screen coordinates.
+  \param flags The flags for the window, a mask of any of the following:
+               ::SDL_WINDOW_FULLSCREEN,    ::SDL_WINDOW_OPENGL,
+               ::SDL_WINDOW_HIDDEN,        ::SDL_WINDOW_BORDERLESS,
+               ::SDL_WINDOW_RESIZABLE,     ::SDL_WINDOW_MAXIMIZED,
+               ::SDL_WINDOW_MINIMIZED,     ::SDL_WINDOW_INPUT_GRABBED,
+               ::SDL_WINDOW_ALLOW_HIGHDPI, ::SDL_WINDOW_VULKAN.
+  
+  \return The created window, or NULL if window creation failed.
+  
+  If the window is created with the SDL_WINDOW_ALLOW_HIGHDPI flag, its size
+  in pixels may differ from its size in screen coordinates on platforms with
+  high-DPI support (e.g. iOS and Mac OS X). Use SDL_GetWindowSize() to query
+  the client area's size in screen coordinates, and SDL_GL_GetDrawableSize(),
+  SDL_Vulkan_GetDrawableSize(), or SDL_GetRendererOutputSize() to query the
+  drawable size in pixels.
+  
+  If the window is created with any of the SDL_WINDOW_OPENGL or
+  SDL_WINDOW_VULKAN flags, then the corresponding LoadLibrary function
+  (SDL_GL_LoadLibrary or SDL_Vulkan_LoadLibrary) is called and the
+  corresponding UnloadLibrary function is called by SDL_DestroyWindow().
+  
+  If SDL_WINDOW_VULKAN is specified and there isn't a working Vulkan driver,
+  SDL_CreateWindow() will fail because SDL_Vulkan_LoadLibrary() will fail.
+  
+  \note On non-Apple devices, SDL requires you to either not link to the
+        Vulkan loader or link to a dynamic library version. This limitation
+        may be removed in a future version of SDL.
+  
+  \sa SDL_DestroyWindow()
+  \sa SDL_GL_LoadLibrary()
+  \sa SDL_Vulkan_LoadLibrary()
+ + +
+ +
proc createWindowFrom(data: pointer): ptr Window {...}{.importc: "SDL_CreateWindowFrom",
+    cdecl.}
+
+ +
\brief Create an SDL window from an existing native window.
+  
+  \param data A pointer to driver-dependent window creation data
+  
+  \return The created window, or NULL if window creation failed.
+  
+  \sa SDL_DestroyWindow()
+ + +
+ +
proc getWindowID(window: ptr Window): Uint32 {...}{.importc: "SDL_GetWindowID", cdecl.}
+
+ +
\brief Get the numeric ID of a window, for logging purposes.
+ + +
+ +
proc getWindowFromID(id: Uint32): ptr Window {...}{.importc: "SDL_GetWindowFromID", cdecl.}
+
+ +
\brief Get a window from a stored ID, or NULL if it doesn't exist.
+ + +
+ +
proc getWindowFlags(window: ptr Window): Uint32 {...}{.importc: "SDL_GetWindowFlags", cdecl.}
+
+ +
\brief Get the window flags.
+ + +
+ +
proc setWindowTitle(window: ptr Window; title: cstring) {...}{.
+    importc: "SDL_SetWindowTitle", cdecl.}
+
+ +
\brief Set the title of a window, in UTF-8 format.
+  
+  \sa SDL_GetWindowTitle()
+ + +
+ +
proc getWindowTitle(window: ptr Window): cstring {...}{.importc: "SDL_GetWindowTitle", cdecl.}
+
+ +
\brief Get the title of a window, in UTF-8 format.
+  
+  \sa SDL_SetWindowTitle()
+ + +
+ +
proc setWindowIcon(window: ptr Window; icon: ptr Surface) {...}{.
+    importc: "SDL_SetWindowIcon", cdecl.}
+
+ +
\brief Set the icon for a window.
+  
+  \param window The window for which the icon should be set.
+  \param icon The icon for the window.
+ + +
+ +
proc setWindowData(window: ptr Window; name: cstring; userdata: pointer): pointer {...}{.
+    importc: "SDL_SetWindowData", cdecl.}
+
+ +
\brief Associate an arbitrary named pointer with a window.
+  
+  \param window   The window to associate with the pointer.
+  \param name     The name of the pointer.
+  \param userdata The associated pointer.
+  
+  \return The previous value associated with 'name'
+  
+  \note The name is case-sensitive.
+  
+  \sa SDL_GetWindowData()
+ + +
+ +
proc getWindowData(window: ptr Window; name: cstring): pointer {...}{.
+    importc: "SDL_GetWindowData", cdecl.}
+
+ +
\brief Retrieve the data pointer associated with a window.
+  
+  \param window   The window to query.
+  \param name     The name of the pointer.
+  
+  \return The value associated with 'name'
+  
+  \sa SDL_SetWindowData()
+ + +
+ +
proc setWindowPosition(window: ptr Window; x: cint; y: cint) {...}{.
+    importc: "SDL_SetWindowPosition", cdecl.}
+
+ +
\brief Set the position of a window.
+  
+  \param window   The window to reposition.
+  \param x        The x coordinate of the window in screen coordinates, or
+                  ::SDL_WINDOWPOS_CENTERED or ::SDL_WINDOWPOS_UNDEFINED.
+  \param y        The y coordinate of the window in screen coordinates, or
+                  ::SDL_WINDOWPOS_CENTERED or ::SDL_WINDOWPOS_UNDEFINED.
+  
+  \note The window coordinate origin is the upper left of the display.
+  
+  \sa SDL_GetWindowPosition()
+ + +
+ +
proc getWindowPosition(window: ptr Window; x: ptr cint; y: ptr cint) {...}{.
+    importc: "SDL_GetWindowPosition", cdecl.}
+
+ +
\brief Get the position of a window.
+  
+  \param window   The window to query.
+  \param x        Pointer to variable for storing the x position, in screen
+                  coordinates. May be NULL.
+  \param y        Pointer to variable for storing the y position, in screen
+                  coordinates. May be NULL.
+  
+  \sa SDL_SetWindowPosition()
+ + +
+ +
proc setWindowSize(window: ptr Window; w: cint; h: cint) {...}{.importc: "SDL_SetWindowSize",
+    cdecl.}
+
+ +
\brief Set the size of a window's client area.
+  
+  \param window   The window to resize.
+  \param w        The width of the window, in screen coordinates. Must be >0.
+  \param h        The height of the window, in screen coordinates. Must be >0.
+  
+  \note Fullscreen windows automatically match the size of the display mode,
+        and you should use SDL_SetWindowDisplayMode() to change their size.
+  
+  The window size in screen coordinates may differ from the size in pixels, if
+  the window was created with SDL_WINDOW_ALLOW_HIGHDPI on a platform with
+  high-dpi support (e.g. iOS or OS X). Use SDL_GL_GetDrawableSize() or
+  SDL_GetRendererOutputSize() to get the real client area size in pixels.
+  
+  \sa SDL_GetWindowSize()
+  \sa SDL_SetWindowDisplayMode()
+ + +
+ +
proc getWindowSize(window: ptr Window; w: ptr cint; h: ptr cint) {...}{.
+    importc: "SDL_GetWindowSize", cdecl.}
+
+ +
\brief Get the size of a window's client area.
+  
+  \param window   The window to query.
+  \param w        Pointer to variable for storing the width, in screen
+                  coordinates. May be NULL.
+  \param h        Pointer to variable for storing the height, in screen
+                  coordinates. May be NULL.
+  
+  The window size in screen coordinates may differ from the size in pixels, if
+  the window was created with SDL_WINDOW_ALLOW_HIGHDPI on a platform with
+  high-dpi support (e.g. iOS or OS X). Use SDL_GL_GetDrawableSize() or
+  SDL_GetRendererOutputSize() to get the real client area size in pixels.
+  
+  \sa SDL_SetWindowSize()
+ + +
+ +
proc getWindowBordersSize(window: ptr Window; top: ptr cint; left: ptr cint;
+                         bottom: ptr cint; right: ptr cint): cint {...}{.
+    importc: "SDL_GetWindowBordersSize", cdecl.}
+
+ +
\brief Get the size of a window's borders (decorations) around the client area.
+  
+  \param window The window to query.
+  \param top Pointer to variable for storing the size of the top border. NULL is permitted.
+  \param left Pointer to variable for storing the size of the left border. NULL is permitted.
+  \param bottom Pointer to variable for storing the size of the bottom border. NULL is permitted.
+  \param right Pointer to variable for storing the size of the right border. NULL is permitted.
+  
+  \return 0 on success, or -1 if getting this information is not supported.
+  
+  \note if this function fails (returns -1), the size values will be
+        initialized to 0, 0, 0, 0 (if a non-NULL pointer is provided), as
+        if the window in question was borderless.
+ + +
+ +
proc setWindowMinimumSize(window: ptr Window; minW: cint; minH: cint) {...}{.
+    importc: "SDL_SetWindowMinimumSize", cdecl.}
+
+ +
\brief Set the minimum size of a window's client area.
+  
+  \param window    The window to set a new minimum size.
+  \param min_w     The minimum width of the window, must be >0
+  \param min_h     The minimum height of the window, must be >0
+  
+  \note You can't change the minimum size of a fullscreen window, it
+        automatically matches the size of the display mode.
+  
+  \sa SDL_GetWindowMinimumSize()
+  \sa SDL_SetWindowMaximumSize()
+ + +
+ +
proc getWindowMinimumSize(window: ptr Window; w: ptr cint; h: ptr cint) {...}{.
+    importc: "SDL_GetWindowMinimumSize", cdecl.}
+
+ +
\brief Get the minimum size of a window's client area.
+  
+  \param window   The window to query.
+  \param w        Pointer to variable for storing the minimum width, may be NULL
+  \param h        Pointer to variable for storing the minimum height, may be NULL
+  
+  \sa SDL_GetWindowMaximumSize()
+  \sa SDL_SetWindowMinimumSize()
+ + +
+ +
proc setWindowMaximumSize(window: ptr Window; maxW: cint; maxH: cint) {...}{.
+    importc: "SDL_SetWindowMaximumSize", cdecl.}
+
+ +
\brief Set the maximum size of a window's client area.
+  
+  \param window    The window to set a new maximum size.
+  \param max_w     The maximum width of the window, must be >0
+  \param max_h     The maximum height of the window, must be >0
+  
+  \note You can't change the maximum size of a fullscreen window, it
+        automatically matches the size of the display mode.
+  
+  \sa SDL_GetWindowMaximumSize()
+  \sa SDL_SetWindowMinimumSize()
+ + +
+ +
proc getWindowMaximumSize(window: ptr Window; w: ptr cint; h: ptr cint) {...}{.
+    importc: "SDL_GetWindowMaximumSize", cdecl.}
+
+ +
\brief Get the maximum size of a window's client area.
+  
+  \param window   The window to query.
+  \param w        Pointer to variable for storing the maximum width, may be NULL
+  \param h        Pointer to variable for storing the maximum height, may be NULL
+  
+  \sa SDL_GetWindowMinimumSize()
+  \sa SDL_SetWindowMaximumSize()
+ + +
+ +
proc setWindowBordered(window: ptr Window; bordered: bool) {...}{.
+    importc: "SDL_SetWindowBordered", cdecl.}
+
+ +
\brief Set the border state of a window.
+  
+  This will add or remove the window's SDL_WINDOW_BORDERLESS flag and
+  add or remove the border from the actual window. This is a no-op if the
+  window's border already matches the requested state.
+  
+  \param window The window of which to change the border state.
+  \param bordered SDL_FALSE to remove border, SDL_TRUE to add border.
+  
+  \note You can't change the border state of a fullscreen window.
+  
+  \sa SDL_GetWindowFlags()
+ + +
+ +
proc setWindowResizable(window: ptr Window; resizable: bool) {...}{.
+    importc: "SDL_SetWindowResizable", cdecl.}
+
+ +
\brief Set the user-resizable state of a window.
+  
+  This will add or remove the window's SDL_WINDOW_RESIZABLE flag and
+  allow/disallow user resizing of the window. This is a no-op if the
+  window's resizable state already matches the requested state.
+  
+  \param window The window of which to change the resizable state.
+  \param resizable SDL_TRUE to allow resizing, SDL_FALSE to disallow.
+  
+  \note You can't change the resizable state of a fullscreen window.
+  
+  \sa SDL_GetWindowFlags()
+ + +
+ +
proc showWindow(window: ptr Window) {...}{.importc: "SDL_ShowWindow", cdecl.}
+
+ +
\brief Show a window.
+  
+  \sa SDL_HideWindow()
+ + +
+ +
proc hideWindow(window: ptr Window) {...}{.importc: "SDL_HideWindow", cdecl.}
+
+ +
\brief Hide a window.
+  
+  \sa SDL_ShowWindow()
+ + +
+ +
proc raiseWindow(window: ptr Window) {...}{.importc: "SDL_RaiseWindow", cdecl.}
+
+ +
\brief Raise a window above other windows and set the input focus.
+ + +
+ +
proc maximizeWindow(window: ptr Window) {...}{.importc: "SDL_MaximizeWindow", cdecl.}
+
+ +
\brief Make a window as large as possible.
+  
+  \sa SDL_RestoreWindow()
+ + +
+ +
proc minimizeWindow(window: ptr Window) {...}{.importc: "SDL_MinimizeWindow", cdecl.}
+
+ +
\brief Minimize a window to an iconic representation.
+  
+  \sa SDL_RestoreWindow()
+ + +
+ +
proc restoreWindow(window: ptr Window) {...}{.importc: "SDL_RestoreWindow", cdecl.}
+
+ +
\brief Restore the size and position of a minimized or maximized window.
+  
+  \sa SDL_MaximizeWindow()
+  \sa SDL_MinimizeWindow()
+ + +
+ +
proc setWindowFullscreen(window: ptr Window; flags: Uint32): cint {...}{.
+    importc: "SDL_SetWindowFullscreen", cdecl.}
+
+ +
\brief Set a window's fullscreen state.
+  
+  \return 0 on success, or -1 if setting the display mode failed.
+  
+  \sa SDL_SetWindowDisplayMode()
+  \sa SDL_GetWindowDisplayMode()
+ + +
+ +
proc getWindowSurface(window: ptr Window): ptr Surface {...}{.
+    importc: "SDL_GetWindowSurface", cdecl.}
+
+ +
\brief Get the SDL surface associated with the window.
+  
+  \return The window's framebuffer surface, or NULL on error.
+  
+  A new surface will be created with the optimal format for the window,
+  if necessary. This surface will be freed when the window is destroyed.
+  
+  \note You may not combine this with 3D or the rendering API on this window.
+  
+  \sa SDL_UpdateWindowSurface()
+  \sa SDL_UpdateWindowSurfaceRects()
+ + +
+ +
proc updateWindowSurface(window: ptr Window): cint {...}{.
+    importc: "SDL_UpdateWindowSurface", cdecl.}
+
+ +
\brief Copy the window surface to the screen.
+  
+  \return 0 on success, or -1 on error.
+  
+  \sa SDL_GetWindowSurface()
+  \sa SDL_UpdateWindowSurfaceRects()
+ + +
+ +
proc updateWindowSurfaceRects(window: ptr Window; rects: ptr Rect; numrects: cint): cint {...}{.
+    importc: "SDL_UpdateWindowSurfaceRects", cdecl.}
+
+ +
\brief Copy a number of rectangles on the window surface to the screen.
+  
+  \return 0 on success, or -1 on error.
+  
+  \sa SDL_GetWindowSurface()
+  \sa SDL_UpdateWindowSurface()
+ + +
+ +
proc setWindowGrab(window: ptr Window; grabbed: bool) {...}{.importc: "SDL_SetWindowGrab",
+    cdecl.}
+
+ +
\brief Set a window's input grab mode.
+  
+  \param window The window for which the input grab mode should be set.
+  \param grabbed This is SDL_TRUE to grab input, and SDL_FALSE to release input.
+  
+  If the caller enables a grab while another window is currently grabbed,
+  the other window loses its grab in favor of the caller's window.
+  
+  \sa SDL_GetWindowGrab()
+ + +
+ +
proc getWindowGrab(window: ptr Window): bool {...}{.importc: "SDL_GetWindowGrab", cdecl.}
+
+ +
\brief Get a window's input grab mode.
+  
+  \return This returns SDL_TRUE if input is grabbed, and SDL_FALSE otherwise.
+  
+  \sa SDL_SetWindowGrab()
+ + +
+ +
proc getGrabbedWindow(): ptr Window {...}{.importc: "SDL_GetGrabbedWindow", cdecl.}
+
+ +
\brief Get the window that currently has an input grab enabled.
+  
+  \return This returns the window if input is grabbed, and NULL otherwise.
+  
+  \sa SDL_SetWindowGrab()
+ + +
+ +
proc setWindowBrightness(window: ptr Window; brightness: cfloat): cint {...}{.
+    importc: "SDL_SetWindowBrightness", cdecl.}
+
+ +
\brief Set the brightness (gamma correction) for a window.
+  
+  \return 0 on success, or -1 if setting the brightness isn't supported.
+  
+  \sa SDL_GetWindowBrightness()
+  \sa SDL_SetWindowGammaRamp()
+ + +
+ +
proc getWindowBrightness(window: ptr Window): cfloat {...}{.
+    importc: "SDL_GetWindowBrightness", cdecl.}
+
+ +
\brief Get the brightness (gamma correction) for a window.
+  
+  \return The last brightness value passed to SDL_SetWindowBrightness()
+  
+  \sa SDL_SetWindowBrightness()
+ + +
+ +
proc setWindowOpacity(window: ptr Window; opacity: cfloat): cint {...}{.
+    importc: "SDL_SetWindowOpacity", cdecl.}
+
+ +
\brief Set the opacity for a window
+  
+  \param window The window which will be made transparent or opaque
+  \param opacity Opacity (0.0f - transparent, 1.0f - opaque) This will be
+                 clamped internally between 0.0f and 1.0f.
+  
+  \return 0 on success, or -1 if setting the opacity isn't supported.
+  
+  \sa SDL_GetWindowOpacity()
+ + +
+ +
proc getWindowOpacity(window: ptr Window; outOpacity: ptr cfloat): cint {...}{.
+    importc: "SDL_GetWindowOpacity", cdecl.}
+
+ +
\brief Get the opacity of a window.
+  
+  If transparency isn't supported on this platform, opacity will be reported
+  as 1.0f without error.
+  
+  \param window The window in question.
+  \param out_opacity Opacity (0.0f - transparent, 1.0f - opaque)
+  
+  \return 0 on success, or -1 on error (invalid window, etc).
+  
+  \sa SDL_SetWindowOpacity()
+ + +
+ +
proc setWindowModalFor(modalWindow: ptr Window; parentWindow: ptr Window): cint {...}{.
+    importc: "SDL_SetWindowModalFor", cdecl.}
+
+ +
\brief Sets the window as a modal for another window (TODO: reconsider this function and/or its name)
+  
+  \param modal_window The window that should be modal
+  \param parent_window The parent window
+  
+  \return 0 on success, or -1 otherwise.
+ + +
+ +
proc setWindowInputFocus(window: ptr Window): cint {...}{.
+    importc: "SDL_SetWindowInputFocus", cdecl.}
+
+ +
\brief Explicitly sets input focus to the window.
+  
+  You almost certainly want SDL_RaiseWindow() instead of this function. Use
+  this with caution, as you might give focus to a window that's completely
+  obscured by other windows.
+  
+  \param window The window that should get the input focus
+  
+  \return 0 on success, or -1 otherwise.
+  \sa SDL_RaiseWindow()
+ + +
+ +
proc setWindowGammaRamp(window: ptr Window; red: ptr Uint16; green: ptr Uint16;
+                       blue: ptr Uint16): cint {...}{.importc: "SDL_SetWindowGammaRamp",
+    cdecl.}
+
+ +
\brief Set the gamma ramp for a window.
+  
+  \param window The window for which the gamma ramp should be set.
+  \param red The translation table for the red channel, or NULL.
+  \param green The translation table for the green channel, or NULL.
+  \param blue The translation table for the blue channel, or NULL.
+  
+  \return 0 on success, or -1 if gamma ramps are unsupported.
+  
+  Set the gamma translation table for the red, green, and blue channels
+  of the video hardware.  Each table is an array of 256 16-bit quantities,
+  representing a mapping between the input and output for that channel.
+  The input is the index into the array, and the output is the 16-bit
+  gamma value at that index, scaled to the output color precision.
+  
+  \sa SDL_GetWindowGammaRamp()
+ + +
+ +
proc getWindowGammaRamp(window: ptr Window; red: ptr Uint16; green: ptr Uint16;
+                       blue: ptr Uint16): cint {...}{.importc: "SDL_GetWindowGammaRamp",
+    cdecl.}
+
+ +
\brief Get the gamma ramp for a window.
+  
+  \param window The window from which the gamma ramp should be queried.
+  \param red   A pointer to a 256 element array of 16-bit quantities to hold
+               the translation table for the red channel, or NULL.
+  \param green A pointer to a 256 element array of 16-bit quantities to hold
+               the translation table for the green channel, or NULL.
+  \param blue  A pointer to a 256 element array of 16-bit quantities to hold
+               the translation table for the blue channel, or NULL.
+  
+  \return 0 on success, or -1 if gamma ramps are unsupported.
+  
+  \sa SDL_SetWindowGammaRamp()
+ + +
+ +
proc setWindowHitTest(window: ptr Window; callback: HitTest; callbackData: pointer): cint {...}{.
+    importc: "SDL_SetWindowHitTest", cdecl.}
+
+ +
\brief Provide a callback that decides if a window region has special properties.
+  
+  Normally windows are dragged and resized by decorations provided by the
+  system window manager (a title bar, borders, etc), but for some apps, it
+  makes sense to drag them from somewhere else inside the window itself; for
+  example, one might have a borderless window that wants to be draggable
+  from any part, or simulate its own title bar, etc.
+  
+  This function lets the app provide a callback that designates pieces of
+  a given window as special. This callback is run during event processing
+  if we need to tell the OS to treat a region of the window specially; the
+  use of this callback is known as "hit testing."
+  
+  Mouse input may not be delivered to your application if it is within
+  a special area; the OS will often apply that input to moving the window or
+  resizing the window and not deliver it to the application.
+  
+  Specifying NULL for a callback disables hit-testing. Hit-testing is
+  disabled by default.
+  
+  Platforms that don't support this functionality will return -1
+  unconditionally, even if you're attempting to disable hit-testing.
+  
+  Your callback may fire at any time, and its firing does not indicate any
+  specific behavior (for example, on Windows, this certainly might fire
+  when the OS is deciding whether to drag your window, but it fires for lots
+  of other reasons, too, some unrelated to anything you probably care about
+  _and when the mouse isn't actually at the location it is testing_).
+  Since this can fire at any time, you should try to keep your callback
+  efficient, devoid of allocations, etc.
+  
+  \param window The window to set hit-testing on.
+  \param callback The callback to call when doing a hit-test.
+  \param callback_data An app-defined void pointer passed to the callback.
+  \return 0 on success, -1 on error (including unsupported).
+ + +
+ +
proc destroyWindow(window: ptr Window) {...}{.importc: "SDL_DestroyWindow", cdecl.}
+
+ +
\brief Destroy a window.
+ + +
+ +
proc isScreenSaverEnabled(): bool {...}{.importc: "SDL_IsScreenSaverEnabled", cdecl.}
+
+ +
\brief Returns whether the screensaver is currently enabled (default off).
+  
+  \sa SDL_EnableScreenSaver()
+  \sa SDL_DisableScreenSaver()
+ + +
+ +
proc enableScreenSaver() {...}{.importc: "SDL_EnableScreenSaver", cdecl.}
+
+ +
\brief Allow the screen to be blanked by a screensaver
+  
+  \sa SDL_IsScreenSaverEnabled()
+  \sa SDL_DisableScreenSaver()
+ + +
+ +
proc disableScreenSaver() {...}{.importc: "SDL_DisableScreenSaver", cdecl.}
+
+ +
\brief Prevent the screen from being blanked by a screensaver
+  
+  \sa SDL_IsScreenSaverEnabled()
+  \sa SDL_EnableScreenSaver()
+ + +
+ +
proc gL_LoadLibrary(path: cstring): cint {...}{.importc: "SDL_GL_LoadLibrary", cdecl.}
+
+ +
\name OpenGL support functions
+@{
+\brief Dynamically load an OpenGL library.
+  
+  \param path The platform dependent OpenGL library name, or NULL to open the
+              default OpenGL library.
+  
+  \return 0 on success, or -1 if the library couldn't be loaded.
+  
+  This should be done after initializing the video driver, but before
+  creating any OpenGL windows.  If no OpenGL library is loaded, the default
+  library will be loaded upon creation of the first OpenGL window.
+  
+  \note If you do this, you need to retrieve all of the GL functions used in
+        your program from the dynamic library using SDL_GL_GetProcAddress().
+  
+  \sa SDL_GL_GetProcAddress()
+  \sa SDL_GL_UnloadLibrary()
+ + +
+ +
proc gL_GetProcAddress(`proc`: cstring): pointer {...}{.importc: "SDL_GL_GetProcAddress",
+    cdecl.}
+
+ +
\brief Get the address of an OpenGL function.
+ + +
+ +
proc gL_UnloadLibrary() {...}{.importc: "SDL_GL_UnloadLibrary", cdecl.}
+
+ +
\brief Unload the OpenGL library previously loaded by SDL_GL_LoadLibrary().
+  
+  \sa SDL_GL_LoadLibrary()
+ + +
+ +
proc gL_ExtensionSupported(extension: cstring): bool {...}{.
+    importc: "SDL_GL_ExtensionSupported", cdecl.}
+
+ +
\brief Return true if an OpenGL extension is supported for the current
+         context.
+ + +
+ +
proc gL_ResetAttributes() {...}{.importc: "SDL_GL_ResetAttributes", cdecl.}
+
+ +
\brief Reset all previously set OpenGL context attributes to their default values
+ + +
+ +
proc gL_SetAttribute(attr: GLattr; value: cint): cint {...}{.
+    importc: "SDL_GL_SetAttribute", cdecl.}
+
+ +
\brief Set an OpenGL window attribute before window creation.
+  
+  \return 0 on success, or -1 if the attribute could not be set.
+ + +
+ +
proc gL_GetAttribute(attr: GLattr; value: ptr cint): cint {...}{.
+    importc: "SDL_GL_GetAttribute", cdecl.}
+
+ +
\brief Get the actual value for an attribute from the current context.
+  
+  \return 0 on success, or -1 if the attribute could not be retrieved.
+          The integer at \c value will be modified in either case.
+ + +
+ +
proc gL_CreateContext(window: ptr Window): GLContext {...}{.
+    importc: "SDL_GL_CreateContext", cdecl.}
+
+ +
\brief Create an OpenGL context for use with an OpenGL window, and make it
+         current.
+  
+  \sa SDL_GL_DeleteContext()
+ + +
+ +
proc gL_MakeCurrent(window: ptr Window; context: GLContext): cint {...}{.
+    importc: "SDL_GL_MakeCurrent", cdecl.}
+
+ +
\brief Set up an OpenGL context for rendering into an OpenGL window.
+  
+  \note The context must have been created with a compatible window.
+ + +
+ +
proc gL_GetCurrentWindow(): ptr Window {...}{.importc: "SDL_GL_GetCurrentWindow", cdecl.}
+
+ +
\brief Get the currently active OpenGL window.
+ + +
+ +
proc gL_GetCurrentContext(): GLContext {...}{.importc: "SDL_GL_GetCurrentContext", cdecl.}
+
+ +
\brief Get the currently active OpenGL context.
+ + +
+ +
proc gL_GetDrawableSize(window: ptr Window; w: ptr cint; h: ptr cint) {...}{.
+    importc: "SDL_GL_GetDrawableSize", cdecl.}
+
+ +
\brief Get the size of a window's underlying drawable in pixels (for use
+         with glViewport).
+  
+  \param window   Window from which the drawable size should be queried
+  \param w        Pointer to variable for storing the width in pixels, may be NULL
+  \param h        Pointer to variable for storing the height in pixels, may be NULL
+ 
+ This may differ from SDL_GetWindowSize() if we're rendering to a high-DPI
+ drawable, i.e. the window was created with SDL_WINDOW_ALLOW_HIGHDPI on a
+ platform with high-DPI support (Apple calls this "Retina"), and not disabled
+ by the SDL_HINT_VIDEO_HIGHDPI_DISABLED hint.
+  
+  \sa SDL_GetWindowSize()
+  \sa SDL_CreateWindow()
+ + +
+ +
proc gL_SetSwapInterval(interval: cint): cint {...}{.importc: "SDL_GL_SetSwapInterval",
+    cdecl.}
+
+ +
\brief Set the swap interval for the current OpenGL context.
+  
+  \param interval 0 for immediate updates, 1 for updates synchronized with the
+                  vertical retrace. If the system supports it, you may
+                  specify -1 to allow late swaps to happen immediately
+                  instead of waiting for the next retrace.
+  
+  \return 0 on success, or -1 if setting the swap interval is not supported.
+  
+  \sa SDL_GL_GetSwapInterval()
+ + +
+ +
proc gL_GetSwapInterval(): cint {...}{.importc: "SDL_GL_GetSwapInterval", cdecl.}
+
+ +
\brief Get the swap interval for the current OpenGL context.
+  
+  \return 0 if there is no vertical retrace synchronization, 1 if the buffer
+          swap is synchronized with the vertical retrace, and -1 if late
+          swaps happen immediately instead of waiting for the next retrace.
+          If the system can't determine the swap interval, or there isn't a
+          valid current context, this will return 0 as a safe default.
+  
+  \sa SDL_GL_SetSwapInterval()
+ + +
+ +
proc gL_SwapWindow(window: ptr Window) {...}{.importc: "SDL_GL_SwapWindow", cdecl.}
+
+ +
\brief Swap the OpenGL buffers for a window, if double-buffering is
+        supported.
+ + +
+ +
proc gL_DeleteContext(context: GLContext) {...}{.importc: "SDL_GL_DeleteContext", cdecl.}
+
+ +
\brief Delete an OpenGL context.
+  
+  \sa SDL_GL_CreateContext()
+ + +
+ +
proc getKeyboardFocus(): ptr Window {...}{.importc: "SDL_GetKeyboardFocus", cdecl.}
+
+ +
Function prototypes
+\brief Get the window which currently has keyboard focus.
+ + +
+ +
proc getKeyboardState(numkeys: ptr cint): ptr Uint8 {...}{.importc: "SDL_GetKeyboardState",
+    cdecl.}
+
+ +
\brief Get a snapshot of the current state of the keyboard.
+  
+  \param numkeys if non-NULL, receives the length of the returned array.
+  
+  \return An array of key states. Indexes into this array are obtained by using ::SDL_Scancode values.
+  
+  \b Example:
+  \code
+  const Uint8state = SDL_GetKeyboardState(NULL);
+  if ( state[SDL_SCANCODE_RETURN] )   {
+      printf("<RETURN> is pressed.\n");
+  }
+  \endcode
+ + +
+ +
proc getModState(): Keymod {...}{.importc: "SDL_GetModState", cdecl.}
+
+ +
\brief Get the current key modifier state for the keyboard.
+ + +
+ +
proc setModState(modstate: Keymod) {...}{.importc: "SDL_SetModState", cdecl.}
+
+ +
\brief Set the current key modifier state for the keyboard.
+  
+  \note This does not change the keyboard state, only the key modifier flags.
+ + +
+ +
proc getKeyFromScancode(scancode: Scancode): Keycode {...}{.
+    importc: "SDL_GetKeyFromScancode", cdecl.}
+
+ +
\brief Get the key code corresponding to the given scancode according
+         to the current keyboard layout.
+  
+  See ::SDL_Keycode for details.
+  
+  \sa SDL_GetKeyName()
+ + +
+ +
proc getScancodeFromKey(key: Keycode): Scancode {...}{.importc: "SDL_GetScancodeFromKey",
+    cdecl.}
+
+ +
\brief Get the scancode corresponding to the given key code according to the
+         current keyboard layout.
+  
+  See ::SDL_Scancode for details.
+  
+  \sa SDL_GetScancodeName()
+ + +
+ +
proc getScancodeName(scancode: Scancode): cstring {...}{.importc: "SDL_GetScancodeName",
+    cdecl.}
+
+ +
\brief Get a human-readable name for a scancode.
+  
+  \return A pointer to the name for the scancode.
+          If the scancode doesn't have a name, this function returns
+          an empty string ("").
+  
+  \sa SDL_Scancode
+ + +
+ +
proc getScancodeFromName(name: cstring): Scancode {...}{.
+    importc: "SDL_GetScancodeFromName", cdecl.}
+
+ +
\brief Get a scancode from a human-readable name
+  
+  \return scancode, or SDL_SCANCODE_UNKNOWN if the name wasn't recognized
+  
+  \sa SDL_Scancode
+ + +
+ +
proc getKeyName(key: Keycode): cstring {...}{.importc: "SDL_GetKeyName", cdecl.}
+
+ +
\brief Get a human-readable name for a key.
+  
+  \return A pointer to a UTF-8 string that stays valid at least until the next
+          call to this function. If you need it around any longer, you must
+          copy it.  If the key doesn't have a name, this function returns an
+          empty string ("").
+  
+  \sa SDL_Keycode
+ + +
+ +
proc getKeyFromName(name: cstring): Keycode {...}{.importc: "SDL_GetKeyFromName", cdecl.}
+
+ +
\brief Get a key code from a human-readable name
+  
+  \return key code, or SDLK_UNKNOWN if the name wasn't recognized
+  
+  \sa SDL_Keycode
+ + +
+ +
proc startTextInput() {...}{.importc: "SDL_StartTextInput", cdecl.}
+
+ +
\brief Start accepting Unicode text input events.
+         This function will show the on-screen keyboard if supported.
+  
+  \sa SDL_StopTextInput()
+  \sa SDL_SetTextInputRect()
+  \sa SDL_HasScreenKeyboardSupport()
+ + +
+ +
proc isTextInputActive(): bool {...}{.importc: "SDL_IsTextInputActive", cdecl.}
+
+ +
\brief Return whether or not Unicode text input events are enabled.
+  
+  \sa SDL_StartTextInput()
+  \sa SDL_StopTextInput()
+ + +
+ +
proc stopTextInput() {...}{.importc: "SDL_StopTextInput", cdecl.}
+
+ +
\brief Stop receiving any text input events.
+         This function will hide the on-screen keyboard if supported.
+  
+  \sa SDL_StartTextInput()
+  \sa SDL_HasScreenKeyboardSupport()
+ + +
+ +
proc setTextInputRect(rect: ptr Rect) {...}{.importc: "SDL_SetTextInputRect", cdecl.}
+
+ +
\brief Set the rectangle used to type Unicode text inputs.
+         This is used as a hint for IME and on-screen keyboard placement.
+  
+  \sa SDL_StartTextInput()
+ + +
+ +
proc hasScreenKeyboardSupport(): bool {...}{.importc: "SDL_HasScreenKeyboardSupport",
+                                     cdecl.}
+
+ +
\brief Returns whether the platform has some screen keyboard support.
+  
+  \return SDL_TRUE if some keyboard support is available else SDL_FALSE.
+  
+  \note Not all screen keyboard functions are supported on all platforms.
+  
+  \sa SDL_IsScreenKeyboardShown()
+ + +
+ +
proc isScreenKeyboardShown(window: ptr Window): bool {...}{.
+    importc: "SDL_IsScreenKeyboardShown", cdecl.}
+
+ +
\brief Returns whether the screen keyboard is shown for given window.
+  
+  \param window The window for which screen keyboard should be queried.
+  
+  \return SDL_TRUE if screen keyboard is shown else SDL_FALSE.
+  
+  \sa SDL_HasScreenKeyboardSupport()
+ + +
+ +
proc getMouseFocus(): ptr Window {...}{.importc: "SDL_GetMouseFocus", cdecl.}
+
+ +
Function prototypes
+\brief Get the window which currently has mouse focus.
+ + +
+ +
proc getMouseState(x: ptr cint; y: ptr cint): Uint32 {...}{.importc: "SDL_GetMouseState", cdecl.}
+
+ +
\brief Retrieve the current state of the mouse.
+  
+  The current button state is returned as a button bitmask, which can
+  be tested using the SDL_BUTTON(X) macros, and x and y are set to the
+  mouse cursor position relative to the focus window for the currently
+  selected mouse.  You can pass NULL for either x or y.
+ + +
+ +
proc getGlobalMouseState(x: ptr cint; y: ptr cint): Uint32 {...}{.
+    importc: "SDL_GetGlobalMouseState", cdecl.}
+
+ +
\brief Get the current state of the mouse, in relation to the desktop
+  
+  This works just like SDL_GetMouseState(), but the coordinates will be
+  reported relative to the top-left of the desktop. This can be useful if
+  you need to track the mouse outside of a specific window and
+  SDL_CaptureMouse() doesn't fit your needs. For example, it could be
+  useful if you need to track the mouse while dragging a window, where
+  coordinates relative to a window might not be in sync at all times.
+  
+  \note SDL_GetMouseState() returns the mouse position as SDL understands
+        it from the last pump of the event queue. This function, however,
+        queries the OS for the current mouse position, and as such, might
+        be a slightly less efficient function. Unless you know what you're
+        doing and have a good reason to use this function, you probably want
+        SDL_GetMouseState() instead.
+  
+  \param x Returns the current X coord, relative to the desktop. Can be NULL.
+  \param y Returns the current Y coord, relative to the desktop. Can be NULL.
+  \return The current button state as a bitmask, which can be tested using the SDL_BUTTON(X) macros.
+  
+  \sa SDL_GetMouseState
+ + +
+ +
proc getRelativeMouseState(x: ptr cint; y: ptr cint): Uint32 {...}{.
+    importc: "SDL_GetRelativeMouseState", cdecl.}
+
+ +
\brief Retrieve the relative state of the mouse.
+  
+  The current button state is returned as a button bitmask, which can
+  be tested using the SDL_BUTTON(X) macros, and x and y are set to the
+  mouse deltas since the last call to SDL_GetRelativeMouseState().
+ + +
+ +
proc warpMouseInWindow(window: ptr Window; x: cint; y: cint) {...}{.
+    importc: "SDL_WarpMouseInWindow", cdecl.}
+
+ +
\brief Moves the mouse to the given position within the window.
+  
+  \param window The window to move the mouse into, or NULL for the current mouse focus
+  \param x The x coordinate within the window
+  \param y The y coordinate within the window
+  
+  \note This function generates a mouse motion event
+ + +
+ +
proc warpMouseGlobal(x: cint; y: cint): cint {...}{.importc: "SDL_WarpMouseGlobal", cdecl.}
+
+ +
\brief Moves the mouse to the given position in global screen space.
+  
+  \param x The x coordinate
+  \param y The y coordinate
+  \return 0 on success, -1 on error (usually: unsupported by a platform).
+  
+  \note This function generates a mouse motion event
+ + +
+ +
proc setRelativeMouseMode(enabled: bool): cint {...}{.
+    importc: "SDL_SetRelativeMouseMode", cdecl.}
+
+ +
\brief Set relative mouse mode.
+  
+  \param enabled Whether or not to enable relative mode
+  
+  \return 0 on success, or -1 if relative mode is not supported.
+  
+  While the mouse is in relative mode, the cursor is hidden, and the
+  driver will try to report continuous motion in the current window.
+  Only relative motion events will be delivered, the mouse position
+  will not change.
+  
+  \note This function will flush any pending mouse motion.
+  
+  \sa SDL_GetRelativeMouseMode()
+ + +
+ +
proc captureMouse(enabled: bool): cint {...}{.importc: "SDL_CaptureMouse", cdecl.}
+
+ +
\brief Capture the mouse, to track input outside an SDL window.
+  
+  \param enabled Whether or not to enable capturing
+  
+  Capturing enables your app to obtain mouse events globally, instead of
+  just within your window. Not all video targets support this function.
+  When capturing is enabled, the current window will get all mouse events,
+  but unlike relative mode, no change is made to the cursor and it is
+  not restrained to your window.
+  
+  This function may also deny mouse input to other windows--both those in
+  your application and others on the system--so you should use this
+  function sparingly, and in small bursts. For example, you might want to
+  track the mouse while the user is dragging something, until the user
+  releases a mouse button. It is not recommended that you capture the mouse
+  for long periods of time, such as the entire time your app is running.
+  
+  While captured, mouse events still report coordinates relative to the
+  current (foreground) window, but those coordinates may be outside the
+  bounds of the window (including negative values). Capturing is only
+  allowed for the foreground window. If the window loses focus while
+  capturing, the capture will be disabled automatically.
+  
+  While capturing is enabled, the current window will have the
+  SDL_WINDOW_MOUSE_CAPTURE flag set.
+  
+  \return 0 on success, or -1 if not supported.
+ + +
+ +
proc getRelativeMouseMode(): bool {...}{.importc: "SDL_GetRelativeMouseMode", cdecl.}
+
+ +
\brief Query whether relative mouse mode is enabled.
+  
+  \sa SDL_SetRelativeMouseMode()
+ + +
+ +
proc createCursor(data: ptr Uint8; mask: ptr Uint8; w: cint; h: cint; hotX: cint; hotY: cint): ptr Cursor {...}{.
+    importc: "SDL_CreateCursor", cdecl.}
+
+ +
\brief Create a cursor, using the specified bitmap data and
+         mask (in MSB format).
+  
+  The cursor width must be a multiple of 8 bits.
+  
+  The cursor is created in black and white according to the following:
+  <table>
+  <tr><td> data </td><td> mask </td><td> resulting pixel on screen </td></tr>
+  <tr><td>  0   </td><td>  1   </td><td> White </td></tr>
+  <tr><td>  1   </td><td>  1   </td><td> Black </td></tr>
+  <tr><td>  0   </td><td>  0   </td><td> Transparent </td></tr>
+  <tr><td>  1   </td><td>  0   </td><td> Inverted color if possible, black
+                                         if not. </td></tr>
+  </table>
+  
+  \sa SDL_FreeCursor()
+ + +
+ +
proc createColorCursor(surface: ptr Surface; hotX: cint; hotY: cint): ptr Cursor {...}{.
+    importc: "SDL_CreateColorCursor", cdecl.}
+
+ +
\brief Create a color cursor.
+  
+  \sa SDL_FreeCursor()
+ + +
+ +
proc createSystemCursor(id: SystemCursor): ptr Cursor {...}{.
+    importc: "SDL_CreateSystemCursor", cdecl.}
+
+ +
\brief Create a system cursor.
+  
+  \sa SDL_FreeCursor()
+ + +
+ +
proc setCursor(cursor: ptr Cursor) {...}{.importc: "SDL_SetCursor", cdecl.}
+
+ +
\brief Set the active cursor.
+ + +
+ +
proc getCursor(): ptr Cursor {...}{.importc: "SDL_GetCursor", cdecl.}
+
+ +
\brief Return the active cursor.
+ + +
+ +
proc getDefaultCursor(): ptr Cursor {...}{.importc: "SDL_GetDefaultCursor", cdecl.}
+
+ +
\brief Return the default cursor.
+ + +
+ +
proc freeCursor(cursor: ptr Cursor) {...}{.importc: "SDL_FreeCursor", cdecl.}
+
+ +
\brief Frees a cursor created with SDL_CreateCursor() or similar functions.
+  
+  \sa SDL_CreateCursor()
+  \sa SDL_CreateColorCursor()
+  \sa SDL_CreateSystemCursor()
+ + +
+ +
proc showCursor(toggle: cint): cint {...}{.importc: "SDL_ShowCursor", cdecl.}
+
+ +
\brief Toggle whether or not the cursor is shown.
+  
+  \param toggle 1 to show the cursor, 0 to hide it, -1 to query the current
+                state.
+  
+  \return 1 if the cursor is shown, or 0 if the cursor is hidden.
+ + +
+ +
proc lockJoysticks() {...}{.importc: "SDL_LockJoysticks", cdecl.}
+
+ +
Function prototypes
+Locking for multi-threaded access to the joystick API
+ 
+ If you are using the joystick API or handling events from multiple threads
+ you should use these locking functions to protect access to the joysticks.
+ 
+ In particular, you are guaranteed that the joystick list won't change, so
+ the API functions that take a joystick index will be valid, and joystick
+ and game controller events will not be delivered.
+ + +
+ +
proc unlockJoysticks() {...}{.importc: "SDL_UnlockJoysticks", cdecl.}
+
+ + + +
+ +
proc numJoysticks(): cint {...}{.importc: "SDL_NumJoysticks", cdecl.}
+
+ +
Count the number of joysticks attached to the system right now
+ + +
+ +
proc joystickNameForIndex(deviceIndex: cint): cstring {...}{.
+    importc: "SDL_JoystickNameForIndex", cdecl.}
+
+ +
Get the implementation dependent name of a joystick.
+  This can be called before any joysticks are opened.
+  If no name can be found, this function returns NULL.
+ + +
+ +
proc joystickGetDevicePlayerIndex(deviceIndex: cint): cint {...}{.
+    importc: "SDL_JoystickGetDevicePlayerIndex", cdecl.}
+
+ +
Get the player index of a joystick, or -1 if it's not available
+  This can be called before any joysticks are opened.
+ + +
+ +
proc joystickGetDeviceGUID(deviceIndex: cint): JoystickGUID {...}{.
+    importc: "SDL_JoystickGetDeviceGUID", cdecl.}
+
+ +
Return the GUID for the joystick at this index
+  This can be called before any joysticks are opened.
+ + +
+ +
proc joystickGetDeviceVendor(deviceIndex: cint): Uint16 {...}{.
+    importc: "SDL_JoystickGetDeviceVendor", cdecl.}
+
+ +
Get the USB vendor ID of a joystick, if available.
+  This can be called before any joysticks are opened.
+  If the vendor ID isn't available this function returns 0.
+ + +
+ +
proc joystickGetDeviceProduct(deviceIndex: cint): Uint16 {...}{.
+    importc: "SDL_JoystickGetDeviceProduct", cdecl.}
+
+ +
Get the USB product ID of a joystick, if available.
+  This can be called before any joysticks are opened.
+  If the product ID isn't available this function returns 0.
+ + +
+ +
proc joystickGetDeviceProductVersion(deviceIndex: cint): Uint16 {...}{.
+    importc: "SDL_JoystickGetDeviceProductVersion", cdecl.}
+
+ +
Get the product version of a joystick, if available.
+  This can be called before any joysticks are opened.
+  If the product version isn't available this function returns 0.
+ + +
+ +
proc joystickGetDeviceType(deviceIndex: cint): JoystickType {...}{.
+    importc: "SDL_JoystickGetDeviceType", cdecl.}
+
+ +
Get the type of a joystick, if available.
+  This can be called before any joysticks are opened.
+ + +
+ +
proc joystickGetDeviceInstanceID(deviceIndex: cint): JoystickID {...}{.
+    importc: "SDL_JoystickGetDeviceInstanceID", cdecl.}
+
+ +
Get the instance ID of a joystick.
+  This can be called before any joysticks are opened.
+  If the index is out of range, this function will return -1.
+ + +
+ +
proc joystickOpen(deviceIndex: cint): ptr Joystick {...}{.importc: "SDL_JoystickOpen", cdecl.}
+
+ +
Open a joystick for use.
+  The index passed as an argument refers to the N'th joystick on the system.
+  This index is not the value which will identify this joystick in future
+  joystick events.  The joystick's instance id (::SDL_JoystickID) will be used
+  there instead.
+  
+  \return A joystick identifier, or NULL if an error occurred.
+ + +
+ +
proc joystickFromInstanceID(instanceId: JoystickID): ptr Joystick {...}{.
+    importc: "SDL_JoystickFromInstanceID", cdecl.}
+
+ +
Return the SDL_Joystick associated with an instance id.
+ + +
+ +
proc joystickFromPlayerIndex(playerIndex: cint): ptr Joystick {...}{.
+    importc: "SDL_JoystickFromPlayerIndex", cdecl.}
+
+ +
Return the SDL_Joystick associated with a player index.
+ + +
+ +
proc joystickName(joystick: ptr Joystick): cstring {...}{.importc: "SDL_JoystickName", cdecl.}
+
+ +
Return the name for this currently opened joystick.
+  If no name can be found, this function returns NULL.
+ + +
+ +
proc joystickGetPlayerIndex(joystick: ptr Joystick): cint {...}{.
+    importc: "SDL_JoystickGetPlayerIndex", cdecl.}
+
+ +
Get the player index of an opened joystick, or -1 if it's not available
+  
+  For XInput controllers this returns the XInput user index.
+ + +
+ +
proc joystickSetPlayerIndex(joystick: ptr Joystick; playerIndex: cint) {...}{.
+    importc: "SDL_JoystickSetPlayerIndex", cdecl.}
+
+ +
Set the player index of an opened joystick
+ + +
+ +
proc joystickGetGUID(joystick: ptr Joystick): JoystickGUID {...}{.
+    importc: "SDL_JoystickGetGUID", cdecl.}
+
+ +
Return the GUID for this opened joystick
+ + +
+ +
proc joystickGetVendor(joystick: ptr Joystick): Uint16 {...}{.
+    importc: "SDL_JoystickGetVendor", cdecl.}
+
+ +
Get the USB vendor ID of an opened joystick, if available.
+  If the vendor ID isn't available this function returns 0.
+ + +
+ +
proc joystickGetProduct(joystick: ptr Joystick): Uint16 {...}{.
+    importc: "SDL_JoystickGetProduct", cdecl.}
+
+ +
Get the USB product ID of an opened joystick, if available.
+  If the product ID isn't available this function returns 0.
+ + +
+ +
proc joystickGetProductVersion(joystick: ptr Joystick): Uint16 {...}{.
+    importc: "SDL_JoystickGetProductVersion", cdecl.}
+
+ +
Get the product version of an opened joystick, if available.
+  If the product version isn't available this function returns 0.
+ + +
+ +
proc joystickGetType(joystick: ptr Joystick): JoystickType {...}{.
+    importc: "SDL_JoystickGetType", cdecl.}
+
+ +
Get the type of an opened joystick.
+ + +
+ +
proc joystickGetGUIDString(guid: JoystickGUID; pszGUID: cstring; cbGUID: cint) {...}{.
+    importc: "SDL_JoystickGetGUIDString", cdecl.}
+
+ +
Return a string representation for this guid. pszGUID must point to at least 33 bytes
+  (32 for the string plus a NULL terminator).
+ + +
+ +
proc joystickGetGUIDFromString(pchGUID: cstring): JoystickGUID {...}{.
+    importc: "SDL_JoystickGetGUIDFromString", cdecl.}
+
+ +
Convert a string into a joystick guid
+ + +
+ +
proc joystickGetAttached(joystick: ptr Joystick): bool {...}{.
+    importc: "SDL_JoystickGetAttached", cdecl.}
+
+ +
Returns SDL_TRUE if the joystick has been opened and currently connected, or SDL_FALSE if it has not.
+ + +
+ +
proc joystickInstanceID(joystick: ptr Joystick): JoystickID {...}{.
+    importc: "SDL_JoystickInstanceID", cdecl.}
+
+ +
Get the instance ID of an opened joystick or -1 if the joystick is invalid.
+ + +
+ +
proc joystickNumAxes(joystick: ptr Joystick): cint {...}{.importc: "SDL_JoystickNumAxes",
+    cdecl.}
+
+ +
Get the number of general axis controls on a joystick.
+ + +
+ +
proc joystickNumBalls(joystick: ptr Joystick): cint {...}{.
+    importc: "SDL_JoystickNumBalls", cdecl.}
+
+ +
Get the number of trackballs on a joystick.
+  
+  Joystick trackballs have only relative motion events associated
+  with them and their state cannot be polled.
+ + +
+ +
proc joystickNumHats(joystick: ptr Joystick): cint {...}{.importc: "SDL_JoystickNumHats",
+    cdecl.}
+
+ +
Get the number of POV hats on a joystick.
+ + +
+ +
proc joystickNumButtons(joystick: ptr Joystick): cint {...}{.
+    importc: "SDL_JoystickNumButtons", cdecl.}
+
+ +
Get the number of buttons on a joystick.
+ + +
+ +
proc joystickUpdate() {...}{.importc: "SDL_JoystickUpdate", cdecl.}
+
+ +
Update the current state of the open joysticks.
+  
+  This is called automatically by the event loop if any joystick
+  events are enabled.
+ + +
+ +
proc joystickEventState(state: cint): cint {...}{.importc: "SDL_JoystickEventState", cdecl.}
+
+ +
Enable/disable joystick event polling.
+  
+  If joystick events are disabled, you must call SDL_JoystickUpdate()
+  yourself and check the state of the joystick when you want joystick
+  information.
+  
+  The state can be one of ::SDL_QUERY, ::SDL_ENABLE or ::SDL_IGNORE.
+ + +
+ +
proc joystickGetAxis(joystick: ptr Joystick; axis: cint): Sint16 {...}{.
+    importc: "SDL_JoystickGetAxis", cdecl.}
+
+ +
Get the current state of an axis control on a joystick.
+  
+  The state is a value ranging from -32768 to 32767.
+  
+  The axis indices start at index 0.
+ + +
+ +
proc joystickGetAxisInitialState(joystick: ptr Joystick; axis: cint; state: ptr Sint16): bool {...}{.
+    importc: "SDL_JoystickGetAxisInitialState", cdecl.}
+
+ +
Get the initial state of an axis control on a joystick.
+  
+  The state is a value ranging from -32768 to 32767.
+  
+  The axis indices start at index 0.
+  
+  \return SDL_TRUE if this axis has any initial value, or SDL_FALSE if not.
+ + +
+ +
proc joystickGetHat(joystick: ptr Joystick; hat: cint): Uint8 {...}{.
+    importc: "SDL_JoystickGetHat", cdecl.}
+
+ +
@}
+Get the current state of a POV hat on a joystick.
+  
+  The hat indices start at index 0.
+  
+  \return The return value is one of the following positions:
+           - ::SDL_HAT_CENTERED
+           - ::SDL_HAT_UP
+           - ::SDL_HAT_RIGHT
+           - ::SDL_HAT_DOWN
+           - ::SDL_HAT_LEFT
+           - ::SDL_HAT_RIGHTUP
+           - ::SDL_HAT_RIGHTDOWN
+           - ::SDL_HAT_LEFTUP
+           - ::SDL_HAT_LEFTDOWN
+ + +
+ +
proc joystickGetBall(joystick: ptr Joystick; ball: cint; dx: ptr cint; dy: ptr cint): cint {...}{.
+    importc: "SDL_JoystickGetBall", cdecl.}
+
+ +
Get the ball axis change since the last poll.
+  
+  \return 0, or -1 if you passed it invalid parameters.
+  
+  The ball indices start at index 0.
+ + +
+ +
proc joystickGetButton(joystick: ptr Joystick; button: cint): Uint8 {...}{.
+    importc: "SDL_JoystickGetButton", cdecl.}
+
+ +
Get the current state of a button on a joystick.
+  
+  The button indices start at index 0.
+ + +
+ +
proc joystickRumble(joystick: ptr Joystick; lowFrequencyRumble: Uint16;
+                   highFrequencyRumble: Uint16; durationMs: Uint32): cint {...}{.
+    importc: "SDL_JoystickRumble", cdecl.}
+
+ +
Trigger a rumble effect
+  Each call to this function cancels any previous rumble effect, and calling it with 0 intensity stops any rumbling.
+  
+  \param joystick The joystick to vibrate
+  \param low_frequency_rumble The intensity of the low frequency (left) rumble motor, from 0 to 0xFFFF
+  \param high_frequency_rumble The intensity of the high frequency (right) rumble motor, from 0 to 0xFFFF
+  \param duration_ms The duration of the rumble effect, in milliseconds
+  
+  \return 0, or -1 if rumble isn't supported on this joystick
+ + +
+ +
proc joystickClose(joystick: ptr Joystick) {...}{.importc: "SDL_JoystickClose", cdecl.}
+
+ +
Close a joystick previously opened with SDL_JoystickOpen().
+ + +
+ +
proc joystickCurrentPowerLevel(joystick: ptr Joystick): JoystickPowerLevel {...}{.
+    importc: "SDL_JoystickCurrentPowerLevel", cdecl.}
+
+ +
Return the battery level of this joystick
+ + +
+ +
proc gameControllerAddMappingsFromRW(rw: ptr RWops; freerw: cint): cint {...}{.
+    importc: "SDL_GameControllerAddMappingsFromRW", cdecl.}
+
+ +
To count the number of game controllers in the system for the following:
+  int nJoysticks = SDL_NumJoysticks();
+  int nGameControllers = 0;
+  for (int i = 0; i < nJoysticks; i++) {
+      if (SDL_IsGameController(i)) {
+          nGameControllers++;
+      }
+  }
+  
+  Using the SDL_HINT_GAMECONTROLLERCONFIG hint or the SDL_GameControllerAddMapping() you can add support for controllers SDL is unaware of or cause an existing controller to have a different binding. The format is:
+  guid,name,mappings
+  
+  Where GUID is the string value from SDL_JoystickGetGUIDString(), name is the human readable string for the device and mappings are controller mappings to joystick ones.
+  Under Windows there is a reserved GUID of "xinput" that covers any XInput devices.
+  The mapping format for joystick is:
+      bX - a joystick button, index X
+      hX.Y - hat X with value Y
+      aX - axis X of the joystick
+  Buttons can be used as a controller axis and vice versa.
+  
+  This string shows an example of a valid mapping for a controller
+  "03000000341a00003608000000000000,PS3 Controller,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b8,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftshoulder:b4,rightshoulder:b5,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7",
+Load a set of mappings from a seekable SDL data stream (memory or file), filtered by the current SDL_GetPlatform()
+  A community sourced database of controllers is available at https:raw.github.com/gabomdq/SDL_GameControllerDB/master/gamecontrollerdb.txt
+  
+  If \c freerw is non-zero, the stream will be closed after being read.
+ 
+ \return number of mappings added, -1 on error
+ + +
+ +
proc gameControllerAddMapping(mappingString: cstring): cint {...}{.
+    importc: "SDL_GameControllerAddMapping", cdecl.}
+
+ +
Add or update an existing mapping configuration
+ 
+ \return 1 if mapping is added, 0 if updated, -1 on error
+ + +
+ +
proc gameControllerNumMappings(): cint {...}{.importc: "SDL_GameControllerNumMappings",
+                                      cdecl.}
+
+ +
Get the number of mappings installed
+  
+  \return the number of mappings
+ + +
+ +
proc gameControllerMappingForIndex(mappingIndex: cint): cstring {...}{.
+    importc: "SDL_GameControllerMappingForIndex", cdecl.}
+
+ +
Get the mapping at a particular index.
+  
+  \return the mapping string.  Must be freed with SDL_free().  Returns NULL if the index is out of range.
+ + +
+ +
proc gameControllerMappingForGUID(guid: JoystickGUID): cstring {...}{.
+    importc: "SDL_GameControllerMappingForGUID", cdecl.}
+
+ +
Get a mapping string for a GUID
+  
+  \return the mapping string.  Must be freed with SDL_free().  Returns NULL if no mapping is available
+ + +
+ +
proc gameControllerMapping(gamecontroller: ptr GameController): cstring {...}{.
+    importc: "SDL_GameControllerMapping", cdecl.}
+
+ +
Get a mapping string for an open GameController
+  
+  \return the mapping string.  Must be freed with SDL_free().  Returns NULL if no mapping is available
+ + +
+ +
proc isGameController(joystickIndex: cint): bool {...}{.importc: "SDL_IsGameController",
+    cdecl.}
+
+ +
Is the joystick on this index supported by the game controller interface?
+ + +
+ +
proc gameControllerNameForIndex(joystickIndex: cint): cstring {...}{.
+    importc: "SDL_GameControllerNameForIndex", cdecl.}
+
+ +
Get the implementation dependent name of a game controller.
+  This can be called before any controllers are opened.
+  If no name can be found, this function returns NULL.
+ + +
+ +
proc gameControllerTypeForIndex(joystickIndex: cint): GameControllerType {...}{.
+    importc: "SDL_GameControllerTypeForIndex", cdecl.}
+
+ +
Get the type of a game controller.
+  This can be called before any controllers are opened.
+ + +
+ +
proc gameControllerMappingForDeviceIndex(joystickIndex: cint): cstring {...}{.
+    importc: "SDL_GameControllerMappingForDeviceIndex", cdecl.}
+
+ +
Get the mapping of a game controller.
+  This can be called before any controllers are opened.
+  
+  \return the mapping string.  Must be freed with SDL_free().  Returns NULL if no mapping is available
+ + +
+ +
proc gameControllerOpen(joystickIndex: cint): ptr GameController {...}{.
+    importc: "SDL_GameControllerOpen", cdecl.}
+
+ +
Open a game controller for use.
+  The index passed as an argument refers to the N'th game controller on the system.
+  This index is not the value which will identify this controller in future
+  controller events.  The joystick's instance id (::SDL_JoystickID) will be
+  used there instead.
+  
+  \return A controller identifier, or NULL if an error occurred.
+ + +
+ +
proc gameControllerFromInstanceID(joyid: JoystickID): ptr GameController {...}{.
+    importc: "SDL_GameControllerFromInstanceID", cdecl.}
+
+ +
Return the SDL_GameController associated with an instance id.
+ + +
+ +
proc gameControllerFromPlayerIndex(playerIndex: cint): ptr GameController {...}{.
+    importc: "SDL_GameControllerFromPlayerIndex", cdecl.}
+
+ +
Return the SDL_GameController associated with a player index.
+ + +
+ +
proc gameControllerName(gamecontroller: ptr GameController): cstring {...}{.
+    importc: "SDL_GameControllerName", cdecl.}
+
+ +
Return the name for this currently opened controller
+ + +
+ +
proc gameControllerGetType(gamecontroller: ptr GameController): GameControllerType {...}{.
+    importc: "SDL_GameControllerGetType", cdecl.}
+
+ +
Return the type of this currently opened controller
+ + +
+ +
proc gameControllerGetPlayerIndex(gamecontroller: ptr GameController): cint {...}{.
+    importc: "SDL_GameControllerGetPlayerIndex", cdecl.}
+
+ +
Get the player index of an opened game controller, or -1 if it's not available
+  
+  For XInput controllers this returns the XInput user index.
+ + +
+ +
proc gameControllerSetPlayerIndex(gamecontroller: ptr GameController;
+                                 playerIndex: cint) {...}{.
+    importc: "SDL_GameControllerSetPlayerIndex", cdecl.}
+
+ +
Set the player index of an opened game controller
+ + +
+ +
proc gameControllerGetVendor(gamecontroller: ptr GameController): Uint16 {...}{.
+    importc: "SDL_GameControllerGetVendor", cdecl.}
+
+ +
Get the USB vendor ID of an opened controller, if available.
+  If the vendor ID isn't available this function returns 0.
+ + +
+ +
proc gameControllerGetProduct(gamecontroller: ptr GameController): Uint16 {...}{.
+    importc: "SDL_GameControllerGetProduct", cdecl.}
+
+ +
Get the USB product ID of an opened controller, if available.
+  If the product ID isn't available this function returns 0.
+ + +
+ +
proc gameControllerGetProductVersion(gamecontroller: ptr GameController): Uint16 {...}{.
+    importc: "SDL_GameControllerGetProductVersion", cdecl.}
+
+ +
Get the product version of an opened controller, if available.
+  If the product version isn't available this function returns 0.
+ + +
+ +
proc gameControllerGetAttached(gamecontroller: ptr GameController): bool {...}{.
+    importc: "SDL_GameControllerGetAttached", cdecl.}
+
+ +
Returns SDL_TRUE if the controller has been opened and currently connected,
+  or SDL_FALSE if it has not.
+ + +
+ +
proc gameControllerGetJoystick(gamecontroller: ptr GameController): ptr Joystick {...}{.
+    importc: "SDL_GameControllerGetJoystick", cdecl.}
+
+ +
Get the underlying joystick object used by a controller
+ + +
+ +
proc gameControllerEventState(state: cint): cint {...}{.
+    importc: "SDL_GameControllerEventState", cdecl.}
+
+ +
Enable/disable controller event polling.
+  
+  If controller events are disabled, you must call SDL_GameControllerUpdate()
+  yourself and check the state of the controller when you want controller
+  information.
+  
+  The state can be one of ::SDL_QUERY, ::SDL_ENABLE or ::SDL_IGNORE.
+ + +
+ +
proc gameControllerUpdate() {...}{.importc: "SDL_GameControllerUpdate", cdecl.}
+
+ +
Update the current state of the open game controllers.
+  
+  This is called automatically by the event loop if any game controller
+  events are enabled.
+ + +
+ +
proc gameControllerGetAxisFromString(pchString: cstring): GameControllerAxis {...}{.
+    importc: "SDL_GameControllerGetAxisFromString", cdecl.}
+
+ +
turn this string into a axis mapping
+ + +
+ +
proc gameControllerGetStringForAxis(axis: GameControllerAxis): cstring {...}{.
+    importc: "SDL_GameControllerGetStringForAxis", cdecl.}
+
+ +
turn this axis enum into a string mapping
+ + +
+ +
proc gameControllerGetBindForAxis(gamecontroller: ptr GameController;
+                                 axis: GameControllerAxis): GameControllerButtonBind {...}{.
+    importc: "SDL_GameControllerGetBindForAxis", cdecl.}
+
+ +
Get the SDL joystick layer binding for this controller button mapping
+ + +
+ +
proc gameControllerGetAxis(gamecontroller: ptr GameController;
+                          axis: GameControllerAxis): Sint16 {...}{.
+    importc: "SDL_GameControllerGetAxis", cdecl.}
+
+ +
Get the current state of an axis control on a game controller.
+  
+  The state is a value ranging from -32768 to 32767 (except for the triggers,
+  which range from 0 to 32767).
+  
+  The axis indices start at index 0.
+ + +
+ +
proc gameControllerGetButtonFromString(pchString: cstring): GameControllerButton {...}{.
+    importc: "SDL_GameControllerGetButtonFromString", cdecl.}
+
+ +
turn this string into a button mapping
+ + +
+ +
proc gameControllerGetStringForButton(button: GameControllerButton): cstring {...}{.
+    importc: "SDL_GameControllerGetStringForButton", cdecl.}
+
+ +
turn this button enum into a string mapping
+ + +
+ +
proc gameControllerGetBindForButton(gamecontroller: ptr GameController;
+                                   button: GameControllerButton): GameControllerButtonBind {...}{.
+    importc: "SDL_GameControllerGetBindForButton", cdecl.}
+
+ +
Get the SDL joystick layer binding for this controller button mapping
+ + +
+ +
proc gameControllerGetButton(gamecontroller: ptr GameController;
+                            button: GameControllerButton): Uint8 {...}{.
+    importc: "SDL_GameControllerGetButton", cdecl.}
+
+ +
Get the current state of a button on a game controller.
+  
+  The button indices start at index 0.
+ + +
+ +
proc gameControllerRumble(gamecontroller: ptr GameController;
+                         lowFrequencyRumble: Uint16; highFrequencyRumble: Uint16;
+                         durationMs: Uint32): cint {...}{.
+    importc: "SDL_GameControllerRumble", cdecl.}
+
+ +
Trigger a rumble effect
+  Each call to this function cancels any previous rumble effect, and calling it with 0 intensity stops any rumbling.
+  
+  \param gamecontroller The controller to vibrate
+  \param low_frequency_rumble The intensity of the low frequency (left) rumble motor, from 0 to 0xFFFF
+  \param high_frequency_rumble The intensity of the high frequency (right) rumble motor, from 0 to 0xFFFF
+  \param duration_ms The duration of the rumble effect, in milliseconds
+  
+  \return 0, or -1 if rumble isn't supported on this joystick
+ + +
+ +
proc gameControllerClose(gamecontroller: ptr GameController) {...}{.
+    importc: "SDL_GameControllerClose", cdecl.}
+
+ +
Close a controller previously opened with SDL_GameControllerOpen().
+ + +
+ +
proc getNumTouchDevices(): cint {...}{.importc: "SDL_GetNumTouchDevices", cdecl.}
+
+ +
Function prototypes
+\brief Get the number of registered touch devices.
+ + +
+ +
proc getTouchDevice(index: cint): TouchID {...}{.importc: "SDL_GetTouchDevice", cdecl.}
+
+ +
\brief Get the touch ID with the given index, or 0 if the index is invalid.
+ + +
+ +
proc getTouchDeviceType(touchID: TouchID): TouchDeviceType {...}{.
+    importc: "SDL_GetTouchDeviceType", cdecl.}
+
+ +
\brief Get the type of the given touch device.
+ + +
+ +
proc getNumTouchFingers(touchID: TouchID): cint {...}{.importc: "SDL_GetNumTouchFingers",
+    cdecl.}
+
+ +
\brief Get the number of active fingers for a given touch device.
+ + +
+ +
proc getTouchFinger(touchID: TouchID; index: cint): ptr Finger {...}{.
+    importc: "SDL_GetTouchFinger", cdecl.}
+
+ +
\brief Get the finger object of the given touch, with the given index.
+ + +
+ +
proc recordGesture(touchId: TouchID): cint {...}{.importc: "SDL_RecordGesture", cdecl.}
+
+ +
Function prototypes
+\brief Begin Recording a gesture on the specified touch, or all touches (-1)
+ + +
+ +
proc saveAllDollarTemplates(dst: ptr RWops): cint {...}{.
+    importc: "SDL_SaveAllDollarTemplates", cdecl.}
+
+ +
\brief Save all currently loaded Dollar Gesture templates
+ + +
+ +
proc saveDollarTemplate(gestureId: GestureID; dst: ptr RWops): cint {...}{.
+    importc: "SDL_SaveDollarTemplate", cdecl.}
+
+ +
\brief Save a currently loaded Dollar Gesture template
+ + +
+ +
proc loadDollarTemplates(touchId: TouchID; src: ptr RWops): cint {...}{.
+    importc: "SDL_LoadDollarTemplates", cdecl.}
+
+ +
\brief Load Dollar Gesture templates from a file
+ + +
+ +
proc pumpEvents() {...}{.importc: "SDL_PumpEvents", cdecl.}
+
+ +
Function prototypes
+Pumps the event loop, gathering events from the input devices.
+  
+  This function updates the event queue and internal input device state.
+  
+  This should only be run in the thread that sets the video mode.
+ + +
+ +
proc peepEvents(events: ptr Event; numevents: cint; action: eventaction;
+               minType: Uint32; maxType: Uint32): cint {...}{.importc: "SDL_PeepEvents",
+    cdecl.}
+
+ +
Checks the event queue for messages and optionally returns them.
+  
+  If \c action is ::SDL_ADDEVENT, up to \c numevents events will be added to
+  the back of the event queue.
+  
+  If \c action is ::SDL_PEEKEVENT, up to \c numevents events at the front
+  of the event queue, within the specified minimum and maximum type,
+  will be returned and will not be removed from the queue.
+  
+  If \c action is ::SDL_GETEVENT, up to \c numevents events at the front
+  of the event queue, within the specified minimum and maximum type,
+  will be returned and will be removed from the queue.
+  
+  \return The number of events actually stored, or -1 if there was an error.
+  
+  This function is thread-safe.
+ + +
+ +
proc hasEvent(kind: Uint32): bool {...}{.importc: "SDL_HasEvent", cdecl.}
+
+ +
@}
+Checks to see if certain event types are in the event queue.
+ + +
+ +
proc hasEvents(minType: Uint32; maxType: Uint32): bool {...}{.importc: "SDL_HasEvents", cdecl.}
+
+ + + +
+ +
proc flushEvent(kind: Uint32) {...}{.importc: "SDL_FlushEvent", cdecl.}
+
+ +
This function clears events from the event queue
+  This function only affects currently queued events. If you want to make
+  sure that all pending OS events are flushed, you can call SDL_PumpEvents()
+  on the main thread immediately before the flush call.
+ + +
+ +
proc flushEvents(minType: Uint32; maxType: Uint32) {...}{.importc: "SDL_FlushEvents", cdecl.}
+
+ + + +
+ +
proc pollEvent(event: ptr Event): cint {...}{.importc: "SDL_PollEvent", cdecl.}
+
+ +
\brief Polls for currently pending events.
+  
+  \return 1 if there are any pending events, or 0 if there are none available.
+  
+  \param event If not NULL, the next event is removed from the queue and
+               stored in that area.
+ + +
+ +
proc waitEvent(event: ptr Event): cint {...}{.importc: "SDL_WaitEvent", cdecl.}
+
+ +
\brief Waits indefinitely for the next available event.
+  
+  \return 1, or 0 if there was an error while waiting for events.
+  
+  \param event If not NULL, the next event is removed from the queue and
+               stored in that area.
+ + +
+ +
proc waitEventTimeout(event: ptr Event; timeout: cint): cint {...}{.
+    importc: "SDL_WaitEventTimeout", cdecl.}
+
+ +
\brief Waits until the specified timeout (in milliseconds) for the next
+         available event.
+  
+  \return 1, or 0 if there was an error while waiting for events.
+  
+  \param event If not NULL, the next event is removed from the queue and
+               stored in that area.
+  \param timeout The timeout (in milliseconds) to wait for next event.
+ + +
+ +
proc pushEvent(event: ptr Event): cint {...}{.importc: "SDL_PushEvent", cdecl.}
+
+ +
\brief Add an event to the event queue.
+  
+  \return 1 on success, 0 if the event was filtered, or -1 if the event queue
+          was full or there was some other error.
+ + +
+ +
proc setEventFilter(filter: EventFilter; userdata: pointer) {...}{.
+    importc: "SDL_SetEventFilter", cdecl.}
+
+ +
Sets up a filter to process all events before they change internal state and
+  are posted to the internal event queue.
+  
+  The filter is prototyped as:
+  \code
+      int SDL_EventFilter(voiduserdata, SDL_Event event);
+  \endcode
+  
+  If the filter returns 1, then the event will be added to the internal queue.
+  If it returns 0, then the event will be dropped from the queue, but the
+  internal state will still be updated.  This allows selective filtering of
+  dynamically arriving events.
+  
+  \warning  Be very careful of what you do in the event filter function, as
+            it may run in a different thread!
+  
+  There is one caveat when dealing with the ::SDL_QuitEvent event type.  The
+  event filter is only called when the window manager desires to close the
+  application window.  If the event filter returns 1, then the window will
+  be closed, otherwise the window will remain open if possible.
+  
+  If the quit event is generated by an interrupt signal, it will bypass the
+  internal queue and be delivered to the application at the next event poll.
+ + +
+ +
proc getEventFilter(filter: ptr EventFilter; userdata: ptr pointer): bool {...}{.
+    importc: "SDL_GetEventFilter", cdecl.}
+
+ +
Return the current event filter - can be used to "chain" filters.
+  If there is no event filter set, this function returns SDL_FALSE.
+ + +
+ +
proc addEventWatch(filter: EventFilter; userdata: pointer) {...}{.
+    importc: "SDL_AddEventWatch", cdecl.}
+
+ +
Add a function which is called when an event is added to the queue.
+ + +
+ +
proc delEventWatch(filter: EventFilter; userdata: pointer) {...}{.
+    importc: "SDL_DelEventWatch", cdecl.}
+
+ +
Remove an event watch function added with SDL_AddEventWatch()
+ + +
+ +
proc filterEvents(filter: EventFilter; userdata: pointer) {...}{.
+    importc: "SDL_FilterEvents", cdecl.}
+
+ +
Run the filter function on the current event queue, removing any
+  events for which the filter returns 0.
+ + +
+ +
proc eventState(kind: Uint32; state: cint): Uint8 {...}{.importc: "SDL_EventState", cdecl.}
+
+ +
This function allows you to set the state of processing certain events.
+   - If \c state is set to ::SDL_IGNORE, that event will be automatically
+     dropped from the event queue and will not be filtered.
+   - If \c state is set to ::SDL_ENABLE, that event will be processed
+     normally.
+   - If \c state is set to ::SDL_QUERY, SDL_EventState() will return the
+     current processing state of the specified event.
+ + +
+ +
proc registerEvents(numevents: cint): Uint32 {...}{.importc: "SDL_RegisterEvents", cdecl.}
+
+ +
This function allocates a set of user-defined events, and returns
+  the beginning event number for that set of events.
+  
+  If there aren't enough user-defined events left, this function
+  returns (Uint32)-1
+ + +
+ +
proc getBasePath(): cstring {...}{.importc: "SDL_GetBasePath", cdecl.}
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+\brief Get the path where the application resides.
+ 
+ Get the "base path". This is the directory where the application was run
+  from, which is probably the installation directory, and may or may not
+  be the process's current working directory.
+ 
+ This returns an absolute path in UTF-8 encoding, and is guaranteed to
+  end with a path separator ('\\' on Windows, '/' most other places).
+ 
+ The pointer returned by this function is owned by you. Please call
+  SDL_free() on the pointer when you are done with it, or it will be a
+  memory leak. This is not necessarily a fast call, though, so you should
+  call this once near startup and save the string if you need it.
+ 
+ Some platforms can't determine the application's path, and on other
+  platforms, this might be meaningless. In such cases, this function will
+  return NULL.
+  
+  \return String of base dir in UTF-8 encoding, or NULL on error.
+ 
+ \sa SDL_GetPrefPath
+ + +
+ +
proc getPrefPath(org: cstring; app: cstring): cstring {...}{.importc: "SDL_GetPrefPath",
+    cdecl.}
+
+ +
\brief Get the user-and-app-specific path where files can be written.
+ 
+ Get the "pref dir". This is meant to be where users can write personal
+  files (preferences and save games, etc) that are specific to your
+  application. This directory is unique per user, per application.
+ 
+ This function will decide the appropriate location in the native filesystem,
+  create the directory if necessary, and return a string of the absolute
+  path to the directory in UTF-8 encoding.
+ 
+ On Windows, the string might look like:
+  "C:\\Users\\bob\\AppData\\Roaming\\My Company\\My Program Name\\"
+ 
+ On Linux, the string might look like:
+  "/home/bob/.local/share/My Program Name/"
+ 
+ On Mac OS X, the string might look like:
+  "/Users/bob/Library/Application Support/My Program Name/"
+ 
+ (etc.)
+ 
+ You specify the name of your organization (if it's not a real organization,
+  your name or an Internet domain you own might do) and the name of your
+  application. These should be untranslated proper names.
+ 
+ Both the org and app strings may become part of a directory name, so
+  please follow these rules:
+    
+    - Try to use the same org string (including case-sensitivity) for
+      all your applications that use this function.
+    - Always use a unique app string for each one, and make sure it never
+      changes for an app once you've decided on it.
+    - Unicode characters are legal, as long as it's UTF-8 encoded, but...
+    - ...only use letters, numbers, and spaces. Avoid punctuation like
+      "Game Name 2: Bad Guy's Revenge!" ... "Game Name 2" is sufficient.
+ 
+ This returns an absolute path in UTF-8 encoding, and is guaranteed to
+  end with a path separator ('\\' on Windows, '/' most other places).
+ 
+ The pointer returned by this function is owned by you. Please call
+  SDL_free() on the pointer when you are done with it, or it will be a
+  memory leak. This is not necessarily a fast call, though, so you should
+  call this once near startup and save the string if you need it.
+ 
+ You should assume the path returned by this function is the only safe
+  place to write files (and that SDL_GetBasePath(), while it might be
+  writable, or even the parent of the returned path, aren't where you
+  should be writing things).
+ 
+ Some platforms can't determine the pref path, and on other
+  platforms, this might be meaningless. In such cases, this function will
+  return NULL.
+   
+   \param org The name of your organization.
+   \param app The name of your application.
+  \return UTF-8 string of user dir in platform-dependent notation. NULL
+          if there's a problem (creating directory failed, etc).
+ 
+ \sa SDL_GetBasePath
+ + +
+ +
proc numHaptics(): cint {...}{.importc: "SDL_NumHaptics", cdecl.}
+
+ +
Function prototypes
+\brief Count the number of haptic devices attached to the system.
+  
+  \return Number of haptic devices detected on the system.
+ + +
+ +
proc hapticName(deviceIndex: cint): cstring {...}{.importc: "SDL_HapticName", cdecl.}
+
+ +
\brief Get the implementation dependent name of a haptic device.
+  
+  This can be called before any joysticks are opened.
+  If no name can be found, this function returns NULL.
+  
+  \param device_index Index of the device to get its name.
+  \return Name of the device or NULL on error.
+  
+  \sa SDL_NumHaptics
+ + +
+ +
proc hapticOpen(deviceIndex: cint): ptr Haptic {...}{.importc: "SDL_HapticOpen", cdecl.}
+
+ +
\brief Opens a haptic device for use.
+  
+  The index passed as an argument refers to the N'th haptic device on this
+  system.
+  
+  When opening a haptic device, its gain will be set to maximum and
+  autocenter will be disabled.  To modify these values use
+  SDL_HapticSetGain() and SDL_HapticSetAutocenter().
+  
+  \param device_index Index of the device to open.
+  \return Device identifier or NULL on error.
+  
+  \sa SDL_HapticIndex
+  \sa SDL_HapticOpenFromMouse
+  \sa SDL_HapticOpenFromJoystick
+  \sa SDL_HapticClose
+  \sa SDL_HapticSetGain
+  \sa SDL_HapticSetAutocenter
+  \sa SDL_HapticPause
+  \sa SDL_HapticStopAll
+ + +
+ +
proc hapticOpened(deviceIndex: cint): cint {...}{.importc: "SDL_HapticOpened", cdecl.}
+
+ +
\brief Checks if the haptic device at index has been opened.
+  
+  \param device_index Index to check to see if it has been opened.
+  \return 1 if it has been opened or 0 if it hasn't.
+  
+  \sa SDL_HapticOpen
+  \sa SDL_HapticIndex
+ + +
+ +
proc hapticIndex(haptic: ptr Haptic): cint {...}{.importc: "SDL_HapticIndex", cdecl.}
+
+ +
\brief Gets the index of a haptic device.
+  
+  \param haptic Haptic device to get the index of.
+  \return The index of the haptic device or -1 on error.
+  
+  \sa SDL_HapticOpen
+  \sa SDL_HapticOpened
+ + +
+ +
proc mouseIsHaptic(): cint {...}{.importc: "SDL_MouseIsHaptic", cdecl.}
+
+ +
\brief Gets whether or not the current mouse has haptic capabilities.
+  
+  \return SDL_TRUE if the mouse is haptic, SDL_FALSE if it isn't.
+  
+  \sa SDL_HapticOpenFromMouse
+ + +
+ +
proc hapticOpenFromMouse(): ptr Haptic {...}{.importc: "SDL_HapticOpenFromMouse", cdecl.}
+
+ +
\brief Tries to open a haptic device from the current mouse.
+  
+  \return The haptic device identifier or NULL on error.
+  
+  \sa SDL_MouseIsHaptic
+  \sa SDL_HapticOpen
+ + +
+ +
proc joystickIsHaptic(joystick: ptr Joystick): cint {...}{.
+    importc: "SDL_JoystickIsHaptic", cdecl.}
+
+ +
\brief Checks to see if a joystick has haptic features.
+  
+  \param joystick Joystick to test for haptic capabilities.
+  \return SDL_TRUE if the joystick is haptic, SDL_FALSE if it isn't
+          or -1 if an error occurred.
+  
+  \sa SDL_HapticOpenFromJoystick
+ + +
+ +
proc hapticOpenFromJoystick(joystick: ptr Joystick): ptr Haptic {...}{.
+    importc: "SDL_HapticOpenFromJoystick", cdecl.}
+
+ +
\brief Opens a haptic device for use from a joystick device.
+  
+  You must still close the haptic device separately.  It will not be closed
+  with the joystick.
+  
+  When opening from a joystick you should first close the haptic device before
+  closing the joystick device.  If not, on some implementations the haptic
+  device will also get unallocated and you'll be unable to use force feedback
+  on that device.
+  
+  \param joystick Joystick to create a haptic device from.
+  \return A valid haptic device identifier on success or NULL on error.
+  
+  \sa SDL_HapticOpen
+  \sa SDL_HapticClose
+ + +
+ +
proc hapticClose(haptic: ptr Haptic) {...}{.importc: "SDL_HapticClose", cdecl.}
+
+ +
\brief Closes a haptic device previously opened with SDL_HapticOpen().
+  
+  \param haptic Haptic device to close.
+ + +
+ +
proc hapticNumEffects(haptic: ptr Haptic): cint {...}{.importc: "SDL_HapticNumEffects",
+    cdecl.}
+
+ +
\brief Returns the number of effects a haptic device can store.
+  
+  On some platforms this isn't fully supported, and therefore is an
+  approximation.  Always check to see if your created effect was actually
+  created and do not rely solely on SDL_HapticNumEffects().
+  
+  \param haptic The haptic device to query effect max.
+  \return The number of effects the haptic device can store or
+          -1 on error.
+  
+  \sa SDL_HapticNumEffectsPlaying
+  \sa SDL_HapticQuery
+ + +
+ +
proc hapticNumEffectsPlaying(haptic: ptr Haptic): cint {...}{.
+    importc: "SDL_HapticNumEffectsPlaying", cdecl.}
+
+ +
\brief Returns the number of effects a haptic device can play at the same
+         time.
+  
+  This is not supported on all platforms, but will always return a value.
+  Added here for the sake of completeness.
+  
+  \param haptic The haptic device to query maximum playing effects.
+  \return The number of effects the haptic device can play at the same time
+          or -1 on error.
+  
+  \sa SDL_HapticNumEffects
+  \sa SDL_HapticQuery
+ + +
+ +
proc hapticQuery(haptic: ptr Haptic): cuint {...}{.importc: "SDL_HapticQuery", cdecl.}
+
+ +
\brief Gets the haptic device's supported features in bitwise manner.
+  
+  Example:
+  \code
+  if (SDL_HapticQuery(haptic) & SDL_HAPTIC_CONSTANT) {
+      printf("We have constant haptic effect!\n");
+  }
+  \endcode
+  
+  \param haptic The haptic device to query.
+  \return Haptic features in bitwise manner (OR'd).
+  
+  \sa SDL_HapticNumEffects
+  \sa SDL_HapticEffectSupported
+ + +
+ +
proc hapticNumAxes(haptic: ptr Haptic): cint {...}{.importc: "SDL_HapticNumAxes", cdecl.}
+
+ +
\brief Gets the number of haptic axes the device has.
+  
+  \sa SDL_HapticDirection
+ + +
+ +
proc hapticEffectSupported(haptic: ptr Haptic; effect: ptr HapticEffect): cint {...}{.
+    importc: "SDL_HapticEffectSupported", cdecl.}
+
+ +
\brief Checks to see if effect is supported by haptic.
+  
+  \param haptic Haptic device to check on.
+  \param effect Effect to check to see if it is supported.
+  \return SDL_TRUE if effect is supported, SDL_FALSE if it isn't or -1 on error.
+  
+  \sa SDL_HapticQuery
+  \sa SDL_HapticNewEffect
+ + +
+ +
proc hapticNewEffect(haptic: ptr Haptic; effect: ptr HapticEffect): cint {...}{.
+    importc: "SDL_HapticNewEffect", cdecl.}
+
+ +
\brief Creates a new haptic effect on the device.
+  
+  \param haptic Haptic device to create the effect on.
+  \param effect Properties of the effect to create.
+  \return The identifier of the effect on success or -1 on error.
+  
+  \sa SDL_HapticUpdateEffect
+  \sa SDL_HapticRunEffect
+  \sa SDL_HapticDestroyEffect
+ + +
+ +
proc hapticUpdateEffect(haptic: ptr Haptic; effect: cint; data: ptr HapticEffect): cint {...}{.
+    importc: "SDL_HapticUpdateEffect", cdecl.}
+
+ +
\brief Updates the properties of an effect.
+  
+  Can be used dynamically, although behavior when dynamically changing
+  direction may be strange.  Specifically the effect may reupload itself
+  and start playing from the start.  You cannot change the type either when
+  running SDL_HapticUpdateEffect().
+  
+  \param haptic Haptic device that has the effect.
+  \param effect Identifier of the effect to update.
+  \param data New effect properties to use.
+  \return 0 on success or -1 on error.
+  
+  \sa SDL_HapticNewEffect
+  \sa SDL_HapticRunEffect
+  \sa SDL_HapticDestroyEffect
+ + +
+ +
proc hapticRunEffect(haptic: ptr Haptic; effect: cint; iterations: Uint32): cint {...}{.
+    importc: "SDL_HapticRunEffect", cdecl.}
+
+ +
\brief Runs the haptic effect on its associated haptic device.
+  
+  If iterations are ::SDL_HAPTIC_INFINITY, it'll run the effect over and over
+  repeating the envelope (attack and fade) every time.  If you only want the
+  effect to last forever, set ::SDL_HAPTIC_INFINITY in the effect's length
+  parameter.
+  
+  \param haptic Haptic device to run the effect on.
+  \param effect Identifier of the haptic effect to run.
+  \param iterations Number of iterations to run the effect. Use
+         ::SDL_HAPTIC_INFINITY for infinity.
+  \return 0 on success or -1 on error.
+  
+  \sa SDL_HapticStopEffect
+  \sa SDL_HapticDestroyEffect
+  \sa SDL_HapticGetEffectStatus
+ + +
+ +
proc hapticStopEffect(haptic: ptr Haptic; effect: cint): cint {...}{.
+    importc: "SDL_HapticStopEffect", cdecl.}
+
+ +
\brief Stops the haptic effect on its associated haptic device.
+  
+  \param haptic Haptic device to stop the effect on.
+  \param effect Identifier of the effect to stop.
+  \return 0 on success or -1 on error.
+  
+  \sa SDL_HapticRunEffect
+  \sa SDL_HapticDestroyEffect
+ + +
+ +
proc hapticDestroyEffect(haptic: ptr Haptic; effect: cint) {...}{.
+    importc: "SDL_HapticDestroyEffect", cdecl.}
+
+ +
\brief Destroys a haptic effect on the device.
+  
+  This will stop the effect if it's running.  Effects are automatically
+  destroyed when the device is closed.
+  
+  \param haptic Device to destroy the effect on.
+  \param effect Identifier of the effect to destroy.
+  
+  \sa SDL_HapticNewEffect
+ + +
+ +
proc hapticGetEffectStatus(haptic: ptr Haptic; effect: cint): cint {...}{.
+    importc: "SDL_HapticGetEffectStatus", cdecl.}
+
+ +
\brief Gets the status of the current effect on the haptic device.
+  
+  Device must support the ::SDL_HAPTIC_STATUS feature.
+  
+  \param haptic Haptic device to query the effect status on.
+  \param effect Identifier of the effect to query its status.
+  \return 0 if it isn't playing, 1 if it is playing or -1 on error.
+  
+  \sa SDL_HapticRunEffect
+  \sa SDL_HapticStopEffect
+ + +
+ +
proc hapticSetGain(haptic: ptr Haptic; gain: cint): cint {...}{.
+    importc: "SDL_HapticSetGain", cdecl.}
+
+ +
\brief Sets the global gain of the device.
+  
+  Device must support the ::SDL_HAPTIC_GAIN feature.
+  
+  The user may specify the maximum gain by setting the environment variable
+  SDL_HAPTIC_GAIN_MAX which should be between 0 and 100.  All calls to
+  SDL_HapticSetGain() will scale linearly using SDL_HAPTIC_GAIN_MAX as the
+  maximum.
+  
+  \param haptic Haptic device to set the gain on.
+  \param gain Value to set the gain to, should be between 0 and 100.
+  \return 0 on success or -1 on error.
+  
+  \sa SDL_HapticQuery
+ + +
+ +
proc hapticSetAutocenter(haptic: ptr Haptic; autocenter: cint): cint {...}{.
+    importc: "SDL_HapticSetAutocenter", cdecl.}
+
+ +
\brief Sets the global autocenter of the device.
+  
+  Autocenter should be between 0 and 100.  Setting it to 0 will disable
+  autocentering.
+  
+  Device must support the ::SDL_HAPTIC_AUTOCENTER feature.
+  
+  \param haptic Haptic device to set autocentering on.
+  \param autocenter Value to set autocenter to, 0 disables autocentering.
+  \return 0 on success or -1 on error.
+  
+  \sa SDL_HapticQuery
+ + +
+ +
proc hapticPause(haptic: ptr Haptic): cint {...}{.importc: "SDL_HapticPause", cdecl.}
+
+ +
\brief Pauses a haptic device.
+  
+  Device must support the ::SDL_HAPTIC_PAUSE feature.  Call
+  SDL_HapticUnpause() to resume playback.
+  
+  Do not modify the effects nor add new ones while the device is paused.
+  That can cause all sorts of weird errors.
+  
+  \param haptic Haptic device to pause.
+  \return 0 on success or -1 on error.
+  
+  \sa SDL_HapticUnpause
+ + +
+ +
proc hapticUnpause(haptic: ptr Haptic): cint {...}{.importc: "SDL_HapticUnpause", cdecl.}
+
+ +
\brief Unpauses a haptic device.
+  
+  Call to unpause after SDL_HapticPause().
+  
+  \param haptic Haptic device to unpause.
+  \return 0 on success or -1 on error.
+  
+  \sa SDL_HapticPause
+ + +
+ +
proc hapticStopAll(haptic: ptr Haptic): cint {...}{.importc: "SDL_HapticStopAll", cdecl.}
+
+ +
\brief Stops all the currently playing effects on a haptic device.
+  
+  \param haptic Haptic device to stop.
+  \return 0 on success or -1 on error.
+ + +
+ +
proc hapticRumbleSupported(haptic: ptr Haptic): cint {...}{.
+    importc: "SDL_HapticRumbleSupported", cdecl.}
+
+ +
\brief Checks to see if rumble is supported on a haptic device.
+  
+  \param haptic Haptic device to check to see if it supports rumble.
+  \return SDL_TRUE if effect is supported, SDL_FALSE if it isn't or -1 on error.
+  
+  \sa SDL_HapticRumbleInit
+  \sa SDL_HapticRumblePlay
+  \sa SDL_HapticRumbleStop
+ + +
+ +
proc hapticRumbleInit(haptic: ptr Haptic): cint {...}{.importc: "SDL_HapticRumbleInit",
+    cdecl.}
+
+ +
\brief Initializes the haptic device for simple rumble playback.
+  
+  \param haptic Haptic device to initialize for simple rumble playback.
+  \return 0 on success or -1 on error.
+  
+  \sa SDL_HapticOpen
+  \sa SDL_HapticRumbleSupported
+  \sa SDL_HapticRumblePlay
+  \sa SDL_HapticRumbleStop
+ + +
+ +
proc hapticRumblePlay(haptic: ptr Haptic; strength: cfloat; length: Uint32): cint {...}{.
+    importc: "SDL_HapticRumblePlay", cdecl.}
+
+ +
\brief Runs simple rumble on a haptic device
+  
+  \param haptic Haptic device to play rumble effect on.
+  \param strength Strength of the rumble to play as a 0-1 float value.
+  \param length Length of the rumble to play in milliseconds.
+  \return 0 on success or -1 on error.
+  
+  \sa SDL_HapticRumbleSupported
+  \sa SDL_HapticRumbleInit
+  \sa SDL_HapticRumbleStop
+ + +
+ +
proc hapticRumbleStop(haptic: ptr Haptic): cint {...}{.importc: "SDL_HapticRumbleStop",
+    cdecl.}
+
+ +
\brief Stops the simple rumble on a haptic device.
+  
+  \param haptic Haptic to stop the rumble on.
+  \return 0 on success or -1 on error.
+  
+  \sa SDL_HapticRumbleSupported
+  \sa SDL_HapticRumbleInit
+  \sa SDL_HapticRumblePlay
+ + +
+ +
proc setHintWithPriority(name: cstring; value: cstring; priority: HintPriority): bool {...}{.
+    importc: "SDL_SetHintWithPriority", cdecl.}
+
+ +
\brief Set a hint with a specific priority
+  
+  The priority controls the behavior when setting a hint that already
+  has a value.  Hints will replace existing hints of their priority and
+  lower.  Environment variables are considered to have override priority.
+  
+  \return SDL_TRUE if the hint was set, SDL_FALSE otherwise
+ + +
+ +
proc setHint(name: cstring; value: cstring): bool {...}{.importc: "SDL_SetHint", cdecl.}
+
+ +
\brief Set a hint with normal priority
+  
+  \return SDL_TRUE if the hint was set, SDL_FALSE otherwise
+ + +
+ +
proc getHint(name: cstring): cstring {...}{.importc: "SDL_GetHint", cdecl.}
+
+ +
\brief Get a hint
+  
+  \return The string value of a hint variable.
+ + +
+ +
proc getHintBoolean(name: cstring; defaultValue: bool): bool {...}{.
+    importc: "SDL_GetHintBoolean", cdecl.}
+
+ +
\brief Get a hint
+  
+  \return The boolean value of a hint variable.
+ + +
+ +
proc addHintCallback(name: cstring; callback: HintCallback; userdata: pointer) {...}{.
+    importc: "SDL_AddHintCallback", cdecl.}
+
+ +
\brief Add a function to watch a particular hint
+  
+  \param name The hint to watch
+  \param callback The function to call when the hint value changes
+  \param userdata A pointer to pass to the callback function
+ + +
+ +
proc delHintCallback(name: cstring; callback: HintCallback; userdata: pointer) {...}{.
+    importc: "SDL_DelHintCallback", cdecl.}
+
+ +
\brief Remove a function watching a particular hint
+  
+  \param name The hint being watched
+  \param callback The function being called when the hint value changes
+  \param userdata A pointer being passed to the callback function
+ + +
+ +
proc clearHints() {...}{.importc: "SDL_ClearHints", cdecl.}
+
+ +
\brief  Clear all hints
+  
+  This function is called during SDL_Quit() to free stored hints.
+ + +
+ +
proc loadObject(sofile: cstring): pointer {...}{.importc: "SDL_LoadObject", cdecl.}
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+This function dynamically loads a shared object and returns a pointer
+  to the object handle (or NULL if there was an error).
+  The 'sofile' parameter is a system dependent name of the object file.
+ + +
+ +
proc loadFunction(handle: pointer; name: cstring): pointer {...}{.
+    importc: "SDL_LoadFunction", cdecl.}
+
+ +
Given an object handle, this function looks up the address of the
+  named function in the shared object and returns it.  This address
+  is no longer valid after calling SDL_UnloadObject().
+ + +
+ +
proc unloadObject(handle: pointer) {...}{.importc: "SDL_UnloadObject", cdecl.}
+
+ +
Unload a shared object from memory.
+ + +
+ +
proc logSetAllPriority(priority: LogPriority) {...}{.importc: "SDL_LogSetAllPriority",
+    cdecl.}
+
+ +
\brief Set the priority of all log categories
+ + +
+ +
proc logSetPriority(category: cint; priority: LogPriority) {...}{.
+    importc: "SDL_LogSetPriority", cdecl.}
+
+ +
\brief Set the priority of a particular log category
+ + +
+ +
proc logGetPriority(category: cint): LogPriority {...}{.importc: "SDL_LogGetPriority",
+    cdecl.}
+
+ +
\brief Get the priority of a particular log category
+ + +
+ +
proc logResetPriorities() {...}{.importc: "SDL_LogResetPriorities", cdecl.}
+
+ +
\brief Reset all priorities to default.
+  
+  \note This is called in SDL_Quit().
+ + +
+ +
proc logVerbose(category: cint; fmt: cstring) {...}{.importc: "SDL_LogVerbose", cdecl,
+    varargs.}
+
+ +
\brief Log a message with SDL_LOG_PRIORITY_VERBOSE
+ + +
+ +
proc logDebug(category: cint; fmt: cstring) {...}{.importc: "SDL_LogDebug", cdecl, varargs.}
+
+ +
\brief Log a message with SDL_LOG_PRIORITY_DEBUG
+ + +
+ +
proc logInfo(category: cint; fmt: cstring) {...}{.importc: "SDL_LogInfo", cdecl, varargs.}
+
+ +
\brief Log a message with SDL_LOG_PRIORITY_INFO
+ + +
+ +
proc logWarn(category: cint; fmt: cstring) {...}{.importc: "SDL_LogWarn", cdecl, varargs.}
+
+ +
\brief Log a message with SDL_LOG_PRIORITY_WARN
+ + +
+ +
proc logError(category: cint; fmt: cstring) {...}{.importc: "SDL_LogError", cdecl, varargs.}
+
+ +
\brief Log a message with SDL_LOG_PRIORITY_ERROR
+ + +
+ +
proc logCritical(category: cint; fmt: cstring) {...}{.importc: "SDL_LogCritical", cdecl,
+    varargs.}
+
+ +
\brief Log a message with SDL_LOG_PRIORITY_CRITICAL
+ + +
+ +
proc logMessage(category: cint; priority: LogPriority; fmt: cstring) {...}{.
+    importc: "SDL_LogMessage", cdecl, varargs.}
+
+ +
\brief Log a message with the specified category and priority.
+ + +
+ +
proc logMessageV(category: cint; priority: LogPriority; fmt: cstring; ap: va_list) {...}{.
+    importc: "SDL_LogMessageV", cdecl.}
+
+ +
\brief Log a message with the specified category and priority.
+ + +
+ +
proc logGetOutputFunction(callback: ptr LogOutputFunction; userdata: ptr pointer) {...}{.
+    importc: "SDL_LogGetOutputFunction", cdecl.}
+
+ +
\brief Get the current log output function.
+ + +
+ +
proc logSetOutputFunction(callback: LogOutputFunction; userdata: pointer) {...}{.
+    importc: "SDL_LogSetOutputFunction", cdecl.}
+
+ +
\brief This function allows you to replace the default log output
+         function with one of your own.
+ + +
+ +
proc showMessageBox(messageboxdata: ptr MessageBoxData; buttonid: ptr cint): cint {...}{.
+    importc: "SDL_ShowMessageBox", cdecl.}
+
+ +
\brief Create a modal message box.
+  
+  \param messageboxdata The SDL_MessageBoxData structure with title, text, etc.
+  \param buttonid The pointer to which user id of hit button should be copied.
+  
+  \return -1 on error, otherwise 0 and buttonid contains user id of button
+          hit or -1 if dialog was closed.
+  
+  \note This function should be called on the thread that created the parent
+        window, or on the main thread if the messagebox has no parent.  It will
+        block execution of that thread until the user clicks a button or
+        closes the messagebox.
+ + +
+ +
proc showSimpleMessageBox(flags: Uint32; title: cstring; message: cstring;
+                         window: ptr Window): cint {...}{.
+    importc: "SDL_ShowSimpleMessageBox", cdecl.}
+
+ +
\brief Create a simple modal message box
+  
+  \param flags    ::SDL_MessageBoxFlags
+  \param title    UTF-8 title text
+  \param message  UTF-8 message text
+  \param window   The parent window, or NULL for no parent
+  
+  \return 0 on success, -1 on error
+  
+  \sa SDL_ShowMessageBox
+ + +
+ +
proc metal_CreateView(window: ptr Window): MetalView {...}{.
+    importc: "SDL_Metal_CreateView", cdecl.}
+
+ +
\name Metal support functions
+@{
+\brief Create a CAMetalLayer-backed NSView/UIView and attach it to the
+        specified window.
+  
+  On macOS, this doesnot associate a MTLDevice with the CAMetalLayer on its
+  own. It is up to user code to do that.
+  
+  The returned handle can be casted directly to a NSView or UIView, and the
+  CAMetalLayer can be accessed from the view's 'layer' property.
+  
+  \code
+  SDL_MetalView metalview = SDL_Metal_CreateView(window);
+  UIViewuiview = (__bridge UIView)metalview;
+  CAMetalLayermetallayer = (CAMetalLayer)uiview.layer;
+ [...]
+  SDL_Metal_DestroyView(metalview);
+  \endcode
+  
+  \sa SDL_Metal_DestroyView
+ + +
+ +
proc metal_DestroyView(view: MetalView) {...}{.importc: "SDL_Metal_DestroyView", cdecl.}
+
+ +
\brief Destroy an existing SDL_MetalView object.
+  
+  This should be called before SDL_DestroyWindow, if SDL_Metal_CreateView was
+  called after SDL_CreateWindow.
+  
+  \sa SDL_Metal_CreateView
+ + +
+ +
proc getPowerInfo(secs: ptr cint; pct: ptr cint): PowerState {...}{.
+    importc: "SDL_GetPowerInfo", cdecl.}
+
+ +
\brief Get the current power supply details.
+  
+  \param secs Seconds of battery life left. You can pass a NULL here if
+              you don't care. Will return -1 if we can't determine a
+              value, or we're not running on a battery.
+  
+  \param pct Percentage of battery life left, between 0 and 100. You can
+             pass a NULL here if you don't care. Will return -1 if we
+             can't determine a value, or we're not running on a battery.
+  
+  \return The state of the battery (if any).
+ + +
+ +
proc getNumRenderDrivers(): cint {...}{.importc: "SDL_GetNumRenderDrivers", cdecl.}
+
+ +
Function prototypes
+\brief Get the number of 2D rendering drivers available for the current
+         display.
+  
+  A render driver is a set of code that handles rendering and texture
+  management on a particular display.  Normally there is only one, but
+  some drivers may have several available with different capabilities.
+  
+  \sa SDL_GetRenderDriverInfo()
+  \sa SDL_CreateRenderer()
+ + +
+ +
proc getRenderDriverInfo(index: cint; info: ptr RendererInfo): cint {...}{.
+    importc: "SDL_GetRenderDriverInfo", cdecl.}
+
+ +
\brief Get information about a specific 2D rendering driver for the current
+         display.
+  
+  \param index The index of the driver to query information about.
+  \param info  A pointer to an SDL_RendererInfo struct to be filled with
+               information on the rendering driver.
+  
+  \return 0 on success, -1 if the index was out of range.
+  
+  \sa SDL_CreateRenderer()
+ + +
+ +
proc createWindowAndRenderer(width: cint; height: cint; windowFlags: Uint32;
+                            window: ptr ptr Window; renderer: ptr ptr Renderer): cint {...}{.
+    importc: "SDL_CreateWindowAndRenderer", cdecl.}
+
+ +
\brief Create a window and default renderer
+  
+  \param width    The width of the window
+  \param height   The height of the window
+  \param window_flags The flags used to create the window
+  \param window   A pointer filled with the window, or NULL on error
+  \param renderer A pointer filled with the renderer, or NULL on error
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc createRenderer(window: ptr Window; index: cint; flags: Uint32): ptr Renderer {...}{.
+    importc: "SDL_CreateRenderer", cdecl.}
+
+ +
\brief Create a 2D rendering context for a window.
+  
+  \param window The window where rendering is displayed.
+  \param index    The index of the rendering driver to initialize, or -1 to
+                  initialize the first one supporting the requested flags.
+  \param flags    ::SDL_RendererFlags.
+  
+  \return A valid rendering context or NULL if there was an error.
+  
+  \sa SDL_CreateSoftwareRenderer()
+  \sa SDL_GetRendererInfo()
+  \sa SDL_DestroyRenderer()
+ + +
+ +
proc createSoftwareRenderer(surface: ptr Surface): ptr Renderer {...}{.
+    importc: "SDL_CreateSoftwareRenderer", cdecl.}
+
+ +
\brief Create a 2D software rendering context for a surface.
+  
+  \param surface The surface where rendering is done.
+  
+  \return A valid rendering context or NULL if there was an error.
+  
+  \sa SDL_CreateRenderer()
+  \sa SDL_DestroyRenderer()
+ + +
+ +
proc getRenderer(window: ptr Window): ptr Renderer {...}{.importc: "SDL_GetRenderer", cdecl.}
+
+ +
\brief Get the renderer associated with a window.
+ + +
+ +
proc getRendererInfo(renderer: ptr Renderer; info: ptr RendererInfo): cint {...}{.
+    importc: "SDL_GetRendererInfo", cdecl.}
+
+ +
\brief Get information about a rendering context.
+ + +
+ +
proc getRendererOutputSize(renderer: ptr Renderer; w: ptr cint; h: ptr cint): cint {...}{.
+    importc: "SDL_GetRendererOutputSize", cdecl.}
+
+ +
\brief Get the output size in pixels of a rendering context.
+ + +
+ +
proc createTexture(renderer: ptr Renderer; format: Uint32; access: cint; w: cint; h: cint): ptr Texture {...}{.
+    importc: "SDL_CreateTexture", cdecl.}
+
+ +
\brief Create a texture for a rendering context.
+  
+  \param renderer The renderer.
+  \param format The format of the texture.
+  \param access One of the enumerated values in ::SDL_TextureAccess.
+  \param w      The width of the texture in pixels.
+  \param h      The height of the texture in pixels.
+  
+  \return The created texture is returned, or NULL if no rendering context was
+          active,  the format was unsupported, or the width or height were out
+          of range.
+  
+  \note The contents of the texture are not defined at creation.
+  
+  \sa SDL_QueryTexture()
+  \sa SDL_UpdateTexture()
+  \sa SDL_DestroyTexture()
+ + +
+ +
proc createTextureFromSurface(renderer: ptr Renderer; surface: ptr Surface): ptr Texture {...}{.
+    importc: "SDL_CreateTextureFromSurface", cdecl.}
+
+ +
\brief Create a texture from an existing surface.
+  
+  \param renderer The renderer.
+  \param surface The surface containing pixel data used to fill the texture.
+  
+  \return The created texture is returned, or NULL on error.
+  
+  \note The surface is not modified or freed by this function.
+  
+  \sa SDL_QueryTexture()
+  \sa SDL_DestroyTexture()
+ + +
+ +
proc queryTexture(texture: ptr Texture; format: ptr Uint32; access: ptr cint; w: ptr cint;
+                 h: ptr cint): cint {...}{.importc: "SDL_QueryTexture", cdecl.}
+
+ +
\brief Query the attributes of a texture
+  
+  \param texture A texture to be queried.
+  \param format  A pointer filled in with the raw format of the texture.  The
+                 actual format may differ, but pixel transfers will use this
+                 format.
+  \param access  A pointer filled in with the actual access to the texture.
+  \param w       A pointer filled in with the width of the texture in pixels.
+  \param h       A pointer filled in with the height of the texture in pixels.
+  
+  \return 0 on success, or -1 if the texture is not valid.
+ + +
+ +
proc setTextureColorMod(texture: ptr Texture; r: Uint8; g: Uint8; b: Uint8): cint {...}{.
+    importc: "SDL_SetTextureColorMod", cdecl.}
+
+ +
\brief Set an additional color value used in render copy operations.
+  
+  \param texture The texture to update.
+  \param r       The red color value multiplied into copy operations.
+  \param g       The green color value multiplied into copy operations.
+  \param b       The blue color value multiplied into copy operations.
+  
+  \return 0 on success, or -1 if the texture is not valid or color modulation
+          is not supported.
+  
+  \sa SDL_GetTextureColorMod()
+ + +
+ +
proc getTextureColorMod(texture: ptr Texture; r: ptr Uint8; g: ptr Uint8; b: ptr Uint8): cint {...}{.
+    importc: "SDL_GetTextureColorMod", cdecl.}
+
+ +
\brief Get the additional color value used in render copy operations.
+  
+  \param texture The texture to query.
+  \param r         A pointer filled in with the current red color value.
+  \param g         A pointer filled in with the current green color value.
+  \param b         A pointer filled in with the current blue color value.
+  
+  \return 0 on success, or -1 if the texture is not valid.
+  
+  \sa SDL_SetTextureColorMod()
+ + +
+ +
proc setTextureAlphaMod(texture: ptr Texture; alpha: Uint8): cint {...}{.
+    importc: "SDL_SetTextureAlphaMod", cdecl.}
+
+ +
\brief Set an additional alpha value used in render copy operations.
+  
+  \param texture The texture to update.
+  \param alpha     The alpha value multiplied into copy operations.
+  
+  \return 0 on success, or -1 if the texture is not valid or alpha modulation
+          is not supported.
+  
+  \sa SDL_GetTextureAlphaMod()
+ + +
+ +
proc getTextureAlphaMod(texture: ptr Texture; alpha: ptr Uint8): cint {...}{.
+    importc: "SDL_GetTextureAlphaMod", cdecl.}
+
+ +
\brief Get the additional alpha value used in render copy operations.
+  
+  \param texture The texture to query.
+  \param alpha     A pointer filled in with the current alpha value.
+  
+  \return 0 on success, or -1 if the texture is not valid.
+  
+  \sa SDL_SetTextureAlphaMod()
+ + +
+ +
proc setTextureBlendMode(texture: ptr Texture; blendMode: BlendMode): cint {...}{.
+    importc: "SDL_SetTextureBlendMode", cdecl.}
+
+ +
\brief Set the blend mode used for texture copy operations.
+  
+  \param texture The texture to update.
+  \param blendMode ::SDL_BlendMode to use for texture blending.
+  
+  \return 0 on success, or -1 if the texture is not valid or the blend mode is
+          not supported.
+  
+  \note If the blend mode is not supported, the closest supported mode is
+        chosen.
+  
+  \sa SDL_GetTextureBlendMode()
+ + +
+ +
proc getTextureBlendMode(texture: ptr Texture; blendMode: ptr BlendMode): cint {...}{.
+    importc: "SDL_GetTextureBlendMode", cdecl.}
+
+ +
\brief Get the blend mode used for texture copy operations.
+  
+  \param texture   The texture to query.
+  \param blendMode A pointer filled in with the current blend mode.
+  
+  \return 0 on success, or -1 if the texture is not valid.
+  
+  \sa SDL_SetTextureBlendMode()
+ + +
+ +
proc setTextureScaleMode(texture: ptr Texture; scaleMode: ScaleMode): cint {...}{.
+    importc: "SDL_SetTextureScaleMode", cdecl.}
+
+ +
\brief Set the scale mode used for texture scale operations.
+  
+  \param texture The texture to update.
+  \param scaleMode ::SDL_ScaleMode to use for texture scaling.
+  
+  \return 0 on success, or -1 if the texture is not valid.
+  
+  \note If the scale mode is not supported, the closest supported mode is
+        chosen.
+  
+  \sa SDL_GetTextureScaleMode()
+ + +
+ +
proc getTextureScaleMode(texture: ptr Texture; scaleMode: ptr ScaleMode): cint {...}{.
+    importc: "SDL_GetTextureScaleMode", cdecl.}
+
+ +
\brief Get the scale mode used for texture scale operations.
+  
+  \param texture   The texture to query.
+  \param scaleMode A pointer filled in with the current scale mode.
+  
+  \return 0 on success, or -1 if the texture is not valid.
+  
+  \sa SDL_SetTextureScaleMode()
+ + +
+ +
proc updateTexture(texture: ptr Texture; rect: ptr Rect; pixels: pointer; pitch: cint): cint {...}{.
+    importc: "SDL_UpdateTexture", cdecl.}
+
+ +
\brief Update the given texture rectangle with new pixel data.
+  
+  \param texture   The texture to update
+  \param rect      A pointer to the rectangle of pixels to update, or NULL to
+                   update the entire texture.
+  \param pixels    The raw pixel data in the format of the texture.
+  \param pitch     The number of bytes in a row of pixel data, including padding between lines.
+  
+  The pixel data must be in the format of the texture. The pixel format can be
+  queried with SDL_QueryTexture.
+  
+  \return 0 on success, or -1 if the texture is not valid.
+  
+  \note This is a fairly slow function.
+ + +
+ +
proc updateYUVTexture(texture: ptr Texture; rect: ptr Rect; Yplane: ptr Uint8;
+                     Ypitch: cint; Uplane: ptr Uint8; Upitch: cint; Vplane: ptr Uint8;
+                     Vpitch: cint): cint {...}{.importc: "SDL_UpdateYUVTexture", cdecl.}
+
+ +
\brief Update a rectangle within a planar YV12 or IYUV texture with new pixel data.
+  
+  \param texture   The texture to update
+  \param rect      A pointer to the rectangle of pixels to update, or NULL to
+                   update the entire texture.
+  \param Yplane    The raw pixel data for the Y plane.
+  \param Ypitch    The number of bytes between rows of pixel data for the Y plane.
+  \param Uplane    The raw pixel data for the U plane.
+  \param Upitch    The number of bytes between rows of pixel data for the U plane.
+  \param Vplane    The raw pixel data for the V plane.
+  \param Vpitch    The number of bytes between rows of pixel data for the V plane.
+  
+  \return 0 on success, or -1 if the texture is not valid.
+  
+  \note You can use SDL_UpdateTexture() as long as your pixel data is
+        a contiguous block of Y and U/V planes in the proper order, but
+        this function is available if your pixel data is not contiguous.
+ + +
+ +
proc lockTexture(texture: ptr Texture; rect: ptr Rect; pixels: ptr pointer;
+                pitch: ptr cint): cint {...}{.importc: "SDL_LockTexture", cdecl.}
+
+ +
\brief Lock a portion of the texture for write-only pixel access.
+  
+  \param texture   The texture to lock for access, which was created with
+                   ::SDL_TEXTUREACCESS_STREAMING.
+  \param rect      A pointer to the rectangle to lock for access. If the rect
+                   is NULL, the entire texture will be locked.
+  \param pixels    This is filled in with a pointer to the locked pixels,
+                   appropriately offset by the locked area.
+  \param pitch     This is filled in with the pitch of the locked pixels.
+  
+  \return 0 on success, or -1 if the texture is not valid or was not created with ::SDL_TEXTUREACCESS_STREAMING.
+  
+  \sa SDL_UnlockTexture()
+ + +
+ +
proc lockTextureToSurface(texture: ptr Texture; rect: ptr Rect;
+                         surface: ptr ptr Surface): cint {...}{.
+    importc: "SDL_LockTextureToSurface", cdecl.}
+
+ +
\brief Lock a portion of the texture for write-only pixel access.
+         Expose it as a SDL surface.
+  
+  \param texture   The texture to lock for access, which was created with
+                   ::SDL_TEXTUREACCESS_STREAMING.
+  \param rect      A pointer to the rectangle to lock for access. If the rect
+                   is NULL, the entire texture will be locked.
+  \param surface   This is filled in with a SDL surface representing the locked area
+                   Surface is freed internally after calling SDL_UnlockTexture or SDL_DestroyTexture.
+  
+  \return 0 on success, or -1 if the texture is not valid or was not created with ::SDL_TEXTUREACCESS_STREAMING.
+  
+  \sa SDL_UnlockTexture()
+ + +
+ +
proc unlockTexture(texture: ptr Texture) {...}{.importc: "SDL_UnlockTexture", cdecl.}
+
+ +
\brief Unlock a texture, uploading the changes to video memory, if needed.
+         If SDL_LockTextureToSurface() was called for locking, the SDL surface is freed.
+  
+  \sa SDL_LockTexture()
+  \sa SDL_LockTextureToSurface()
+ + +
+ +
proc renderTargetSupported(renderer: ptr Renderer): bool {...}{.
+    importc: "SDL_RenderTargetSupported", cdecl.}
+
+ +
\brief Determines whether a window supports the use of render targets
+ 
+ \param renderer The renderer that will be checked
+ 
+ \return SDL_TRUE if supported, SDL_FALSE if not.
+ + +
+ +
proc setRenderTarget(renderer: ptr Renderer; texture: ptr Texture): cint {...}{.
+    importc: "SDL_SetRenderTarget", cdecl.}
+
+ +
\brief Set a texture as the current rendering target.
+ 
+ \param renderer The renderer.
+ \param texture The targeted texture, which must be created with the SDL_TEXTUREACCESS_TARGET flag, or NULL for the default render target
+ 
+ \return 0 on success, or -1 on error
+  
+  \sa SDL_GetRenderTarget()
+ + +
+ +
proc getRenderTarget(renderer: ptr Renderer): ptr Texture {...}{.
+    importc: "SDL_GetRenderTarget", cdecl.}
+
+ +
\brief Get the current render target or NULL for the default render target.
+ 
+ \return The current render target
+  
+  \sa SDL_SetRenderTarget()
+ + +
+ +
proc renderSetLogicalSize(renderer: ptr Renderer; w: cint; h: cint): cint {...}{.
+    importc: "SDL_RenderSetLogicalSize", cdecl.}
+
+ +
\brief Set device independent resolution for rendering
+  
+  \param renderer The renderer for which resolution should be set.
+  \param w      The width of the logical resolution
+  \param h      The height of the logical resolution
+  
+  This function uses the viewport and scaling functionality to allow a fixed logical
+  resolution for rendering, regardless of the actual output resolution.  If the actual
+  output resolution doesn't have the same aspect ratio the output rendering will be
+  centered within the output display.
+  
+  If the output display is a window, mouse events in the window will be filtered
+  and scaled so they seem to arrive within the logical resolution.
+  
+  \note If this function results in scaling or subpixel drawing by the
+        rendering backend, it will be handled using the appropriate
+        quality hints.
+  
+  \sa SDL_RenderGetLogicalSize()
+  \sa SDL_RenderSetScale()
+  \sa SDL_RenderSetViewport()
+ + +
+ +
proc renderGetLogicalSize(renderer: ptr Renderer; w: ptr cint; h: ptr cint) {...}{.
+    importc: "SDL_RenderGetLogicalSize", cdecl.}
+
+ +
\brief Get device independent resolution for rendering
+  
+  \param renderer The renderer from which resolution should be queried.
+  \param w      A pointer filled with the width of the logical resolution
+  \param h      A pointer filled with the height of the logical resolution
+  
+  \sa SDL_RenderSetLogicalSize()
+ + +
+ +
proc renderSetIntegerScale(renderer: ptr Renderer; enable: bool): cint {...}{.
+    importc: "SDL_RenderSetIntegerScale", cdecl.}
+
+ +
\brief Set whether to force integer scales for resolution-independent rendering
+  
+  \param renderer The renderer for which integer scaling should be set.
+  \param enable   Enable or disable integer scaling
+  
+  This function restricts the logical viewport to integer values - that is, when
+  a resolution is between two multiples of a logical size, the viewport size is
+  rounded down to the lower multiple.
+  
+  \sa SDL_RenderSetLogicalSize()
+ + +
+ +
proc renderGetIntegerScale(renderer: ptr Renderer): bool {...}{.
+    importc: "SDL_RenderGetIntegerScale", cdecl.}
+
+ +
\brief Get whether integer scales are forced for resolution-independent rendering
+  
+  \param renderer The renderer from which integer scaling should be queried.
+  
+  \sa SDL_RenderSetIntegerScale()
+ + +
+ +
proc renderSetViewport(renderer: ptr Renderer; rect: ptr Rect): cint {...}{.
+    importc: "SDL_RenderSetViewport", cdecl.}
+
+ +
\brief Set the drawing area for rendering on the current target.
+  
+  \param renderer The renderer for which the drawing area should be set.
+  \param rect The rectangle representing the drawing area, or NULL to set the viewport to the entire target.
+  
+  The x,y of the viewport rect represents the origin for rendering.
+  
+  \return 0 on success, or -1 on error
+  
+  \note If the window associated with the renderer is resized, the viewport is automatically reset.
+  
+  \sa SDL_RenderGetViewport()
+  \sa SDL_RenderSetLogicalSize()
+ + +
+ +
proc renderGetViewport(renderer: ptr Renderer; rect: ptr Rect) {...}{.
+    importc: "SDL_RenderGetViewport", cdecl.}
+
+ +
\brief Get the drawing area for the current target.
+  
+  \sa SDL_RenderSetViewport()
+ + +
+ +
proc renderSetClipRect(renderer: ptr Renderer; rect: ptr Rect): cint {...}{.
+    importc: "SDL_RenderSetClipRect", cdecl.}
+
+ +
\brief Set the clip rectangle for the current target.
+  
+  \param renderer The renderer for which clip rectangle should be set.
+  \param rect   A pointer to the rectangle to set as the clip rectangle,
+                relative to the viewport, or NULL to disable clipping.
+  
+  \return 0 on success, or -1 on error
+  
+  \sa SDL_RenderGetClipRect()
+ + +
+ +
proc renderGetClipRect(renderer: ptr Renderer; rect: ptr Rect) {...}{.
+    importc: "SDL_RenderGetClipRect", cdecl.}
+
+ +
\brief Get the clip rectangle for the current target.
+  
+  \param renderer The renderer from which clip rectangle should be queried.
+  \param rect   A pointer filled in with the current clip rectangle, or
+                an empty rectangle if clipping is disabled.
+  
+  \sa SDL_RenderSetClipRect()
+ + +
+ +
proc renderIsClipEnabled(renderer: ptr Renderer): bool {...}{.
+    importc: "SDL_RenderIsClipEnabled", cdecl.}
+
+ +
\brief Get whether clipping is enabled on the given renderer.
+  
+  \param renderer The renderer from which clip state should be queried.
+  
+  \sa SDL_RenderGetClipRect()
+ + +
+ +
proc renderSetScale(renderer: ptr Renderer; scaleX: cfloat; scaleY: cfloat): cint {...}{.
+    importc: "SDL_RenderSetScale", cdecl.}
+
+ +
\brief Set the drawing scale for rendering on the current target.
+  
+  \param renderer The renderer for which the drawing scale should be set.
+  \param scaleX The horizontal scaling factor
+  \param scaleY The vertical scaling factor
+  
+  The drawing coordinates are scaled by the x/y scaling factors
+  before they are used by the renderer.  This allows resolution
+  independent drawing with a single coordinate system.
+  
+  \note If this results in scaling or subpixel drawing by the
+        rendering backend, it will be handled using the appropriate
+        quality hints.  For best results use integer scaling factors.
+  
+  \sa SDL_RenderGetScale()
+  \sa SDL_RenderSetLogicalSize()
+ + +
+ +
proc renderGetScale(renderer: ptr Renderer; scaleX: ptr cfloat; scaleY: ptr cfloat) {...}{.
+    importc: "SDL_RenderGetScale", cdecl.}
+
+ +
\brief Get the drawing scale for the current target.
+  
+  \param renderer The renderer from which drawing scale should be queried.
+  \param scaleX A pointer filled in with the horizontal scaling factor
+  \param scaleY A pointer filled in with the vertical scaling factor
+  
+  \sa SDL_RenderSetScale()
+ + +
+ +
proc setRenderDrawColor(renderer: ptr Renderer; r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint {...}{.
+    importc: "SDL_SetRenderDrawColor", cdecl.}
+
+ +
\brief Set the color used for drawing operations (Rect, Line and Clear).
+  
+  \param renderer The renderer for which drawing color should be set.
+  \param r The red value used to draw on the rendering target.
+  \param g The green value used to draw on the rendering target.
+  \param b The blue value used to draw on the rendering target.
+  \param a The alpha value used to draw on the rendering target, usually
+           ::SDL_ALPHA_OPAQUE (255).
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc getRenderDrawColor(renderer: ptr Renderer; r: ptr Uint8; g: ptr Uint8; b: ptr Uint8;
+                       a: ptr Uint8): cint {...}{.importc: "SDL_GetRenderDrawColor", cdecl.}
+
+ +
\brief Get the color used for drawing operations (Rect, Line and Clear).
+  
+  \param renderer The renderer from which drawing color should be queried.
+  \param r A pointer to the red value used to draw on the rendering target.
+  \param g A pointer to the green value used to draw on the rendering target.
+  \param b A pointer to the blue value used to draw on the rendering target.
+  \param a A pointer to the alpha value used to draw on the rendering target,
+           usually ::SDL_ALPHA_OPAQUE (255).
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc setRenderDrawBlendMode(renderer: ptr Renderer; blendMode: BlendMode): cint {...}{.
+    importc: "SDL_SetRenderDrawBlendMode", cdecl.}
+
+ +
\brief Set the blend mode used for drawing operations (Fill and Line).
+  
+  \param renderer The renderer for which blend mode should be set.
+  \param blendMode ::SDL_BlendMode to use for blending.
+  
+  \return 0 on success, or -1 on error
+  
+  \note If the blend mode is not supported, the closest supported mode is
+        chosen.
+  
+  \sa SDL_GetRenderDrawBlendMode()
+ + +
+ +
proc getRenderDrawBlendMode(renderer: ptr Renderer; blendMode: ptr BlendMode): cint {...}{.
+    importc: "SDL_GetRenderDrawBlendMode", cdecl.}
+
+ +
\brief Get the blend mode used for drawing operations.
+  
+  \param renderer The renderer from which blend mode should be queried.
+  \param blendMode A pointer filled in with the current blend mode.
+  
+  \return 0 on success, or -1 on error
+  
+  \sa SDL_SetRenderDrawBlendMode()
+ + +
+ +
proc renderClear(renderer: ptr Renderer): cint {...}{.importc: "SDL_RenderClear", cdecl.}
+
+ +
\brief Clear the current rendering target with the drawing color
+  
+  This function clears the entire rendering target, ignoring the viewport and
+  the clip rectangle.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderDrawPoint(renderer: ptr Renderer; x: cint; y: cint): cint {...}{.
+    importc: "SDL_RenderDrawPoint", cdecl.}
+
+ +
\brief Draw a point on the current rendering target.
+  
+  \param renderer The renderer which should draw a point.
+  \param x The x coordinate of the point.
+  \param y The y coordinate of the point.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderDrawPoints(renderer: ptr Renderer; points: ptr Point; count: cint): cint {...}{.
+    importc: "SDL_RenderDrawPoints", cdecl.}
+
+ +
\brief Draw multiple points on the current rendering target.
+  
+  \param renderer The renderer which should draw multiple points.
+  \param points The points to draw
+  \param count The number of points to draw
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderDrawLine(renderer: ptr Renderer; x1: cint; y1: cint; x2: cint; y2: cint): cint {...}{.
+    importc: "SDL_RenderDrawLine", cdecl.}
+
+ +
\brief Draw a line on the current rendering target.
+  
+  \param renderer The renderer which should draw a line.
+  \param x1 The x coordinate of the start point.
+  \param y1 The y coordinate of the start point.
+  \param x2 The x coordinate of the end point.
+  \param y2 The y coordinate of the end point.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderDrawLines(renderer: ptr Renderer; points: ptr Point; count: cint): cint {...}{.
+    importc: "SDL_RenderDrawLines", cdecl.}
+
+ +
\brief Draw a series of connected lines on the current rendering target.
+  
+  \param renderer The renderer which should draw multiple lines.
+  \param points The points along the lines
+  \param count The number of points, drawing count-1 lines
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderDrawRect(renderer: ptr Renderer; rect: ptr Rect): cint {...}{.
+    importc: "SDL_RenderDrawRect", cdecl.}
+
+ +
\brief Draw a rectangle on the current rendering target.
+  
+  \param renderer The renderer which should draw a rectangle.
+  \param rect A pointer to the destination rectangle, or NULL to outline the entire rendering target.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderDrawRects(renderer: ptr Renderer; rects: ptr Rect; count: cint): cint {...}{.
+    importc: "SDL_RenderDrawRects", cdecl.}
+
+ +
\brief Draw some number of rectangles on the current rendering target.
+  
+  \param renderer The renderer which should draw multiple rectangles.
+  \param rects A pointer to an array of destination rectangles.
+  \param count The number of rectangles.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderFillRect(renderer: ptr Renderer; rect: ptr Rect): cint {...}{.
+    importc: "SDL_RenderFillRect", cdecl.}
+
+ +
\brief Fill a rectangle on the current rendering target with the drawing color.
+  
+  \param renderer The renderer which should fill a rectangle.
+  \param rect A pointer to the destination rectangle, or NULL for the entire
+              rendering target.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderFillRects(renderer: ptr Renderer; rects: ptr Rect; count: cint): cint {...}{.
+    importc: "SDL_RenderFillRects", cdecl.}
+
+ +
\brief Fill some number of rectangles on the current rendering target with the drawing color.
+  
+  \param renderer The renderer which should fill multiple rectangles.
+  \param rects A pointer to an array of destination rectangles.
+  \param count The number of rectangles.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderCopy(renderer: ptr Renderer; texture: ptr Texture; srcrect: ptr Rect;
+               dstrect: ptr Rect): cint {...}{.importc: "SDL_RenderCopy", cdecl.}
+
+ +
\brief Copy a portion of the texture to the current rendering target.
+  
+  \param renderer The renderer which should copy parts of a texture.
+  \param texture The source texture.
+  \param srcrect   A pointer to the source rectangle, or NULL for the entire
+                   texture.
+  \param dstrect   A pointer to the destination rectangle, or NULL for the
+                   entire rendering target.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderCopyEx(renderer: ptr Renderer; texture: ptr Texture; srcrect: ptr Rect;
+                 dstrect: ptr Rect; angle: cdouble; center: ptr Point;
+                 flip: RendererFlip): cint {...}{.importc: "SDL_RenderCopyEx", cdecl.}
+
+ +
\brief Copy a portion of the source texture to the current rendering target, rotating it by angle around the given center
+  
+  \param renderer The renderer which should copy parts of a texture.
+  \param texture The source texture.
+  \param srcrect   A pointer to the source rectangle, or NULL for the entire
+                   texture.
+  \param dstrect   A pointer to the destination rectangle, or NULL for the
+                   entire rendering target.
+  \param angle    An angle in degrees that indicates the rotation that will be applied to dstrect, rotating it in a clockwise direction
+  \param center   A pointer to a point indicating the point around which dstrect will be rotated (if NULL, rotation will be done around dstrect.w/2, dstrect.h/2).
+  \param flip     An SDL_RendererFlip value stating which flipping actions should be performed on the texture
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderDrawPointF(renderer: ptr Renderer; x: cfloat; y: cfloat): cint {...}{.
+    importc: "SDL_RenderDrawPointF", cdecl.}
+
+ +
\brief Draw a point on the current rendering target.
+  
+  \param renderer The renderer which should draw a point.
+  \param x The x coordinate of the point.
+  \param y The y coordinate of the point.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderDrawPointsF(renderer: ptr Renderer; points: ptr FPoint; count: cint): cint {...}{.
+    importc: "SDL_RenderDrawPointsF", cdecl.}
+
+ +
\brief Draw multiple points on the current rendering target.
+  
+  \param renderer The renderer which should draw multiple points.
+  \param points The points to draw
+  \param count The number of points to draw
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderDrawLineF(renderer: ptr Renderer; x1: cfloat; y1: cfloat; x2: cfloat;
+                    y2: cfloat): cint {...}{.importc: "SDL_RenderDrawLineF", cdecl.}
+
+ +
\brief Draw a line on the current rendering target.
+  
+  \param renderer The renderer which should draw a line.
+  \param x1 The x coordinate of the start point.
+  \param y1 The y coordinate of the start point.
+  \param x2 The x coordinate of the end point.
+  \param y2 The y coordinate of the end point.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderDrawLinesF(renderer: ptr Renderer; points: ptr FPoint; count: cint): cint {...}{.
+    importc: "SDL_RenderDrawLinesF", cdecl.}
+
+ +
\brief Draw a series of connected lines on the current rendering target.
+  
+  \param renderer The renderer which should draw multiple lines.
+  \param points The points along the lines
+  \param count The number of points, drawing count-1 lines
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderDrawRectF(renderer: ptr Renderer; rect: ptr FRect): cint {...}{.
+    importc: "SDL_RenderDrawRectF", cdecl.}
+
+ +
\brief Draw a rectangle on the current rendering target.
+  
+  \param renderer The renderer which should draw a rectangle.
+  \param rect A pointer to the destination rectangle, or NULL to outline the entire rendering target.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderDrawRectsF(renderer: ptr Renderer; rects: ptr FRect; count: cint): cint {...}{.
+    importc: "SDL_RenderDrawRectsF", cdecl.}
+
+ +
\brief Draw some number of rectangles on the current rendering target.
+  
+  \param renderer The renderer which should draw multiple rectangles.
+  \param rects A pointer to an array of destination rectangles.
+  \param count The number of rectangles.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderFillRectF(renderer: ptr Renderer; rect: ptr FRect): cint {...}{.
+    importc: "SDL_RenderFillRectF", cdecl.}
+
+ +
\brief Fill a rectangle on the current rendering target with the drawing color.
+  
+  \param renderer The renderer which should fill a rectangle.
+  \param rect A pointer to the destination rectangle, or NULL for the entire
+              rendering target.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderFillRectsF(renderer: ptr Renderer; rects: ptr FRect; count: cint): cint {...}{.
+    importc: "SDL_RenderFillRectsF", cdecl.}
+
+ +
\brief Fill some number of rectangles on the current rendering target with the drawing color.
+  
+  \param renderer The renderer which should fill multiple rectangles.
+  \param rects A pointer to an array of destination rectangles.
+  \param count The number of rectangles.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderCopyF(renderer: ptr Renderer; texture: ptr Texture; srcrect: ptr Rect;
+                dstrect: ptr FRect): cint {...}{.importc: "SDL_RenderCopyF", cdecl.}
+
+ +
\brief Copy a portion of the texture to the current rendering target.
+  
+  \param renderer The renderer which should copy parts of a texture.
+  \param texture The source texture.
+  \param srcrect   A pointer to the source rectangle, or NULL for the entire
+                   texture.
+  \param dstrect   A pointer to the destination rectangle, or NULL for the
+                   entire rendering target.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderCopyExF(renderer: ptr Renderer; texture: ptr Texture; srcrect: ptr Rect;
+                  dstrect: ptr FRect; angle: cdouble; center: ptr FPoint;
+                  flip: RendererFlip): cint {...}{.importc: "SDL_RenderCopyExF", cdecl.}
+
+ +
\brief Copy a portion of the source texture to the current rendering target, rotating it by angle around the given center
+  
+  \param renderer The renderer which should copy parts of a texture.
+  \param texture The source texture.
+  \param srcrect   A pointer to the source rectangle, or NULL for the entire
+                   texture.
+  \param dstrect   A pointer to the destination rectangle, or NULL for the
+                   entire rendering target.
+  \param angle    An angle in degrees that indicates the rotation that will be applied to dstrect, rotating it in a clockwise direction
+  \param center   A pointer to a point indicating the point around which dstrect will be rotated (if NULL, rotation will be done around dstrect.w/2, dstrect.h/2).
+  \param flip     An SDL_RendererFlip value stating which flipping actions should be performed on the texture
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderReadPixels(renderer: ptr Renderer; rect: ptr Rect; format: Uint32;
+                     pixels: pointer; pitch: cint): cint {...}{.
+    importc: "SDL_RenderReadPixels", cdecl.}
+
+ +
\brief Read pixels from the current rendering target.
+  
+  \param renderer The renderer from which pixels should be read.
+  \param rect   A pointer to the rectangle to read, or NULL for the entire
+                render target.
+  \param format The desired format of the pixel data, or 0 to use the format
+                of the rendering target
+  \param pixels A pointer to be filled in with the pixel data
+  \param pitch  The pitch of the pixels parameter.
+  
+  \return 0 on success, or -1 if pixel reading is not supported.
+  
+  \warning This is a very slow operation, and should not be used frequently.
+ + +
+ +
proc renderPresent(renderer: ptr Renderer) {...}{.importc: "SDL_RenderPresent", cdecl.}
+
+ +
\brief Update the screen with rendering performed.
+ + +
+ +
proc destroyTexture(texture: ptr Texture) {...}{.importc: "SDL_DestroyTexture", cdecl.}
+
+ +
\brief Destroy the specified texture.
+  
+  \sa SDL_CreateTexture()
+  \sa SDL_CreateTextureFromSurface()
+ + +
+ +
proc destroyRenderer(renderer: ptr Renderer) {...}{.importc: "SDL_DestroyRenderer", cdecl.}
+
+ +
\brief Destroy the rendering context for a window and free associated
+         textures.
+  
+  \sa SDL_CreateRenderer()
+ + +
+ +
proc renderFlush(renderer: ptr Renderer): cint {...}{.importc: "SDL_RenderFlush", cdecl.}
+
+ +
\brief Force the rendering context to flush any pending commands to the
+         underlying rendering API.
+  
+  You do not need to (and in fact, shouldn't) call this function unless
+  you are planning to call into OpenGL/Direct3D/Metal/whatever directly
+  in addition to using an SDL_Renderer.
+  
+  This is for a very-specific case: if you are using SDL's render API,
+  you asked for a specific renderer backend (OpenGL, Direct3D, etc),
+  you set SDL_HINT_RENDER_BATCHING to "1", and you plan to make
+  OpenGL/D3D/whatever calls in addition to SDL render API calls. If all of
+  this applies, you should call SDL_RenderFlush() between calls to SDL's
+  render API and the low-level API you're using in cooperation.
+  
+  In all other cases, you can ignore this function. This is only here to
+  get maximum performance out of a specific situation. In all other cases,
+  SDL will do the right thing, perhaps at a performance loss.
+  
+  This function is first available in SDL 2.0.10, and is not needed in
+  2.0.9 and earlier, as earlier versions did not queue rendering commands
+  at all, instead flushing them to the OS immediately.
+ + +
+ +
proc gL_BindTexture(texture: ptr Texture; texw: ptr cfloat; texh: ptr cfloat): cint {...}{.
+    importc: "SDL_GL_BindTexture", cdecl.}
+
+ +
\brief Bind the texture to the current OpenGL/ES/ES2 context for use with
+         OpenGL instructions.
+  
+  \param texture  The SDL texture to bind
+  \param texw     A pointer to a float that will be filled with the texture width
+  \param texh     A pointer to a float that will be filled with the texture height
+  
+  \return 0 on success, or -1 if the operation is not supported
+ + +
+ +
proc gL_UnbindTexture(texture: ptr Texture): cint {...}{.importc: "SDL_GL_UnbindTexture",
+    cdecl.}
+
+ +
\brief Unbind a texture from the current OpenGL/ES/ES2 context.
+  
+  \param texture  The SDL texture to unbind
+  
+  \return 0 on success, or -1 if the operation is not supported
+ + +
+ +
proc renderGetMetalLayer(renderer: ptr Renderer): pointer {...}{.
+    importc: "SDL_RenderGetMetalLayer", cdecl.}
+
+ +
\brief Get the CAMetalLayer associated with the given Metal renderer
+  
+  \param renderer The renderer to query
+  
+  \return CAMetalLayer on success, or NULL if the renderer isn't a Metal renderer
+  
+  \sa SDL_RenderGetMetalCommandEncoder()
+ + +
+ +
proc renderGetMetalCommandEncoder(renderer: ptr Renderer): pointer {...}{.
+    importc: "SDL_RenderGetMetalCommandEncoder", cdecl.}
+
+ +
\brief Get the Metal command encoder for the current frame
+  
+  \param renderer The renderer to query
+  
+  \return id<MTLRenderCommandEncoder> on success, or NULL if the renderer isn't a Metal renderer
+  
+  \sa SDL_RenderGetMetalLayer()
+ + +
+ +
proc numSensors(): cint {...}{.importc: "SDL_NumSensors", cdecl.}
+
+ +
Gyroscope sensor
+ 
+ The gyroscope returns the current rate of rotation in radians per second.
+ The rotation is positive in the counter-clockwise direction. That is,
+ an observer looking from a positive location on one of the axes would
+ see positive rotation on that axis when it appeared to be rotating
+ counter-clockwise.
+ 
+ values[0]: Angular speed around the x axis
+ values[1]: Angular speed around the y axis
+ values[2]: Angular speed around the z axis
+ 
+ For phones held in portrait mode, the axes are defined as follows:
+ -X ... +X : left ... right
+ -Y ... +Y : bottom ... top
+ -Z ... +Z : farther ... closer
+ 
+ The axis data is not changed when the phone is rotated.
+ 
+ \sa SDL_GetDisplayOrientation()
+Function prototypes
+\brief Count the number of sensors attached to the system right now
+ + +
+ +
proc sensorGetDeviceName(deviceIndex: cint): cstring {...}{.
+    importc: "SDL_SensorGetDeviceName", cdecl.}
+
+ +
\brief Get the implementation dependent name of a sensor.
+  
+  This can be called before any sensors are opened.
+  
+  \return The sensor name, or NULL if device_index is out of range.
+ + +
+ +
proc sensorGetDeviceType(deviceIndex: cint): SensorType {...}{.
+    importc: "SDL_SensorGetDeviceType", cdecl.}
+
+ +
\brief Get the type of a sensor.
+  
+  This can be called before any sensors are opened.
+  
+  \return The sensor type, or SDL_SENSOR_INVALID if device_index is out of range.
+ + +
+ +
proc sensorGetDeviceNonPortableType(deviceIndex: cint): cint {...}{.
+    importc: "SDL_SensorGetDeviceNonPortableType", cdecl.}
+
+ +
\brief Get the platform dependent type of a sensor.
+  
+  This can be called before any sensors are opened.
+  
+  \return The sensor platform dependent type, or -1 if device_index is out of range.
+ + +
+ +
proc sensorGetDeviceInstanceID(deviceIndex: cint): SensorID {...}{.
+    importc: "SDL_SensorGetDeviceInstanceID", cdecl.}
+
+ +
\brief Get the instance ID of a sensor.
+  
+  This can be called before any sensors are opened.
+  
+  \return The sensor instance ID, or -1 if device_index is out of range.
+ + +
+ +
proc sensorOpen(deviceIndex: cint): ptr Sensor {...}{.importc: "SDL_SensorOpen", cdecl.}
+
+ +
\brief Open a sensor for use.
+  
+  The index passed as an argument refers to the N'th sensor on the system.
+  
+  \return A sensor identifier, or NULL if an error occurred.
+ + +
+ +
proc sensorFromInstanceID(instanceId: SensorID): ptr Sensor {...}{.
+    importc: "SDL_SensorFromInstanceID", cdecl.}
+
+ +
Return the SDL_Sensor associated with an instance id.
+ + +
+ +
proc sensorGetName(sensor: ptr Sensor): cstring {...}{.importc: "SDL_SensorGetName", cdecl.}
+
+ +
\brief Get the implementation dependent name of a sensor.
+  
+  \return The sensor name, or NULL if the sensor is NULL.
+ + +
+ +
proc sensorGetType(sensor: ptr Sensor): SensorType {...}{.importc: "SDL_SensorGetType",
+    cdecl.}
+
+ +
\brief Get the type of a sensor.
+  
+  This can be called before any sensors are opened.
+  
+  \return The sensor type, or SDL_SENSOR_INVALID if the sensor is NULL.
+ + +
+ +
proc sensorGetNonPortableType(sensor: ptr Sensor): cint {...}{.
+    importc: "SDL_SensorGetNonPortableType", cdecl.}
+
+ +
\brief Get the platform dependent type of a sensor.
+  
+  This can be called before any sensors are opened.
+  
+  \return The sensor platform dependent type, or -1 if the sensor is NULL.
+ + +
+ +
proc sensorGetInstanceID(sensor: ptr Sensor): SensorID {...}{.
+    importc: "SDL_SensorGetInstanceID", cdecl.}
+
+ +
\brief Get the instance ID of a sensor.
+  
+  This can be called before any sensors are opened.
+  
+  \return The sensor instance ID, or -1 if the sensor is NULL.
+ + +
+ +
proc sensorGetData(sensor: ptr Sensor; data: ptr cfloat; numValues: cint): cint {...}{.
+    importc: "SDL_SensorGetData", cdecl.}
+
+ +
Get the current state of an opened sensor.
+  
+  The number of values and interpretation of the data is sensor dependent.
+  
+  \param sensor The sensor to query
+  \param data A pointer filled with the current sensor state
+  \param num_values The number of values to write to data
+  
+  \return 0 or -1 if an error occurred.
+ + +
+ +
proc sensorClose(sensor: ptr Sensor) {...}{.importc: "SDL_SensorClose", cdecl.}
+
+ +
Close a sensor previously opened with SDL_SensorOpen()
+ + +
+ +
proc sensorUpdate() {...}{.importc: "SDL_SensorUpdate", cdecl.}
+
+ +
Update the current state of the open sensors.
+  
+  This is called automatically by the event loop if sensor events are enabled.
+  
+  This needs to be called from the thread that initialized the sensor subsystem.
+ + +
+ +
proc createShapedWindow(title: cstring; x: cuint; y: cuint; w: cuint; h: cuint;
+                       flags: Uint32): ptr Window {...}{.
+    importc: "SDL_CreateShapedWindow", cdecl.}
+
+ +
\brief Create a window that can be shaped with the specified position, dimensions, and flags.
+  
+  \param title The title of the window, in UTF-8 encoding.
+  \param x     The x position of the window, ::SDL_WINDOWPOS_CENTERED, or
+               ::SDL_WINDOWPOS_UNDEFINED.
+  \param y     The y position of the window, ::SDL_WINDOWPOS_CENTERED, or
+               ::SDL_WINDOWPOS_UNDEFINED.
+  \param w     The width of the window.
+  \param h     The height of the window.
+  \param flags The flags for the window, a mask of SDL_WINDOW_BORDERLESS with any of the following:
+               ::SDL_WINDOW_OPENGL,     ::SDL_WINDOW_INPUT_GRABBED,
+               ::SDL_WINDOW_HIDDEN,     ::SDL_WINDOW_RESIZABLE,
+               ::SDL_WINDOW_MAXIMIZED,  ::SDL_WINDOW_MINIMIZED,
+       ::SDL_WINDOW_BORDERLESS is always set, and ::SDL_WINDOW_FULLSCREEN is always unset.
+  
+  \return The window created, or NULL if window creation failed.
+  
+  \sa SDL_DestroyWindow()
+ + +
+ +
proc isShapedWindow(window: ptr Window): bool {...}{.importc: "SDL_IsShapedWindow", cdecl.}
+
+ +
\brief Return whether the given window is a shaped window.
+ 
+ \param window The window to query for being shaped.
+ 
+ \return SDL_TRUE if the window is a window that can be shaped, SDL_FALSE if the window is unshaped or NULL.
+ 
+ \sa SDL_CreateShapedWindow
+ + +
+ +
proc setWindowShape(window: ptr Window; shape: ptr Surface;
+                   shapeMode: ptr WindowShapeMode): cint {...}{.
+    importc: "SDL_SetWindowShape", cdecl.}
+
+ +
\brief Set the shape and parameters of a shaped window.
+ 
+ \param window The shaped window whose parameters should be set.
+ \param shape A surface encoding the desired shape for the window.
+ \param shape_mode The parameters to set for the shaped window.
+ 
+ \return 0 on success, SDL_INVALID_SHAPE_ARGUMENT on an invalid shape argument, or SDL_NONSHAPEABLE_WINDOW
+           if the SDL_Window given does not reference a valid shaped window.
+ 
+ \sa SDL_WindowShapeMode
+ \sa SDL_GetShapedWindowMode.
+ + +
+ +
proc getShapedWindowMode(window: ptr Window; shapeMode: ptr WindowShapeMode): cint {...}{.
+    importc: "SDL_GetShapedWindowMode", cdecl.}
+
+ +
\brief Get the shape parameters of a shaped window.
+ 
+ \param window The shaped window whose parameters should be retrieved.
+ \param shape_mode An empty shape-mode structure to fill, or NULL to check whether the window has a shape.
+ 
+ \return 0 if the window has a shape and, provided shape_mode was not NULL, shape_mode has been filled with the mode
+           data, SDL_NONSHAPEABLE_WINDOW if the SDL_Window given is not a shaped window, or SDL_WINDOW_LACKS_SHAPE if
+           the SDL_Window given is a shapeable window currently lacking a shape.
+ 
+ \sa SDL_WindowShapeMode
+ \sa SDL_SetWindowShape
+ + +
+ +
proc isTablet(): bool {...}{.importc: "SDL_IsTablet", cdecl.}
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+Platform specific functions for Windows
+Platform specific functions for Linux
+Platform specific functions for iOS
+Platform specific functions for Android
+Platform specific functions for WinRT
+\brief Return true if the current device is a tablet.
+ + +
+ +
proc onApplicationWillTerminate() {...}{.importc: "SDL_OnApplicationWillTerminate", cdecl.}
+
+ +
Functions used by iOS application delegates to notify SDL about state changes
+ + +
+ +
proc onApplicationDidReceiveMemoryWarning() {...}{.
+    importc: "SDL_OnApplicationDidReceiveMemoryWarning", cdecl.}
+
+ + + +
+ +
proc onApplicationWillResignActive() {...}{.importc: "SDL_OnApplicationWillResignActive",
+                                     cdecl.}
+
+ + + +
+ +
proc onApplicationDidEnterBackground() {...}{.importc: "SDL_OnApplicationDidEnterBackground",
+                                       cdecl.}
+
+ + + +
+ +
proc onApplicationWillEnterForeground() {...}{.importc: "SDL_OnApplicationWillEnterForeground",
+                                        cdecl.}
+
+ + + +
+ +
proc onApplicationDidBecomeActive() {...}{.importc: "SDL_OnApplicationDidBecomeActive",
+                                    cdecl.}
+
+ + + +
+ +
proc getTicks(): Uint32 {...}{.importc: "SDL_GetTicks", cdecl.}
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+\brief Get the number of milliseconds since the SDL library initialization.
+ 
+ \note This value wraps if the program runs for more than ~49 days.
+ + +
+ +
proc getPerformanceCounter(): Uint64 {...}{.importc: "SDL_GetPerformanceCounter", cdecl.}
+
+ +
\brief Get the current value of the high resolution counter
+ + +
+ +
proc getPerformanceFrequency(): Uint64 {...}{.importc: "SDL_GetPerformanceFrequency",
+                                      cdecl.}
+
+ +
\brief Get the count per second of the high resolution counter
+ + +
+ +
proc delay(ms: Uint32) {...}{.importc: "SDL_Delay", cdecl.}
+
+ +
\brief Wait a specified number of milliseconds before returning.
+ + +
+ +
proc addTimer(interval: Uint32; callback: TimerCallback; param: pointer): TimerID {...}{.
+    importc: "SDL_AddTimer", cdecl.}
+
+ +
\brief Add a new timer to the pool of timers already running.
+ 
+ \return A timer ID, or 0 when an error occurs.
+ + +
+ +
proc removeTimer(id: TimerID): bool {...}{.importc: "SDL_RemoveTimer", cdecl.}
+
+ +
\brief Remove a timer knowing its ID.
+ 
+ \return A boolean value indicating success or failure.
+ 
+ \warning It is not safe to remove a timer multiple times.
+ + +
+ +
proc getVersion(ver: ptr Version) {...}{.importc: "SDL_GetVersion", cdecl.}
+
+ +
\brief Get the version of SDL that is linked against your program.
+  
+  If you are linking to SDL dynamically, then it is possible that the
+  current version will be different than the version you compiled against.
+  This function returns the current version, while SDL_VERSION() is a
+  macro that tells you what version you compiled with.
+  
+  \code
+  SDL_version compiled;
+  SDL_version linked;
+  
+  SDL_VERSION(&compiled);
+  SDL_GetVersion(&linked);
+  printf("We compiled against SDL version %d.%d.%d ...\n",
+         compiled.major, compiled.minor, compiled.patch);
+  printf("But we linked against SDL version %d.%d.%d.\n",
+         linked.major, linked.minor, linked.patch);
+  \endcode
+  
+  This function may be called safely at any time, even before SDL_Init().
+  
+  \sa SDL_VERSION
+ + +
+ +
proc getRevision(): cstring {...}{.importc: "SDL_GetRevision", cdecl.}
+
+ +
\brief Get the code revision of SDL that is linked against your program.
+  
+  Returns an arbitrary string (a hash value) uniquely identifying the
+  exact revision of the SDL library in use, and is only useful in comparing
+  against other revisions. It is NOT an incrementing number.
+ + +
+ +
proc getRevisionNumber(): cint {...}{.importc: "SDL_GetRevisionNumber", cdecl.}
+
+ +
\brief Get the revision number of SDL that is linked against your program.
+  
+  Returns a number uniquely identifying the exact revision of the SDL
+  library in use. It is an incrementing number based on commits to
+  hg.libsdl.org.
+ + +
+ +
proc init(flags: Uint32): cint {...}{.importc: "SDL_Init", cdecl.}
+
+ +
@}
+This function initializes  the subsystems specified by \c flags
+ + +
+ +
proc initSubSystem(flags: Uint32): cint {...}{.importc: "SDL_InitSubSystem", cdecl.}
+
+ +
This function initializes specific SDL subsystems
+  
+  Subsystem initialization is ref-counted, you must call
+  SDL_QuitSubSystem() for each SDL_InitSubSystem() to correctly
+  shutdown a subsystem manually (or call SDL_Quit() to force shutdown).
+  If a subsystem is already loaded then this call will
+  increase the ref-count and return.
+ + +
+ +
proc quitSubSystem(flags: Uint32) {...}{.importc: "SDL_QuitSubSystem", cdecl.}
+
+ +
This function cleans up specific SDL subsystems
+ + +
+ +
proc wasInit(flags: Uint32): Uint32 {...}{.importc: "SDL_WasInit", cdecl.}
+
+ +
This function returns a mask of the specified subsystems which have
+  previously been initialized.
+  
+  If \c flags is 0, it returns a mask of all initialized subsystems.
+ + +
+ +
proc quit() {...}{.importc: "SDL_Quit", cdecl.}
+
+ +
This function cleans up all initialized subsystems. You should
+  call it upon all exit conditions.
+ + +
+ +
+
+

Templates

+
+ +
template sdl_button(x: untyped): untyped
+
+ + + +
+ +
template WINDOWPOS_UNDEFINED_DISPLAY(x: untyped): untyped
+
+ + + +
+ +
template WINDOWPOS_ISUNDEFINED(x: untyped): untyped
+
+ + + +
+ +
template WINDOWPOS_CENTERED_DISPLAY(x: untyped): untyped
+
+ + + +
+ +
template WINDOWPOS_ISCENTERED(x: untyped): untyped
+
+ + + +
+ +
+ +
+
+ +
+ +
+
+
+ + + diff --git a/docs/sdl2.idx b/docs/sdl2.idx new file mode 100644 index 0000000..c8155e6 --- /dev/null +++ b/docs/sdl2.idx @@ -0,0 +1,2173 @@ +SDLCacheDir sdl2.html#SDLCacheDir sdl2: SDLCacheDir +SDLStd sdl2.html#SDLStd sdl2: SDLStd +SDLGit sdl2.html#SDLGit sdl2: SDLGit +SDLDL sdl2.html#SDLDL sdl2: SDLDL +SDLStatic sdl2.html#SDLStatic sdl2: SDLStatic +SDLSetVer sdl2.html#SDLSetVer sdl2: SDLSetVer +SDLLPath sdl2.html#SDLLPath sdl2: SDLLPath +SDLPath sdl2.html#SDLPath sdl2: SDLPath +sdl_button sdl2.html#sdl_button.t,untyped sdl2: sdl_button(x: untyped): untyped +WINDOWPOS_UNDEFINED_DISPLAY sdl2.html#WINDOWPOS_UNDEFINED_DISPLAY.t,untyped sdl2: WINDOWPOS_UNDEFINED_DISPLAY(x: untyped): untyped +WINDOWPOS_ISUNDEFINED sdl2.html#WINDOWPOS_ISUNDEFINED.t,untyped sdl2: WINDOWPOS_ISUNDEFINED(x: untyped): untyped +WINDOWPOS_CENTERED_DISPLAY sdl2.html#WINDOWPOS_CENTERED_DISPLAY.t,untyped sdl2: WINDOWPOS_CENTERED_DISPLAY(x: untyped): untyped +WINDOWPOS_ISCENTERED sdl2.html#WINDOWPOS_ISCENTERED.t,untyped sdl2: WINDOWPOS_ISCENTERED(x: untyped): untyped +AssertState sdl2.html#AssertState sdl2: AssertState +errorcode sdl2.html#errorcode sdl2: errorcode +ThreadPriority sdl2.html#ThreadPriority sdl2: ThreadPriority +AudioStatus sdl2.html#AudioStatus sdl2: AudioStatus +PixelType sdl2.html#PixelType sdl2: PixelType +BitmapOrder sdl2.html#BitmapOrder sdl2: BitmapOrder +PackedOrder sdl2.html#PackedOrder sdl2: PackedOrder +ArrayOrder sdl2.html#ArrayOrder sdl2: ArrayOrder +PackedLayout sdl2.html#PackedLayout sdl2: PackedLayout +PixelFormatEnum sdl2.html#PixelFormatEnum sdl2: PixelFormatEnum +BlendMode sdl2.html#BlendMode sdl2: BlendMode +BlendOperation sdl2.html#BlendOperation sdl2: BlendOperation +BlendFactor sdl2.html#BlendFactor sdl2: BlendFactor +YUV_CONVERSION_MODE sdl2.html#YUV_CONVERSION_MODE sdl2: YUV_CONVERSION_MODE +WindowFlags sdl2.html#WindowFlags sdl2: WindowFlags +WindowEventID sdl2.html#WindowEventID sdl2: WindowEventID +DisplayEventID sdl2.html#DisplayEventID sdl2: DisplayEventID +DisplayOrientation sdl2.html#DisplayOrientation sdl2: DisplayOrientation +GLattr sdl2.html#GLattr sdl2: GLattr +GLprofile sdl2.html#GLprofile sdl2: GLprofile +GLcontextFlag sdl2.html#GLcontextFlag sdl2: GLcontextFlag +GLcontextReleaseFlag sdl2.html#GLcontextReleaseFlag sdl2: GLcontextReleaseFlag +GLContextResetNotificationEnum sdl2.html#GLContextResetNotificationEnum sdl2: GLContextResetNotificationEnum +HitTestResult sdl2.html#HitTestResult sdl2: HitTestResult +Scancode sdl2.html#Scancode sdl2: Scancode +KeyCodeEnum sdl2.html#KeyCodeEnum sdl2: KeyCodeEnum +Keymod sdl2.html#Keymod sdl2: Keymod +SystemCursor sdl2.html#SystemCursor sdl2: SystemCursor +MouseWheelDirection sdl2.html#MouseWheelDirection sdl2: MouseWheelDirection +JoystickType sdl2.html#JoystickType sdl2: JoystickType +JoystickPowerLevel sdl2.html#JoystickPowerLevel sdl2: JoystickPowerLevel +GameControllerType sdl2.html#GameControllerType sdl2: GameControllerType +GameControllerAxis sdl2.html#GameControllerAxis sdl2: GameControllerAxis +GameControllerButton sdl2.html#GameControllerButton sdl2: GameControllerButton +TouchDeviceType sdl2.html#TouchDeviceType sdl2: TouchDeviceType +EventType sdl2.html#EventType sdl2: EventType +eventaction sdl2.html#eventaction sdl2: eventaction +HintPriority sdl2.html#HintPriority sdl2: HintPriority +LogCategory sdl2.html#LogCategory sdl2: LogCategory +LogPriority sdl2.html#LogPriority sdl2: LogPriority +MessageBoxFlags sdl2.html#MessageBoxFlags sdl2: MessageBoxFlags +MessageBoxButtonFlags sdl2.html#MessageBoxButtonFlags sdl2: MessageBoxButtonFlags +MessageBoxColorType sdl2.html#MessageBoxColorType sdl2: MessageBoxColorType +PowerState sdl2.html#PowerState sdl2: PowerState +RendererFlags sdl2.html#RendererFlags sdl2: RendererFlags +ScaleMode sdl2.html#ScaleMode sdl2: ScaleMode +TextureAccess sdl2.html#TextureAccess sdl2: TextureAccess +TextureModulate sdl2.html#TextureModulate sdl2: TextureModulate +RendererFlip sdl2.html#RendererFlip sdl2: RendererFlip +SensorType sdl2.html#SensorType sdl2: SensorType +WindowShapeMode sdl2.html#WindowShapeMode sdl2: WindowShapeMode +MIN_UINT8 sdl2.html#MIN_UINT8 sdl2: MIN_UINT8 +MIN_UINT64 sdl2.html#MIN_UINT64 sdl2: MIN_UINT64 +MAX_SINT16 sdl2.html#MAX_SINT16 sdl2: MAX_SINT16 +MAX_SINT32 sdl2.html#MAX_SINT32 sdl2: MAX_SINT32 +Colour sdl2.html#Colour sdl2: Colour +MOUSE_TOUCHID sdl2.html#MOUSE_TOUCHID sdl2: MOUSE_TOUCHID +WINDOWPOS_CENTERED_MASK sdl2.html#WINDOWPOS_CENTERED_MASK sdl2: WINDOWPOS_CENTERED_MASK +MAX_UINT8 sdl2.html#MAX_UINT8 sdl2: MAX_UINT8 +BlitScaled sdl2.html#BlitScaled sdl2: BlitScaled +MIN_SINT8 sdl2.html#MIN_SINT8 sdl2: MIN_SINT8 +MIN_UINT16 sdl2.html#MIN_UINT16 sdl2: MIN_UINT16 +MIN_UINT32 sdl2.html#MIN_UINT32 sdl2: MIN_UINT32 +TOUCH_MOUSEID sdl2.html#TOUCH_MOUSEID sdl2: TOUCH_MOUSEID +BlitSurface sdl2.html#BlitSurface sdl2: BlitSurface +WINDOWPOS_UNDEFINED_MASK sdl2.html#WINDOWPOS_UNDEFINED_MASK sdl2: WINDOWPOS_UNDEFINED_MASK +MIN_SINT32 sdl2.html#MIN_SINT32 sdl2: MIN_SINT32 +MUTEX_MAXWAIT sdl2.html#MUTEX_MAXWAIT sdl2: MUTEX_MAXWAIT +MAX_SINT8 sdl2.html#MAX_SINT8 sdl2: MAX_SINT8 +MAX_UINT16 sdl2.html#MAX_UINT16 sdl2: MAX_UINT16 +MAX_UINT32 sdl2.html#MAX_UINT32 sdl2: MAX_UINT32 +MIN_SINT16 sdl2.html#MIN_SINT16 sdl2: MIN_SINT16 +MAX_UINT64 sdl2.html#MAX_UINT64 sdl2: MAX_UINT64 +MAX_SINT64 sdl2.html#MAX_SINT64 sdl2: MAX_SINT64 +MACOSX sdl2.html#MACOSX sdl2: MACOSX +SIZEOF_VOIDP sdl2.html#SIZEOF_VOIDP sdl2: SIZEOF_VOIDP +HAVE_GCC_ATOMICS sdl2.html#HAVE_GCC_ATOMICS sdl2: HAVE_GCC_ATOMICS +HAVE_LIBC sdl2.html#HAVE_LIBC sdl2: HAVE_LIBC +STDC_HEADERS sdl2.html#STDC_HEADERS sdl2: STDC_HEADERS +HAVE_ALLOCA_H sdl2.html#HAVE_ALLOCA_H sdl2: HAVE_ALLOCA_H +HAVE_CTYPE_H sdl2.html#HAVE_CTYPE_H sdl2: HAVE_CTYPE_H +HAVE_FLOAT_H sdl2.html#HAVE_FLOAT_H sdl2: HAVE_FLOAT_H +HAVE_ICONV_H sdl2.html#HAVE_ICONV_H sdl2: HAVE_ICONV_H +HAVE_INTTYPES_H sdl2.html#HAVE_INTTYPES_H sdl2: HAVE_INTTYPES_H +HAVE_LIMITS_H sdl2.html#HAVE_LIMITS_H sdl2: HAVE_LIMITS_H +HAVE_MATH_H sdl2.html#HAVE_MATH_H sdl2: HAVE_MATH_H +HAVE_MEMORY_H sdl2.html#HAVE_MEMORY_H sdl2: HAVE_MEMORY_H +HAVE_SIGNAL_H sdl2.html#HAVE_SIGNAL_H sdl2: HAVE_SIGNAL_H +HAVE_STDARG_H sdl2.html#HAVE_STDARG_H sdl2: HAVE_STDARG_H +HAVE_STDINT_H sdl2.html#HAVE_STDINT_H sdl2: HAVE_STDINT_H +HAVE_STDIO_H sdl2.html#HAVE_STDIO_H sdl2: HAVE_STDIO_H +HAVE_STDLIB_H sdl2.html#HAVE_STDLIB_H sdl2: HAVE_STDLIB_H +HAVE_STRINGS_H sdl2.html#HAVE_STRINGS_H sdl2: HAVE_STRINGS_H +HAVE_STRING_H sdl2.html#HAVE_STRING_H sdl2: HAVE_STRING_H +HAVE_SYS_TYPES_H sdl2.html#HAVE_SYS_TYPES_H sdl2: HAVE_SYS_TYPES_H +HAVE_WCHAR_H sdl2.html#HAVE_WCHAR_H sdl2: HAVE_WCHAR_H +HAVE_LIBUNWIND_H sdl2.html#HAVE_LIBUNWIND_H sdl2: HAVE_LIBUNWIND_H +HAVE_MALLOC sdl2.html#HAVE_MALLOC sdl2: HAVE_MALLOC +HAVE_CALLOC sdl2.html#HAVE_CALLOC sdl2: HAVE_CALLOC +HAVE_REALLOC sdl2.html#HAVE_REALLOC sdl2: HAVE_REALLOC +HAVE_FREE sdl2.html#HAVE_FREE sdl2: HAVE_FREE +HAVE_ALLOCA sdl2.html#HAVE_ALLOCA sdl2: HAVE_ALLOCA +HAVE_GETENV sdl2.html#HAVE_GETENV sdl2: HAVE_GETENV +HAVE_SETENV sdl2.html#HAVE_SETENV sdl2: HAVE_SETENV +HAVE_PUTENV sdl2.html#HAVE_PUTENV sdl2: HAVE_PUTENV +HAVE_UNSETENV sdl2.html#HAVE_UNSETENV sdl2: HAVE_UNSETENV +HAVE_QSORT sdl2.html#HAVE_QSORT sdl2: HAVE_QSORT +HAVE_ABS sdl2.html#HAVE_ABS sdl2: HAVE_ABS +HAVE_BCOPY sdl2.html#HAVE_BCOPY sdl2: HAVE_BCOPY +HAVE_MEMSET sdl2.html#HAVE_MEMSET sdl2: HAVE_MEMSET +HAVE_MEMCPY sdl2.html#HAVE_MEMCPY sdl2: HAVE_MEMCPY +HAVE_MEMMOVE sdl2.html#HAVE_MEMMOVE sdl2: HAVE_MEMMOVE +HAVE_MEMCMP sdl2.html#HAVE_MEMCMP sdl2: HAVE_MEMCMP +HAVE_WCSLEN sdl2.html#HAVE_WCSLEN sdl2: HAVE_WCSLEN +HAVE_WCSLCPY sdl2.html#HAVE_WCSLCPY sdl2: HAVE_WCSLCPY +HAVE_WCSLCAT sdl2.html#HAVE_WCSLCAT sdl2: HAVE_WCSLCAT +HAVE_WCSDUP sdl2.html#HAVE_WCSDUP sdl2: HAVE_WCSDUP +HAVE_WCSSTR sdl2.html#HAVE_WCSSTR sdl2: HAVE_WCSSTR +HAVE_WCSCMP sdl2.html#HAVE_WCSCMP sdl2: HAVE_WCSCMP +HAVE_WCSNCMP sdl2.html#HAVE_WCSNCMP sdl2: HAVE_WCSNCMP +HAVE_STRLEN sdl2.html#HAVE_STRLEN sdl2: HAVE_STRLEN +HAVE_STRLCPY sdl2.html#HAVE_STRLCPY sdl2: HAVE_STRLCPY +HAVE_STRLCAT sdl2.html#HAVE_STRLCAT sdl2: HAVE_STRLCAT +HAVE_STRCHR sdl2.html#HAVE_STRCHR sdl2: HAVE_STRCHR +HAVE_STRRCHR sdl2.html#HAVE_STRRCHR sdl2: HAVE_STRRCHR +HAVE_STRSTR sdl2.html#HAVE_STRSTR sdl2: HAVE_STRSTR +HAVE_STRTOK_R sdl2.html#HAVE_STRTOK_R sdl2: HAVE_STRTOK_R +HAVE_STRTOL sdl2.html#HAVE_STRTOL sdl2: HAVE_STRTOL +HAVE_STRTOUL sdl2.html#HAVE_STRTOUL sdl2: HAVE_STRTOUL +HAVE_STRTOLL sdl2.html#HAVE_STRTOLL sdl2: HAVE_STRTOLL +HAVE_STRTOULL sdl2.html#HAVE_STRTOULL sdl2: HAVE_STRTOULL +HAVE_STRTOD sdl2.html#HAVE_STRTOD sdl2: HAVE_STRTOD +HAVE_ATOI sdl2.html#HAVE_ATOI sdl2: HAVE_ATOI +HAVE_ATOF sdl2.html#HAVE_ATOF sdl2: HAVE_ATOF +HAVE_STRCMP sdl2.html#HAVE_STRCMP sdl2: HAVE_STRCMP +HAVE_STRNCMP sdl2.html#HAVE_STRNCMP sdl2: HAVE_STRNCMP +HAVE_STRCASECMP sdl2.html#HAVE_STRCASECMP sdl2: HAVE_STRCASECMP +HAVE_STRNCASECMP sdl2.html#HAVE_STRNCASECMP sdl2: HAVE_STRNCASECMP +HAVE_VSSCANF sdl2.html#HAVE_VSSCANF sdl2: HAVE_VSSCANF +HAVE_VSNPRINTF sdl2.html#HAVE_VSNPRINTF sdl2: HAVE_VSNPRINTF +HAVE_ACOS sdl2.html#HAVE_ACOS sdl2: HAVE_ACOS +HAVE_ACOSF sdl2.html#HAVE_ACOSF sdl2: HAVE_ACOSF +HAVE_ASIN sdl2.html#HAVE_ASIN sdl2: HAVE_ASIN +HAVE_ASINF sdl2.html#HAVE_ASINF sdl2: HAVE_ASINF +HAVE_ATAN sdl2.html#HAVE_ATAN sdl2: HAVE_ATAN +HAVE_ATANF sdl2.html#HAVE_ATANF sdl2: HAVE_ATANF +HAVE_ATAN2 sdl2.html#HAVE_ATAN2 sdl2: HAVE_ATAN2 +HAVE_ATAN2F sdl2.html#HAVE_ATAN2F sdl2: HAVE_ATAN2F +HAVE_CEIL sdl2.html#HAVE_CEIL sdl2: HAVE_CEIL +HAVE_CEILF sdl2.html#HAVE_CEILF sdl2: HAVE_CEILF +HAVE_COPYSIGN sdl2.html#HAVE_COPYSIGN sdl2: HAVE_COPYSIGN +HAVE_COPYSIGNF sdl2.html#HAVE_COPYSIGNF sdl2: HAVE_COPYSIGNF +HAVE_COS sdl2.html#HAVE_COS sdl2: HAVE_COS +HAVE_COSF sdl2.html#HAVE_COSF sdl2: HAVE_COSF +HAVE_EXP sdl2.html#HAVE_EXP sdl2: HAVE_EXP +HAVE_EXPF sdl2.html#HAVE_EXPF sdl2: HAVE_EXPF +HAVE_FABS sdl2.html#HAVE_FABS sdl2: HAVE_FABS +HAVE_FABSF sdl2.html#HAVE_FABSF sdl2: HAVE_FABSF +HAVE_FLOOR sdl2.html#HAVE_FLOOR sdl2: HAVE_FLOOR +HAVE_FLOORF sdl2.html#HAVE_FLOORF sdl2: HAVE_FLOORF +HAVE_FMOD sdl2.html#HAVE_FMOD sdl2: HAVE_FMOD +HAVE_FMODF sdl2.html#HAVE_FMODF sdl2: HAVE_FMODF +HAVE_LOG sdl2.html#HAVE_LOG sdl2: HAVE_LOG +HAVE_LOGF sdl2.html#HAVE_LOGF sdl2: HAVE_LOGF +HAVE_LOG10 sdl2.html#HAVE_LOG10 sdl2: HAVE_LOG10 +HAVE_LOG10F sdl2.html#HAVE_LOG10F sdl2: HAVE_LOG10F +HAVE_POW sdl2.html#HAVE_POW sdl2: HAVE_POW +HAVE_POWF sdl2.html#HAVE_POWF sdl2: HAVE_POWF +HAVE_SCALBN sdl2.html#HAVE_SCALBN sdl2: HAVE_SCALBN +HAVE_SCALBNF sdl2.html#HAVE_SCALBNF sdl2: HAVE_SCALBNF +HAVE_SIN sdl2.html#HAVE_SIN sdl2: HAVE_SIN +HAVE_SINF sdl2.html#HAVE_SINF sdl2: HAVE_SINF +HAVE_SQRT sdl2.html#HAVE_SQRT sdl2: HAVE_SQRT +HAVE_SQRTF sdl2.html#HAVE_SQRTF sdl2: HAVE_SQRTF +HAVE_TAN sdl2.html#HAVE_TAN sdl2: HAVE_TAN +HAVE_TANF sdl2.html#HAVE_TANF sdl2: HAVE_TANF +HAVE_FSEEKO sdl2.html#HAVE_FSEEKO sdl2: HAVE_FSEEKO +HAVE_SIGACTION sdl2.html#HAVE_SIGACTION sdl2: HAVE_SIGACTION +HAVE_SA_SIGACTION sdl2.html#HAVE_SA_SIGACTION sdl2: HAVE_SA_SIGACTION +HAVE_SETJMP sdl2.html#HAVE_SETJMP sdl2: HAVE_SETJMP +HAVE_NANOSLEEP sdl2.html#HAVE_NANOSLEEP sdl2: HAVE_NANOSLEEP +HAVE_SYSCONF sdl2.html#HAVE_SYSCONF sdl2: HAVE_SYSCONF +HAVE_SYSCTLBYNAME sdl2.html#HAVE_SYSCTLBYNAME sdl2: HAVE_SYSCTLBYNAME +HAVE_MPROTECT sdl2.html#HAVE_MPROTECT sdl2: HAVE_MPROTECT +HAVE_ICONV sdl2.html#HAVE_ICONV sdl2: HAVE_ICONV +HAVE_PTHREAD_SETNAME_NP sdl2.html#HAVE_PTHREAD_SETNAME_NP sdl2: HAVE_PTHREAD_SETNAME_NP +HAVE_POLL sdl2.html#HAVE_POLL sdl2: HAVE_POLL +HAVE_EXIT sdl2.html#HAVE_EXIT sdl2: HAVE_EXIT +HAVE_IMMINTRIN_H sdl2.html#HAVE_IMMINTRIN_H sdl2: HAVE_IMMINTRIN_H +AUDIO_DRIVER_COREAUDIO sdl2.html#AUDIO_DRIVER_COREAUDIO sdl2: AUDIO_DRIVER_COREAUDIO +AUDIO_DRIVER_DISK sdl2.html#AUDIO_DRIVER_DISK sdl2: AUDIO_DRIVER_DISK +AUDIO_DRIVER_DUMMY sdl2.html#AUDIO_DRIVER_DUMMY sdl2: AUDIO_DRIVER_DUMMY +JOYSTICK_IOKIT sdl2.html#JOYSTICK_IOKIT sdl2: JOYSTICK_IOKIT +HAPTIC_TYPE_IOKIT sdl2.html#HAPTIC_TYPE_IOKIT sdl2: HAPTIC_TYPE_IOKIT +SENSOR_DUMMY sdl2.html#SENSOR_DUMMY sdl2: SENSOR_DUMMY +LOADSO_DLOPEN sdl2.html#LOADSO_DLOPEN sdl2: LOADSO_DLOPEN +THREAD_PTHREAD sdl2.html#THREAD_PTHREAD sdl2: THREAD_PTHREAD +THREAD_PTHREAD_RECURSIVE_MUTEX sdl2.html#THREAD_PTHREAD_RECURSIVE_MUTEX sdl2: THREAD_PTHREAD_RECURSIVE_MUTEX +TIMER_UNIX sdl2.html#TIMER_UNIX sdl2: TIMER_UNIX +VIDEO_DRIVER_COCOA sdl2.html#VIDEO_DRIVER_COCOA sdl2: VIDEO_DRIVER_COCOA +VIDEO_DRIVER_DUMMY sdl2.html#VIDEO_DRIVER_DUMMY sdl2: VIDEO_DRIVER_DUMMY +VIDEO_RENDER_OGL sdl2.html#VIDEO_RENDER_OGL sdl2: VIDEO_RENDER_OGL +VIDEO_RENDER_OGL_ES2 sdl2.html#VIDEO_RENDER_OGL_ES2 sdl2: VIDEO_RENDER_OGL_ES2 +VIDEO_RENDER_METAL sdl2.html#VIDEO_RENDER_METAL sdl2: VIDEO_RENDER_METAL +VIDEO_OPENGL sdl2.html#VIDEO_OPENGL sdl2: VIDEO_OPENGL +VIDEO_OPENGL_ES2 sdl2.html#VIDEO_OPENGL_ES2 sdl2: VIDEO_OPENGL_ES2 +VIDEO_OPENGL_CGL sdl2.html#VIDEO_OPENGL_CGL sdl2: VIDEO_OPENGL_CGL +VIDEO_OPENGL_EGL sdl2.html#VIDEO_OPENGL_EGL sdl2: VIDEO_OPENGL_EGL +VIDEO_VULKAN sdl2.html#VIDEO_VULKAN sdl2: VIDEO_VULKAN +VIDEO_METAL sdl2.html#VIDEO_METAL sdl2: VIDEO_METAL +POWER_MACOSX sdl2.html#POWER_MACOSX sdl2: POWER_MACOSX +FILESYSTEM_COCOA sdl2.html#FILESYSTEM_COCOA sdl2: FILESYSTEM_COCOA +ASSEMBLY_ROUTINES sdl2.html#ASSEMBLY_ROUTINES sdl2: ASSEMBLY_ROUTINES +PRIs64 sdl2.html#PRIs64 sdl2: PRIs64 +ICONV_ERROR sdl2.html#ICONV_ERROR sdl2: ICONV_ERROR +ICONV_E2BIG sdl2.html#ICONV_E2BIG sdl2: ICONV_E2BIG +ICONV_EILSEQ sdl2.html#ICONV_EILSEQ sdl2: ICONV_EILSEQ +ICONV_EINVAL sdl2.html#ICONV_EINVAL sdl2: ICONV_EINVAL +ASSERT_LEVEL sdl2.html#ASSERT_LEVEL sdl2: ASSERT_LEVEL +NULL_WHILE_LOOP_CONDITION sdl2.html#NULL_WHILE_LOOP_CONDITION sdl2: NULL_WHILE_LOOP_CONDITION +ASSERTION_RETRY sdl2.html#ASSERTION_RETRY sdl2: ASSERTION_RETRY +ASSERTION_BREAK sdl2.html#ASSERTION_BREAK sdl2: ASSERTION_BREAK +ASSERTION_ABORT sdl2.html#ASSERTION_ABORT sdl2: ASSERTION_ABORT +ASSERTION_IGNORE sdl2.html#ASSERTION_IGNORE sdl2: ASSERTION_IGNORE +ASSERTION_ALWAYS_IGNORE sdl2.html#ASSERTION_ALWAYS_IGNORE sdl2: ASSERTION_ALWAYS_IGNORE +ENOMEM sdl2.html#ENOMEM sdl2: ENOMEM +EFREAD sdl2.html#EFREAD sdl2: EFREAD +EFWRITE sdl2.html#EFWRITE sdl2: EFWRITE +EFSEEK sdl2.html#EFSEEK sdl2: EFSEEK +UNSUPPORTED sdl2.html#UNSUPPORTED sdl2: UNSUPPORTED +LASTERROR sdl2.html#LASTERROR sdl2: LASTERROR +LIL_ENDIAN sdl2.html#LIL_ENDIAN sdl2: LIL_ENDIAN +BIG_ENDIAN sdl2.html#BIG_ENDIAN sdl2: BIG_ENDIAN +BYTEORDER sdl2.html#BYTEORDER sdl2: BYTEORDER +MUTEX_TIMEDOUT sdl2.html#MUTEX_TIMEDOUT sdl2: MUTEX_TIMEDOUT +THREAD_PRIORITY_LOW sdl2.html#THREAD_PRIORITY_LOW sdl2: THREAD_PRIORITY_LOW +THREAD_PRIORITY_NORMAL sdl2.html#THREAD_PRIORITY_NORMAL sdl2: THREAD_PRIORITY_NORMAL +THREAD_PRIORITY_HIGH sdl2.html#THREAD_PRIORITY_HIGH sdl2: THREAD_PRIORITY_HIGH +THREAD_PRIORITY_TIME_CRITICAL sdl2.html#THREAD_PRIORITY_TIME_CRITICAL sdl2: THREAD_PRIORITY_TIME_CRITICAL +RWOPS_UNKNOWN sdl2.html#RWOPS_UNKNOWN sdl2: RWOPS_UNKNOWN +RWOPS_WINFILE sdl2.html#RWOPS_WINFILE sdl2: RWOPS_WINFILE +RWOPS_STDFILE sdl2.html#RWOPS_STDFILE sdl2: RWOPS_STDFILE +RWOPS_JNIFILE sdl2.html#RWOPS_JNIFILE sdl2: RWOPS_JNIFILE +RWOPS_MEMORY sdl2.html#RWOPS_MEMORY sdl2: RWOPS_MEMORY +RWOPS_MEMORY_RO sdl2.html#RWOPS_MEMORY_RO sdl2: RWOPS_MEMORY_RO +RW_SEEK_SET sdl2.html#RW_SEEK_SET sdl2: RW_SEEK_SET +RW_SEEK_CUR sdl2.html#RW_SEEK_CUR sdl2: RW_SEEK_CUR +RW_SEEK_END sdl2.html#RW_SEEK_END sdl2: RW_SEEK_END +AUDIO_MASK_BITSIZE sdl2.html#AUDIO_MASK_BITSIZE sdl2: AUDIO_MASK_BITSIZE +AUDIO_MASK_DATATYPE sdl2.html#AUDIO_MASK_DATATYPE sdl2: AUDIO_MASK_DATATYPE +AUDIO_MASK_ENDIAN sdl2.html#AUDIO_MASK_ENDIAN sdl2: AUDIO_MASK_ENDIAN +AUDIO_MASK_SIGNED sdl2.html#AUDIO_MASK_SIGNED sdl2: AUDIO_MASK_SIGNED +AUDIO_U8 sdl2.html#AUDIO_U8 sdl2: AUDIO_U8 +AUDIO_S8 sdl2.html#AUDIO_S8 sdl2: AUDIO_S8 +AUDIO_U16LSB sdl2.html#AUDIO_U16LSB sdl2: AUDIO_U16LSB +AUDIO_S16LSB sdl2.html#AUDIO_S16LSB sdl2: AUDIO_S16LSB +AUDIO_U16MSB sdl2.html#AUDIO_U16MSB sdl2: AUDIO_U16MSB +AUDIO_S16MSB sdl2.html#AUDIO_S16MSB sdl2: AUDIO_S16MSB +AUDIO_U16 sdl2.html#AUDIO_U16 sdl2: AUDIO_U16 +AUDIO_S16 sdl2.html#AUDIO_S16 sdl2: AUDIO_S16 +AUDIO_S32LSB sdl2.html#AUDIO_S32LSB sdl2: AUDIO_S32LSB +AUDIO_S32MSB sdl2.html#AUDIO_S32MSB sdl2: AUDIO_S32MSB +AUDIO_S32 sdl2.html#AUDIO_S32 sdl2: AUDIO_S32 +AUDIO_F32LSB sdl2.html#AUDIO_F32LSB sdl2: AUDIO_F32LSB +AUDIO_F32MSB sdl2.html#AUDIO_F32MSB sdl2: AUDIO_F32MSB +AUDIO_F32 sdl2.html#AUDIO_F32 sdl2: AUDIO_F32 +AUDIO_U16SYS sdl2.html#AUDIO_U16SYS sdl2: AUDIO_U16SYS +AUDIO_S16SYS sdl2.html#AUDIO_S16SYS sdl2: AUDIO_S16SYS +AUDIO_S32SYS sdl2.html#AUDIO_S32SYS sdl2: AUDIO_S32SYS +AUDIO_F32SYS sdl2.html#AUDIO_F32SYS sdl2: AUDIO_F32SYS +AUDIO_ALLOW_FREQUENCY_CHANGE sdl2.html#AUDIO_ALLOW_FREQUENCY_CHANGE sdl2: AUDIO_ALLOW_FREQUENCY_CHANGE +AUDIO_ALLOW_FORMAT_CHANGE sdl2.html#AUDIO_ALLOW_FORMAT_CHANGE sdl2: AUDIO_ALLOW_FORMAT_CHANGE +AUDIO_ALLOW_CHANNELS_CHANGE sdl2.html#AUDIO_ALLOW_CHANNELS_CHANGE sdl2: AUDIO_ALLOW_CHANNELS_CHANGE +AUDIO_ALLOW_SAMPLES_CHANGE sdl2.html#AUDIO_ALLOW_SAMPLES_CHANGE sdl2: AUDIO_ALLOW_SAMPLES_CHANGE +AUDIO_ALLOW_ANY_CHANGE sdl2.html#AUDIO_ALLOW_ANY_CHANGE sdl2: AUDIO_ALLOW_ANY_CHANGE +AUDIOCVT_MAX_FILTERS sdl2.html#AUDIOCVT_MAX_FILTERS sdl2: AUDIOCVT_MAX_FILTERS +AUDIO_STOPPED sdl2.html#AUDIO_STOPPED sdl2: AUDIO_STOPPED +AUDIO_PLAYING sdl2.html#AUDIO_PLAYING sdl2: AUDIO_PLAYING +AUDIO_PAUSED sdl2.html#AUDIO_PAUSED sdl2: AUDIO_PAUSED +MIX_MAXVOLUME sdl2.html#MIX_MAXVOLUME sdl2: MIX_MAXVOLUME +CACHELINE_SIZE sdl2.html#CACHELINE_SIZE sdl2: CACHELINE_SIZE +ALPHA_OPAQUE sdl2.html#ALPHA_OPAQUE sdl2: ALPHA_OPAQUE +ALPHA_TRANSPARENT sdl2.html#ALPHA_TRANSPARENT sdl2: ALPHA_TRANSPARENT +PIXELTYPE_UNKNOWN sdl2.html#PIXELTYPE_UNKNOWN sdl2: PIXELTYPE_UNKNOWN +PIXELTYPE_INDEX1 sdl2.html#PIXELTYPE_INDEX1 sdl2: PIXELTYPE_INDEX1 +PIXELTYPE_INDEX4 sdl2.html#PIXELTYPE_INDEX4 sdl2: PIXELTYPE_INDEX4 +PIXELTYPE_INDEX8 sdl2.html#PIXELTYPE_INDEX8 sdl2: PIXELTYPE_INDEX8 +PIXELTYPE_PACKED8 sdl2.html#PIXELTYPE_PACKED8 sdl2: PIXELTYPE_PACKED8 +PIXELTYPE_PACKED16 sdl2.html#PIXELTYPE_PACKED16 sdl2: PIXELTYPE_PACKED16 +PIXELTYPE_PACKED32 sdl2.html#PIXELTYPE_PACKED32 sdl2: PIXELTYPE_PACKED32 +PIXELTYPE_ARRAYU8 sdl2.html#PIXELTYPE_ARRAYU8 sdl2: PIXELTYPE_ARRAYU8 +PIXELTYPE_ARRAYU16 sdl2.html#PIXELTYPE_ARRAYU16 sdl2: PIXELTYPE_ARRAYU16 +PIXELTYPE_ARRAYU32 sdl2.html#PIXELTYPE_ARRAYU32 sdl2: PIXELTYPE_ARRAYU32 +PIXELTYPE_ARRAYF16 sdl2.html#PIXELTYPE_ARRAYF16 sdl2: PIXELTYPE_ARRAYF16 +PIXELTYPE_ARRAYF32 sdl2.html#PIXELTYPE_ARRAYF32 sdl2: PIXELTYPE_ARRAYF32 +BITMAPORDER_NONE sdl2.html#BITMAPORDER_NONE sdl2: BITMAPORDER_NONE +BITMAPORDER_4321 sdl2.html#BITMAPORDER_4321 sdl2: BITMAPORDER_4321 +BITMAPORDER_1234 sdl2.html#BITMAPORDER_1234 sdl2: BITMAPORDER_1234 +PACKEDORDER_NONE sdl2.html#PACKEDORDER_NONE sdl2: PACKEDORDER_NONE +PACKEDORDER_XRGB sdl2.html#PACKEDORDER_XRGB sdl2: PACKEDORDER_XRGB +PACKEDORDER_RGBX sdl2.html#PACKEDORDER_RGBX sdl2: PACKEDORDER_RGBX +PACKEDORDER_ARGB sdl2.html#PACKEDORDER_ARGB sdl2: PACKEDORDER_ARGB +PACKEDORDER_RGBA sdl2.html#PACKEDORDER_RGBA sdl2: PACKEDORDER_RGBA +PACKEDORDER_XBGR sdl2.html#PACKEDORDER_XBGR sdl2: PACKEDORDER_XBGR +PACKEDORDER_BGRX sdl2.html#PACKEDORDER_BGRX sdl2: PACKEDORDER_BGRX +PACKEDORDER_ABGR sdl2.html#PACKEDORDER_ABGR sdl2: PACKEDORDER_ABGR +PACKEDORDER_BGRA sdl2.html#PACKEDORDER_BGRA sdl2: PACKEDORDER_BGRA +ARRAYORDER_NONE sdl2.html#ARRAYORDER_NONE sdl2: ARRAYORDER_NONE +ARRAYORDER_RGB sdl2.html#ARRAYORDER_RGB sdl2: ARRAYORDER_RGB +ARRAYORDER_RGBA sdl2.html#ARRAYORDER_RGBA sdl2: ARRAYORDER_RGBA +ARRAYORDER_ARGB sdl2.html#ARRAYORDER_ARGB sdl2: ARRAYORDER_ARGB +ARRAYORDER_BGR sdl2.html#ARRAYORDER_BGR sdl2: ARRAYORDER_BGR +ARRAYORDER_BGRA sdl2.html#ARRAYORDER_BGRA sdl2: ARRAYORDER_BGRA +ARRAYORDER_ABGR sdl2.html#ARRAYORDER_ABGR sdl2: ARRAYORDER_ABGR +PACKEDLAYOUT_NONE sdl2.html#PACKEDLAYOUT_NONE sdl2: PACKEDLAYOUT_NONE +PACKEDLAYOUT_332 sdl2.html#PACKEDLAYOUT_332 sdl2: PACKEDLAYOUT_332 +PACKEDLAYOUT_4444 sdl2.html#PACKEDLAYOUT_4444 sdl2: PACKEDLAYOUT_4444 +PACKEDLAYOUT_1555 sdl2.html#PACKEDLAYOUT_1555 sdl2: PACKEDLAYOUT_1555 +PACKEDLAYOUT_5551 sdl2.html#PACKEDLAYOUT_5551 sdl2: PACKEDLAYOUT_5551 +PACKEDLAYOUT_565 sdl2.html#PACKEDLAYOUT_565 sdl2: PACKEDLAYOUT_565 +PACKEDLAYOUT_8888 sdl2.html#PACKEDLAYOUT_8888 sdl2: PACKEDLAYOUT_8888 +PACKEDLAYOUT_2101010 sdl2.html#PACKEDLAYOUT_2101010 sdl2: PACKEDLAYOUT_2101010 +PACKEDLAYOUT_1010102 sdl2.html#PACKEDLAYOUT_1010102 sdl2: PACKEDLAYOUT_1010102 +PIXELFORMAT_UNKNOWN sdl2.html#PIXELFORMAT_UNKNOWN sdl2: PIXELFORMAT_UNKNOWN +PIXELFORMAT_INDEX1LSB sdl2.html#PIXELFORMAT_INDEX1LSB sdl2: PIXELFORMAT_INDEX1LSB +PIXELFORMAT_INDEX1MSB sdl2.html#PIXELFORMAT_INDEX1MSB sdl2: PIXELFORMAT_INDEX1MSB +PIXELFORMAT_INDEX4LSB sdl2.html#PIXELFORMAT_INDEX4LSB sdl2: PIXELFORMAT_INDEX4LSB +PIXELFORMAT_INDEX4MSB sdl2.html#PIXELFORMAT_INDEX4MSB sdl2: PIXELFORMAT_INDEX4MSB +PIXELFORMAT_INDEX8 sdl2.html#PIXELFORMAT_INDEX8 sdl2: PIXELFORMAT_INDEX8 +PIXELFORMAT_RGB332 sdl2.html#PIXELFORMAT_RGB332 sdl2: PIXELFORMAT_RGB332 +PIXELFORMAT_RGB444 sdl2.html#PIXELFORMAT_RGB444 sdl2: PIXELFORMAT_RGB444 +PIXELFORMAT_BGR444 sdl2.html#PIXELFORMAT_BGR444 sdl2: PIXELFORMAT_BGR444 +PIXELFORMAT_RGB555 sdl2.html#PIXELFORMAT_RGB555 sdl2: PIXELFORMAT_RGB555 +PIXELFORMAT_BGR555 sdl2.html#PIXELFORMAT_BGR555 sdl2: PIXELFORMAT_BGR555 +PIXELFORMAT_ARGB4444 sdl2.html#PIXELFORMAT_ARGB4444 sdl2: PIXELFORMAT_ARGB4444 +PIXELFORMAT_RGBA4444 sdl2.html#PIXELFORMAT_RGBA4444 sdl2: PIXELFORMAT_RGBA4444 +PIXELFORMAT_ABGR4444 sdl2.html#PIXELFORMAT_ABGR4444 sdl2: PIXELFORMAT_ABGR4444 +PIXELFORMAT_BGRA4444 sdl2.html#PIXELFORMAT_BGRA4444 sdl2: PIXELFORMAT_BGRA4444 +PIXELFORMAT_ARGB1555 sdl2.html#PIXELFORMAT_ARGB1555 sdl2: PIXELFORMAT_ARGB1555 +PIXELFORMAT_RGBA5551 sdl2.html#PIXELFORMAT_RGBA5551 sdl2: PIXELFORMAT_RGBA5551 +PIXELFORMAT_ABGR1555 sdl2.html#PIXELFORMAT_ABGR1555 sdl2: PIXELFORMAT_ABGR1555 +PIXELFORMAT_BGRA5551 sdl2.html#PIXELFORMAT_BGRA5551 sdl2: PIXELFORMAT_BGRA5551 +PIXELFORMAT_RGB565 sdl2.html#PIXELFORMAT_RGB565 sdl2: PIXELFORMAT_RGB565 +PIXELFORMAT_BGR565 sdl2.html#PIXELFORMAT_BGR565 sdl2: PIXELFORMAT_BGR565 +PIXELFORMAT_RGB24 sdl2.html#PIXELFORMAT_RGB24 sdl2: PIXELFORMAT_RGB24 +PIXELFORMAT_BGR24 sdl2.html#PIXELFORMAT_BGR24 sdl2: PIXELFORMAT_BGR24 +PIXELFORMAT_RGB888 sdl2.html#PIXELFORMAT_RGB888 sdl2: PIXELFORMAT_RGB888 +PIXELFORMAT_RGBX8888 sdl2.html#PIXELFORMAT_RGBX8888 sdl2: PIXELFORMAT_RGBX8888 +PIXELFORMAT_BGR888 sdl2.html#PIXELFORMAT_BGR888 sdl2: PIXELFORMAT_BGR888 +PIXELFORMAT_BGRX8888 sdl2.html#PIXELFORMAT_BGRX8888 sdl2: PIXELFORMAT_BGRX8888 +PIXELFORMAT_ARGB8888 sdl2.html#PIXELFORMAT_ARGB8888 sdl2: PIXELFORMAT_ARGB8888 +PIXELFORMAT_RGBA8888 sdl2.html#PIXELFORMAT_RGBA8888 sdl2: PIXELFORMAT_RGBA8888 +PIXELFORMAT_ABGR8888 sdl2.html#PIXELFORMAT_ABGR8888 sdl2: PIXELFORMAT_ABGR8888 +PIXELFORMAT_BGRA8888 sdl2.html#PIXELFORMAT_BGRA8888 sdl2: PIXELFORMAT_BGRA8888 +PIXELFORMAT_ARGB2101010 sdl2.html#PIXELFORMAT_ARGB2101010 sdl2: PIXELFORMAT_ARGB2101010 +PIXELFORMAT_RGBA32 sdl2.html#PIXELFORMAT_RGBA32 sdl2: PIXELFORMAT_RGBA32 +PIXELFORMAT_ARGB32 sdl2.html#PIXELFORMAT_ARGB32 sdl2: PIXELFORMAT_ARGB32 +PIXELFORMAT_BGRA32 sdl2.html#PIXELFORMAT_BGRA32 sdl2: PIXELFORMAT_BGRA32 +PIXELFORMAT_ABGR32 sdl2.html#PIXELFORMAT_ABGR32 sdl2: PIXELFORMAT_ABGR32 +PIXELFORMAT_YV12 sdl2.html#PIXELFORMAT_YV12 sdl2: PIXELFORMAT_YV12 +PIXELFORMAT_IYUV sdl2.html#PIXELFORMAT_IYUV sdl2: PIXELFORMAT_IYUV +PIXELFORMAT_YUY2 sdl2.html#PIXELFORMAT_YUY2 sdl2: PIXELFORMAT_YUY2 +PIXELFORMAT_UYVY sdl2.html#PIXELFORMAT_UYVY sdl2: PIXELFORMAT_UYVY +PIXELFORMAT_YVYU sdl2.html#PIXELFORMAT_YVYU sdl2: PIXELFORMAT_YVYU +PIXELFORMAT_NV12 sdl2.html#PIXELFORMAT_NV12 sdl2: PIXELFORMAT_NV12 +PIXELFORMAT_NV21 sdl2.html#PIXELFORMAT_NV21 sdl2: PIXELFORMAT_NV21 +PIXELFORMAT_EXTERNAL_OES sdl2.html#PIXELFORMAT_EXTERNAL_OES sdl2: PIXELFORMAT_EXTERNAL_OES +BLENDMODE_NONE sdl2.html#BLENDMODE_NONE sdl2: BLENDMODE_NONE +BLENDMODE_BLEND sdl2.html#BLENDMODE_BLEND sdl2: BLENDMODE_BLEND +BLENDMODE_ADD sdl2.html#BLENDMODE_ADD sdl2: BLENDMODE_ADD +BLENDMODE_MOD sdl2.html#BLENDMODE_MOD sdl2: BLENDMODE_MOD +BLENDMODE_MUL sdl2.html#BLENDMODE_MUL sdl2: BLENDMODE_MUL +BLENDMODE_INVALID sdl2.html#BLENDMODE_INVALID sdl2: BLENDMODE_INVALID +BLENDOPERATION_ADD sdl2.html#BLENDOPERATION_ADD sdl2: BLENDOPERATION_ADD +BLENDOPERATION_SUBTRACT sdl2.html#BLENDOPERATION_SUBTRACT sdl2: BLENDOPERATION_SUBTRACT +BLENDOPERATION_REV_SUBTRACT sdl2.html#BLENDOPERATION_REV_SUBTRACT sdl2: BLENDOPERATION_REV_SUBTRACT +BLENDOPERATION_MINIMUM sdl2.html#BLENDOPERATION_MINIMUM sdl2: BLENDOPERATION_MINIMUM +BLENDOPERATION_MAXIMUM sdl2.html#BLENDOPERATION_MAXIMUM sdl2: BLENDOPERATION_MAXIMUM +BLENDFACTOR_ZERO sdl2.html#BLENDFACTOR_ZERO sdl2: BLENDFACTOR_ZERO +BLENDFACTOR_ONE sdl2.html#BLENDFACTOR_ONE sdl2: BLENDFACTOR_ONE +BLENDFACTOR_SRC_COLOR sdl2.html#BLENDFACTOR_SRC_COLOR sdl2: BLENDFACTOR_SRC_COLOR +BLENDFACTOR_ONE_MINUS_SRC_COLOR sdl2.html#BLENDFACTOR_ONE_MINUS_SRC_COLOR sdl2: BLENDFACTOR_ONE_MINUS_SRC_COLOR +BLENDFACTOR_SRC_ALPHA sdl2.html#BLENDFACTOR_SRC_ALPHA sdl2: BLENDFACTOR_SRC_ALPHA +BLENDFACTOR_ONE_MINUS_SRC_ALPHA sdl2.html#BLENDFACTOR_ONE_MINUS_SRC_ALPHA sdl2: BLENDFACTOR_ONE_MINUS_SRC_ALPHA +BLENDFACTOR_DST_COLOR sdl2.html#BLENDFACTOR_DST_COLOR sdl2: BLENDFACTOR_DST_COLOR +BLENDFACTOR_ONE_MINUS_DST_COLOR sdl2.html#BLENDFACTOR_ONE_MINUS_DST_COLOR sdl2: BLENDFACTOR_ONE_MINUS_DST_COLOR +BLENDFACTOR_DST_ALPHA sdl2.html#BLENDFACTOR_DST_ALPHA sdl2: BLENDFACTOR_DST_ALPHA +BLENDFACTOR_ONE_MINUS_DST_ALPHA sdl2.html#BLENDFACTOR_ONE_MINUS_DST_ALPHA sdl2: BLENDFACTOR_ONE_MINUS_DST_ALPHA +SWSURFACE sdl2.html#SWSURFACE sdl2: SWSURFACE +PREALLOC sdl2.html#PREALLOC sdl2: PREALLOC +RLEACCEL sdl2.html#RLEACCEL sdl2: RLEACCEL +DONTFREE sdl2.html#DONTFREE sdl2: DONTFREE +SIMD_ALIGNED sdl2.html#SIMD_ALIGNED sdl2: SIMD_ALIGNED +YUV_CONVERSION_JPEG sdl2.html#YUV_CONVERSION_JPEG sdl2: YUV_CONVERSION_JPEG +YUV_CONVERSION_BT601 sdl2.html#YUV_CONVERSION_BT601 sdl2: YUV_CONVERSION_BT601 +YUV_CONVERSION_BT709 sdl2.html#YUV_CONVERSION_BT709 sdl2: YUV_CONVERSION_BT709 +YUV_CONVERSION_AUTOMATIC sdl2.html#YUV_CONVERSION_AUTOMATIC sdl2: YUV_CONVERSION_AUTOMATIC +WINDOW_FULLSCREEN sdl2.html#WINDOW_FULLSCREEN sdl2: WINDOW_FULLSCREEN +WINDOW_OPENGL sdl2.html#WINDOW_OPENGL sdl2: WINDOW_OPENGL +WINDOW_SHOWN sdl2.html#WINDOW_SHOWN sdl2: WINDOW_SHOWN +WINDOW_HIDDEN sdl2.html#WINDOW_HIDDEN sdl2: WINDOW_HIDDEN +WINDOW_BORDERLESS sdl2.html#WINDOW_BORDERLESS sdl2: WINDOW_BORDERLESS +WINDOW_RESIZABLE sdl2.html#WINDOW_RESIZABLE sdl2: WINDOW_RESIZABLE +WINDOW_MINIMIZED sdl2.html#WINDOW_MINIMIZED sdl2: WINDOW_MINIMIZED +WINDOW_MAXIMIZED sdl2.html#WINDOW_MAXIMIZED sdl2: WINDOW_MAXIMIZED +WINDOW_INPUT_GRABBED sdl2.html#WINDOW_INPUT_GRABBED sdl2: WINDOW_INPUT_GRABBED +WINDOW_INPUT_FOCUS sdl2.html#WINDOW_INPUT_FOCUS sdl2: WINDOW_INPUT_FOCUS +WINDOW_MOUSE_FOCUS sdl2.html#WINDOW_MOUSE_FOCUS sdl2: WINDOW_MOUSE_FOCUS +WINDOW_FULLSCREEN_DESKTOP sdl2.html#WINDOW_FULLSCREEN_DESKTOP sdl2: WINDOW_FULLSCREEN_DESKTOP +WINDOW_FOREIGN sdl2.html#WINDOW_FOREIGN sdl2: WINDOW_FOREIGN +WINDOW_ALLOW_HIGHDPI sdl2.html#WINDOW_ALLOW_HIGHDPI sdl2: WINDOW_ALLOW_HIGHDPI +WINDOW_MOUSE_CAPTURE sdl2.html#WINDOW_MOUSE_CAPTURE sdl2: WINDOW_MOUSE_CAPTURE +WINDOW_ALWAYS_ON_TOP sdl2.html#WINDOW_ALWAYS_ON_TOP sdl2: WINDOW_ALWAYS_ON_TOP +WINDOW_SKIP_TASKBAR sdl2.html#WINDOW_SKIP_TASKBAR sdl2: WINDOW_SKIP_TASKBAR +WINDOW_UTILITY sdl2.html#WINDOW_UTILITY sdl2: WINDOW_UTILITY +WINDOW_TOOLTIP sdl2.html#WINDOW_TOOLTIP sdl2: WINDOW_TOOLTIP +WINDOW_POPUP_MENU sdl2.html#WINDOW_POPUP_MENU sdl2: WINDOW_POPUP_MENU +WINDOW_VULKAN sdl2.html#WINDOW_VULKAN sdl2: WINDOW_VULKAN +WINDOWEVENT_NONE sdl2.html#WINDOWEVENT_NONE sdl2: WINDOWEVENT_NONE +WINDOWEVENT_SHOWN sdl2.html#WINDOWEVENT_SHOWN sdl2: WINDOWEVENT_SHOWN +WINDOWEVENT_HIDDEN sdl2.html#WINDOWEVENT_HIDDEN sdl2: WINDOWEVENT_HIDDEN +WINDOWEVENT_EXPOSED sdl2.html#WINDOWEVENT_EXPOSED sdl2: WINDOWEVENT_EXPOSED +WINDOWEVENT_MOVED sdl2.html#WINDOWEVENT_MOVED sdl2: WINDOWEVENT_MOVED +WINDOWEVENT_RESIZED sdl2.html#WINDOWEVENT_RESIZED sdl2: WINDOWEVENT_RESIZED +WINDOWEVENT_SIZE_CHANGED sdl2.html#WINDOWEVENT_SIZE_CHANGED sdl2: WINDOWEVENT_SIZE_CHANGED +WINDOWEVENT_MINIMIZED sdl2.html#WINDOWEVENT_MINIMIZED sdl2: WINDOWEVENT_MINIMIZED +WINDOWEVENT_MAXIMIZED sdl2.html#WINDOWEVENT_MAXIMIZED sdl2: WINDOWEVENT_MAXIMIZED +WINDOWEVENT_RESTORED sdl2.html#WINDOWEVENT_RESTORED sdl2: WINDOWEVENT_RESTORED +WINDOWEVENT_ENTER sdl2.html#WINDOWEVENT_ENTER sdl2: WINDOWEVENT_ENTER +WINDOWEVENT_LEAVE sdl2.html#WINDOWEVENT_LEAVE sdl2: WINDOWEVENT_LEAVE +WINDOWEVENT_FOCUS_GAINED sdl2.html#WINDOWEVENT_FOCUS_GAINED sdl2: WINDOWEVENT_FOCUS_GAINED +WINDOWEVENT_FOCUS_LOST sdl2.html#WINDOWEVENT_FOCUS_LOST sdl2: WINDOWEVENT_FOCUS_LOST +WINDOWEVENT_CLOSE sdl2.html#WINDOWEVENT_CLOSE sdl2: WINDOWEVENT_CLOSE +WINDOWEVENT_TAKE_FOCUS sdl2.html#WINDOWEVENT_TAKE_FOCUS sdl2: WINDOWEVENT_TAKE_FOCUS +WINDOWEVENT_HIT_TEST sdl2.html#WINDOWEVENT_HIT_TEST sdl2: WINDOWEVENT_HIT_TEST +DISPLAYEVENT_NONE sdl2.html#DISPLAYEVENT_NONE sdl2: DISPLAYEVENT_NONE +DISPLAYEVENT_ORIENTATION sdl2.html#DISPLAYEVENT_ORIENTATION sdl2: DISPLAYEVENT_ORIENTATION +ORIENTATION_UNKNOWN sdl2.html#ORIENTATION_UNKNOWN sdl2: ORIENTATION_UNKNOWN +ORIENTATION_LANDSCAPE sdl2.html#ORIENTATION_LANDSCAPE sdl2: ORIENTATION_LANDSCAPE +ORIENTATION_LANDSCAPE_FLIPPED sdl2.html#ORIENTATION_LANDSCAPE_FLIPPED sdl2: ORIENTATION_LANDSCAPE_FLIPPED +ORIENTATION_PORTRAIT sdl2.html#ORIENTATION_PORTRAIT sdl2: ORIENTATION_PORTRAIT +ORIENTATION_PORTRAIT_FLIPPED sdl2.html#ORIENTATION_PORTRAIT_FLIPPED sdl2: ORIENTATION_PORTRAIT_FLIPPED +GL_RED_SIZE sdl2.html#GL_RED_SIZE sdl2: GL_RED_SIZE +GL_GREEN_SIZE sdl2.html#GL_GREEN_SIZE sdl2: GL_GREEN_SIZE +GL_BLUE_SIZE sdl2.html#GL_BLUE_SIZE sdl2: GL_BLUE_SIZE +GL_ALPHA_SIZE sdl2.html#GL_ALPHA_SIZE sdl2: GL_ALPHA_SIZE +GL_BUFFER_SIZE sdl2.html#GL_BUFFER_SIZE sdl2: GL_BUFFER_SIZE +GL_DOUBLEBUFFER sdl2.html#GL_DOUBLEBUFFER sdl2: GL_DOUBLEBUFFER +GL_DEPTH_SIZE sdl2.html#GL_DEPTH_SIZE sdl2: GL_DEPTH_SIZE +GL_STENCIL_SIZE sdl2.html#GL_STENCIL_SIZE sdl2: GL_STENCIL_SIZE +GL_ACCUM_RED_SIZE sdl2.html#GL_ACCUM_RED_SIZE sdl2: GL_ACCUM_RED_SIZE +GL_ACCUM_GREEN_SIZE sdl2.html#GL_ACCUM_GREEN_SIZE sdl2: GL_ACCUM_GREEN_SIZE +GL_ACCUM_BLUE_SIZE sdl2.html#GL_ACCUM_BLUE_SIZE sdl2: GL_ACCUM_BLUE_SIZE +GL_ACCUM_ALPHA_SIZE sdl2.html#GL_ACCUM_ALPHA_SIZE sdl2: GL_ACCUM_ALPHA_SIZE +GL_STEREO sdl2.html#GL_STEREO sdl2: GL_STEREO +GL_MULTISAMPLEBUFFERS sdl2.html#GL_MULTISAMPLEBUFFERS sdl2: GL_MULTISAMPLEBUFFERS +GL_MULTISAMPLESAMPLES sdl2.html#GL_MULTISAMPLESAMPLES sdl2: GL_MULTISAMPLESAMPLES +GL_ACCELERATED_VISUAL sdl2.html#GL_ACCELERATED_VISUAL sdl2: GL_ACCELERATED_VISUAL +GL_RETAINED_BACKING sdl2.html#GL_RETAINED_BACKING sdl2: GL_RETAINED_BACKING +GL_CONTEXT_MAJOR_VERSION sdl2.html#GL_CONTEXT_MAJOR_VERSION sdl2: GL_CONTEXT_MAJOR_VERSION +GL_CONTEXT_MINOR_VERSION sdl2.html#GL_CONTEXT_MINOR_VERSION sdl2: GL_CONTEXT_MINOR_VERSION +GL_CONTEXT_EGL sdl2.html#GL_CONTEXT_EGL sdl2: GL_CONTEXT_EGL +GL_CONTEXT_FLAGS sdl2.html#GL_CONTEXT_FLAGS sdl2: GL_CONTEXT_FLAGS +GL_CONTEXT_PROFILE_MASK sdl2.html#GL_CONTEXT_PROFILE_MASK sdl2: GL_CONTEXT_PROFILE_MASK +GL_SHARE_WITH_CURRENT_CONTEXT sdl2.html#GL_SHARE_WITH_CURRENT_CONTEXT sdl2: GL_SHARE_WITH_CURRENT_CONTEXT +GL_FRAMEBUFFER_SRGB_CAPABLE sdl2.html#GL_FRAMEBUFFER_SRGB_CAPABLE sdl2: GL_FRAMEBUFFER_SRGB_CAPABLE +GL_CONTEXT_RELEASE_BEHAVIOR sdl2.html#GL_CONTEXT_RELEASE_BEHAVIOR sdl2: GL_CONTEXT_RELEASE_BEHAVIOR +GL_CONTEXT_RESET_NOTIFICATION sdl2.html#GL_CONTEXT_RESET_NOTIFICATION sdl2: GL_CONTEXT_RESET_NOTIFICATION +GL_CONTEXT_NO_ERROR sdl2.html#GL_CONTEXT_NO_ERROR sdl2: GL_CONTEXT_NO_ERROR +GL_CONTEXT_PROFILE_CORE sdl2.html#GL_CONTEXT_PROFILE_CORE sdl2: GL_CONTEXT_PROFILE_CORE +GL_CONTEXT_PROFILE_COMPATIBILITY sdl2.html#GL_CONTEXT_PROFILE_COMPATIBILITY sdl2: GL_CONTEXT_PROFILE_COMPATIBILITY +GL_CONTEXT_PROFILE_ES sdl2.html#GL_CONTEXT_PROFILE_ES sdl2: GL_CONTEXT_PROFILE_ES +GL_CONTEXT_DEBUG_FLAG sdl2.html#GL_CONTEXT_DEBUG_FLAG sdl2: GL_CONTEXT_DEBUG_FLAG +GL_CONTEXT_FORWARD_COMPATIBLE_FLAG sdl2.html#GL_CONTEXT_FORWARD_COMPATIBLE_FLAG sdl2: GL_CONTEXT_FORWARD_COMPATIBLE_FLAG +GL_CONTEXT_ROBUST_ACCESS_FLAG sdl2.html#GL_CONTEXT_ROBUST_ACCESS_FLAG sdl2: GL_CONTEXT_ROBUST_ACCESS_FLAG +GL_CONTEXT_RESET_ISOLATION_FLAG sdl2.html#GL_CONTEXT_RESET_ISOLATION_FLAG sdl2: GL_CONTEXT_RESET_ISOLATION_FLAG +GL_CONTEXT_RELEASE_BEHAVIOR_NONE sdl2.html#GL_CONTEXT_RELEASE_BEHAVIOR_NONE sdl2: GL_CONTEXT_RELEASE_BEHAVIOR_NONE +GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH sdl2.html#GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH sdl2: GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH +GL_CONTEXT_RESET_NO_NOTIFICATION sdl2.html#GL_CONTEXT_RESET_NO_NOTIFICATION sdl2: GL_CONTEXT_RESET_NO_NOTIFICATION +GL_CONTEXT_RESET_LOSE_CONTEXT sdl2.html#GL_CONTEXT_RESET_LOSE_CONTEXT sdl2: GL_CONTEXT_RESET_LOSE_CONTEXT +HITTEST_NORMAL sdl2.html#HITTEST_NORMAL sdl2: HITTEST_NORMAL +HITTEST_DRAGGABLE sdl2.html#HITTEST_DRAGGABLE sdl2: HITTEST_DRAGGABLE +HITTEST_RESIZE_TOPLEFT sdl2.html#HITTEST_RESIZE_TOPLEFT sdl2: HITTEST_RESIZE_TOPLEFT +HITTEST_RESIZE_TOP sdl2.html#HITTEST_RESIZE_TOP sdl2: HITTEST_RESIZE_TOP +HITTEST_RESIZE_TOPRIGHT sdl2.html#HITTEST_RESIZE_TOPRIGHT sdl2: HITTEST_RESIZE_TOPRIGHT +HITTEST_RESIZE_RIGHT sdl2.html#HITTEST_RESIZE_RIGHT sdl2: HITTEST_RESIZE_RIGHT +HITTEST_RESIZE_BOTTOMRIGHT sdl2.html#HITTEST_RESIZE_BOTTOMRIGHT sdl2: HITTEST_RESIZE_BOTTOMRIGHT +HITTEST_RESIZE_BOTTOM sdl2.html#HITTEST_RESIZE_BOTTOM sdl2: HITTEST_RESIZE_BOTTOM +HITTEST_RESIZE_BOTTOMLEFT sdl2.html#HITTEST_RESIZE_BOTTOMLEFT sdl2: HITTEST_RESIZE_BOTTOMLEFT +HITTEST_RESIZE_LEFT sdl2.html#HITTEST_RESIZE_LEFT sdl2: HITTEST_RESIZE_LEFT +SCANCODE_UNKNOWN sdl2.html#SCANCODE_UNKNOWN sdl2: SCANCODE_UNKNOWN +SCANCODE_A sdl2.html#SCANCODE_A sdl2: SCANCODE_A +SCANCODE_B sdl2.html#SCANCODE_B sdl2: SCANCODE_B +SCANCODE_C sdl2.html#SCANCODE_C sdl2: SCANCODE_C +SCANCODE_D sdl2.html#SCANCODE_D sdl2: SCANCODE_D +SCANCODE_E sdl2.html#SCANCODE_E sdl2: SCANCODE_E +SCANCODE_F sdl2.html#SCANCODE_F sdl2: SCANCODE_F +SCANCODE_G sdl2.html#SCANCODE_G sdl2: SCANCODE_G +SCANCODE_H sdl2.html#SCANCODE_H sdl2: SCANCODE_H +SCANCODE_I sdl2.html#SCANCODE_I sdl2: SCANCODE_I +SCANCODE_J sdl2.html#SCANCODE_J sdl2: SCANCODE_J +SCANCODE_K sdl2.html#SCANCODE_K sdl2: SCANCODE_K +SCANCODE_L sdl2.html#SCANCODE_L sdl2: SCANCODE_L +SCANCODE_M sdl2.html#SCANCODE_M sdl2: SCANCODE_M +SCANCODE_N sdl2.html#SCANCODE_N sdl2: SCANCODE_N +SCANCODE_O sdl2.html#SCANCODE_O sdl2: SCANCODE_O +SCANCODE_P sdl2.html#SCANCODE_P sdl2: SCANCODE_P +SCANCODE_Q sdl2.html#SCANCODE_Q sdl2: SCANCODE_Q +SCANCODE_R sdl2.html#SCANCODE_R sdl2: SCANCODE_R +SCANCODE_S sdl2.html#SCANCODE_S sdl2: SCANCODE_S +SCANCODE_T sdl2.html#SCANCODE_T sdl2: SCANCODE_T +SCANCODE_U sdl2.html#SCANCODE_U sdl2: SCANCODE_U +SCANCODE_V sdl2.html#SCANCODE_V sdl2: SCANCODE_V +SCANCODE_W sdl2.html#SCANCODE_W sdl2: SCANCODE_W +SCANCODE_X sdl2.html#SCANCODE_X sdl2: SCANCODE_X +SCANCODE_Y sdl2.html#SCANCODE_Y sdl2: SCANCODE_Y +SCANCODE_Z sdl2.html#SCANCODE_Z sdl2: SCANCODE_Z +SCANCODE_1 sdl2.html#SCANCODE_1 sdl2: SCANCODE_1 +SCANCODE_2 sdl2.html#SCANCODE_2 sdl2: SCANCODE_2 +SCANCODE_3 sdl2.html#SCANCODE_3 sdl2: SCANCODE_3 +SCANCODE_4 sdl2.html#SCANCODE_4 sdl2: SCANCODE_4 +SCANCODE_5 sdl2.html#SCANCODE_5 sdl2: SCANCODE_5 +SCANCODE_6 sdl2.html#SCANCODE_6 sdl2: SCANCODE_6 +SCANCODE_7 sdl2.html#SCANCODE_7 sdl2: SCANCODE_7 +SCANCODE_8 sdl2.html#SCANCODE_8 sdl2: SCANCODE_8 +SCANCODE_9 sdl2.html#SCANCODE_9 sdl2: SCANCODE_9 +SCANCODE_0 sdl2.html#SCANCODE_0 sdl2: SCANCODE_0 +SCANCODE_RETURN sdl2.html#SCANCODE_RETURN sdl2: SCANCODE_RETURN +SCANCODE_ESCAPE sdl2.html#SCANCODE_ESCAPE sdl2: SCANCODE_ESCAPE +SCANCODE_BACKSPACE sdl2.html#SCANCODE_BACKSPACE sdl2: SCANCODE_BACKSPACE +SCANCODE_TAB sdl2.html#SCANCODE_TAB sdl2: SCANCODE_TAB +SCANCODE_SPACE sdl2.html#SCANCODE_SPACE sdl2: SCANCODE_SPACE +SCANCODE_MINUS sdl2.html#SCANCODE_MINUS sdl2: SCANCODE_MINUS +SCANCODE_EQUALS sdl2.html#SCANCODE_EQUALS sdl2: SCANCODE_EQUALS +SCANCODE_LEFTBRACKET sdl2.html#SCANCODE_LEFTBRACKET sdl2: SCANCODE_LEFTBRACKET +SCANCODE_RIGHTBRACKET sdl2.html#SCANCODE_RIGHTBRACKET sdl2: SCANCODE_RIGHTBRACKET +SCANCODE_BACKSLASH sdl2.html#SCANCODE_BACKSLASH sdl2: SCANCODE_BACKSLASH +SCANCODE_NONUSHASH sdl2.html#SCANCODE_NONUSHASH sdl2: SCANCODE_NONUSHASH +SCANCODE_SEMICOLON sdl2.html#SCANCODE_SEMICOLON sdl2: SCANCODE_SEMICOLON +SCANCODE_APOSTROPHE sdl2.html#SCANCODE_APOSTROPHE sdl2: SCANCODE_APOSTROPHE +SCANCODE_GRAVE sdl2.html#SCANCODE_GRAVE sdl2: SCANCODE_GRAVE +SCANCODE_COMMA sdl2.html#SCANCODE_COMMA sdl2: SCANCODE_COMMA +SCANCODE_PERIOD sdl2.html#SCANCODE_PERIOD sdl2: SCANCODE_PERIOD +SCANCODE_SLASH sdl2.html#SCANCODE_SLASH sdl2: SCANCODE_SLASH +SCANCODE_CAPSLOCK sdl2.html#SCANCODE_CAPSLOCK sdl2: SCANCODE_CAPSLOCK +SCANCODE_F1 sdl2.html#SCANCODE_F1 sdl2: SCANCODE_F1 +SCANCODE_F2 sdl2.html#SCANCODE_F2 sdl2: SCANCODE_F2 +SCANCODE_F3 sdl2.html#SCANCODE_F3 sdl2: SCANCODE_F3 +SCANCODE_F4 sdl2.html#SCANCODE_F4 sdl2: SCANCODE_F4 +SCANCODE_F5 sdl2.html#SCANCODE_F5 sdl2: SCANCODE_F5 +SCANCODE_F6 sdl2.html#SCANCODE_F6 sdl2: SCANCODE_F6 +SCANCODE_F7 sdl2.html#SCANCODE_F7 sdl2: SCANCODE_F7 +SCANCODE_F8 sdl2.html#SCANCODE_F8 sdl2: SCANCODE_F8 +SCANCODE_F9 sdl2.html#SCANCODE_F9 sdl2: SCANCODE_F9 +SCANCODE_F10 sdl2.html#SCANCODE_F10 sdl2: SCANCODE_F10 +SCANCODE_F11 sdl2.html#SCANCODE_F11 sdl2: SCANCODE_F11 +SCANCODE_F12 sdl2.html#SCANCODE_F12 sdl2: SCANCODE_F12 +SCANCODE_PRINTSCREEN sdl2.html#SCANCODE_PRINTSCREEN sdl2: SCANCODE_PRINTSCREEN +SCANCODE_SCROLLLOCK sdl2.html#SCANCODE_SCROLLLOCK sdl2: SCANCODE_SCROLLLOCK +SCANCODE_PAUSE sdl2.html#SCANCODE_PAUSE sdl2: SCANCODE_PAUSE +SCANCODE_INSERT sdl2.html#SCANCODE_INSERT sdl2: SCANCODE_INSERT +SCANCODE_HOME sdl2.html#SCANCODE_HOME sdl2: SCANCODE_HOME +SCANCODE_PAGEUP sdl2.html#SCANCODE_PAGEUP sdl2: SCANCODE_PAGEUP +SCANCODE_DELETE sdl2.html#SCANCODE_DELETE sdl2: SCANCODE_DELETE +SCANCODE_END sdl2.html#SCANCODE_END sdl2: SCANCODE_END +SCANCODE_PAGEDOWN sdl2.html#SCANCODE_PAGEDOWN sdl2: SCANCODE_PAGEDOWN +SCANCODE_RIGHT sdl2.html#SCANCODE_RIGHT sdl2: SCANCODE_RIGHT +SCANCODE_LEFT sdl2.html#SCANCODE_LEFT sdl2: SCANCODE_LEFT +SCANCODE_DOWN sdl2.html#SCANCODE_DOWN sdl2: SCANCODE_DOWN +SCANCODE_UP sdl2.html#SCANCODE_UP sdl2: SCANCODE_UP +SCANCODE_NUMLOCKCLEAR sdl2.html#SCANCODE_NUMLOCKCLEAR sdl2: SCANCODE_NUMLOCKCLEAR +SCANCODE_KP_DIVIDE sdl2.html#SCANCODE_KP_DIVIDE sdl2: SCANCODE_KP_DIVIDE +SCANCODE_KP_MULTIPLY sdl2.html#SCANCODE_KP_MULTIPLY sdl2: SCANCODE_KP_MULTIPLY +SCANCODE_KP_MINUS sdl2.html#SCANCODE_KP_MINUS sdl2: SCANCODE_KP_MINUS +SCANCODE_KP_PLUS sdl2.html#SCANCODE_KP_PLUS sdl2: SCANCODE_KP_PLUS +SCANCODE_KP_ENTER sdl2.html#SCANCODE_KP_ENTER sdl2: SCANCODE_KP_ENTER +SCANCODE_KP_1 sdl2.html#SCANCODE_KP_1 sdl2: SCANCODE_KP_1 +SCANCODE_KP_2 sdl2.html#SCANCODE_KP_2 sdl2: SCANCODE_KP_2 +SCANCODE_KP_3 sdl2.html#SCANCODE_KP_3 sdl2: SCANCODE_KP_3 +SCANCODE_KP_4 sdl2.html#SCANCODE_KP_4 sdl2: SCANCODE_KP_4 +SCANCODE_KP_5 sdl2.html#SCANCODE_KP_5 sdl2: SCANCODE_KP_5 +SCANCODE_KP_6 sdl2.html#SCANCODE_KP_6 sdl2: SCANCODE_KP_6 +SCANCODE_KP_7 sdl2.html#SCANCODE_KP_7 sdl2: SCANCODE_KP_7 +SCANCODE_KP_8 sdl2.html#SCANCODE_KP_8 sdl2: SCANCODE_KP_8 +SCANCODE_KP_9 sdl2.html#SCANCODE_KP_9 sdl2: SCANCODE_KP_9 +SCANCODE_KP_0 sdl2.html#SCANCODE_KP_0 sdl2: SCANCODE_KP_0 +SCANCODE_KP_PERIOD sdl2.html#SCANCODE_KP_PERIOD sdl2: SCANCODE_KP_PERIOD +SCANCODE_NONUSBACKSLASH sdl2.html#SCANCODE_NONUSBACKSLASH sdl2: SCANCODE_NONUSBACKSLASH +SCANCODE_APPLICATION sdl2.html#SCANCODE_APPLICATION sdl2: SCANCODE_APPLICATION +SCANCODE_POWER sdl2.html#SCANCODE_POWER sdl2: SCANCODE_POWER +SCANCODE_KP_EQUALS sdl2.html#SCANCODE_KP_EQUALS sdl2: SCANCODE_KP_EQUALS +SCANCODE_F13 sdl2.html#SCANCODE_F13 sdl2: SCANCODE_F13 +SCANCODE_F14 sdl2.html#SCANCODE_F14 sdl2: SCANCODE_F14 +SCANCODE_F15 sdl2.html#SCANCODE_F15 sdl2: SCANCODE_F15 +SCANCODE_F16 sdl2.html#SCANCODE_F16 sdl2: SCANCODE_F16 +SCANCODE_F17 sdl2.html#SCANCODE_F17 sdl2: SCANCODE_F17 +SCANCODE_F18 sdl2.html#SCANCODE_F18 sdl2: SCANCODE_F18 +SCANCODE_F19 sdl2.html#SCANCODE_F19 sdl2: SCANCODE_F19 +SCANCODE_F20 sdl2.html#SCANCODE_F20 sdl2: SCANCODE_F20 +SCANCODE_F21 sdl2.html#SCANCODE_F21 sdl2: SCANCODE_F21 +SCANCODE_F22 sdl2.html#SCANCODE_F22 sdl2: SCANCODE_F22 +SCANCODE_F23 sdl2.html#SCANCODE_F23 sdl2: SCANCODE_F23 +SCANCODE_F24 sdl2.html#SCANCODE_F24 sdl2: SCANCODE_F24 +SCANCODE_EXECUTE sdl2.html#SCANCODE_EXECUTE sdl2: SCANCODE_EXECUTE +SCANCODE_HELP sdl2.html#SCANCODE_HELP sdl2: SCANCODE_HELP +SCANCODE_MENU sdl2.html#SCANCODE_MENU sdl2: SCANCODE_MENU +SCANCODE_SELECT sdl2.html#SCANCODE_SELECT sdl2: SCANCODE_SELECT +SCANCODE_STOP sdl2.html#SCANCODE_STOP sdl2: SCANCODE_STOP +SCANCODE_AGAIN sdl2.html#SCANCODE_AGAIN sdl2: SCANCODE_AGAIN +SCANCODE_UNDO sdl2.html#SCANCODE_UNDO sdl2: SCANCODE_UNDO +SCANCODE_CUT sdl2.html#SCANCODE_CUT sdl2: SCANCODE_CUT +SCANCODE_COPY sdl2.html#SCANCODE_COPY sdl2: SCANCODE_COPY +SCANCODE_PASTE sdl2.html#SCANCODE_PASTE sdl2: SCANCODE_PASTE +SCANCODE_FIND sdl2.html#SCANCODE_FIND sdl2: SCANCODE_FIND +SCANCODE_MUTE sdl2.html#SCANCODE_MUTE sdl2: SCANCODE_MUTE +SCANCODE_VOLUMEUP sdl2.html#SCANCODE_VOLUMEUP sdl2: SCANCODE_VOLUMEUP +SCANCODE_VOLUMEDOWN sdl2.html#SCANCODE_VOLUMEDOWN sdl2: SCANCODE_VOLUMEDOWN +SCANCODE_KP_COMMA sdl2.html#SCANCODE_KP_COMMA sdl2: SCANCODE_KP_COMMA +SCANCODE_KP_EQUALSAS400 sdl2.html#SCANCODE_KP_EQUALSAS400 sdl2: SCANCODE_KP_EQUALSAS400 +SCANCODE_INTERNATIONAL1 sdl2.html#SCANCODE_INTERNATIONAL1 sdl2: SCANCODE_INTERNATIONAL1 +SCANCODE_INTERNATIONAL2 sdl2.html#SCANCODE_INTERNATIONAL2 sdl2: SCANCODE_INTERNATIONAL2 +SCANCODE_INTERNATIONAL3 sdl2.html#SCANCODE_INTERNATIONAL3 sdl2: SCANCODE_INTERNATIONAL3 +SCANCODE_INTERNATIONAL4 sdl2.html#SCANCODE_INTERNATIONAL4 sdl2: SCANCODE_INTERNATIONAL4 +SCANCODE_INTERNATIONAL5 sdl2.html#SCANCODE_INTERNATIONAL5 sdl2: SCANCODE_INTERNATIONAL5 +SCANCODE_INTERNATIONAL6 sdl2.html#SCANCODE_INTERNATIONAL6 sdl2: SCANCODE_INTERNATIONAL6 +SCANCODE_INTERNATIONAL7 sdl2.html#SCANCODE_INTERNATIONAL7 sdl2: SCANCODE_INTERNATIONAL7 +SCANCODE_INTERNATIONAL8 sdl2.html#SCANCODE_INTERNATIONAL8 sdl2: SCANCODE_INTERNATIONAL8 +SCANCODE_INTERNATIONAL9 sdl2.html#SCANCODE_INTERNATIONAL9 sdl2: SCANCODE_INTERNATIONAL9 +SCANCODE_LANG1 sdl2.html#SCANCODE_LANG1 sdl2: SCANCODE_LANG1 +SCANCODE_LANG2 sdl2.html#SCANCODE_LANG2 sdl2: SCANCODE_LANG2 +SCANCODE_LANG3 sdl2.html#SCANCODE_LANG3 sdl2: SCANCODE_LANG3 +SCANCODE_LANG4 sdl2.html#SCANCODE_LANG4 sdl2: SCANCODE_LANG4 +SCANCODE_LANG5 sdl2.html#SCANCODE_LANG5 sdl2: SCANCODE_LANG5 +SCANCODE_LANG6 sdl2.html#SCANCODE_LANG6 sdl2: SCANCODE_LANG6 +SCANCODE_LANG7 sdl2.html#SCANCODE_LANG7 sdl2: SCANCODE_LANG7 +SCANCODE_LANG8 sdl2.html#SCANCODE_LANG8 sdl2: SCANCODE_LANG8 +SCANCODE_LANG9 sdl2.html#SCANCODE_LANG9 sdl2: SCANCODE_LANG9 +SCANCODE_ALTERASE sdl2.html#SCANCODE_ALTERASE sdl2: SCANCODE_ALTERASE +SCANCODE_SYSREQ sdl2.html#SCANCODE_SYSREQ sdl2: SCANCODE_SYSREQ +SCANCODE_CANCEL sdl2.html#SCANCODE_CANCEL sdl2: SCANCODE_CANCEL +SCANCODE_CLEAR sdl2.html#SCANCODE_CLEAR sdl2: SCANCODE_CLEAR +SCANCODE_PRIOR sdl2.html#SCANCODE_PRIOR sdl2: SCANCODE_PRIOR +SCANCODE_RETURN2 sdl2.html#SCANCODE_RETURN2 sdl2: SCANCODE_RETURN2 +SCANCODE_SEPARATOR sdl2.html#SCANCODE_SEPARATOR sdl2: SCANCODE_SEPARATOR +SCANCODE_OUT sdl2.html#SCANCODE_OUT sdl2: SCANCODE_OUT +SCANCODE_OPER sdl2.html#SCANCODE_OPER sdl2: SCANCODE_OPER +SCANCODE_CLEARAGAIN sdl2.html#SCANCODE_CLEARAGAIN sdl2: SCANCODE_CLEARAGAIN +SCANCODE_CRSEL sdl2.html#SCANCODE_CRSEL sdl2: SCANCODE_CRSEL +SCANCODE_EXSEL sdl2.html#SCANCODE_EXSEL sdl2: SCANCODE_EXSEL +SCANCODE_KP_00 sdl2.html#SCANCODE_KP_00 sdl2: SCANCODE_KP_00 +SCANCODE_KP_000 sdl2.html#SCANCODE_KP_000 sdl2: SCANCODE_KP_000 +SCANCODE_THOUSANDSSEPARATOR sdl2.html#SCANCODE_THOUSANDSSEPARATOR sdl2: SCANCODE_THOUSANDSSEPARATOR +SCANCODE_DECIMALSEPARATOR sdl2.html#SCANCODE_DECIMALSEPARATOR sdl2: SCANCODE_DECIMALSEPARATOR +SCANCODE_CURRENCYUNIT sdl2.html#SCANCODE_CURRENCYUNIT sdl2: SCANCODE_CURRENCYUNIT +SCANCODE_CURRENCYSUBUNIT sdl2.html#SCANCODE_CURRENCYSUBUNIT sdl2: SCANCODE_CURRENCYSUBUNIT +SCANCODE_KP_LEFTPAREN sdl2.html#SCANCODE_KP_LEFTPAREN sdl2: SCANCODE_KP_LEFTPAREN +SCANCODE_KP_RIGHTPAREN sdl2.html#SCANCODE_KP_RIGHTPAREN sdl2: SCANCODE_KP_RIGHTPAREN +SCANCODE_KP_LEFTBRACE sdl2.html#SCANCODE_KP_LEFTBRACE sdl2: SCANCODE_KP_LEFTBRACE +SCANCODE_KP_RIGHTBRACE sdl2.html#SCANCODE_KP_RIGHTBRACE sdl2: SCANCODE_KP_RIGHTBRACE +SCANCODE_KP_TAB sdl2.html#SCANCODE_KP_TAB sdl2: SCANCODE_KP_TAB +SCANCODE_KP_BACKSPACE sdl2.html#SCANCODE_KP_BACKSPACE sdl2: SCANCODE_KP_BACKSPACE +SCANCODE_KP_A sdl2.html#SCANCODE_KP_A sdl2: SCANCODE_KP_A +SCANCODE_KP_B sdl2.html#SCANCODE_KP_B sdl2: SCANCODE_KP_B +SCANCODE_KP_C sdl2.html#SCANCODE_KP_C sdl2: SCANCODE_KP_C +SCANCODE_KP_D sdl2.html#SCANCODE_KP_D sdl2: SCANCODE_KP_D +SCANCODE_KP_E sdl2.html#SCANCODE_KP_E sdl2: SCANCODE_KP_E +SCANCODE_KP_F sdl2.html#SCANCODE_KP_F sdl2: SCANCODE_KP_F +SCANCODE_KP_XOR sdl2.html#SCANCODE_KP_XOR sdl2: SCANCODE_KP_XOR +SCANCODE_KP_POWER sdl2.html#SCANCODE_KP_POWER sdl2: SCANCODE_KP_POWER +SCANCODE_KP_PERCENT sdl2.html#SCANCODE_KP_PERCENT sdl2: SCANCODE_KP_PERCENT +SCANCODE_KP_LESS sdl2.html#SCANCODE_KP_LESS sdl2: SCANCODE_KP_LESS +SCANCODE_KP_GREATER sdl2.html#SCANCODE_KP_GREATER sdl2: SCANCODE_KP_GREATER +SCANCODE_KP_AMPERSAND sdl2.html#SCANCODE_KP_AMPERSAND sdl2: SCANCODE_KP_AMPERSAND +SCANCODE_KP_DBLAMPERSAND sdl2.html#SCANCODE_KP_DBLAMPERSAND sdl2: SCANCODE_KP_DBLAMPERSAND +SCANCODE_KP_VERTICALBAR sdl2.html#SCANCODE_KP_VERTICALBAR sdl2: SCANCODE_KP_VERTICALBAR +SCANCODE_KP_DBLVERTICALBAR sdl2.html#SCANCODE_KP_DBLVERTICALBAR sdl2: SCANCODE_KP_DBLVERTICALBAR +SCANCODE_KP_COLON sdl2.html#SCANCODE_KP_COLON sdl2: SCANCODE_KP_COLON +SCANCODE_KP_HASH sdl2.html#SCANCODE_KP_HASH sdl2: SCANCODE_KP_HASH +SCANCODE_KP_SPACE sdl2.html#SCANCODE_KP_SPACE sdl2: SCANCODE_KP_SPACE +SCANCODE_KP_AT sdl2.html#SCANCODE_KP_AT sdl2: SCANCODE_KP_AT +SCANCODE_KP_EXCLAM sdl2.html#SCANCODE_KP_EXCLAM sdl2: SCANCODE_KP_EXCLAM +SCANCODE_KP_MEMSTORE sdl2.html#SCANCODE_KP_MEMSTORE sdl2: SCANCODE_KP_MEMSTORE +SCANCODE_KP_MEMRECALL sdl2.html#SCANCODE_KP_MEMRECALL sdl2: SCANCODE_KP_MEMRECALL +SCANCODE_KP_MEMCLEAR sdl2.html#SCANCODE_KP_MEMCLEAR sdl2: SCANCODE_KP_MEMCLEAR +SCANCODE_KP_MEMADD sdl2.html#SCANCODE_KP_MEMADD sdl2: SCANCODE_KP_MEMADD +SCANCODE_KP_MEMSUBTRACT sdl2.html#SCANCODE_KP_MEMSUBTRACT sdl2: SCANCODE_KP_MEMSUBTRACT +SCANCODE_KP_MEMMULTIPLY sdl2.html#SCANCODE_KP_MEMMULTIPLY sdl2: SCANCODE_KP_MEMMULTIPLY +SCANCODE_KP_MEMDIVIDE sdl2.html#SCANCODE_KP_MEMDIVIDE sdl2: SCANCODE_KP_MEMDIVIDE +SCANCODE_KP_PLUSMINUS sdl2.html#SCANCODE_KP_PLUSMINUS sdl2: SCANCODE_KP_PLUSMINUS +SCANCODE_KP_CLEAR sdl2.html#SCANCODE_KP_CLEAR sdl2: SCANCODE_KP_CLEAR +SCANCODE_KP_CLEARENTRY sdl2.html#SCANCODE_KP_CLEARENTRY sdl2: SCANCODE_KP_CLEARENTRY +SCANCODE_KP_BINARY sdl2.html#SCANCODE_KP_BINARY sdl2: SCANCODE_KP_BINARY +SCANCODE_KP_OCTAL sdl2.html#SCANCODE_KP_OCTAL sdl2: SCANCODE_KP_OCTAL +SCANCODE_KP_DECIMAL sdl2.html#SCANCODE_KP_DECIMAL sdl2: SCANCODE_KP_DECIMAL +SCANCODE_KP_HEXADECIMAL sdl2.html#SCANCODE_KP_HEXADECIMAL sdl2: SCANCODE_KP_HEXADECIMAL +SCANCODE_LCTRL sdl2.html#SCANCODE_LCTRL sdl2: SCANCODE_LCTRL +SCANCODE_LSHIFT sdl2.html#SCANCODE_LSHIFT sdl2: SCANCODE_LSHIFT +SCANCODE_LALT sdl2.html#SCANCODE_LALT sdl2: SCANCODE_LALT +SCANCODE_LGUI sdl2.html#SCANCODE_LGUI sdl2: SCANCODE_LGUI +SCANCODE_RCTRL sdl2.html#SCANCODE_RCTRL sdl2: SCANCODE_RCTRL +SCANCODE_RSHIFT sdl2.html#SCANCODE_RSHIFT sdl2: SCANCODE_RSHIFT +SCANCODE_RALT sdl2.html#SCANCODE_RALT sdl2: SCANCODE_RALT +SCANCODE_RGUI sdl2.html#SCANCODE_RGUI sdl2: SCANCODE_RGUI +SCANCODE_MODE sdl2.html#SCANCODE_MODE sdl2: SCANCODE_MODE +SCANCODE_AUDIONEXT sdl2.html#SCANCODE_AUDIONEXT sdl2: SCANCODE_AUDIONEXT +SCANCODE_AUDIOPREV sdl2.html#SCANCODE_AUDIOPREV sdl2: SCANCODE_AUDIOPREV +SCANCODE_AUDIOSTOP sdl2.html#SCANCODE_AUDIOSTOP sdl2: SCANCODE_AUDIOSTOP +SCANCODE_AUDIOPLAY sdl2.html#SCANCODE_AUDIOPLAY sdl2: SCANCODE_AUDIOPLAY +SCANCODE_AUDIOMUTE sdl2.html#SCANCODE_AUDIOMUTE sdl2: SCANCODE_AUDIOMUTE +SCANCODE_MEDIASELECT sdl2.html#SCANCODE_MEDIASELECT sdl2: SCANCODE_MEDIASELECT +SCANCODE_WWW sdl2.html#SCANCODE_WWW sdl2: SCANCODE_WWW +SCANCODE_MAIL sdl2.html#SCANCODE_MAIL sdl2: SCANCODE_MAIL +SCANCODE_CALCULATOR sdl2.html#SCANCODE_CALCULATOR sdl2: SCANCODE_CALCULATOR +SCANCODE_COMPUTER sdl2.html#SCANCODE_COMPUTER sdl2: SCANCODE_COMPUTER +SCANCODE_AC_SEARCH sdl2.html#SCANCODE_AC_SEARCH sdl2: SCANCODE_AC_SEARCH +SCANCODE_AC_HOME sdl2.html#SCANCODE_AC_HOME sdl2: SCANCODE_AC_HOME +SCANCODE_AC_BACK sdl2.html#SCANCODE_AC_BACK sdl2: SCANCODE_AC_BACK +SCANCODE_AC_FORWARD sdl2.html#SCANCODE_AC_FORWARD sdl2: SCANCODE_AC_FORWARD +SCANCODE_AC_STOP sdl2.html#SCANCODE_AC_STOP sdl2: SCANCODE_AC_STOP +SCANCODE_AC_REFRESH sdl2.html#SCANCODE_AC_REFRESH sdl2: SCANCODE_AC_REFRESH +SCANCODE_AC_BOOKMARKS sdl2.html#SCANCODE_AC_BOOKMARKS sdl2: SCANCODE_AC_BOOKMARKS +SCANCODE_BRIGHTNESSDOWN sdl2.html#SCANCODE_BRIGHTNESSDOWN sdl2: SCANCODE_BRIGHTNESSDOWN +SCANCODE_BRIGHTNESSUP sdl2.html#SCANCODE_BRIGHTNESSUP sdl2: SCANCODE_BRIGHTNESSUP +SCANCODE_DISPLAYSWITCH sdl2.html#SCANCODE_DISPLAYSWITCH sdl2: SCANCODE_DISPLAYSWITCH +SCANCODE_KBDILLUMTOGGLE sdl2.html#SCANCODE_KBDILLUMTOGGLE sdl2: SCANCODE_KBDILLUMTOGGLE +SCANCODE_KBDILLUMDOWN sdl2.html#SCANCODE_KBDILLUMDOWN sdl2: SCANCODE_KBDILLUMDOWN +SCANCODE_KBDILLUMUP sdl2.html#SCANCODE_KBDILLUMUP sdl2: SCANCODE_KBDILLUMUP +SCANCODE_EJECT sdl2.html#SCANCODE_EJECT sdl2: SCANCODE_EJECT +SCANCODE_SLEEP sdl2.html#SCANCODE_SLEEP sdl2: SCANCODE_SLEEP +SCANCODE_APP1 sdl2.html#SCANCODE_APP1 sdl2: SCANCODE_APP1 +SCANCODE_APP2 sdl2.html#SCANCODE_APP2 sdl2: SCANCODE_APP2 +SCANCODE_AUDIOREWIND sdl2.html#SCANCODE_AUDIOREWIND sdl2: SCANCODE_AUDIOREWIND +SCANCODE_AUDIOFASTFORWARD sdl2.html#SCANCODE_AUDIOFASTFORWARD sdl2: SCANCODE_AUDIOFASTFORWARD +NUM_SCANCODES sdl2.html#NUM_SCANCODES sdl2: NUM_SCANCODES +KEYCODE_SCANCODE_MASK sdl2.html#KEYCODE_SCANCODE_MASK sdl2: KEYCODE_SCANCODE_MASK +KEYCODE_UNKNOWN sdl2.html#KEYCODE_UNKNOWN sdl2: KEYCODE_UNKNOWN +KEYCODE_RETURN sdl2.html#KEYCODE_RETURN sdl2: KEYCODE_RETURN +KEYCODE_ESCAPE sdl2.html#KEYCODE_ESCAPE sdl2: KEYCODE_ESCAPE +KEYCODE_BACKSPACE sdl2.html#KEYCODE_BACKSPACE sdl2: KEYCODE_BACKSPACE +KEYCODE_TAB sdl2.html#KEYCODE_TAB sdl2: KEYCODE_TAB +KEYCODE_SPACE sdl2.html#KEYCODE_SPACE sdl2: KEYCODE_SPACE +KEYCODE_EXCLAIM sdl2.html#KEYCODE_EXCLAIM sdl2: KEYCODE_EXCLAIM +KEYCODE_QUOTEDBL sdl2.html#KEYCODE_QUOTEDBL sdl2: KEYCODE_QUOTEDBL +KEYCODE_HASH sdl2.html#KEYCODE_HASH sdl2: KEYCODE_HASH +KEYCODE_PERCENT sdl2.html#KEYCODE_PERCENT sdl2: KEYCODE_PERCENT +KEYCODE_DOLLAR sdl2.html#KEYCODE_DOLLAR sdl2: KEYCODE_DOLLAR +KEYCODE_AMPERSAND sdl2.html#KEYCODE_AMPERSAND sdl2: KEYCODE_AMPERSAND +KEYCODE_QUOTE sdl2.html#KEYCODE_QUOTE sdl2: KEYCODE_QUOTE +KEYCODE_LEFTPAREN sdl2.html#KEYCODE_LEFTPAREN sdl2: KEYCODE_LEFTPAREN +KEYCODE_RIGHTPAREN sdl2.html#KEYCODE_RIGHTPAREN sdl2: KEYCODE_RIGHTPAREN +KEYCODE_ASTERISK sdl2.html#KEYCODE_ASTERISK sdl2: KEYCODE_ASTERISK +KEYCODE_PLUS sdl2.html#KEYCODE_PLUS sdl2: KEYCODE_PLUS +KEYCODE_COMMA sdl2.html#KEYCODE_COMMA sdl2: KEYCODE_COMMA +KEYCODE_MINUS sdl2.html#KEYCODE_MINUS sdl2: KEYCODE_MINUS +KEYCODE_PERIOD sdl2.html#KEYCODE_PERIOD sdl2: KEYCODE_PERIOD +KEYCODE_SLASH sdl2.html#KEYCODE_SLASH sdl2: KEYCODE_SLASH +KEYCODE_0 sdl2.html#KEYCODE_0 sdl2: KEYCODE_0 +KEYCODE_1 sdl2.html#KEYCODE_1 sdl2: KEYCODE_1 +KEYCODE_2 sdl2.html#KEYCODE_2 sdl2: KEYCODE_2 +KEYCODE_3 sdl2.html#KEYCODE_3 sdl2: KEYCODE_3 +KEYCODE_4 sdl2.html#KEYCODE_4 sdl2: KEYCODE_4 +KEYCODE_5 sdl2.html#KEYCODE_5 sdl2: KEYCODE_5 +KEYCODE_6 sdl2.html#KEYCODE_6 sdl2: KEYCODE_6 +KEYCODE_7 sdl2.html#KEYCODE_7 sdl2: KEYCODE_7 +KEYCODE_8 sdl2.html#KEYCODE_8 sdl2: KEYCODE_8 +KEYCODE_9 sdl2.html#KEYCODE_9 sdl2: KEYCODE_9 +KEYCODE_COLON sdl2.html#KEYCODE_COLON sdl2: KEYCODE_COLON +KEYCODE_SEMICOLON sdl2.html#KEYCODE_SEMICOLON sdl2: KEYCODE_SEMICOLON +KEYCODE_LESS sdl2.html#KEYCODE_LESS sdl2: KEYCODE_LESS +KEYCODE_EQUALS sdl2.html#KEYCODE_EQUALS sdl2: KEYCODE_EQUALS +KEYCODE_GREATER sdl2.html#KEYCODE_GREATER sdl2: KEYCODE_GREATER +KEYCODE_QUESTION sdl2.html#KEYCODE_QUESTION sdl2: KEYCODE_QUESTION +KEYCODE_AT sdl2.html#KEYCODE_AT sdl2: KEYCODE_AT +KEYCODE_LEFTBRACKET sdl2.html#KEYCODE_LEFTBRACKET sdl2: KEYCODE_LEFTBRACKET +KEYCODE_BACKSLASH sdl2.html#KEYCODE_BACKSLASH sdl2: KEYCODE_BACKSLASH +KEYCODE_RIGHTBRACKET sdl2.html#KEYCODE_RIGHTBRACKET sdl2: KEYCODE_RIGHTBRACKET +KEYCODE_CARET sdl2.html#KEYCODE_CARET sdl2: KEYCODE_CARET +KEYCODE_UNDERSCORE sdl2.html#KEYCODE_UNDERSCORE sdl2: KEYCODE_UNDERSCORE +KEYCODE_BACKQUOTE sdl2.html#KEYCODE_BACKQUOTE sdl2: KEYCODE_BACKQUOTE +KEYCODE_a sdl2.html#KEYCODE_a sdl2: KEYCODE_a +KEYCODE_b sdl2.html#KEYCODE_b sdl2: KEYCODE_b +KEYCODE_c sdl2.html#KEYCODE_c sdl2: KEYCODE_c +KEYCODE_d sdl2.html#KEYCODE_d sdl2: KEYCODE_d +KEYCODE_e sdl2.html#KEYCODE_e sdl2: KEYCODE_e +KEYCODE_f sdl2.html#KEYCODE_f sdl2: KEYCODE_f +KEYCODE_g sdl2.html#KEYCODE_g sdl2: KEYCODE_g +KEYCODE_h sdl2.html#KEYCODE_h sdl2: KEYCODE_h +KEYCODE_i sdl2.html#KEYCODE_i sdl2: KEYCODE_i +KEYCODE_j sdl2.html#KEYCODE_j sdl2: KEYCODE_j +KEYCODE_k sdl2.html#KEYCODE_k sdl2: KEYCODE_k +KEYCODE_l sdl2.html#KEYCODE_l sdl2: KEYCODE_l +KEYCODE_m sdl2.html#KEYCODE_m sdl2: KEYCODE_m +KEYCODE_n sdl2.html#KEYCODE_n sdl2: KEYCODE_n +KEYCODE_o sdl2.html#KEYCODE_o sdl2: KEYCODE_o +KEYCODE_p sdl2.html#KEYCODE_p sdl2: KEYCODE_p +KEYCODE_q sdl2.html#KEYCODE_q sdl2: KEYCODE_q +KEYCODE_r sdl2.html#KEYCODE_r sdl2: KEYCODE_r +KEYCODE_s sdl2.html#KEYCODE_s sdl2: KEYCODE_s +KEYCODE_t sdl2.html#KEYCODE_t sdl2: KEYCODE_t +KEYCODE_u sdl2.html#KEYCODE_u sdl2: KEYCODE_u +KEYCODE_v sdl2.html#KEYCODE_v sdl2: KEYCODE_v +KEYCODE_w sdl2.html#KEYCODE_w sdl2: KEYCODE_w +KEYCODE_x sdl2.html#KEYCODE_x sdl2: KEYCODE_x +KEYCODE_y sdl2.html#KEYCODE_y sdl2: KEYCODE_y +KEYCODE_z sdl2.html#KEYCODE_z sdl2: KEYCODE_z +KEYCODE_CAPSLOCK sdl2.html#KEYCODE_CAPSLOCK sdl2: KEYCODE_CAPSLOCK +KEYCODE_F1 sdl2.html#KEYCODE_F1 sdl2: KEYCODE_F1 +KEYCODE_F2 sdl2.html#KEYCODE_F2 sdl2: KEYCODE_F2 +KEYCODE_F3 sdl2.html#KEYCODE_F3 sdl2: KEYCODE_F3 +KEYCODE_F4 sdl2.html#KEYCODE_F4 sdl2: KEYCODE_F4 +KEYCODE_F5 sdl2.html#KEYCODE_F5 sdl2: KEYCODE_F5 +KEYCODE_F6 sdl2.html#KEYCODE_F6 sdl2: KEYCODE_F6 +KEYCODE_F7 sdl2.html#KEYCODE_F7 sdl2: KEYCODE_F7 +KEYCODE_F8 sdl2.html#KEYCODE_F8 sdl2: KEYCODE_F8 +KEYCODE_F9 sdl2.html#KEYCODE_F9 sdl2: KEYCODE_F9 +KEYCODE_F10 sdl2.html#KEYCODE_F10 sdl2: KEYCODE_F10 +KEYCODE_F11 sdl2.html#KEYCODE_F11 sdl2: KEYCODE_F11 +KEYCODE_F12 sdl2.html#KEYCODE_F12 sdl2: KEYCODE_F12 +KEYCODE_PRINTSCREEN sdl2.html#KEYCODE_PRINTSCREEN sdl2: KEYCODE_PRINTSCREEN +KEYCODE_SCROLLLOCK sdl2.html#KEYCODE_SCROLLLOCK sdl2: KEYCODE_SCROLLLOCK +KEYCODE_PAUSE sdl2.html#KEYCODE_PAUSE sdl2: KEYCODE_PAUSE +KEYCODE_INSERT sdl2.html#KEYCODE_INSERT sdl2: KEYCODE_INSERT +KEYCODE_HOME sdl2.html#KEYCODE_HOME sdl2: KEYCODE_HOME +KEYCODE_PAGEUP sdl2.html#KEYCODE_PAGEUP sdl2: KEYCODE_PAGEUP +KEYCODE_DELETE sdl2.html#KEYCODE_DELETE sdl2: KEYCODE_DELETE +KEYCODE_END sdl2.html#KEYCODE_END sdl2: KEYCODE_END +KEYCODE_PAGEDOWN sdl2.html#KEYCODE_PAGEDOWN sdl2: KEYCODE_PAGEDOWN +KEYCODE_RIGHT sdl2.html#KEYCODE_RIGHT sdl2: KEYCODE_RIGHT +KEYCODE_LEFT sdl2.html#KEYCODE_LEFT sdl2: KEYCODE_LEFT +KEYCODE_DOWN sdl2.html#KEYCODE_DOWN sdl2: KEYCODE_DOWN +KEYCODE_UP sdl2.html#KEYCODE_UP sdl2: KEYCODE_UP +KEYCODE_NUMLOCKCLEAR sdl2.html#KEYCODE_NUMLOCKCLEAR sdl2: KEYCODE_NUMLOCKCLEAR +KEYCODE_KP_DIVIDE sdl2.html#KEYCODE_KP_DIVIDE sdl2: KEYCODE_KP_DIVIDE +KEYCODE_KP_MULTIPLY sdl2.html#KEYCODE_KP_MULTIPLY sdl2: KEYCODE_KP_MULTIPLY +KEYCODE_KP_MINUS sdl2.html#KEYCODE_KP_MINUS sdl2: KEYCODE_KP_MINUS +KEYCODE_KP_PLUS sdl2.html#KEYCODE_KP_PLUS sdl2: KEYCODE_KP_PLUS +KEYCODE_KP_ENTER sdl2.html#KEYCODE_KP_ENTER sdl2: KEYCODE_KP_ENTER +KEYCODE_KP_1 sdl2.html#KEYCODE_KP_1 sdl2: KEYCODE_KP_1 +KEYCODE_KP_2 sdl2.html#KEYCODE_KP_2 sdl2: KEYCODE_KP_2 +KEYCODE_KP_3 sdl2.html#KEYCODE_KP_3 sdl2: KEYCODE_KP_3 +KEYCODE_KP_4 sdl2.html#KEYCODE_KP_4 sdl2: KEYCODE_KP_4 +KEYCODE_KP_5 sdl2.html#KEYCODE_KP_5 sdl2: KEYCODE_KP_5 +KEYCODE_KP_6 sdl2.html#KEYCODE_KP_6 sdl2: KEYCODE_KP_6 +KEYCODE_KP_7 sdl2.html#KEYCODE_KP_7 sdl2: KEYCODE_KP_7 +KEYCODE_KP_8 sdl2.html#KEYCODE_KP_8 sdl2: KEYCODE_KP_8 +KEYCODE_KP_9 sdl2.html#KEYCODE_KP_9 sdl2: KEYCODE_KP_9 +KEYCODE_KP_0 sdl2.html#KEYCODE_KP_0 sdl2: KEYCODE_KP_0 +KEYCODE_KP_PERIOD sdl2.html#KEYCODE_KP_PERIOD sdl2: KEYCODE_KP_PERIOD +KEYCODE_APPLICATION sdl2.html#KEYCODE_APPLICATION sdl2: KEYCODE_APPLICATION +KEYCODE_POWER sdl2.html#KEYCODE_POWER sdl2: KEYCODE_POWER +KEYCODE_KP_EQUALS sdl2.html#KEYCODE_KP_EQUALS sdl2: KEYCODE_KP_EQUALS +KEYCODE_F13 sdl2.html#KEYCODE_F13 sdl2: KEYCODE_F13 +KEYCODE_F14 sdl2.html#KEYCODE_F14 sdl2: KEYCODE_F14 +KEYCODE_F15 sdl2.html#KEYCODE_F15 sdl2: KEYCODE_F15 +KEYCODE_F16 sdl2.html#KEYCODE_F16 sdl2: KEYCODE_F16 +KEYCODE_F17 sdl2.html#KEYCODE_F17 sdl2: KEYCODE_F17 +KEYCODE_F18 sdl2.html#KEYCODE_F18 sdl2: KEYCODE_F18 +KEYCODE_F19 sdl2.html#KEYCODE_F19 sdl2: KEYCODE_F19 +KEYCODE_F20 sdl2.html#KEYCODE_F20 sdl2: KEYCODE_F20 +KEYCODE_F21 sdl2.html#KEYCODE_F21 sdl2: KEYCODE_F21 +KEYCODE_F22 sdl2.html#KEYCODE_F22 sdl2: KEYCODE_F22 +KEYCODE_F23 sdl2.html#KEYCODE_F23 sdl2: KEYCODE_F23 +KEYCODE_F24 sdl2.html#KEYCODE_F24 sdl2: KEYCODE_F24 +KEYCODE_EXECUTE sdl2.html#KEYCODE_EXECUTE sdl2: KEYCODE_EXECUTE +KEYCODE_HELP sdl2.html#KEYCODE_HELP sdl2: KEYCODE_HELP +KEYCODE_MENU sdl2.html#KEYCODE_MENU sdl2: KEYCODE_MENU +KEYCODE_SELECT sdl2.html#KEYCODE_SELECT sdl2: KEYCODE_SELECT +KEYCODE_STOP sdl2.html#KEYCODE_STOP sdl2: KEYCODE_STOP +KEYCODE_AGAIN sdl2.html#KEYCODE_AGAIN sdl2: KEYCODE_AGAIN +KEYCODE_UNDO sdl2.html#KEYCODE_UNDO sdl2: KEYCODE_UNDO +KEYCODE_CUT sdl2.html#KEYCODE_CUT sdl2: KEYCODE_CUT +KEYCODE_COPY sdl2.html#KEYCODE_COPY sdl2: KEYCODE_COPY +KEYCODE_PASTE sdl2.html#KEYCODE_PASTE sdl2: KEYCODE_PASTE +KEYCODE_FIND sdl2.html#KEYCODE_FIND sdl2: KEYCODE_FIND +KEYCODE_MUTE sdl2.html#KEYCODE_MUTE sdl2: KEYCODE_MUTE +KEYCODE_VOLUMEUP sdl2.html#KEYCODE_VOLUMEUP sdl2: KEYCODE_VOLUMEUP +KEYCODE_VOLUMEDOWN sdl2.html#KEYCODE_VOLUMEDOWN sdl2: KEYCODE_VOLUMEDOWN +KEYCODE_KP_COMMA sdl2.html#KEYCODE_KP_COMMA sdl2: KEYCODE_KP_COMMA +KEYCODE_KP_EQUALSAS400 sdl2.html#KEYCODE_KP_EQUALSAS400 sdl2: KEYCODE_KP_EQUALSAS400 +KEYCODE_ALTERASE sdl2.html#KEYCODE_ALTERASE sdl2: KEYCODE_ALTERASE +KEYCODE_SYSREQ sdl2.html#KEYCODE_SYSREQ sdl2: KEYCODE_SYSREQ +KEYCODE_CANCEL sdl2.html#KEYCODE_CANCEL sdl2: KEYCODE_CANCEL +KEYCODE_CLEAR sdl2.html#KEYCODE_CLEAR sdl2: KEYCODE_CLEAR +KEYCODE_PRIOR sdl2.html#KEYCODE_PRIOR sdl2: KEYCODE_PRIOR +KEYCODE_RETURN2 sdl2.html#KEYCODE_RETURN2 sdl2: KEYCODE_RETURN2 +KEYCODE_SEPARATOR sdl2.html#KEYCODE_SEPARATOR sdl2: KEYCODE_SEPARATOR +KEYCODE_OUT sdl2.html#KEYCODE_OUT sdl2: KEYCODE_OUT +KEYCODE_OPER sdl2.html#KEYCODE_OPER sdl2: KEYCODE_OPER +KEYCODE_CLEARAGAIN sdl2.html#KEYCODE_CLEARAGAIN sdl2: KEYCODE_CLEARAGAIN +KEYCODE_CRSEL sdl2.html#KEYCODE_CRSEL sdl2: KEYCODE_CRSEL +KEYCODE_EXSEL sdl2.html#KEYCODE_EXSEL sdl2: KEYCODE_EXSEL +KEYCODE_KP_00 sdl2.html#KEYCODE_KP_00 sdl2: KEYCODE_KP_00 +KEYCODE_KP_000 sdl2.html#KEYCODE_KP_000 sdl2: KEYCODE_KP_000 +KEYCODE_THOUSANDSSEPARATOR sdl2.html#KEYCODE_THOUSANDSSEPARATOR sdl2: KEYCODE_THOUSANDSSEPARATOR +KEYCODE_DECIMALSEPARATOR sdl2.html#KEYCODE_DECIMALSEPARATOR sdl2: KEYCODE_DECIMALSEPARATOR +KEYCODE_CURRENCYUNIT sdl2.html#KEYCODE_CURRENCYUNIT sdl2: KEYCODE_CURRENCYUNIT +KEYCODE_CURRENCYSUBUNIT sdl2.html#KEYCODE_CURRENCYSUBUNIT sdl2: KEYCODE_CURRENCYSUBUNIT +KEYCODE_KP_LEFTPAREN sdl2.html#KEYCODE_KP_LEFTPAREN sdl2: KEYCODE_KP_LEFTPAREN +KEYCODE_KP_RIGHTPAREN sdl2.html#KEYCODE_KP_RIGHTPAREN sdl2: KEYCODE_KP_RIGHTPAREN +KEYCODE_KP_LEFTBRACE sdl2.html#KEYCODE_KP_LEFTBRACE sdl2: KEYCODE_KP_LEFTBRACE +KEYCODE_KP_RIGHTBRACE sdl2.html#KEYCODE_KP_RIGHTBRACE sdl2: KEYCODE_KP_RIGHTBRACE +KEYCODE_KP_TAB sdl2.html#KEYCODE_KP_TAB sdl2: KEYCODE_KP_TAB +KEYCODE_KP_BACKSPACE sdl2.html#KEYCODE_KP_BACKSPACE sdl2: KEYCODE_KP_BACKSPACE +KEYCODE_KP_A sdl2.html#KEYCODE_KP_A sdl2: KEYCODE_KP_A +KEYCODE_KP_B sdl2.html#KEYCODE_KP_B sdl2: KEYCODE_KP_B +KEYCODE_KP_C sdl2.html#KEYCODE_KP_C sdl2: KEYCODE_KP_C +KEYCODE_KP_D sdl2.html#KEYCODE_KP_D sdl2: KEYCODE_KP_D +KEYCODE_KP_E sdl2.html#KEYCODE_KP_E sdl2: KEYCODE_KP_E +KEYCODE_KP_F sdl2.html#KEYCODE_KP_F sdl2: KEYCODE_KP_F +KEYCODE_KP_XOR sdl2.html#KEYCODE_KP_XOR sdl2: KEYCODE_KP_XOR +KEYCODE_KP_POWER sdl2.html#KEYCODE_KP_POWER sdl2: KEYCODE_KP_POWER +KEYCODE_KP_PERCENT sdl2.html#KEYCODE_KP_PERCENT sdl2: KEYCODE_KP_PERCENT +KEYCODE_KP_LESS sdl2.html#KEYCODE_KP_LESS sdl2: KEYCODE_KP_LESS +KEYCODE_KP_GREATER sdl2.html#KEYCODE_KP_GREATER sdl2: KEYCODE_KP_GREATER +KEYCODE_KP_AMPERSAND sdl2.html#KEYCODE_KP_AMPERSAND sdl2: KEYCODE_KP_AMPERSAND +KEYCODE_KP_DBLAMPERSAND sdl2.html#KEYCODE_KP_DBLAMPERSAND sdl2: KEYCODE_KP_DBLAMPERSAND +KEYCODE_KP_VERTICALBAR sdl2.html#KEYCODE_KP_VERTICALBAR sdl2: KEYCODE_KP_VERTICALBAR +KEYCODE_KP_DBLVERTICALBAR sdl2.html#KEYCODE_KP_DBLVERTICALBAR sdl2: KEYCODE_KP_DBLVERTICALBAR +KEYCODE_KP_COLON sdl2.html#KEYCODE_KP_COLON sdl2: KEYCODE_KP_COLON +KEYCODE_KP_HASH sdl2.html#KEYCODE_KP_HASH sdl2: KEYCODE_KP_HASH +KEYCODE_KP_SPACE sdl2.html#KEYCODE_KP_SPACE sdl2: KEYCODE_KP_SPACE +KEYCODE_KP_AT sdl2.html#KEYCODE_KP_AT sdl2: KEYCODE_KP_AT +KEYCODE_KP_EXCLAM sdl2.html#KEYCODE_KP_EXCLAM sdl2: KEYCODE_KP_EXCLAM +KEYCODE_KP_MEMSTORE sdl2.html#KEYCODE_KP_MEMSTORE sdl2: KEYCODE_KP_MEMSTORE +KEYCODE_KP_MEMRECALL sdl2.html#KEYCODE_KP_MEMRECALL sdl2: KEYCODE_KP_MEMRECALL +KEYCODE_KP_MEMCLEAR sdl2.html#KEYCODE_KP_MEMCLEAR sdl2: KEYCODE_KP_MEMCLEAR +KEYCODE_KP_MEMADD sdl2.html#KEYCODE_KP_MEMADD sdl2: KEYCODE_KP_MEMADD +KEYCODE_KP_MEMSUBTRACT sdl2.html#KEYCODE_KP_MEMSUBTRACT sdl2: KEYCODE_KP_MEMSUBTRACT +KEYCODE_KP_MEMMULTIPLY sdl2.html#KEYCODE_KP_MEMMULTIPLY sdl2: KEYCODE_KP_MEMMULTIPLY +KEYCODE_KP_MEMDIVIDE sdl2.html#KEYCODE_KP_MEMDIVIDE sdl2: KEYCODE_KP_MEMDIVIDE +KEYCODE_KP_PLUSMINUS sdl2.html#KEYCODE_KP_PLUSMINUS sdl2: KEYCODE_KP_PLUSMINUS +KEYCODE_KP_CLEAR sdl2.html#KEYCODE_KP_CLEAR sdl2: KEYCODE_KP_CLEAR +KEYCODE_KP_CLEARENTRY sdl2.html#KEYCODE_KP_CLEARENTRY sdl2: KEYCODE_KP_CLEARENTRY +KEYCODE_KP_BINARY sdl2.html#KEYCODE_KP_BINARY sdl2: KEYCODE_KP_BINARY +KEYCODE_KP_OCTAL sdl2.html#KEYCODE_KP_OCTAL sdl2: KEYCODE_KP_OCTAL +KEYCODE_KP_DECIMAL sdl2.html#KEYCODE_KP_DECIMAL sdl2: KEYCODE_KP_DECIMAL +KEYCODE_KP_HEXADECIMAL sdl2.html#KEYCODE_KP_HEXADECIMAL sdl2: KEYCODE_KP_HEXADECIMAL +KEYCODE_LCTRL sdl2.html#KEYCODE_LCTRL sdl2: KEYCODE_LCTRL +KEYCODE_LSHIFT sdl2.html#KEYCODE_LSHIFT sdl2: KEYCODE_LSHIFT +KEYCODE_LALT sdl2.html#KEYCODE_LALT sdl2: KEYCODE_LALT +KEYCODE_LGUI sdl2.html#KEYCODE_LGUI sdl2: KEYCODE_LGUI +KEYCODE_RCTRL sdl2.html#KEYCODE_RCTRL sdl2: KEYCODE_RCTRL +KEYCODE_RSHIFT sdl2.html#KEYCODE_RSHIFT sdl2: KEYCODE_RSHIFT +KEYCODE_RALT sdl2.html#KEYCODE_RALT sdl2: KEYCODE_RALT +KEYCODE_RGUI sdl2.html#KEYCODE_RGUI sdl2: KEYCODE_RGUI +KEYCODE_MODE sdl2.html#KEYCODE_MODE sdl2: KEYCODE_MODE +KEYCODE_AUDIONEXT sdl2.html#KEYCODE_AUDIONEXT sdl2: KEYCODE_AUDIONEXT +KEYCODE_AUDIOPREV sdl2.html#KEYCODE_AUDIOPREV sdl2: KEYCODE_AUDIOPREV +KEYCODE_AUDIOSTOP sdl2.html#KEYCODE_AUDIOSTOP sdl2: KEYCODE_AUDIOSTOP +KEYCODE_AUDIOPLAY sdl2.html#KEYCODE_AUDIOPLAY sdl2: KEYCODE_AUDIOPLAY +KEYCODE_AUDIOMUTE sdl2.html#KEYCODE_AUDIOMUTE sdl2: KEYCODE_AUDIOMUTE +KEYCODE_MEDIASELECT sdl2.html#KEYCODE_MEDIASELECT sdl2: KEYCODE_MEDIASELECT +KEYCODE_WWW sdl2.html#KEYCODE_WWW sdl2: KEYCODE_WWW +KEYCODE_MAIL sdl2.html#KEYCODE_MAIL sdl2: KEYCODE_MAIL +KEYCODE_CALCULATOR sdl2.html#KEYCODE_CALCULATOR sdl2: KEYCODE_CALCULATOR +KEYCODE_COMPUTER sdl2.html#KEYCODE_COMPUTER sdl2: KEYCODE_COMPUTER +KEYCODE_AC_SEARCH sdl2.html#KEYCODE_AC_SEARCH sdl2: KEYCODE_AC_SEARCH +KEYCODE_AC_HOME sdl2.html#KEYCODE_AC_HOME sdl2: KEYCODE_AC_HOME +KEYCODE_AC_BACK sdl2.html#KEYCODE_AC_BACK sdl2: KEYCODE_AC_BACK +KEYCODE_AC_FORWARD sdl2.html#KEYCODE_AC_FORWARD sdl2: KEYCODE_AC_FORWARD +KEYCODE_AC_STOP sdl2.html#KEYCODE_AC_STOP sdl2: KEYCODE_AC_STOP +KEYCODE_AC_REFRESH sdl2.html#KEYCODE_AC_REFRESH sdl2: KEYCODE_AC_REFRESH +KEYCODE_AC_BOOKMARKS sdl2.html#KEYCODE_AC_BOOKMARKS sdl2: KEYCODE_AC_BOOKMARKS +KEYCODE_BRIGHTNESSDOWN sdl2.html#KEYCODE_BRIGHTNESSDOWN sdl2: KEYCODE_BRIGHTNESSDOWN +KEYCODE_BRIGHTNESSUP sdl2.html#KEYCODE_BRIGHTNESSUP sdl2: KEYCODE_BRIGHTNESSUP +KEYCODE_DISPLAYSWITCH sdl2.html#KEYCODE_DISPLAYSWITCH sdl2: KEYCODE_DISPLAYSWITCH +KEYCODE_KBDILLUMTOGGLE sdl2.html#KEYCODE_KBDILLUMTOGGLE sdl2: KEYCODE_KBDILLUMTOGGLE +KEYCODE_KBDILLUMDOWN sdl2.html#KEYCODE_KBDILLUMDOWN sdl2: KEYCODE_KBDILLUMDOWN +KEYCODE_KBDILLUMUP sdl2.html#KEYCODE_KBDILLUMUP sdl2: KEYCODE_KBDILLUMUP +KEYCODE_EJECT sdl2.html#KEYCODE_EJECT sdl2: KEYCODE_EJECT +KEYCODE_SLEEP sdl2.html#KEYCODE_SLEEP sdl2: KEYCODE_SLEEP +KEYCODE_APP1 sdl2.html#KEYCODE_APP1 sdl2: KEYCODE_APP1 +KEYCODE_APP2 sdl2.html#KEYCODE_APP2 sdl2: KEYCODE_APP2 +KEYCODE_AUDIOREWIND sdl2.html#KEYCODE_AUDIOREWIND sdl2: KEYCODE_AUDIOREWIND +KEYCODE_AUDIOFASTFORWARD sdl2.html#KEYCODE_AUDIOFASTFORWARD sdl2: KEYCODE_AUDIOFASTFORWARD +KMOD_NONE sdl2.html#KMOD_NONE sdl2: KMOD_NONE +KMOD_LSHIFT sdl2.html#KMOD_LSHIFT sdl2: KMOD_LSHIFT +KMOD_RSHIFT sdl2.html#KMOD_RSHIFT sdl2: KMOD_RSHIFT +KMOD_LCTRL sdl2.html#KMOD_LCTRL sdl2: KMOD_LCTRL +KMOD_RCTRL sdl2.html#KMOD_RCTRL sdl2: KMOD_RCTRL +KMOD_LALT sdl2.html#KMOD_LALT sdl2: KMOD_LALT +KMOD_RALT sdl2.html#KMOD_RALT sdl2: KMOD_RALT +KMOD_LGUI sdl2.html#KMOD_LGUI sdl2: KMOD_LGUI +KMOD_RGUI sdl2.html#KMOD_RGUI sdl2: KMOD_RGUI +KMOD_NUM sdl2.html#KMOD_NUM sdl2: KMOD_NUM +KMOD_CAPS sdl2.html#KMOD_CAPS sdl2: KMOD_CAPS +KMOD_MODE sdl2.html#KMOD_MODE sdl2: KMOD_MODE +KMOD_RESERVED sdl2.html#KMOD_RESERVED sdl2: KMOD_RESERVED +KMOD_CTRL sdl2.html#KMOD_CTRL sdl2: KMOD_CTRL +KMOD_SHIFT sdl2.html#KMOD_SHIFT sdl2: KMOD_SHIFT +KMOD_ALT sdl2.html#KMOD_ALT sdl2: KMOD_ALT +KMOD_GUI sdl2.html#KMOD_GUI sdl2: KMOD_GUI +SYSTEM_CURSOR_ARROW sdl2.html#SYSTEM_CURSOR_ARROW sdl2: SYSTEM_CURSOR_ARROW +SYSTEM_CURSOR_IBEAM sdl2.html#SYSTEM_CURSOR_IBEAM sdl2: SYSTEM_CURSOR_IBEAM +SYSTEM_CURSOR_WAIT sdl2.html#SYSTEM_CURSOR_WAIT sdl2: SYSTEM_CURSOR_WAIT +SYSTEM_CURSOR_CROSSHAIR sdl2.html#SYSTEM_CURSOR_CROSSHAIR sdl2: SYSTEM_CURSOR_CROSSHAIR +SYSTEM_CURSOR_WAITARROW sdl2.html#SYSTEM_CURSOR_WAITARROW sdl2: SYSTEM_CURSOR_WAITARROW +SYSTEM_CURSOR_SIZENWSE sdl2.html#SYSTEM_CURSOR_SIZENWSE sdl2: SYSTEM_CURSOR_SIZENWSE +SYSTEM_CURSOR_SIZENESW sdl2.html#SYSTEM_CURSOR_SIZENESW sdl2: SYSTEM_CURSOR_SIZENESW +SYSTEM_CURSOR_SIZEWE sdl2.html#SYSTEM_CURSOR_SIZEWE sdl2: SYSTEM_CURSOR_SIZEWE +SYSTEM_CURSOR_SIZENS sdl2.html#SYSTEM_CURSOR_SIZENS sdl2: SYSTEM_CURSOR_SIZENS +SYSTEM_CURSOR_SIZEALL sdl2.html#SYSTEM_CURSOR_SIZEALL sdl2: SYSTEM_CURSOR_SIZEALL +SYSTEM_CURSOR_NO sdl2.html#SYSTEM_CURSOR_NO sdl2: SYSTEM_CURSOR_NO +SYSTEM_CURSOR_HAND sdl2.html#SYSTEM_CURSOR_HAND sdl2: SYSTEM_CURSOR_HAND +NUM_SYSTEM_CURSORS sdl2.html#NUM_SYSTEM_CURSORS sdl2: NUM_SYSTEM_CURSORS +MOUSEWHEEL_NORMAL sdl2.html#MOUSEWHEEL_NORMAL sdl2: MOUSEWHEEL_NORMAL +MOUSEWHEEL_FLIPPED sdl2.html#MOUSEWHEEL_FLIPPED sdl2: MOUSEWHEEL_FLIPPED +BUTTON_LEFT sdl2.html#BUTTON_LEFT sdl2: BUTTON_LEFT +BUTTON_MIDDLE sdl2.html#BUTTON_MIDDLE sdl2: BUTTON_MIDDLE +BUTTON_RIGHT sdl2.html#BUTTON_RIGHT sdl2: BUTTON_RIGHT +BUTTON_X1 sdl2.html#BUTTON_X1 sdl2: BUTTON_X1 +BUTTON_X2 sdl2.html#BUTTON_X2 sdl2: BUTTON_X2 +JOYSTICK_TYPE_UNKNOWN sdl2.html#JOYSTICK_TYPE_UNKNOWN sdl2: JOYSTICK_TYPE_UNKNOWN +JOYSTICK_TYPE_GAMECONTROLLER sdl2.html#JOYSTICK_TYPE_GAMECONTROLLER sdl2: JOYSTICK_TYPE_GAMECONTROLLER +JOYSTICK_TYPE_WHEEL sdl2.html#JOYSTICK_TYPE_WHEEL sdl2: JOYSTICK_TYPE_WHEEL +JOYSTICK_TYPE_ARCADE_STICK sdl2.html#JOYSTICK_TYPE_ARCADE_STICK sdl2: JOYSTICK_TYPE_ARCADE_STICK +JOYSTICK_TYPE_FLIGHT_STICK sdl2.html#JOYSTICK_TYPE_FLIGHT_STICK sdl2: JOYSTICK_TYPE_FLIGHT_STICK +JOYSTICK_TYPE_DANCE_PAD sdl2.html#JOYSTICK_TYPE_DANCE_PAD sdl2: JOYSTICK_TYPE_DANCE_PAD +JOYSTICK_TYPE_GUITAR sdl2.html#JOYSTICK_TYPE_GUITAR sdl2: JOYSTICK_TYPE_GUITAR +JOYSTICK_TYPE_DRUM_KIT sdl2.html#JOYSTICK_TYPE_DRUM_KIT sdl2: JOYSTICK_TYPE_DRUM_KIT +JOYSTICK_TYPE_ARCADE_PAD sdl2.html#JOYSTICK_TYPE_ARCADE_PAD sdl2: JOYSTICK_TYPE_ARCADE_PAD +JOYSTICK_TYPE_THROTTLE sdl2.html#JOYSTICK_TYPE_THROTTLE sdl2: JOYSTICK_TYPE_THROTTLE +JOYSTICK_POWER_UNKNOWN sdl2.html#JOYSTICK_POWER_UNKNOWN sdl2: JOYSTICK_POWER_UNKNOWN +JOYSTICK_POWER_EMPTY sdl2.html#JOYSTICK_POWER_EMPTY sdl2: JOYSTICK_POWER_EMPTY +JOYSTICK_POWER_LOW sdl2.html#JOYSTICK_POWER_LOW sdl2: JOYSTICK_POWER_LOW +JOYSTICK_POWER_MEDIUM sdl2.html#JOYSTICK_POWER_MEDIUM sdl2: JOYSTICK_POWER_MEDIUM +JOYSTICK_POWER_FULL sdl2.html#JOYSTICK_POWER_FULL sdl2: JOYSTICK_POWER_FULL +JOYSTICK_POWER_WIRED sdl2.html#JOYSTICK_POWER_WIRED sdl2: JOYSTICK_POWER_WIRED +JOYSTICK_POWER_MAX sdl2.html#JOYSTICK_POWER_MAX sdl2: JOYSTICK_POWER_MAX +JOYSTICK_AXIS_MAX sdl2.html#JOYSTICK_AXIS_MAX sdl2: JOYSTICK_AXIS_MAX +JOYSTICK_AXIS_MIN sdl2.html#JOYSTICK_AXIS_MIN sdl2: JOYSTICK_AXIS_MIN +HAT_CENTERED sdl2.html#HAT_CENTERED sdl2: HAT_CENTERED +HAT_UP sdl2.html#HAT_UP sdl2: HAT_UP +HAT_RIGHT sdl2.html#HAT_RIGHT sdl2: HAT_RIGHT +HAT_DOWN sdl2.html#HAT_DOWN sdl2: HAT_DOWN +HAT_LEFT sdl2.html#HAT_LEFT sdl2: HAT_LEFT +HAT_RIGHTUP sdl2.html#HAT_RIGHTUP sdl2: HAT_RIGHTUP +HAT_RIGHTDOWN sdl2.html#HAT_RIGHTDOWN sdl2: HAT_RIGHTDOWN +HAT_LEFTUP sdl2.html#HAT_LEFTUP sdl2: HAT_LEFTUP +HAT_LEFTDOWN sdl2.html#HAT_LEFTDOWN sdl2: HAT_LEFTDOWN +CONTROLLER_TYPE_UNKNOWN sdl2.html#CONTROLLER_TYPE_UNKNOWN sdl2: CONTROLLER_TYPE_UNKNOWN +CONTROLLER_TYPE_XBOX360 sdl2.html#CONTROLLER_TYPE_XBOX360 sdl2: CONTROLLER_TYPE_XBOX360 +CONTROLLER_TYPE_XBOXONE sdl2.html#CONTROLLER_TYPE_XBOXONE sdl2: CONTROLLER_TYPE_XBOXONE +CONTROLLER_TYPE_PS3 sdl2.html#CONTROLLER_TYPE_PS3 sdl2: CONTROLLER_TYPE_PS3 +CONTROLLER_TYPE_PS4 sdl2.html#CONTROLLER_TYPE_PS4 sdl2: CONTROLLER_TYPE_PS4 +CONTROLLER_TYPE_NINTENDO_SWITCH_PRO sdl2.html#CONTROLLER_TYPE_NINTENDO_SWITCH_PRO sdl2: CONTROLLER_TYPE_NINTENDO_SWITCH_PRO +CONTROLLER_AXIS_INVALID sdl2.html#CONTROLLER_AXIS_INVALID sdl2: CONTROLLER_AXIS_INVALID +CONTROLLER_AXIS_LEFTX sdl2.html#CONTROLLER_AXIS_LEFTX sdl2: CONTROLLER_AXIS_LEFTX +CONTROLLER_AXIS_LEFTY sdl2.html#CONTROLLER_AXIS_LEFTY sdl2: CONTROLLER_AXIS_LEFTY +CONTROLLER_AXIS_RIGHTX sdl2.html#CONTROLLER_AXIS_RIGHTX sdl2: CONTROLLER_AXIS_RIGHTX +CONTROLLER_AXIS_RIGHTY sdl2.html#CONTROLLER_AXIS_RIGHTY sdl2: CONTROLLER_AXIS_RIGHTY +CONTROLLER_AXIS_TRIGGERLEFT sdl2.html#CONTROLLER_AXIS_TRIGGERLEFT sdl2: CONTROLLER_AXIS_TRIGGERLEFT +CONTROLLER_AXIS_TRIGGERRIGHT sdl2.html#CONTROLLER_AXIS_TRIGGERRIGHT sdl2: CONTROLLER_AXIS_TRIGGERRIGHT +CONTROLLER_AXIS_MAX sdl2.html#CONTROLLER_AXIS_MAX sdl2: CONTROLLER_AXIS_MAX +CONTROLLER_BUTTON_INVALID sdl2.html#CONTROLLER_BUTTON_INVALID sdl2: CONTROLLER_BUTTON_INVALID +CONTROLLER_BUTTON_A sdl2.html#CONTROLLER_BUTTON_A sdl2: CONTROLLER_BUTTON_A +CONTROLLER_BUTTON_B sdl2.html#CONTROLLER_BUTTON_B sdl2: CONTROLLER_BUTTON_B +CONTROLLER_BUTTON_X sdl2.html#CONTROLLER_BUTTON_X sdl2: CONTROLLER_BUTTON_X +CONTROLLER_BUTTON_Y sdl2.html#CONTROLLER_BUTTON_Y sdl2: CONTROLLER_BUTTON_Y +CONTROLLER_BUTTON_BACK sdl2.html#CONTROLLER_BUTTON_BACK sdl2: CONTROLLER_BUTTON_BACK +CONTROLLER_BUTTON_GUIDE sdl2.html#CONTROLLER_BUTTON_GUIDE sdl2: CONTROLLER_BUTTON_GUIDE +CONTROLLER_BUTTON_START sdl2.html#CONTROLLER_BUTTON_START sdl2: CONTROLLER_BUTTON_START +CONTROLLER_BUTTON_LEFTSTICK sdl2.html#CONTROLLER_BUTTON_LEFTSTICK sdl2: CONTROLLER_BUTTON_LEFTSTICK +CONTROLLER_BUTTON_RIGHTSTICK sdl2.html#CONTROLLER_BUTTON_RIGHTSTICK sdl2: CONTROLLER_BUTTON_RIGHTSTICK +CONTROLLER_BUTTON_LEFTSHOULDER sdl2.html#CONTROLLER_BUTTON_LEFTSHOULDER sdl2: CONTROLLER_BUTTON_LEFTSHOULDER +CONTROLLER_BUTTON_RIGHTSHOULDER sdl2.html#CONTROLLER_BUTTON_RIGHTSHOULDER sdl2: CONTROLLER_BUTTON_RIGHTSHOULDER +CONTROLLER_BUTTON_DPAD_UP sdl2.html#CONTROLLER_BUTTON_DPAD_UP sdl2: CONTROLLER_BUTTON_DPAD_UP +CONTROLLER_BUTTON_DPAD_DOWN sdl2.html#CONTROLLER_BUTTON_DPAD_DOWN sdl2: CONTROLLER_BUTTON_DPAD_DOWN +CONTROLLER_BUTTON_DPAD_LEFT sdl2.html#CONTROLLER_BUTTON_DPAD_LEFT sdl2: CONTROLLER_BUTTON_DPAD_LEFT +CONTROLLER_BUTTON_DPAD_RIGHT sdl2.html#CONTROLLER_BUTTON_DPAD_RIGHT sdl2: CONTROLLER_BUTTON_DPAD_RIGHT +CONTROLLER_BUTTON_MAX sdl2.html#CONTROLLER_BUTTON_MAX sdl2: CONTROLLER_BUTTON_MAX +TOUCH_DEVICE_INVALID sdl2.html#TOUCH_DEVICE_INVALID sdl2: TOUCH_DEVICE_INVALID +TOUCH_DEVICE_DIRECT sdl2.html#TOUCH_DEVICE_DIRECT sdl2: TOUCH_DEVICE_DIRECT +TOUCH_DEVICE_INDIRECT_ABSOLUTE sdl2.html#TOUCH_DEVICE_INDIRECT_ABSOLUTE sdl2: TOUCH_DEVICE_INDIRECT_ABSOLUTE +TOUCH_DEVICE_INDIRECT_RELATIVE sdl2.html#TOUCH_DEVICE_INDIRECT_RELATIVE sdl2: TOUCH_DEVICE_INDIRECT_RELATIVE +RELEASED sdl2.html#RELEASED sdl2: RELEASED +PRESSED sdl2.html#PRESSED sdl2: PRESSED +EVENT_FIRSTEVENT sdl2.html#EVENT_FIRSTEVENT sdl2: EVENT_FIRSTEVENT +EVENT_QUIT sdl2.html#EVENT_QUIT sdl2: EVENT_QUIT +EVENT_APP_TERMINATING sdl2.html#EVENT_APP_TERMINATING sdl2: EVENT_APP_TERMINATING +EVENT_APP_LOWMEMORY sdl2.html#EVENT_APP_LOWMEMORY sdl2: EVENT_APP_LOWMEMORY +EVENT_APP_WILLENTERBACKGROUND sdl2.html#EVENT_APP_WILLENTERBACKGROUND sdl2: EVENT_APP_WILLENTERBACKGROUND +EVENT_APP_DIDENTERBACKGROUND sdl2.html#EVENT_APP_DIDENTERBACKGROUND sdl2: EVENT_APP_DIDENTERBACKGROUND +EVENT_APP_WILLENTERFOREGROUND sdl2.html#EVENT_APP_WILLENTERFOREGROUND sdl2: EVENT_APP_WILLENTERFOREGROUND +EVENT_APP_DIDENTERFOREGROUND sdl2.html#EVENT_APP_DIDENTERFOREGROUND sdl2: EVENT_APP_DIDENTERFOREGROUND +EVENT_DISPLAYEVENT sdl2.html#EVENT_DISPLAYEVENT sdl2: EVENT_DISPLAYEVENT +EVENT_WINDOWEVENT sdl2.html#EVENT_WINDOWEVENT sdl2: EVENT_WINDOWEVENT +EVENT_SYSWMEVENT sdl2.html#EVENT_SYSWMEVENT sdl2: EVENT_SYSWMEVENT +EVENT_KEYDOWN sdl2.html#EVENT_KEYDOWN sdl2: EVENT_KEYDOWN +EVENT_KEYUP sdl2.html#EVENT_KEYUP sdl2: EVENT_KEYUP +EVENT_TEXTEDITING sdl2.html#EVENT_TEXTEDITING sdl2: EVENT_TEXTEDITING +EVENT_TEXTINPUT sdl2.html#EVENT_TEXTINPUT sdl2: EVENT_TEXTINPUT +EVENT_KEYMAPCHANGED sdl2.html#EVENT_KEYMAPCHANGED sdl2: EVENT_KEYMAPCHANGED +EVENT_MOUSEMOTION sdl2.html#EVENT_MOUSEMOTION sdl2: EVENT_MOUSEMOTION +EVENT_MOUSEBUTTONDOWN sdl2.html#EVENT_MOUSEBUTTONDOWN sdl2: EVENT_MOUSEBUTTONDOWN +EVENT_MOUSEBUTTONUP sdl2.html#EVENT_MOUSEBUTTONUP sdl2: EVENT_MOUSEBUTTONUP +EVENT_MOUSEWHEEL sdl2.html#EVENT_MOUSEWHEEL sdl2: EVENT_MOUSEWHEEL +EVENT_JOYAXISMOTION sdl2.html#EVENT_JOYAXISMOTION sdl2: EVENT_JOYAXISMOTION +EVENT_JOYBALLMOTION sdl2.html#EVENT_JOYBALLMOTION sdl2: EVENT_JOYBALLMOTION +EVENT_JOYHATMOTION sdl2.html#EVENT_JOYHATMOTION sdl2: EVENT_JOYHATMOTION +EVENT_JOYBUTTONDOWN sdl2.html#EVENT_JOYBUTTONDOWN sdl2: EVENT_JOYBUTTONDOWN +EVENT_JOYBUTTONUP sdl2.html#EVENT_JOYBUTTONUP sdl2: EVENT_JOYBUTTONUP +EVENT_JOYDEVICEADDED sdl2.html#EVENT_JOYDEVICEADDED sdl2: EVENT_JOYDEVICEADDED +EVENT_JOYDEVICEREMOVED sdl2.html#EVENT_JOYDEVICEREMOVED sdl2: EVENT_JOYDEVICEREMOVED +EVENT_CONTROLLERAXISMOTION sdl2.html#EVENT_CONTROLLERAXISMOTION sdl2: EVENT_CONTROLLERAXISMOTION +EVENT_CONTROLLERBUTTONDOWN sdl2.html#EVENT_CONTROLLERBUTTONDOWN sdl2: EVENT_CONTROLLERBUTTONDOWN +EVENT_CONTROLLERBUTTONUP sdl2.html#EVENT_CONTROLLERBUTTONUP sdl2: EVENT_CONTROLLERBUTTONUP +EVENT_CONTROLLERDEVICEADDED sdl2.html#EVENT_CONTROLLERDEVICEADDED sdl2: EVENT_CONTROLLERDEVICEADDED +EVENT_CONTROLLERDEVICEREMOVED sdl2.html#EVENT_CONTROLLERDEVICEREMOVED sdl2: EVENT_CONTROLLERDEVICEREMOVED +EVENT_CONTROLLERDEVICEREMAPPED sdl2.html#EVENT_CONTROLLERDEVICEREMAPPED sdl2: EVENT_CONTROLLERDEVICEREMAPPED +EVENT_FINGERDOWN sdl2.html#EVENT_FINGERDOWN sdl2: EVENT_FINGERDOWN +EVENT_FINGERUP sdl2.html#EVENT_FINGERUP sdl2: EVENT_FINGERUP +EVENT_FINGERMOTION sdl2.html#EVENT_FINGERMOTION sdl2: EVENT_FINGERMOTION +EVENT_DOLLARGESTURE sdl2.html#EVENT_DOLLARGESTURE sdl2: EVENT_DOLLARGESTURE +EVENT_DOLLARRECORD sdl2.html#EVENT_DOLLARRECORD sdl2: EVENT_DOLLARRECORD +EVENT_MULTIGESTURE sdl2.html#EVENT_MULTIGESTURE sdl2: EVENT_MULTIGESTURE +EVENT_CLIPBOARDUPDATE sdl2.html#EVENT_CLIPBOARDUPDATE sdl2: EVENT_CLIPBOARDUPDATE +EVENT_DROPFILE sdl2.html#EVENT_DROPFILE sdl2: EVENT_DROPFILE +EVENT_DROPTEXT sdl2.html#EVENT_DROPTEXT sdl2: EVENT_DROPTEXT +EVENT_DROPBEGIN sdl2.html#EVENT_DROPBEGIN sdl2: EVENT_DROPBEGIN +EVENT_DROPCOMPLETE sdl2.html#EVENT_DROPCOMPLETE sdl2: EVENT_DROPCOMPLETE +EVENT_AUDIODEVICEADDED sdl2.html#EVENT_AUDIODEVICEADDED sdl2: EVENT_AUDIODEVICEADDED +EVENT_AUDIODEVICEREMOVED sdl2.html#EVENT_AUDIODEVICEREMOVED sdl2: EVENT_AUDIODEVICEREMOVED +EVENT_SENSORUPDATE sdl2.html#EVENT_SENSORUPDATE sdl2: EVENT_SENSORUPDATE +EVENT_RENDER_TARGETS_RESET sdl2.html#EVENT_RENDER_TARGETS_RESET sdl2: EVENT_RENDER_TARGETS_RESET +EVENT_RENDER_DEVICE_RESET sdl2.html#EVENT_RENDER_DEVICE_RESET sdl2: EVENT_RENDER_DEVICE_RESET +EVENT_USEREVENT sdl2.html#EVENT_USEREVENT sdl2: EVENT_USEREVENT +EVENT_LASTEVENT sdl2.html#EVENT_LASTEVENT sdl2: EVENT_LASTEVENT +TEXTEDITINGEVENT_TEXT_SIZE sdl2.html#TEXTEDITINGEVENT_TEXT_SIZE sdl2: TEXTEDITINGEVENT_TEXT_SIZE +TEXTINPUTEVENT_TEXT_SIZE sdl2.html#TEXTINPUTEVENT_TEXT_SIZE sdl2: TEXTINPUTEVENT_TEXT_SIZE +ADDEVENT sdl2.html#ADDEVENT sdl2: ADDEVENT +PEEKEVENT sdl2.html#PEEKEVENT sdl2: PEEKEVENT +GETEVENT sdl2.html#GETEVENT sdl2: GETEVENT +QUERY sdl2.html#QUERY sdl2: QUERY +IGNORE sdl2.html#IGNORE sdl2: IGNORE +DISABLE sdl2.html#DISABLE sdl2: DISABLE +ENABLE sdl2.html#ENABLE sdl2: ENABLE +HAPTIC_TYPE_CONSTANT sdl2.html#HAPTIC_TYPE_CONSTANT sdl2: HAPTIC_TYPE_CONSTANT +HAPTIC_TYPE_SINE sdl2.html#HAPTIC_TYPE_SINE sdl2: HAPTIC_TYPE_SINE +HAPTIC_TYPE_LEFTRIGHT sdl2.html#HAPTIC_TYPE_LEFTRIGHT sdl2: HAPTIC_TYPE_LEFTRIGHT +HAPTIC_TYPE_TRIANGLE sdl2.html#HAPTIC_TYPE_TRIANGLE sdl2: HAPTIC_TYPE_TRIANGLE +HAPTIC_TYPE_SAWTOOTHUP sdl2.html#HAPTIC_TYPE_SAWTOOTHUP sdl2: HAPTIC_TYPE_SAWTOOTHUP +HAPTIC_TYPE_SAWTOOTHDOWN sdl2.html#HAPTIC_TYPE_SAWTOOTHDOWN sdl2: HAPTIC_TYPE_SAWTOOTHDOWN +HAPTIC_TYPE_RAMP sdl2.html#HAPTIC_TYPE_RAMP sdl2: HAPTIC_TYPE_RAMP +HAPTIC_TYPE_SPRING sdl2.html#HAPTIC_TYPE_SPRING sdl2: HAPTIC_TYPE_SPRING +HAPTIC_TYPE_DAMPER sdl2.html#HAPTIC_TYPE_DAMPER sdl2: HAPTIC_TYPE_DAMPER +HAPTIC_TYPE_INERTIA sdl2.html#HAPTIC_TYPE_INERTIA sdl2: HAPTIC_TYPE_INERTIA +HAPTIC_TYPE_FRICTION sdl2.html#HAPTIC_TYPE_FRICTION sdl2: HAPTIC_TYPE_FRICTION +HAPTIC_TYPE_CUSTOM sdl2.html#HAPTIC_TYPE_CUSTOM sdl2: HAPTIC_TYPE_CUSTOM +HAPTIC_TYPE_GAIN sdl2.html#HAPTIC_TYPE_GAIN sdl2: HAPTIC_TYPE_GAIN +HAPTIC_TYPE_AUTOCENTER sdl2.html#HAPTIC_TYPE_AUTOCENTER sdl2: HAPTIC_TYPE_AUTOCENTER +HAPTIC_TYPE_STATUS sdl2.html#HAPTIC_TYPE_STATUS sdl2: HAPTIC_TYPE_STATUS +HAPTIC_TYPE_PAUSE sdl2.html#HAPTIC_TYPE_PAUSE sdl2: HAPTIC_TYPE_PAUSE +HAPTIC_TYPE_POLAR sdl2.html#HAPTIC_TYPE_POLAR sdl2: HAPTIC_TYPE_POLAR +HAPTIC_TYPE_CARTESIAN sdl2.html#HAPTIC_TYPE_CARTESIAN sdl2: HAPTIC_TYPE_CARTESIAN +HAPTIC_TYPE_SPHERICAL sdl2.html#HAPTIC_TYPE_SPHERICAL sdl2: HAPTIC_TYPE_SPHERICAL +HAPTIC_TYPE_INFINITY sdl2.html#HAPTIC_TYPE_INFINITY sdl2: HAPTIC_TYPE_INFINITY +HINT_FRAMEBUFFER_ACCELERATION sdl2.html#HINT_FRAMEBUFFER_ACCELERATION sdl2: HINT_FRAMEBUFFER_ACCELERATION +HINT_RENDER_DRIVER sdl2.html#HINT_RENDER_DRIVER sdl2: HINT_RENDER_DRIVER +HINT_RENDER_OPENGL_SHADERS sdl2.html#HINT_RENDER_OPENGL_SHADERS sdl2: HINT_RENDER_OPENGL_SHADERS +HINT_RENDER_DIRECT3D_THREADSAFE sdl2.html#HINT_RENDER_DIRECT3D_THREADSAFE sdl2: HINT_RENDER_DIRECT3D_THREADSAFE +HINT_RENDER_DIRECT3D11_DEBUG sdl2.html#HINT_RENDER_DIRECT3D11_DEBUG sdl2: HINT_RENDER_DIRECT3D11_DEBUG +HINT_RENDER_LOGICAL_SIZE_MODE sdl2.html#HINT_RENDER_LOGICAL_SIZE_MODE sdl2: HINT_RENDER_LOGICAL_SIZE_MODE +HINT_RENDER_SCALE_QUALITY sdl2.html#HINT_RENDER_SCALE_QUALITY sdl2: HINT_RENDER_SCALE_QUALITY +HINT_RENDER_VSYNC sdl2.html#HINT_RENDER_VSYNC sdl2: HINT_RENDER_VSYNC +HINT_VIDEO_ALLOW_SCREENSAVER sdl2.html#HINT_VIDEO_ALLOW_SCREENSAVER sdl2: HINT_VIDEO_ALLOW_SCREENSAVER +HINT_VIDEO_EXTERNAL_CONTEXT sdl2.html#HINT_VIDEO_EXTERNAL_CONTEXT sdl2: HINT_VIDEO_EXTERNAL_CONTEXT +HINT_VIDEO_X11_XVIDMODE sdl2.html#HINT_VIDEO_X11_XVIDMODE sdl2: HINT_VIDEO_X11_XVIDMODE +HINT_VIDEO_X11_XINERAMA sdl2.html#HINT_VIDEO_X11_XINERAMA sdl2: HINT_VIDEO_X11_XINERAMA +HINT_VIDEO_X11_XRANDR sdl2.html#HINT_VIDEO_X11_XRANDR sdl2: HINT_VIDEO_X11_XRANDR +HINT_VIDEO_X11_WINDOW_VISUALID sdl2.html#HINT_VIDEO_X11_WINDOW_VISUALID sdl2: HINT_VIDEO_X11_WINDOW_VISUALID +HINT_VIDEO_X11_NET_WM_PING sdl2.html#HINT_VIDEO_X11_NET_WM_PING sdl2: HINT_VIDEO_X11_NET_WM_PING +HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR sdl2.html#HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR sdl2: HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR +HINT_VIDEO_X11_FORCE_EGL sdl2.html#HINT_VIDEO_X11_FORCE_EGL sdl2: HINT_VIDEO_X11_FORCE_EGL +HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN sdl2.html#HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN sdl2: HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN +HINT_WINDOWS_INTRESOURCE_ICON sdl2.html#HINT_WINDOWS_INTRESOURCE_ICON sdl2: HINT_WINDOWS_INTRESOURCE_ICON +HINT_WINDOWS_INTRESOURCE_ICON_SMALL sdl2.html#HINT_WINDOWS_INTRESOURCE_ICON_SMALL sdl2: HINT_WINDOWS_INTRESOURCE_ICON_SMALL +HINT_WINDOWS_ENABLE_MESSAGELOOP sdl2.html#HINT_WINDOWS_ENABLE_MESSAGELOOP sdl2: HINT_WINDOWS_ENABLE_MESSAGELOOP +HINT_GRAB_KEYBOARD sdl2.html#HINT_GRAB_KEYBOARD sdl2: HINT_GRAB_KEYBOARD +HINT_MOUSE_DOUBLE_CLICK_TIME sdl2.html#HINT_MOUSE_DOUBLE_CLICK_TIME sdl2: HINT_MOUSE_DOUBLE_CLICK_TIME +HINT_MOUSE_DOUBLE_CLICK_RADIUS sdl2.html#HINT_MOUSE_DOUBLE_CLICK_RADIUS sdl2: HINT_MOUSE_DOUBLE_CLICK_RADIUS +HINT_MOUSE_NORMAL_SPEED_SCALE sdl2.html#HINT_MOUSE_NORMAL_SPEED_SCALE sdl2: HINT_MOUSE_NORMAL_SPEED_SCALE +HINT_MOUSE_RELATIVE_SPEED_SCALE sdl2.html#HINT_MOUSE_RELATIVE_SPEED_SCALE sdl2: HINT_MOUSE_RELATIVE_SPEED_SCALE +HINT_MOUSE_RELATIVE_MODE_WARP sdl2.html#HINT_MOUSE_RELATIVE_MODE_WARP sdl2: HINT_MOUSE_RELATIVE_MODE_WARP +HINT_MOUSE_FOCUS_CLICKTHROUGH sdl2.html#HINT_MOUSE_FOCUS_CLICKTHROUGH sdl2: HINT_MOUSE_FOCUS_CLICKTHROUGH +HINT_TOUCH_MOUSE_EVENTS sdl2.html#HINT_TOUCH_MOUSE_EVENTS sdl2: HINT_TOUCH_MOUSE_EVENTS +HINT_MOUSE_TOUCH_EVENTS sdl2.html#HINT_MOUSE_TOUCH_EVENTS sdl2: HINT_MOUSE_TOUCH_EVENTS +HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS sdl2.html#HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS sdl2: HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS +HINT_IDLE_TIMER_DISABLED sdl2.html#HINT_IDLE_TIMER_DISABLED sdl2: HINT_IDLE_TIMER_DISABLED +HINT_ORIENTATIONS sdl2.html#HINT_ORIENTATIONS sdl2: HINT_ORIENTATIONS +HINT_APPLE_TV_CONTROLLER_UI_EVENTS sdl2.html#HINT_APPLE_TV_CONTROLLER_UI_EVENTS sdl2: HINT_APPLE_TV_CONTROLLER_UI_EVENTS +HINT_APPLE_TV_REMOTE_ALLOW_ROTATION sdl2.html#HINT_APPLE_TV_REMOTE_ALLOW_ROTATION sdl2: HINT_APPLE_TV_REMOTE_ALLOW_ROTATION +HINT_IOS_HIDE_HOME_INDICATOR sdl2.html#HINT_IOS_HIDE_HOME_INDICATOR sdl2: HINT_IOS_HIDE_HOME_INDICATOR +HINT_ACCELEROMETER_AS_JOYSTICK sdl2.html#HINT_ACCELEROMETER_AS_JOYSTICK sdl2: HINT_ACCELEROMETER_AS_JOYSTICK +HINT_TV_REMOTE_AS_JOYSTICK sdl2.html#HINT_TV_REMOTE_AS_JOYSTICK sdl2: HINT_TV_REMOTE_AS_JOYSTICK +HINT_XINPUT_ENABLED sdl2.html#HINT_XINPUT_ENABLED sdl2: HINT_XINPUT_ENABLED +HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING sdl2.html#HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING sdl2: HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING +HINT_GAMECONTROLLERTYPE sdl2.html#HINT_GAMECONTROLLERTYPE sdl2: HINT_GAMECONTROLLERTYPE +HINT_GAMECONTROLLERCONFIG sdl2.html#HINT_GAMECONTROLLERCONFIG sdl2: HINT_GAMECONTROLLERCONFIG +HINT_GAMECONTROLLERCONFIG_FILE sdl2.html#HINT_GAMECONTROLLERCONFIG_FILE sdl2: HINT_GAMECONTROLLERCONFIG_FILE +HINT_GAMECONTROLLER_IGNORE_DEVICES sdl2.html#HINT_GAMECONTROLLER_IGNORE_DEVICES sdl2: HINT_GAMECONTROLLER_IGNORE_DEVICES +HINT_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT sdl2.html#HINT_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT sdl2: HINT_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT +HINT_GAMECONTROLLER_USE_BUTTON_LABELS sdl2.html#HINT_GAMECONTROLLER_USE_BUTTON_LABELS sdl2: HINT_GAMECONTROLLER_USE_BUTTON_LABELS +HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS sdl2.html#HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS sdl2: HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS +HINT_JOYSTICK_HIDAPI sdl2.html#HINT_JOYSTICK_HIDAPI sdl2: HINT_JOYSTICK_HIDAPI +HINT_JOYSTICK_HIDAPI_PS4 sdl2.html#HINT_JOYSTICK_HIDAPI_PS4 sdl2: HINT_JOYSTICK_HIDAPI_PS4 +HINT_JOYSTICK_HIDAPI_PS4_RUMBLE sdl2.html#HINT_JOYSTICK_HIDAPI_PS4_RUMBLE sdl2: HINT_JOYSTICK_HIDAPI_PS4_RUMBLE +HINT_JOYSTICK_HIDAPI_STEAM sdl2.html#HINT_JOYSTICK_HIDAPI_STEAM sdl2: HINT_JOYSTICK_HIDAPI_STEAM +HINT_JOYSTICK_HIDAPI_SWITCH sdl2.html#HINT_JOYSTICK_HIDAPI_SWITCH sdl2: HINT_JOYSTICK_HIDAPI_SWITCH +HINT_JOYSTICK_HIDAPI_XBOX sdl2.html#HINT_JOYSTICK_HIDAPI_XBOX sdl2: HINT_JOYSTICK_HIDAPI_XBOX +HINT_JOYSTICK_HIDAPI_GAMECUBE sdl2.html#HINT_JOYSTICK_HIDAPI_GAMECUBE sdl2: HINT_JOYSTICK_HIDAPI_GAMECUBE +HINT_ENABLE_STEAM_CONTROLLERS sdl2.html#HINT_ENABLE_STEAM_CONTROLLERS sdl2: HINT_ENABLE_STEAM_CONTROLLERS +HINT_ALLOW_TOPMOST sdl2.html#HINT_ALLOW_TOPMOST sdl2: HINT_ALLOW_TOPMOST +HINT_TIMER_RESOLUTION sdl2.html#HINT_TIMER_RESOLUTION sdl2: HINT_TIMER_RESOLUTION +HINT_QTWAYLAND_CONTENT_ORIENTATION sdl2.html#HINT_QTWAYLAND_CONTENT_ORIENTATION sdl2: HINT_QTWAYLAND_CONTENT_ORIENTATION +HINT_QTWAYLAND_WINDOW_FLAGS sdl2.html#HINT_QTWAYLAND_WINDOW_FLAGS sdl2: HINT_QTWAYLAND_WINDOW_FLAGS +HINT_THREAD_STACK_SIZE sdl2.html#HINT_THREAD_STACK_SIZE sdl2: HINT_THREAD_STACK_SIZE +HINT_VIDEO_HIGHDPI_DISABLED sdl2.html#HINT_VIDEO_HIGHDPI_DISABLED sdl2: HINT_VIDEO_HIGHDPI_DISABLED +HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK sdl2.html#HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK sdl2: HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK +HINT_VIDEO_WIN_D3DCOMPILER sdl2.html#HINT_VIDEO_WIN_D3DCOMPILER sdl2: HINT_VIDEO_WIN_D3DCOMPILER +HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT sdl2.html#HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT sdl2: HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT +HINT_WINRT_PRIVACY_POLICY_URL sdl2.html#HINT_WINRT_PRIVACY_POLICY_URL sdl2: HINT_WINRT_PRIVACY_POLICY_URL +HINT_WINRT_PRIVACY_POLICY_LABEL sdl2.html#HINT_WINRT_PRIVACY_POLICY_LABEL sdl2: HINT_WINRT_PRIVACY_POLICY_LABEL +HINT_WINRT_HANDLE_BACK_BUTTON sdl2.html#HINT_WINRT_HANDLE_BACK_BUTTON sdl2: HINT_WINRT_HANDLE_BACK_BUTTON +HINT_VIDEO_MAC_FULLSCREEN_SPACES sdl2.html#HINT_VIDEO_MAC_FULLSCREEN_SPACES sdl2: HINT_VIDEO_MAC_FULLSCREEN_SPACES +HINT_MAC_BACKGROUND_APP sdl2.html#HINT_MAC_BACKGROUND_APP sdl2: HINT_MAC_BACKGROUND_APP +HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION sdl2.html#HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION sdl2: HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION +HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION sdl2.html#HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION sdl2: HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION +HINT_IME_INTERNAL_EDITING sdl2.html#HINT_IME_INTERNAL_EDITING sdl2: HINT_IME_INTERNAL_EDITING +HINT_ANDROID_TRAP_BACK_BUTTON sdl2.html#HINT_ANDROID_TRAP_BACK_BUTTON sdl2: HINT_ANDROID_TRAP_BACK_BUTTON +HINT_ANDROID_BLOCK_ON_PAUSE sdl2.html#HINT_ANDROID_BLOCK_ON_PAUSE sdl2: HINT_ANDROID_BLOCK_ON_PAUSE +HINT_RETURN_KEY_HIDES_IME sdl2.html#HINT_RETURN_KEY_HIDES_IME sdl2: HINT_RETURN_KEY_HIDES_IME +HINT_EMSCRIPTEN_KEYBOARD_ELEMENT sdl2.html#HINT_EMSCRIPTEN_KEYBOARD_ELEMENT sdl2: HINT_EMSCRIPTEN_KEYBOARD_ELEMENT +HINT_NO_SIGNAL_HANDLERS sdl2.html#HINT_NO_SIGNAL_HANDLERS sdl2: HINT_NO_SIGNAL_HANDLERS +HINT_WINDOWS_NO_CLOSE_ON_ALT_F4 sdl2.html#HINT_WINDOWS_NO_CLOSE_ON_ALT_F4 sdl2: HINT_WINDOWS_NO_CLOSE_ON_ALT_F4 +HINT_BMP_SAVE_LEGACY_FORMAT sdl2.html#HINT_BMP_SAVE_LEGACY_FORMAT sdl2: HINT_BMP_SAVE_LEGACY_FORMAT +HINT_WINDOWS_DISABLE_THREAD_NAMING sdl2.html#HINT_WINDOWS_DISABLE_THREAD_NAMING sdl2: HINT_WINDOWS_DISABLE_THREAD_NAMING +HINT_RPI_VIDEO_LAYER sdl2.html#HINT_RPI_VIDEO_LAYER sdl2: HINT_RPI_VIDEO_LAYER +HINT_VIDEO_DOUBLE_BUFFER sdl2.html#HINT_VIDEO_DOUBLE_BUFFER sdl2: HINT_VIDEO_DOUBLE_BUFFER +HINT_OPENGL_ES_DRIVER sdl2.html#HINT_OPENGL_ES_DRIVER sdl2: HINT_OPENGL_ES_DRIVER +HINT_AUDIO_RESAMPLING_MODE sdl2.html#HINT_AUDIO_RESAMPLING_MODE sdl2: HINT_AUDIO_RESAMPLING_MODE +HINT_AUDIO_CATEGORY sdl2.html#HINT_AUDIO_CATEGORY sdl2: HINT_AUDIO_CATEGORY +HINT_RENDER_BATCHING sdl2.html#HINT_RENDER_BATCHING sdl2: HINT_RENDER_BATCHING +HINT_EVENT_LOGGING sdl2.html#HINT_EVENT_LOGGING sdl2: HINT_EVENT_LOGGING +HINT_WAVE_RIFF_CHUNK_SIZE sdl2.html#HINT_WAVE_RIFF_CHUNK_SIZE sdl2: HINT_WAVE_RIFF_CHUNK_SIZE +HINT_WAVE_TRUNCATION sdl2.html#HINT_WAVE_TRUNCATION sdl2: HINT_WAVE_TRUNCATION +HINT_WAVE_FACT_CHUNK sdl2.html#HINT_WAVE_FACT_CHUNK sdl2: HINT_WAVE_FACT_CHUNK +HINT_DISPLAY_USABLE_BOUNDS sdl2.html#HINT_DISPLAY_USABLE_BOUNDS sdl2: HINT_DISPLAY_USABLE_BOUNDS +HINT_DEFAULT sdl2.html#HINT_DEFAULT sdl2: HINT_DEFAULT +HINT_NORMAL sdl2.html#HINT_NORMAL sdl2: HINT_NORMAL +HINT_OVERRIDE sdl2.html#HINT_OVERRIDE sdl2: HINT_OVERRIDE +MAX_LOG_MESSAGE sdl2.html#MAX_LOG_MESSAGE sdl2: MAX_LOG_MESSAGE +LOG_CATEGORY_APPLICATION sdl2.html#LOG_CATEGORY_APPLICATION sdl2: LOG_CATEGORY_APPLICATION +LOG_CATEGORY_ERROR sdl2.html#LOG_CATEGORY_ERROR sdl2: LOG_CATEGORY_ERROR +LOG_CATEGORY_ASSERT sdl2.html#LOG_CATEGORY_ASSERT sdl2: LOG_CATEGORY_ASSERT +LOG_CATEGORY_SYSTEM sdl2.html#LOG_CATEGORY_SYSTEM sdl2: LOG_CATEGORY_SYSTEM +LOG_CATEGORY_AUDIO sdl2.html#LOG_CATEGORY_AUDIO sdl2: LOG_CATEGORY_AUDIO +LOG_CATEGORY_VIDEO sdl2.html#LOG_CATEGORY_VIDEO sdl2: LOG_CATEGORY_VIDEO +LOG_CATEGORY_RENDER sdl2.html#LOG_CATEGORY_RENDER sdl2: LOG_CATEGORY_RENDER +LOG_CATEGORY_INPUT sdl2.html#LOG_CATEGORY_INPUT sdl2: LOG_CATEGORY_INPUT +LOG_CATEGORY_TEST sdl2.html#LOG_CATEGORY_TEST sdl2: LOG_CATEGORY_TEST +LOG_CATEGORY_RESERVED1 sdl2.html#LOG_CATEGORY_RESERVED1 sdl2: LOG_CATEGORY_RESERVED1 +LOG_CATEGORY_RESERVED2 sdl2.html#LOG_CATEGORY_RESERVED2 sdl2: LOG_CATEGORY_RESERVED2 +LOG_CATEGORY_RESERVED3 sdl2.html#LOG_CATEGORY_RESERVED3 sdl2: LOG_CATEGORY_RESERVED3 +LOG_CATEGORY_RESERVED4 sdl2.html#LOG_CATEGORY_RESERVED4 sdl2: LOG_CATEGORY_RESERVED4 +LOG_CATEGORY_RESERVED5 sdl2.html#LOG_CATEGORY_RESERVED5 sdl2: LOG_CATEGORY_RESERVED5 +LOG_CATEGORY_RESERVED6 sdl2.html#LOG_CATEGORY_RESERVED6 sdl2: LOG_CATEGORY_RESERVED6 +LOG_CATEGORY_RESERVED7 sdl2.html#LOG_CATEGORY_RESERVED7 sdl2: LOG_CATEGORY_RESERVED7 +LOG_CATEGORY_RESERVED8 sdl2.html#LOG_CATEGORY_RESERVED8 sdl2: LOG_CATEGORY_RESERVED8 +LOG_CATEGORY_RESERVED9 sdl2.html#LOG_CATEGORY_RESERVED9 sdl2: LOG_CATEGORY_RESERVED9 +LOG_CATEGORY_RESERVED10 sdl2.html#LOG_CATEGORY_RESERVED10 sdl2: LOG_CATEGORY_RESERVED10 +LOG_CATEGORY_CUSTOM sdl2.html#LOG_CATEGORY_CUSTOM sdl2: LOG_CATEGORY_CUSTOM +LOG_PRIORITY_VERBOSE sdl2.html#LOG_PRIORITY_VERBOSE sdl2: LOG_PRIORITY_VERBOSE +LOG_PRIORITY_DEBUG sdl2.html#LOG_PRIORITY_DEBUG sdl2: LOG_PRIORITY_DEBUG +LOG_PRIORITY_INFO sdl2.html#LOG_PRIORITY_INFO sdl2: LOG_PRIORITY_INFO +LOG_PRIORITY_WARN sdl2.html#LOG_PRIORITY_WARN sdl2: LOG_PRIORITY_WARN +LOG_PRIORITY_ERROR sdl2.html#LOG_PRIORITY_ERROR sdl2: LOG_PRIORITY_ERROR +LOG_PRIORITY_CRITICAL sdl2.html#LOG_PRIORITY_CRITICAL sdl2: LOG_PRIORITY_CRITICAL +NUM_LOG_PRIORITIES sdl2.html#NUM_LOG_PRIORITIES sdl2: NUM_LOG_PRIORITIES +MESSAGEBOX_ERROR sdl2.html#MESSAGEBOX_ERROR sdl2: MESSAGEBOX_ERROR +MESSAGEBOX_WARNING sdl2.html#MESSAGEBOX_WARNING sdl2: MESSAGEBOX_WARNING +MESSAGEBOX_INFORMATION sdl2.html#MESSAGEBOX_INFORMATION sdl2: MESSAGEBOX_INFORMATION +MESSAGEBOX_BUTTONS_LEFT_TO_RIGHT sdl2.html#MESSAGEBOX_BUTTONS_LEFT_TO_RIGHT sdl2: MESSAGEBOX_BUTTONS_LEFT_TO_RIGHT +MESSAGEBOX_BUTTONS_RIGHT_TO_LEFT sdl2.html#MESSAGEBOX_BUTTONS_RIGHT_TO_LEFT sdl2: MESSAGEBOX_BUTTONS_RIGHT_TO_LEFT +MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT sdl2.html#MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT sdl2: MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT +MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT sdl2.html#MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT sdl2: MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT +MESSAGEBOX_COLOR_BACKGROUND sdl2.html#MESSAGEBOX_COLOR_BACKGROUND sdl2: MESSAGEBOX_COLOR_BACKGROUND +MESSAGEBOX_COLOR_TEXT sdl2.html#MESSAGEBOX_COLOR_TEXT sdl2: MESSAGEBOX_COLOR_TEXT +MESSAGEBOX_COLOR_BUTTON_BORDER sdl2.html#MESSAGEBOX_COLOR_BUTTON_BORDER sdl2: MESSAGEBOX_COLOR_BUTTON_BORDER +MESSAGEBOX_COLOR_BUTTON_BACKGROUND sdl2.html#MESSAGEBOX_COLOR_BUTTON_BACKGROUND sdl2: MESSAGEBOX_COLOR_BUTTON_BACKGROUND +MESSAGEBOX_COLOR_BUTTON_SELECTED sdl2.html#MESSAGEBOX_COLOR_BUTTON_SELECTED sdl2: MESSAGEBOX_COLOR_BUTTON_SELECTED +MESSAGEBOX_COLOR_MAX sdl2.html#MESSAGEBOX_COLOR_MAX sdl2: MESSAGEBOX_COLOR_MAX +POWERSTATE_UNKNOWN sdl2.html#POWERSTATE_UNKNOWN sdl2: POWERSTATE_UNKNOWN +POWERSTATE_ON_BATTERY sdl2.html#POWERSTATE_ON_BATTERY sdl2: POWERSTATE_ON_BATTERY +POWERSTATE_NO_BATTERY sdl2.html#POWERSTATE_NO_BATTERY sdl2: POWERSTATE_NO_BATTERY +POWERSTATE_CHARGING sdl2.html#POWERSTATE_CHARGING sdl2: POWERSTATE_CHARGING +POWERSTATE_CHARGED sdl2.html#POWERSTATE_CHARGED sdl2: POWERSTATE_CHARGED +RENDERER_SOFTWARE sdl2.html#RENDERER_SOFTWARE sdl2: RENDERER_SOFTWARE +RENDERER_ACCELERATED sdl2.html#RENDERER_ACCELERATED sdl2: RENDERER_ACCELERATED +RENDERER_PRESENTVSYNC sdl2.html#RENDERER_PRESENTVSYNC sdl2: RENDERER_PRESENTVSYNC +RENDERER_TARGETTEXTURE sdl2.html#RENDERER_TARGETTEXTURE sdl2: RENDERER_TARGETTEXTURE +ScaleModeNearest sdl2.html#ScaleModeNearest sdl2: ScaleModeNearest +ScaleModeLinear sdl2.html#ScaleModeLinear sdl2: ScaleModeLinear +ScaleModeBest sdl2.html#ScaleModeBest sdl2: ScaleModeBest +TEXTUREACCESS_STATIC sdl2.html#TEXTUREACCESS_STATIC sdl2: TEXTUREACCESS_STATIC +TEXTUREACCESS_STREAMING sdl2.html#TEXTUREACCESS_STREAMING sdl2: TEXTUREACCESS_STREAMING +TEXTUREACCESS_TARGET sdl2.html#TEXTUREACCESS_TARGET sdl2: TEXTUREACCESS_TARGET +TEXTUREMODULATE_NONE sdl2.html#TEXTUREMODULATE_NONE sdl2: TEXTUREMODULATE_NONE +TEXTUREMODULATE_COLOR sdl2.html#TEXTUREMODULATE_COLOR sdl2: TEXTUREMODULATE_COLOR +TEXTUREMODULATE_ALPHA sdl2.html#TEXTUREMODULATE_ALPHA sdl2: TEXTUREMODULATE_ALPHA +FLIP_NONE sdl2.html#FLIP_NONE sdl2: FLIP_NONE +FLIP_HORIZONTAL sdl2.html#FLIP_HORIZONTAL sdl2: FLIP_HORIZONTAL +FLIP_VERTICAL sdl2.html#FLIP_VERTICAL sdl2: FLIP_VERTICAL +SENSOR_INVALID sdl2.html#SENSOR_INVALID sdl2: SENSOR_INVALID +SENSOR_UNKNOWN sdl2.html#SENSOR_UNKNOWN sdl2: SENSOR_UNKNOWN +SENSOR_ACCEL sdl2.html#SENSOR_ACCEL sdl2: SENSOR_ACCEL +SENSOR_GYRO sdl2.html#SENSOR_GYRO sdl2: SENSOR_GYRO +STANDARD_GRAVITY sdl2.html#STANDARD_GRAVITY sdl2: STANDARD_GRAVITY +NONSHAPEABLE_WINDOW sdl2.html#NONSHAPEABLE_WINDOW sdl2: NONSHAPEABLE_WINDOW +INVALID_SHAPE_ARGUMENT sdl2.html#INVALID_SHAPE_ARGUMENT sdl2: INVALID_SHAPE_ARGUMENT +WINDOW_LACKS_SHAPE sdl2.html#WINDOW_LACKS_SHAPE sdl2: WINDOW_LACKS_SHAPE +ShapeModeDefault sdl2.html#ShapeModeDefault sdl2: ShapeModeDefault +ShapeModeBinarizeAlpha sdl2.html#ShapeModeBinarizeAlpha sdl2: ShapeModeBinarizeAlpha +ShapeModeReverseBinarizeAlpha sdl2.html#ShapeModeReverseBinarizeAlpha sdl2: ShapeModeReverseBinarizeAlpha +ShapeModeColorKey sdl2.html#ShapeModeColorKey sdl2: ShapeModeColorKey +MAJOR_VERSION sdl2.html#MAJOR_VERSION sdl2: MAJOR_VERSION +MINOR_VERSION sdl2.html#MINOR_VERSION sdl2: MINOR_VERSION +PATCHLEVEL sdl2.html#PATCHLEVEL sdl2: PATCHLEVEL +INIT_TIMER sdl2.html#INIT_TIMER sdl2: INIT_TIMER +INIT_AUDIO sdl2.html#INIT_AUDIO sdl2: INIT_AUDIO +INIT_VIDEO sdl2.html#INIT_VIDEO sdl2: INIT_VIDEO +INIT_JOYSTICK sdl2.html#INIT_JOYSTICK sdl2: INIT_JOYSTICK +INIT_HAPTIC sdl2.html#INIT_HAPTIC sdl2: INIT_HAPTIC +INIT_GAMECONTROLLER sdl2.html#INIT_GAMECONTROLLER sdl2: INIT_GAMECONTROLLER +INIT_EVENTS sdl2.html#INIT_EVENTS sdl2: INIT_EVENTS +INIT_SENSOR sdl2.html#INIT_SENSOR sdl2: INIT_SENSOR +INIT_NOPARACHUTE sdl2.html#INIT_NOPARACHUTE sdl2: INIT_NOPARACHUTE +INIT_EVERYTHING sdl2.html#INIT_EVERYTHING sdl2: INIT_EVERYTHING +RWops sdl2.html#RWops sdl2: RWops +BlitMap sdl2.html#BlitMap sdl2: BlitMap +CONTROLLER_BINDTYPE_NONE sdl2.html#CONTROLLER_BINDTYPE_NONE GameControllerBindType.CONTROLLER_BINDTYPE_NONE +CONTROLLER_BINDTYPE_BUTTON sdl2.html#CONTROLLER_BINDTYPE_BUTTON GameControllerBindType.CONTROLLER_BINDTYPE_BUTTON +CONTROLLER_BINDTYPE_AXIS sdl2.html#CONTROLLER_BINDTYPE_AXIS GameControllerBindType.CONTROLLER_BINDTYPE_AXIS +CONTROLLER_BINDTYPE_HAT sdl2.html#CONTROLLER_BINDTYPE_HAT GameControllerBindType.CONTROLLER_BINDTYPE_HAT +GameControllerBindType sdl2.html#GameControllerBindType sdl2: GameControllerBindType +false sdl2.html#false Bool.false +true sdl2.html#true Bool.true +Bool sdl2.html#Bool sdl2: Bool +GameControllerButtonBind sdl2.html#GameControllerButtonBind sdl2: GameControllerButtonBind +ButtonBindHat sdl2.html#ButtonBindHat sdl2: ButtonBindHat +Sint8 sdl2.html#Sint8 sdl2: Sint8 +Uint8 sdl2.html#Uint8 sdl2: Uint8 +Sint16 sdl2.html#Sint16 sdl2: Sint16 +Uint16 sdl2.html#Uint16 sdl2: Uint16 +Sint32 sdl2.html#Sint32 sdl2: Sint32 +Uint32 sdl2.html#Uint32 sdl2: Uint32 +Sint64 sdl2.html#Sint64 sdl2: Sint64 +Uint64 sdl2.html#Uint64 sdl2: Uint64 +malloc_func sdl2.html#malloc_func sdl2: malloc_func +calloc_func sdl2.html#calloc_func sdl2: calloc_func +realloc_func sdl2.html#realloc_func sdl2: realloc_func +free_func sdl2.html#free_func sdl2: free_func +iconv_t sdl2.html#iconv_t sdl2: iconv_t +main_func sdl2.html#main_func sdl2: main_func +AssertData sdl2.html#AssertData sdl2: AssertData +AssertionHandler sdl2.html#AssertionHandler sdl2: AssertionHandler +SpinLock sdl2.html#SpinLock sdl2: SpinLock +atomic_t sdl2.html#atomic_t sdl2: atomic_t +mutex sdl2.html#mutex sdl2: mutex +semaphore sdl2.html#semaphore sdl2: semaphore +sem sdl2.html#sem sdl2: sem +cond sdl2.html#cond sdl2: cond +Thread sdl2.html#Thread sdl2: Thread +threadID sdl2.html#threadID sdl2: threadID +TLSID sdl2.html#TLSID sdl2: TLSID +ThreadFunction sdl2.html#ThreadFunction sdl2: ThreadFunction +AudioFormat sdl2.html#AudioFormat sdl2: AudioFormat +AudioCallback sdl2.html#AudioCallback sdl2: AudioCallback +AudioSpec sdl2.html#AudioSpec sdl2: AudioSpec +AudioCVT sdl2.html#AudioCVT sdl2: AudioCVT +AudioFilter sdl2.html#AudioFilter sdl2: AudioFilter +AudioDeviceID sdl2.html#AudioDeviceID sdl2: AudioDeviceID +AudioStream sdl2.html#AudioStream sdl2: AudioStream +Color sdl2.html#Color sdl2: Color +Palette sdl2.html#Palette sdl2: Palette +PixelFormat sdl2.html#PixelFormat sdl2: PixelFormat +Point sdl2.html#Point sdl2: Point +FPoint sdl2.html#FPoint sdl2: FPoint +Rect sdl2.html#Rect sdl2: Rect +FRect sdl2.html#FRect sdl2: FRect +Surface sdl2.html#Surface sdl2: Surface +blit sdl2.html#blit sdl2: blit +DisplayMode sdl2.html#DisplayMode sdl2: DisplayMode +Window sdl2.html#Window sdl2: Window +GLContext sdl2.html#GLContext sdl2: GLContext +HitTest sdl2.html#HitTest sdl2: HitTest +Keycode sdl2.html#Keycode sdl2: Keycode +Keysym sdl2.html#Keysym sdl2: Keysym +Cursor sdl2.html#Cursor sdl2: Cursor +Joystick sdl2.html#Joystick sdl2: Joystick +JoystickGUID sdl2.html#JoystickGUID sdl2: JoystickGUID +JoystickID sdl2.html#JoystickID sdl2: JoystickID +GameController sdl2.html#GameController sdl2: GameController +TouchID sdl2.html#TouchID sdl2: TouchID +FingerID sdl2.html#FingerID sdl2: FingerID +Finger sdl2.html#Finger sdl2: Finger +GestureID sdl2.html#GestureID sdl2: GestureID +CommonEvent sdl2.html#CommonEvent sdl2: CommonEvent +DisplayEvent sdl2.html#DisplayEvent sdl2: DisplayEvent +WindowEvent sdl2.html#WindowEvent sdl2: WindowEvent +KeyboardEvent sdl2.html#KeyboardEvent sdl2: KeyboardEvent +TextEditingEvent sdl2.html#TextEditingEvent sdl2: TextEditingEvent +TextInputEvent sdl2.html#TextInputEvent sdl2: TextInputEvent +MouseMotionEvent sdl2.html#MouseMotionEvent sdl2: MouseMotionEvent +MouseButtonEvent sdl2.html#MouseButtonEvent sdl2: MouseButtonEvent +MouseWheelEvent sdl2.html#MouseWheelEvent sdl2: MouseWheelEvent +JoyAxisEvent sdl2.html#JoyAxisEvent sdl2: JoyAxisEvent +JoyBallEvent sdl2.html#JoyBallEvent sdl2: JoyBallEvent +JoyHatEvent sdl2.html#JoyHatEvent sdl2: JoyHatEvent +JoyButtonEvent sdl2.html#JoyButtonEvent sdl2: JoyButtonEvent +JoyDeviceEvent sdl2.html#JoyDeviceEvent sdl2: JoyDeviceEvent +ControllerAxisEvent sdl2.html#ControllerAxisEvent sdl2: ControllerAxisEvent +ControllerButtonEvent sdl2.html#ControllerButtonEvent sdl2: ControllerButtonEvent +ControllerDeviceEvent sdl2.html#ControllerDeviceEvent sdl2: ControllerDeviceEvent +AudioDeviceEvent sdl2.html#AudioDeviceEvent sdl2: AudioDeviceEvent +TouchFingerEvent sdl2.html#TouchFingerEvent sdl2: TouchFingerEvent +MultiGestureEvent sdl2.html#MultiGestureEvent sdl2: MultiGestureEvent +DollarGestureEvent sdl2.html#DollarGestureEvent sdl2: DollarGestureEvent +DropEvent sdl2.html#DropEvent sdl2: DropEvent +SensorEvent sdl2.html#SensorEvent sdl2: SensorEvent +QuitEvent sdl2.html#QuitEvent sdl2: QuitEvent +OSEvent sdl2.html#OSEvent sdl2: OSEvent +UserEvent sdl2.html#UserEvent sdl2: UserEvent +SysWMmsg sdl2.html#SysWMmsg sdl2: SysWMmsg +SysWMEvent sdl2.html#SysWMEvent sdl2: SysWMEvent +Event sdl2.html#Event sdl2: Event +EventFilter sdl2.html#EventFilter sdl2: EventFilter +PHaptic sdl2.html#PHaptic sdl2: PHaptic +Haptic sdl2.html#Haptic sdl2: Haptic +HapticDirection sdl2.html#HapticDirection sdl2: HapticDirection +HapticConstant sdl2.html#HapticConstant sdl2: HapticConstant +HapticPeriodic sdl2.html#HapticPeriodic sdl2: HapticPeriodic +HapticCondition sdl2.html#HapticCondition sdl2: HapticCondition +HapticRamp sdl2.html#HapticRamp sdl2: HapticRamp +HapticLeftRight sdl2.html#HapticLeftRight sdl2: HapticLeftRight +HapticCustom sdl2.html#HapticCustom sdl2: HapticCustom +HapticEffect sdl2.html#HapticEffect sdl2: HapticEffect +HintCallback sdl2.html#HintCallback sdl2: HintCallback +LogOutputFunction sdl2.html#LogOutputFunction sdl2: LogOutputFunction +MessageBoxButtonData sdl2.html#MessageBoxButtonData sdl2: MessageBoxButtonData +MessageBoxColor sdl2.html#MessageBoxColor sdl2: MessageBoxColor +MessageBoxColorScheme sdl2.html#MessageBoxColorScheme sdl2: MessageBoxColorScheme +MessageBoxData sdl2.html#MessageBoxData sdl2: MessageBoxData +MetalView sdl2.html#MetalView sdl2: MetalView +RendererInfo sdl2.html#RendererInfo sdl2: RendererInfo +Renderer sdl2.html#Renderer sdl2: Renderer +Texture sdl2.html#Texture sdl2: Texture +Sensor sdl2.html#Sensor sdl2: Sensor +SensorID sdl2.html#SensorID sdl2: SensorID +WindowShapeParams sdl2.html#WindowShapeParams sdl2: WindowShapeParams +TimerCallback sdl2.html#TimerCallback sdl2: TimerCallback +TimerID sdl2.html#TimerID sdl2: TimerID +Version sdl2.html#Version sdl2: Version +getPlatform sdl2.html#getPlatform sdl2: getPlatform(): cstring +malloc sdl2.html#malloc,uint sdl2: malloc(size: uint): pointer +calloc sdl2.html#calloc,uint,uint sdl2: calloc(nmemb: uint; size: uint): pointer +realloc sdl2.html#realloc,pointer,uint sdl2: realloc(mem: pointer; size: uint): pointer +free sdl2.html#free,pointer sdl2: free(mem: pointer) +getMemoryFunctions sdl2.html#getMemoryFunctions,ptr.malloc_func,ptr.calloc_func,ptr.realloc_func,ptr.free_func sdl2: getMemoryFunctions(mallocFunc: ptr malloc_func; callocFunc: ptr calloc_func;\n reallocFunc: ptr realloc_func; freeFunc: ptr free_func) +setMemoryFunctions sdl2.html#setMemoryFunctions,malloc_func,calloc_func,realloc_func,free_func sdl2: setMemoryFunctions(mallocFunc: malloc_func; callocFunc: calloc_func;\n reallocFunc: realloc_func; freeFunc: free_func): cint +getNumAllocations sdl2.html#getNumAllocations sdl2: getNumAllocations(): cint +getenv sdl2.html#getenv,cstring sdl2: getenv(name: cstring): cstring +setenv sdl2.html#setenv,cstring,cstring,cint sdl2: setenv(name: cstring; value: cstring; overwrite: cint): cint +qsort sdl2.html#qsort,pointer,uint,uint,proc(pointer,pointer) sdl2: qsort(base: pointer; nmemb: uint; size: uint;\n compare: proc (a1: pointer; a2: pointer): cint {.cdecl.}) +abs sdl2.html#abs,cint sdl2: abs(x: cint): cint +isdigit sdl2.html#isdigit,cint sdl2: isdigit(x: cint): cint +isspace sdl2.html#isspace,cint sdl2: isspace(x: cint): cint +isupper sdl2.html#isupper,cint sdl2: isupper(x: cint): cint +islower sdl2.html#islower,cint sdl2: islower(x: cint): cint +toupper sdl2.html#toupper,cint sdl2: toupper(x: cint): cint +tolower sdl2.html#tolower,cint sdl2: tolower(x: cint): cint +memset sdl2.html#memset,pointer,cint,uint sdl2: memset(dst: pointer; c: cint; len: uint): pointer +memcpy sdl2.html#memcpy,pointer,pointer,uint sdl2: memcpy(dst: pointer; src: pointer; len: uint): pointer +memmove sdl2.html#memmove,pointer,pointer,uint sdl2: memmove(dst: pointer; src: pointer; len: uint): pointer +memcmp sdl2.html#memcmp,pointer,pointer,uint sdl2: memcmp(s1: pointer; s2: pointer; len: uint): cint +wcslen sdl2.html#wcslen,ptr.wchar_t sdl2: wcslen(wstr: ptr wchar_t): uint +wcslcpy sdl2.html#wcslcpy,ptr.wchar_t,ptr.wchar_t,uint sdl2: wcslcpy(dst: ptr wchar_t; src: ptr wchar_t; maxlen: uint): uint +wcslcat sdl2.html#wcslcat,ptr.wchar_t,ptr.wchar_t,uint sdl2: wcslcat(dst: ptr wchar_t; src: ptr wchar_t; maxlen: uint): uint +wcsdup sdl2.html#wcsdup,ptr.wchar_t sdl2: wcsdup(wstr: ptr wchar_t): ptr wchar_t +wcsstr sdl2.html#wcsstr,ptr.wchar_t,ptr.wchar_t sdl2: wcsstr(haystack: ptr wchar_t; needle: ptr wchar_t): ptr wchar_t +wcscmp sdl2.html#wcscmp,ptr.wchar_t,ptr.wchar_t sdl2: wcscmp(str1: ptr wchar_t; str2: ptr wchar_t): cint +wcsncmp sdl2.html#wcsncmp,ptr.wchar_t,ptr.wchar_t,uint sdl2: wcsncmp(str1: ptr wchar_t; str2: ptr wchar_t; maxlen: uint): cint +strlen sdl2.html#strlen,cstring sdl2: strlen(str: cstring): uint +strlcpy sdl2.html#strlcpy,cstring,cstring,uint sdl2: strlcpy(dst: cstring; src: cstring; maxlen: uint): uint +utf8strlcpy sdl2.html#utf8strlcpy,cstring,cstring,uint sdl2: utf8strlcpy(dst: cstring; src: cstring; dstBytes: uint): uint +strlcat sdl2.html#strlcat,cstring,cstring,uint sdl2: strlcat(dst: cstring; src: cstring; maxlen: uint): uint +strdup sdl2.html#strdup,cstring sdl2: strdup(str: cstring): cstring +strrev sdl2.html#strrev,cstring sdl2: strrev(str: cstring): cstring +strupr sdl2.html#strupr,cstring sdl2: strupr(str: cstring): cstring +strlwr sdl2.html#strlwr,cstring sdl2: strlwr(str: cstring): cstring +strchr sdl2.html#strchr,cstring,cint sdl2: strchr(str: cstring; c: cint): cstring +strrchr sdl2.html#strrchr,cstring,cint sdl2: strrchr(str: cstring; c: cint): cstring +strstr sdl2.html#strstr,cstring,cstring sdl2: strstr(haystack: cstring; needle: cstring): cstring +strtokr sdl2.html#strtokr,cstring,cstring,ptr.cstring sdl2: strtokr(s1: cstring; s2: cstring; saveptr: ptr cstring): cstring +utf8strlen sdl2.html#utf8strlen,cstring sdl2: utf8strlen(str: cstring): uint +itoa sdl2.html#itoa,cint,cstring,cint sdl2: itoa(value: cint; str: cstring; radix: cint): cstring +uitoa sdl2.html#uitoa,cuint,cstring,cint sdl2: uitoa(value: cuint; str: cstring; radix: cint): cstring +ltoa sdl2.html#ltoa,clong,cstring,cint sdl2: ltoa(value: clong; str: cstring; radix: cint): cstring +ultoa sdl2.html#ultoa,culong,cstring,cint sdl2: ultoa(value: culong; str: cstring; radix: cint): cstring +lltoa sdl2.html#lltoa,Sint64,cstring,cint sdl2: lltoa(value: Sint64; str: cstring; radix: cint): cstring +ulltoa sdl2.html#ulltoa,Uint64,cstring,cint sdl2: ulltoa(value: Uint64; str: cstring; radix: cint): cstring +atoi sdl2.html#atoi,cstring sdl2: atoi(str: cstring): cint +atof sdl2.html#atof,cstring sdl2: atof(str: cstring): cdouble +strtol sdl2.html#strtol,cstring,ptr.cstring,cint sdl2: strtol(str: cstring; endp: ptr cstring; base: cint): clong +strtoul sdl2.html#strtoul,cstring,ptr.cstring,cint sdl2: strtoul(str: cstring; endp: ptr cstring; base: cint): culong +strtoll sdl2.html#strtoll,cstring,ptr.cstring,cint sdl2: strtoll(str: cstring; endp: ptr cstring; base: cint): Sint64 +strtoull sdl2.html#strtoull,cstring,ptr.cstring,cint sdl2: strtoull(str: cstring; endp: ptr cstring; base: cint): Uint64 +strtod sdl2.html#strtod,cstring,ptr.cstring sdl2: strtod(str: cstring; endp: ptr cstring): cdouble +strcmp sdl2.html#strcmp,cstring,cstring sdl2: strcmp(str1: cstring; str2: cstring): cint +strncmp sdl2.html#strncmp,cstring,cstring,uint sdl2: strncmp(str1: cstring; str2: cstring; maxlen: uint): cint +strcasecmp sdl2.html#strcasecmp,cstring,cstring sdl2: strcasecmp(str1: cstring; str2: cstring): cint +strncasecmp sdl2.html#strncasecmp,cstring,cstring,uint sdl2: strncasecmp(str1: cstring; str2: cstring; len: uint): cint +sscanf sdl2.html#sscanf,cstring,cstring sdl2: sscanf(text: cstring; fmt: cstring): cint +vsscanf sdl2.html#vsscanf,cstring,cstring,va_list sdl2: vsscanf(text: cstring; fmt: cstring; ap: va_list): cint +snprintf sdl2.html#snprintf,cstring,uint,cstring sdl2: snprintf(text: cstring; maxlen: uint; fmt: cstring): cint +vsnprintf sdl2.html#vsnprintf,cstring,uint,cstring,va_list sdl2: vsnprintf(text: cstring; maxlen: uint; fmt: cstring; ap: va_list): cint +acos sdl2.html#acos,cdouble sdl2: acos(x: cdouble): cdouble +acosf sdl2.html#acosf,cfloat sdl2: acosf(x: cfloat): cfloat +asin sdl2.html#asin,cdouble sdl2: asin(x: cdouble): cdouble +asinf sdl2.html#asinf,cfloat sdl2: asinf(x: cfloat): cfloat +atan sdl2.html#atan,cdouble sdl2: atan(x: cdouble): cdouble +atanf sdl2.html#atanf,cfloat sdl2: atanf(x: cfloat): cfloat +atan2 sdl2.html#atan2,cdouble,cdouble sdl2: atan2(x: cdouble; y: cdouble): cdouble +atan2f sdl2.html#atan2f,cfloat,cfloat sdl2: atan2f(x: cfloat; y: cfloat): cfloat +ceil sdl2.html#ceil,cdouble sdl2: ceil(x: cdouble): cdouble +ceilf sdl2.html#ceilf,cfloat sdl2: ceilf(x: cfloat): cfloat +copysign sdl2.html#copysign,cdouble,cdouble sdl2: copysign(x: cdouble; y: cdouble): cdouble +copysignf sdl2.html#copysignf,cfloat,cfloat sdl2: copysignf(x: cfloat; y: cfloat): cfloat +cos sdl2.html#cos,cdouble sdl2: cos(x: cdouble): cdouble +cosf sdl2.html#cosf,cfloat sdl2: cosf(x: cfloat): cfloat +exp sdl2.html#exp,cdouble sdl2: exp(x: cdouble): cdouble +expf sdl2.html#expf,cfloat sdl2: expf(x: cfloat): cfloat +fabs sdl2.html#fabs,cdouble sdl2: fabs(x: cdouble): cdouble +fabsf sdl2.html#fabsf,cfloat sdl2: fabsf(x: cfloat): cfloat +floor sdl2.html#floor,cdouble sdl2: floor(x: cdouble): cdouble +floorf sdl2.html#floorf,cfloat sdl2: floorf(x: cfloat): cfloat +fmod sdl2.html#fmod,cdouble,cdouble sdl2: fmod(x: cdouble; y: cdouble): cdouble +fmodf sdl2.html#fmodf,cfloat,cfloat sdl2: fmodf(x: cfloat; y: cfloat): cfloat +log sdl2.html#log,cdouble sdl2: log(x: cdouble): cdouble +logf sdl2.html#logf,cfloat sdl2: logf(x: cfloat): cfloat +log10 sdl2.html#log10,cdouble sdl2: log10(x: cdouble): cdouble +log10f sdl2.html#log10f,cfloat sdl2: log10f(x: cfloat): cfloat +pow sdl2.html#pow,cdouble,cdouble sdl2: pow(x: cdouble; y: cdouble): cdouble +powf sdl2.html#powf,cfloat,cfloat sdl2: powf(x: cfloat; y: cfloat): cfloat +scalbn sdl2.html#scalbn,cdouble,cint sdl2: scalbn(x: cdouble; n: cint): cdouble +scalbnf sdl2.html#scalbnf,cfloat,cint sdl2: scalbnf(x: cfloat; n: cint): cfloat +sin sdl2.html#sin,cdouble sdl2: sin(x: cdouble): cdouble +sinf sdl2.html#sinf,cfloat sdl2: sinf(x: cfloat): cfloat +sqrt sdl2.html#sqrt,cdouble sdl2: sqrt(x: cdouble): cdouble +sqrtf sdl2.html#sqrtf,cfloat sdl2: sqrtf(x: cfloat): cfloat +tan sdl2.html#tan,cdouble sdl2: tan(x: cdouble): cdouble +tanf sdl2.html#tanf,cfloat sdl2: tanf(x: cfloat): cfloat +iconv_open sdl2.html#iconv_open,cstring,cstring sdl2: iconv_open(tocode: cstring; fromcode: cstring): iconv_t +iconv_close sdl2.html#iconv_close,iconv_t sdl2: iconv_close(cd: iconv_t): cint +iconv sdl2.html#iconv,iconv_t,ptr.cstring,ptr.uint,ptr.cstring,ptr.uint sdl2: iconv(cd: iconv_t; inbuf: ptr cstring; inbytesleft: ptr uint; outbuf: ptr cstring;\n outbytesleft: ptr uint): uint +iconv_string sdl2.html#iconv_string,cstring,cstring,cstring,uint sdl2: iconv_string(tocode: cstring; fromcode: cstring; inbuf: cstring; inbytesleft: uint): cstring +main sdl2.html#main,cint,UncheckedArray[cstring] sdl2: main(argc: cint; argv: UncheckedArray[cstring]): cint +setMainReady sdl2.html#setMainReady sdl2: setMainReady() +reportAssertion sdl2.html#reportAssertion,ptr.AssertData,cstring,cstring,cint sdl2: reportAssertion(a1: ptr AssertData; a2: cstring; a3: cstring; a4: cint): AssertState +setAssertionHandler sdl2.html#setAssertionHandler,AssertionHandler,pointer sdl2: setAssertionHandler(handler: AssertionHandler; userdata: pointer) +getDefaultAssertionHandler sdl2.html#getDefaultAssertionHandler sdl2: getDefaultAssertionHandler(): AssertionHandler +getAssertionHandler sdl2.html#getAssertionHandler,ptr.pointer sdl2: getAssertionHandler(puserdata: ptr pointer): AssertionHandler +getAssertionReport sdl2.html#getAssertionReport sdl2: getAssertionReport(): ptr AssertData +resetAssertionReport sdl2.html#resetAssertionReport sdl2: resetAssertionReport() +atomicTryLock sdl2.html#atomicTryLock,ptr.SpinLock sdl2: atomicTryLock(lock: ptr SpinLock): bool +atomicLock sdl2.html#atomicLock,ptr.SpinLock sdl2: atomicLock(lock: ptr SpinLock) +atomicUnlock sdl2.html#atomicUnlock,ptr.SpinLock sdl2: atomicUnlock(lock: ptr SpinLock) +memoryBarrierReleaseFunction sdl2.html#memoryBarrierReleaseFunction sdl2: memoryBarrierReleaseFunction() +memoryBarrierAcquireFunction sdl2.html#memoryBarrierAcquireFunction sdl2: memoryBarrierAcquireFunction() +atomicCAS sdl2.html#atomicCAS,ptr.atomic_t,cint,cint sdl2: atomicCAS(a: ptr atomic_t; oldval: cint; newval: cint): bool +atomicSet sdl2.html#atomicSet,ptr.atomic_t,cint sdl2: atomicSet(a: ptr atomic_t; v: cint): cint +atomicGet sdl2.html#atomicGet,ptr.atomic_t sdl2: atomicGet(a: ptr atomic_t): cint +atomicAdd sdl2.html#atomicAdd,ptr.atomic_t,cint sdl2: atomicAdd(a: ptr atomic_t; v: cint): cint +atomicCASPtr sdl2.html#atomicCASPtr,ptr.pointer,pointer,pointer sdl2: atomicCASPtr(a: ptr pointer; oldval: pointer; newval: pointer): bool +atomicSetPtr sdl2.html#atomicSetPtr,ptr.pointer,pointer sdl2: atomicSetPtr(a: ptr pointer; v: pointer): pointer +atomicGetPtr sdl2.html#atomicGetPtr,ptr.pointer sdl2: atomicGetPtr(a: ptr pointer): pointer +setError sdl2.html#setError,cstring sdl2: setError(fmt: cstring): cint +getError sdl2.html#getError sdl2: getError(): cstring +clearError sdl2.html#clearError sdl2: clearError() +error sdl2.html#error,errorcode sdl2: error(code: errorcode): cint +createMutex sdl2.html#createMutex sdl2: createMutex(): ptr mutex +lockMutex sdl2.html#lockMutex,ptr.mutex sdl2: lockMutex(mutex: ptr mutex): cint +tryLockMutex sdl2.html#tryLockMutex,ptr.mutex sdl2: tryLockMutex(mutex: ptr mutex): cint +unlockMutex sdl2.html#unlockMutex,ptr.mutex sdl2: unlockMutex(mutex: ptr mutex): cint +destroyMutex sdl2.html#destroyMutex,ptr.mutex sdl2: destroyMutex(mutex: ptr mutex) +createSemaphore sdl2.html#createSemaphore,Uint32 sdl2: createSemaphore(initialValue: Uint32): ptr sem +destroySemaphore sdl2.html#destroySemaphore,ptr.semaphore sdl2: destroySemaphore(sem: ptr sem) +semWait sdl2.html#semWait,ptr.semaphore sdl2: semWait(sem: ptr sem): cint +semTryWait sdl2.html#semTryWait,ptr.semaphore sdl2: semTryWait(sem: ptr sem): cint +semWaitTimeout sdl2.html#semWaitTimeout,ptr.semaphore,Uint32 sdl2: semWaitTimeout(sem: ptr sem; ms: Uint32): cint +semPost sdl2.html#semPost,ptr.semaphore sdl2: semPost(sem: ptr sem): cint +semValue sdl2.html#semValue,ptr.semaphore sdl2: semValue(sem: ptr sem): Uint32 +createCond sdl2.html#createCond sdl2: createCond(): ptr cond +destroyCond sdl2.html#destroyCond,ptr.cond sdl2: destroyCond(cond: ptr cond) +condSignal sdl2.html#condSignal,ptr.cond sdl2: condSignal(cond: ptr cond): cint +condBroadcast sdl2.html#condBroadcast,ptr.cond sdl2: condBroadcast(cond: ptr cond): cint +condWait sdl2.html#condWait,ptr.cond,ptr.mutex sdl2: condWait(cond: ptr cond; mutex: ptr mutex): cint +condWaitTimeout sdl2.html#condWaitTimeout,ptr.cond,ptr.mutex,Uint32 sdl2: condWaitTimeout(cond: ptr cond; mutex: ptr mutex; ms: Uint32): cint +createThread sdl2.html#createThread,ThreadFunction,cstring,pointer sdl2: createThread(fn: ThreadFunction; name: cstring; data: pointer): ptr Thread +createThreadWithStackSize sdl2.html#createThreadWithStackSize,ThreadFunction,cstring,uint,pointer sdl2: createThreadWithStackSize(fn: ThreadFunction; name: cstring; stacksize: uint;\n data: pointer): ptr Thread +getThreadName sdl2.html#getThreadName,ptr.Thread sdl2: getThreadName(thread: ptr Thread): cstring +getThreadID sdl2.html#getThreadID,ptr.Thread sdl2: getThreadID(thread: ptr Thread): threadID +setThreadPriority sdl2.html#setThreadPriority,ThreadPriority sdl2: setThreadPriority(priority: ThreadPriority): cint +waitThread sdl2.html#waitThread,ptr.Thread,ptr.cint sdl2: waitThread(thread: ptr Thread; status: ptr cint) +detachThread sdl2.html#detachThread,ptr.Thread sdl2: detachThread(thread: ptr Thread) +tLSCreate sdl2.html#tLSCreate sdl2: tLSCreate(): TLSID +tLSGet sdl2.html#tLSGet,TLSID sdl2: tLSGet(id: TLSID): pointer +tLSSet sdl2.html#tLSSet,TLSID,pointer,proc(pointer) sdl2: tLSSet(id: TLSID; value: pointer; destructor: proc (a1: pointer) {.cdecl.}): cint +rWFromFile sdl2.html#rWFromFile,cstring,cstring sdl2: rWFromFile(file: cstring; mode: cstring): ptr RWops +rWFromFP sdl2.html#rWFromFP,File,bool sdl2: rWFromFP(fp: File; autoclose: bool): ptr RWops +rWFromMem sdl2.html#rWFromMem,pointer,cint sdl2: rWFromMem(mem: pointer; size: cint): ptr RWops +rWFromConstMem sdl2.html#rWFromConstMem,pointer,cint sdl2: rWFromConstMem(mem: pointer; size: cint): ptr RWops +allocRW sdl2.html#allocRW sdl2: allocRW(): ptr RWops +freeRW sdl2.html#freeRW,ptr.RWops sdl2: freeRW(area: ptr RWops) +rWsize sdl2.html#rWsize,ptr.RWops sdl2: rWsize(context: ptr RWops): Sint64 +rWseek sdl2.html#rWseek,ptr.RWops,Sint64,cint sdl2: rWseek(context: ptr RWops; offset: Sint64; whence: cint): Sint64 +rWtell sdl2.html#rWtell,ptr.RWops sdl2: rWtell(context: ptr RWops): Sint64 +rWread sdl2.html#rWread,ptr.RWops,pointer,uint,uint sdl2: rWread(context: ptr RWops; `ptr`: pointer; size: uint; maxnum: uint): uint +rWwrite sdl2.html#rWwrite,ptr.RWops,pointer,uint,uint sdl2: rWwrite(context: ptr RWops; `ptr`: pointer; size: uint; num: uint): uint +rWclose sdl2.html#rWclose,ptr.RWops sdl2: rWclose(context: ptr RWops): cint +loadFile_RW sdl2.html#loadFile_RW,ptr.RWops,ptr.uint,cint sdl2: loadFile_RW(src: ptr RWops; datasize: ptr uint; freesrc: cint): pointer +loadFile sdl2.html#loadFile,cstring,ptr.uint sdl2: loadFile(file: cstring; datasize: ptr uint): pointer +readU8 sdl2.html#readU8,ptr.RWops sdl2: readU8(src: ptr RWops): Uint8 +readLE16 sdl2.html#readLE16,ptr.RWops sdl2: readLE16(src: ptr RWops): Uint16 +readBE16 sdl2.html#readBE16,ptr.RWops sdl2: readBE16(src: ptr RWops): Uint16 +readLE32 sdl2.html#readLE32,ptr.RWops sdl2: readLE32(src: ptr RWops): Uint32 +readBE32 sdl2.html#readBE32,ptr.RWops sdl2: readBE32(src: ptr RWops): Uint32 +readLE64 sdl2.html#readLE64,ptr.RWops sdl2: readLE64(src: ptr RWops): Uint64 +readBE64 sdl2.html#readBE64,ptr.RWops sdl2: readBE64(src: ptr RWops): Uint64 +writeU8 sdl2.html#writeU8,ptr.RWops,Uint8 sdl2: writeU8(dst: ptr RWops; value: Uint8): uint +writeLE16 sdl2.html#writeLE16,ptr.RWops,Uint16 sdl2: writeLE16(dst: ptr RWops; value: Uint16): uint +writeBE16 sdl2.html#writeBE16,ptr.RWops,Uint16 sdl2: writeBE16(dst: ptr RWops; value: Uint16): uint +writeLE32 sdl2.html#writeLE32,ptr.RWops,Uint32 sdl2: writeLE32(dst: ptr RWops; value: Uint32): uint +writeBE32 sdl2.html#writeBE32,ptr.RWops,Uint32 sdl2: writeBE32(dst: ptr RWops; value: Uint32): uint +writeLE64 sdl2.html#writeLE64,ptr.RWops,Uint64 sdl2: writeLE64(dst: ptr RWops; value: Uint64): uint +writeBE64 sdl2.html#writeBE64,ptr.RWops,Uint64 sdl2: writeBE64(dst: ptr RWops; value: Uint64): uint +getNumAudioDrivers sdl2.html#getNumAudioDrivers sdl2: getNumAudioDrivers(): cint +getAudioDriver sdl2.html#getAudioDriver,cint sdl2: getAudioDriver(index: cint): cstring +audioInit sdl2.html#audioInit,cstring sdl2: audioInit(driverName: cstring): cint +audioQuit sdl2.html#audioQuit sdl2: audioQuit() +getCurrentAudioDriver sdl2.html#getCurrentAudioDriver sdl2: getCurrentAudioDriver(): cstring +openAudio sdl2.html#openAudio,ptr.AudioSpec,ptr.AudioSpec sdl2: openAudio(desired: ptr AudioSpec; obtained: ptr AudioSpec): cint +getNumAudioDevices sdl2.html#getNumAudioDevices,cint sdl2: getNumAudioDevices(iscapture: cint): cint +getAudioDeviceName sdl2.html#getAudioDeviceName,cint,cint sdl2: getAudioDeviceName(index: cint; iscapture: cint): cstring +openAudioDevice sdl2.html#openAudioDevice,cstring,cint,ptr.AudioSpec,ptr.AudioSpec,cint sdl2: openAudioDevice(device: cstring; iscapture: cint; desired: ptr AudioSpec;\n obtained: ptr AudioSpec; allowedChanges: cint): AudioDeviceID +getAudioStatus sdl2.html#getAudioStatus sdl2: getAudioStatus(): AudioStatus +getAudioDeviceStatus sdl2.html#getAudioDeviceStatus,AudioDeviceID sdl2: getAudioDeviceStatus(dev: AudioDeviceID): AudioStatus +pauseAudio sdl2.html#pauseAudio,cint sdl2: pauseAudio(pauseOn: cint) +pauseAudioDevice sdl2.html#pauseAudioDevice,AudioDeviceID,cint sdl2: pauseAudioDevice(dev: AudioDeviceID; pauseOn: cint) +loadWAV_RW sdl2.html#loadWAV_RW,ptr.RWops,cint,ptr.AudioSpec,ptr.ptr.Uint8,ptr.Uint32 sdl2: loadWAV_RW(src: ptr RWops; freesrc: cint; spec: ptr AudioSpec; audioBuf: ptr ptr Uint8;\n audioLen: ptr Uint32): ptr AudioSpec +freeWAV sdl2.html#freeWAV,ptr.Uint8 sdl2: freeWAV(audioBuf: ptr Uint8) +buildAudioCVT sdl2.html#buildAudioCVT,ptr.AudioCVT,AudioFormat,Uint8,cint,AudioFormat,Uint8,cint sdl2: buildAudioCVT(cvt: ptr AudioCVT; srcFormat: AudioFormat; srcChannels: Uint8;\n srcRate: cint; dstFormat: AudioFormat; dstChannels: Uint8; dstRate: cint): cint +convertAudio sdl2.html#convertAudio,ptr.AudioCVT sdl2: convertAudio(cvt: ptr AudioCVT): cint +newAudioStream sdl2.html#newAudioStream,AudioFormat,Uint8,cint,AudioFormat,Uint8,cint sdl2: newAudioStream(srcFormat: AudioFormat; srcChannels: Uint8; srcRate: cint;\n dstFormat: AudioFormat; dstChannels: Uint8; dstRate: cint): ptr AudioStream +audioStreamPut sdl2.html#audioStreamPut,ptr.AudioStream,pointer,cint sdl2: audioStreamPut(stream: ptr AudioStream; buf: pointer; len: cint): cint +audioStreamGet sdl2.html#audioStreamGet,ptr.AudioStream,pointer,cint sdl2: audioStreamGet(stream: ptr AudioStream; buf: pointer; len: cint): cint +audioStreamAvailable sdl2.html#audioStreamAvailable,ptr.AudioStream sdl2: audioStreamAvailable(stream: ptr AudioStream): cint +audioStreamFlush sdl2.html#audioStreamFlush,ptr.AudioStream sdl2: audioStreamFlush(stream: ptr AudioStream): cint +audioStreamClear sdl2.html#audioStreamClear,ptr.AudioStream sdl2: audioStreamClear(stream: ptr AudioStream) +freeAudioStream sdl2.html#freeAudioStream,ptr.AudioStream sdl2: freeAudioStream(stream: ptr AudioStream) +mixAudio sdl2.html#mixAudio,ptr.Uint8,ptr.Uint8,Uint32,cint sdl2: mixAudio(dst: ptr Uint8; src: ptr Uint8; len: Uint32; volume: cint) +mixAudioFormat sdl2.html#mixAudioFormat,ptr.Uint8,ptr.Uint8,AudioFormat,Uint32,cint sdl2: mixAudioFormat(dst: ptr Uint8; src: ptr Uint8; format: AudioFormat; len: Uint32;\n volume: cint) +queueAudio sdl2.html#queueAudio,AudioDeviceID,pointer,Uint32 sdl2: queueAudio(dev: AudioDeviceID; data: pointer; len: Uint32): cint +dequeueAudio sdl2.html#dequeueAudio,AudioDeviceID,pointer,Uint32 sdl2: dequeueAudio(dev: AudioDeviceID; data: pointer; len: Uint32): Uint32 +getQueuedAudioSize sdl2.html#getQueuedAudioSize,AudioDeviceID sdl2: getQueuedAudioSize(dev: AudioDeviceID): Uint32 +clearQueuedAudio sdl2.html#clearQueuedAudio,AudioDeviceID sdl2: clearQueuedAudio(dev: AudioDeviceID) +lockAudio sdl2.html#lockAudio sdl2: lockAudio() +lockAudioDevice sdl2.html#lockAudioDevice,AudioDeviceID sdl2: lockAudioDevice(dev: AudioDeviceID) +unlockAudio sdl2.html#unlockAudio sdl2: unlockAudio() +unlockAudioDevice sdl2.html#unlockAudioDevice,AudioDeviceID sdl2: unlockAudioDevice(dev: AudioDeviceID) +closeAudio sdl2.html#closeAudio sdl2: closeAudio() +closeAudioDevice sdl2.html#closeAudioDevice,AudioDeviceID sdl2: closeAudioDevice(dev: AudioDeviceID) +setClipboardText sdl2.html#setClipboardText,cstring sdl2: setClipboardText(text: cstring): cint +getClipboardText sdl2.html#getClipboardText sdl2: getClipboardText(): cstring +hasClipboardText sdl2.html#hasClipboardText sdl2: hasClipboardText(): bool +getCPUCount sdl2.html#getCPUCount sdl2: getCPUCount(): cint +getCPUCacheLineSize sdl2.html#getCPUCacheLineSize sdl2: getCPUCacheLineSize(): cint +hasRDTSC sdl2.html#hasRDTSC sdl2: hasRDTSC(): bool +hasAltiVec sdl2.html#hasAltiVec sdl2: hasAltiVec(): bool +hasMMX sdl2.html#hasMMX sdl2: hasMMX(): bool +has3DNow sdl2.html#has3DNow sdl2: has3DNow(): bool +hasSSE sdl2.html#hasSSE sdl2: hasSSE(): bool +hasSSE2 sdl2.html#hasSSE2 sdl2: hasSSE2(): bool +hasSSE3 sdl2.html#hasSSE3 sdl2: hasSSE3(): bool +hasSSE41 sdl2.html#hasSSE41 sdl2: hasSSE41(): bool +hasSSE42 sdl2.html#hasSSE42 sdl2: hasSSE42(): bool +hasAVX sdl2.html#hasAVX sdl2: hasAVX(): bool +hasAVX2 sdl2.html#hasAVX2 sdl2: hasAVX2(): bool +hasAVX512F sdl2.html#hasAVX512F sdl2: hasAVX512F(): bool +hasARMSIMD sdl2.html#hasARMSIMD sdl2: hasARMSIMD(): bool +hasNEON sdl2.html#hasNEON sdl2: hasNEON(): bool +getSystemRAM sdl2.html#getSystemRAM sdl2: getSystemRAM(): cint +sIMDGetAlignment sdl2.html#sIMDGetAlignment sdl2: sIMDGetAlignment(): uint +sIMDAlloc sdl2.html#sIMDAlloc,uint sdl2: sIMDAlloc(len: uint): pointer +sIMDFree sdl2.html#sIMDFree,pointer sdl2: sIMDFree(`ptr`: pointer) +getPixelFormatName sdl2.html#getPixelFormatName,Uint32 sdl2: getPixelFormatName(format: Uint32): cstring +pixelFormatEnumToMasks sdl2.html#pixelFormatEnumToMasks,Uint32,ptr.cint,ptr.Uint32,ptr.Uint32,ptr.Uint32,ptr.Uint32 sdl2: pixelFormatEnumToMasks(format: Uint32; bpp: ptr cint; Rmask: ptr Uint32;\n Gmask: ptr Uint32; Bmask: ptr Uint32; Amask: ptr Uint32): bool +masksToPixelFormatEnum sdl2.html#masksToPixelFormatEnum,cint,Uint32,Uint32,Uint32,Uint32 sdl2: masksToPixelFormatEnum(bpp: cint; Rmask: Uint32; Gmask: Uint32; Bmask: Uint32;\n Amask: Uint32): Uint32 +allocFormat sdl2.html#allocFormat,Uint32 sdl2: allocFormat(pixelFormat: Uint32): ptr PixelFormat +freeFormat sdl2.html#freeFormat,ptr.PixelFormat sdl2: freeFormat(format: ptr PixelFormat) +allocPalette sdl2.html#allocPalette,cint sdl2: allocPalette(ncolors: cint): ptr Palette +setPixelFormatPalette sdl2.html#setPixelFormatPalette,ptr.PixelFormat,ptr.Palette sdl2: setPixelFormatPalette(format: ptr PixelFormat; palette: ptr Palette): cint +setPaletteColors sdl2.html#setPaletteColors,ptr.Palette,ptr.Color,cint,cint sdl2: setPaletteColors(palette: ptr Palette; colors: ptr Color; firstcolor: cint;\n ncolors: cint): cint +freePalette sdl2.html#freePalette,ptr.Palette sdl2: freePalette(palette: ptr Palette) +mapRGB sdl2.html#mapRGB,ptr.PixelFormat,Uint8,Uint8,Uint8 sdl2: mapRGB(format: ptr PixelFormat; r: Uint8; g: Uint8; b: Uint8): Uint32 +mapRGBA sdl2.html#mapRGBA,ptr.PixelFormat,Uint8,Uint8,Uint8,Uint8 sdl2: mapRGBA(format: ptr PixelFormat; r: Uint8; g: Uint8; b: Uint8; a: Uint8): Uint32 +getRGB sdl2.html#getRGB,Uint32,ptr.PixelFormat,ptr.Uint8,ptr.Uint8,ptr.Uint8 sdl2: getRGB(pixel: Uint32; format: ptr PixelFormat; r: ptr Uint8; g: ptr Uint8; b: ptr Uint8) +getRGBA sdl2.html#getRGBA,Uint32,ptr.PixelFormat,ptr.Uint8,ptr.Uint8,ptr.Uint8,ptr.Uint8 sdl2: getRGBA(pixel: Uint32; format: ptr PixelFormat; r: ptr Uint8; g: ptr Uint8; b: ptr Uint8;\n a: ptr Uint8) +calculateGammaRamp sdl2.html#calculateGammaRamp,cfloat,ptr.Uint16 sdl2: calculateGammaRamp(gamma: cfloat; ramp: ptr Uint16) +hasIntersection sdl2.html#hasIntersection,ptr.Rect,ptr.Rect sdl2: hasIntersection(A: ptr Rect; B: ptr Rect): bool +intersectRect sdl2.html#intersectRect,ptr.Rect,ptr.Rect,ptr.Rect sdl2: intersectRect(A: ptr Rect; B: ptr Rect; result: ptr Rect): bool +unionRect sdl2.html#unionRect,ptr.Rect,ptr.Rect,ptr.Rect sdl2: unionRect(A: ptr Rect; B: ptr Rect; result: ptr Rect) +enclosePoints sdl2.html#enclosePoints,ptr.Point,cint,ptr.Rect,ptr.Rect sdl2: enclosePoints(points: ptr Point; count: cint; clip: ptr Rect; result: ptr Rect): bool +intersectRectAndLine sdl2.html#intersectRectAndLine,ptr.Rect,ptr.cint,ptr.cint,ptr.cint,ptr.cint sdl2: intersectRectAndLine(rect: ptr Rect; X1: ptr cint; Y1: ptr cint; X2: ptr cint; Y2: ptr cint): bool +composeCustomBlendMode sdl2.html#composeCustomBlendMode,BlendFactor,BlendFactor,BlendOperation,BlendFactor,BlendFactor,BlendOperation sdl2: composeCustomBlendMode(srcColorFactor: BlendFactor; dstColorFactor: BlendFactor;\n colorOperation: BlendOperation;\n srcAlphaFactor: BlendFactor; dstAlphaFactor: BlendFactor;\n alphaOperation: BlendOperation): BlendMode +createRGBSurface sdl2.html#createRGBSurface,Uint32,cint,cint,cint,Uint32,Uint32,Uint32,Uint32 sdl2: createRGBSurface(flags: Uint32; width: cint; height: cint; depth: cint; Rmask: Uint32;\n Gmask: Uint32; Bmask: Uint32; Amask: Uint32): ptr Surface +createRGBSurfaceWithFormat sdl2.html#createRGBSurfaceWithFormat,Uint32,cint,cint,cint,Uint32 sdl2: createRGBSurfaceWithFormat(flags: Uint32; width: cint; height: cint; depth: cint;\n format: Uint32): ptr Surface +createRGBSurfaceFrom sdl2.html#createRGBSurfaceFrom,pointer,cint,cint,cint,cint,Uint32,Uint32,Uint32,Uint32 sdl2: createRGBSurfaceFrom(pixels: pointer; width: cint; height: cint; depth: cint;\n pitch: cint; Rmask: Uint32; Gmask: Uint32; Bmask: Uint32;\n Amask: Uint32): ptr Surface +createRGBSurfaceWithFormatFrom sdl2.html#createRGBSurfaceWithFormatFrom,pointer,cint,cint,cint,cint,Uint32 sdl2: createRGBSurfaceWithFormatFrom(pixels: pointer; width: cint; height: cint;\n depth: cint; pitch: cint; format: Uint32): ptr Surface +freeSurface sdl2.html#freeSurface,ptr.Surface sdl2: freeSurface(surface: ptr Surface) +setSurfacePalette sdl2.html#setSurfacePalette,ptr.Surface,ptr.Palette sdl2: setSurfacePalette(surface: ptr Surface; palette: ptr Palette): cint +lockSurface sdl2.html#lockSurface,ptr.Surface sdl2: lockSurface(surface: ptr Surface): cint +unlockSurface sdl2.html#unlockSurface,ptr.Surface sdl2: unlockSurface(surface: ptr Surface) +loadBMP_RW sdl2.html#loadBMP_RW,ptr.RWops,cint sdl2: loadBMP_RW(src: ptr RWops; freesrc: cint): ptr Surface +saveBMP_RW sdl2.html#saveBMP_RW,ptr.Surface,ptr.RWops,cint sdl2: saveBMP_RW(surface: ptr Surface; dst: ptr RWops; freedst: cint): cint +setSurfaceRLE sdl2.html#setSurfaceRLE,ptr.Surface,cint sdl2: setSurfaceRLE(surface: ptr Surface; flag: cint): cint +setColorKey sdl2.html#setColorKey,ptr.Surface,cint,Uint32 sdl2: setColorKey(surface: ptr Surface; flag: cint; key: Uint32): cint +hasColorKey sdl2.html#hasColorKey,ptr.Surface sdl2: hasColorKey(surface: ptr Surface): bool +getColorKey sdl2.html#getColorKey,ptr.Surface,ptr.Uint32 sdl2: getColorKey(surface: ptr Surface; key: ptr Uint32): cint +setSurfaceColorMod sdl2.html#setSurfaceColorMod,ptr.Surface,Uint8,Uint8,Uint8 sdl2: setSurfaceColorMod(surface: ptr Surface; r: Uint8; g: Uint8; b: Uint8): cint +getSurfaceColorMod sdl2.html#getSurfaceColorMod,ptr.Surface,ptr.Uint8,ptr.Uint8,ptr.Uint8 sdl2: getSurfaceColorMod(surface: ptr Surface; r: ptr Uint8; g: ptr Uint8; b: ptr Uint8): cint +setSurfaceAlphaMod sdl2.html#setSurfaceAlphaMod,ptr.Surface,Uint8 sdl2: setSurfaceAlphaMod(surface: ptr Surface; alpha: Uint8): cint +getSurfaceAlphaMod sdl2.html#getSurfaceAlphaMod,ptr.Surface,ptr.Uint8 sdl2: getSurfaceAlphaMod(surface: ptr Surface; alpha: ptr Uint8): cint +setSurfaceBlendMode sdl2.html#setSurfaceBlendMode,ptr.Surface,BlendMode sdl2: setSurfaceBlendMode(surface: ptr Surface; blendMode: BlendMode): cint +getSurfaceBlendMode sdl2.html#getSurfaceBlendMode,ptr.Surface,ptr.BlendMode sdl2: getSurfaceBlendMode(surface: ptr Surface; blendMode: ptr BlendMode): cint +setClipRect sdl2.html#setClipRect,ptr.Surface,ptr.Rect sdl2: setClipRect(surface: ptr Surface; rect: ptr Rect): bool +getClipRect sdl2.html#getClipRect,ptr.Surface,ptr.Rect sdl2: getClipRect(surface: ptr Surface; rect: ptr Rect) +duplicateSurface sdl2.html#duplicateSurface,ptr.Surface sdl2: duplicateSurface(surface: ptr Surface): ptr Surface +convertSurface sdl2.html#convertSurface,ptr.Surface,ptr.PixelFormat,Uint32 sdl2: convertSurface(src: ptr Surface; fmt: ptr PixelFormat; flags: Uint32): ptr Surface +convertSurfaceFormat sdl2.html#convertSurfaceFormat,ptr.Surface,Uint32,Uint32 sdl2: convertSurfaceFormat(src: ptr Surface; pixelFormat: Uint32; flags: Uint32): ptr Surface +convertPixels sdl2.html#convertPixels,cint,cint,Uint32,pointer,cint,Uint32,pointer,cint sdl2: convertPixels(width: cint; height: cint; srcFormat: Uint32; src: pointer;\n srcPitch: cint; dstFormat: Uint32; dst: pointer; dstPitch: cint): cint +fillRect sdl2.html#fillRect,ptr.Surface,ptr.Rect,Uint32 sdl2: fillRect(dst: ptr Surface; rect: ptr Rect; color: Uint32): cint +fillRects sdl2.html#fillRects,ptr.Surface,ptr.Rect,cint,Uint32 sdl2: fillRects(dst: ptr Surface; rects: ptr Rect; count: cint; color: Uint32): cint +upperBlit sdl2.html#upperBlit,ptr.Surface,ptr.Rect,ptr.Surface,ptr.Rect sdl2: upperBlit(src: ptr Surface; srcrect: ptr Rect; dst: ptr Surface; dstrect: ptr Rect): cint +lowerBlit sdl2.html#lowerBlit,ptr.Surface,ptr.Rect,ptr.Surface,ptr.Rect sdl2: lowerBlit(src: ptr Surface; srcrect: ptr Rect; dst: ptr Surface; dstrect: ptr Rect): cint +softStretch sdl2.html#softStretch,ptr.Surface,ptr.Rect,ptr.Surface,ptr.Rect sdl2: softStretch(src: ptr Surface; srcrect: ptr Rect; dst: ptr Surface; dstrect: ptr Rect): cint +upperBlitScaled sdl2.html#upperBlitScaled,ptr.Surface,ptr.Rect,ptr.Surface,ptr.Rect sdl2: upperBlitScaled(src: ptr Surface; srcrect: ptr Rect; dst: ptr Surface; dstrect: ptr Rect): cint +lowerBlitScaled sdl2.html#lowerBlitScaled,ptr.Surface,ptr.Rect,ptr.Surface,ptr.Rect sdl2: lowerBlitScaled(src: ptr Surface; srcrect: ptr Rect; dst: ptr Surface; dstrect: ptr Rect): cint +setYUVConversionMode sdl2.html#setYUVConversionMode,YUV_CONVERSION_MODE sdl2: setYUVConversionMode(mode: YUV_CONVERSION_MODE) +getYUVConversionMode sdl2.html#getYUVConversionMode sdl2: getYUVConversionMode(): YUV_CONVERSION_MODE +getYUVConversionModeForResolution sdl2.html#getYUVConversionModeForResolution,cint,cint sdl2: getYUVConversionModeForResolution(width: cint; height: cint): YUV_CONVERSION_MODE +getNumVideoDrivers sdl2.html#getNumVideoDrivers sdl2: getNumVideoDrivers(): cint +getVideoDriver sdl2.html#getVideoDriver,cint sdl2: getVideoDriver(index: cint): cstring +videoInit sdl2.html#videoInit,cstring sdl2: videoInit(driverName: cstring): cint +videoQuit sdl2.html#videoQuit sdl2: videoQuit() +getCurrentVideoDriver sdl2.html#getCurrentVideoDriver sdl2: getCurrentVideoDriver(): cstring +getNumVideoDisplays sdl2.html#getNumVideoDisplays sdl2: getNumVideoDisplays(): cint +getDisplayName sdl2.html#getDisplayName,cint sdl2: getDisplayName(displayIndex: cint): cstring +getDisplayBounds sdl2.html#getDisplayBounds,cint,ptr.Rect sdl2: getDisplayBounds(displayIndex: cint; rect: ptr Rect): cint +getDisplayUsableBounds sdl2.html#getDisplayUsableBounds,cint,ptr.Rect sdl2: getDisplayUsableBounds(displayIndex: cint; rect: ptr Rect): cint +getDisplayDPI sdl2.html#getDisplayDPI,cint,ptr.cfloat,ptr.cfloat,ptr.cfloat sdl2: getDisplayDPI(displayIndex: cint; ddpi: ptr cfloat; hdpi: ptr cfloat; vdpi: ptr cfloat): cint +getDisplayOrientation sdl2.html#getDisplayOrientation,cint sdl2: getDisplayOrientation(displayIndex: cint): DisplayOrientation +getNumDisplayModes sdl2.html#getNumDisplayModes,cint sdl2: getNumDisplayModes(displayIndex: cint): cint +getDisplayMode sdl2.html#getDisplayMode,cint,cint,ptr.DisplayMode sdl2: getDisplayMode(displayIndex: cint; modeIndex: cint; mode: ptr DisplayMode): cint +getDesktopDisplayMode sdl2.html#getDesktopDisplayMode,cint,ptr.DisplayMode sdl2: getDesktopDisplayMode(displayIndex: cint; mode: ptr DisplayMode): cint +getCurrentDisplayMode sdl2.html#getCurrentDisplayMode,cint,ptr.DisplayMode sdl2: getCurrentDisplayMode(displayIndex: cint; mode: ptr DisplayMode): cint +getClosestDisplayMode sdl2.html#getClosestDisplayMode,cint,ptr.DisplayMode,ptr.DisplayMode sdl2: getClosestDisplayMode(displayIndex: cint; mode: ptr DisplayMode;\n closest: ptr DisplayMode): ptr DisplayMode +getWindowDisplayIndex sdl2.html#getWindowDisplayIndex,ptr.Window sdl2: getWindowDisplayIndex(window: ptr Window): cint +setWindowDisplayMode sdl2.html#setWindowDisplayMode,ptr.Window,ptr.DisplayMode sdl2: setWindowDisplayMode(window: ptr Window; mode: ptr DisplayMode): cint +getWindowDisplayMode sdl2.html#getWindowDisplayMode,ptr.Window,ptr.DisplayMode sdl2: getWindowDisplayMode(window: ptr Window; mode: ptr DisplayMode): cint +getWindowPixelFormat sdl2.html#getWindowPixelFormat,ptr.Window sdl2: getWindowPixelFormat(window: ptr Window): Uint32 +createWindow sdl2.html#createWindow,cstring,cint,cint,cint,cint,Uint32 sdl2: createWindow(title: cstring; x: cint; y: cint; w: cint; h: cint; flags: Uint32): ptr Window +createWindowFrom sdl2.html#createWindowFrom,pointer sdl2: createWindowFrom(data: pointer): ptr Window +getWindowID sdl2.html#getWindowID,ptr.Window sdl2: getWindowID(window: ptr Window): Uint32 +getWindowFromID sdl2.html#getWindowFromID,Uint32 sdl2: getWindowFromID(id: Uint32): ptr Window +getWindowFlags sdl2.html#getWindowFlags,ptr.Window sdl2: getWindowFlags(window: ptr Window): Uint32 +setWindowTitle sdl2.html#setWindowTitle,ptr.Window,cstring sdl2: setWindowTitle(window: ptr Window; title: cstring) +getWindowTitle sdl2.html#getWindowTitle,ptr.Window sdl2: getWindowTitle(window: ptr Window): cstring +setWindowIcon sdl2.html#setWindowIcon,ptr.Window,ptr.Surface sdl2: setWindowIcon(window: ptr Window; icon: ptr Surface) +setWindowData sdl2.html#setWindowData,ptr.Window,cstring,pointer sdl2: setWindowData(window: ptr Window; name: cstring; userdata: pointer): pointer +getWindowData sdl2.html#getWindowData,ptr.Window,cstring sdl2: getWindowData(window: ptr Window; name: cstring): pointer +setWindowPosition sdl2.html#setWindowPosition,ptr.Window,cint,cint sdl2: setWindowPosition(window: ptr Window; x: cint; y: cint) +getWindowPosition sdl2.html#getWindowPosition,ptr.Window,ptr.cint,ptr.cint sdl2: getWindowPosition(window: ptr Window; x: ptr cint; y: ptr cint) +setWindowSize sdl2.html#setWindowSize,ptr.Window,cint,cint sdl2: setWindowSize(window: ptr Window; w: cint; h: cint) +getWindowSize sdl2.html#getWindowSize,ptr.Window,ptr.cint,ptr.cint sdl2: getWindowSize(window: ptr Window; w: ptr cint; h: ptr cint) +getWindowBordersSize sdl2.html#getWindowBordersSize,ptr.Window,ptr.cint,ptr.cint,ptr.cint,ptr.cint sdl2: getWindowBordersSize(window: ptr Window; top: ptr cint; left: ptr cint; bottom: ptr cint;\n right: ptr cint): cint +setWindowMinimumSize sdl2.html#setWindowMinimumSize,ptr.Window,cint,cint sdl2: setWindowMinimumSize(window: ptr Window; minW: cint; minH: cint) +getWindowMinimumSize sdl2.html#getWindowMinimumSize,ptr.Window,ptr.cint,ptr.cint sdl2: getWindowMinimumSize(window: ptr Window; w: ptr cint; h: ptr cint) +setWindowMaximumSize sdl2.html#setWindowMaximumSize,ptr.Window,cint,cint sdl2: setWindowMaximumSize(window: ptr Window; maxW: cint; maxH: cint) +getWindowMaximumSize sdl2.html#getWindowMaximumSize,ptr.Window,ptr.cint,ptr.cint sdl2: getWindowMaximumSize(window: ptr Window; w: ptr cint; h: ptr cint) +setWindowBordered sdl2.html#setWindowBordered,ptr.Window,bool sdl2: setWindowBordered(window: ptr Window; bordered: bool) +setWindowResizable sdl2.html#setWindowResizable,ptr.Window,bool sdl2: setWindowResizable(window: ptr Window; resizable: bool) +showWindow sdl2.html#showWindow,ptr.Window sdl2: showWindow(window: ptr Window) +hideWindow sdl2.html#hideWindow,ptr.Window sdl2: hideWindow(window: ptr Window) +raiseWindow sdl2.html#raiseWindow,ptr.Window sdl2: raiseWindow(window: ptr Window) +maximizeWindow sdl2.html#maximizeWindow,ptr.Window sdl2: maximizeWindow(window: ptr Window) +minimizeWindow sdl2.html#minimizeWindow,ptr.Window sdl2: minimizeWindow(window: ptr Window) +restoreWindow sdl2.html#restoreWindow,ptr.Window sdl2: restoreWindow(window: ptr Window) +setWindowFullscreen sdl2.html#setWindowFullscreen,ptr.Window,Uint32 sdl2: setWindowFullscreen(window: ptr Window; flags: Uint32): cint +getWindowSurface sdl2.html#getWindowSurface,ptr.Window sdl2: getWindowSurface(window: ptr Window): ptr Surface +updateWindowSurface sdl2.html#updateWindowSurface,ptr.Window sdl2: updateWindowSurface(window: ptr Window): cint +updateWindowSurfaceRects sdl2.html#updateWindowSurfaceRects,ptr.Window,ptr.Rect,cint sdl2: updateWindowSurfaceRects(window: ptr Window; rects: ptr Rect; numrects: cint): cint +setWindowGrab sdl2.html#setWindowGrab,ptr.Window,bool sdl2: setWindowGrab(window: ptr Window; grabbed: bool) +getWindowGrab sdl2.html#getWindowGrab,ptr.Window sdl2: getWindowGrab(window: ptr Window): bool +getGrabbedWindow sdl2.html#getGrabbedWindow sdl2: getGrabbedWindow(): ptr Window +setWindowBrightness sdl2.html#setWindowBrightness,ptr.Window,cfloat sdl2: setWindowBrightness(window: ptr Window; brightness: cfloat): cint +getWindowBrightness sdl2.html#getWindowBrightness,ptr.Window sdl2: getWindowBrightness(window: ptr Window): cfloat +setWindowOpacity sdl2.html#setWindowOpacity,ptr.Window,cfloat sdl2: setWindowOpacity(window: ptr Window; opacity: cfloat): cint +getWindowOpacity sdl2.html#getWindowOpacity,ptr.Window,ptr.cfloat sdl2: getWindowOpacity(window: ptr Window; outOpacity: ptr cfloat): cint +setWindowModalFor sdl2.html#setWindowModalFor,ptr.Window,ptr.Window sdl2: setWindowModalFor(modalWindow: ptr Window; parentWindow: ptr Window): cint +setWindowInputFocus sdl2.html#setWindowInputFocus,ptr.Window sdl2: setWindowInputFocus(window: ptr Window): cint +setWindowGammaRamp sdl2.html#setWindowGammaRamp,ptr.Window,ptr.Uint16,ptr.Uint16,ptr.Uint16 sdl2: setWindowGammaRamp(window: ptr Window; red: ptr Uint16; green: ptr Uint16;\n blue: ptr Uint16): cint +getWindowGammaRamp sdl2.html#getWindowGammaRamp,ptr.Window,ptr.Uint16,ptr.Uint16,ptr.Uint16 sdl2: getWindowGammaRamp(window: ptr Window; red: ptr Uint16; green: ptr Uint16;\n blue: ptr Uint16): cint +setWindowHitTest sdl2.html#setWindowHitTest,ptr.Window,HitTest,pointer sdl2: setWindowHitTest(window: ptr Window; callback: HitTest; callbackData: pointer): cint +destroyWindow sdl2.html#destroyWindow,ptr.Window sdl2: destroyWindow(window: ptr Window) +isScreenSaverEnabled sdl2.html#isScreenSaverEnabled sdl2: isScreenSaverEnabled(): bool +enableScreenSaver sdl2.html#enableScreenSaver sdl2: enableScreenSaver() +disableScreenSaver sdl2.html#disableScreenSaver sdl2: disableScreenSaver() +gL_LoadLibrary sdl2.html#gL_LoadLibrary,cstring sdl2: gL_LoadLibrary(path: cstring): cint +gL_GetProcAddress sdl2.html#gL_GetProcAddress,cstring sdl2: gL_GetProcAddress(`proc`: cstring): pointer +gL_UnloadLibrary sdl2.html#gL_UnloadLibrary sdl2: gL_UnloadLibrary() +gL_ExtensionSupported sdl2.html#gL_ExtensionSupported,cstring sdl2: gL_ExtensionSupported(extension: cstring): bool +gL_ResetAttributes sdl2.html#gL_ResetAttributes sdl2: gL_ResetAttributes() +gL_SetAttribute sdl2.html#gL_SetAttribute,GLattr,cint sdl2: gL_SetAttribute(attr: GLattr; value: cint): cint +gL_GetAttribute sdl2.html#gL_GetAttribute,GLattr,ptr.cint sdl2: gL_GetAttribute(attr: GLattr; value: ptr cint): cint +gL_CreateContext sdl2.html#gL_CreateContext,ptr.Window sdl2: gL_CreateContext(window: ptr Window): GLContext +gL_MakeCurrent sdl2.html#gL_MakeCurrent,ptr.Window,GLContext sdl2: gL_MakeCurrent(window: ptr Window; context: GLContext): cint +gL_GetCurrentWindow sdl2.html#gL_GetCurrentWindow sdl2: gL_GetCurrentWindow(): ptr Window +gL_GetCurrentContext sdl2.html#gL_GetCurrentContext sdl2: gL_GetCurrentContext(): GLContext +gL_GetDrawableSize sdl2.html#gL_GetDrawableSize,ptr.Window,ptr.cint,ptr.cint sdl2: gL_GetDrawableSize(window: ptr Window; w: ptr cint; h: ptr cint) +gL_SetSwapInterval sdl2.html#gL_SetSwapInterval,cint sdl2: gL_SetSwapInterval(interval: cint): cint +gL_GetSwapInterval sdl2.html#gL_GetSwapInterval sdl2: gL_GetSwapInterval(): cint +gL_SwapWindow sdl2.html#gL_SwapWindow,ptr.Window sdl2: gL_SwapWindow(window: ptr Window) +gL_DeleteContext sdl2.html#gL_DeleteContext,GLContext sdl2: gL_DeleteContext(context: GLContext) +getKeyboardFocus sdl2.html#getKeyboardFocus sdl2: getKeyboardFocus(): ptr Window +getKeyboardState sdl2.html#getKeyboardState,ptr.cint sdl2: getKeyboardState(numkeys: ptr cint): ptr Uint8 +getModState sdl2.html#getModState sdl2: getModState(): Keymod +setModState sdl2.html#setModState,Keymod sdl2: setModState(modstate: Keymod) +getKeyFromScancode sdl2.html#getKeyFromScancode,Scancode sdl2: getKeyFromScancode(scancode: Scancode): Keycode +getScancodeFromKey sdl2.html#getScancodeFromKey,Keycode sdl2: getScancodeFromKey(key: Keycode): Scancode +getScancodeName sdl2.html#getScancodeName,Scancode sdl2: getScancodeName(scancode: Scancode): cstring +getScancodeFromName sdl2.html#getScancodeFromName,cstring sdl2: getScancodeFromName(name: cstring): Scancode +getKeyName sdl2.html#getKeyName,Keycode sdl2: getKeyName(key: Keycode): cstring +getKeyFromName sdl2.html#getKeyFromName,cstring sdl2: getKeyFromName(name: cstring): Keycode +startTextInput sdl2.html#startTextInput sdl2: startTextInput() +isTextInputActive sdl2.html#isTextInputActive sdl2: isTextInputActive(): bool +stopTextInput sdl2.html#stopTextInput sdl2: stopTextInput() +setTextInputRect sdl2.html#setTextInputRect,ptr.Rect sdl2: setTextInputRect(rect: ptr Rect) +hasScreenKeyboardSupport sdl2.html#hasScreenKeyboardSupport sdl2: hasScreenKeyboardSupport(): bool +isScreenKeyboardShown sdl2.html#isScreenKeyboardShown,ptr.Window sdl2: isScreenKeyboardShown(window: ptr Window): bool +getMouseFocus sdl2.html#getMouseFocus sdl2: getMouseFocus(): ptr Window +getMouseState sdl2.html#getMouseState,ptr.cint,ptr.cint sdl2: getMouseState(x: ptr cint; y: ptr cint): Uint32 +getGlobalMouseState sdl2.html#getGlobalMouseState,ptr.cint,ptr.cint sdl2: getGlobalMouseState(x: ptr cint; y: ptr cint): Uint32 +getRelativeMouseState sdl2.html#getRelativeMouseState,ptr.cint,ptr.cint sdl2: getRelativeMouseState(x: ptr cint; y: ptr cint): Uint32 +warpMouseInWindow sdl2.html#warpMouseInWindow,ptr.Window,cint,cint sdl2: warpMouseInWindow(window: ptr Window; x: cint; y: cint) +warpMouseGlobal sdl2.html#warpMouseGlobal,cint,cint sdl2: warpMouseGlobal(x: cint; y: cint): cint +setRelativeMouseMode sdl2.html#setRelativeMouseMode,bool sdl2: setRelativeMouseMode(enabled: bool): cint +captureMouse sdl2.html#captureMouse,bool sdl2: captureMouse(enabled: bool): cint +getRelativeMouseMode sdl2.html#getRelativeMouseMode sdl2: getRelativeMouseMode(): bool +createCursor sdl2.html#createCursor,ptr.Uint8,ptr.Uint8,cint,cint,cint,cint sdl2: createCursor(data: ptr Uint8; mask: ptr Uint8; w: cint; h: cint; hotX: cint; hotY: cint): ptr Cursor +createColorCursor sdl2.html#createColorCursor,ptr.Surface,cint,cint sdl2: createColorCursor(surface: ptr Surface; hotX: cint; hotY: cint): ptr Cursor +createSystemCursor sdl2.html#createSystemCursor,SystemCursor sdl2: createSystemCursor(id: SystemCursor): ptr Cursor +setCursor sdl2.html#setCursor,ptr.Cursor sdl2: setCursor(cursor: ptr Cursor) +getCursor sdl2.html#getCursor sdl2: getCursor(): ptr Cursor +getDefaultCursor sdl2.html#getDefaultCursor sdl2: getDefaultCursor(): ptr Cursor +freeCursor sdl2.html#freeCursor,ptr.Cursor sdl2: freeCursor(cursor: ptr Cursor) +showCursor sdl2.html#showCursor,cint sdl2: showCursor(toggle: cint): cint +lockJoysticks sdl2.html#lockJoysticks sdl2: lockJoysticks() +unlockJoysticks sdl2.html#unlockJoysticks sdl2: unlockJoysticks() +numJoysticks sdl2.html#numJoysticks sdl2: numJoysticks(): cint +joystickNameForIndex sdl2.html#joystickNameForIndex,cint sdl2: joystickNameForIndex(deviceIndex: cint): cstring +joystickGetDevicePlayerIndex sdl2.html#joystickGetDevicePlayerIndex,cint sdl2: joystickGetDevicePlayerIndex(deviceIndex: cint): cint +joystickGetDeviceGUID sdl2.html#joystickGetDeviceGUID,cint sdl2: joystickGetDeviceGUID(deviceIndex: cint): JoystickGUID +joystickGetDeviceVendor sdl2.html#joystickGetDeviceVendor,cint sdl2: joystickGetDeviceVendor(deviceIndex: cint): Uint16 +joystickGetDeviceProduct sdl2.html#joystickGetDeviceProduct,cint sdl2: joystickGetDeviceProduct(deviceIndex: cint): Uint16 +joystickGetDeviceProductVersion sdl2.html#joystickGetDeviceProductVersion,cint sdl2: joystickGetDeviceProductVersion(deviceIndex: cint): Uint16 +joystickGetDeviceType sdl2.html#joystickGetDeviceType,cint sdl2: joystickGetDeviceType(deviceIndex: cint): JoystickType +joystickGetDeviceInstanceID sdl2.html#joystickGetDeviceInstanceID,cint sdl2: joystickGetDeviceInstanceID(deviceIndex: cint): JoystickID +joystickOpen sdl2.html#joystickOpen,cint sdl2: joystickOpen(deviceIndex: cint): ptr Joystick +joystickFromInstanceID sdl2.html#joystickFromInstanceID,JoystickID sdl2: joystickFromInstanceID(instanceId: JoystickID): ptr Joystick +joystickFromPlayerIndex sdl2.html#joystickFromPlayerIndex,cint sdl2: joystickFromPlayerIndex(playerIndex: cint): ptr Joystick +joystickName sdl2.html#joystickName,ptr.Joystick sdl2: joystickName(joystick: ptr Joystick): cstring +joystickGetPlayerIndex sdl2.html#joystickGetPlayerIndex,ptr.Joystick sdl2: joystickGetPlayerIndex(joystick: ptr Joystick): cint +joystickSetPlayerIndex sdl2.html#joystickSetPlayerIndex,ptr.Joystick,cint sdl2: joystickSetPlayerIndex(joystick: ptr Joystick; playerIndex: cint) +joystickGetGUID sdl2.html#joystickGetGUID,ptr.Joystick sdl2: joystickGetGUID(joystick: ptr Joystick): JoystickGUID +joystickGetVendor sdl2.html#joystickGetVendor,ptr.Joystick sdl2: joystickGetVendor(joystick: ptr Joystick): Uint16 +joystickGetProduct sdl2.html#joystickGetProduct,ptr.Joystick sdl2: joystickGetProduct(joystick: ptr Joystick): Uint16 +joystickGetProductVersion sdl2.html#joystickGetProductVersion,ptr.Joystick sdl2: joystickGetProductVersion(joystick: ptr Joystick): Uint16 +joystickGetType sdl2.html#joystickGetType,ptr.Joystick sdl2: joystickGetType(joystick: ptr Joystick): JoystickType +joystickGetGUIDString sdl2.html#joystickGetGUIDString,JoystickGUID,cstring,cint sdl2: joystickGetGUIDString(guid: JoystickGUID; pszGUID: cstring; cbGUID: cint) +joystickGetGUIDFromString sdl2.html#joystickGetGUIDFromString,cstring sdl2: joystickGetGUIDFromString(pchGUID: cstring): JoystickGUID +joystickGetAttached sdl2.html#joystickGetAttached,ptr.Joystick sdl2: joystickGetAttached(joystick: ptr Joystick): bool +joystickInstanceID sdl2.html#joystickInstanceID,ptr.Joystick sdl2: joystickInstanceID(joystick: ptr Joystick): JoystickID +joystickNumAxes sdl2.html#joystickNumAxes,ptr.Joystick sdl2: joystickNumAxes(joystick: ptr Joystick): cint +joystickNumBalls sdl2.html#joystickNumBalls,ptr.Joystick sdl2: joystickNumBalls(joystick: ptr Joystick): cint +joystickNumHats sdl2.html#joystickNumHats,ptr.Joystick sdl2: joystickNumHats(joystick: ptr Joystick): cint +joystickNumButtons sdl2.html#joystickNumButtons,ptr.Joystick sdl2: joystickNumButtons(joystick: ptr Joystick): cint +joystickUpdate sdl2.html#joystickUpdate sdl2: joystickUpdate() +joystickEventState sdl2.html#joystickEventState,cint sdl2: joystickEventState(state: cint): cint +joystickGetAxis sdl2.html#joystickGetAxis,ptr.Joystick,cint sdl2: joystickGetAxis(joystick: ptr Joystick; axis: cint): Sint16 +joystickGetAxisInitialState sdl2.html#joystickGetAxisInitialState,ptr.Joystick,cint,ptr.Sint16 sdl2: joystickGetAxisInitialState(joystick: ptr Joystick; axis: cint; state: ptr Sint16): bool +joystickGetHat sdl2.html#joystickGetHat,ptr.Joystick,cint sdl2: joystickGetHat(joystick: ptr Joystick; hat: cint): Uint8 +joystickGetBall sdl2.html#joystickGetBall,ptr.Joystick,cint,ptr.cint,ptr.cint sdl2: joystickGetBall(joystick: ptr Joystick; ball: cint; dx: ptr cint; dy: ptr cint): cint +joystickGetButton sdl2.html#joystickGetButton,ptr.Joystick,cint sdl2: joystickGetButton(joystick: ptr Joystick; button: cint): Uint8 +joystickRumble sdl2.html#joystickRumble,ptr.Joystick,Uint16,Uint16,Uint32 sdl2: joystickRumble(joystick: ptr Joystick; lowFrequencyRumble: Uint16;\n highFrequencyRumble: Uint16; durationMs: Uint32): cint +joystickClose sdl2.html#joystickClose,ptr.Joystick sdl2: joystickClose(joystick: ptr Joystick) +joystickCurrentPowerLevel sdl2.html#joystickCurrentPowerLevel,ptr.Joystick sdl2: joystickCurrentPowerLevel(joystick: ptr Joystick): JoystickPowerLevel +gameControllerAddMappingsFromRW sdl2.html#gameControllerAddMappingsFromRW,ptr.RWops,cint sdl2: gameControllerAddMappingsFromRW(rw: ptr RWops; freerw: cint): cint +gameControllerAddMapping sdl2.html#gameControllerAddMapping,cstring sdl2: gameControllerAddMapping(mappingString: cstring): cint +gameControllerNumMappings sdl2.html#gameControllerNumMappings sdl2: gameControllerNumMappings(): cint +gameControllerMappingForIndex sdl2.html#gameControllerMappingForIndex,cint sdl2: gameControllerMappingForIndex(mappingIndex: cint): cstring +gameControllerMappingForGUID sdl2.html#gameControllerMappingForGUID,JoystickGUID sdl2: gameControllerMappingForGUID(guid: JoystickGUID): cstring +gameControllerMapping sdl2.html#gameControllerMapping,ptr.GameController sdl2: gameControllerMapping(gamecontroller: ptr GameController): cstring +isGameController sdl2.html#isGameController,cint sdl2: isGameController(joystickIndex: cint): bool +gameControllerNameForIndex sdl2.html#gameControllerNameForIndex,cint sdl2: gameControllerNameForIndex(joystickIndex: cint): cstring +gameControllerTypeForIndex sdl2.html#gameControllerTypeForIndex,cint sdl2: gameControllerTypeForIndex(joystickIndex: cint): GameControllerType +gameControllerMappingForDeviceIndex sdl2.html#gameControllerMappingForDeviceIndex,cint sdl2: gameControllerMappingForDeviceIndex(joystickIndex: cint): cstring +gameControllerOpen sdl2.html#gameControllerOpen,cint sdl2: gameControllerOpen(joystickIndex: cint): ptr GameController +gameControllerFromInstanceID sdl2.html#gameControllerFromInstanceID,JoystickID sdl2: gameControllerFromInstanceID(joyid: JoystickID): ptr GameController +gameControllerFromPlayerIndex sdl2.html#gameControllerFromPlayerIndex,cint sdl2: gameControllerFromPlayerIndex(playerIndex: cint): ptr GameController +gameControllerName sdl2.html#gameControllerName,ptr.GameController sdl2: gameControllerName(gamecontroller: ptr GameController): cstring +gameControllerGetType sdl2.html#gameControllerGetType,ptr.GameController sdl2: gameControllerGetType(gamecontroller: ptr GameController): GameControllerType +gameControllerGetPlayerIndex sdl2.html#gameControllerGetPlayerIndex,ptr.GameController sdl2: gameControllerGetPlayerIndex(gamecontroller: ptr GameController): cint +gameControllerSetPlayerIndex sdl2.html#gameControllerSetPlayerIndex,ptr.GameController,cint sdl2: gameControllerSetPlayerIndex(gamecontroller: ptr GameController; playerIndex: cint) +gameControllerGetVendor sdl2.html#gameControllerGetVendor,ptr.GameController sdl2: gameControllerGetVendor(gamecontroller: ptr GameController): Uint16 +gameControllerGetProduct sdl2.html#gameControllerGetProduct,ptr.GameController sdl2: gameControllerGetProduct(gamecontroller: ptr GameController): Uint16 +gameControllerGetProductVersion sdl2.html#gameControllerGetProductVersion,ptr.GameController sdl2: gameControllerGetProductVersion(gamecontroller: ptr GameController): Uint16 +gameControllerGetAttached sdl2.html#gameControllerGetAttached,ptr.GameController sdl2: gameControllerGetAttached(gamecontroller: ptr GameController): bool +gameControllerGetJoystick sdl2.html#gameControllerGetJoystick,ptr.GameController sdl2: gameControllerGetJoystick(gamecontroller: ptr GameController): ptr Joystick +gameControllerEventState sdl2.html#gameControllerEventState,cint sdl2: gameControllerEventState(state: cint): cint +gameControllerUpdate sdl2.html#gameControllerUpdate sdl2: gameControllerUpdate() +gameControllerGetAxisFromString sdl2.html#gameControllerGetAxisFromString,cstring sdl2: gameControllerGetAxisFromString(pchString: cstring): GameControllerAxis +gameControllerGetStringForAxis sdl2.html#gameControllerGetStringForAxis,GameControllerAxis sdl2: gameControllerGetStringForAxis(axis: GameControllerAxis): cstring +gameControllerGetBindForAxis sdl2.html#gameControllerGetBindForAxis,ptr.GameController,GameControllerAxis sdl2: gameControllerGetBindForAxis(gamecontroller: ptr GameController;\n axis: GameControllerAxis): GameControllerButtonBind +gameControllerGetAxis sdl2.html#gameControllerGetAxis,ptr.GameController,GameControllerAxis sdl2: gameControllerGetAxis(gamecontroller: ptr GameController; axis: GameControllerAxis): Sint16 +gameControllerGetButtonFromString sdl2.html#gameControllerGetButtonFromString,cstring sdl2: gameControllerGetButtonFromString(pchString: cstring): GameControllerButton +gameControllerGetStringForButton sdl2.html#gameControllerGetStringForButton,GameControllerButton sdl2: gameControllerGetStringForButton(button: GameControllerButton): cstring +gameControllerGetBindForButton sdl2.html#gameControllerGetBindForButton,ptr.GameController,GameControllerButton sdl2: gameControllerGetBindForButton(gamecontroller: ptr GameController;\n button: GameControllerButton): GameControllerButtonBind +gameControllerGetButton sdl2.html#gameControllerGetButton,ptr.GameController,GameControllerButton sdl2: gameControllerGetButton(gamecontroller: ptr GameController;\n button: GameControllerButton): Uint8 +gameControllerRumble sdl2.html#gameControllerRumble,ptr.GameController,Uint16,Uint16,Uint32 sdl2: gameControllerRumble(gamecontroller: ptr GameController;\n lowFrequencyRumble: Uint16; highFrequencyRumble: Uint16;\n durationMs: Uint32): cint +gameControllerClose sdl2.html#gameControllerClose,ptr.GameController sdl2: gameControllerClose(gamecontroller: ptr GameController) +getNumTouchDevices sdl2.html#getNumTouchDevices sdl2: getNumTouchDevices(): cint +getTouchDevice sdl2.html#getTouchDevice,cint sdl2: getTouchDevice(index: cint): TouchID +getTouchDeviceType sdl2.html#getTouchDeviceType,TouchID sdl2: getTouchDeviceType(touchID: TouchID): TouchDeviceType +getNumTouchFingers sdl2.html#getNumTouchFingers,TouchID sdl2: getNumTouchFingers(touchID: TouchID): cint +getTouchFinger sdl2.html#getTouchFinger,TouchID,cint sdl2: getTouchFinger(touchID: TouchID; index: cint): ptr Finger +recordGesture sdl2.html#recordGesture,TouchID sdl2: recordGesture(touchId: TouchID): cint +saveAllDollarTemplates sdl2.html#saveAllDollarTemplates,ptr.RWops sdl2: saveAllDollarTemplates(dst: ptr RWops): cint +saveDollarTemplate sdl2.html#saveDollarTemplate,GestureID,ptr.RWops sdl2: saveDollarTemplate(gestureId: GestureID; dst: ptr RWops): cint +loadDollarTemplates sdl2.html#loadDollarTemplates,TouchID,ptr.RWops sdl2: loadDollarTemplates(touchId: TouchID; src: ptr RWops): cint +pumpEvents sdl2.html#pumpEvents sdl2: pumpEvents() +peepEvents sdl2.html#peepEvents,ptr.Event,cint,eventaction,Uint32,Uint32 sdl2: peepEvents(events: ptr Event; numevents: cint; action: eventaction; minType: Uint32;\n maxType: Uint32): cint +hasEvent sdl2.html#hasEvent,Uint32 sdl2: hasEvent(kind: Uint32): bool +hasEvents sdl2.html#hasEvents,Uint32,Uint32 sdl2: hasEvents(minType: Uint32; maxType: Uint32): bool +flushEvent sdl2.html#flushEvent,Uint32 sdl2: flushEvent(kind: Uint32) +flushEvents sdl2.html#flushEvents,Uint32,Uint32 sdl2: flushEvents(minType: Uint32; maxType: Uint32) +pollEvent sdl2.html#pollEvent,ptr.Event sdl2: pollEvent(event: ptr Event): cint +waitEvent sdl2.html#waitEvent,ptr.Event sdl2: waitEvent(event: ptr Event): cint +waitEventTimeout sdl2.html#waitEventTimeout,ptr.Event,cint sdl2: waitEventTimeout(event: ptr Event; timeout: cint): cint +pushEvent sdl2.html#pushEvent,ptr.Event sdl2: pushEvent(event: ptr Event): cint +setEventFilter sdl2.html#setEventFilter,EventFilter,pointer sdl2: setEventFilter(filter: EventFilter; userdata: pointer) +getEventFilter sdl2.html#getEventFilter,ptr.EventFilter,ptr.pointer sdl2: getEventFilter(filter: ptr EventFilter; userdata: ptr pointer): bool +addEventWatch sdl2.html#addEventWatch,EventFilter,pointer sdl2: addEventWatch(filter: EventFilter; userdata: pointer) +delEventWatch sdl2.html#delEventWatch,EventFilter,pointer sdl2: delEventWatch(filter: EventFilter; userdata: pointer) +filterEvents sdl2.html#filterEvents,EventFilter,pointer sdl2: filterEvents(filter: EventFilter; userdata: pointer) +eventState sdl2.html#eventState,Uint32,cint sdl2: eventState(kind: Uint32; state: cint): Uint8 +registerEvents sdl2.html#registerEvents,cint sdl2: registerEvents(numevents: cint): Uint32 +getBasePath sdl2.html#getBasePath sdl2: getBasePath(): cstring +getPrefPath sdl2.html#getPrefPath,cstring,cstring sdl2: getPrefPath(org: cstring; app: cstring): cstring +numHaptics sdl2.html#numHaptics sdl2: numHaptics(): cint +hapticName sdl2.html#hapticName,cint sdl2: hapticName(deviceIndex: cint): cstring +hapticOpen sdl2.html#hapticOpen,cint sdl2: hapticOpen(deviceIndex: cint): ptr Haptic +hapticOpened sdl2.html#hapticOpened,cint sdl2: hapticOpened(deviceIndex: cint): cint +hapticIndex sdl2.html#hapticIndex,ptr.PHaptic sdl2: hapticIndex(haptic: ptr Haptic): cint +mouseIsHaptic sdl2.html#mouseIsHaptic sdl2: mouseIsHaptic(): cint +hapticOpenFromMouse sdl2.html#hapticOpenFromMouse sdl2: hapticOpenFromMouse(): ptr Haptic +joystickIsHaptic sdl2.html#joystickIsHaptic,ptr.Joystick sdl2: joystickIsHaptic(joystick: ptr Joystick): cint +hapticOpenFromJoystick sdl2.html#hapticOpenFromJoystick,ptr.Joystick sdl2: hapticOpenFromJoystick(joystick: ptr Joystick): ptr Haptic +hapticClose sdl2.html#hapticClose,ptr.PHaptic sdl2: hapticClose(haptic: ptr Haptic) +hapticNumEffects sdl2.html#hapticNumEffects,ptr.PHaptic sdl2: hapticNumEffects(haptic: ptr Haptic): cint +hapticNumEffectsPlaying sdl2.html#hapticNumEffectsPlaying,ptr.PHaptic sdl2: hapticNumEffectsPlaying(haptic: ptr Haptic): cint +hapticQuery sdl2.html#hapticQuery,ptr.PHaptic sdl2: hapticQuery(haptic: ptr Haptic): cuint +hapticNumAxes sdl2.html#hapticNumAxes,ptr.PHaptic sdl2: hapticNumAxes(haptic: ptr Haptic): cint +hapticEffectSupported sdl2.html#hapticEffectSupported,ptr.PHaptic,ptr.HapticEffect sdl2: hapticEffectSupported(haptic: ptr Haptic; effect: ptr HapticEffect): cint +hapticNewEffect sdl2.html#hapticNewEffect,ptr.PHaptic,ptr.HapticEffect sdl2: hapticNewEffect(haptic: ptr Haptic; effect: ptr HapticEffect): cint +hapticUpdateEffect sdl2.html#hapticUpdateEffect,ptr.PHaptic,cint,ptr.HapticEffect sdl2: hapticUpdateEffect(haptic: ptr Haptic; effect: cint; data: ptr HapticEffect): cint +hapticRunEffect sdl2.html#hapticRunEffect,ptr.PHaptic,cint,Uint32 sdl2: hapticRunEffect(haptic: ptr Haptic; effect: cint; iterations: Uint32): cint +hapticStopEffect sdl2.html#hapticStopEffect,ptr.PHaptic,cint sdl2: hapticStopEffect(haptic: ptr Haptic; effect: cint): cint +hapticDestroyEffect sdl2.html#hapticDestroyEffect,ptr.PHaptic,cint sdl2: hapticDestroyEffect(haptic: ptr Haptic; effect: cint) +hapticGetEffectStatus sdl2.html#hapticGetEffectStatus,ptr.PHaptic,cint sdl2: hapticGetEffectStatus(haptic: ptr Haptic; effect: cint): cint +hapticSetGain sdl2.html#hapticSetGain,ptr.PHaptic,cint sdl2: hapticSetGain(haptic: ptr Haptic; gain: cint): cint +hapticSetAutocenter sdl2.html#hapticSetAutocenter,ptr.PHaptic,cint sdl2: hapticSetAutocenter(haptic: ptr Haptic; autocenter: cint): cint +hapticPause sdl2.html#hapticPause,ptr.PHaptic sdl2: hapticPause(haptic: ptr Haptic): cint +hapticUnpause sdl2.html#hapticUnpause,ptr.PHaptic sdl2: hapticUnpause(haptic: ptr Haptic): cint +hapticStopAll sdl2.html#hapticStopAll,ptr.PHaptic sdl2: hapticStopAll(haptic: ptr Haptic): cint +hapticRumbleSupported sdl2.html#hapticRumbleSupported,ptr.PHaptic sdl2: hapticRumbleSupported(haptic: ptr Haptic): cint +hapticRumbleInit sdl2.html#hapticRumbleInit,ptr.PHaptic sdl2: hapticRumbleInit(haptic: ptr Haptic): cint +hapticRumblePlay sdl2.html#hapticRumblePlay,ptr.PHaptic,cfloat,Uint32 sdl2: hapticRumblePlay(haptic: ptr Haptic; strength: cfloat; length: Uint32): cint +hapticRumbleStop sdl2.html#hapticRumbleStop,ptr.PHaptic sdl2: hapticRumbleStop(haptic: ptr Haptic): cint +setHintWithPriority sdl2.html#setHintWithPriority,cstring,cstring,HintPriority sdl2: setHintWithPriority(name: cstring; value: cstring; priority: HintPriority): bool +setHint sdl2.html#setHint,cstring,cstring sdl2: setHint(name: cstring; value: cstring): bool +getHint sdl2.html#getHint,cstring sdl2: getHint(name: cstring): cstring +getHintBoolean sdl2.html#getHintBoolean,cstring,bool sdl2: getHintBoolean(name: cstring; defaultValue: bool): bool +addHintCallback sdl2.html#addHintCallback,cstring,HintCallback,pointer sdl2: addHintCallback(name: cstring; callback: HintCallback; userdata: pointer) +delHintCallback sdl2.html#delHintCallback,cstring,HintCallback,pointer sdl2: delHintCallback(name: cstring; callback: HintCallback; userdata: pointer) +clearHints sdl2.html#clearHints sdl2: clearHints() +loadObject sdl2.html#loadObject,cstring sdl2: loadObject(sofile: cstring): pointer +loadFunction sdl2.html#loadFunction,pointer,cstring sdl2: loadFunction(handle: pointer; name: cstring): pointer +unloadObject sdl2.html#unloadObject,pointer sdl2: unloadObject(handle: pointer) +logSetAllPriority sdl2.html#logSetAllPriority,LogPriority sdl2: logSetAllPriority(priority: LogPriority) +logSetPriority sdl2.html#logSetPriority,cint,LogPriority sdl2: logSetPriority(category: cint; priority: LogPriority) +logGetPriority sdl2.html#logGetPriority,cint sdl2: logGetPriority(category: cint): LogPriority +logResetPriorities sdl2.html#logResetPriorities sdl2: logResetPriorities() +logVerbose sdl2.html#logVerbose,cint,cstring sdl2: logVerbose(category: cint; fmt: cstring) +logDebug sdl2.html#logDebug,cint,cstring sdl2: logDebug(category: cint; fmt: cstring) +logInfo sdl2.html#logInfo,cint,cstring sdl2: logInfo(category: cint; fmt: cstring) +logWarn sdl2.html#logWarn,cint,cstring sdl2: logWarn(category: cint; fmt: cstring) +logError sdl2.html#logError,cint,cstring sdl2: logError(category: cint; fmt: cstring) +logCritical sdl2.html#logCritical,cint,cstring sdl2: logCritical(category: cint; fmt: cstring) +logMessage sdl2.html#logMessage,cint,LogPriority,cstring sdl2: logMessage(category: cint; priority: LogPriority; fmt: cstring) +logMessageV sdl2.html#logMessageV,cint,LogPriority,cstring,va_list sdl2: logMessageV(category: cint; priority: LogPriority; fmt: cstring; ap: va_list) +logGetOutputFunction sdl2.html#logGetOutputFunction,ptr.LogOutputFunction,ptr.pointer sdl2: logGetOutputFunction(callback: ptr LogOutputFunction; userdata: ptr pointer) +logSetOutputFunction sdl2.html#logSetOutputFunction,LogOutputFunction,pointer sdl2: logSetOutputFunction(callback: LogOutputFunction; userdata: pointer) +showMessageBox sdl2.html#showMessageBox,ptr.MessageBoxData,ptr.cint sdl2: showMessageBox(messageboxdata: ptr MessageBoxData; buttonid: ptr cint): cint +showSimpleMessageBox sdl2.html#showSimpleMessageBox,Uint32,cstring,cstring,ptr.Window sdl2: showSimpleMessageBox(flags: Uint32; title: cstring; message: cstring;\n window: ptr Window): cint +metal_CreateView sdl2.html#metal_CreateView,ptr.Window sdl2: metal_CreateView(window: ptr Window): MetalView +metal_DestroyView sdl2.html#metal_DestroyView,MetalView sdl2: metal_DestroyView(view: MetalView) +getPowerInfo sdl2.html#getPowerInfo,ptr.cint,ptr.cint sdl2: getPowerInfo(secs: ptr cint; pct: ptr cint): PowerState +getNumRenderDrivers sdl2.html#getNumRenderDrivers sdl2: getNumRenderDrivers(): cint +getRenderDriverInfo sdl2.html#getRenderDriverInfo,cint,ptr.RendererInfo sdl2: getRenderDriverInfo(index: cint; info: ptr RendererInfo): cint +createWindowAndRenderer sdl2.html#createWindowAndRenderer,cint,cint,Uint32,ptr.ptr.Window,ptr.ptr.Renderer sdl2: createWindowAndRenderer(width: cint; height: cint; windowFlags: Uint32;\n window: ptr ptr Window; renderer: ptr ptr Renderer): cint +createRenderer sdl2.html#createRenderer,ptr.Window,cint,Uint32 sdl2: createRenderer(window: ptr Window; index: cint; flags: Uint32): ptr Renderer +createSoftwareRenderer sdl2.html#createSoftwareRenderer,ptr.Surface sdl2: createSoftwareRenderer(surface: ptr Surface): ptr Renderer +getRenderer sdl2.html#getRenderer,ptr.Window sdl2: getRenderer(window: ptr Window): ptr Renderer +getRendererInfo sdl2.html#getRendererInfo,ptr.Renderer,ptr.RendererInfo sdl2: getRendererInfo(renderer: ptr Renderer; info: ptr RendererInfo): cint +getRendererOutputSize sdl2.html#getRendererOutputSize,ptr.Renderer,ptr.cint,ptr.cint sdl2: getRendererOutputSize(renderer: ptr Renderer; w: ptr cint; h: ptr cint): cint +createTexture sdl2.html#createTexture,ptr.Renderer,Uint32,cint,cint,cint sdl2: createTexture(renderer: ptr Renderer; format: Uint32; access: cint; w: cint; h: cint): ptr Texture +createTextureFromSurface sdl2.html#createTextureFromSurface,ptr.Renderer,ptr.Surface sdl2: createTextureFromSurface(renderer: ptr Renderer; surface: ptr Surface): ptr Texture +queryTexture sdl2.html#queryTexture,ptr.Texture,ptr.Uint32,ptr.cint,ptr.cint,ptr.cint sdl2: queryTexture(texture: ptr Texture; format: ptr Uint32; access: ptr cint; w: ptr cint;\n h: ptr cint): cint +setTextureColorMod sdl2.html#setTextureColorMod,ptr.Texture,Uint8,Uint8,Uint8 sdl2: setTextureColorMod(texture: ptr Texture; r: Uint8; g: Uint8; b: Uint8): cint +getTextureColorMod sdl2.html#getTextureColorMod,ptr.Texture,ptr.Uint8,ptr.Uint8,ptr.Uint8 sdl2: getTextureColorMod(texture: ptr Texture; r: ptr Uint8; g: ptr Uint8; b: ptr Uint8): cint +setTextureAlphaMod sdl2.html#setTextureAlphaMod,ptr.Texture,Uint8 sdl2: setTextureAlphaMod(texture: ptr Texture; alpha: Uint8): cint +getTextureAlphaMod sdl2.html#getTextureAlphaMod,ptr.Texture,ptr.Uint8 sdl2: getTextureAlphaMod(texture: ptr Texture; alpha: ptr Uint8): cint +setTextureBlendMode sdl2.html#setTextureBlendMode,ptr.Texture,BlendMode sdl2: setTextureBlendMode(texture: ptr Texture; blendMode: BlendMode): cint +getTextureBlendMode sdl2.html#getTextureBlendMode,ptr.Texture,ptr.BlendMode sdl2: getTextureBlendMode(texture: ptr Texture; blendMode: ptr BlendMode): cint +setTextureScaleMode sdl2.html#setTextureScaleMode,ptr.Texture,ScaleMode sdl2: setTextureScaleMode(texture: ptr Texture; scaleMode: ScaleMode): cint +getTextureScaleMode sdl2.html#getTextureScaleMode,ptr.Texture,ptr.ScaleMode sdl2: getTextureScaleMode(texture: ptr Texture; scaleMode: ptr ScaleMode): cint +updateTexture sdl2.html#updateTexture,ptr.Texture,ptr.Rect,pointer,cint sdl2: updateTexture(texture: ptr Texture; rect: ptr Rect; pixels: pointer; pitch: cint): cint +updateYUVTexture sdl2.html#updateYUVTexture,ptr.Texture,ptr.Rect,ptr.Uint8,cint,ptr.Uint8,cint,ptr.Uint8,cint sdl2: updateYUVTexture(texture: ptr Texture; rect: ptr Rect; Yplane: ptr Uint8; Ypitch: cint;\n Uplane: ptr Uint8; Upitch: cint; Vplane: ptr Uint8; Vpitch: cint): cint +lockTexture sdl2.html#lockTexture,ptr.Texture,ptr.Rect,ptr.pointer,ptr.cint sdl2: lockTexture(texture: ptr Texture; rect: ptr Rect; pixels: ptr pointer; pitch: ptr cint): cint +lockTextureToSurface sdl2.html#lockTextureToSurface,ptr.Texture,ptr.Rect,ptr.ptr.Surface sdl2: lockTextureToSurface(texture: ptr Texture; rect: ptr Rect; surface: ptr ptr Surface): cint +unlockTexture sdl2.html#unlockTexture,ptr.Texture sdl2: unlockTexture(texture: ptr Texture) +renderTargetSupported sdl2.html#renderTargetSupported,ptr.Renderer sdl2: renderTargetSupported(renderer: ptr Renderer): bool +setRenderTarget sdl2.html#setRenderTarget,ptr.Renderer,ptr.Texture sdl2: setRenderTarget(renderer: ptr Renderer; texture: ptr Texture): cint +getRenderTarget sdl2.html#getRenderTarget,ptr.Renderer sdl2: getRenderTarget(renderer: ptr Renderer): ptr Texture +renderSetLogicalSize sdl2.html#renderSetLogicalSize,ptr.Renderer,cint,cint sdl2: renderSetLogicalSize(renderer: ptr Renderer; w: cint; h: cint): cint +renderGetLogicalSize sdl2.html#renderGetLogicalSize,ptr.Renderer,ptr.cint,ptr.cint sdl2: renderGetLogicalSize(renderer: ptr Renderer; w: ptr cint; h: ptr cint) +renderSetIntegerScale sdl2.html#renderSetIntegerScale,ptr.Renderer,bool sdl2: renderSetIntegerScale(renderer: ptr Renderer; enable: bool): cint +renderGetIntegerScale sdl2.html#renderGetIntegerScale,ptr.Renderer sdl2: renderGetIntegerScale(renderer: ptr Renderer): bool +renderSetViewport sdl2.html#renderSetViewport,ptr.Renderer,ptr.Rect sdl2: renderSetViewport(renderer: ptr Renderer; rect: ptr Rect): cint +renderGetViewport sdl2.html#renderGetViewport,ptr.Renderer,ptr.Rect sdl2: renderGetViewport(renderer: ptr Renderer; rect: ptr Rect) +renderSetClipRect sdl2.html#renderSetClipRect,ptr.Renderer,ptr.Rect sdl2: renderSetClipRect(renderer: ptr Renderer; rect: ptr Rect): cint +renderGetClipRect sdl2.html#renderGetClipRect,ptr.Renderer,ptr.Rect sdl2: renderGetClipRect(renderer: ptr Renderer; rect: ptr Rect) +renderIsClipEnabled sdl2.html#renderIsClipEnabled,ptr.Renderer sdl2: renderIsClipEnabled(renderer: ptr Renderer): bool +renderSetScale sdl2.html#renderSetScale,ptr.Renderer,cfloat,cfloat sdl2: renderSetScale(renderer: ptr Renderer; scaleX: cfloat; scaleY: cfloat): cint +renderGetScale sdl2.html#renderGetScale,ptr.Renderer,ptr.cfloat,ptr.cfloat sdl2: renderGetScale(renderer: ptr Renderer; scaleX: ptr cfloat; scaleY: ptr cfloat) +setRenderDrawColor sdl2.html#setRenderDrawColor,ptr.Renderer,Uint8,Uint8,Uint8,Uint8 sdl2: setRenderDrawColor(renderer: ptr Renderer; r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint +getRenderDrawColor sdl2.html#getRenderDrawColor,ptr.Renderer,ptr.Uint8,ptr.Uint8,ptr.Uint8,ptr.Uint8 sdl2: getRenderDrawColor(renderer: ptr Renderer; r: ptr Uint8; g: ptr Uint8; b: ptr Uint8;\n a: ptr Uint8): cint +setRenderDrawBlendMode sdl2.html#setRenderDrawBlendMode,ptr.Renderer,BlendMode sdl2: setRenderDrawBlendMode(renderer: ptr Renderer; blendMode: BlendMode): cint +getRenderDrawBlendMode sdl2.html#getRenderDrawBlendMode,ptr.Renderer,ptr.BlendMode sdl2: getRenderDrawBlendMode(renderer: ptr Renderer; blendMode: ptr BlendMode): cint +renderClear sdl2.html#renderClear,ptr.Renderer sdl2: renderClear(renderer: ptr Renderer): cint +renderDrawPoint sdl2.html#renderDrawPoint,ptr.Renderer,cint,cint sdl2: renderDrawPoint(renderer: ptr Renderer; x: cint; y: cint): cint +renderDrawPoints sdl2.html#renderDrawPoints,ptr.Renderer,ptr.Point,cint sdl2: renderDrawPoints(renderer: ptr Renderer; points: ptr Point; count: cint): cint +renderDrawLine sdl2.html#renderDrawLine,ptr.Renderer,cint,cint,cint,cint sdl2: renderDrawLine(renderer: ptr Renderer; x1: cint; y1: cint; x2: cint; y2: cint): cint +renderDrawLines sdl2.html#renderDrawLines,ptr.Renderer,ptr.Point,cint sdl2: renderDrawLines(renderer: ptr Renderer; points: ptr Point; count: cint): cint +renderDrawRect sdl2.html#renderDrawRect,ptr.Renderer,ptr.Rect sdl2: renderDrawRect(renderer: ptr Renderer; rect: ptr Rect): cint +renderDrawRects sdl2.html#renderDrawRects,ptr.Renderer,ptr.Rect,cint sdl2: renderDrawRects(renderer: ptr Renderer; rects: ptr Rect; count: cint): cint +renderFillRect sdl2.html#renderFillRect,ptr.Renderer,ptr.Rect sdl2: renderFillRect(renderer: ptr Renderer; rect: ptr Rect): cint +renderFillRects sdl2.html#renderFillRects,ptr.Renderer,ptr.Rect,cint sdl2: renderFillRects(renderer: ptr Renderer; rects: ptr Rect; count: cint): cint +renderCopy sdl2.html#renderCopy,ptr.Renderer,ptr.Texture,ptr.Rect,ptr.Rect sdl2: renderCopy(renderer: ptr Renderer; texture: ptr Texture; srcrect: ptr Rect;\n dstrect: ptr Rect): cint +renderCopyEx sdl2.html#renderCopyEx,ptr.Renderer,ptr.Texture,ptr.Rect,ptr.Rect,cdouble,ptr.Point,RendererFlip sdl2: renderCopyEx(renderer: ptr Renderer; texture: ptr Texture; srcrect: ptr Rect;\n dstrect: ptr Rect; angle: cdouble; center: ptr Point; flip: RendererFlip): cint +renderDrawPointF sdl2.html#renderDrawPointF,ptr.Renderer,cfloat,cfloat sdl2: renderDrawPointF(renderer: ptr Renderer; x: cfloat; y: cfloat): cint +renderDrawPointsF sdl2.html#renderDrawPointsF,ptr.Renderer,ptr.FPoint,cint sdl2: renderDrawPointsF(renderer: ptr Renderer; points: ptr FPoint; count: cint): cint +renderDrawLineF sdl2.html#renderDrawLineF,ptr.Renderer,cfloat,cfloat,cfloat,cfloat sdl2: renderDrawLineF(renderer: ptr Renderer; x1: cfloat; y1: cfloat; x2: cfloat; y2: cfloat): cint +renderDrawLinesF sdl2.html#renderDrawLinesF,ptr.Renderer,ptr.FPoint,cint sdl2: renderDrawLinesF(renderer: ptr Renderer; points: ptr FPoint; count: cint): cint +renderDrawRectF sdl2.html#renderDrawRectF,ptr.Renderer,ptr.FRect sdl2: renderDrawRectF(renderer: ptr Renderer; rect: ptr FRect): cint +renderDrawRectsF sdl2.html#renderDrawRectsF,ptr.Renderer,ptr.FRect,cint sdl2: renderDrawRectsF(renderer: ptr Renderer; rects: ptr FRect; count: cint): cint +renderFillRectF sdl2.html#renderFillRectF,ptr.Renderer,ptr.FRect sdl2: renderFillRectF(renderer: ptr Renderer; rect: ptr FRect): cint +renderFillRectsF sdl2.html#renderFillRectsF,ptr.Renderer,ptr.FRect,cint sdl2: renderFillRectsF(renderer: ptr Renderer; rects: ptr FRect; count: cint): cint +renderCopyF sdl2.html#renderCopyF,ptr.Renderer,ptr.Texture,ptr.Rect,ptr.FRect sdl2: renderCopyF(renderer: ptr Renderer; texture: ptr Texture; srcrect: ptr Rect;\n dstrect: ptr FRect): cint +renderCopyExF sdl2.html#renderCopyExF,ptr.Renderer,ptr.Texture,ptr.Rect,ptr.FRect,cdouble,ptr.FPoint,RendererFlip sdl2: renderCopyExF(renderer: ptr Renderer; texture: ptr Texture; srcrect: ptr Rect;\n dstrect: ptr FRect; angle: cdouble; center: ptr FPoint; flip: RendererFlip): cint +renderReadPixels sdl2.html#renderReadPixels,ptr.Renderer,ptr.Rect,Uint32,pointer,cint sdl2: renderReadPixels(renderer: ptr Renderer; rect: ptr Rect; format: Uint32;\n pixels: pointer; pitch: cint): cint +renderPresent sdl2.html#renderPresent,ptr.Renderer sdl2: renderPresent(renderer: ptr Renderer) +destroyTexture sdl2.html#destroyTexture,ptr.Texture sdl2: destroyTexture(texture: ptr Texture) +destroyRenderer sdl2.html#destroyRenderer,ptr.Renderer sdl2: destroyRenderer(renderer: ptr Renderer) +renderFlush sdl2.html#renderFlush,ptr.Renderer sdl2: renderFlush(renderer: ptr Renderer): cint +gL_BindTexture sdl2.html#gL_BindTexture,ptr.Texture,ptr.cfloat,ptr.cfloat sdl2: gL_BindTexture(texture: ptr Texture; texw: ptr cfloat; texh: ptr cfloat): cint +gL_UnbindTexture sdl2.html#gL_UnbindTexture,ptr.Texture sdl2: gL_UnbindTexture(texture: ptr Texture): cint +renderGetMetalLayer sdl2.html#renderGetMetalLayer,ptr.Renderer sdl2: renderGetMetalLayer(renderer: ptr Renderer): pointer +renderGetMetalCommandEncoder sdl2.html#renderGetMetalCommandEncoder,ptr.Renderer sdl2: renderGetMetalCommandEncoder(renderer: ptr Renderer): pointer +numSensors sdl2.html#numSensors sdl2: numSensors(): cint +sensorGetDeviceName sdl2.html#sensorGetDeviceName,cint sdl2: sensorGetDeviceName(deviceIndex: cint): cstring +sensorGetDeviceType sdl2.html#sensorGetDeviceType,cint sdl2: sensorGetDeviceType(deviceIndex: cint): SensorType +sensorGetDeviceNonPortableType sdl2.html#sensorGetDeviceNonPortableType,cint sdl2: sensorGetDeviceNonPortableType(deviceIndex: cint): cint +sensorGetDeviceInstanceID sdl2.html#sensorGetDeviceInstanceID,cint sdl2: sensorGetDeviceInstanceID(deviceIndex: cint): SensorID +sensorOpen sdl2.html#sensorOpen,cint sdl2: sensorOpen(deviceIndex: cint): ptr Sensor +sensorFromInstanceID sdl2.html#sensorFromInstanceID,SensorID sdl2: sensorFromInstanceID(instanceId: SensorID): ptr Sensor +sensorGetName sdl2.html#sensorGetName,ptr.Sensor sdl2: sensorGetName(sensor: ptr Sensor): cstring +sensorGetType sdl2.html#sensorGetType,ptr.Sensor sdl2: sensorGetType(sensor: ptr Sensor): SensorType +sensorGetNonPortableType sdl2.html#sensorGetNonPortableType,ptr.Sensor sdl2: sensorGetNonPortableType(sensor: ptr Sensor): cint +sensorGetInstanceID sdl2.html#sensorGetInstanceID,ptr.Sensor sdl2: sensorGetInstanceID(sensor: ptr Sensor): SensorID +sensorGetData sdl2.html#sensorGetData,ptr.Sensor,ptr.cfloat,cint sdl2: sensorGetData(sensor: ptr Sensor; data: ptr cfloat; numValues: cint): cint +sensorClose sdl2.html#sensorClose,ptr.Sensor sdl2: sensorClose(sensor: ptr Sensor) +sensorUpdate sdl2.html#sensorUpdate sdl2: sensorUpdate() +createShapedWindow sdl2.html#createShapedWindow,cstring,cuint,cuint,cuint,cuint,Uint32 sdl2: createShapedWindow(title: cstring; x: cuint; y: cuint; w: cuint; h: cuint; flags: Uint32): ptr Window +isShapedWindow sdl2.html#isShapedWindow,ptr.Window sdl2: isShapedWindow(window: ptr Window): bool +setWindowShape sdl2.html#setWindowShape,ptr.Window,ptr.Surface,ptr.WindowShapeMode sdl2: setWindowShape(window: ptr Window; shape: ptr Surface; shapeMode: ptr WindowShapeMode): cint +getShapedWindowMode sdl2.html#getShapedWindowMode,ptr.Window,ptr.WindowShapeMode sdl2: getShapedWindowMode(window: ptr Window; shapeMode: ptr WindowShapeMode): cint +isTablet sdl2.html#isTablet sdl2: isTablet(): bool +onApplicationWillTerminate sdl2.html#onApplicationWillTerminate sdl2: onApplicationWillTerminate() +onApplicationDidReceiveMemoryWarning sdl2.html#onApplicationDidReceiveMemoryWarning sdl2: onApplicationDidReceiveMemoryWarning() +onApplicationWillResignActive sdl2.html#onApplicationWillResignActive sdl2: onApplicationWillResignActive() +onApplicationDidEnterBackground sdl2.html#onApplicationDidEnterBackground sdl2: onApplicationDidEnterBackground() +onApplicationWillEnterForeground sdl2.html#onApplicationWillEnterForeground sdl2: onApplicationWillEnterForeground() +onApplicationDidBecomeActive sdl2.html#onApplicationDidBecomeActive sdl2: onApplicationDidBecomeActive() +getTicks sdl2.html#getTicks sdl2: getTicks(): Uint32 +getPerformanceCounter sdl2.html#getPerformanceCounter sdl2: getPerformanceCounter(): Uint64 +getPerformanceFrequency sdl2.html#getPerformanceFrequency sdl2: getPerformanceFrequency(): Uint64 +delay sdl2.html#delay,Uint32 sdl2: delay(ms: Uint32) +addTimer sdl2.html#addTimer,Uint32,TimerCallback,pointer sdl2: addTimer(interval: Uint32; callback: TimerCallback; param: pointer): TimerID +removeTimer sdl2.html#removeTimer,TimerID sdl2: removeTimer(id: TimerID): bool +getVersion sdl2.html#getVersion,ptr.Version sdl2: getVersion(ver: ptr Version) +getRevision sdl2.html#getRevision sdl2: getRevision(): cstring +getRevisionNumber sdl2.html#getRevisionNumber sdl2: getRevisionNumber(): cint +init sdl2.html#init,Uint32 sdl2: init(flags: Uint32): cint +initSubSystem sdl2.html#initSubSystem,Uint32 sdl2: initSubSystem(flags: Uint32): cint +quitSubSystem sdl2.html#quitSubSystem,Uint32 sdl2: quitSubSystem(flags: Uint32) +wasInit sdl2.html#wasInit,Uint32 sdl2: wasInit(flags: Uint32): Uint32 +quit sdl2.html#quit sdl2: quit() +SDLDyLibPath sdl2.html#SDLDyLibPath sdl2: SDLDyLibPath +SDLMainLib sdl2.html#SDLMainLib sdl2: SDLMainLib +SDLStaticLib sdl2.html#SDLStaticLib sdl2: SDLStaticLib +WINDOWPOS_UNDEFINED sdl2.html#WINDOWPOS_UNDEFINED sdl2: WINDOWPOS_UNDEFINED +WINDOWPOS_CENTERED sdl2.html#WINDOWPOS_CENTERED sdl2: WINDOWPOS_CENTERED +SCANCODE_MASK sdl2.html#SCANCODE_MASK sdl2: SCANCODE_MASK +BUTTON_LMASK sdl2.html#BUTTON_LMASK sdl2: BUTTON_LMASK +BUTTON_MMASK sdl2.html#BUTTON_MMASK sdl2: BUTTON_MMASK +BUTTON_RMASK sdl2.html#BUTTON_RMASK sdl2: BUTTON_RMASK +BUTTON_X1MASK sdl2.html#BUTTON_X1MASK sdl2: BUTTON_X1MASK +BUTTON_X2MASK sdl2.html#BUTTON_X2MASK sdl2: BUTTON_X2MASK diff --git a/docs/sdl2/dochack.js b/docs/sdl2/dochack.js new file mode 100644 index 0000000..6f0a993 --- /dev/null +++ b/docs/sdl2/dochack.js @@ -0,0 +1,1961 @@ +/* Generated by the Nim Compiler v1.3.1 */ +var framePtr = null; +var excHandler = 0; +var lastJSError = null; +if (typeof Int8Array === 'undefined') Int8Array = Array; +if (typeof Int16Array === 'undefined') Int16Array = Array; +if (typeof Int32Array === 'undefined') Int32Array = Array; +if (typeof Uint8Array === 'undefined') Uint8Array = Array; +if (typeof Uint16Array === 'undefined') Uint16Array = Array; +if (typeof Uint32Array === 'undefined') Uint32Array = Array; +if (typeof Float32Array === 'undefined') Float32Array = Array; +if (typeof Float64Array === 'undefined') Float64Array = Array; +var NTI1163065 = {size: 0,kind: 1,base: null,node: null,finalizer: null}; +var NTI10846058 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI1169053 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI11000571 = {size: 0,kind: 24,base: null,node: null,finalizer: null}; +var NTI1787454 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787450 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787446 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787442 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787438 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787434 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787430 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787426 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787422 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787418 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787414 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787410 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787406 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787402 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787398 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787394 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787390 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787386 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787382 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787378 = {size: 0,kind: 25,base: null,node: null,finalizer: null}; +var NTI1787205 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI1787289 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI1787287 = {size: 0,kind: 22,base: null,node: null,finalizer: null}; +var NTI1787229 = {size: 0, kind: 14, base: null, node: null, finalizer: null}; +var NTI1787574 = {size: 0,kind: 24,base: null,node: null,finalizer: null}; +var NTI1787572 = {size: 0,kind: 24,base: null,node: null,finalizer: null}; +var NTI1787570 = {size: 0,kind: 24,base: null,node: null,finalizer: null}; +var NTI1787233 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI1787231 = {size: 0,kind: 22,base: null,node: null,finalizer: null}; +var NTI1789105 = {size: 0,kind: 24,base: null,node: null,finalizer: null}; +var NTI1169041 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI1169049 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI1163045 = {size: 0,kind: 31,base: null,node: null,finalizer: null}; +var NTI1325043 = {size: 0, kind: 18, base: null, node: null, finalizer: null}; +var NTI1168808 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI1169086 = {size: 0,kind: 22,base: null,node: null,finalizer: null}; +var NTI1163014 = {size: 0,kind: 28,base: null,node: null,finalizer: null}; +var NTI1163016 = {size: 0,kind: 29,base: null,node: null,finalizer: null}; +var NTI1169081 = {size: 0,kind: 22,base: null,node: null,finalizer: null}; +var NTI1169017 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI1169019 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI1169033 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NTI1169037 = {size: 0, kind: 17, base: null, node: null, finalizer: null}; +var NNI1169037 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI1169037.node = NNI1169037; +var NNI1169033 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI1169033.node = NNI1169033; +var NNI1169019 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI1169019.node = NNI1169019; +NTI1169081.base = NTI1169017; +NTI1169086.base = NTI1169017; +var NNI1169017 = {kind: 2, len: 5, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "parent", len: 0, typ: NTI1169081, name: "parent", sons: null}, +{kind: 1, offset: "name", len: 0, typ: NTI1163016, name: "name", sons: null}, +{kind: 1, offset: "message", len: 0, typ: NTI1163014, name: "msg", sons: null}, +{kind: 1, offset: "trace", len: 0, typ: NTI1163014, name: "trace", sons: null}, +{kind: 1, offset: "up", len: 0, typ: NTI1169086, name: "up", sons: null}]}; +NTI1169017.node = NNI1169017; +var NNI1168808 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI1168808.node = NNI1168808; +NTI1169017.base = NTI1168808; +NTI1169019.base = NTI1169017; +NTI1169033.base = NTI1169019; +NTI1169037.base = NTI1169033; +var NNI1325043 = {kind: 2, len: 2, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "Field0", len: 0, typ: NTI1163016, name: "Field0", sons: null}, +{kind: 1, offset: "Field1", len: 0, typ: NTI1163045, name: "Field1", sons: null}]}; +NTI1325043.node = NNI1325043; +var NNI1169049 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI1169049.node = NNI1169049; +NTI1169049.base = NTI1169019; +var NNI1169041 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI1169041.node = NNI1169041; +NTI1169041.base = NTI1169019; +NTI1787570.base = NTI1787231; +NTI1787572.base = NTI1787231; +NTI1787574.base = NTI1787231; +var NNI1787229 = {kind: 2, offset: 0, typ: null, name: null, len: 12, sons: {"1": {kind: 1, offset: 1, typ: NTI1787229, name: "ElementNode", len: 0, sons: null}, +"2": {kind: 1, offset: 2, typ: NTI1787229, name: "AttributeNode", len: 0, sons: null}, +"3": {kind: 1, offset: 3, typ: NTI1787229, name: "TextNode", len: 0, sons: null}, +"4": {kind: 1, offset: 4, typ: NTI1787229, name: "CDATANode", len: 0, sons: null}, +"5": {kind: 1, offset: 5, typ: NTI1787229, name: "EntityRefNode", len: 0, sons: null}, +"6": {kind: 1, offset: 6, typ: NTI1787229, name: "EntityNode", len: 0, sons: null}, +"7": {kind: 1, offset: 7, typ: NTI1787229, name: "ProcessingInstructionNode", len: 0, sons: null}, +"8": {kind: 1, offset: 8, typ: NTI1787229, name: "CommentNode", len: 0, sons: null}, +"9": {kind: 1, offset: 9, typ: NTI1787229, name: "DocumentNode", len: 0, sons: null}, +"10": {kind: 1, offset: 10, typ: NTI1787229, name: "DocumentTypeNode", len: 0, sons: null}, +"11": {kind: 1, offset: 11, typ: NTI1787229, name: "DocumentFragmentNode", len: 0, sons: null}, +"12": {kind: 1, offset: 12, typ: NTI1787229, name: "NotationNode", len: 0, sons: null}}}; +NTI1787229.node = NNI1787229; +var NNI1787289 = {kind: 2, len: 100, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "background", len: 0, typ: NTI1163016, name: "background", sons: null}, +{kind: 1, offset: "backgroundAttachment", len: 0, typ: NTI1163016, name: "backgroundAttachment", sons: null}, +{kind: 1, offset: "backgroundColor", len: 0, typ: NTI1163016, name: "backgroundColor", sons: null}, +{kind: 1, offset: "backgroundImage", len: 0, typ: NTI1163016, name: "backgroundImage", sons: null}, +{kind: 1, offset: "backgroundPosition", len: 0, typ: NTI1163016, name: "backgroundPosition", sons: null}, +{kind: 1, offset: "backgroundRepeat", len: 0, typ: NTI1163016, name: "backgroundRepeat", sons: null}, +{kind: 1, offset: "backgroundSize", len: 0, typ: NTI1163016, name: "backgroundSize", sons: null}, +{kind: 1, offset: "border", len: 0, typ: NTI1163016, name: "border", sons: null}, +{kind: 1, offset: "borderBottom", len: 0, typ: NTI1163016, name: "borderBottom", sons: null}, +{kind: 1, offset: "borderBottomColor", len: 0, typ: NTI1163016, name: "borderBottomColor", sons: null}, +{kind: 1, offset: "borderBottomStyle", len: 0, typ: NTI1163016, name: "borderBottomStyle", sons: null}, +{kind: 1, offset: "borderBottomWidth", len: 0, typ: NTI1163016, name: "borderBottomWidth", sons: null}, +{kind: 1, offset: "borderColor", len: 0, typ: NTI1163016, name: "borderColor", sons: null}, +{kind: 1, offset: "borderLeft", len: 0, typ: NTI1163016, name: "borderLeft", sons: null}, +{kind: 1, offset: "borderLeftColor", len: 0, typ: NTI1163016, name: "borderLeftColor", sons: null}, +{kind: 1, offset: "borderLeftStyle", len: 0, typ: NTI1163016, name: "borderLeftStyle", sons: null}, +{kind: 1, offset: "borderLeftWidth", len: 0, typ: NTI1163016, name: "borderLeftWidth", sons: null}, +{kind: 1, offset: "borderRadius", len: 0, typ: NTI1163016, name: "borderRadius", sons: null}, +{kind: 1, offset: "borderRight", len: 0, typ: NTI1163016, name: "borderRight", sons: null}, +{kind: 1, offset: "borderRightColor", len: 0, typ: NTI1163016, name: "borderRightColor", sons: null}, +{kind: 1, offset: "borderRightStyle", len: 0, typ: NTI1163016, name: "borderRightStyle", sons: null}, +{kind: 1, offset: "borderRightWidth", len: 0, typ: NTI1163016, name: "borderRightWidth", sons: null}, +{kind: 1, offset: "borderStyle", len: 0, typ: NTI1163016, name: "borderStyle", sons: null}, +{kind: 1, offset: "borderTop", len: 0, typ: NTI1163016, name: "borderTop", sons: null}, +{kind: 1, offset: "borderTopColor", len: 0, typ: NTI1163016, name: "borderTopColor", sons: null}, +{kind: 1, offset: "borderTopStyle", len: 0, typ: NTI1163016, name: "borderTopStyle", sons: null}, +{kind: 1, offset: "borderTopWidth", len: 0, typ: NTI1163016, name: "borderTopWidth", sons: null}, +{kind: 1, offset: "borderWidth", len: 0, typ: NTI1163016, name: "borderWidth", sons: null}, +{kind: 1, offset: "bottom", len: 0, typ: NTI1163016, name: "bottom", sons: null}, +{kind: 1, offset: "boxSizing", len: 0, typ: NTI1163016, name: "boxSizing", sons: null}, +{kind: 1, offset: "boxShadow", len: 0, typ: NTI1163016, name: "boxShadow", sons: null}, +{kind: 1, offset: "captionSide", len: 0, typ: NTI1163016, name: "captionSide", sons: null}, +{kind: 1, offset: "clear", len: 0, typ: NTI1163016, name: "clear", sons: null}, +{kind: 1, offset: "clip", len: 0, typ: NTI1163016, name: "clip", sons: null}, +{kind: 1, offset: "color", len: 0, typ: NTI1163016, name: "color", sons: null}, +{kind: 1, offset: "cursor", len: 0, typ: NTI1163016, name: "cursor", sons: null}, +{kind: 1, offset: "direction", len: 0, typ: NTI1163016, name: "direction", sons: null}, +{kind: 1, offset: "display", len: 0, typ: NTI1163016, name: "display", sons: null}, +{kind: 1, offset: "emptyCells", len: 0, typ: NTI1163016, name: "emptyCells", sons: null}, +{kind: 1, offset: "cssFloat", len: 0, typ: NTI1163016, name: "cssFloat", sons: null}, +{kind: 1, offset: "font", len: 0, typ: NTI1163016, name: "font", sons: null}, +{kind: 1, offset: "fontFamily", len: 0, typ: NTI1163016, name: "fontFamily", sons: null}, +{kind: 1, offset: "fontSize", len: 0, typ: NTI1163016, name: "fontSize", sons: null}, +{kind: 1, offset: "fontStretch", len: 0, typ: NTI1163016, name: "fontStretch", sons: null}, +{kind: 1, offset: "fontStyle", len: 0, typ: NTI1163016, name: "fontStyle", sons: null}, +{kind: 1, offset: "fontVariant", len: 0, typ: NTI1163016, name: "fontVariant", sons: null}, +{kind: 1, offset: "fontWeight", len: 0, typ: NTI1163016, name: "fontWeight", sons: null}, +{kind: 1, offset: "height", len: 0, typ: NTI1163016, name: "height", sons: null}, +{kind: 1, offset: "left", len: 0, typ: NTI1163016, name: "left", sons: null}, +{kind: 1, offset: "letterSpacing", len: 0, typ: NTI1163016, name: "letterSpacing", sons: null}, +{kind: 1, offset: "lineHeight", len: 0, typ: NTI1163016, name: "lineHeight", sons: null}, +{kind: 1, offset: "listStyle", len: 0, typ: NTI1163016, name: "listStyle", sons: null}, +{kind: 1, offset: "listStyleImage", len: 0, typ: NTI1163016, name: "listStyleImage", sons: null}, +{kind: 1, offset: "listStylePosition", len: 0, typ: NTI1163016, name: "listStylePosition", sons: null}, +{kind: 1, offset: "listStyleType", len: 0, typ: NTI1163016, name: "listStyleType", sons: null}, +{kind: 1, offset: "margin", len: 0, typ: NTI1163016, name: "margin", sons: null}, +{kind: 1, offset: "marginBottom", len: 0, typ: NTI1163016, name: "marginBottom", sons: null}, +{kind: 1, offset: "marginLeft", len: 0, typ: NTI1163016, name: "marginLeft", sons: null}, +{kind: 1, offset: "marginRight", len: 0, typ: NTI1163016, name: "marginRight", sons: null}, +{kind: 1, offset: "marginTop", len: 0, typ: NTI1163016, name: "marginTop", sons: null}, +{kind: 1, offset: "maxHeight", len: 0, typ: NTI1163016, name: "maxHeight", sons: null}, +{kind: 1, offset: "maxWidth", len: 0, typ: NTI1163016, name: "maxWidth", sons: null}, +{kind: 1, offset: "minHeight", len: 0, typ: NTI1163016, name: "minHeight", sons: null}, +{kind: 1, offset: "minWidth", len: 0, typ: NTI1163016, name: "minWidth", sons: null}, +{kind: 1, offset: "opacity", len: 0, typ: NTI1163016, name: "opacity", sons: null}, +{kind: 1, offset: "outline", len: 0, typ: NTI1163016, name: "outline", sons: null}, +{kind: 1, offset: "overflow", len: 0, typ: NTI1163016, name: "overflow", sons: null}, +{kind: 1, offset: "overflowX", len: 0, typ: NTI1163016, name: "overflowX", sons: null}, +{kind: 1, offset: "overflowY", len: 0, typ: NTI1163016, name: "overflowY", sons: null}, +{kind: 1, offset: "padding", len: 0, typ: NTI1163016, name: "padding", sons: null}, +{kind: 1, offset: "paddingBottom", len: 0, typ: NTI1163016, name: "paddingBottom", sons: null}, +{kind: 1, offset: "paddingLeft", len: 0, typ: NTI1163016, name: "paddingLeft", sons: null}, +{kind: 1, offset: "paddingRight", len: 0, typ: NTI1163016, name: "paddingRight", sons: null}, +{kind: 1, offset: "paddingTop", len: 0, typ: NTI1163016, name: "paddingTop", sons: null}, +{kind: 1, offset: "pageBreakAfter", len: 0, typ: NTI1163016, name: "pageBreakAfter", sons: null}, +{kind: 1, offset: "pageBreakBefore", len: 0, typ: NTI1163016, name: "pageBreakBefore", sons: null}, +{kind: 1, offset: "pointerEvents", len: 0, typ: NTI1163016, name: "pointerEvents", sons: null}, +{kind: 1, offset: "position", len: 0, typ: NTI1163016, name: "position", sons: null}, +{kind: 1, offset: "resize", len: 0, typ: NTI1163016, name: "resize", sons: null}, +{kind: 1, offset: "right", len: 0, typ: NTI1163016, name: "right", sons: null}, +{kind: 1, offset: "scrollbar3dLightColor", len: 0, typ: NTI1163016, name: "scrollbar3dLightColor", sons: null}, +{kind: 1, offset: "scrollbarArrowColor", len: 0, typ: NTI1163016, name: "scrollbarArrowColor", sons: null}, +{kind: 1, offset: "scrollbarBaseColor", len: 0, typ: NTI1163016, name: "scrollbarBaseColor", sons: null}, +{kind: 1, offset: "scrollbarDarkshadowColor", len: 0, typ: NTI1163016, name: "scrollbarDarkshadowColor", sons: null}, +{kind: 1, offset: "scrollbarFaceColor", len: 0, typ: NTI1163016, name: "scrollbarFaceColor", sons: null}, +{kind: 1, offset: "scrollbarHighlightColor", len: 0, typ: NTI1163016, name: "scrollbarHighlightColor", sons: null}, +{kind: 1, offset: "scrollbarShadowColor", len: 0, typ: NTI1163016, name: "scrollbarShadowColor", sons: null}, +{kind: 1, offset: "scrollbarTrackColor", len: 0, typ: NTI1163016, name: "scrollbarTrackColor", sons: null}, +{kind: 1, offset: "tableLayout", len: 0, typ: NTI1163016, name: "tableLayout", sons: null}, +{kind: 1, offset: "textAlign", len: 0, typ: NTI1163016, name: "textAlign", sons: null}, +{kind: 1, offset: "textDecoration", len: 0, typ: NTI1163016, name: "textDecoration", sons: null}, +{kind: 1, offset: "textIndent", len: 0, typ: NTI1163016, name: "textIndent", sons: null}, +{kind: 1, offset: "textTransform", len: 0, typ: NTI1163016, name: "textTransform", sons: null}, +{kind: 1, offset: "transform", len: 0, typ: NTI1163016, name: "transform", sons: null}, +{kind: 1, offset: "top", len: 0, typ: NTI1163016, name: "top", sons: null}, +{kind: 1, offset: "verticalAlign", len: 0, typ: NTI1163016, name: "verticalAlign", sons: null}, +{kind: 1, offset: "visibility", len: 0, typ: NTI1163016, name: "visibility", sons: null}, +{kind: 1, offset: "width", len: 0, typ: NTI1163016, name: "width", sons: null}, +{kind: 1, offset: "wordSpacing", len: 0, typ: NTI1163016, name: "wordSpacing", sons: null}, +{kind: 1, offset: "zIndex", len: 0, typ: NTI1163045, name: "zIndex", sons: null}]}; +NTI1787289.node = NNI1787289; +NTI1787289.base = NTI1168808; +NTI1787287.base = NTI1787289; +var NNI1787233 = {kind: 2, len: 16, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "attributes", len: 0, typ: NTI1787570, name: "attributes", sons: null}, +{kind: 1, offset: "childNodes", len: 0, typ: NTI1787572, name: "childNodes", sons: null}, +{kind: 1, offset: "children", len: 0, typ: NTI1787574, name: "children", sons: null}, +{kind: 1, offset: "data", len: 0, typ: NTI1163016, name: "data", sons: null}, +{kind: 1, offset: "firstChild", len: 0, typ: NTI1787231, name: "firstChild", sons: null}, +{kind: 1, offset: "lastChild", len: 0, typ: NTI1787231, name: "lastChild", sons: null}, +{kind: 1, offset: "nextSibling", len: 0, typ: NTI1787231, name: "nextSibling", sons: null}, +{kind: 1, offset: "nodeName", len: 0, typ: NTI1163016, name: "nodeName", sons: null}, +{kind: 1, offset: "nodeType", len: 0, typ: NTI1787229, name: "nodeType", sons: null}, +{kind: 1, offset: "nodeValue", len: 0, typ: NTI1163016, name: "nodeValue", sons: null}, +{kind: 1, offset: "parentNode", len: 0, typ: NTI1787231, name: "parentNode", sons: null}, +{kind: 1, offset: "previousSibling", len: 0, typ: NTI1787231, name: "previousSibling", sons: null}, +{kind: 1, offset: "innerHTML", len: 0, typ: NTI1163016, name: "innerHTML", sons: null}, +{kind: 1, offset: "innerText", len: 0, typ: NTI1163016, name: "innerText", sons: null}, +{kind: 1, offset: "textContent", len: 0, typ: NTI1163016, name: "textContent", sons: null}, +{kind: 1, offset: "style", len: 0, typ: NTI1787287, name: "style", sons: null}]}; +NTI1787233.node = NNI1787233; +var NNI1787205 = {kind: 2, len: 20, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "onabort", len: 0, typ: NTI1787378, name: "onabort", sons: null}, +{kind: 1, offset: "onblur", len: 0, typ: NTI1787382, name: "onblur", sons: null}, +{kind: 1, offset: "onchange", len: 0, typ: NTI1787386, name: "onchange", sons: null}, +{kind: 1, offset: "onclick", len: 0, typ: NTI1787390, name: "onclick", sons: null}, +{kind: 1, offset: "ondblclick", len: 0, typ: NTI1787394, name: "ondblclick", sons: null}, +{kind: 1, offset: "onerror", len: 0, typ: NTI1787398, name: "onerror", sons: null}, +{kind: 1, offset: "onfocus", len: 0, typ: NTI1787402, name: "onfocus", sons: null}, +{kind: 1, offset: "onkeydown", len: 0, typ: NTI1787406, name: "onkeydown", sons: null}, +{kind: 1, offset: "onkeypress", len: 0, typ: NTI1787410, name: "onkeypress", sons: null}, +{kind: 1, offset: "onkeyup", len: 0, typ: NTI1787414, name: "onkeyup", sons: null}, +{kind: 1, offset: "onload", len: 0, typ: NTI1787418, name: "onload", sons: null}, +{kind: 1, offset: "onmousedown", len: 0, typ: NTI1787422, name: "onmousedown", sons: null}, +{kind: 1, offset: "onmousemove", len: 0, typ: NTI1787426, name: "onmousemove", sons: null}, +{kind: 1, offset: "onmouseout", len: 0, typ: NTI1787430, name: "onmouseout", sons: null}, +{kind: 1, offset: "onmouseover", len: 0, typ: NTI1787434, name: "onmouseover", sons: null}, +{kind: 1, offset: "onmouseup", len: 0, typ: NTI1787438, name: "onmouseup", sons: null}, +{kind: 1, offset: "onreset", len: 0, typ: NTI1787442, name: "onreset", sons: null}, +{kind: 1, offset: "onselect", len: 0, typ: NTI1787446, name: "onselect", sons: null}, +{kind: 1, offset: "onsubmit", len: 0, typ: NTI1787450, name: "onsubmit", sons: null}, +{kind: 1, offset: "onunload", len: 0, typ: NTI1787454, name: "onunload", sons: null}]}; +NTI1787205.node = NNI1787205; +NTI1787205.base = NTI1168808; +NTI1787233.base = NTI1787205; +NTI1787231.base = NTI1787233; +NTI1789105.base = NTI1787231; +NTI11000571.base = NTI1163016; +var NNI1169053 = {kind: 2, len: 0, offset: 0, typ: null, name: null, sons: []}; +NTI1169053.node = NNI1169053; +NTI1169053.base = NTI1169019; +var NNI10846058 = {kind: 2, len: 2, offset: 0, typ: null, name: null, sons: [{kind: 1, offset: "Field0", len: 0, typ: NTI1163045, name: "Field0", sons: null}, +{kind: 1, offset: "Field1", len: 0, typ: NTI1163065, name: "Field1", sons: null}]}; +NTI10846058.node = NNI10846058; +function makeNimstrLit(c_1390062) { + var ln = c_1390062.length; + var result = new Array(ln); + for (var i = 0; i < ln; ++i) { + result[i] = c_1390062.charCodeAt(i); + } + return result; + + + +} +function arrayConstr(len_1415067, value_1415068, typ_1415069) { + var result = new Array(len_1415067); + for (var i = 0; i < len_1415067; ++i) result[i] = nimCopy(null, value_1415068, typ_1415069); + return result; + + + +} +function setConstr() { + var result = {}; + for (var i = 0; i < arguments.length; ++i) { + var x = arguments[i]; + if (typeof(x) == "object") { + for (var j = x[0]; j <= x[1]; ++j) { + result[j] = true; + } + } else { + result[x] = true; + } + } + return result; + + + +} +var ConstSet1 = setConstr(17, 16, 4, 18, 27, 19, 23, 22, 21); +function nimCopy(dest_1405023, src_1405024, ti_1405025) { + var result_1410219 = null; + + switch (ti_1405025.kind) { + case 21: + case 22: + case 23: + case 5: + if (!(is_fat_pointer_1400401(ti_1405025))) { + result_1410219 = src_1405024; + } + else { + result_1410219 = [src_1405024[0], src_1405024[1]]; + } + + break; + case 19: + if (dest_1405023 === null || dest_1405023 === undefined) { + dest_1405023 = {}; + } + else { + for (var key in dest_1405023) { delete dest_1405023[key]; } + } + for (var key in src_1405024) { dest_1405023[key] = src_1405024[key]; } + result_1410219 = dest_1405023; + + break; + case 18: + case 17: + if (!((ti_1405025.base == null))) { + result_1410219 = nimCopy(dest_1405023, src_1405024, ti_1405025.base); + } + else { + if ((ti_1405025.kind == 17)) { + result_1410219 = (dest_1405023 === null || dest_1405023 === undefined) ? {m_type: ti_1405025} : dest_1405023; + } + else { + result_1410219 = (dest_1405023 === null || dest_1405023 === undefined) ? {} : dest_1405023; + } + } + nimCopyAux(result_1410219, src_1405024, ti_1405025.node); + break; + case 24: + case 4: + case 27: + case 16: + if (src_1405024 === null) { + result_1410219 = null; + } + else { + if (dest_1405023 === null || dest_1405023 === undefined) { + dest_1405023 = new Array(src_1405024.length); + } + else { + dest_1405023.length = src_1405024.length; + } + result_1410219 = dest_1405023; + for (var i = 0; i < src_1405024.length; ++i) { + result_1410219[i] = nimCopy(result_1410219[i], src_1405024[i], ti_1405025.base); + } + } + + break; + case 28: + if (src_1405024 !== null) { + result_1410219 = src_1405024.slice(0); + } + + break; + default: + result_1410219 = src_1405024; + break; + } + + return result_1410219; + +} +function cstrToNimstr(c_1390079) { + var ln = c_1390079.length; + var result = new Array(ln); + var r = 0; + for (var i = 0; i < ln; ++i) { + var ch = c_1390079.charCodeAt(i); + + if (ch < 128) { + result[r] = ch; + } + else { + if (ch < 2048) { + result[r] = (ch >> 6) | 192; + } + else { + if (ch < 55296 || ch >= 57344) { + result[r] = (ch >> 12) | 224; + } + else { + ++i; + ch = 65536 + (((ch & 1023) << 10) | (c_1390079.charCodeAt(i) & 1023)); + result[r] = (ch >> 18) | 240; + ++r; + result[r] = ((ch >> 12) & 63) | 128; + } + ++r; + result[r] = ((ch >> 6) & 63) | 128; + } + ++r; + result[r] = (ch & 63) | 128; + } + ++r; + } + return result; + + + +} +function toJSStr(s_1390096) { + var Tmp5; + var Tmp7; + + var result_1390097 = null; + + var res_1390170 = new_seq_1390128((s_1390096 != null ? s_1390096.length : 0)); + var i_1390172 = 0; + var j_1390174 = 0; + L1: do { + L2: while (true) { + if (!(i_1390172 < (s_1390096 != null ? s_1390096.length : 0))) break L2; + var c_1390175 = s_1390096[i_1390172]; + if ((c_1390175 < 128)) { + res_1390170[j_1390174] = String.fromCharCode(c_1390175); + i_1390172 += 1; + } + else { + var helper_1390198 = new_seq_1390128(0); + L3: do { + L4: while (true) { + if (!true) break L4; + var code_1390199 = c_1390175.toString(16); + if (((code_1390199 != null ? code_1390199.length : 0) == 1)) { + if (helper_1390198 != null) { helper_1390198.push("%0"); } else { helper_1390198 = ["%0"]; }; + } + else { + if (helper_1390198 != null) { helper_1390198.push("%"); } else { helper_1390198 = ["%"]; }; + } + + if (helper_1390198 != null) { helper_1390198.push(code_1390199); } else { helper_1390198 = [code_1390199]; }; + i_1390172 += 1; + if (((s_1390096 != null ? s_1390096.length : 0) <= i_1390172)) Tmp5 = true; else { Tmp5 = (s_1390096[i_1390172] < 128); } if (Tmp5) { + break L3; + } + + c_1390175 = s_1390096[i_1390172]; + } + } while(false); +++excHandler; + Tmp7 = framePtr; + try { + res_1390170[j_1390174] = decodeURIComponent(helper_1390198.join("")); +--excHandler; +} catch (EXC) { + var prevJSError = lastJSError; + lastJSError = EXC; + --excHandler; + framePtr = Tmp7; + res_1390170[j_1390174] = helper_1390198.join(""); + lastJSError = prevJSError; + } finally { + framePtr = Tmp7; + } + } + + j_1390174 += 1; + } + } while(false); + if (res_1390170 === null) res_1390170 = []; + if (res_1390170.length < j_1390174) { for (var i=res_1390170.length;i 2147483647 || result < -2147483648) raiseOverflow(); + return result; + + + +} +function chckIndx(i_1415086, a_1415087, b_1415088) { + var Tmp1; + + var result_1415089 = 0; + + BeforeRet: do { + if (!(a_1415087 <= i_1415086)) Tmp1 = false; else { Tmp1 = (i_1415086 <= b_1415088); } if (Tmp1) { + result_1415089 = i_1415086; + break BeforeRet; + } + else { + raiseIndexError(i_1415086, a_1415087, b_1415088); + } + + } while (false); + + return result_1415089; + +} +function subInt(a_1395421, b_1395422) { + var result = a_1395421 - b_1395422; + if (result > 2147483647 || result < -2147483648) raiseOverflow(); + return result; + + + +} +var ConstSet2 = setConstr([65, 90]); +function chckRange(i_1420016, a_1420017, b_1420018) { + var Tmp1; + + var result_1420019 = 0; + + BeforeRet: do { + if (!(a_1420017 <= i_1420016)) Tmp1 = false; else { Tmp1 = (i_1420016 <= b_1420018); } if (Tmp1) { + result_1420019 = i_1420016; + break BeforeRet; + } + else { + raiseRangeError(); + } + + } while (false); + + return result_1420019; + +} +var ConstSet3 = setConstr(95, 32, 46); +var ConstSet4 = setConstr(95, 32, 46); +function mulInt(a_1395439, b_1395440) { + var result = a_1395439 * b_1395440; + if (result > 2147483647 || result < -2147483648) raiseOverflow(); + return result; + + + +} +var ConstSet5 = setConstr([97, 122]); +var ConstSet6 = setConstr([65, 90], [97, 122]); +var ConstSet7 = setConstr([97, 122]); +var ConstSet8 = setConstr([65, 90]); +function nimMax(a_1395821, b_1395822) { + var Tmp1; + + var result_1395823 = 0; + + BeforeRet: do { + if ((b_1395822 <= a_1395821)) { + Tmp1 = a_1395821; + } + else { + Tmp1 = b_1395822; + } + + result_1395823 = Tmp1; + break BeforeRet; + } while (false); + + return result_1395823; + +} +function nimMin(a_1395803, b_1395804) { + var Tmp1; + + var result_1395805 = 0; + + BeforeRet: do { + if ((a_1395803 <= b_1395804)) { + Tmp1 = a_1395803; + } + else { + Tmp1 = b_1395804; + } + + result_1395805 = Tmp1; + break BeforeRet; + } while (false); + + return result_1395805; + +} +var nim_program_result = 0; +var global_raise_hook_1307018 = [null]; +var local_raise_hook_1307023 = [null]; +var out_of_mem_hook_1307026 = [null]; +var unhandled_exception_hook_1307031 = [null]; +if (!Math.trunc) { + Math.trunc = function(v) { + v = +v; + if (!isFinite(v)) return v; + return (v - v % 1) || (v < 0 ? -0 : v === 0 ? v : 0); + }; +} + +var alternative_11000319 = [null]; +function add_1307042(x_1307045, x_1307045_Idx, y_1307046) { + if (x_1307045[x_1307045_Idx] === null) { x_1307045[x_1307045_Idx] = []; } + var off = x_1307045[x_1307045_Idx].length; + x_1307045[x_1307045_Idx].length += y_1307046.length; + for (var i = 0; i < y_1307046.length; ++i) { + x_1307045[x_1307045_Idx][off+i] = y_1307046.charCodeAt(i); + } + + + +} +function is_fat_pointer_1400401(ti_1400403) { + var result_1400404 = false; + + BeforeRet: do { + result_1400404 = !((ConstSet1[ti_1400403.base.kind] != undefined)); + break BeforeRet; + } while (false); + + return result_1400404; + +} +function nimCopyAux(dest_1405028, src_1405029, n_1405031) { + switch (n_1405031.kind) { + case 0: + break; + case 1: + dest_1405028[n_1405031.offset] = nimCopy(dest_1405028[n_1405031.offset], src_1405029[n_1405031.offset], n_1405031.typ); + + break; + case 2: + for (var i = 0; i < n_1405031.sons.length; i++) { + nimCopyAux(dest_1405028, src_1405029, n_1405031.sons[i]); + } + + break; + case 3: + dest_1405028[n_1405031.offset] = nimCopy(dest_1405028[n_1405031.offset], src_1405029[n_1405031.offset], n_1405031.typ); + for (var i = 0; i < n_1405031.sons.length; ++i) { + nimCopyAux(dest_1405028, src_1405029, n_1405031.sons[i][1]); + } + + break; + } + + +} +function aux_write_stack_trace_1325038(f_1325040) { + var Tmp3; + + var result_1325041 = [null]; + + var it_1325049 = f_1325040; + var i_1325051 = 0; + var total_1325053 = 0; + var temp_frames_1325060 = arrayConstr(64, {Field0: null, Field1: 0}, NTI1325043); + L1: do { + L2: while (true) { + if (!!((it_1325049 == null))) Tmp3 = false; else { Tmp3 = (i_1325051 <= 63); } if (!Tmp3) break L2; + temp_frames_1325060[i_1325051].Field0 = it_1325049.procname; + temp_frames_1325060[i_1325051].Field1 = it_1325049.line; + i_1325051 += 1; + total_1325053 += 1; + it_1325049 = it_1325049.prev; + } + } while(false); + L4: do { + L5: while (true) { + if (!!((it_1325049 == null))) break L5; + total_1325053 += 1; + it_1325049 = it_1325049.prev; + } + } while(false); + result_1325041[0] = nimCopy(null, [], NTI1163014); + if (!((total_1325053 == i_1325051))) { + if (result_1325041[0] != null) { result_1325041[0] = (result_1325041[0]).concat(makeNimstrLit("(")); } else { result_1325041[0] = makeNimstrLit("("); }; + if (result_1325041[0] != null) { result_1325041[0] = (result_1325041[0]).concat(cstrToNimstr(((total_1325053 - i_1325051))+"")); } else { result_1325041[0] = cstrToNimstr(((total_1325053 - i_1325051))+"").slice(); }; + if (result_1325041[0] != null) { result_1325041[0] = (result_1325041[0]).concat(makeNimstrLit(" calls omitted) ...\x0A")); } else { result_1325041[0] = makeNimstrLit(" calls omitted) ...\x0A"); }; + } + + L6: do { + var j_1340236 = 0; + var colontmp__11000463 = 0; + colontmp__11000463 = (i_1325051 - 1); + var res_11000468 = colontmp__11000463; + L7: do { + L8: while (true) { + if (!(0 <= res_11000468)) break L8; + j_1340236 = res_11000468; + add_1307042(result_1325041, 0, temp_frames_1325060[j_1340236].Field0); + if ((0 < temp_frames_1325060[j_1340236].Field1)) { + if (result_1325041[0] != null) { result_1325041[0] = (result_1325041[0]).concat(makeNimstrLit(", line: ")); } else { result_1325041[0] = makeNimstrLit(", line: "); }; + if (result_1325041[0] != null) { result_1325041[0] = (result_1325041[0]).concat(cstrToNimstr((temp_frames_1325060[j_1340236].Field1)+"")); } else { result_1325041[0] = cstrToNimstr((temp_frames_1325060[j_1340236].Field1)+"").slice(); }; + } + + if (result_1325041[0] != null) { result_1325041[0] = (result_1325041[0]).concat(makeNimstrLit("\x0A")); } else { result_1325041[0] = makeNimstrLit("\x0A"); }; + res_11000468 -= 1; + } + } while(false); + } while(false); + + return result_1325041[0]; + +} +function raw_write_stack_trace_1345059() { + var result_1345061 = null; + + if (!((framePtr == null))) { + result_1345061 = nimCopy(null, (makeNimstrLit("Traceback (most recent call last)\x0A") || []).concat(aux_write_stack_trace_1325038(framePtr) || []), NTI1163014); + } + else { + result_1345061 = nimCopy(null, makeNimstrLit("No stack traceback available\x0A"), NTI1163014); + } + + + return result_1345061; + +} +function new_seq_1390128(len_1390131) { + var result_1390133 = null; + + var F={procname:"newSeq.newSeq",prev:framePtr,filename:"system.nim",line:0}; + framePtr = F; + F.line = 643; + result_1390133 = new Array(len_1390131); for (var i=0;i", "text/html"); + + stuff_11000556 = doc.documentElement; + + F.line = 286; + db_11000528[0] = nimCopy(null, stuff_11000556.getElementsByClassName("reference"), NTI1789105); + F.line = 287; + contents_11000530[0] = nimCopy(null, [], NTI11000571); + L1: do { + F.line = 288; + var ahref_11010214 = null; + F.line = 184; + var i_11020040 = 0; + F.line = 185; + var l_11020041 = (db_11000528[0] != null ? db_11000528[0].length : 0); + L2: do { + F.line = 186; + L3: while (true) { + if (!(i_11020040 < l_11020041)) break L3; + F.line = 288; + ahref_11010214 = db_11000528[0][chckIndx(i_11020040, 0, (db_11000528[0] != null ? db_11000528[0].length : 0)+0-1)-0]; + F.line = 289; + if (contents_11000530[0] != null) { contents_11000530[0].push(ahref_11010214.getAttribute("data-doc-search-tag")); } else { contents_11000530[0] = [ahref_11010214.getAttribute("data-doc-search-tag")]; }; + F.line = 188; + i_11020040 = addInt(i_11020040, 1); + if (!(((db_11000528[0] != null ? db_11000528[0].length : 0) == l_11020041))) { + F.line = 189; + failed_assert_impl_1267680(makeNimstrLit("/Users/joey/Nim/lib/system/iterators.nim(189, 11) `len(a) == L` the length of the seq changed while iterating over it")); + } + + } + } while(false); + } while(false); + } + + F.line = 290; + var ul_11010225 = tree_10921020(makeNimstrLit("UL"), []); + F.line = 291; + result_11000550 = tree_10921020(makeNimstrLit("DIV"), []); + F.line = 292; + set_class_10921118(result_11000550, makeNimstrLit("search_results")); + F.line = 293; + var matches_11010246 = []; + L4: do { + F.line = 294; + var i_11010259 = 0; + F.line = 104; + var colontmp__11020047 = 0; + F.line = 294; + colontmp__11020047 = (db_11000528[0] != null ? db_11000528[0].length : 0); + F.line = 106; + var i_11020048 = 0; + L5: do { + F.line = 107; + L6: while (true) { + if (!(i_11020048 < colontmp__11020047)) break L6; + F.line = 294; + i_11010259 = i_11020048; + L7: do { + F.line = 295; + var c_11010260 = contents_11000530[0][chckIndx(i_11010259, 0, (contents_11000530[0] != null ? contents_11000530[0].length : 0)+0-1)-0]; + if (((c_11010260 == "Examples") || (c_11010260 == "PEG construction"))) { + F.line = 300; + break L7; + } + + F.line = 301; + var colontmp__11020055 = fuzzy_match_10846054(value_11000549, c_11010260); + F.line = 301; + var score_11010261 = colontmp__11020055["Field0"]; + F.line = 301; + var matched_11010262 = colontmp__11020055["Field1"]; + if (matched_11010262) { + F.line = 303; + if (matches_11010246 != null) { matches_11010246.push({Field0: db_11000528[0][chckIndx(i_11010259, 0, (db_11000528[0] != null ? db_11000528[0].length : 0)+0-1)-0], Field1: score_11010261}); } else { matches_11010246 = [{Field0: db_11000528[0][chckIndx(i_11010259, 0, (db_11000528[0] != null ? db_11000528[0].length : 0)+0-1)-0], Field1: score_11010261}]; }; + } + + } while(false); + F.line = 109; + i_11020048 = addInt(i_11020048, 1); + } + } while(false); + } while(false); + F.line = 305; + matches_11010246.sort(HEX3Aanonymous_11010273); + L8: do { + F.line = 306; + var i_11010326 = 0; + F.line = 104; + var colontmp__11020052 = 0; + F.line = 306; + colontmp__11020052 = nimMin((matches_11010246 != null ? matches_11010246.length : 0), 19); + F.line = 106; + var i_11020053 = 0; + L9: do { + F.line = 107; + L10: while (true) { + if (!(i_11020053 < colontmp__11020052)) break L10; + F.line = 306; + i_11010326 = i_11020053; + F.line = 307; + matches_11010246[chckIndx(i_11010326, 0, (matches_11010246 != null ? matches_11010246.length : 0)+0-1)-0]["Field0"].innerHTML = matches_11010246[chckIndx(i_11010326, 0, (matches_11010246 != null ? matches_11010246.length : 0)+0-1)-0]["Field0"].getAttribute("data-doc-search-tag"); + F.line = 308; + add_10921100(ul_11010225, tree_10921020(makeNimstrLit("LI"), [matches_11010246[chckIndx(i_11010326, 0, (matches_11010246 != null ? matches_11010246.length : 0)+0-1)-0]["Field0"]])); + F.line = 109; + i_11020053 = addInt(i_11020053, 1); + } + } while(false); + } while(false); + if ((ul_11010225.childNodes.length == 0)) { + F.line = 310; + add_10921100(result_11000550, tree_10921020(makeNimstrLit("B"), [text_10921135(makeNimstrLit("no search results"))])); + } + else { + F.line = 312; + add_10921100(result_11000550, tree_10921020(makeNimstrLit("B"), [text_10921135(makeNimstrLit("search results"))])); + F.line = 313; + add_10921100(result_11000550, ul_11010225); + } + + framePtr = F.prev; + + return result_11000550; + +} +function search() { + function wrapper_11010435() { + var F={procname:"search.wrapper",prev:framePtr,filename:"dochack.nim",line:0}; + framePtr = F; + F.line = 320; + var elem_11010437 = document.getElementById("searchInput"); + F.line = 321; + var value_11010438 = elem_11010437.value; + if (!(((value_11010438 != null ? value_11010438.length : 0) == 0))) { + if ((oldtoc_11010403[0] == null)) { + F.line = 324; + oldtoc_11010403[0] = document.getElementById("tocRoot"); + } + + F.line = 325; + var results_11015006 = dosearch_11000547(value_11010438); + F.line = 326; + replace_by_id_10921172("tocRoot", results_11015006); + } + else { + if (!((oldtoc_11010403[0] == null))) { + F.line = 328; + replace_by_id_10921172("tocRoot", oldtoc_11010403[0]); + } + } + framePtr = F.prev; + + + } + + var F={procname:"dochack.search",prev:framePtr,filename:"dochack.nim",line:0}; + framePtr = F; + if (!((timer_11010404[0] == null))) { + F.line = 330; + clearTimeout(timer_11010404[0]); + } + + F.line = 331; + timer_11010404[0] = setTimeout(wrapper_11010435, 400); + framePtr = F.prev; + + +} diff --git a/docs/sdl2/nimdoc.out.css b/docs/sdl2/nimdoc.out.css new file mode 100644 index 0000000..4ee73ea --- /dev/null +++ b/docs/sdl2/nimdoc.out.css @@ -0,0 +1,891 @@ +/* +Stylesheet for use with Docutils/rst2html. + +See http://docutils.sf.net/docs/howto/html-stylesheets.html for how to +customize this style sheet. + +Modified from Chad Skeeters' rst2html-style +https://bitbucket.org/cskeeters/rst2html-style/ + +Modified by Boyd Greenfield and narimiran +*/ + +:root { + --primary-background: #fff; + --secondary-background: ghostwhite; + --third-background: #e8e8e8; + --border: #dde; + --text: #222; + --anchor: #07b; + --anchor-focus: #607c9f; + --input-focus: #1fa0eb; + --strong: #3c3c3c; + --hint: #9A9A9A; + --nim-sprite-base64: url("data:image/png;base64,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"); + + --keyword: #5e8f60; + --identifier: #222; + --comment: #484a86; + --operator: #155da4; + --punctuation: black; + --other: black; + --escapeSequence: #c4891b; + --number: #252dbe; + --literal: #a4255b; + --raw-data: #a4255b; +} + +[data-theme="dark"] { + --primary-background: #171921; + --secondary-background: #1e202a; + --third-background: #2b2e3b; + --border: #0e1014; + --text: #fff; + --anchor: #8be9fd; + --anchor-focus: #8be9fd; + --input-focus: #8be9fd; + --strong: #bd93f9; + --hint: #7A7C85; + --nim-sprite-base64: url("data:image/png;base64,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"); + + --keyword: #ff79c6; + --identifier: #f8f8f2; + --comment: #6272a4; + --operator: #ff79c6; + --punctuation: #f8f8f2; + --other: #f8f8f2; + --escapeSequence: #bd93f9; + --number: #bd93f9; + --literal: #f1fa8c; + --raw-data: #8be9fd; +} + +.theme-switch-wrapper { + display: flex; + align-items: center; + + em { + margin-left: 10px; + font-size: 1rem; + } +} +.theme-switch { + display: inline-block; + height: 22px; + position: relative; + width: 50px; +} + +.theme-switch input { + display: none; +} + +.slider { + background-color: #ccc; + bottom: 0; + cursor: pointer; + left: 0; + position: absolute; + right: 0; + top: 0; + transition: .4s; +} + +.slider:before { + background-color: #fff; + bottom: 4px; + content: ""; + height: 13px; + left: 4px; + position: absolute; + transition: .4s; + width: 13px; +} + +input:checked + .slider { + background-color: #66bb6a; +} + +input:checked + .slider:before { + transform: translateX(26px); +} + +.slider.round { + border-radius: 17px; +} + +.slider.round:before { + border-radius: 50%; +} + +html { + font-size: 100%; + -webkit-text-size-adjust: 100%; + -ms-text-size-adjust: 100%; } + +body { + font-family: "Lato", "Helvetica Neue", "HelveticaNeue", Helvetica, Arial, sans-serif; + font-weight: 400; + font-size: 1.125em; + line-height: 1.5; + color: var(--text); + background-color: var(--primary-background); } + +/* Skeleton grid */ +.container { + position: relative; + width: 100%; + max-width: 1050px; + margin: 0 auto; + padding: 0; + box-sizing: border-box; } + +.column, +.columns { + width: 100%; + float: left; + box-sizing: border-box; + margin-left: 1%; +} + +.column:first-child, +.columns:first-child { + margin-left: 0; } + +.three.columns { + width: 19%; } + +.nine.columns { + width: 80.0%; } + +.twelve.columns { + width: 100%; + margin-left: 0; } + +@media screen and (max-width: 860px) { + .three.columns { + display: none; + } + .nine.columns { + width: 98.0%; + } + body { + font-size: 1em; + line-height: 1.35; + } +} + +cite { + font-style: italic !important; } + + +/* Nim search input */ +div#searchInputDiv { + margin-bottom: 1em; +} +input#searchInput { + width: 80%; +} + +/* + * Some custom formatting for input forms. + * This also fixes input form colors on Firefox with a dark system theme on Linux. + */ +input { + -moz-appearance: none; + background-color: var(--secondary-background); + color: var(--text); + border: 1px solid var(--border); + font-family: "Lato", "Helvetica Neue", "HelveticaNeue", Helvetica, Arial, sans-serif; + font-size: 0.9em; + padding: 6px; +} + +input:focus { + border: 1px solid var(--input-focus); + box-shadow: 0 0 3px var(--input-focus); +} + +select { + -moz-appearance: none; + background-color: var(--secondary-background); + color: var(--text); + border: 1px solid var(--border); + font-family: "Lato", "Helvetica Neue", "HelveticaNeue", Helvetica, Arial, sans-serif; + font-size: 0.9em; + padding: 6px; +} + +select:focus { + border: 1px solid var(--input-focus); + box-shadow: 0 0 3px var(--input-focus); +} + +/* Docgen styles */ +/* Links */ +a { + color: var(--anchor); + text-decoration: none; +} + +a span.Identifier { + text-decoration: underline; + text-decoration-color: #aab; +} + +a.reference-toplevel { + font-weight: bold; +} + +a.toc-backref { + text-decoration: none; + color: var(--text); } + +a.link-seesrc { + color: #607c9f; + font-size: 0.9em; + font-style: italic; } + +a:hover, +a:focus { + color: var(--anchor-focus); + text-decoration: underline; } + +a:hover span.Identifier { + color: var(--anchor); +} + + +sub, +sup { + position: relative; + font-size: 75%; + line-height: 0; + vertical-align: baseline; } + +sup { + top: -0.5em; } + +sub { + bottom: -0.25em; } + +img { + width: auto; + height: auto; + max-width: 100%; + vertical-align: middle; + border: 0; + -ms-interpolation-mode: bicubic; } + +@media print { + * { + color: black !important; + text-shadow: none !important; + background: transparent !important; + box-shadow: none !important; } + + a, + a:visited { + text-decoration: underline; } + + a[href]:after { + content: " (" attr(href) ")"; } + + abbr[title]:after { + content: " (" attr(title) ")"; } + + .ir a:after, + a[href^="javascript:"]:after, + a[href^="#"]:after { + content: ""; } + + pre, + blockquote { + border: 1px solid #999; + page-break-inside: avoid; } + + thead { + display: table-header-group; } + + tr, + img { + page-break-inside: avoid; } + + img { + max-width: 100% !important; } + + @page { + margin: 0.5cm; } + + h1 { + page-break-before: always; } + + h1.title { + page-break-before: avoid; } + + p, + h2, + h3 { + orphans: 3; + widows: 3; } + + h2, + h3 { + page-break-after: avoid; } +} + + +p { + margin-top: 0.5em; + margin-bottom: 0.5em; +} + +small { + font-size: 85%; } + +strong { + font-weight: 600; + font-size: 0.95em; + color: var(--strong); +} + +em { + font-style: italic; } + +h1 { + font-size: 1.8em; + font-weight: 400; + padding-bottom: .25em; + border-bottom: 6px solid var(--third-background); + margin-top: 2.5em; + margin-bottom: 1em; + line-height: 1.2em; } + +h1.title { + padding-bottom: 1em; + border-bottom: 0px; + font-size: 2.5em; + text-align: center; + font-weight: 900; + margin-top: 0.75em; + margin-bottom: 0em; +} + +h2 { + font-size: 1.3em; + margin-top: 2em; } + +h2.subtitle { + text-align: center; } + +h3 { + font-size: 1.125em; + font-style: italic; + margin-top: 1.5em; } + +h4 { + font-size: 1.125em; + margin-top: 1em; } + +h5 { + font-size: 1.125em; + margin-top: 0.75em; } + +h6 { + font-size: 1.1em; } + + +ul, +ol { + padding: 0; + margin-top: 0.5em; + margin-left: 0.75em; } + +ul ul, +ul ol, +ol ol, +ol ul { + margin-bottom: 0; + margin-left: 1.25em; } + +li { + list-style-type: circle; +} + +ul.simple-boot li { + list-style-type: none; + margin-left: 0em; + margin-bottom: 0.5em; +} + +ol.simple > li, ul.simple > li { + margin-bottom: 0.25em; + margin-left: 0.4em } + +ul.simple.simple-toc > li { + margin-top: 1em; +} + +ul.simple-toc { + list-style: none; + font-size: 0.9em; + margin-left: -0.3em; + margin-top: 1em; } + +ul.simple-toc > li { + list-style-type: none; +} + +ul.simple-toc-section { + list-style-type: circle; + margin-left: 1em; + color: #6c9aae; } + + +ol.arabic { + list-style: decimal; } + +ol.loweralpha { + list-style: lower-alpha; } + +ol.upperalpha { + list-style: upper-alpha; } + +ol.lowerroman { + list-style: lower-roman; } + +ol.upperroman { + list-style: upper-roman; } + +ul.auto-toc { + list-style-type: none; } + + +dl { + margin-bottom: 1.5em; } + +dt { + margin-bottom: -0.5em; + margin-left: 0.0em; } + +dd { + margin-left: 2.0em; + margin-bottom: 3.0em; + margin-top: 0.5em; } + + +hr { + margin: 2em 0; + border: 0; + border-top: 1px solid #aaa; } + +blockquote { + font-size: 0.9em; + font-style: italic; + padding-left: 0.5em; + margin-left: 0; + border-left: 5px solid #bbc; +} + +.pre { + font-family: "Source Code Pro", Monaco, Menlo, Consolas, "Courier New", monospace; + font-weight: 500; + font-size: 0.85em; + color: var(--text); + background-color: var(--third-background); + padding-left: 3px; + padding-right: 3px; + border-radius: 4px; +} + +pre { + font-family: "Source Code Pro", Monaco, Menlo, Consolas, "Courier New", monospace; + color: var(--text); + font-weight: 500; + display: inline-block; + box-sizing: border-box; + min-width: 100%; + padding: 0.5em; + margin-top: 0.5em; + margin-bottom: 0.5em; + font-size: 0.85em; + white-space: pre !important; + overflow-y: hidden; + overflow-x: visible; + background-color: var(--secondary-background); + border: 1px solid var(--border); + -webkit-border-radius: 6px; + -moz-border-radius: 6px; + border-radius: 6px; } + +.pre-scrollable { + max-height: 340px; + overflow-y: scroll; } + + +/* Nim line-numbered tables */ +.line-nums-table { + width: 100%; + table-layout: fixed; } + +table.line-nums-table { + border-radius: 4px; + border: 1px solid #cccccc; + background-color: ghostwhite; + border-collapse: separate; + margin-top: 15px; + margin-bottom: 25px; } + +.line-nums-table tbody { + border: none; } + +.line-nums-table td pre { + border: none; + background-color: transparent; } + +.line-nums-table td.blob-line-nums { + width: 28px; } + +.line-nums-table td.blob-line-nums pre { + color: #b0b0b0; + -webkit-filter: opacity(75%); + text-align: right; + border-color: transparent; + background-color: transparent; + padding-left: 0px; + margin-left: 0px; + padding-right: 0px; + margin-right: 0px; } + + +table { + max-width: 100%; + background-color: transparent; + margin-top: 0.5em; + margin-bottom: 1.5em; + border-collapse: collapse; + border-color: var(--third-background); + border-spacing: 0; + font-size: 0.9em; +} + +table th, table td { + padding: 0px 0.5em 0px; + border-color: var(--third-background); +} + +table th { + background-color: var(--third-background); + border-color: var(--third-background); + font-weight: bold; } + +table th.docinfo-name { + background-color: transparent; +} + +table tr:hover { + background-color: var(--third-background); } + + +/* rst2html default used to remove borders from tables and images */ +.borderless, table.borderless td, table.borderless th { + border: 0; } + +table.borderless td, table.borderless th { + /* Override padding for "table.docutils td" with "! important". + The right padding separates the table cells. */ + padding: 0 0.5em 0 0 !important; } + +.first { + /* Override more specific margin styles with "! important". */ + margin-top: 0 !important; } + +.last, .with-subtitle { + margin-bottom: 0 !important; } + +.hidden { + display: none; } + +blockquote.epigraph { + margin: 2em 5em; } + +dl.docutils dd { + margin-bottom: 0.5em; } + +object[type="image/svg+xml"], object[type="application/x-shockwave-flash"] { + overflow: hidden; } + + +div.figure { + margin-left: 2em; + margin-right: 2em; } + +div.footer, div.header { + clear: both; + text-align: center; + color: #666; + font-size: smaller; } + +div.footer { + padding-top: 5em; +} + +div.line-block { + display: block; + margin-top: 1em; + margin-bottom: 1em; } + +div.line-block div.line-block { + margin-top: 0; + margin-bottom: 0; + margin-left: 1.5em; } + +div.topic { + margin: 2em; } + +div.search_results { + background-color: antiquewhite; + margin: 3em; + padding: 1em; + border: 1px solid #4d4d4d; +} + +div#global-links ul { + margin-left: 0; + list-style-type: none; +} + +div#global-links > simple-boot { + margin-left: 3em; +} + +hr.docutils { + width: 75%; } + +img.align-left, .figure.align-left, object.align-left { + clear: left; + float: left; + margin-right: 1em; } + +img.align-right, .figure.align-right, object.align-right { + clear: right; + float: right; + margin-left: 1em; } + +img.align-center, .figure.align-center, object.align-center { + display: block; + margin-left: auto; + margin-right: auto; } + +.align-left { + text-align: left; } + +.align-center { + clear: both; + text-align: center; } + +.align-right { + text-align: right; } + +/* reset inner alignment in figures */ +div.align-right { + text-align: inherit; } + +p.attribution { + text-align: right; + margin-left: 50%; } + +p.caption { + font-style: italic; } + +p.credits { + font-style: italic; + font-size: smaller; } + +p.label { + white-space: nowrap; } + +p.rubric { + font-weight: bold; + font-size: larger; + color: maroon; + text-align: center; } + +p.topic-title { + font-weight: bold; } + +pre.address { + margin-bottom: 0; + margin-top: 0; + font: inherit; } + +pre.literal-block, pre.doctest-block, pre.math, pre.code { + margin-left: 2em; + margin-right: 2em; } + +pre.code .ln { + color: grey; } + +/* line numbers */ +pre.code, code { + background-color: #eeeeee; } + +pre.code .comment, code .comment { + color: #5c6576; } + +pre.code .keyword, code .keyword { + color: #3B0D06; + font-weight: bold; } + +pre.code .literal.string, code .literal.string { + color: #0c5404; } + +pre.code .name.builtin, code .name.builtin { + color: #352b84; } + +pre.code .deleted, code .deleted { + background-color: #DEB0A1; } + +pre.code .inserted, code .inserted { + background-color: #A3D289; } + +span.classifier { + font-style: oblique; } + +span.classifier-delimiter { + font-weight: bold; } + +span.option { + white-space: nowrap; } + +span.problematic { + color: #b30000; } + +span.section-subtitle { + /* font-size relative to parent (h1..h6 element) */ + font-size: 80%; } + +span.DecNumber { + color: var(--number); } + +span.BinNumber { + color: var(--number); } + +span.HexNumber { + color: var(--number); } + +span.OctNumber { + color: var(--number); } + +span.FloatNumber { + color: var(--number); } + +span.Identifier { + color: var(--identifier); } + +span.Keyword { + font-weight: 600; + color: var(--keyword); } + +span.StringLit { + color: var(--literal); } + +span.LongStringLit { + color: var(--literal); } + +span.CharLit { + color: var(--literal); } + +span.EscapeSequence { + color: var(--escapeSequence); } + +span.Operator { + color: var(--operator); } + +span.Punctuation { + color: var(--punctuation); } + +span.Comment, span.LongComment { + font-style: italic; + font-weight: 400; + color: var(--comment); } + +span.RegularExpression { + color: darkviolet; } + +span.TagStart { + color: darkviolet; } + +span.TagEnd { + color: darkviolet; } + +span.Key { + color: #252dbe; } + +span.Value { + color: #252dbe; } + +span.RawData { + color: var(--raw-data); } + +span.Assembler { + color: #252dbe; } + +span.Preprocessor { + color: #252dbe; } + +span.Directive { + color: #252dbe; } + +span.Command, span.Rule, span.Hyperlink, span.Label, span.Reference, +span.Other { + color: var(--other); } + +/* Pop type, const, proc, and iterator defs in nim def blocks */ +dt pre > span.Identifier, dt pre > span.Operator { + color: var(--identifier); + font-weight: 700; } + +dt pre > span.Keyword ~ span.Identifier, dt pre > span.Identifier ~ span.Identifier, +dt pre > span.Operator ~ span.Identifier, dt pre > span.Other ~ span.Identifier { + color: var(--identifier); + font-weight: inherit; } + +/* Nim sprite for the footer (taken from main page favicon) */ +.nim-sprite { + display: inline-block; + width: 51px; + height: 14px; + background-position: 0 0; + background-size: 51px 14px; + -webkit-filter: opacity(50%); + background-repeat: no-repeat; + background-image: var(--nim-sprite-base64); + margin-bottom: 5px; } + +span.pragmadots { + /* Position: relative frees us up to make the dots + look really nice without fucking up the layout and + causing bulging in the parent container */ + position: relative; + /* 1px down looks slightly nicer */ + top: 1px; + padding: 2px; + background-color: var(--third-background); + border-radius: 4px; + margin: 0 2px; + cursor: pointer; + font-size: 0.8em; +} + +span.pragmadots:hover { + background-color: var(--hint); +} +span.pragmawrap { + display: none; +} + +span.attachedType { + display: none; + visibility: hidden; +} \ No newline at end of file diff --git a/docs/sdl2/sdl2.html b/docs/sdl2/sdl2.html new file mode 100644 index 0000000..3de1570 --- /dev/null +++ b/docs/sdl2/sdl2.html @@ -0,0 +1,26102 @@ + + + + + + + + + + + + + + + + + + +sdl2/sdl2 + + + + + + + + +
+
+

sdl2/sdl2

+
+
+
+ +     Dark Mode +
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+ +

+
+

Types

+
+ +
AssertState = distinct cint
+
+ + + +
+ +
errorcode = distinct cint
+
+ + + +
+ +
ThreadPriority = distinct cint
+
+ + + +
+ +
AudioStatus = distinct cint
+
+ + + +
+ +
PixelType = distinct cint
+
+ + + +
+ +
BitmapOrder = distinct cint
+
+ + + +
+ +
PackedOrder = distinct cint
+
+ + + +
+ +
ArrayOrder = distinct cint
+
+ + + +
+ +
PackedLayout = distinct cint
+
+ + + +
+ +
PixelFormatEnum = distinct cint
+
+ + + +
+ +
BlendMode = distinct cint
+
+ + + +
+ +
BlendOperation = distinct cint
+
+ + + +
+ +
BlendFactor = distinct cint
+
+ + + +
+ +
YUV_CONVERSION_MODE = distinct cint
+
+ + + +
+ +
WindowFlags = distinct cint
+
+ + + +
+ +
WindowEventID = distinct cint
+
+ + + +
+ +
DisplayEventID = distinct cint
+
+ + + +
+ +
DisplayOrientation = distinct cint
+
+ + + +
+ +
GLattr = distinct cint
+
+ + + +
+ +
GLprofile = distinct cint
+
+ + + +
+ +
GLcontextFlag = distinct cint
+
+ + + +
+ +
GLcontextReleaseFlag = distinct cint
+
+ + + +
+ +
GLContextResetNotificationEnum = distinct cint
+
+ + + +
+ +
HitTestResult = distinct cint
+
+ + + +
+ +
Scancode = distinct cint
+
+ + + +
+ +
KeyCodeEnum = distinct cint
+
+ + + +
+ +
Keymod = distinct cint
+
+ + + +
+ +
SystemCursor = distinct cint
+
+ + + +
+ +
MouseWheelDirection = distinct cint
+
+ + + +
+ +
JoystickType = distinct cint
+
+ + + +
+ +
JoystickPowerLevel = distinct cint
+
+ + + +
+ +
GameControllerType = distinct cint
+
+ + + +
+ +
GameControllerAxis = distinct cint
+
+ + + +
+ +
GameControllerButton = distinct cint
+
+ + + +
+ +
TouchDeviceType = distinct cint
+
+ + + +
+ +
EventType = distinct cint
+
+ + + +
+ +
eventaction = distinct cint
+
+ + + +
+ +
HintPriority = distinct cint
+
+ + + +
+ +
LogCategory = distinct cint
+
+ + + +
+ +
LogPriority = distinct cint
+
+ + + +
+ +
MessageBoxFlags = distinct cint
+
+ + + +
+ +
MessageBoxButtonFlags = distinct cint
+
+ + + +
+ +
MessageBoxColorType = distinct cint
+
+ + + +
+ +
PowerState = distinct cint
+
+ + + +
+ +
RendererFlags = distinct cint
+
+ + + +
+ +
ScaleMode = distinct cint
+
+ + + +
+ +
TextureAccess = distinct cint
+
+ + + +
+ +
TextureModulate = distinct cint
+
+ + + +
+ +
RendererFlip = distinct cint
+
+ + + +
+ +
SensorType = distinct cint
+
+ + + +
+ +
WindowShapeMode = distinct cint
+
+ + + +
+ +
RWops {...}{.incompleteStruct.} = object
+
+ + + +
+ +
BlitMap {...}{.incompleteStruct.} = object
+
+ + + +
+ +
GameControllerBindType = enum
+  CONTROLLER_BINDTYPE_NONE = 0, CONTROLLER_BINDTYPE_BUTTON,
+  CONTROLLER_BINDTYPE_AXIS, CONTROLLER_BINDTYPE_HAT
+
+ + + +
+ +
Bool = bool
+
+ + + +
+ +
GameControllerButtonBind = object
+  case bindType*: GameControllerBindType
+  of CONTROLLER_BINDTYPE_BUTTON:
+      button*: cint
+
+  of CONTROLLER_BINDTYPE_AXIS:
+      axis*: cint
+
+  of CONTROLLER_BINDTYPE_HAT:
+      hat*: ButtonBindHat
+
+  of CONTROLLER_BINDTYPE_NONE:
+      nil
+
+  
+
+ + + +
+ +
ButtonBindHat = object
+  hat*: int
+  hatMask*: int
+
+
+ + + +
+ +
Sint8 = int8
+
+ + + +
+ +
Uint8 = uint8
+
+ + + +
+ +
Sint16 = int16
+
+ + + +
+ +
Uint16 = uint16
+
+ + + +
+ +
Sint32 = int32
+
+ + + +
+ +
Uint32 = uint32
+
+ + + +
+ +
Sint64 = int64
+
+ + + +
+ +
Uint64 = uint64
+
+ + + +
+ +
malloc_func = proc (size: uint): pointer {...}{.cdecl.}
+
+ + + +
+ +
calloc_func = proc (nmemb: uint; size: uint): pointer {...}{.cdecl.}
+
+ + + +
+ +
realloc_func = proc (mem: pointer; size: uint): pointer {...}{.cdecl.}
+
+ + + +
+ +
free_func = proc (mem: pointer) {...}{.cdecl.}
+
+ + + +
+ +
iconv_t {...}{.incompleteStruct.} = object
+
+ + + +
+ +
main_func = proc (argc: cint; argv: UncheckedArray[cstring]): cint {...}{.cdecl.}
+
+ + + +
+ +
AssertData {...}{.bycopy.} = object
+  alwaysIgnore*: cint
+  triggerCount*: cuint
+  condition*: cstring
+  filename*: cstring
+  linenum*: cint
+  function*: cstring
+  next*: ptr AssertData
+
+
+ + + +
+ +
AssertionHandler = proc (data: ptr AssertData; userdata: pointer): AssertState {...}{.cdecl.}
+
+ + + +
+ +
SpinLock = cint
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+\name SDL AtomicLock
+ 
+ The atomic locks are efficient spinlocks using CPU instructions,
+ but are vulnerable to starvation and can spin forever if a thread
+ holding a lock has been terminated.  For this reason you should
+ minimize the code executed inside an atomic lock and never do
+ expensive things like API or system calls while holding them.
+ 
+ The atomic locks are not safe to lock recursively.
+ 
+ Porting Note:
+ The spin lock functions and type are required and can not be
+ emulated because they are used in the atomic emulation code.
+@{
+ + +
+ +
atomic_t {...}{.bycopy.} = object
+  value*: cint
+
+
+ +
\brief A type representing an atomic integer value.  It is a struct
+        so people don't accidentally use numeric operations on it.
+ + +
+ +
mutex {...}{.incompleteStruct.} = object
+
+ + + +
+ +
semaphore {...}{.incompleteStruct.} = object
+
+ + + +
+ +
sem = semaphore
+
+ + + +
+ +
cond {...}{.incompleteStruct.} = object
+
+ + + +
+ +
Thread {...}{.incompleteStruct.} = object
+
+ + + +
+ +
threadID = culong
+
+ +
The SDL thread ID
+ + +
+ +
TLSID = cuint
+
+ +
Thread local storage ID, 0 is the invalid ID
+ + +
+ +
ThreadFunction = proc (data: pointer): cint {...}{.cdecl.}
+
+ + + +
+ +
AudioFormat = Uint16
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+\brief Audio format flags.
+  
+  These are what the 16 bits in SDL_AudioFormat currently mean...
+  (Unspecified bits are always zero).
+  
+  \verbatim
+    ++-----------------------sample is signed if set
+    ||
+    ||       ++-----------sample is bigendian if set
+    ||       ||
+    ||       ||          ++---sample is float if set
+    ||       ||          ||
+    ||       ||          || +---sample bit size---+
+    ||       ||          || |                     |
+    15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
+    \endverbatim
+  
+  There are macros in SDL 2.0 and later to query these bits.
+ + +
+ +
AudioCallback = proc (userdata: pointer; stream: ptr Uint8; len: cint) {...}{.cdecl.}
+
+ + + +
+ +
AudioSpec {...}{.bycopy.} = object
+  freq*: cint                  ## ::
+            ##   < DSP frequency -- samples per second
+  format*: AudioFormat         ## ::
+                     ##   < Audio data format
+  channels*: Uint8             ## ::
+                 ##   < Number of channels: 1 mono, 2 stereo
+  silence*: Uint8              ## ::
+                ##   < Audio buffer silence value (calculated)
+  samples*: Uint16             ## ::
+                 ##   < Audio buffer size in sample FRAMES (total samples divided by channel count)
+  padding*: Uint16             ## ::
+                 ##   < Necessary for some compile environments
+  size*: Uint32                ## ::
+              ##   < Audio buffer size in bytes (calculated)
+  callback*: AudioCallback     ## ::
+                         ##   < Callback that feeds the audio device (NULL to use SDL_QueueAudio()).
+  userdata*: pointer           ## ::
+                   ##   < Userdata passed to callback (ignored for NULL callbacks).
+  
+
+ +
The calculated values in this structure are calculated by SDL_OpenAudio().
+  
+  For multi-channel audio, the default SDL channel mapping is:
+  2:  FL FR                       (stereo)
+  3:  FL FR LFE                   (2.1 surround)
+  4:  FL FR BL BR                 (quad)
+  5:  FL FR FC BL BR              (quad + center)
+  6:  FL FR FC LFE SL SR          (5.1 surround - last two can also be BL BR)
+  7:  FL FR FC LFE BC SL SR       (6.1 surround)
+  8:  FL FR FC LFE BL BR SL SR    (7.1 surround)
+ + +
+ +
AudioCVT {...}{.bycopy.} = object
+  needed*: cint                ## ::
+              ##   < Set to 1 if conversion possible
+  srcFormat*: AudioFormat      ## ::
+                        ##   < Source audio format
+  dstFormat*: AudioFormat      ## ::
+                        ##   < Target audio format
+  rateIncr*: cdouble           ## ::
+                   ##   < Rate conversion increment
+  buf*: ptr Uint8               ## ::
+               ##   < Buffer to hold entire audio data
+  len*: cint                   ## ::
+           ##   < Length of original audio buffer
+  lenCvt*: cint                ## ::
+              ##   < Length of converted audio buffer
+  lenMult*: cint               ## ::
+               ##   < buffer must be lenlen_mult big
+  lenRatio*: cdouble           ## ::
+                   ##   < Given len, final size is lenlen_ratio
+  filters*: array[9 + typeof(9)(1), AudioFilter] ## ::
+                                            ##   < NULL-terminated list of filter functions
+  filterIndex*: cint           ## ::
+                   ##   < Current audio conversion function
+  
+
+ + + +
+ +
AudioFilter = proc (cvt: ptr AudioCVT; format: AudioFormat) {...}{.cdecl.}
+
+ + + +
+ +
AudioDeviceID = Uint32
+
+ +
SDL Audio Device IDs.
+  
+  A successful call to SDL_OpenAudio() is always device id 1, and legacy
+  SDL audio APIs assume you want this device ID. SDL_OpenAudioDevice() calls
+  always returns devices >= 2 on success. The legacy calls are good both
+  for backwards compatibility and when you don't care about multiple,
+  specific, or capture devices.
+ + +
+ +
AudioStream {...}{.incompleteStruct.} = object
+
+ + + +
+ +
Color {...}{.bycopy.} = object
+  r*: Uint8
+  g*: Uint8
+  b*: Uint8
+  a*: Uint8
+
+
+ + + +
+ +
Palette {...}{.bycopy.} = object
+  ncolors*: cint
+  colors*: ptr Color
+  Version*: Uint32
+  refcount*: cint
+
+
+ + + +
+ +
PixelFormat {...}{.bycopy.} = object
+  format*: Uint32
+  palette*: ptr Palette
+  BitsPerPixel*: Uint8
+  BytesPerPixel*: Uint8
+  padding*: array[2, Uint8]
+  Rmask*: Uint32
+  Gmask*: Uint32
+  Bmask*: Uint32
+  Amask*: Uint32
+  Rloss*: Uint8
+  Gloss*: Uint8
+  Bloss*: Uint8
+  Aloss*: Uint8
+  Rshift*: Uint8
+  Gshift*: Uint8
+  Bshift*: Uint8
+  Ashift*: Uint8
+  refcount*: cint
+  next*: ptr PixelFormat
+
+
+ +
\note Everything in the pixel format structure is read-only.
+ + +
+ +
Point {...}{.bycopy.} = object
+  x*: cint
+  y*: cint
+
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+\brief  The structure that defines a point (integer)
+  
+  \sa SDL_EnclosePoints
+  \sa SDL_PointInRect
+ + +
+ +
FPoint {...}{.bycopy.} = object
+  x*: cfloat
+  y*: cfloat
+
+
+ +
\brief  The structure that defines a point (floating point)
+  
+  \sa SDL_EnclosePoints
+  \sa SDL_PointInRect
+ + +
+ +
Rect {...}{.bycopy.} = object
+  x*: cint
+  y*: cint
+  w*: cint
+  h*: cint
+
+
+ +
\brief A rectangle, with the origin at the upper left (integer).
+  
+  \sa SDL_RectEmpty
+  \sa SDL_RectEquals
+  \sa SDL_HasIntersection
+  \sa SDL_IntersectRect
+  \sa SDL_UnionRect
+  \sa SDL_EnclosePoints
+ + +
+ +
FRect {...}{.bycopy.} = object
+  x*: cfloat
+  y*: cfloat
+  w*: cfloat
+  h*: cfloat
+
+
+ +
\brief A rectangle, with the origin at the upper left (floating point).
+ + +
+ +
Surface {...}{.bycopy.} = object
+  flags*: Uint32               ## ::
+               ##   < Read-only
+  format*: ptr PixelFormat      ## ::
+                        ##   < Read-only
+  w*: cint                     ## ::
+         ##   < Read-only
+  h*: cint                     ## ::
+         ##   < Read-only
+  pitch*: cint                 ## ::
+             ##   < Read-only
+  pixels*: pointer             ## ::
+                 ##   < Read-write
+  userdata*: pointer           ## ::
+                   ##   < Read-write
+  locked*: cint                ## ::
+              ##   < Read-only
+  lockData*: pointer           ## ::
+                   ##   < Read-only
+  clipRect*: Rect              ## ::
+                ##   < Read-only
+  map*: ptr BlitMap             ## ::
+                 ##   < Private
+  refcount*: cint              ## ::
+                ##   < Read-mostly
+  
+
+ +
\brief A collection of pixels used in software blitting.
+ 
+ \note  This structure should be treated as read-only, except for \c pixels,
+        which, if not NULL, contains the raw pixel data for the surface.
+ + +
+ +
blit = proc (src: ptr Surface; srcrect: ptr Rect; dst: ptr Surface; dstrect: ptr Rect): cint {...}{.
+    cdecl.}
+
+ + + +
+ +
DisplayMode {...}{.bycopy.} = object
+  format*: Uint32              ## ::
+                ##   < pixel format
+  w*: cint                     ## ::
+         ##   < width, in screen coordinates
+  h*: cint                     ## ::
+         ##   < height, in screen coordinates
+  refreshRate*: cint           ## ::
+                   ##   < refresh rate (or zero for unspecified)
+  driverdata*: pointer         ## ::
+                     ##   < driver-specific data, initialize to 0
+  
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+\brief  The structure that defines a display mode
+  
+  \sa SDL_GetNumDisplayModes()
+  \sa SDL_GetDisplayMode()
+  \sa SDL_GetDesktopDisplayMode()
+  \sa SDL_GetCurrentDisplayMode()
+  \sa SDL_GetClosestDisplayMode()
+  \sa SDL_SetWindowDisplayMode()
+  \sa SDL_GetWindowDisplayMode()
+ + +
+ +
Window {...}{.incompleteStruct.} = object
+
+ + + +
+ +
GLContext = pointer
+
+ +
\brief An opaque handle to an OpenGL context.
+ + +
+ +
HitTest = proc (win: ptr Window; area: ptr Point; data: pointer): HitTestResult {...}{.cdecl.}
+
+ + + +
+ +
Keycode = Sint32
+
+ +
vi: set ts=4 sw=4 expandtab:
+\brief The SDL virtual key representation.
+  
+  Values of this type are used to represent keyboard keys using the current
+  layout of the keyboard.  These values include Unicode values representing
+  the unmodified character that would be generated by pressing the key, or
+  an SDLK_ constant for those keys that do not generate characters.
+  
+  A special exception is the number keys at the top of the keyboard which
+  always map to SDLK_0...SDLK_9, regardless of layout.
+ + +
+ +
Keysym {...}{.bycopy.} = object
+  scancode*: Scancode          ## ::
+                    ##   < SDL physical key code - see ::SDL_Scancode for details
+  sym*: Keycode                ## ::
+              ##   < SDL virtual key code - see ::SDL_Keycode for details
+  `mod`*: Uint16               ## ::
+               ##   < current key modifiers
+  unused*: Uint32
+
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+\brief The SDL keysym structure, used in key events.
+  
+  \note  If you are looking for translated character input, see the ::SDL_TEXTINPUT event.
+ + +
+ +
Cursor {...}{.incompleteStruct.} = object
+
+ + + +
+ +
Joystick {...}{.incompleteStruct.} = object
+
+ + + +
+ +
JoystickGUID {...}{.bycopy.} = object
+  data*: array[16, Uint8]
+
+
+ +
A structure that encodes the stable unique id for a joystick device
+ + +
+ +
JoystickID = Sint32
+
+ +
This is a unique ID for a joystick for the time it is connected to the system,
+ and is never reused for the lifetime of the application. If the joystick is
+ disconnected and reconnected, it will get a new ID.
+ 
+ The ID value starts at 0 and increments from there. The value -1 is an invalid ID.
+ + +
+ +
GameController {...}{.incompleteStruct.} = object
+
+ + + +
+ +
TouchID = Sint64
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+ + +
+ +
FingerID = Sint64
+
+ + + +
+ +
Finger {...}{.bycopy.} = object
+  id*: FingerID
+  x*: cfloat
+  y*: cfloat
+  pressure*: cfloat
+
+
+ + + +
+ +
GestureID = Sint64
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+ + +
+ +
CommonEvent {...}{.bycopy.} = object
+  kind*: Uint32
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  
+
+ +
\brief Fields shared by every event
+ + +
+ +
DisplayEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_DISPLAYEVENT
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  display*: Uint32             ## ::
+                 ##   < The associated display index
+  event*: Uint8                ## ::
+              ##   < ::SDL_DisplayEventID
+  padding1*: Uint8
+  padding2*: Uint8
+  padding3*: Uint8
+  data1*: Sint32               ## ::
+               ##   < event dependent data
+  
+
+ +
\brief Display state change event data (event.display.)
+ + +
+ +
WindowEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_WINDOWEVENT
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  windowID*: Uint32            ## ::
+                  ##   < The associated window
+  event*: Uint8                ## ::
+              ##   < ::SDL_WindowEventID
+  padding1*: Uint8
+  padding2*: Uint8
+  padding3*: Uint8
+  data1*: Sint32               ## ::
+               ##   < event dependent data
+  data2*: Sint32               ## ::
+               ##   < event dependent data
+  
+
+ +
\brief Window state change event data (event.window.)
+ + +
+ +
KeyboardEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_KEYDOWN or ::SDL_KEYUP
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  windowID*: Uint32            ## ::
+                  ##   < The window with keyboard focus, if any
+  state*: Uint8                ## ::
+              ##   < ::SDL_PRESSED or ::SDL_RELEASED
+  repeat*: Uint8               ## ::
+               ##   < Non-zero if this is a key repeat
+  padding2*: Uint8
+  padding3*: Uint8
+  keysym*: Keysym              ## ::
+                ##   < The key that was pressed or released
+  
+
+ +
\brief Keyboard button event structure (event.key.)
+ + +
+ +
TextEditingEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_TEXTEDITING
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  windowID*: Uint32            ## ::
+                  ##   < The window with keyboard focus, if any
+  text*: array[(32), cchar]     ## ::
+                         ##   < The editing text
+  start*: Sint32               ## ::
+               ##   < The start cursor of selected editing text
+  length*: Sint32              ## ::
+                ##   < The length of selected editing text
+  
+
+ +
\brief Keyboard text editing event structure (event.edit.)
+ + +
+ +
TextInputEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_TEXTINPUT
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  windowID*: Uint32            ## ::
+                  ##   < The window with keyboard focus, if any
+  text*: array[(32), cchar]     ## ::
+                         ##   < The input text
+  
+
+ +
\brief Keyboard text input event structure (event.text.)
+ + +
+ +
MouseMotionEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_MOUSEMOTION
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  windowID*: Uint32            ## ::
+                  ##   < The window with mouse focus, if any
+  which*: Uint32               ## ::
+               ##   < The mouse instance id, or SDL_TOUCH_MOUSEID
+  state*: Uint32               ## ::
+               ##   < The current button state
+  x*: Sint32                   ## ::
+           ##   < X coordinate, relative to window
+  y*: Sint32                   ## ::
+           ##   < Y coordinate, relative to window
+  xrel*: Sint32                ## ::
+              ##   < The relative motion in the X direction
+  yrel*: Sint32                ## ::
+              ##   < The relative motion in the Y direction
+  
+
+ +
\brief Mouse motion event structure (event.motion.)
+ + +
+ +
MouseButtonEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_MOUSEBUTTONDOWN or ::SDL_MOUSEBUTTONUP
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  windowID*: Uint32            ## ::
+                  ##   < The window with mouse focus, if any
+  which*: Uint32               ## ::
+               ##   < The mouse instance id, or SDL_TOUCH_MOUSEID
+  button*: Uint8               ## ::
+               ##   < The mouse button index
+  state*: Uint8                ## ::
+              ##   < ::SDL_PRESSED or ::SDL_RELEASED
+  clicks*: Uint8               ## ::
+               ##   < 1 for single-click, 2 for double-click, etc.
+  padding1*: Uint8
+  x*: Sint32                   ## ::
+           ##   < X coordinate, relative to window
+  y*: Sint32                   ## ::
+           ##   < Y coordinate, relative to window
+  
+
+ +
\brief Mouse button event structure (event.button.)
+ + +
+ +
MouseWheelEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_MOUSEWHEEL
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  windowID*: Uint32            ## ::
+                  ##   < The window with mouse focus, if any
+  which*: Uint32               ## ::
+               ##   < The mouse instance id, or SDL_TOUCH_MOUSEID
+  x*: Sint32                   ## ::
+           ##   < The amount scrolled horizontally, positive to the right and negative to the left
+  y*: Sint32                   ## ::
+           ##   < The amount scrolled vertically, positive away from the user and negative toward the user
+  direction*: Uint32           ## ::
+                   ##   < Set to one of the SDL_MOUSEWHEEL_ defines. When FLIPPED the values in X and Y will be opposite. Multiply by -1 to change them back
+  
+
+ +
\brief Mouse wheel event structure (event.wheel.)
+ + +
+ +
JoyAxisEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_JOYAXISMOTION
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  which*: JoystickID           ## ::
+                   ##   < The joystick instance id
+  axis*: Uint8                 ## ::
+             ##   < The joystick axis index
+  padding1*: Uint8
+  padding2*: Uint8
+  padding3*: Uint8
+  value*: Sint16               ## ::
+               ##   < The axis value (range: -32768 to 32767)
+  padding4*: Uint16
+
+
+ +
\brief Joystick axis motion event structure (event.jaxis.)
+ + +
+ +
JoyBallEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_JOYBALLMOTION
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  which*: JoystickID           ## ::
+                   ##   < The joystick instance id
+  ball*: Uint8                 ## ::
+             ##   < The joystick trackball index
+  padding1*: Uint8
+  padding2*: Uint8
+  padding3*: Uint8
+  xrel*: Sint16                ## ::
+              ##   < The relative motion in the X direction
+  yrel*: Sint16                ## ::
+              ##   < The relative motion in the Y direction
+  
+
+ +
\brief Joystick trackball motion event structure (event.jball.)
+ + +
+ +
JoyHatEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_JOYHATMOTION
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  which*: JoystickID           ## ::
+                   ##   < The joystick instance id
+  hat*: Uint8                  ## ::
+            ##   < The joystick hat index
+  value*: Uint8 ## ::
+              ##   < The hat position value.
+              ##      \sa ::SDL_HAT_LEFTUP ::SDL_HAT_UP ::SDL_HAT_RIGHTUP
+              ##      \sa ::SDL_HAT_LEFT ::SDL_HAT_CENTERED ::SDL_HAT_RIGHT
+              ##      \sa ::SDL_HAT_LEFTDOWN ::SDL_HAT_DOWN ::SDL_HAT_RIGHTDOWN
+              ##   
+              ##      Note that zero means the POV is centered.
+  padding1*: Uint8
+  padding2*: Uint8
+
+
+ +
\brief Joystick hat position change event structure (event.jhat.)
+ + +
+ +
JoyButtonEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_JOYBUTTONDOWN or ::SDL_JOYBUTTONUP
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  which*: JoystickID           ## ::
+                   ##   < The joystick instance id
+  button*: Uint8               ## ::
+               ##   < The joystick button index
+  state*: Uint8                ## ::
+              ##   < ::SDL_PRESSED or ::SDL_RELEASED
+  padding1*: Uint8
+  padding2*: Uint8
+
+
+ +
\brief Joystick button event structure (event.jbutton.)
+ + +
+ +
JoyDeviceEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_JOYDEVICEADDED or ::SDL_JOYDEVICEREMOVED
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  which*: Sint32               ## ::
+               ##   < The joystick device index for the ADDED event, instance id for the REMOVED event
+  
+
+ +
\brief Joystick device event structure (event.jdevice.)
+ + +
+ +
ControllerAxisEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_CONTROLLERAXISMOTION
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  which*: JoystickID           ## ::
+                   ##   < The joystick instance id
+  axis*: Uint8                 ## ::
+             ##   < The controller axis (SDL_GameControllerAxis)
+  padding1*: Uint8
+  padding2*: Uint8
+  padding3*: Uint8
+  value*: Sint16               ## ::
+               ##   < The axis value (range: -32768 to 32767)
+  padding4*: Uint16
+
+
+ +
\brief Game controller axis motion event structure (event.caxis.)
+ + +
+ +
ControllerButtonEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_CONTROLLERBUTTONDOWN or ::SDL_CONTROLLERBUTTONUP
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  which*: JoystickID           ## ::
+                   ##   < The joystick instance id
+  button*: Uint8               ## ::
+               ##   < The controller button (SDL_GameControllerButton)
+  state*: Uint8                ## ::
+              ##   < ::SDL_PRESSED or ::SDL_RELEASED
+  padding1*: Uint8
+  padding2*: Uint8
+
+
+ +
\brief Game controller button event structure (event.cbutton.)
+ + +
+ +
ControllerDeviceEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_CONTROLLERDEVICEADDED, ::SDL_CONTROLLERDEVICEREMOVED, or ::SDL_CONTROLLERDEVICEREMAPPED
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  which*: Sint32               ## ::
+               ##   < The joystick device index for the ADDED event, instance id for the REMOVED or REMAPPED event
+  
+
+ +
\brief Controller device event structure (event.cdevice.)
+ + +
+ +
AudioDeviceEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_AUDIODEVICEADDED, or ::SDL_AUDIODEVICEREMOVED
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  which*: Uint32               ## ::
+               ##   < The audio device index for the ADDED event (valid until next SDL_GetNumAudioDevices() call), SDL_AudioDeviceID for the REMOVED event
+  iscapture*: Uint8            ## ::
+                  ##   < zero if an output device, non-zero if a capture device.
+  padding1*: Uint8
+  padding2*: Uint8
+  padding3*: Uint8
+
+
+ +
\brief Audio device event structure (event.adevice.)
+ + +
+ +
TouchFingerEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_FINGERMOTION or ::SDL_FINGERDOWN or ::SDL_FINGERUP
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  touchId*: TouchID            ## ::
+                  ##   < The touch device id
+  fingerId*: FingerID
+  x*: cfloat                   ## ::
+           ##   < Normalized in the range 0...1
+  y*: cfloat                   ## ::
+           ##   < Normalized in the range 0...1
+  dx*: cfloat                  ## ::
+            ##   < Normalized in the range -1...1
+  dy*: cfloat                  ## ::
+            ##   < Normalized in the range -1...1
+  pressure*: cfloat            ## ::
+                  ##   < Normalized in the range 0...1
+  windowID*: Uint32            ## ::
+                  ##   < The window underneath the finger, if any
+  
+
+ +
\brief Touch finger event structure (event.tfinger.)
+ + +
+ +
MultiGestureEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_MULTIGESTURE
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  touchId*: TouchID            ## ::
+                  ##   < The touch device id
+  dTheta*: cfloat
+  dDist*: cfloat
+  x*: cfloat
+  y*: cfloat
+  numFingers*: Uint16
+  padding*: Uint16
+
+
+ +
\brief Multiple Finger Gesture Event (event.mgesture.)
+ + +
+ +
DollarGestureEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_DOLLARGESTURE or ::SDL_DOLLARRECORD
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  touchId*: TouchID            ## ::
+                  ##   < The touch device id
+  gestureId*: GestureID
+  numFingers*: Uint32
+  error*: cfloat
+  x*: cfloat                   ## ::
+           ##   < Normalized center of gesture
+  y*: cfloat                   ## ::
+           ##   < Normalized center of gesture
+  
+
+ +
\brief Dollar Gesture Event (event.dgesture.)
+ + +
+ +
DropEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_DROPBEGIN or ::SDL_DROPFILE or ::SDL_DROPTEXT or ::SDL_DROPCOMPLETE
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  file*: cstring               ## ::
+               ##   < The file name, which should be freed with SDL_free(), is NULL on begin/complete
+  windowID*: Uint32            ## ::
+                  ##   < The window that was dropped on, if any
+  
+
+ +
\brief An event used to request a file open by the system (event.drop.)
+         This event is enabled by default, you can disable it with SDL_EventState().
+  \note If this event is enabled, you must free the filename in the event.
+ + +
+ +
SensorEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_SENSORUPDATE
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  which*: Sint32               ## ::
+               ##   < The instance ID of the sensor
+  data*: array[6, cfloat]       ## ::
+                       ##   < Up to 6 values from the sensor - additional values can be queried using SDL_SensorGetData()
+  
+
+ +
\brief Sensor event structure (event.sensor.)
+ + +
+ +
QuitEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_QUIT
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  
+
+ +
\brief The "quit requested" event
+ + +
+ +
OSEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_QUIT
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  
+
+ +
\brief OS Specific event
+ + +
+ +
UserEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_USEREVENT through ::SDL_LASTEVENT-1
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  windowID*: Uint32            ## ::
+                  ##   < The associated window if any
+  code*: Sint32                ## ::
+              ##   < User defined event code
+  data1*: pointer              ## ::
+                ##   < User defined data pointer
+  data2*: pointer              ## ::
+                ##   < User defined data pointer
+  
+
+ +
\brief A user-defined event type (event.user.)
+ + +
+ +
SysWMmsg {...}{.incompleteStruct.} = object
+
+ + + +
+ +
SysWMEvent {...}{.bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < ::SDL_SYSWMEVENT
+  timestamp*: Uint32           ## ::
+                   ##   < In milliseconds, populated using SDL_GetTicks()
+  msg*: ptr SysWMmsg            ## ::
+                  ##   < driver dependent data, defined in SDL_syswm.h
+  
+
+ +
\brief A video driver dependent system event (event.syswm.)
+         This event is disabled by default, you can enable it with SDL_EventState()
+  
+  \note If you want to use this event, you should include SDL_syswm.h.
+ + +
+ +
Event {...}{.union, bycopy.} = object
+  kind*: Uint32                ## ::
+              ##   < Event type, shared with all events
+  common*: CommonEvent         ## ::
+                     ##   < Common event data
+  display*: DisplayEvent       ## ::
+                       ##   < Display event data
+  window*: WindowEvent         ## ::
+                     ##   < Window event data
+  key*: KeyboardEvent          ## ::
+                    ##   < Keyboard event data
+  edit*: TextEditingEvent      ## ::
+                        ##   < Text editing event data
+  text*: TextInputEvent        ## ::
+                      ##   < Text input event data
+  motion*: MouseMotionEvent    ## ::
+                          ##   < Mouse motion event data
+  button*: MouseButtonEvent    ## ::
+                          ##   < Mouse button event data
+  wheel*: MouseWheelEvent      ## ::
+                        ##   < Mouse wheel event data
+  jaxis*: JoyAxisEvent         ## ::
+                     ##   < Joystick axis event data
+  jball*: JoyBallEvent         ## ::
+                     ##   < Joystick ball event data
+  jhat*: JoyHatEvent           ## ::
+                   ##   < Joystick hat event data
+  jbutton*: JoyButtonEvent     ## ::
+                         ##   < Joystick button event data
+  jdevice*: JoyDeviceEvent     ## ::
+                         ##   < Joystick device change event data
+  caxis*: ControllerAxisEvent  ## ::
+                            ##   < Game Controller axis event data
+  cbutton*: ControllerButtonEvent ## ::
+                                ##   < Game Controller button event data
+  cdevice*: ControllerDeviceEvent ## ::
+                                ##   < Game Controller device event data
+  adevice*: AudioDeviceEvent   ## ::
+                           ##   < Audio device event data
+  sensor*: SensorEvent         ## ::
+                     ##   < Sensor event data
+  quit*: QuitEvent             ## ::
+                 ##   < Quit request event data
+  user*: UserEvent             ## ::
+                 ##   < Custom event data
+  syswm*: SysWMEvent           ## ::
+                   ##   < System dependent window event data
+  tfinger*: TouchFingerEvent   ## ::
+                           ##   < Touch finger event data
+  mgesture*: MultiGestureEvent ## ::
+                             ##   < Gesture event data
+  dgesture*: DollarGestureEvent ## ::
+                              ##   < Gesture event data
+  drop*: DropEvent             ## ::
+                 ##   < Drag and drop event data
+  padding*: array[56, Uint8]
+
+
+ +
\brief General event structure
+ + +
+ +
EventFilter = proc (userdata: pointer; event: ptr Event): cint {...}{.cdecl.}
+
+ + + +
+ +
PHaptic {...}{.incompleteStruct.} = object
+
+ + + +
+ +
Haptic = PHaptic
+
+ + + +
+ +
HapticDirection {...}{.bycopy.} = object
+  kind*: Uint8                 ## ::
+             ##   < The type of encoding.
+  dir*: array[3, Sint32]        ## ::
+                      ##   < The encoded direction.
+  
+
+ +
\brief Structure that represents a haptic direction.
+  
+  This is the direction where the force comes from,
+  instead of the direction in which the force is exerted.
+  
+  Directions can be specified by:
+   - ::SDL_HAPTIC_POLAR : Specified by polar coordinates.
+   - ::SDL_HAPTIC_CARTESIAN : Specified by cartesian coordinates.
+   - ::SDL_HAPTIC_SPHERICAL : Specified by spherical coordinates.
+  
+  Cardinal directions of the haptic device are relative to the positioning
+  of the device.  North is considered to be away from the user.
+  
+  The following diagram represents the cardinal directions:
+  \verbatim
+                 .--.
+                 |__| .-------.
+                 |=.| |.-----.|
+                 |--| ||     ||
+                 |  | |'-----'|
+                 |__|~')_____('
+                   [ COMPUTER ]
+                     North (0,-1)
+                         ^
+                         |
+                         |
+   (-1,0)  West <----[ HAPTIC ]----> East (1,0)
+                         |
+                         |
+                         v
+                      South (0,1)
+                      [ USER ]
+                        \|||/
+                        (o o)
+                  ---ooO-(_)-Ooo---
+    \endverbatim
+  
+  If type is ::SDL_HAPTIC_POLAR, direction is encoded by hundredths of a
+  degree starting north and turning clockwise.  ::SDL_HAPTIC_POLAR only uses
+  the first \c dir parameter.  The cardinal directions would be:
+   - North: 0 (0 degrees)
+   - East: 9000 (90 degrees)
+   - South: 18000 (180 degrees)
+   - West: 27000 (270 degrees)
+  
+  If type is ::SDL_HAPTIC_CARTESIAN, direction is encoded by three positions
+  (X axis, Y axis and Z axis (with 3 axes)).  ::SDL_HAPTIC_CARTESIAN uses
+  the first three \c dir parameters.  The cardinal directions would be:
+   - North:  0,-1, 0
+   - East:   1, 0, 0
+   - South:  0, 1, 0
+   - West:  -1, 0, 0
+  
+  The Z axis represents the height of the effect if supported, otherwise
+  it's unused.  In cartesian encoding (1, 2) would be the same as (2, 4), you
+  can use any multiple you want, only the direction matters.
+  
+  If type is ::SDL_HAPTIC_SPHERICAL, direction is encoded by two rotations.
+  The first two \c dir parameters are used.  The \c dir parameters are as
+  follows (all values are in hundredths of degrees):
+   - Degrees from (1, 0) rotated towards (0, 1).
+   - Degrees towards (0, 0, 1) (device needs at least 3 axes).
+  
+  
+  Example of force coming from the south with all encodings (force coming
+  from the south means the user will have to pull the stick to counteract):
+  \code
+  SDL_HapticDirection direction;
+ 
+ Cartesian directions
+  direction.type = SDL_HAPTIC_CARTESIAN; Using cartesian direction encoding.
+  direction.dir[0] = 0; X position
+  direction.dir[1] = 1; Y position
+ Assuming the device has 2 axes, we don't need to specify third parameter.
+ 
+ Polar directions
+  direction.type = SDL_HAPTIC_POLAR; We'll be using polar direction encoding.
+  direction.dir[0] = 18000; Polar only uses first parameter
+ 
+ Spherical coordinates
+  direction.type = SDL_HAPTIC_SPHERICAL; Spherical encoding
+  direction.dir[0] = 9000; Since we only have two axes we don't need more parameters.
+  \endcode
+  
+  \sa SDL_HAPTIC_POLAR
+  \sa SDL_HAPTIC_CARTESIAN
+  \sa SDL_HAPTIC_SPHERICAL
+  \sa SDL_HapticEffect
+  \sa SDL_HapticNumAxes
+ + +
+ +
HapticConstant {...}{.bycopy.} = object
+  kind*: Uint16                ## ::
+              ##   < ::SDL_HAPTIC_CONSTANT
+  direction*: HapticDirection  ## ::
+                            ##   < Direction of the effect.
+  length*: Uint32              ## ::
+                ##   < Duration of the effect.
+  delay*: Uint16               ## ::
+               ##   < Delay before starting the effect.
+  button*: Uint16              ## ::
+                ##   < Button that triggers the effect.
+  interval*: Uint16            ## ::
+                  ##   < How soon it can be triggered again after button.
+  level*: Sint16               ## ::
+               ##   < Strength of the constant effect.
+  attackLength*: Uint16        ## ::
+                      ##   < Duration of the attack.
+  attackLevel*: Uint16         ## ::
+                     ##   < Level at the start of the attack.
+  fadeLength*: Uint16          ## ::
+                    ##   < Duration of the fade.
+  fadeLevel*: Uint16           ## ::
+                   ##   < Level at the end of the fade.
+  
+
+ +
\brief A structure containing a template for a Constant effect.
+  
+  This struct is exclusively for the ::SDL_HAPTIC_CONSTANT effect.
+  
+  A constant effect applies a constant force in the specified direction
+  to the joystick.
+  
+  \sa SDL_HAPTIC_CONSTANT
+  \sa SDL_HapticEffect
+ + +
+ +
HapticPeriodic {...}{.bycopy.} = object
+  kind*: Uint16 ## ::
+              ##   < ::SDL_HAPTIC_SINE, ::SDL_HAPTIC_LEFTRIGHT,
+              ##                                ::SDL_HAPTIC_TRIANGLE, ::SDL_HAPTIC_SAWTOOTHUP or
+              ##                                ::SDL_HAPTIC_SAWTOOTHDOWN
+  direction*: HapticDirection  ## ::
+                            ##   < Direction of the effect.
+  length*: Uint32              ## ::
+                ##   < Duration of the effect.
+  delay*: Uint16               ## ::
+               ##   < Delay before starting the effect.
+  button*: Uint16              ## ::
+                ##   < Button that triggers the effect.
+  interval*: Uint16            ## ::
+                  ##   < How soon it can be triggered again after button.
+  period*: Uint16              ## ::
+                ##   < Period of the wave.
+  magnitude*: Sint16           ## ::
+                   ##   < Peak value; if negative, equivalent to 180 degrees extra phase shift.
+  offset*: Sint16              ## ::
+                ##   < Mean value of the wave.
+  phase*: Uint16               ## ::
+               ##   < Positive phase shift given by hundredth of a degree.
+  attackLength*: Uint16        ## ::
+                      ##   < Duration of the attack.
+  attackLevel*: Uint16         ## ::
+                     ##   < Level at the start of the attack.
+  fadeLength*: Uint16          ## ::
+                    ##   < Duration of the fade.
+  fadeLevel*: Uint16           ## ::
+                   ##   < Level at the end of the fade.
+  
+
+ +
\brief A structure containing a template for a Periodic effect.
+  
+  The struct handles the following effects:
+   - ::SDL_HAPTIC_SINE
+   - ::SDL_HAPTIC_LEFTRIGHT
+   - ::SDL_HAPTIC_TRIANGLE
+   - ::SDL_HAPTIC_SAWTOOTHUP
+   - ::SDL_HAPTIC_SAWTOOTHDOWN
+  
+  A periodic effect consists in a wave-shaped effect that repeats itself
+  over time.  The type determines the shape of the wave and the parameters
+  determine the dimensions of the wave.
+  
+  Phase is given by hundredth of a degree meaning that giving the phase a value
+  of 9000 will displace it 25% of its period.  Here are sample values:
+   -     0: No phase displacement.
+   -  9000: Displaced 25% of its period.
+   - 18000: Displaced 50% of its period.
+   - 27000: Displaced 75% of its period.
+   - 36000: Displaced 100% of its period, same as 0, but 0 is preferred.
+  
+  Examples:
+  \verbatim
+    SDL_HAPTIC_SINE
+      __      __      __      __
+     /  \    /  \    /  \    /
+    /    \__/    \__/    \__/
+    SDL_HAPTIC_SQUARE
+     __    __    __    __    __
+    |  |  |  |  |  |  |  |  |  |
+    |  |__|  |__|  |__|  |__|  |
+    SDL_HAPTIC_TRIANGLE
+      /\    /\    /\    /\    /\
+     /  \  /  \  /  \  /  \  /
+    /    \/    \/    \/    \/
+    SDL_HAPTIC_SAWTOOTHUP
+      /|  /|  /|  /|  /|  /|  /|
+     / | / | / | / | / | / | / |
+    /  |/  |/  |/  |/  |/  |/  |
+    SDL_HAPTIC_SAWTOOTHDOWN
+    \  |\  |\  |\  |\  |\  |\  |
+     \ | \ | \ | \ | \ | \ | \ |
+      \|  \|  \|  \|  \|  \|  \|
+    \endverbatim
+  
+  \sa SDL_HAPTIC_SINE
+  \sa SDL_HAPTIC_LEFTRIGHT
+  \sa SDL_HAPTIC_TRIANGLE
+  \sa SDL_HAPTIC_SAWTOOTHUP
+  \sa SDL_HAPTIC_SAWTOOTHDOWN
+  \sa SDL_HapticEffect
+ + +
+ +
HapticCondition {...}{.bycopy.} = object
+  kind*: Uint16                ## ::
+              ##   < ::SDL_HAPTIC_SPRING, ::SDL_HAPTIC_DAMPER,
+              ##                                    ::SDL_HAPTIC_INERTIA or ::SDL_HAPTIC_FRICTION
+  direction*: HapticDirection  ## ::
+                            ##   < Direction of the effect - Not used ATM.
+  length*: Uint32              ## ::
+                ##   < Duration of the effect.
+  delay*: Uint16               ## ::
+               ##   < Delay before starting the effect.
+  button*: Uint16              ## ::
+                ##   < Button that triggers the effect.
+  interval*: Uint16            ## ::
+                  ##   < How soon it can be triggered again after button.
+  rightSat*: array[3, Uint16]   ## ::
+                           ##   < Level when joystick is to the positive side; max 0xFFFF.
+  leftSat*: array[3, Uint16]    ## ::
+                          ##   < Level when joystick is to the negative side; max 0xFFFF.
+  rightCoeff*: array[3, Sint16] ## ::
+                             ##   < How fast to increase the force towards the positive side.
+  leftCoeff*: array[3, Sint16]  ## ::
+                            ##   < How fast to increase the force towards the negative side.
+  deadband*: array[3, Uint16]   ## ::
+                           ##   < Size of the dead zone; max 0xFFFF: whole axis-range when 0-centered.
+  center*: array[3, Sint16]     ## ::
+                         ##   < Position of the dead zone.
+  
+
+ +
\brief A structure containing a template for a Condition effect.
+  
+  The struct handles the following effects:
+   - ::SDL_HAPTIC_SPRING: Effect based on axes position.
+   - ::SDL_HAPTIC_DAMPER: Effect based on axes velocity.
+   - ::SDL_HAPTIC_INERTIA: Effect based on axes acceleration.
+   - ::SDL_HAPTIC_FRICTION: Effect based on axes movement.
+  
+  Direction is handled by condition internals instead of a direction member.
+  The condition effect specific members have three parameters.  The first
+  refers to the X axis, the second refers to the Y axis and the third
+  refers to the Z axis.  The right terms refer to the positive side of the
+  axis and the left terms refer to the negative side of the axis.  Please
+  refer to the ::SDL_HapticDirection diagram for which side is positive and
+  which is negative.
+  
+  \sa SDL_HapticDirection
+  \sa SDL_HAPTIC_SPRING
+  \sa SDL_HAPTIC_DAMPER
+  \sa SDL_HAPTIC_INERTIA
+  \sa SDL_HAPTIC_FRICTION
+  \sa SDL_HapticEffect
+ + +
+ +
HapticRamp {...}{.bycopy.} = object
+  kind*: Uint16                ## ::
+              ##   < ::SDL_HAPTIC_RAMP
+  direction*: HapticDirection  ## ::
+                            ##   < Direction of the effect.
+  length*: Uint32              ## ::
+                ##   < Duration of the effect.
+  delay*: Uint16               ## ::
+               ##   < Delay before starting the effect.
+  button*: Uint16              ## ::
+                ##   < Button that triggers the effect.
+  interval*: Uint16            ## ::
+                  ##   < How soon it can be triggered again after button.
+  start*: Sint16               ## ::
+               ##   < Beginning strength level.
+  `end`*: Sint16               ## ::
+               ##   < Ending strength level.
+  attackLength*: Uint16        ## ::
+                      ##   < Duration of the attack.
+  attackLevel*: Uint16         ## ::
+                     ##   < Level at the start of the attack.
+  fadeLength*: Uint16          ## ::
+                    ##   < Duration of the fade.
+  fadeLevel*: Uint16           ## ::
+                   ##   < Level at the end of the fade.
+  
+
+ +
\brief A structure containing a template for a Ramp effect.
+  
+  This struct is exclusively for the ::SDL_HAPTIC_RAMP effect.
+  
+  The ramp effect starts at start strength and ends at end strength.
+  It augments in linear fashion.  If you use attack and fade with a ramp
+  the effects get added to the ramp effect making the effect become
+  quadratic instead of linear.
+  
+  \sa SDL_HAPTIC_RAMP
+  \sa SDL_HapticEffect
+ + +
+ +
HapticLeftRight {...}{.bycopy.} = object
+  kind*: Uint16                ## ::
+              ##   < ::SDL_HAPTIC_LEFTRIGHT
+  length*: Uint32              ## ::
+                ##   < Duration of the effect in milliseconds.
+  largeMagnitude*: Uint16      ## ::
+                        ##   < Control of the large controller motor.
+  smallMagnitude*: Uint16      ## ::
+                        ##   < Control of the small controller motor.
+  
+
+ +
\brief A structure containing a template for a Left/Right effect.
+ 
+ This struct is exclusively for the ::SDL_HAPTIC_LEFTRIGHT effect.
+ 
+ The Left/Right effect is used to explicitly control the large and small
+ motors, commonly found in modern game controllers. The small (right) motor
+ is high frequency, and the large (left) motor is low frequency.
+ 
+ \sa SDL_HAPTIC_LEFTRIGHT
+ \sa SDL_HapticEffect
+ + +
+ +
HapticCustom {...}{.bycopy.} = object
+  kind*: Uint16                ## ::
+              ##   < ::SDL_HAPTIC_CUSTOM
+  direction*: HapticDirection  ## ::
+                            ##   < Direction of the effect.
+  length*: Uint32              ## ::
+                ##   < Duration of the effect.
+  delay*: Uint16               ## ::
+               ##   < Delay before starting the effect.
+  button*: Uint16              ## ::
+                ##   < Button that triggers the effect.
+  interval*: Uint16            ## ::
+                  ##   < How soon it can be triggered again after button.
+  channels*: Uint8             ## ::
+                 ##   < Axes to use, minimum of one.
+  period*: Uint16              ## ::
+                ##   < Sample periods.
+  samples*: Uint16             ## ::
+                 ##   < Amount of samples.
+  data*: ptr Uint16             ## ::
+                 ##   < Should contain channelssamples items.
+  attackLength*: Uint16        ## ::
+                      ##   < Duration of the attack.
+  attackLevel*: Uint16         ## ::
+                     ##   < Level at the start of the attack.
+  fadeLength*: Uint16          ## ::
+                    ##   < Duration of the fade.
+  fadeLevel*: Uint16           ## ::
+                   ##   < Level at the end of the fade.
+  
+
+ +
\brief A structure containing a template for the ::SDL_HAPTIC_CUSTOM effect.
+  
+  This struct is exclusively for the ::SDL_HAPTIC_CUSTOM effect.
+  
+  A custom force feedback effect is much like a periodic effect, where the
+  application can define its exact shape.  You will have to allocate the
+  data yourself.  Data should consist of channels samples Uint16 samples.
+  
+  If channels is one, the effect is rotated using the defined direction.
+  Otherwise it uses the samples in data for the different axes.
+  
+  \sa SDL_HAPTIC_CUSTOM
+  \sa SDL_HapticEffect
+ + +
+ +
HapticEffect {...}{.union, bycopy.} = object
+  kind*: Uint16                ## ::
+              ##   < Effect type.
+  constant*: HapticConstant    ## ::
+                          ##   < Constant effect.
+  periodic*: HapticPeriodic    ## ::
+                          ##   < Periodic effect.
+  condition*: HapticCondition  ## ::
+                            ##   < Condition effect.
+  ramp*: HapticRamp            ## ::
+                  ##   < Ramp effect.
+  leftright*: HapticLeftRight  ## ::
+                            ##   < Left/Right effect.
+  custom*: HapticCustom        ## ::
+                      ##   < Custom effect.
+  
+
+ +
\brief The generic template for any haptic effect.
+  
+  All values max at 32767 (0x7FFF).  Signed values also can be negative.
+  Time values unless specified otherwise are in milliseconds.
+  
+  You can also pass ::SDL_HAPTIC_INFINITY to length instead of a 0-32767
+  value.  Neither delay, interval, attack_length nor fade_length support
+  ::SDL_HAPTIC_INFINITY.  Fade will also not be used since effect never ends.
+  
+  Additionally, the ::SDL_HAPTIC_RAMP effect does not support a duration of
+  ::SDL_HAPTIC_INFINITY.
+  
+  Button triggers may not be supported on all devices, it is advised to not
+  use them if possible.  Buttons start at index 1 instead of index 0 like
+  the joystick.
+  
+  If both attack_length and fade_level are 0, the envelope is not used,
+  otherwise both values are used.
+  
+  Common parts:
+  \code
+ Replay - All effects have this
+  Uint32 length; Duration of effect (ms).
+  Uint16 delay; Delay before starting effect.
+ 
+ Trigger - All effects have this
+  Uint16 button; Button that triggers effect.
+  Uint16 interval; How soon before effect can be triggered again.
+ 
+ Envelope - All effects except condition effects have this
+  Uint16 attack_length; Duration of the attack (ms).
+  Uint16 attack_level; Level at the start of the attack.
+  Uint16 fade_length; Duration of the fade out (ms).
+  Uint16 fade_level; Level at the end of the fade.
+  \endcode
+  
+  
+  Here we have an example of a constant effect evolution in time:
+  \verbatim
+    Strength
+    ^
+    |
+    |    effect level -->  _________________
+    |                     /                 \
+    |                    /                   \
+    |                   /                     \
+    |                  /                       \
+    | attack_level --> |                        \
+    |                  |                        |  <---  fade_level
+    |
+    +--------------------------------------------------> Time
+                       [--]                 [---]
+                       attack_length        fade_length
+    [------------------][-----------------------]
+    delay               length
+    \endverbatim
+  
+  Note either the attack_level or the fade_level may be above the actual
+  effect level.
+  
+  \sa SDL_HapticConstant
+  \sa SDL_HapticPeriodic
+  \sa SDL_HapticCondition
+  \sa SDL_HapticRamp
+  \sa SDL_HapticLeftRight
+  \sa SDL_HapticCustom
+ + +
+ +
HintCallback = proc (userdata: pointer; name: cstring; oldValue: cstring;
+                  newValue: cstring) {...}{.cdecl.}
+
+ + + +
+ +
LogOutputFunction = proc (userdata: pointer; category: cint; priority: LogPriority;
+                       message: cstring) {...}{.cdecl.}
+
+ + + +
+ +
MessageBoxButtonData {...}{.bycopy.} = object
+  flags*: Uint32               ## ::
+               ##   < ::SDL_MessageBoxButtonFlags
+  buttonid*: cint              ## ::
+                ##   < User defined button id (value returned via SDL_ShowMessageBox)
+  text*: cstring               ## ::
+               ##   < The UTF-8 button text
+  
+
+ +
\brief Individual button data.
+ + +
+ +
MessageBoxColor {...}{.bycopy.} = object
+  r*: Uint8
+  g*: Uint8
+  b*: Uint8
+
+
+ +
\brief RGB value used in a message box color scheme
+ + +
+ +
MessageBoxColorScheme {...}{.bycopy.} = object
+  colors*: array[MESSAGEBOX_COLOR_MAX, MessageBoxColor]
+
+
+ +
\brief A set of colors to use for message box dialogs
+ + +
+ +
MessageBoxData {...}{.bycopy.} = object
+  flags*: Uint32               ## ::
+               ##   < ::SDL_MessageBoxFlags
+  window*: ptr Window           ## ::
+                   ##   < Parent window, can be NULL
+  title*: cstring              ## ::
+                ##   < UTF-8 title
+  message*: cstring            ## ::
+                  ##   < UTF-8 message text
+  numbuttons*: cint
+  buttons*: ptr MessageBoxButtonData
+  colorScheme*: ptr MessageBoxColorScheme ## ::
+                                       ##   < ::SDL_MessageBoxColorScheme, can be NULL to use system settings
+  
+
+ +
\brief MessageBox structure containing title, text, window, etc.
+ + +
+ +
MetalView = pointer
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+\brief A handle to a CAMetalLayer-backed NSView (macOS) or UIView (iOS/tvOS).
+  
+  \note This can be cast directly to an NSView or UIView.
+ + +
+ +
RendererInfo {...}{.bycopy.} = object
+  name*: cstring               ## ::
+               ##   < The name of the renderer
+  flags*: Uint32               ## ::
+               ##   < Supported ::SDL_RendererFlags
+  numTextureFormats*: Uint32   ## ::
+                           ##   < The number of available texture formats
+  textureFormats*: array[16, Uint32] ## ::
+                                  ##   < The available texture formats
+  maxTextureWidth*: cint       ## ::
+                       ##   < The maximum texture width
+  maxTextureHeight*: cint      ## ::
+                        ##   < The maximum texture height
+  
+
+ +
\brief Information on the capabilities of a render driver or context.
+ + +
+ +
Renderer {...}{.incompleteStruct.} = object
+
+ + + +
+ +
Texture {...}{.incompleteStruct.} = object
+
+ + + +
+ +
Sensor {...}{.incompleteStruct.} = object
+
+ + + +
+ +
SensorID = Sint32
+
+ +
This is a unique ID for a sensor for the time it is connected to the system,
+ and is never reused for the lifetime of the application.
+ 
+ The ID value starts at 0 and increments from there. The value -1 is an invalid ID.
+ + +
+ +
WindowShapeParams {...}{.union, bycopy.} = object
+  binarizationCutoff*: Uint8
+  colorKey*: Color
+
+
+ +
\brief A union containing parameters for shaped windows.
+ + +
+ +
TimerCallback = proc (interval: Uint32; param: pointer): Uint32 {...}{.cdecl.}
+
+ + + +
+ +
TimerID = cint
+
+ +
Definition of the timer ID type.
+ + +
+ +
Version {...}{.bycopy.} = object
+  major*: Uint8                ## ::
+              ##   < major version
+  minor*: Uint8                ## ::
+              ##   < minor version
+  patch*: Uint8                ## ::
+              ##   < update version
+  
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+\brief Information the version of SDL in use.
+  
+  Represents the library's version as three levels: major revision
+  (increments with massive changes, additions, and enhancements),
+  minor revision (increments with backwards-compatible changes to the
+  major revision), and patchlevel (increments with fixes to the minor
+  revision).
+  
+  \sa SDL_VERSION
+  \sa SDL_GetVersion
+ + +
+ +
+
+

Consts

+
+ +
SDLCacheDir = "/Users/joey/Projects/nim-sdl2/src/build"
+
+ + + +
+ +
SDLStd = false
+
+ + + +
+ +
SDLGit = false
+
+ + + +
+ +
SDLDL = true
+
+ + + +
+ +
SDLStatic = true
+
+ + + +
+ +
SDLSetVer = ""
+
+ + + +
+ +
SDLLPath = "/Users/joey/Projects/nim-sdl2/src/build/sdl2/buildcache/libSDL2.a"
+
+ + + +
+ +
SDLPath = "/Users/joey/Projects/nim-sdl2/src/build/sdl2/include/SDL.h"
+
+ + + +
+ +
MIN_UINT8 = 0'u8
+
+ + + +
+ +
MIN_UINT64 = 0'u64
+
+ + + +
+ +
MAX_SINT16 = 32767'i16
+
+ + + +
+ +
MAX_SINT32 = 2147483647'i32
+
+ + + +
+ +
Colour = ""
+
+ + + +
+ +
MOUSE_TOUCHID = -1'i64
+
+ + + +
+ +
WINDOWPOS_CENTERED_MASK = 805240832'u
+
+ + + +
+ +
MAX_UINT8 = 255'u8
+
+ + + +
+ +
BlitScaled = ""
+
+ + + +
+ +
MIN_SINT8 = -128'i8
+
+ + + +
+ +
MIN_UINT16 = 0'u16
+
+ + + +
+ +
MIN_UINT32 = 0'u32
+
+ + + +
+ +
TOUCH_MOUSEID = 4294967295
+
+ + + +
+ +
BlitSurface = ""
+
+ + + +
+ +
WINDOWPOS_UNDEFINED_MASK = 536805376'u
+
+ + + +
+ +
MIN_SINT32 = -2147483648'i32
+
+ + + +
+ +
MUTEX_MAXWAIT = 4294967295
+
+ + + +
+ +
MAX_SINT8 = 127'i8
+
+ + + +
+ +
MAX_UINT16 = 65535'u16
+
+ + + +
+ +
MAX_UINT32 = 4294967295'u32
+
+ + + +
+ +
MIN_SINT16 = -32768'i16
+
+ + + +
+ +
MAX_UINT64 = 18446744073709551615'u64
+
+ + + +
+ +
MAX_SINT64 = 9223372036854775807'i64
+
+ + + +
+ +
MACOSX = 1
+
+ + + +
+ +
SIZEOF_VOIDP = 8
+
+ + + +
+ +
HAVE_GCC_ATOMICS = 1
+
+ + + +
+ +
HAVE_LIBC = 1
+
+ + + +
+ +
STDC_HEADERS = 1
+
+ + + +
+ +
HAVE_ALLOCA_H = 1
+
+ + + +
+ +
HAVE_CTYPE_H = 1
+
+ + + +
+ +
HAVE_FLOAT_H = 1
+
+ + + +
+ +
HAVE_ICONV_H = 1
+
+ + + +
+ +
HAVE_INTTYPES_H = 1
+
+ + + +
+ +
HAVE_LIMITS_H = 1
+
+ + + +
+ +
HAVE_MATH_H = 1
+
+ + + +
+ +
HAVE_MEMORY_H = 1
+
+ + + +
+ +
HAVE_SIGNAL_H = 1
+
+ + + +
+ +
HAVE_STDARG_H = 1
+
+ + + +
+ +
HAVE_STDINT_H = 1
+
+ + + +
+ +
HAVE_STDIO_H = 1
+
+ + + +
+ +
HAVE_STDLIB_H = 1
+
+ + + +
+ +
HAVE_STRINGS_H = 1
+
+ + + +
+ +
HAVE_STRING_H = 1
+
+ + + +
+ +
HAVE_SYS_TYPES_H = 1
+
+ + + +
+ +
HAVE_WCHAR_H = 1
+
+ + + +
+ +
HAVE_LIBUNWIND_H = 1
+
+ + + +
+ +
HAVE_MALLOC = 1
+
+ + + +
+ +
HAVE_CALLOC = 1
+
+ + + +
+ +
HAVE_REALLOC = 1
+
+ + + +
+ +
HAVE_FREE = 1
+
+ + + +
+ +
HAVE_ALLOCA = 1
+
+ + + +
+ +
HAVE_GETENV = 1
+
+ + + +
+ +
HAVE_SETENV = 1
+
+ + + +
+ +
HAVE_PUTENV = 1
+
+ + + +
+ +
HAVE_UNSETENV = 1
+
+ + + +
+ +
HAVE_QSORT = 1
+
+ + + +
+ +
HAVE_ABS = 1
+
+ + + +
+ +
HAVE_BCOPY = 1
+
+ + + +
+ +
HAVE_MEMSET = 1
+
+ + + +
+ +
HAVE_MEMCPY = 1
+
+ + + +
+ +
HAVE_MEMMOVE = 1
+
+ + + +
+ +
HAVE_MEMCMP = 1
+
+ + + +
+ +
HAVE_WCSLEN = 1
+
+ + + +
+ +
HAVE_WCSLCPY = 1
+
+ + + +
+ +
HAVE_WCSLCAT = 1
+
+ + + +
+ +
HAVE_WCSDUP = 1
+
+ + + +
+ +
HAVE_WCSSTR = 1
+
+ + + +
+ +
HAVE_WCSCMP = 1
+
+ + + +
+ +
HAVE_WCSNCMP = 1
+
+ + + +
+ +
HAVE_STRLEN = 1
+
+ + + +
+ +
HAVE_STRLCPY = 1
+
+ + + +
+ +
HAVE_STRLCAT = 1
+
+ + + +
+ +
HAVE_STRCHR = 1
+
+ + + +
+ +
HAVE_STRRCHR = 1
+
+ + + +
+ +
HAVE_STRSTR = 1
+
+ + + +
+ +
HAVE_STRTOK_R = 1
+
+ + + +
+ +
HAVE_STRTOL = 1
+
+ + + +
+ +
HAVE_STRTOUL = 1
+
+ + + +
+ +
HAVE_STRTOLL = 1
+
+ + + +
+ +
HAVE_STRTOULL = 1
+
+ + + +
+ +
HAVE_STRTOD = 1
+
+ + + +
+ +
HAVE_ATOI = 1
+
+ + + +
+ +
HAVE_ATOF = 1
+
+ + + +
+ +
HAVE_STRCMP = 1
+
+ + + +
+ +
HAVE_STRNCMP = 1
+
+ + + +
+ +
HAVE_STRCASECMP = 1
+
+ + + +
+ +
HAVE_STRNCASECMP = 1
+
+ + + +
+ +
HAVE_VSSCANF = 1
+
+ + + +
+ +
HAVE_VSNPRINTF = 1
+
+ + + +
+ +
HAVE_ACOS = 1
+
+ + + +
+ +
HAVE_ACOSF = 1
+
+ + + +
+ +
HAVE_ASIN = 1
+
+ + + +
+ +
HAVE_ASINF = 1
+
+ + + +
+ +
HAVE_ATAN = 1
+
+ + + +
+ +
HAVE_ATANF = 1
+
+ + + +
+ +
HAVE_ATAN2 = 1
+
+ + + +
+ +
HAVE_ATAN2F = 1
+
+ + + +
+ +
HAVE_CEIL = 1
+
+ + + +
+ +
HAVE_CEILF = 1
+
+ + + +
+ +
HAVE_COPYSIGN = 1
+
+ + + +
+ +
HAVE_COPYSIGNF = 1
+
+ + + +
+ +
HAVE_COS = 1
+
+ + + +
+ +
HAVE_COSF = 1
+
+ + + +
+ +
HAVE_EXP = 1
+
+ + + +
+ +
HAVE_EXPF = 1
+
+ + + +
+ +
HAVE_FABS = 1
+
+ + + +
+ +
HAVE_FABSF = 1
+
+ + + +
+ +
HAVE_FLOOR = 1
+
+ + + +
+ +
HAVE_FLOORF = 1
+
+ + + +
+ +
HAVE_FMOD = 1
+
+ + + +
+ +
HAVE_FMODF = 1
+
+ + + +
+ +
HAVE_LOG = 1
+
+ + + +
+ +
HAVE_LOGF = 1
+
+ + + +
+ +
HAVE_LOG10 = 1
+
+ + + +
+ +
HAVE_LOG10F = 1
+
+ + + +
+ +
HAVE_POW = 1
+
+ + + +
+ +
HAVE_POWF = 1
+
+ + + +
+ +
HAVE_SCALBN = 1
+
+ + + +
+ +
HAVE_SCALBNF = 1
+
+ + + +
+ +
HAVE_SIN = 1
+
+ + + +
+ +
HAVE_SINF = 1
+
+ + + +
+ +
HAVE_SQRT = 1
+
+ + + +
+ +
HAVE_SQRTF = 1
+
+ + + +
+ +
HAVE_TAN = 1
+
+ + + +
+ +
HAVE_TANF = 1
+
+ + + +
+ +
HAVE_FSEEKO = 1
+
+ + + +
+ +
HAVE_SIGACTION = 1
+
+ + + +
+ +
HAVE_SA_SIGACTION = 1
+
+ + + +
+ +
HAVE_SETJMP = 1
+
+ + + +
+ +
HAVE_NANOSLEEP = 1
+
+ + + +
+ +
HAVE_SYSCONF = 1
+
+ + + +
+ +
HAVE_SYSCTLBYNAME = 1
+
+ + + +
+ +
HAVE_MPROTECT = 1
+
+ + + +
+ +
HAVE_ICONV = 1
+
+ + + +
+ +
HAVE_PTHREAD_SETNAME_NP = 1
+
+ + + +
+ +
HAVE_POLL = 1
+
+ + + +
+ +
HAVE_EXIT = 1
+
+ + + +
+ +
HAVE_IMMINTRIN_H = 1
+
+ + + +
+ +
AUDIO_DRIVER_COREAUDIO = 1
+
+ + + +
+ +
AUDIO_DRIVER_DISK = 1
+
+ + + +
+ +
AUDIO_DRIVER_DUMMY = 1
+
+ + + +
+ +
JOYSTICK_IOKIT = 1
+
+ + + +
+ +
HAPTIC_TYPE_IOKIT = 1
+
+ + + +
+ +
SENSOR_DUMMY = 1
+
+ + + +
+ +
LOADSO_DLOPEN = 1
+
+ + + +
+ +
THREAD_PTHREAD = 1
+
+ + + +
+ +
THREAD_PTHREAD_RECURSIVE_MUTEX = 1
+
+ + + +
+ +
TIMER_UNIX = 1
+
+ + + +
+ +
VIDEO_DRIVER_COCOA = 1
+
+ + + +
+ +
VIDEO_DRIVER_DUMMY = 1
+
+ + + +
+ +
VIDEO_RENDER_OGL = 1
+
+ + + +
+ +
VIDEO_RENDER_OGL_ES2 = 1
+
+ + + +
+ +
VIDEO_RENDER_METAL = 1
+
+ + + +
+ +
VIDEO_OPENGL = 1
+
+ + + +
+ +
VIDEO_OPENGL_ES2 = 1
+
+ + + +
+ +
VIDEO_OPENGL_CGL = 1
+
+ + + +
+ +
VIDEO_OPENGL_EGL = 1
+
+ + + +
+ +
VIDEO_VULKAN = 1
+
+ + + +
+ +
VIDEO_METAL = 1
+
+ + + +
+ +
POWER_MACOSX = 1
+
+ + + +
+ +
FILESYSTEM_COCOA = 1
+
+ + + +
+ +
ASSEMBLY_ROUTINES = 1
+
+ + + +
+ +
PRIs64 = "lld"
+
+ + + +
+ +
ICONV_ERROR = -1
+
+ + + +
+ +
ICONV_E2BIG = -2
+
+ + + +
+ +
ICONV_EILSEQ = -3
+
+ + + +
+ +
ICONV_EINVAL = -4
+
+ + + +
+ +
ASSERT_LEVEL = 2
+
+ + + +
+ +
NULL_WHILE_LOOP_CONDITION = 0
+
+ + + +
+ +
ASSERTION_RETRY = 0'i32
+
+ +
< Retry the assert immediately.
+ + +
+ +
ASSERTION_BREAK = 1
+
+ +
< Make the debugger trigger a breakpoint.
+ + +
+ +
ASSERTION_ABORT = 2
+
+ +
< Terminate the program.
+ + +
+ +
ASSERTION_IGNORE = 3
+
+ +
< Ignore the assert.
+ + +
+ +
ASSERTION_ALWAYS_IGNORE = 4
+
+ +
< Ignore the assert from now on.
+ + +
+ +
ENOMEM = 0'i32
+
+ + + +
+ +
EFREAD = 1
+
+ + + +
+ +
EFWRITE = 2
+
+ + + +
+ +
EFSEEK = 3
+
+ + + +
+ +
UNSUPPORTED = 4
+
+ + + +
+ +
LASTERROR = 5
+
+ + + +
+ +
LIL_ENDIAN = 1234
+
+ + + +
+ +
BIG_ENDIAN = 4321
+
+ + + +
+ +
BYTEORDER = 1234
+
+ + + +
+ +
MUTEX_TIMEDOUT = 1
+
+ + + +
+ +
THREAD_PRIORITY_LOW = 0'i32
+
+ + + +
+ +
THREAD_PRIORITY_NORMAL = 1
+
+ + + +
+ +
THREAD_PRIORITY_HIGH = 2
+
+ + + +
+ +
THREAD_PRIORITY_TIME_CRITICAL = 3
+
+ + + +
+ +
RWOPS_UNKNOWN = 0'u
+
+ + + +
+ +
RWOPS_WINFILE = 1'u
+
+ + + +
+ +
RWOPS_STDFILE = 2'u
+
+ + + +
+ +
RWOPS_JNIFILE = 3'u
+
+ + + +
+ +
RWOPS_MEMORY = 4'u
+
+ + + +
+ +
RWOPS_MEMORY_RO = 5'u
+
+ + + +
+ +
RW_SEEK_SET = 0
+
+ + + +
+ +
RW_SEEK_CUR = 1
+
+ + + +
+ +
RW_SEEK_END = 2
+
+ + + +
+ +
AUDIO_MASK_BITSIZE = 0x000000FF
+
+ + + +
+ +
AUDIO_MASK_DATATYPE = 256
+
+ + + +
+ +
AUDIO_MASK_ENDIAN = 4096
+
+ + + +
+ +
AUDIO_MASK_SIGNED = 32768
+
+ + + +
+ +
AUDIO_U8 = 0x00000008
+
+ + + +
+ +
AUDIO_S8 = 0x00008008
+
+ + + +
+ +
AUDIO_U16LSB = 0x00000010
+
+ + + +
+ +
AUDIO_S16LSB = 0x00008010
+
+ + + +
+ +
AUDIO_U16MSB = 0x00001010
+
+ + + +
+ +
AUDIO_S16MSB = 0x00009010
+
+ + + +
+ +
AUDIO_U16 = 0x00000010
+
+ + + +
+ +
AUDIO_S16 = 0x00008010
+
+ + + +
+ +
AUDIO_S32LSB = 0x00008020
+
+ + + +
+ +
AUDIO_S32MSB = 0x00009020
+
+ + + +
+ +
AUDIO_S32 = 0x00008020
+
+ + + +
+ +
AUDIO_F32LSB = 0x00008120
+
+ + + +
+ +
AUDIO_F32MSB = 0x00009120
+
+ + + +
+ +
AUDIO_F32 = 0x00008120
+
+ + + +
+ +
AUDIO_U16SYS = 0x00000010
+
+ + + +
+ +
AUDIO_S16SYS = 0x00008010
+
+ + + +
+ +
AUDIO_S32SYS = 0x00008020
+
+ + + +
+ +
AUDIO_F32SYS = 0x00008120
+
+ + + +
+ +
AUDIO_ALLOW_FREQUENCY_CHANGE = 0x00000001
+
+ + + +
+ +
AUDIO_ALLOW_FORMAT_CHANGE = 0x00000002
+
+ + + +
+ +
AUDIO_ALLOW_CHANNELS_CHANGE = 0x00000004
+
+ + + +
+ +
AUDIO_ALLOW_SAMPLES_CHANGE = 0x00000008
+
+ + + +
+ +
AUDIO_ALLOW_ANY_CHANGE = 15
+
+ + + +
+ +
AUDIOCVT_MAX_FILTERS = 9
+
+ + + +
+ +
AUDIO_STOPPED = 0'i32
+
+ + + +
+ +
AUDIO_PLAYING = 1
+
+ + + +
+ +
AUDIO_PAUSED = 2
+
+ + + +
+ +
MIX_MAXVOLUME = 128
+
+ + + +
+ +
CACHELINE_SIZE = 128
+
+ + + +
+ +
ALPHA_OPAQUE = 255
+
+ + + +
+ +
ALPHA_TRANSPARENT = 0
+
+ + + +
+ +
PIXELTYPE_UNKNOWN = 0'i32
+
+ + + +
+ +
PIXELTYPE_INDEX1 = 1
+
+ + + +
+ +
PIXELTYPE_INDEX4 = 2
+
+ + + +
+ +
PIXELTYPE_INDEX8 = 3
+
+ + + +
+ +
PIXELTYPE_PACKED8 = 4
+
+ + + +
+ +
PIXELTYPE_PACKED16 = 5
+
+ + + +
+ +
PIXELTYPE_PACKED32 = 6
+
+ + + +
+ +
PIXELTYPE_ARRAYU8 = 7
+
+ + + +
+ +
PIXELTYPE_ARRAYU16 = 8
+
+ + + +
+ +
PIXELTYPE_ARRAYU32 = 9
+
+ + + +
+ +
PIXELTYPE_ARRAYF16 = 10
+
+ + + +
+ +
PIXELTYPE_ARRAYF32 = 11
+
+ + + +
+ +
BITMAPORDER_NONE = 0'i32
+
+ + + +
+ +
BITMAPORDER_4321 = 1
+
+ + + +
+ +
BITMAPORDER_1234 = 2
+
+ + + +
+ +
PACKEDORDER_NONE = 0'i32
+
+ + + +
+ +
PACKEDORDER_XRGB = 1
+
+ + + +
+ +
PACKEDORDER_RGBX = 2
+
+ + + +
+ +
PACKEDORDER_ARGB = 3
+
+ + + +
+ +
PACKEDORDER_RGBA = 4
+
+ + + +
+ +
PACKEDORDER_XBGR = 5
+
+ + + +
+ +
PACKEDORDER_BGRX = 6
+
+ + + +
+ +
PACKEDORDER_ABGR = 7
+
+ + + +
+ +
PACKEDORDER_BGRA = 8
+
+ + + +
+ +
ARRAYORDER_NONE = 0'i32
+
+ + + +
+ +
ARRAYORDER_RGB = 1
+
+ + + +
+ +
ARRAYORDER_RGBA = 2
+
+ + + +
+ +
ARRAYORDER_ARGB = 3
+
+ + + +
+ +
ARRAYORDER_BGR = 4
+
+ + + +
+ +
ARRAYORDER_BGRA = 5
+
+ + + +
+ +
ARRAYORDER_ABGR = 6
+
+ + + +
+ +
PACKEDLAYOUT_NONE = 0'i32
+
+ + + +
+ +
PACKEDLAYOUT_332 = 1
+
+ + + +
+ +
PACKEDLAYOUT_4444 = 2
+
+ + + +
+ +
PACKEDLAYOUT_1555 = 3
+
+ + + +
+ +
PACKEDLAYOUT_5551 = 4
+
+ + + +
+ +
PACKEDLAYOUT_565 = 5
+
+ + + +
+ +
PACKEDLAYOUT_8888 = 6
+
+ + + +
+ +
PACKEDLAYOUT_2101010 = 7
+
+ + + +
+ +
PACKEDLAYOUT_1010102 = 8
+
+ + + +
+ +
PIXELFORMAT_UNKNOWN = 0'i32
+
+ + + +
+ +
PIXELFORMAT_INDEX1LSB = 286261504'i32
+
+ + + +
+ +
PIXELFORMAT_INDEX1MSB = 287310080'i32
+
+ + + +
+ +
PIXELFORMAT_INDEX4LSB = 303039488'i32
+
+ + + +
+ +
PIXELFORMAT_INDEX4MSB = 304088064'i32
+
+ + + +
+ +
PIXELFORMAT_INDEX8 = 318769153'i32
+
+ + + +
+ +
PIXELFORMAT_RGB332 = 336660481'i32
+
+ + + +
+ +
PIXELFORMAT_RGB444 = 353504258'i32
+
+ + + +
+ +
PIXELFORMAT_BGR444 = 357698562'i32
+
+ + + +
+ +
PIXELFORMAT_RGB555 = 353570562'i32
+
+ + + +
+ +
PIXELFORMAT_BGR555 = 357764866'i32
+
+ + + +
+ +
PIXELFORMAT_ARGB4444 = 355602434'i32
+
+ + + +
+ +
PIXELFORMAT_RGBA4444 = 356651010'i32
+
+ + + +
+ +
PIXELFORMAT_ABGR4444 = 359796738'i32
+
+ + + +
+ +
PIXELFORMAT_BGRA4444 = 360845314'i32
+
+ + + +
+ +
PIXELFORMAT_ARGB1555 = 355667970'i32
+
+ + + +
+ +
PIXELFORMAT_RGBA5551 = 356782082'i32
+
+ + + +
+ +
PIXELFORMAT_ABGR1555 = 359862274'i32
+
+ + + +
+ +
PIXELFORMAT_BGRA5551 = 360976386'i32
+
+ + + +
+ +
PIXELFORMAT_RGB565 = 353701890'i32
+
+ + + +
+ +
PIXELFORMAT_BGR565 = 357896194'i32
+
+ + + +
+ +
PIXELFORMAT_RGB24 = 386930691'i32
+
+ + + +
+ +
PIXELFORMAT_BGR24 = 390076419'i32
+
+ + + +
+ +
PIXELFORMAT_RGB888 = 370546692'i32
+
+ + + +
+ +
PIXELFORMAT_RGBX8888 = 371595268'i32
+
+ + + +
+ +
PIXELFORMAT_BGR888 = 374740996'i32
+
+ + + +
+ +
PIXELFORMAT_BGRX8888 = 375789572'i32
+
+ + + +
+ +
PIXELFORMAT_ARGB8888 = 372645892'i32
+
+ + + +
+ +
PIXELFORMAT_RGBA8888 = 373694468'i32
+
+ + + +
+ +
PIXELFORMAT_ABGR8888 = 376840196'i32
+
+ + + +
+ +
PIXELFORMAT_BGRA8888 = 377888772'i32
+
+ + + +
+ +
PIXELFORMAT_ARGB2101010 = 372711428'i32
+
+ +
Aliases for RGBA byte arrays of color data, for the current platform
+ + +
+ +
PIXELFORMAT_RGBA32 = 376840196'i32
+
+ + + +
+ +
PIXELFORMAT_ARGB32 = 377888772'i32
+
+ + + +
+ +
PIXELFORMAT_BGRA32 = 372645892'i32
+
+ + + +
+ +
PIXELFORMAT_ABGR32 = 373694468'i32
+
+ + + +
+ +
PIXELFORMAT_YV12 = 373694469
+
+ + + +
+ +
PIXELFORMAT_IYUV = 373694470
+
+ + + +
+ +
PIXELFORMAT_YUY2 = 373694471
+
+ + + +
+ +
PIXELFORMAT_UYVY = 373694472
+
+ + + +
+ +
PIXELFORMAT_YVYU = 373694473
+
+ + + +
+ +
PIXELFORMAT_NV12 = 373694474
+
+ + + +
+ +
PIXELFORMAT_NV21 = 373694475
+
+ + + +
+ +
PIXELFORMAT_EXTERNAL_OES = 373694476
+
+ + + +
+ +
BLENDMODE_NONE = 0'i32
+
+ +
< no blending
+                                              dstRGBA = srcRGBA
+ + +
+ +
BLENDMODE_BLEND = 1'i32
+
+ +
< alpha blending
+                                              dstRGB = (srcRGB srcA) + (dstRGB (1-srcA))
+                                              dstA = srcA + (dstA (1-srcA))
+ + +
+ +
BLENDMODE_ADD = 2'i32
+
+ +
< additive blending
+                                              dstRGB = (srcRGB srcA) + dstRGB
+                                              dstA = dstA
+ + +
+ +
BLENDMODE_MOD = 4'i32
+
+ +
< color modulate
+                                              dstRGB = srcRGB dstRGB
+                                              dstA = dstA
+ + +
+ +
BLENDMODE_MUL = 8'i32
+
+ +
< color multiply
+                                              dstRGB = (srcRGB dstRGB) + (dstRGB (1-srcA))
+                                              dstA = (srcA dstA) + (dstA (1-srcA))
+ + +
+ +
BLENDMODE_INVALID = 2147483647'i32
+
+ +
Additional custom blend modes can be returned by SDL_ComposeCustomBlendMode()
+ + +
+ +
BLENDOPERATION_ADD = 1'i32
+
+ +
< dst + src: supported by all renderers
+ + +
+ +
BLENDOPERATION_SUBTRACT = 2'i32
+
+ +
< dst - src : supported by D3D9, D3D11, OpenGL, OpenGLES
+ + +
+ +
BLENDOPERATION_REV_SUBTRACT = 3'i32
+
+ +
< src - dst : supported by D3D9, D3D11, OpenGL, OpenGLES
+ + +
+ +
BLENDOPERATION_MINIMUM = 4'i32
+
+ +
< min(dst, src) : supported by D3D11
+ + +
+ +
BLENDOPERATION_MAXIMUM = 5'i32
+
+ +
< max(dst, src) : supported by D3D11
+ + +
+ +
BLENDFACTOR_ZERO = 1'i32
+
+ +
< 0, 0, 0, 0
+ + +
+ +
BLENDFACTOR_ONE = 2'i32
+
+ +
< 1, 1, 1, 1
+ + +
+ +
BLENDFACTOR_SRC_COLOR = 3'i32
+
+ +
< srcR, srcG, srcB, srcA
+ + +
+ +
BLENDFACTOR_ONE_MINUS_SRC_COLOR = 4'i32
+
+ +
< 1-srcR, 1-srcG, 1-srcB, 1-srcA
+ + +
+ +
BLENDFACTOR_SRC_ALPHA = 5'i32
+
+ +
< srcA, srcA, srcA, srcA
+ + +
+ +
BLENDFACTOR_ONE_MINUS_SRC_ALPHA = 6'i32
+
+ +
< 1-srcA, 1-srcA, 1-srcA, 1-srcA
+ + +
+ +
BLENDFACTOR_DST_COLOR = 7'i32
+
+ +
< dstR, dstG, dstB, dstA
+ + +
+ +
BLENDFACTOR_ONE_MINUS_DST_COLOR = 8'i32
+
+ +
< 1-dstR, 1-dstG, 1-dstB, 1-dstA
+ + +
+ +
BLENDFACTOR_DST_ALPHA = 9'i32
+
+ +
< dstA, dstA, dstA, dstA
+ + +
+ +
BLENDFACTOR_ONE_MINUS_DST_ALPHA = 10'i32
+
+ +
< 1-dstA, 1-dstA, 1-dstA, 1-dstA
+ + +
+ +
SWSURFACE = 0
+
+ + + +
+ +
PREALLOC = 0x00000001
+
+ + + +
+ +
RLEACCEL = 0x00000002
+
+ + + +
+ +
DONTFREE = 0x00000004
+
+ + + +
+ +
SIMD_ALIGNED = 0x00000008
+
+ + + +
+ +
YUV_CONVERSION_JPEG = 0'i32
+
+ +
< Full range JPEG
+ + +
+ +
YUV_CONVERSION_BT601 = 1
+
+ +
< BT.601 (the default)
+ + +
+ +
YUV_CONVERSION_BT709 = 2
+
+ +
< BT.709
+ + +
+ +
YUV_CONVERSION_AUTOMATIC = 3
+
+ +
< BT.601 for SD content, BT.709 for HD content
+ + +
+ +
WINDOW_FULLSCREEN = 1'i32
+
+ +
< fullscreen window
+ + +
+ +
WINDOW_OPENGL = 2'i32
+
+ +
< window usable with OpenGL context
+ + +
+ +
WINDOW_SHOWN = 4'i32
+
+ +
< window is visible
+ + +
+ +
WINDOW_HIDDEN = 8'i32
+
+ +
< window is not visible
+ + +
+ +
WINDOW_BORDERLESS = 16'i32
+
+ +
< no window decoration
+ + +
+ +
WINDOW_RESIZABLE = 32'i32
+
+ +
< window can be resized
+ + +
+ +
WINDOW_MINIMIZED = 64'i32
+
+ +
< window is minimized
+ + +
+ +
WINDOW_MAXIMIZED = 128'i32
+
+ +
< window is maximized
+ + +
+ +
WINDOW_INPUT_GRABBED = 256'i32
+
+ +
< window has grabbed input focus
+ + +
+ +
WINDOW_INPUT_FOCUS = 512'i32
+
+ +
< window has input focus
+ + +
+ +
WINDOW_MOUSE_FOCUS = 1024'i32
+
+ +
< window has mouse focus
+ + +
+ +
WINDOW_FULLSCREEN_DESKTOP = 4097'i32
+
+ + + +
+ +
WINDOW_FOREIGN = 2048'i32
+
+ +
< window not created by SDL
+ + +
+ +
WINDOW_ALLOW_HIGHDPI = 8192'i32
+
+ +
< window should be created in high-DPI mode if supported.
+                                                     On macOS NSHighResolutionCapable must be set true in the
+                                                     application's Info.plist for this to have any effect.
+ + +
+ +
WINDOW_MOUSE_CAPTURE = 16384'i32
+
+ +
< window has mouse captured (unrelated to INPUT_GRABBED)
+ + +
+ +
WINDOW_ALWAYS_ON_TOP = 32768'i32
+
+ +
< window should always be above others
+ + +
+ +
WINDOW_SKIP_TASKBAR = 65536'i32
+
+ +
< window should not be added to the taskbar
+ + +
+ +
WINDOW_UTILITY = 131072'i32
+
+ +
< window should be treated as a utility window
+ + +
+ +
WINDOW_TOOLTIP = 262144'i32
+
+ +
< window should be treated as a tooltip
+ + +
+ +
WINDOW_POPUP_MENU = 524288'i32
+
+ +
< window should be treated as a popup menu
+ + +
+ +
WINDOW_VULKAN = 268435456'i32
+
+ +
< window usable for Vulkan surface
+ + +
+ +
WINDOWEVENT_NONE = 0'i32
+
+ +
< Never used
+ + +
+ +
WINDOWEVENT_SHOWN = 1
+
+ +
< Window has been shown
+ + +
+ +
WINDOWEVENT_HIDDEN = 2
+
+ +
< Window has been hidden
+ + +
+ +
WINDOWEVENT_EXPOSED = 3
+
+ +
< Window has been exposed and should be
+                                         redrawn
+ + +
+ +
WINDOWEVENT_MOVED = 4
+
+ +
< Window has been moved to data1, data2
+ + +
+ +
WINDOWEVENT_RESIZED = 5
+
+ +
< Window has been resized to data1xdata2
+ + +
+ +
WINDOWEVENT_SIZE_CHANGED = 6
+
+ +
< The window size has changed, either as
+                                         a result of an API call or through the
+                                         system or user changing the window size.
+ + +
+ +
WINDOWEVENT_MINIMIZED = 7
+
+ +
< Window has been minimized
+ + +
+ +
WINDOWEVENT_MAXIMIZED = 8
+
+ +
< Window has been maximized
+ + +
+ +
WINDOWEVENT_RESTORED = 9
+
+ +
< Window has been restored to normal size
+                                         and position
+ + +
+ +
WINDOWEVENT_ENTER = 10
+
+ +
< Window has gained mouse focus
+ + +
+ +
WINDOWEVENT_LEAVE = 11
+
+ +
< Window has lost mouse focus
+ + +
+ +
WINDOWEVENT_FOCUS_GAINED = 12
+
+ +
< Window has gained keyboard focus
+ + +
+ +
WINDOWEVENT_FOCUS_LOST = 13
+
+ +
< Window has lost keyboard focus
+ + +
+ +
WINDOWEVENT_CLOSE = 14
+
+ +
< The window manager requests that the window be closed
+ + +
+ +
WINDOWEVENT_TAKE_FOCUS = 15
+
+ +
< Window is being offered a focus (should SetWindowInputFocus() on itself or a subwindow, or ignore)
+ + +
+ +
WINDOWEVENT_HIT_TEST = 16
+
+ +
< Window had a hit test that wasn't SDL_HITTEST_NORMAL.
+ + +
+ +
DISPLAYEVENT_NONE = 0'i32
+
+ +
< Never used
+ + +
+ +
DISPLAYEVENT_ORIENTATION = 1
+
+ +
< Display orientation has changed to data1
+ + +
+ +
ORIENTATION_UNKNOWN = 0'i32
+
+ +
< The display orientation can't be determined
+ + +
+ +
ORIENTATION_LANDSCAPE = 1
+
+ +
< The display is in landscape mode, with the right side up, relative to portrait mode
+ + +
+ +
ORIENTATION_LANDSCAPE_FLIPPED = 2
+
+ +
< The display is in landscape mode, with the left side up, relative to portrait mode
+ + +
+ +
ORIENTATION_PORTRAIT = 3
+
+ +
< The display is in portrait mode
+ + +
+ +
ORIENTATION_PORTRAIT_FLIPPED = 4
+
+ +
< The display is in portrait mode, upside down
+ + +
+ +
GL_RED_SIZE = 0'i32
+
+ + + +
+ +
GL_GREEN_SIZE = 1
+
+ + + +
+ +
GL_BLUE_SIZE = 2
+
+ + + +
+ +
GL_ALPHA_SIZE = 3
+
+ + + +
+ +
GL_BUFFER_SIZE = 4
+
+ + + +
+ +
GL_DOUBLEBUFFER = 5
+
+ + + +
+ +
GL_DEPTH_SIZE = 6
+
+ + + +
+ +
GL_STENCIL_SIZE = 7
+
+ + + +
+ +
GL_ACCUM_RED_SIZE = 8
+
+ + + +
+ +
GL_ACCUM_GREEN_SIZE = 9
+
+ + + +
+ +
GL_ACCUM_BLUE_SIZE = 10
+
+ + + +
+ +
GL_ACCUM_ALPHA_SIZE = 11
+
+ + + +
+ +
GL_STEREO = 12
+
+ + + +
+ +
GL_MULTISAMPLEBUFFERS = 13
+
+ + + +
+ +
GL_MULTISAMPLESAMPLES = 14
+
+ + + +
+ +
GL_ACCELERATED_VISUAL = 15
+
+ + + +
+ +
GL_RETAINED_BACKING = 16
+
+ + + +
+ +
GL_CONTEXT_MAJOR_VERSION = 17
+
+ + + +
+ +
GL_CONTEXT_MINOR_VERSION = 18
+
+ + + +
+ +
GL_CONTEXT_EGL = 19
+
+ + + +
+ +
GL_CONTEXT_FLAGS = 20
+
+ + + +
+ +
GL_CONTEXT_PROFILE_MASK = 21
+
+ + + +
+ +
GL_SHARE_WITH_CURRENT_CONTEXT = 22
+
+ + + +
+ +
GL_FRAMEBUFFER_SRGB_CAPABLE = 23
+
+ + + +
+ +
GL_CONTEXT_RELEASE_BEHAVIOR = 24
+
+ + + +
+ +
GL_CONTEXT_RESET_NOTIFICATION = 25
+
+ + + +
+ +
GL_CONTEXT_NO_ERROR = 26
+
+ + + +
+ +
GL_CONTEXT_PROFILE_CORE = 1'i32
+
+ + + +
+ +
GL_CONTEXT_PROFILE_COMPATIBILITY = 2'i32
+
+ + + +
+ +
GL_CONTEXT_PROFILE_ES = 4'i32
+
+ +
< GLX_CONTEXT_ES2_PROFILE_BIT_EXT
+ + +
+ +
GL_CONTEXT_DEBUG_FLAG = 1'i32
+
+ + + +
+ +
GL_CONTEXT_FORWARD_COMPATIBLE_FLAG = 2'i32
+
+ + + +
+ +
GL_CONTEXT_ROBUST_ACCESS_FLAG = 4'i32
+
+ + + +
+ +
GL_CONTEXT_RESET_ISOLATION_FLAG = 8'i32
+
+ + + +
+ +
GL_CONTEXT_RELEASE_BEHAVIOR_NONE = 0'i32
+
+ + + +
+ +
GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH = 1'i32
+
+ + + +
+ +
GL_CONTEXT_RESET_NO_NOTIFICATION = 0'i32
+
+ + + +
+ +
GL_CONTEXT_RESET_LOSE_CONTEXT = 1'i32
+
+ + + +
+ +
HITTEST_NORMAL = 0'i32
+
+ +
< Region is normal. No special properties.
+ + +
+ +
HITTEST_DRAGGABLE = 1
+
+ +
< Region can drag entire window.
+ + +
+ +
HITTEST_RESIZE_TOPLEFT = 2
+
+ + + +
+ +
HITTEST_RESIZE_TOP = 3
+
+ + + +
+ +
HITTEST_RESIZE_TOPRIGHT = 4
+
+ + + +
+ +
HITTEST_RESIZE_RIGHT = 5
+
+ + + +
+ +
HITTEST_RESIZE_BOTTOMRIGHT = 6
+
+ + + +
+ +
HITTEST_RESIZE_BOTTOM = 7
+
+ + + +
+ +
HITTEST_RESIZE_BOTTOMLEFT = 8
+
+ + + +
+ +
HITTEST_RESIZE_LEFT = 9
+
+ + + +
+ +
SCANCODE_UNKNOWN = 0'i32
+
+ +
\name Usage page 0x07
+  
+  These values are from usage page 0x07 (USB keyboard page).
+ + +
+ +
SCANCODE_A = 4'i32
+
+ + + +
+ +
SCANCODE_B = 5'i32
+
+ + + +
+ +
SCANCODE_C = 6'i32
+
+ + + +
+ +
SCANCODE_D = 7'i32
+
+ + + +
+ +
SCANCODE_E = 8'i32
+
+ + + +
+ +
SCANCODE_F = 9'i32
+
+ + + +
+ +
SCANCODE_G = 10'i32
+
+ + + +
+ +
SCANCODE_H = 11'i32
+
+ + + +
+ +
SCANCODE_I = 12'i32
+
+ + + +
+ +
SCANCODE_J = 13'i32
+
+ + + +
+ +
SCANCODE_K = 14'i32
+
+ + + +
+ +
SCANCODE_L = 15'i32
+
+ + + +
+ +
SCANCODE_M = 16'i32
+
+ + + +
+ +
SCANCODE_N = 17'i32
+
+ + + +
+ +
SCANCODE_O = 18'i32
+
+ + + +
+ +
SCANCODE_P = 19'i32
+
+ + + +
+ +
SCANCODE_Q = 20'i32
+
+ + + +
+ +
SCANCODE_R = 21'i32
+
+ + + +
+ +
SCANCODE_S = 22'i32
+
+ + + +
+ +
SCANCODE_T = 23'i32
+
+ + + +
+ +
SCANCODE_U = 24'i32
+
+ + + +
+ +
SCANCODE_V = 25'i32
+
+ + + +
+ +
SCANCODE_W = 26'i32
+
+ + + +
+ +
SCANCODE_X = 27'i32
+
+ + + +
+ +
SCANCODE_Y = 28'i32
+
+ + + +
+ +
SCANCODE_Z = 29'i32
+
+ + + +
+ +
SCANCODE_1 = 30'i32
+
+ + + +
+ +
SCANCODE_2 = 31'i32
+
+ + + +
+ +
SCANCODE_3 = 32'i32
+
+ + + +
+ +
SCANCODE_4 = 33'i32
+
+ + + +
+ +
SCANCODE_5 = 34'i32
+
+ + + +
+ +
SCANCODE_6 = 35'i32
+
+ + + +
+ +
SCANCODE_7 = 36'i32
+
+ + + +
+ +
SCANCODE_8 = 37'i32
+
+ + + +
+ +
SCANCODE_9 = 38'i32
+
+ + + +
+ +
SCANCODE_0 = 39'i32
+
+ + + +
+ +
SCANCODE_RETURN = 40'i32
+
+ + + +
+ +
SCANCODE_ESCAPE = 41'i32
+
+ + + +
+ +
SCANCODE_BACKSPACE = 42'i32
+
+ + + +
+ +
SCANCODE_TAB = 43'i32
+
+ + + +
+ +
SCANCODE_SPACE = 44'i32
+
+ + + +
+ +
SCANCODE_MINUS = 45'i32
+
+ + + +
+ +
SCANCODE_EQUALS = 46'i32
+
+ + + +
+ +
SCANCODE_LEFTBRACKET = 47'i32
+
+ + + +
+ +
SCANCODE_RIGHTBRACKET = 48'i32
+
+ + + +
+ +
SCANCODE_BACKSLASH = 49'i32
+
+ +
< Located at the lower left of the return
+   key on ISO keyboards and at the right end
+   of the QWERTY row on ANSI keyboards.
+   Produces REVERSE SOLIDUS (backslash) and
+   VERTICAL LINE in a US layout, REVERSE
+   SOLIDUS and VERTICAL LINE in a UK Mac
+   layout, NUMBER SIGN and TILDE in a UK
+   Windows layout, DOLLAR SIGN and POUND SIGN
+   in a Swiss German layout, NUMBER SIGN and
+   APOSTROPHE in a German layout, GRAVE
+   ACCENT and POUND SIGN in a French Mac
+   layout, and ASTERISK and MICRO SIGN in a
+   French Windows layout.
+ + +
+ +
SCANCODE_NONUSHASH = 50'i32
+
+ +
< ISO USB keyboards actually use this code
+   instead of 49 for the same key, but all
+   OSes I've seen treat the two codes
+   identically. So, as an implementor, unless
+   your keyboard generates both of those
+   codes and your OS treats them differently,
+   you should generate SDL_SCANCODE_BACKSLASH
+   instead of this code. As a user, you
+   should not rely on this code because SDL
+   will never generate it with most (all?)
+   keyboards.
+ + +
+ +
SCANCODE_SEMICOLON = 51'i32
+
+ + + +
+ +
SCANCODE_APOSTROPHE = 52'i32
+
+ + + +
+ +
SCANCODE_GRAVE = 53'i32
+
+ +
< Located in the top left corner (on both ANSI
+   and ISO keyboards). Produces GRAVE ACCENT and
+   TILDE in a US Windows layout and in US and UK
+   Mac layouts on ANSI keyboards, GRAVE ACCENT
+   and NOT SIGN in a UK Windows layout, SECTION
+   SIGN and PLUS-MINUS SIGN in US and UK Mac
+   layouts on ISO keyboards, SECTION SIGN and
+   DEGREE SIGN in a Swiss German layout (Mac:
+   only on ISO keyboards), CIRCUMFLEX ACCENT and
+   DEGREE SIGN in a German layout (Mac: only on
+   ISO keyboards), SUPERSCRIPT TWO and TILDE in a
+   French Windows layout, COMMERCIAL AT and
+   NUMBER SIGN in a French Mac layout on ISO
+   keyboards, and LESS-THAN SIGN and GREATER-THAN
+   SIGN in a Swiss German, German, or French Mac
+   layout on ANSI keyboards.
+ + +
+ +
SCANCODE_COMMA = 54'i32
+
+ + + +
+ +
SCANCODE_PERIOD = 55'i32
+
+ + + +
+ +
SCANCODE_SLASH = 56'i32
+
+ + + +
+ +
SCANCODE_CAPSLOCK = 57'i32
+
+ + + +
+ +
SCANCODE_F1 = 58'i32
+
+ + + +
+ +
SCANCODE_F2 = 59'i32
+
+ + + +
+ +
SCANCODE_F3 = 60'i32
+
+ + + +
+ +
SCANCODE_F4 = 61'i32
+
+ + + +
+ +
SCANCODE_F5 = 62'i32
+
+ + + +
+ +
SCANCODE_F6 = 63'i32
+
+ + + +
+ +
SCANCODE_F7 = 64'i32
+
+ + + +
+ +
SCANCODE_F8 = 65'i32
+
+ + + +
+ +
SCANCODE_F9 = 66'i32
+
+ + + +
+ +
SCANCODE_F10 = 67'i32
+
+ + + +
+ +
SCANCODE_F11 = 68'i32
+
+ + + +
+ +
SCANCODE_F12 = 69'i32
+
+ + + +
+ +
SCANCODE_PRINTSCREEN = 70'i32
+
+ + + +
+ +
SCANCODE_SCROLLLOCK = 71'i32
+
+ + + +
+ +
SCANCODE_PAUSE = 72'i32
+
+ + + +
+ +
SCANCODE_INSERT = 73'i32
+
+ +
< insert on PC, help on some Mac keyboards (but
+                                   does send code 73, not 117)
+ + +
+ +
SCANCODE_HOME = 74'i32
+
+ + + +
+ +
SCANCODE_PAGEUP = 75'i32
+
+ + + +
+ +
SCANCODE_DELETE = 76'i32
+
+ + + +
+ +
SCANCODE_END = 77'i32
+
+ + + +
+ +
SCANCODE_PAGEDOWN = 78'i32
+
+ + + +
+ +
SCANCODE_RIGHT = 79'i32
+
+ + + +
+ +
SCANCODE_LEFT = 80'i32
+
+ + + +
+ +
SCANCODE_DOWN = 81'i32
+
+ + + +
+ +
SCANCODE_UP = 82'i32
+
+ + + +
+ +
SCANCODE_NUMLOCKCLEAR = 83'i32
+
+ +
< num lock on PC, clear on Mac keyboards
+ + +
+ +
SCANCODE_KP_DIVIDE = 84'i32
+
+ + + +
+ +
SCANCODE_KP_MULTIPLY = 85'i32
+
+ + + +
+ +
SCANCODE_KP_MINUS = 86'i32
+
+ + + +
+ +
SCANCODE_KP_PLUS = 87'i32
+
+ + + +
+ +
SCANCODE_KP_ENTER = 88'i32
+
+ + + +
+ +
SCANCODE_KP_1 = 89'i32
+
+ + + +
+ +
SCANCODE_KP_2 = 90'i32
+
+ + + +
+ +
SCANCODE_KP_3 = 91'i32
+
+ + + +
+ +
SCANCODE_KP_4 = 92'i32
+
+ + + +
+ +
SCANCODE_KP_5 = 93'i32
+
+ + + +
+ +
SCANCODE_KP_6 = 94'i32
+
+ + + +
+ +
SCANCODE_KP_7 = 95'i32
+
+ + + +
+ +
SCANCODE_KP_8 = 96'i32
+
+ + + +
+ +
SCANCODE_KP_9 = 97'i32
+
+ + + +
+ +
SCANCODE_KP_0 = 98'i32
+
+ + + +
+ +
SCANCODE_KP_PERIOD = 99'i32
+
+ + + +
+ +
SCANCODE_NONUSBACKSLASH = 100'i32
+
+ +
< This is the additional key that ISO
+   keyboards have over ANSI ones,
+   located between left shift and Y.
+   Produces GRAVE ACCENT and TILDE in a
+   US or UK Mac layout, REVERSE SOLIDUS
+   (backslash) and VERTICAL LINE in a
+   US or UK Windows layout, and
+   LESS-THAN SIGN and GREATER-THAN SIGN
+   in a Swiss German, German, or French
+   layout.
+ + +
+ +
SCANCODE_APPLICATION = 101'i32
+
+ +
< windows contextual menu, compose
+ + +
+ +
SCANCODE_POWER = 102'i32
+
+ +
< The USB document says this is a status flag,
+   not a physical key - but some Mac keyboards
+   do have a power key.
+ + +
+ +
SCANCODE_KP_EQUALS = 103'i32
+
+ + + +
+ +
SCANCODE_F13 = 104'i32
+
+ + + +
+ +
SCANCODE_F14 = 105'i32
+
+ + + +
+ +
SCANCODE_F15 = 106'i32
+
+ + + +
+ +
SCANCODE_F16 = 107'i32
+
+ + + +
+ +
SCANCODE_F17 = 108'i32
+
+ + + +
+ +
SCANCODE_F18 = 109'i32
+
+ + + +
+ +
SCANCODE_F19 = 110'i32
+
+ + + +
+ +
SCANCODE_F20 = 111'i32
+
+ + + +
+ +
SCANCODE_F21 = 112'i32
+
+ + + +
+ +
SCANCODE_F22 = 113'i32
+
+ + + +
+ +
SCANCODE_F23 = 114'i32
+
+ + + +
+ +
SCANCODE_F24 = 115'i32
+
+ + + +
+ +
SCANCODE_EXECUTE = 116'i32
+
+ + + +
+ +
SCANCODE_HELP = 117'i32
+
+ + + +
+ +
SCANCODE_MENU = 118'i32
+
+ + + +
+ +
SCANCODE_SELECT = 119'i32
+
+ + + +
+ +
SCANCODE_STOP = 120'i32
+
+ + + +
+ +
SCANCODE_AGAIN = 121'i32
+
+ +
< redo
+ + +
+ +
SCANCODE_UNDO = 122'i32
+
+ + + +
+ +
SCANCODE_CUT = 123'i32
+
+ + + +
+ +
SCANCODE_COPY = 124'i32
+
+ + + +
+ +
SCANCODE_PASTE = 125'i32
+
+ + + +
+ +
SCANCODE_FIND = 126'i32
+
+ + + +
+ +
SCANCODE_MUTE = 127'i32
+
+ + + +
+ +
SCANCODE_VOLUMEUP = 128'i32
+
+ + + +
+ +
SCANCODE_VOLUMEDOWN = 129'i32
+
+ +
not sure whether there's a reason to enable these
+ + +
+ +
SCANCODE_KP_COMMA = 133'i32
+
+ + + +
+ +
SCANCODE_KP_EQUALSAS400 = 134'i32
+
+ + + +
+ +
SCANCODE_INTERNATIONAL1 = 135'i32
+
+ +
< used on Asian keyboards, see
+                                            footnotes in USB doc
+ + +
+ +
SCANCODE_INTERNATIONAL2 = 136'i32
+
+ + + +
+ +
SCANCODE_INTERNATIONAL3 = 137'i32
+
+ +
< Yen
+ + +
+ +
SCANCODE_INTERNATIONAL4 = 138'i32
+
+ + + +
+ +
SCANCODE_INTERNATIONAL5 = 139'i32
+
+ + + +
+ +
SCANCODE_INTERNATIONAL6 = 140'i32
+
+ + + +
+ +
SCANCODE_INTERNATIONAL7 = 141'i32
+
+ + + +
+ +
SCANCODE_INTERNATIONAL8 = 142'i32
+
+ + + +
+ +
SCANCODE_INTERNATIONAL9 = 143'i32
+
+ + + +
+ +
SCANCODE_LANG1 = 144'i32
+
+ +
< Hangul/English toggle
+ + +
+ +
SCANCODE_LANG2 = 145'i32
+
+ +
< Hanja conversion
+ + +
+ +
SCANCODE_LANG3 = 146'i32
+
+ +
< Katakana
+ + +
+ +
SCANCODE_LANG4 = 147'i32
+
+ +
< Hiragana
+ + +
+ +
SCANCODE_LANG5 = 148'i32
+
+ +
< Zenkaku/Hankaku
+ + +
+ +
SCANCODE_LANG6 = 149'i32
+
+ +
< reserved
+ + +
+ +
SCANCODE_LANG7 = 150'i32
+
+ +
< reserved
+ + +
+ +
SCANCODE_LANG8 = 151'i32
+
+ +
< reserved
+ + +
+ +
SCANCODE_LANG9 = 152'i32
+
+ +
< reserved
+ + +
+ +
SCANCODE_ALTERASE = 153'i32
+
+ +
< Erase-Eaze
+ + +
+ +
SCANCODE_SYSREQ = 154'i32
+
+ + + +
+ +
SCANCODE_CANCEL = 155'i32
+
+ + + +
+ +
SCANCODE_CLEAR = 156'i32
+
+ + + +
+ +
SCANCODE_PRIOR = 157'i32
+
+ + + +
+ +
SCANCODE_RETURN2 = 158'i32
+
+ + + +
+ +
SCANCODE_SEPARATOR = 159'i32
+
+ + + +
+ +
SCANCODE_OUT = 160'i32
+
+ + + +
+ +
SCANCODE_OPER = 161'i32
+
+ + + +
+ +
SCANCODE_CLEARAGAIN = 162'i32
+
+ + + +
+ +
SCANCODE_CRSEL = 163'i32
+
+ + + +
+ +
SCANCODE_EXSEL = 164'i32
+
+ + + +
+ +
SCANCODE_KP_00 = 176'i32
+
+ + + +
+ +
SCANCODE_KP_000 = 177'i32
+
+ + + +
+ +
SCANCODE_THOUSANDSSEPARATOR = 178'i32
+
+ + + +
+ +
SCANCODE_DECIMALSEPARATOR = 179'i32
+
+ + + +
+ +
SCANCODE_CURRENCYUNIT = 180'i32
+
+ + + +
+ +
SCANCODE_CURRENCYSUBUNIT = 181'i32
+
+ + + +
+ +
SCANCODE_KP_LEFTPAREN = 182'i32
+
+ + + +
+ +
SCANCODE_KP_RIGHTPAREN = 183'i32
+
+ + + +
+ +
SCANCODE_KP_LEFTBRACE = 184'i32
+
+ + + +
+ +
SCANCODE_KP_RIGHTBRACE = 185'i32
+
+ + + +
+ +
SCANCODE_KP_TAB = 186'i32
+
+ + + +
+ +
SCANCODE_KP_BACKSPACE = 187'i32
+
+ + + +
+ +
SCANCODE_KP_A = 188'i32
+
+ + + +
+ +
SCANCODE_KP_B = 189'i32
+
+ + + +
+ +
SCANCODE_KP_C = 190'i32
+
+ + + +
+ +
SCANCODE_KP_D = 191'i32
+
+ + + +
+ +
SCANCODE_KP_E = 192'i32
+
+ + + +
+ +
SCANCODE_KP_F = 193'i32
+
+ + + +
+ +
SCANCODE_KP_XOR = 194'i32
+
+ + + +
+ +
SCANCODE_KP_POWER = 195'i32
+
+ + + +
+ +
SCANCODE_KP_PERCENT = 196'i32
+
+ + + +
+ +
SCANCODE_KP_LESS = 197'i32
+
+ + + +
+ +
SCANCODE_KP_GREATER = 198'i32
+
+ + + +
+ +
SCANCODE_KP_AMPERSAND = 199'i32
+
+ + + +
+ +
SCANCODE_KP_DBLAMPERSAND = 200'i32
+
+ + + +
+ +
SCANCODE_KP_VERTICALBAR = 201'i32
+
+ + + +
+ +
SCANCODE_KP_DBLVERTICALBAR = 202'i32
+
+ + + +
+ +
SCANCODE_KP_COLON = 203'i32
+
+ + + +
+ +
SCANCODE_KP_HASH = 204'i32
+
+ + + +
+ +
SCANCODE_KP_SPACE = 205'i32
+
+ + + +
+ +
SCANCODE_KP_AT = 206'i32
+
+ + + +
+ +
SCANCODE_KP_EXCLAM = 207'i32
+
+ + + +
+ +
SCANCODE_KP_MEMSTORE = 208'i32
+
+ + + +
+ +
SCANCODE_KP_MEMRECALL = 209'i32
+
+ + + +
+ +
SCANCODE_KP_MEMCLEAR = 210'i32
+
+ + + +
+ +
SCANCODE_KP_MEMADD = 211'i32
+
+ + + +
+ +
SCANCODE_KP_MEMSUBTRACT = 212'i32
+
+ + + +
+ +
SCANCODE_KP_MEMMULTIPLY = 213'i32
+
+ + + +
+ +
SCANCODE_KP_MEMDIVIDE = 214'i32
+
+ + + +
+ +
SCANCODE_KP_PLUSMINUS = 215'i32
+
+ + + +
+ +
SCANCODE_KP_CLEAR = 216'i32
+
+ + + +
+ +
SCANCODE_KP_CLEARENTRY = 217'i32
+
+ + + +
+ +
SCANCODE_KP_BINARY = 218'i32
+
+ + + +
+ +
SCANCODE_KP_OCTAL = 219'i32
+
+ + + +
+ +
SCANCODE_KP_DECIMAL = 220'i32
+
+ + + +
+ +
SCANCODE_KP_HEXADECIMAL = 221'i32
+
+ + + +
+ +
SCANCODE_LCTRL = 224'i32
+
+ + + +
+ +
SCANCODE_LSHIFT = 225'i32
+
+ + + +
+ +
SCANCODE_LALT = 226'i32
+
+ +
< alt, option
+ + +
+ +
SCANCODE_LGUI = 227'i32
+
+ +
< windows, command (apple), meta
+ + +
+ +
SCANCODE_RCTRL = 228'i32
+
+ + + +
+ +
SCANCODE_RSHIFT = 229'i32
+
+ + + +
+ +
SCANCODE_RALT = 230'i32
+
+ +
< alt gr, option
+ + +
+ +
SCANCODE_RGUI = 231'i32
+
+ +
< windows, command (apple), meta
+ + +
+ +
SCANCODE_MODE = 257'i32
+
+ +
< I'm not sure if this is really not covered
+   by any of the above, but since there's a
+   special KMOD_MODE for it I'm adding it here
+ + +
+ +
SCANCODE_AUDIONEXT = 258'i32
+
+ + + +
+ +
SCANCODE_AUDIOPREV = 259'i32
+
+ + + +
+ +
SCANCODE_AUDIOSTOP = 260'i32
+
+ + + +
+ +
SCANCODE_AUDIOPLAY = 261'i32
+
+ + + +
+ +
SCANCODE_AUDIOMUTE = 262'i32
+
+ + + +
+ +
SCANCODE_MEDIASELECT = 263'i32
+
+ + + +
+ +
SCANCODE_WWW = 264'i32
+
+ + + +
+ +
SCANCODE_MAIL = 265'i32
+
+ + + +
+ +
SCANCODE_CALCULATOR = 266'i32
+
+ + + +
+ +
SCANCODE_COMPUTER = 267'i32
+
+ + + +
+ +
SCANCODE_AC_SEARCH = 268'i32
+
+ + + +
+ +
SCANCODE_AC_HOME = 269'i32
+
+ + + +
+ +
SCANCODE_AC_BACK = 270'i32
+
+ + + +
+ +
SCANCODE_AC_FORWARD = 271'i32
+
+ + + +
+ +
SCANCODE_AC_STOP = 272'i32
+
+ + + +
+ +
SCANCODE_AC_REFRESH = 273'i32
+
+ + + +
+ +
SCANCODE_AC_BOOKMARKS = 274'i32
+
+ +
@}
+ + +
+ +
SCANCODE_BRIGHTNESSDOWN = 275'i32
+
+ + + +
+ +
SCANCODE_BRIGHTNESSUP = 276'i32
+
+ + + +
+ +
SCANCODE_DISPLAYSWITCH = 277'i32
+
+ +
< display mirroring/dual display
+                                           switch, video mode switch
+ + +
+ +
SCANCODE_KBDILLUMTOGGLE = 278'i32
+
+ + + +
+ +
SCANCODE_KBDILLUMDOWN = 279'i32
+
+ + + +
+ +
SCANCODE_KBDILLUMUP = 280'i32
+
+ + + +
+ +
SCANCODE_EJECT = 281'i32
+
+ + + +
+ +
SCANCODE_SLEEP = 282'i32
+
+ + + +
+ +
SCANCODE_APP1 = 283'i32
+
+ + + +
+ +
SCANCODE_APP2 = 284'i32
+
+ +
@}
+ + +
+ +
SCANCODE_AUDIOREWIND = 285'i32
+
+ + + +
+ +
SCANCODE_AUDIOFASTFORWARD = 286'i32
+
+ +
@}
+ + +
+ +
NUM_SCANCODES = 512'i32
+
+ +
< not a key, just marks the number of scancodes
+                                 for array bounds
+ + +
+ +
KEYCODE_SCANCODE_MASK = 1073741824
+
+ + + +
+ +
KEYCODE_UNKNOWN = 0'i32
+
+ + + +
+ +
KEYCODE_RETURN = 13'i32
+
+ + + +
+ +
KEYCODE_ESCAPE = 27'i32
+
+ + + +
+ +
KEYCODE_BACKSPACE = 8'i32
+
+ + + +
+ +
KEYCODE_TAB = 9'i32
+
+ + + +
+ +
KEYCODE_SPACE = 32'i32
+
+ + + +
+ +
KEYCODE_EXCLAIM = 33'i32
+
+ + + +
+ +
KEYCODE_QUOTEDBL = 34'i32
+
+ + + +
+ +
KEYCODE_HASH = 35'i32
+
+ + + +
+ +
KEYCODE_PERCENT = 37'i32
+
+ + + +
+ +
KEYCODE_DOLLAR = 36'i32
+
+ + + +
+ +
KEYCODE_AMPERSAND = 38'i32
+
+ + + +
+ +
KEYCODE_QUOTE = 39'i32
+
+ + + +
+ +
KEYCODE_LEFTPAREN = 40'i32
+
+ + + +
+ +
KEYCODE_RIGHTPAREN = 41'i32
+
+ + + +
+ +
KEYCODE_ASTERISK = 42'i32
+
+ + + +
+ +
KEYCODE_PLUS = 43'i32
+
+ + + +
+ +
KEYCODE_COMMA = 44'i32
+
+ + + +
+ +
KEYCODE_MINUS = 45'i32
+
+ + + +
+ +
KEYCODE_PERIOD = 46'i32
+
+ + + +
+ +
KEYCODE_SLASH = 47'i32
+
+ + + +
+ +
KEYCODE_0 = 48'i32
+
+ + + +
+ +
KEYCODE_1 = 49'i32
+
+ + + +
+ +
KEYCODE_2 = 50'i32
+
+ + + +
+ +
KEYCODE_3 = 51'i32
+
+ + + +
+ +
KEYCODE_4 = 52'i32
+
+ + + +
+ +
KEYCODE_5 = 53'i32
+
+ + + +
+ +
KEYCODE_6 = 54'i32
+
+ + + +
+ +
KEYCODE_7 = 55'i32
+
+ + + +
+ +
KEYCODE_8 = 56'i32
+
+ + + +
+ +
KEYCODE_9 = 57'i32
+
+ + + +
+ +
KEYCODE_COLON = 58'i32
+
+ + + +
+ +
KEYCODE_SEMICOLON = 59'i32
+
+ + + +
+ +
KEYCODE_LESS = 60'i32
+
+ + + +
+ +
KEYCODE_EQUALS = 61'i32
+
+ + + +
+ +
KEYCODE_GREATER = 62'i32
+
+ + + +
+ +
KEYCODE_QUESTION = 63'i32
+
+ + + +
+ +
KEYCODE_AT = 64'i32
+
+ +
Skip uppercase letters
+ + +
+ +
KEYCODE_LEFTBRACKET = 91'i32
+
+ + + +
+ +
KEYCODE_BACKSLASH = 92'i32
+
+ + + +
+ +
KEYCODE_RIGHTBRACKET = 93'i32
+
+ + + +
+ +
KEYCODE_CARET = 94'i32
+
+ + + +
+ +
KEYCODE_UNDERSCORE = 95'i32
+
+ + + +
+ +
KEYCODE_BACKQUOTE = 96'i32
+
+ + + +
+ +
KEYCODE_a = 97'i32
+
+ + + +
+ +
KEYCODE_b = 98'i32
+
+ + + +
+ +
KEYCODE_c = 99'i32
+
+ + + +
+ +
KEYCODE_d = 100'i32
+
+ + + +
+ +
KEYCODE_e = 101'i32
+
+ + + +
+ +
KEYCODE_f = 102'i32
+
+ + + +
+ +
KEYCODE_g = 103'i32
+
+ + + +
+ +
KEYCODE_h = 104'i32
+
+ + + +
+ +
KEYCODE_i = 105'i32
+
+ + + +
+ +
KEYCODE_j = 106'i32
+
+ + + +
+ +
KEYCODE_k = 107'i32
+
+ + + +
+ +
KEYCODE_l = 108'i32
+
+ + + +
+ +
KEYCODE_m = 109'i32
+
+ + + +
+ +
KEYCODE_n = 110'i32
+
+ + + +
+ +
KEYCODE_o = 111'i32
+
+ + + +
+ +
KEYCODE_p = 112'i32
+
+ + + +
+ +
KEYCODE_q = 113'i32
+
+ + + +
+ +
KEYCODE_r = 114'i32
+
+ + + +
+ +
KEYCODE_s = 115'i32
+
+ + + +
+ +
KEYCODE_t = 116'i32
+
+ + + +
+ +
KEYCODE_u = 117'i32
+
+ + + +
+ +
KEYCODE_v = 118'i32
+
+ + + +
+ +
KEYCODE_w = 119'i32
+
+ + + +
+ +
KEYCODE_x = 120'i32
+
+ + + +
+ +
KEYCODE_y = 121'i32
+
+ + + +
+ +
KEYCODE_z = 122'i32
+
+ + + +
+ +
KEYCODE_CAPSLOCK = 1073741881'i32
+
+ + + +
+ +
KEYCODE_F1 = 1073741882'i32
+
+ + + +
+ +
KEYCODE_F2 = 1073741883'i32
+
+ + + +
+ +
KEYCODE_F3 = 1073741884'i32
+
+ + + +
+ +
KEYCODE_F4 = 1073741885'i32
+
+ + + +
+ +
KEYCODE_F5 = 1073741886'i32
+
+ + + +
+ +
KEYCODE_F6 = 1073741887'i32
+
+ + + +
+ +
KEYCODE_F7 = 1073741888'i32
+
+ + + +
+ +
KEYCODE_F8 = 1073741889'i32
+
+ + + +
+ +
KEYCODE_F9 = 1073741890'i32
+
+ + + +
+ +
KEYCODE_F10 = 1073741891'i32
+
+ + + +
+ +
KEYCODE_F11 = 1073741892'i32
+
+ + + +
+ +
KEYCODE_F12 = 1073741893'i32
+
+ + + +
+ +
KEYCODE_PRINTSCREEN = 1073741894'i32
+
+ + + +
+ +
KEYCODE_SCROLLLOCK = 1073741895'i32
+
+ + + +
+ +
KEYCODE_PAUSE = 1073741896'i32
+
+ + + +
+ +
KEYCODE_INSERT = 1073741897'i32
+
+ + + +
+ +
KEYCODE_HOME = 1073741898'i32
+
+ + + +
+ +
KEYCODE_PAGEUP = 1073741899'i32
+
+ + + +
+ +
KEYCODE_DELETE = 127'i32
+
+ + + +
+ +
KEYCODE_END = 1073741901'i32
+
+ + + +
+ +
KEYCODE_PAGEDOWN = 1073741902'i32
+
+ + + +
+ +
KEYCODE_RIGHT = 1073741903'i32
+
+ + + +
+ +
KEYCODE_LEFT = 1073741904'i32
+
+ + + +
+ +
KEYCODE_DOWN = 1073741905'i32
+
+ + + +
+ +
KEYCODE_UP = 1073741906'i32
+
+ + + +
+ +
KEYCODE_NUMLOCKCLEAR = 1073741907'i32
+
+ + + +
+ +
KEYCODE_KP_DIVIDE = 1073741908'i32
+
+ + + +
+ +
KEYCODE_KP_MULTIPLY = 1073741909'i32
+
+ + + +
+ +
KEYCODE_KP_MINUS = 1073741910'i32
+
+ + + +
+ +
KEYCODE_KP_PLUS = 1073741911'i32
+
+ + + +
+ +
KEYCODE_KP_ENTER = 1073741912'i32
+
+ + + +
+ +
KEYCODE_KP_1 = 1073741913'i32
+
+ + + +
+ +
KEYCODE_KP_2 = 1073741914'i32
+
+ + + +
+ +
KEYCODE_KP_3 = 1073741915'i32
+
+ + + +
+ +
KEYCODE_KP_4 = 1073741916'i32
+
+ + + +
+ +
KEYCODE_KP_5 = 1073741917'i32
+
+ + + +
+ +
KEYCODE_KP_6 = 1073741918'i32
+
+ + + +
+ +
KEYCODE_KP_7 = 1073741919'i32
+
+ + + +
+ +
KEYCODE_KP_8 = 1073741920'i32
+
+ + + +
+ +
KEYCODE_KP_9 = 1073741921'i32
+
+ + + +
+ +
KEYCODE_KP_0 = 1073741922'i32
+
+ + + +
+ +
KEYCODE_KP_PERIOD = 1073741923'i32
+
+ + + +
+ +
KEYCODE_APPLICATION = 1073741925'i32
+
+ + + +
+ +
KEYCODE_POWER = 1073741926'i32
+
+ + + +
+ +
KEYCODE_KP_EQUALS = 1073741927'i32
+
+ + + +
+ +
KEYCODE_F13 = 1073741928'i32
+
+ + + +
+ +
KEYCODE_F14 = 1073741929'i32
+
+ + + +
+ +
KEYCODE_F15 = 1073741930'i32
+
+ + + +
+ +
KEYCODE_F16 = 1073741931'i32
+
+ + + +
+ +
KEYCODE_F17 = 1073741932'i32
+
+ + + +
+ +
KEYCODE_F18 = 1073741933'i32
+
+ + + +
+ +
KEYCODE_F19 = 1073741934'i32
+
+ + + +
+ +
KEYCODE_F20 = 1073741935'i32
+
+ + + +
+ +
KEYCODE_F21 = 1073741936'i32
+
+ + + +
+ +
KEYCODE_F22 = 1073741937'i32
+
+ + + +
+ +
KEYCODE_F23 = 1073741938'i32
+
+ + + +
+ +
KEYCODE_F24 = 1073741939'i32
+
+ + + +
+ +
KEYCODE_EXECUTE = 1073741940'i32
+
+ + + +
+ +
KEYCODE_HELP = 1073741941'i32
+
+ + + +
+ +
KEYCODE_MENU = 1073741942'i32
+
+ + + +
+ +
KEYCODE_SELECT = 1073741943'i32
+
+ + + +
+ +
KEYCODE_STOP = 1073741944'i32
+
+ + + +
+ +
KEYCODE_AGAIN = 1073741945'i32
+
+ + + +
+ +
KEYCODE_UNDO = 1073741946'i32
+
+ + + +
+ +
KEYCODE_CUT = 1073741947'i32
+
+ + + +
+ +
KEYCODE_COPY = 1073741948'i32
+
+ + + +
+ +
KEYCODE_PASTE = 1073741949'i32
+
+ + + +
+ +
KEYCODE_FIND = 1073741950'i32
+
+ + + +
+ +
KEYCODE_MUTE = 1073741951'i32
+
+ + + +
+ +
KEYCODE_VOLUMEUP = 1073741952'i32
+
+ + + +
+ +
KEYCODE_VOLUMEDOWN = 1073741953'i32
+
+ + + +
+ +
KEYCODE_KP_COMMA = 1073741957'i32
+
+ + + +
+ +
KEYCODE_KP_EQUALSAS400 = 1073741958'i32
+
+ + + +
+ +
KEYCODE_ALTERASE = 1073741977'i32
+
+ + + +
+ +
KEYCODE_SYSREQ = 1073741978'i32
+
+ + + +
+ +
KEYCODE_CANCEL = 1073741979'i32
+
+ + + +
+ +
KEYCODE_CLEAR = 1073741980'i32
+
+ + + +
+ +
KEYCODE_PRIOR = 1073741981'i32
+
+ + + +
+ +
KEYCODE_RETURN2 = 1073741982'i32
+
+ + + +
+ +
KEYCODE_SEPARATOR = 1073741983'i32
+
+ + + +
+ +
KEYCODE_OUT = 1073741984'i32
+
+ + + +
+ +
KEYCODE_OPER = 1073741985'i32
+
+ + + +
+ +
KEYCODE_CLEARAGAIN = 1073741986'i32
+
+ + + +
+ +
KEYCODE_CRSEL = 1073741987'i32
+
+ + + +
+ +
KEYCODE_EXSEL = 1073741988'i32
+
+ + + +
+ +
KEYCODE_KP_00 = 1073742000'i32
+
+ + + +
+ +
KEYCODE_KP_000 = 1073742001'i32
+
+ + + +
+ +
KEYCODE_THOUSANDSSEPARATOR = 1073742002'i32
+
+ + + +
+ +
KEYCODE_DECIMALSEPARATOR = 1073742003'i32
+
+ + + +
+ +
KEYCODE_CURRENCYUNIT = 1073742004'i32
+
+ + + +
+ +
KEYCODE_CURRENCYSUBUNIT = 1073742005'i32
+
+ + + +
+ +
KEYCODE_KP_LEFTPAREN = 1073742006'i32
+
+ + + +
+ +
KEYCODE_KP_RIGHTPAREN = 1073742007'i32
+
+ + + +
+ +
KEYCODE_KP_LEFTBRACE = 1073742008'i32
+
+ + + +
+ +
KEYCODE_KP_RIGHTBRACE = 1073742009'i32
+
+ + + +
+ +
KEYCODE_KP_TAB = 1073742010'i32
+
+ + + +
+ +
KEYCODE_KP_BACKSPACE = 1073742011'i32
+
+ + + +
+ +
KEYCODE_KP_A = 1073742012'i32
+
+ + + +
+ +
KEYCODE_KP_B = 1073742013'i32
+
+ + + +
+ +
KEYCODE_KP_C = 1073742014'i32
+
+ + + +
+ +
KEYCODE_KP_D = 1073742015'i32
+
+ + + +
+ +
KEYCODE_KP_E = 1073742016'i32
+
+ + + +
+ +
KEYCODE_KP_F = 1073742017'i32
+
+ + + +
+ +
KEYCODE_KP_XOR = 1073742018'i32
+
+ + + +
+ +
KEYCODE_KP_POWER = 1073742019'i32
+
+ + + +
+ +
KEYCODE_KP_PERCENT = 1073742020'i32
+
+ + + +
+ +
KEYCODE_KP_LESS = 1073742021'i32
+
+ + + +
+ +
KEYCODE_KP_GREATER = 1073742022'i32
+
+ + + +
+ +
KEYCODE_KP_AMPERSAND = 1073742023'i32
+
+ + + +
+ +
KEYCODE_KP_DBLAMPERSAND = 1073742024'i32
+
+ + + +
+ +
KEYCODE_KP_VERTICALBAR = 1073742025'i32
+
+ + + +
+ +
KEYCODE_KP_DBLVERTICALBAR = 1073742026'i32
+
+ + + +
+ +
KEYCODE_KP_COLON = 1073742027'i32
+
+ + + +
+ +
KEYCODE_KP_HASH = 1073742028'i32
+
+ + + +
+ +
KEYCODE_KP_SPACE = 1073742029'i32
+
+ + + +
+ +
KEYCODE_KP_AT = 1073742030'i32
+
+ + + +
+ +
KEYCODE_KP_EXCLAM = 1073742031'i32
+
+ + + +
+ +
KEYCODE_KP_MEMSTORE = 1073742032'i32
+
+ + + +
+ +
KEYCODE_KP_MEMRECALL = 1073742033'i32
+
+ + + +
+ +
KEYCODE_KP_MEMCLEAR = 1073742034'i32
+
+ + + +
+ +
KEYCODE_KP_MEMADD = 1073742035'i32
+
+ + + +
+ +
KEYCODE_KP_MEMSUBTRACT = 1073742036'i32
+
+ + + +
+ +
KEYCODE_KP_MEMMULTIPLY = 1073742037'i32
+
+ + + +
+ +
KEYCODE_KP_MEMDIVIDE = 1073742038'i32
+
+ + + +
+ +
KEYCODE_KP_PLUSMINUS = 1073742039'i32
+
+ + + +
+ +
KEYCODE_KP_CLEAR = 1073742040'i32
+
+ + + +
+ +
KEYCODE_KP_CLEARENTRY = 1073742041'i32
+
+ + + +
+ +
KEYCODE_KP_BINARY = 1073742042'i32
+
+ + + +
+ +
KEYCODE_KP_OCTAL = 1073742043'i32
+
+ + + +
+ +
KEYCODE_KP_DECIMAL = 1073742044'i32
+
+ + + +
+ +
KEYCODE_KP_HEXADECIMAL = 1073742045'i32
+
+ + + +
+ +
KEYCODE_LCTRL = 1073742048'i32
+
+ + + +
+ +
KEYCODE_LSHIFT = 1073742049'i32
+
+ + + +
+ +
KEYCODE_LALT = 1073742050'i32
+
+ + + +
+ +
KEYCODE_LGUI = 1073742051'i32
+
+ + + +
+ +
KEYCODE_RCTRL = 1073742052'i32
+
+ + + +
+ +
KEYCODE_RSHIFT = 1073742053'i32
+
+ + + +
+ +
KEYCODE_RALT = 1073742054'i32
+
+ + + +
+ +
KEYCODE_RGUI = 1073742055'i32
+
+ + + +
+ +
KEYCODE_MODE = 1073742081'i32
+
+ + + +
+ +
KEYCODE_AUDIONEXT = 1073742082'i32
+
+ + + +
+ +
KEYCODE_AUDIOPREV = 1073742083'i32
+
+ + + +
+ +
KEYCODE_AUDIOSTOP = 1073742084'i32
+
+ + + +
+ +
KEYCODE_AUDIOPLAY = 1073742085'i32
+
+ + + +
+ +
KEYCODE_AUDIOMUTE = 1073742086'i32
+
+ + + +
+ +
KEYCODE_MEDIASELECT = 1073742087'i32
+
+ + + +
+ +
KEYCODE_WWW = 1073742088'i32
+
+ + + +
+ +
KEYCODE_MAIL = 1073742089'i32
+
+ + + +
+ +
KEYCODE_CALCULATOR = 1073742090'i32
+
+ + + +
+ +
KEYCODE_COMPUTER = 1073742091'i32
+
+ + + +
+ +
KEYCODE_AC_SEARCH = 1073742092'i32
+
+ + + +
+ +
KEYCODE_AC_HOME = 1073742093'i32
+
+ + + +
+ +
KEYCODE_AC_BACK = 1073742094'i32
+
+ + + +
+ +
KEYCODE_AC_FORWARD = 1073742095'i32
+
+ + + +
+ +
KEYCODE_AC_STOP = 1073742096'i32
+
+ + + +
+ +
KEYCODE_AC_REFRESH = 1073742097'i32
+
+ + + +
+ +
KEYCODE_AC_BOOKMARKS = 1073742098'i32
+
+ + + +
+ +
KEYCODE_BRIGHTNESSDOWN = 1073742099'i32
+
+ + + +
+ +
KEYCODE_BRIGHTNESSUP = 1073742100'i32
+
+ + + +
+ +
KEYCODE_DISPLAYSWITCH = 1073742101'i32
+
+ + + +
+ +
KEYCODE_KBDILLUMTOGGLE = 1073742102'i32
+
+ + + +
+ +
KEYCODE_KBDILLUMDOWN = 1073742103'i32
+
+ + + +
+ +
KEYCODE_KBDILLUMUP = 1073742104'i32
+
+ + + +
+ +
KEYCODE_EJECT = 1073742105'i32
+
+ + + +
+ +
KEYCODE_SLEEP = 1073742106'i32
+
+ + + +
+ +
KEYCODE_APP1 = 1073742107'i32
+
+ + + +
+ +
KEYCODE_APP2 = 1073742108'i32
+
+ + + +
+ +
KEYCODE_AUDIOREWIND = 1073742109'i32
+
+ + + +
+ +
KEYCODE_AUDIOFASTFORWARD = 1073742110'i32
+
+ + + +
+ +
KMOD_NONE = 0'i32
+
+ + + +
+ +
KMOD_LSHIFT = 1'i32
+
+ + + +
+ +
KMOD_RSHIFT = 2'i32
+
+ + + +
+ +
KMOD_LCTRL = 64'i32
+
+ + + +
+ +
KMOD_RCTRL = 128'i32
+
+ + + +
+ +
KMOD_LALT = 256'i32
+
+ + + +
+ +
KMOD_RALT = 512'i32
+
+ + + +
+ +
KMOD_LGUI = 1024'i32
+
+ + + +
+ +
KMOD_RGUI = 2048'i32
+
+ + + +
+ +
KMOD_NUM = 4096'i32
+
+ + + +
+ +
KMOD_CAPS = 8192'i32
+
+ + + +
+ +
KMOD_MODE = 16384'i32
+
+ + + +
+ +
KMOD_RESERVED = 32768'i32
+
+ + + +
+ +
KMOD_CTRL = 192'i32
+
+ + + +
+ +
KMOD_SHIFT = 3'i32
+
+ + + +
+ +
KMOD_ALT = 768'i32
+
+ + + +
+ +
KMOD_GUI = 3072'i32
+
+ + + +
+ +
SYSTEM_CURSOR_ARROW = 0'i32
+
+ +
< Arrow
+ + +
+ +
SYSTEM_CURSOR_IBEAM = 1
+
+ +
< I-beam
+ + +
+ +
SYSTEM_CURSOR_WAIT = 2
+
+ +
< Wait
+ + +
+ +
SYSTEM_CURSOR_CROSSHAIR = 3
+
+ +
< Crosshair
+ + +
+ +
SYSTEM_CURSOR_WAITARROW = 4
+
+ +
< Small wait cursor (or Wait if not available)
+ + +
+ +
SYSTEM_CURSOR_SIZENWSE = 5
+
+ +
< Double arrow pointing northwest and southeast
+ + +
+ +
SYSTEM_CURSOR_SIZENESW = 6
+
+ +
< Double arrow pointing northeast and southwest
+ + +
+ +
SYSTEM_CURSOR_SIZEWE = 7
+
+ +
< Double arrow pointing west and east
+ + +
+ +
SYSTEM_CURSOR_SIZENS = 8
+
+ +
< Double arrow pointing north and south
+ + +
+ +
SYSTEM_CURSOR_SIZEALL = 9
+
+ +
< Four pointed arrow pointing north, south, east, and west
+ + +
+ +
SYSTEM_CURSOR_NO = 10
+
+ +
< Slashed circle or crossbones
+ + +
+ +
SYSTEM_CURSOR_HAND = 11
+
+ +
< Hand
+ + +
+ +
NUM_SYSTEM_CURSORS = 12
+
+ + + +
+ +
MOUSEWHEEL_NORMAL = 0'i32
+
+ +
< The scroll direction is normal
+ + +
+ +
MOUSEWHEEL_FLIPPED = 1
+
+ +
< The scroll direction is flipped / natural
+ + +
+ +
BUTTON_LEFT = 1
+
+ + + +
+ +
BUTTON_MIDDLE = 2
+
+ + + +
+ +
BUTTON_RIGHT = 3
+
+ + + +
+ +
BUTTON_X1 = 4
+
+ + + +
+ +
BUTTON_X2 = 5
+
+ + + +
+ +
JOYSTICK_TYPE_UNKNOWN = 0'i32
+
+ + + +
+ +
JOYSTICK_TYPE_GAMECONTROLLER = 1
+
+ + + +
+ +
JOYSTICK_TYPE_WHEEL = 2
+
+ + + +
+ +
JOYSTICK_TYPE_ARCADE_STICK = 3
+
+ + + +
+ +
JOYSTICK_TYPE_FLIGHT_STICK = 4
+
+ + + +
+ +
JOYSTICK_TYPE_DANCE_PAD = 5
+
+ + + +
+ +
JOYSTICK_TYPE_GUITAR = 6
+
+ + + +
+ +
JOYSTICK_TYPE_DRUM_KIT = 7
+
+ + + +
+ +
JOYSTICK_TYPE_ARCADE_PAD = 8
+
+ + + +
+ +
JOYSTICK_TYPE_THROTTLE = 9
+
+ + + +
+ +
JOYSTICK_POWER_UNKNOWN = -1'i32
+
+ + + +
+ +
JOYSTICK_POWER_EMPTY = 0
+
+ +
<= 5%
+ + +
+ +
JOYSTICK_POWER_LOW = 1
+
+ +
<= 20%
+ + +
+ +
JOYSTICK_POWER_MEDIUM = 2
+
+ +
<= 70%
+ + +
+ +
JOYSTICK_POWER_FULL = 3
+
+ +
<= 100%
+ + +
+ +
JOYSTICK_POWER_WIRED = 4
+
+ + + +
+ +
JOYSTICK_POWER_MAX = 5
+
+ + + +
+ +
JOYSTICK_AXIS_MAX = 32767
+
+ + + +
+ +
JOYSTICK_AXIS_MIN = -32768
+
+ + + +
+ +
HAT_CENTERED = 0x00000000
+
+ + + +
+ +
HAT_UP = 0x00000001
+
+ + + +
+ +
HAT_RIGHT = 0x00000002
+
+ + + +
+ +
HAT_DOWN = 0x00000004
+
+ + + +
+ +
HAT_LEFT = 0x00000008
+
+ + + +
+ +
HAT_RIGHTUP = 3
+
+ + + +
+ +
HAT_RIGHTDOWN = 6
+
+ + + +
+ +
HAT_LEFTUP = 9
+
+ + + +
+ +
HAT_LEFTDOWN = 12
+
+ + + +
+ +
CONTROLLER_TYPE_UNKNOWN = 0'i32
+
+ + + +
+ +
CONTROLLER_TYPE_XBOX360 = 1
+
+ + + +
+ +
CONTROLLER_TYPE_XBOXONE = 2
+
+ + + +
+ +
CONTROLLER_TYPE_PS3 = 3
+
+ + + +
+ +
CONTROLLER_TYPE_PS4 = 4
+
+ + + +
+ +
CONTROLLER_TYPE_NINTENDO_SWITCH_PRO = 5
+
+ + + +
+ +
CONTROLLER_AXIS_INVALID = -1'i32
+
+ + + +
+ +
CONTROLLER_AXIS_LEFTX = 0
+
+ + + +
+ +
CONTROLLER_AXIS_LEFTY = 1
+
+ + + +
+ +
CONTROLLER_AXIS_RIGHTX = 2
+
+ + + +
+ +
CONTROLLER_AXIS_RIGHTY = 3
+
+ + + +
+ +
CONTROLLER_AXIS_TRIGGERLEFT = 4
+
+ + + +
+ +
CONTROLLER_AXIS_TRIGGERRIGHT = 5
+
+ + + +
+ +
CONTROLLER_AXIS_MAX = 6
+
+ + + +
+ +
CONTROLLER_BUTTON_INVALID = -1'i32
+
+ + + +
+ +
CONTROLLER_BUTTON_A = 0
+
+ + + +
+ +
CONTROLLER_BUTTON_B = 1
+
+ + + +
+ +
CONTROLLER_BUTTON_X = 2
+
+ + + +
+ +
CONTROLLER_BUTTON_Y = 3
+
+ + + +
+ +
CONTROLLER_BUTTON_BACK = 4
+
+ + + +
+ +
CONTROLLER_BUTTON_GUIDE = 5
+
+ + + +
+ +
CONTROLLER_BUTTON_START = 6
+
+ + + +
+ +
CONTROLLER_BUTTON_LEFTSTICK = 7
+
+ + + +
+ +
CONTROLLER_BUTTON_RIGHTSTICK = 8
+
+ + + +
+ +
CONTROLLER_BUTTON_LEFTSHOULDER = 9
+
+ + + +
+ +
CONTROLLER_BUTTON_RIGHTSHOULDER = 10
+
+ + + +
+ +
CONTROLLER_BUTTON_DPAD_UP = 11
+
+ + + +
+ +
CONTROLLER_BUTTON_DPAD_DOWN = 12
+
+ + + +
+ +
CONTROLLER_BUTTON_DPAD_LEFT = 13
+
+ + + +
+ +
CONTROLLER_BUTTON_DPAD_RIGHT = 14
+
+ + + +
+ +
CONTROLLER_BUTTON_MAX = 15
+
+ + + +
+ +
TOUCH_DEVICE_INVALID = -1'i32
+
+ + + +
+ +
TOUCH_DEVICE_DIRECT = 0
+
+ +
touch screen with window-relative coordinates
+ + +
+ +
TOUCH_DEVICE_INDIRECT_ABSOLUTE = 1
+
+ +
trackpad with absolute device coordinates
+ + +
+ +
TOUCH_DEVICE_INDIRECT_RELATIVE = 2
+
+ +
trackpad with screen cursor-relative coordinates
+ + +
+ +
RELEASED = 0
+
+ + + +
+ +
PRESSED = 1
+
+ + + +
+ +
EVENT_FIRSTEVENT = 0'i32
+
+ +
< Unused (do not remove)
+ + +
+ +
EVENT_QUIT = 256'i32
+
+ +
< User-requested quit
+ + +
+ +
EVENT_APP_TERMINATING = 257
+
+ +
< The application is being terminated by the OS
+                                     Called on iOS in applicationWillTerminate()
+                                     Called on Android in onDestroy()
+ + +
+ +
EVENT_APP_LOWMEMORY = 258
+
+ +
< The application is low on memory, free memory if possible.
+                                     Called on iOS in applicationDidReceiveMemoryWarning()
+                                     Called on Android in onLowMemory()
+ + +
+ +
EVENT_APP_WILLENTERBACKGROUND = 259
+
+ +
< The application is about to enter the background
+                                     Called on iOS in applicationWillResignActive()
+                                     Called on Android in onPause()
+ + +
+ +
EVENT_APP_DIDENTERBACKGROUND = 260
+
+ +
< The application did enter the background and may not get CPU for some time
+                                     Called on iOS in applicationDidEnterBackground()
+                                     Called on Android in onPause()
+ + +
+ +
EVENT_APP_WILLENTERFOREGROUND = 261
+
+ +
< The application is about to enter the foreground
+                                     Called on iOS in applicationWillEnterForeground()
+                                     Called on Android in onResume()
+ + +
+ +
EVENT_APP_DIDENTERFOREGROUND = 262
+
+ +
< The application is now interactive
+                                     Called on iOS in applicationDidBecomeActive()
+                                     Called on Android in onResume()
+ + +
+ +
EVENT_DISPLAYEVENT = 336'i32
+
+ +
< Display state change
+ + +
+ +
EVENT_WINDOWEVENT = 512'i32
+
+ +
< Window state change
+ + +
+ +
EVENT_SYSWMEVENT = 513
+
+ +
< System specific event
+ + +
+ +
EVENT_KEYDOWN = 768'i32
+
+ +
< Key pressed
+ + +
+ +
EVENT_KEYUP = 769
+
+ +
< Key released
+ + +
+ +
EVENT_TEXTEDITING = 770
+
+ +
< Keyboard text editing (composition)
+ + +
+ +
EVENT_TEXTINPUT = 771
+
+ +
< Keyboard text input
+ + +
+ +
EVENT_KEYMAPCHANGED = 772
+
+ +
< Keymap changed due to a system event such as an
+                                     input language or keyboard layout change.
+ + +
+ +
EVENT_MOUSEMOTION = 1024'i32
+
+ +
< Mouse moved
+ + +
+ +
EVENT_MOUSEBUTTONDOWN = 1025
+
+ +
< Mouse button pressed
+ + +
+ +
EVENT_MOUSEBUTTONUP = 1026
+
+ +
< Mouse button released
+ + +
+ +
EVENT_MOUSEWHEEL = 1027
+
+ +
< Mouse wheel motion
+ + +
+ +
EVENT_JOYAXISMOTION = 1536'i32
+
+ +
< Joystick axis motion
+ + +
+ +
EVENT_JOYBALLMOTION = 1537
+
+ +
< Joystick trackball motion
+ + +
+ +
EVENT_JOYHATMOTION = 1538
+
+ +
< Joystick hat position change
+ + +
+ +
EVENT_JOYBUTTONDOWN = 1539
+
+ +
< Joystick button pressed
+ + +
+ +
EVENT_JOYBUTTONUP = 1540
+
+ +
< Joystick button released
+ + +
+ +
EVENT_JOYDEVICEADDED = 1541
+
+ +
< A new joystick has been inserted into the system
+ + +
+ +
EVENT_JOYDEVICEREMOVED = 1542
+
+ +
< An opened joystick has been removed
+ + +
+ +
EVENT_CONTROLLERAXISMOTION = 1616'i32
+
+ +
< Game controller axis motion
+ + +
+ +
EVENT_CONTROLLERBUTTONDOWN = 1617
+
+ +
< Game controller button pressed
+ + +
+ +
EVENT_CONTROLLERBUTTONUP = 1618
+
+ +
< Game controller button released
+ + +
+ +
EVENT_CONTROLLERDEVICEADDED = 1619
+
+ +
< A new Game controller has been inserted into the system
+ + +
+ +
EVENT_CONTROLLERDEVICEREMOVED = 1620
+
+ +
< An opened Game controller has been removed
+ + +
+ +
EVENT_CONTROLLERDEVICEREMAPPED = 1621
+
+ +
< The controller mapping was updated
+ + +
+ +
EVENT_FINGERDOWN = 1792'i32
+
+ + + +
+ +
EVENT_FINGERUP = 1793
+
+ + + +
+ +
EVENT_FINGERMOTION = 1794
+
+ +
Gesture events
+ + +
+ +
EVENT_DOLLARGESTURE = 2048'i32
+
+ + + +
+ +
EVENT_DOLLARRECORD = 2049
+
+ + + +
+ +
EVENT_MULTIGESTURE = 2050
+
+ +
Clipboard events
+ + +
+ +
EVENT_CLIPBOARDUPDATE = 2304'i32
+
+ +
< The clipboard changed
+ + +
+ +
EVENT_DROPFILE = 4096'i32
+
+ +
< The system requests a file open
+ + +
+ +
EVENT_DROPTEXT = 4097
+
+ +
< text/plain drag-and-drop event
+ + +
+ +
EVENT_DROPBEGIN = 4098
+
+ +
< A new set of drops is beginning (NULL filename)
+ + +
+ +
EVENT_DROPCOMPLETE = 4099
+
+ +
< Current set of drops is now complete (NULL filename)
+ + +
+ +
EVENT_AUDIODEVICEADDED = 4352'i32
+
+ +
< A new audio device is available
+ + +
+ +
EVENT_AUDIODEVICEREMOVED = 4353
+
+ +
< An audio device has been removed.
+ + +
+ +
EVENT_SENSORUPDATE = 4608'i32
+
+ +
< A sensor was updated
+ + +
+ +
EVENT_RENDER_TARGETS_RESET = 8192'i32
+
+ +
< The render targets have been reset and their contents need to be updated
+ + +
+ +
EVENT_RENDER_DEVICE_RESET = 8193
+
+ +
< The device has been reset and all textures need to be recreated
+ + +
+ +
EVENT_USEREVENT = 32768'i32
+
+ +
This last event is only for bounding internal arrays
+ + +
+ +
EVENT_LASTEVENT = 65535'i32
+
+ + + +
+ +
TEXTEDITINGEVENT_TEXT_SIZE = 32
+
+ + + +
+ +
TEXTINPUTEVENT_TEXT_SIZE = 32
+
+ + + +
+ +
ADDEVENT = 0'i32
+
+ + + +
+ +
PEEKEVENT = 1
+
+ + + +
+ +
GETEVENT = 2
+
+ + + +
+ +
QUERY = -1
+
+ + + +
+ +
IGNORE = 0
+
+ + + +
+ +
DISABLE = 0
+
+ + + +
+ +
ENABLE = 1
+
+ + + +
+ +
HAPTIC_TYPE_CONSTANT = 1'u
+
+ + + +
+ +
HAPTIC_TYPE_SINE = 2'u
+
+ + + +
+ +
HAPTIC_TYPE_LEFTRIGHT = 4'u
+
+ + + +
+ +
HAPTIC_TYPE_TRIANGLE = 8'u
+
+ + + +
+ +
HAPTIC_TYPE_SAWTOOTHUP = 16'u
+
+ + + +
+ +
HAPTIC_TYPE_SAWTOOTHDOWN = 32'u
+
+ + + +
+ +
HAPTIC_TYPE_RAMP = 64'u
+
+ + + +
+ +
HAPTIC_TYPE_SPRING = 128'u
+
+ + + +
+ +
HAPTIC_TYPE_DAMPER = 256'u
+
+ + + +
+ +
HAPTIC_TYPE_INERTIA = 512'u
+
+ + + +
+ +
HAPTIC_TYPE_FRICTION = 1024'u
+
+ + + +
+ +
HAPTIC_TYPE_CUSTOM = 2048'u
+
+ + + +
+ +
HAPTIC_TYPE_GAIN = 4096'u
+
+ + + +
+ +
HAPTIC_TYPE_AUTOCENTER = 8192'u
+
+ + + +
+ +
HAPTIC_TYPE_STATUS = 16384'u
+
+ + + +
+ +
HAPTIC_TYPE_PAUSE = 32768'u
+
+ + + +
+ +
HAPTIC_TYPE_POLAR = 0
+
+ + + +
+ +
HAPTIC_TYPE_CARTESIAN = 1
+
+ + + +
+ +
HAPTIC_TYPE_SPHERICAL = 2
+
+ + + +
+ +
HAPTIC_TYPE_INFINITY = 4294967295'u
+
+ + + +
+ +
HINT_FRAMEBUFFER_ACCELERATION = "SDL_FRAMEBUFFER_ACCELERATION"
+
+ + + +
+ +
HINT_RENDER_DRIVER = "SDL_RENDER_DRIVER"
+
+ + + +
+ +
HINT_RENDER_OPENGL_SHADERS = "SDL_RENDER_OPENGL_SHADERS"
+
+ + + +
+ +
HINT_RENDER_DIRECT3D_THREADSAFE = "SDL_RENDER_DIRECT3D_THREADSAFE"
+
+ + + +
+ +
HINT_RENDER_DIRECT3D11_DEBUG = "SDL_RENDER_DIRECT3D11_DEBUG"
+
+ + + +
+ +
HINT_RENDER_LOGICAL_SIZE_MODE = "SDL_RENDER_LOGICAL_SIZE_MODE"
+
+ + + +
+ +
HINT_RENDER_SCALE_QUALITY = "SDL_RENDER_SCALE_QUALITY"
+
+ + + +
+ +
HINT_RENDER_VSYNC = "SDL_RENDER_VSYNC"
+
+ + + +
+ +
HINT_VIDEO_ALLOW_SCREENSAVER = "SDL_VIDEO_ALLOW_SCREENSAVER"
+
+ + + +
+ +
HINT_VIDEO_EXTERNAL_CONTEXT = "SDL_VIDEO_EXTERNAL_CONTEXT"
+
+ + + +
+ +
HINT_VIDEO_X11_XVIDMODE = "SDL_VIDEO_X11_XVIDMODE"
+
+ + + +
+ +
HINT_VIDEO_X11_XINERAMA = "SDL_VIDEO_X11_XINERAMA"
+
+ + + +
+ +
HINT_VIDEO_X11_XRANDR = "SDL_VIDEO_X11_XRANDR"
+
+ + + +
+ +
HINT_VIDEO_X11_WINDOW_VISUALID = "SDL_VIDEO_X11_WINDOW_VISUALID"
+
+ + + +
+ +
HINT_VIDEO_X11_NET_WM_PING = "SDL_VIDEO_X11_NET_WM_PING"
+
+ + + +
+ +
HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR = "SDL_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR"
+
+ + + +
+ +
HINT_VIDEO_X11_FORCE_EGL = "SDL_VIDEO_X11_FORCE_EGL"
+
+ + + +
+ +
HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN = "SDL_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN"
+
+ + + +
+ +
HINT_WINDOWS_INTRESOURCE_ICON = "SDL_WINDOWS_INTRESOURCE_ICON"
+
+ + + +
+ +
HINT_WINDOWS_INTRESOURCE_ICON_SMALL = "SDL_WINDOWS_INTRESOURCE_ICON_SMALL"
+
+ + + +
+ +
HINT_WINDOWS_ENABLE_MESSAGELOOP = "SDL_WINDOWS_ENABLE_MESSAGELOOP"
+
+ + + +
+ +
HINT_GRAB_KEYBOARD = "SDL_GRAB_KEYBOARD"
+
+ + + +
+ +
HINT_MOUSE_DOUBLE_CLICK_TIME = "SDL_MOUSE_DOUBLE_CLICK_TIME"
+
+ + + +
+ +
HINT_MOUSE_DOUBLE_CLICK_RADIUS = "SDL_MOUSE_DOUBLE_CLICK_RADIUS"
+
+ + + +
+ +
HINT_MOUSE_NORMAL_SPEED_SCALE = "SDL_MOUSE_NORMAL_SPEED_SCALE"
+
+ + + +
+ +
HINT_MOUSE_RELATIVE_SPEED_SCALE = "SDL_MOUSE_RELATIVE_SPEED_SCALE"
+
+ + + +
+ +
HINT_MOUSE_RELATIVE_MODE_WARP = "SDL_MOUSE_RELATIVE_MODE_WARP"
+
+ + + +
+ +
HINT_MOUSE_FOCUS_CLICKTHROUGH = "SDL_MOUSE_FOCUS_CLICKTHROUGH"
+
+ + + +
+ +
HINT_TOUCH_MOUSE_EVENTS = "SDL_TOUCH_MOUSE_EVENTS"
+
+ + + +
+ +
HINT_MOUSE_TOUCH_EVENTS = "SDL_MOUSE_TOUCH_EVENTS"
+
+ + + +
+ +
HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS = "SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS"
+
+ + + +
+ +
HINT_IDLE_TIMER_DISABLED = "SDL_IOS_IDLE_TIMER_DISABLED"
+
+ + + +
+ +
HINT_ORIENTATIONS = "SDL_IOS_ORIENTATIONS"
+
+ + + +
+ +
HINT_APPLE_TV_CONTROLLER_UI_EVENTS = "SDL_APPLE_TV_CONTROLLER_UI_EVENTS"
+
+ + + +
+ +
HINT_APPLE_TV_REMOTE_ALLOW_ROTATION = "SDL_APPLE_TV_REMOTE_ALLOW_ROTATION"
+
+ + + +
+ +
HINT_IOS_HIDE_HOME_INDICATOR = "SDL_IOS_HIDE_HOME_INDICATOR"
+
+ + + +
+ +
HINT_ACCELEROMETER_AS_JOYSTICK = "SDL_ACCELEROMETER_AS_JOYSTICK"
+
+ + + +
+ +
HINT_TV_REMOTE_AS_JOYSTICK = "SDL_TV_REMOTE_AS_JOYSTICK"
+
+ + + +
+ +
HINT_XINPUT_ENABLED = "SDL_XINPUT_ENABLED"
+
+ + + +
+ +
HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING = "SDL_XINPUT_USE_OLD_JOYSTICK_MAPPING"
+
+ + + +
+ +
HINT_GAMECONTROLLERTYPE = "SDL_GAMECONTROLLERTYPE"
+
+ + + +
+ +
HINT_GAMECONTROLLERCONFIG = "SDL_GAMECONTROLLERCONFIG"
+
+ + + +
+ +
HINT_GAMECONTROLLERCONFIG_FILE = "SDL_GAMECONTROLLERCONFIG_FILE"
+
+ + + +
+ +
HINT_GAMECONTROLLER_IGNORE_DEVICES = "SDL_GAMECONTROLLER_IGNORE_DEVICES"
+
+ + + +
+ +
HINT_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT = "SDL_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT"
+
+ + + +
+ +
HINT_GAMECONTROLLER_USE_BUTTON_LABELS = "SDL_GAMECONTROLLER_USE_BUTTON_LABELS"
+
+ + + +
+ +
HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS = "SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS"
+
+ + + +
+ +
HINT_JOYSTICK_HIDAPI = "SDL_JOYSTICK_HIDAPI"
+
+ + + +
+ +
HINT_JOYSTICK_HIDAPI_PS4 = "SDL_JOYSTICK_HIDAPI_PS4"
+
+ + + +
+ +
HINT_JOYSTICK_HIDAPI_PS4_RUMBLE = "SDL_JOYSTICK_HIDAPI_PS4_RUMBLE"
+
+ + + +
+ +
HINT_JOYSTICK_HIDAPI_STEAM = "SDL_JOYSTICK_HIDAPI_STEAM"
+
+ + + +
+ +
HINT_JOYSTICK_HIDAPI_SWITCH = "SDL_JOYSTICK_HIDAPI_SWITCH"
+
+ + + +
+ +
HINT_JOYSTICK_HIDAPI_XBOX = "SDL_JOYSTICK_HIDAPI_XBOX"
+
+ + + +
+ +
HINT_JOYSTICK_HIDAPI_GAMECUBE = "SDL_JOYSTICK_HIDAPI_GAMECUBE"
+
+ + + +
+ +
HINT_ENABLE_STEAM_CONTROLLERS = "SDL_ENABLE_STEAM_CONTROLLERS"
+
+ + + +
+ +
HINT_ALLOW_TOPMOST = "SDL_ALLOW_TOPMOST"
+
+ + + +
+ +
HINT_TIMER_RESOLUTION = "SDL_TIMER_RESOLUTION"
+
+ + + +
+ +
HINT_QTWAYLAND_CONTENT_ORIENTATION = "SDL_QTWAYLAND_CONTENT_ORIENTATION"
+
+ + + +
+ +
HINT_QTWAYLAND_WINDOW_FLAGS = "SDL_QTWAYLAND_WINDOW_FLAGS"
+
+ + + +
+ +
HINT_THREAD_STACK_SIZE = "SDL_THREAD_STACK_SIZE"
+
+ + + +
+ +
HINT_VIDEO_HIGHDPI_DISABLED = "SDL_VIDEO_HIGHDPI_DISABLED"
+
+ + + +
+ +
HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK = "SDL_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK"
+
+ + + +
+ +
HINT_VIDEO_WIN_D3DCOMPILER = "SDL_VIDEO_WIN_D3DCOMPILER"
+
+ + + +
+ +
HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT = "SDL_VIDEO_WINDOW_SHARE_PIXEL_FORMAT"
+
+ + + +
+ +
HINT_WINRT_PRIVACY_POLICY_URL = "SDL_WINRT_PRIVACY_POLICY_URL"
+
+ + + +
+ +
HINT_WINRT_PRIVACY_POLICY_LABEL = "SDL_WINRT_PRIVACY_POLICY_LABEL"
+
+ + + +
+ +
HINT_WINRT_HANDLE_BACK_BUTTON = "SDL_WINRT_HANDLE_BACK_BUTTON"
+
+ + + +
+ +
HINT_VIDEO_MAC_FULLSCREEN_SPACES = "SDL_VIDEO_MAC_FULLSCREEN_SPACES"
+
+ + + +
+ +
HINT_MAC_BACKGROUND_APP = "SDL_MAC_BACKGROUND_APP"
+
+ + + +
+ +
HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION = "SDL_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION"
+
+ + + +
+ +
HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION = "SDL_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION"
+
+ + + +
+ +
HINT_IME_INTERNAL_EDITING = "SDL_IME_INTERNAL_EDITING"
+
+ + + +
+ +
HINT_ANDROID_TRAP_BACK_BUTTON = "SDL_ANDROID_TRAP_BACK_BUTTON"
+
+ + + +
+ +
HINT_ANDROID_BLOCK_ON_PAUSE = "SDL_ANDROID_BLOCK_ON_PAUSE"
+
+ + + +
+ +
HINT_RETURN_KEY_HIDES_IME = "SDL_RETURN_KEY_HIDES_IME"
+
+ + + +
+ +
HINT_EMSCRIPTEN_KEYBOARD_ELEMENT = "SDL_EMSCRIPTEN_KEYBOARD_ELEMENT"
+
+ + + +
+ +
HINT_NO_SIGNAL_HANDLERS = "SDL_NO_SIGNAL_HANDLERS"
+
+ + + +
+ +
HINT_WINDOWS_NO_CLOSE_ON_ALT_F4 = "SDL_WINDOWS_NO_CLOSE_ON_ALT_F4"
+
+ + + +
+ +
HINT_BMP_SAVE_LEGACY_FORMAT = "SDL_BMP_SAVE_LEGACY_FORMAT"
+
+ + + +
+ +
HINT_WINDOWS_DISABLE_THREAD_NAMING = "SDL_WINDOWS_DISABLE_THREAD_NAMING"
+
+ + + +
+ +
HINT_RPI_VIDEO_LAYER = "SDL_RPI_VIDEO_LAYER"
+
+ + + +
+ +
HINT_VIDEO_DOUBLE_BUFFER = "SDL_VIDEO_DOUBLE_BUFFER"
+
+ + + +
+ +
HINT_OPENGL_ES_DRIVER = "SDL_OPENGL_ES_DRIVER"
+
+ + + +
+ +
HINT_AUDIO_RESAMPLING_MODE = "SDL_AUDIO_RESAMPLING_MODE"
+
+ + + +
+ +
HINT_AUDIO_CATEGORY = "SDL_AUDIO_CATEGORY"
+
+ + + +
+ +
HINT_RENDER_BATCHING = "SDL_RENDER_BATCHING"
+
+ + + +
+ +
HINT_EVENT_LOGGING = "SDL_EVENT_LOGGING"
+
+ + + +
+ +
HINT_WAVE_RIFF_CHUNK_SIZE = "SDL_WAVE_RIFF_CHUNK_SIZE"
+
+ + + +
+ +
HINT_WAVE_TRUNCATION = "SDL_WAVE_TRUNCATION"
+
+ + + +
+ +
HINT_WAVE_FACT_CHUNK = "SDL_WAVE_FACT_CHUNK"
+
+ + + +
+ +
HINT_DISPLAY_USABLE_BOUNDS = "SDL_DISPLAY_USABLE_BOUNDS"
+
+ + + +
+ +
HINT_DEFAULT = 0'i32
+
+ + + +
+ +
HINT_NORMAL = 1
+
+ + + +
+ +
HINT_OVERRIDE = 2
+
+ + + +
+ +
MAX_LOG_MESSAGE = 4096
+
+ + + +
+ +
LOG_CATEGORY_APPLICATION = 0'i32
+
+ + + +
+ +
LOG_CATEGORY_ERROR = 1
+
+ + + +
+ +
LOG_CATEGORY_ASSERT = 2
+
+ + + +
+ +
LOG_CATEGORY_SYSTEM = 3
+
+ + + +
+ +
LOG_CATEGORY_AUDIO = 4
+
+ + + +
+ +
LOG_CATEGORY_VIDEO = 5
+
+ + + +
+ +
LOG_CATEGORY_RENDER = 6
+
+ + + +
+ +
LOG_CATEGORY_INPUT = 7
+
+ + + +
+ +
LOG_CATEGORY_TEST = 8
+
+ +
Reserved for future SDL library use
+ + +
+ +
LOG_CATEGORY_RESERVED1 = 9
+
+ + + +
+ +
LOG_CATEGORY_RESERVED2 = 10
+
+ + + +
+ +
LOG_CATEGORY_RESERVED3 = 11
+
+ + + +
+ +
LOG_CATEGORY_RESERVED4 = 12
+
+ + + +
+ +
LOG_CATEGORY_RESERVED5 = 13
+
+ + + +
+ +
LOG_CATEGORY_RESERVED6 = 14
+
+ + + +
+ +
LOG_CATEGORY_RESERVED7 = 15
+
+ + + +
+ +
LOG_CATEGORY_RESERVED8 = 16
+
+ + + +
+ +
LOG_CATEGORY_RESERVED9 = 17
+
+ + + +
+ +
LOG_CATEGORY_RESERVED10 = 18
+
+ +
Beyond this point is reserved for application use, e.g.
+       enum {
+           MYAPP_CATEGORY_AWESOME1 = SDL_LOG_CATEGORY_CUSTOM,
+           MYAPP_CATEGORY_AWESOME2,
+           MYAPP_CATEGORY_AWESOME3,
+           ...
+       };
+ + +
+ +
LOG_CATEGORY_CUSTOM = 19
+
+ + + +
+ +
LOG_PRIORITY_VERBOSE = 1'i32
+
+ + + +
+ +
LOG_PRIORITY_DEBUG = 2
+
+ + + +
+ +
LOG_PRIORITY_INFO = 3
+
+ + + +
+ +
LOG_PRIORITY_WARN = 4
+
+ + + +
+ +
LOG_PRIORITY_ERROR = 5
+
+ + + +
+ +
LOG_PRIORITY_CRITICAL = 6
+
+ + + +
+ +
NUM_LOG_PRIORITIES = 7
+
+ + + +
+ +
MESSAGEBOX_ERROR = 16'i32
+
+ +
< error dialog
+ + +
+ +
MESSAGEBOX_WARNING = 32'i32
+
+ +
< warning dialog
+ + +
+ +
MESSAGEBOX_INFORMATION = 64'i32
+
+ +
< informational dialog
+ + +
+ +
MESSAGEBOX_BUTTONS_LEFT_TO_RIGHT = 128'i32
+
+ +
< buttons placed left to right
+ + +
+ +
MESSAGEBOX_BUTTONS_RIGHT_TO_LEFT = 256'i32
+
+ +
< buttons placed right to left
+ + +
+ +
MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT = 1'i32
+
+ +
< Marks the default button when return is hit
+ + +
+ +
MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT = 2'i32
+
+ +
< Marks the default button when escape is hit
+ + +
+ +
MESSAGEBOX_COLOR_BACKGROUND = 0'i32
+
+ + + +
+ +
MESSAGEBOX_COLOR_TEXT = 1
+
+ + + +
+ +
MESSAGEBOX_COLOR_BUTTON_BORDER = 2
+
+ + + +
+ +
MESSAGEBOX_COLOR_BUTTON_BACKGROUND = 3
+
+ + + +
+ +
MESSAGEBOX_COLOR_BUTTON_SELECTED = 4
+
+ + + +
+ +
MESSAGEBOX_COLOR_MAX = 5
+
+ + + +
+ +
POWERSTATE_UNKNOWN = 0'i32
+
+ +
< cannot determine power status
+ + +
+ +
POWERSTATE_ON_BATTERY = 1
+
+ +
< Not plugged in, running on the battery
+ + +
+ +
POWERSTATE_NO_BATTERY = 2
+
+ +
< Plugged in, no battery available
+ + +
+ +
POWERSTATE_CHARGING = 3
+
+ +
< Plugged in, charging battery
+ + +
+ +
POWERSTATE_CHARGED = 4
+
+ +
< Plugged in, battery charged
+ + +
+ +
RENDERER_SOFTWARE = 1'i32
+
+ +
< The renderer is a software fallback
+ + +
+ +
RENDERER_ACCELERATED = 2'i32
+
+ +
< The renderer uses hardware
+                                                     acceleration
+ + +
+ +
RENDERER_PRESENTVSYNC = 4'i32
+
+ +
< Present is synchronized
+                                                     with the refresh rate
+ + +
+ +
RENDERER_TARGETTEXTURE = 8'i32
+
+ +
< The renderer supports
+                                                     rendering to texture
+ + +
+ +
ScaleModeNearest = 0'i32
+
+ +
< nearest pixel sampling
+ + +
+ +
ScaleModeLinear = 1
+
+ +
< linear filtering
+ + +
+ +
ScaleModeBest = 2
+
+ +
< anisotropic filtering
+ + +
+ +
TEXTUREACCESS_STATIC = 0'i32
+
+ +
< Changes rarely, not lockable
+ + +
+ +
TEXTUREACCESS_STREAMING = 1
+
+ +
< Changes frequently, lockable
+ + +
+ +
TEXTUREACCESS_TARGET = 2
+
+ +
< Texture can be used as a render target
+ + +
+ +
TEXTUREMODULATE_NONE = 0'i32
+
+ +
< No modulation
+ + +
+ +
TEXTUREMODULATE_COLOR = 1'i32
+
+ +
< srcC = srcC color
+ + +
+ +
TEXTUREMODULATE_ALPHA = 2'i32
+
+ +
< srcA = srcA alpha
+ + +
+ +
FLIP_NONE = 0'i32
+
+ +
< Do not flip
+ + +
+ +
FLIP_HORIZONTAL = 1'i32
+
+ +
< flip horizontally
+ + +
+ +
FLIP_VERTICAL = 2'i32
+
+ +
< flip vertically
+ + +
+ +
SENSOR_INVALID = -1'i32
+
+ +
< Returned for an invalid sensor
+ + +
+ +
SENSOR_UNKNOWN = 0
+
+ +
< Unknown sensor type
+ + +
+ +
SENSOR_ACCEL = 1
+
+ +
< Accelerometer
+ + +
+ +
SENSOR_GYRO = 2
+
+ +
< Gyroscope
+ + +
+ +
STANDARD_GRAVITY = 9.806649999999999'f64
+
+ + + +
+ +
NONSHAPEABLE_WINDOW = -1
+
+ + + +
+ +
INVALID_SHAPE_ARGUMENT = -2
+
+ + + +
+ +
WINDOW_LACKS_SHAPE = -3
+
+ + + +
+ +
ShapeModeDefault = 0'i32
+
+ +
\brief A binarized alpha cutoff with a given integer value.
+ + +
+ +
ShapeModeBinarizeAlpha = 1
+
+ +
\brief A binarized alpha cutoff with a given integer value, but with the opposite comparison.
+ + +
+ +
ShapeModeReverseBinarizeAlpha = 2
+
+ +
\brief A color key is applied.
+ + +
+ +
ShapeModeColorKey = 3
+
+ + + +
+ +
MAJOR_VERSION = 2
+
+ + + +
+ +
MINOR_VERSION = 0
+
+ + + +
+ +
PATCHLEVEL = 12
+
+ + + +
+ +
INIT_TIMER = 0x00000001'u
+
+ + + +
+ +
INIT_AUDIO = 0x00000010'u
+
+ + + +
+ +
INIT_VIDEO = 0x00000020'u
+
+ + + +
+ +
INIT_JOYSTICK = 0x00000200'u
+
+ + + +
+ +
INIT_HAPTIC = 0x00001000'u
+
+ + + +
+ +
INIT_GAMECONTROLLER = 0x00002000'u
+
+ + + +
+ +
INIT_EVENTS = 0x00004000'u
+
+ + + +
+ +
INIT_SENSOR = 0x00008000'u
+
+ + + +
+ +
INIT_NOPARACHUTE = 0x00100000'u
+
+ + + +
+ +
INIT_EVERYTHING = 62001'u
+
+ + + +
+ +
SDLDyLibPath = "/Users/joey/Projects/nim-sdl2/src/build/sdl2/buildcache/libSDL2-2.0.dylib"
+
+ + + +
+ +
SDLMainLib = "/Users/joey/Projects/nim-sdl2/src/build/sdl2/buildcache/libSDL2main.a"
+
+ + + +
+ +
SDLStaticLib = "/Users/joey/Projects/nim-sdl2/src/build/sdl2/buildcache/libSDL2.a"
+
+ + + +
+ +
WINDOWPOS_UNDEFINED = 536805376'u
+
+ + + +
+ +
WINDOWPOS_CENTERED = 805240832'u
+
+ + + +
+ +
SCANCODE_MASK = 1073741824
+
+ + + +
+ +
BUTTON_LMASK = 1
+
+ + + +
+ +
BUTTON_MMASK = 2
+
+ + + +
+ +
BUTTON_RMASK = 4
+
+ + + +
+ +
BUTTON_X1MASK = 8
+
+ + + +
+ +
BUTTON_X2MASK = 16
+
+ + + +
+ +
+
+

Procs

+
+ +
proc getPlatform(): cstring {...}{.importc: "SDL_GetPlatform", cdecl.}
+
+ +
Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+\brief Gets the name of the platform.
+ + +
+ +
proc malloc(size: uint): pointer {...}{.importc: "SDL_malloc", cdecl.}
+
+ + + +
+ +
proc calloc(nmemb: uint; size: uint): pointer {...}{.importc: "SDL_calloc", cdecl.}
+
+ + + +
+ +
proc realloc(mem: pointer; size: uint): pointer {...}{.importc: "SDL_realloc", cdecl.}
+
+ + + +
+ +
proc free(mem: pointer) {...}{.importc: "SDL_free", cdecl.}
+
+ + + +
+ +
proc getMemoryFunctions(mallocFunc: ptr malloc_func; callocFunc: ptr calloc_func;
+                       reallocFunc: ptr realloc_func; freeFunc: ptr free_func) {...}{.
+    importc: "SDL_GetMemoryFunctions", cdecl.}
+
+ +
\brief Get the current set of SDL memory functions
+ + +
+ +
proc setMemoryFunctions(mallocFunc: malloc_func; callocFunc: calloc_func;
+                       reallocFunc: realloc_func; freeFunc: free_func): cint {...}{.
+    importc: "SDL_SetMemoryFunctions", cdecl.}
+
+ +
\brief Replace SDL's memory allocation functions with a custom set
+  
+  \note If you are replacing SDL's memory functions, you should call
+        SDL_GetNumAllocations() and be very careful if it returns non-zero.
+        That means that your free function will be called with memory
+        allocated by the previous memory allocation functions.
+ + +
+ +
proc getNumAllocations(): cint {...}{.importc: "SDL_GetNumAllocations", cdecl.}
+
+ +
\brief Get the number of outstanding (unfreed) allocations
+ + +
+ +
proc getenv(name: cstring): cstring {...}{.importc: "SDL_getenv", cdecl.}
+
+ + + +
+ +
proc setenv(name: cstring; value: cstring; overwrite: cint): cint {...}{.
+    importc: "SDL_setenv", cdecl.}
+
+ + + +
+ +
proc qsort(base: pointer; nmemb: uint; size: uint;
+          compare: proc (a1: pointer; a2: pointer): cint {...}{.cdecl.}) {...}{.
+    importc: "SDL_qsort", cdecl.}
+
+ + + +
+ +
proc abs(x: cint): cint {...}{.importc: "SDL_abs", cdecl.}
+
+ + + +
+ +
proc isdigit(x: cint): cint {...}{.importc: "SDL_isdigit", cdecl.}
+
+ + + +
+ +
proc isspace(x: cint): cint {...}{.importc: "SDL_isspace", cdecl.}
+
+ + + +
+ +
proc isupper(x: cint): cint {...}{.importc: "SDL_isupper", cdecl.}
+
+ + + +
+ +
proc islower(x: cint): cint {...}{.importc: "SDL_islower", cdecl.}
+
+ + + +
+ +
proc toupper(x: cint): cint {...}{.importc: "SDL_toupper", cdecl.}
+
+ + + +
+ +
proc tolower(x: cint): cint {...}{.importc: "SDL_tolower", cdecl.}
+
+ + + +
+ +
proc memset(dst: pointer; c: cint; len: uint): pointer {...}{.importc: "SDL_memset", cdecl.}
+
+ + + +
+ +
proc memcpy(dst: pointer; src: pointer; len: uint): pointer {...}{.importc: "SDL_memcpy", cdecl.}
+
+ + + +
+ +
proc memmove(dst: pointer; src: pointer; len: uint): pointer {...}{.importc: "SDL_memmove",
+    cdecl.}
+
+ + + +
+ +
proc memcmp(s1: pointer; s2: pointer; len: uint): cint {...}{.importc: "SDL_memcmp", cdecl.}
+
+ + + +
+ +
proc wcslen(wstr: ptr wchar_t): uint {...}{.importc: "SDL_wcslen", cdecl.}
+
+ + + +
+ +
proc wcslcpy(dst: ptr wchar_t; src: ptr wchar_t; maxlen: uint): uint {...}{.
+    importc: "SDL_wcslcpy", cdecl.}
+
+ + + +
+ +
proc wcslcat(dst: ptr wchar_t; src: ptr wchar_t; maxlen: uint): uint {...}{.
+    importc: "SDL_wcslcat", cdecl.}
+
+ + + +
+ +
proc wcsdup(wstr: ptr wchar_t): ptr wchar_t {...}{.importc: "SDL_wcsdup", cdecl.}
+
+ + + +
+ +
proc wcsstr(haystack: ptr wchar_t; needle: ptr wchar_t): ptr wchar_t {...}{.
+    importc: "SDL_wcsstr", cdecl.}
+
+ + + +
+ +
proc wcscmp(str1: ptr wchar_t; str2: ptr wchar_t): cint {...}{.importc: "SDL_wcscmp", cdecl.}
+
+ + + +
+ +
proc wcsncmp(str1: ptr wchar_t; str2: ptr wchar_t; maxlen: uint): cint {...}{.
+    importc: "SDL_wcsncmp", cdecl.}
+
+ + + +
+ +
proc strlen(str: cstring): uint {...}{.importc: "SDL_strlen", cdecl.}
+
+ + + +
+ +
proc strlcpy(dst: cstring; src: cstring; maxlen: uint): uint {...}{.importc: "SDL_strlcpy",
+    cdecl.}
+
+ + + +
+ +
proc utf8strlcpy(dst: cstring; src: cstring; dstBytes: uint): uint {...}{.
+    importc: "SDL_utf8strlcpy", cdecl.}
+
+ + + +
+ +
proc strlcat(dst: cstring; src: cstring; maxlen: uint): uint {...}{.importc: "SDL_strlcat",
+    cdecl.}
+
+ + + +
+ +
proc strdup(str: cstring): cstring {...}{.importc: "SDL_strdup", cdecl.}
+
+ + + +
+ +
proc strrev(str: cstring): cstring {...}{.importc: "SDL_strrev", cdecl.}
+
+ + + +
+ +
proc strupr(str: cstring): cstring {...}{.importc: "SDL_strupr", cdecl.}
+
+ + + +
+ +
proc strlwr(str: cstring): cstring {...}{.importc: "SDL_strlwr", cdecl.}
+
+ + + +
+ +
proc strchr(str: cstring; c: cint): cstring {...}{.importc: "SDL_strchr", cdecl.}
+
+ + + +
+ +
proc strrchr(str: cstring; c: cint): cstring {...}{.importc: "SDL_strrchr", cdecl.}
+
+ + + +
+ +
proc strstr(haystack: cstring; needle: cstring): cstring {...}{.importc: "SDL_strstr", cdecl.}
+
+ + + +
+ +
proc strtokr(s1: cstring; s2: cstring; saveptr: ptr cstring): cstring {...}{.
+    importc: "SDL_strtokr", cdecl.}
+
+ + + +
+ +
proc utf8strlen(str: cstring): uint {...}{.importc: "SDL_utf8strlen", cdecl.}
+
+ + + +
+ +
proc itoa(value: cint; str: cstring; radix: cint): cstring {...}{.importc: "SDL_itoa", cdecl.}
+
+ + + +
+ +
proc uitoa(value: cuint; str: cstring; radix: cint): cstring {...}{.importc: "SDL_uitoa", cdecl.}
+
+ + + +
+ +
proc ltoa(value: clong; str: cstring; radix: cint): cstring {...}{.importc: "SDL_ltoa", cdecl.}
+
+ + + +
+ +
proc ultoa(value: culong; str: cstring; radix: cint): cstring {...}{.importc: "SDL_ultoa",
+    cdecl.}
+
+ + + +
+ +
proc lltoa(value: Sint64; str: cstring; radix: cint): cstring {...}{.importc: "SDL_lltoa",
+    cdecl.}
+
+ + + +
+ +
proc ulltoa(value: Uint64; str: cstring; radix: cint): cstring {...}{.importc: "SDL_ulltoa",
+    cdecl.}
+
+ + + +
+ +
proc atoi(str: cstring): cint {...}{.importc: "SDL_atoi", cdecl.}
+
+ + + +
+ +
proc atof(str: cstring): cdouble {...}{.importc: "SDL_atof", cdecl.}
+
+ + + +
+ +
proc strtol(str: cstring; endp: ptr cstring; base: cint): clong {...}{.importc: "SDL_strtol",
+    cdecl.}
+
+ + + +
+ +
proc strtoul(str: cstring; endp: ptr cstring; base: cint): culong {...}{.
+    importc: "SDL_strtoul", cdecl.}
+
+ + + +
+ +
proc strtoll(str: cstring; endp: ptr cstring; base: cint): Sint64 {...}{.
+    importc: "SDL_strtoll", cdecl.}
+
+ + + +
+ +
proc strtoull(str: cstring; endp: ptr cstring; base: cint): Uint64 {...}{.
+    importc: "SDL_strtoull", cdecl.}
+
+ + + +
+ +
proc strtod(str: cstring; endp: ptr cstring): cdouble {...}{.importc: "SDL_strtod", cdecl.}
+
+ + + +
+ +
proc strcmp(str1: cstring; str2: cstring): cint {...}{.importc: "SDL_strcmp", cdecl.}
+
+ + + +
+ +
proc strncmp(str1: cstring; str2: cstring; maxlen: uint): cint {...}{.importc: "SDL_strncmp",
+    cdecl.}
+
+ + + +
+ +
proc strcasecmp(str1: cstring; str2: cstring): cint {...}{.importc: "SDL_strcasecmp", cdecl.}
+
+ + + +
+ +
proc strncasecmp(str1: cstring; str2: cstring; len: uint): cint {...}{.
+    importc: "SDL_strncasecmp", cdecl.}
+
+ + + +
+ +
proc sscanf(text: cstring; fmt: cstring): cint {...}{.importc: "SDL_sscanf", cdecl, varargs.}
+
+ + + +
+ +
proc vsscanf(text: cstring; fmt: cstring; ap: va_list): cint {...}{.importc: "SDL_vsscanf",
+    cdecl.}
+
+ + + +
+ +
proc snprintf(text: cstring; maxlen: uint; fmt: cstring): cint {...}{.
+    importc: "SDL_snprintf", cdecl, varargs.}
+
+ + + +
+ +
proc vsnprintf(text: cstring; maxlen: uint; fmt: cstring; ap: va_list): cint {...}{.
+    importc: "SDL_vsnprintf", cdecl.}
+
+ + + +
+ +
proc acos(x: cdouble): cdouble {...}{.importc: "SDL_acos", cdecl.}
+
+ + + +
+ +
proc acosf(x: cfloat): cfloat {...}{.importc: "SDL_acosf", cdecl.}
+
+ + + +
+ +
proc asin(x: cdouble): cdouble {...}{.importc: "SDL_asin", cdecl.}
+
+ + + +
+ +
proc asinf(x: cfloat): cfloat {...}{.importc: "SDL_asinf", cdecl.}
+
+ + + +
+ +
proc atan(x: cdouble): cdouble {...}{.importc: "SDL_atan", cdecl.}
+
+ + + +
+ +
proc atanf(x: cfloat): cfloat {...}{.importc: "SDL_atanf", cdecl.}
+
+ + + +
+ +
proc atan2(x: cdouble; y: cdouble): cdouble {...}{.importc: "SDL_atan2", cdecl.}
+
+ + + +
+ +
proc atan2f(x: cfloat; y: cfloat): cfloat {...}{.importc: "SDL_atan2f", cdecl.}
+
+ + + +
+ +
proc ceil(x: cdouble): cdouble {...}{.importc: "SDL_ceil", cdecl.}
+
+ + + +
+ +
proc ceilf(x: cfloat): cfloat {...}{.importc: "SDL_ceilf", cdecl.}
+
+ + + +
+ +
proc copysign(x: cdouble; y: cdouble): cdouble {...}{.importc: "SDL_copysign", cdecl.}
+
+ + + +
+ +
proc copysignf(x: cfloat; y: cfloat): cfloat {...}{.importc: "SDL_copysignf", cdecl.}
+
+ + + +
+ +
proc cos(x: cdouble): cdouble {...}{.importc: "SDL_cos", cdecl.}
+
+ + + +
+ +
proc cosf(x: cfloat): cfloat {...}{.importc: "SDL_cosf", cdecl.}
+
+ + + +
+ +
proc exp(x: cdouble): cdouble {...}{.importc: "SDL_exp", cdecl.}
+
+ + + +
+ +
proc expf(x: cfloat): cfloat {...}{.importc: "SDL_expf", cdecl.}
+
+ + + +
+ +
proc fabs(x: cdouble): cdouble {...}{.importc: "SDL_fabs", cdecl.}
+
+ + + +
+ +
proc fabsf(x: cfloat): cfloat {...}{.importc: "SDL_fabsf", cdecl.}
+
+ + + +
+ +
proc floor(x: cdouble): cdouble {...}{.importc: "SDL_floor", cdecl.}
+
+ + + +
+ +
proc floorf(x: cfloat): cfloat {...}{.importc: "SDL_floorf", cdecl.}
+
+ + + +
+ +
proc fmod(x: cdouble; y: cdouble): cdouble {...}{.importc: "SDL_fmod", cdecl.}
+
+ + + +
+ +
proc fmodf(x: cfloat; y: cfloat): cfloat {...}{.importc: "SDL_fmodf", cdecl.}
+
+ + + +
+ +
proc log(x: cdouble): cdouble {...}{.importc: "SDL_log", cdecl.}
+
+ + + +
+ +
proc logf(x: cfloat): cfloat {...}{.importc: "SDL_logf", cdecl.}
+
+ + + +
+ +
proc log10(x: cdouble): cdouble {...}{.importc: "SDL_log10", cdecl.}
+
+ + + +
+ +
proc log10f(x: cfloat): cfloat {...}{.importc: "SDL_log10f", cdecl.}
+
+ + + +
+ +
proc pow(x: cdouble; y: cdouble): cdouble {...}{.importc: "SDL_pow", cdecl.}
+
+ + + +
+ +
proc powf(x: cfloat; y: cfloat): cfloat {...}{.importc: "SDL_powf", cdecl.}
+
+ + + +
+ +
proc scalbn(x: cdouble; n: cint): cdouble {...}{.importc: "SDL_scalbn", cdecl.}
+
+ + + +
+ +
proc scalbnf(x: cfloat; n: cint): cfloat {...}{.importc: "SDL_scalbnf", cdecl.}
+
+ + + +
+ +
proc sin(x: cdouble): cdouble {...}{.importc: "SDL_sin", cdecl.}
+
+ + + +
+ +
proc sinf(x: cfloat): cfloat {...}{.importc: "SDL_sinf", cdecl.}
+
+ + + +
+ +
proc sqrt(x: cdouble): cdouble {...}{.importc: "SDL_sqrt", cdecl.}
+
+ + + +
+ +
proc sqrtf(x: cfloat): cfloat {...}{.importc: "SDL_sqrtf", cdecl.}
+
+ + + +
+ +
proc tan(x: cdouble): cdouble {...}{.importc: "SDL_tan", cdecl.}
+
+ + + +
+ +
proc tanf(x: cfloat): cfloat {...}{.importc: "SDL_tanf", cdecl.}
+
+ + + +
+ +
proc iconv_open(tocode: cstring; fromcode: cstring): iconv_t {...}{.
+    importc: "SDL_iconv_open", cdecl.}
+
+ + + +
+ +
proc iconv_close(cd: iconv_t): cint {...}{.importc: "SDL_iconv_close", cdecl.}
+
+ + + +
+ +
proc iconv(cd: iconv_t; inbuf: ptr cstring; inbytesleft: ptr uint; outbuf: ptr cstring;
+          outbytesleft: ptr uint): uint {...}{.importc: "SDL_iconv", cdecl.}
+
+ + + +
+ +
proc iconv_string(tocode: cstring; fromcode: cstring; inbuf: cstring; inbytesleft: uint): cstring {...}{.
+    importc: "SDL_iconv_string", cdecl.}
+
+ +
This function converts a string between encodings in one pass, returning a
+  string that must be freed with SDL_free() or NULL on error.
+ + +
+ +
proc main(argc: cint; argv: UncheckedArray[cstring]): cint {...}{.importc: "SDL_main", cdecl.}
+
+ + + +
+ +
proc setMainReady() {...}{.importc: "SDL_SetMainReady", cdecl.}
+
+ +
This is called by the real SDL main function to let the rest of the
+  library know that initialization was done properly.
+  
+  Calling this yourself without knowing what you're doing can cause
+  crashes and hard to diagnose problems with your application.
+ + +
+ +
proc reportAssertion(a1: ptr AssertData; a2: cstring; a3: cstring; a4: cint): AssertState {...}{.
+    importc: "SDL_ReportAssertion", cdecl.}
+
+ +
Never call this directly. Use the SDL_assert macros.
+ + +
+ +
proc setAssertionHandler(handler: AssertionHandler; userdata: pointer) {...}{.
+    importc: "SDL_SetAssertionHandler", cdecl.}
+
+ +
\brief Set an application-defined assertion handler.
+  
+  This allows an app to show its own assertion UI and/or force the
+  response to an assertion failure. If the app doesn't provide this, SDL
+  will try to do the right thing, popping up a system-specific GUI dialog,
+  and probably minimizing any fullscreen windows.
+  
+  This callback may fire from any thread, but it runs wrapped in a mutex, so
+  it will only fire from one thread at a time.
+  
+  Setting the callback to NULL restores SDL's original internal handler.
+  
+  This callback is NOT reset to SDL's internal handler upon SDL_Quit()!
+  
+  Return SDL_AssertState value of how to handle the assertion failure.
+  
+  \param handler Callback function, called when an assertion fails.
+  \param userdata A pointer passed to the callback as-is.
+ + +
+ +
proc getDefaultAssertionHandler(): AssertionHandler {...}{.
+    importc: "SDL_GetDefaultAssertionHandler", cdecl.}
+
+ +
\brief Get the default assertion handler.
+  
+  This returns the function pointer that is called by default when an
+   assertion is triggered. This is an internal function provided by SDL,
+   that is used for assertions when SDL_SetAssertionHandler() hasn't been
+   used to provide a different function.
+  
+  \return The default SDL_AssertionHandler that is called when an assert triggers.
+ + +
+ +
proc getAssertionHandler(puserdata: ptr pointer): AssertionHandler {...}{.
+    importc: "SDL_GetAssertionHandler", cdecl.}
+
+ +
\brief Get the current assertion handler.
+  
+  This returns the function pointer that is called when an assertion is
+   triggered. This is either the value last passed to
+   SDL_SetAssertionHandler(), or if no application-specified function is
+   set, is equivalent to calling SDL_GetDefaultAssertionHandler().
+   
+   \param puserdata Pointer to a void, which will store the "userdata"
+                    pointer that was passed to SDL_SetAssertionHandler().
+                    This value will always be NULL for the default handler.
+                    If you don't care about this data, it is safe to pass
+                    a NULL pointer to this function to ignore it.
+  \return The SDL_AssertionHandler that is called when an assert triggers.
+ + +
+ +
proc getAssertionReport(): ptr AssertData {...}{.importc: "SDL_GetAssertionReport", cdecl.}
+
+ +
\brief Get a list of all assertion failures.
+  
+  Get all assertions triggered since last call to SDL_ResetAssertionReport(),
+  or the start of the program.
+  
+  The proper way to examine this data looks something like this:
+  
+  <code>
+  const SDL_AssertDataitem = SDL_GetAssertionReport();
+  while (item) {
+      printf("'%s', %s (%s:%d), triggered %u times, always ignore: %s.\\n",
+             item->condition, item->function, item->filename,
+             item->linenum, item->trigger_count,
+             item->always_ignore ? "yes" : "no");
+      item = item->next;
+  }
+  </code>
+  
+  \return List of all assertions.
+  \sa SDL_ResetAssertionReport
+ + +
+ +
proc resetAssertionReport() {...}{.importc: "SDL_ResetAssertionReport", cdecl.}
+
+ +
\brief Reset the list of all assertion failures.
+  
+  Reset list of all assertions triggered.
+  
+  \sa SDL_GetAssertionReport
+ + +
+ +
proc atomicTryLock(lock: ptr SpinLock): bool {...}{.importc: "SDL_AtomicTryLock", cdecl.}
+
+ +
\brief Try to lock a spin lock by setting it to a non-zero value.
+ 
+ \param lock Points to the lock.
+ 
+ \return SDL_TRUE if the lock succeeded, SDL_FALSE if the lock is already held.
+ + +
+ +
proc atomicLock(lock: ptr SpinLock) {...}{.importc: "SDL_AtomicLock", cdecl.}
+
+ +
\brief Lock a spin lock by setting it to a non-zero value.
+ 
+ \param lock Points to the lock.
+ + +
+ +
proc atomicUnlock(lock: ptr SpinLock) {...}{.importc: "SDL_AtomicUnlock", cdecl.}
+
+ +
\brief Unlock a spin lock by setting it to 0. Always returns immediately
+ 
+ \param lock Points to the lock.
+ + +
+ +
proc memoryBarrierReleaseFunction() {...}{.importc: "SDL_MemoryBarrierReleaseFunction",
+                                    cdecl.}
+
+ +
Memory barriers are designed to prevent reads and writes from being
+ reordered by the compiler and being seen out of order on multi-core CPUs.
+ 
+ A typical pattern would be for thread A to write some data and a flag,
+ and for thread B to read the flag and get the data. In this case you
+ would insert a release barrier between writing the data and the flag,
+ guaranteeing that the data write completes no later than the flag is
+ written, and you would insert an acquire barrier between reading the
+ flag and reading the data, to ensure that all the reads associated
+ with the flag have completed.
+ 
+ In this pattern you should always see a release barrier paired with
+ an acquire barrier and you should gate the data reads/writes with a
+ single flag variable.
+ 
+ For more information on these semantics, take a look at the blog post:
+ http:preshing.com/20120913/acquire-and-release-semantics
+ + +
+ +
proc memoryBarrierAcquireFunction() {...}{.importc: "SDL_MemoryBarrierAcquireFunction",
+                                    cdecl.}
+
+ + + +
+ +
proc atomicCAS(a: ptr atomic_t; oldval: cint; newval: cint): bool {...}{.
+    importc: "SDL_AtomicCAS", cdecl.}
+
+ +
\brief Set an atomic variable to a new value if it is currently an old value.
+ 
+ \return SDL_TRUE if the atomic variable was set, SDL_FALSE otherwise.
+ 
+ \note If you don't know what this function is for, you shouldn't use it!
+ + +
+ +
proc atomicSet(a: ptr atomic_t; v: cint): cint {...}{.importc: "SDL_AtomicSet", cdecl.}
+
+ +
\brief Set an atomic variable to a value.
+ 
+ \return The previous value of the atomic variable.
+ + +
+ +
proc atomicGet(a: ptr atomic_t): cint {...}{.importc: "SDL_AtomicGet", cdecl.}
+
+ +
\brief Get the value of an atomic variable
+ + +
+ +
proc atomicAdd(a: ptr atomic_t; v: cint): cint {...}{.importc: "SDL_AtomicAdd", cdecl.}
+
+ +
\brief Add to an atomic variable.
+ 
+ \return The previous value of the atomic variable.
+ 
+ \note This same style can be used for any number operation
+ + +
+ +
proc atomicCASPtr(a: ptr pointer; oldval: pointer; newval: pointer): bool {...}{.
+    importc: "SDL_AtomicCASPtr", cdecl.}
+
+ +
\brief Set a pointer to a new value if it is currently an old value.
+ 
+ \return SDL_TRUE if the pointer was set, SDL_FALSE otherwise.
+ 
+ \note If you don't know what this function is for, you shouldn't use it!
+ + +
+ +
proc atomicSetPtr(a: ptr pointer; v: pointer): pointer {...}{.importc: "SDL_AtomicSetPtr",
+    cdecl.}
+
+ +
\brief Set a pointer to a value atomically.
+ 
+ \return The previous value of the pointer.
+ + +
+ +
proc atomicGetPtr(a: ptr pointer): pointer {...}{.importc: "SDL_AtomicGetPtr", cdecl.}
+
+ +
\brief Get the value of a pointer atomically.
+ + +
+ +
proc setError(fmt: cstring): cint {...}{.importc: "SDL_SetError", cdecl, varargs.}
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+Public functions
+SDL_SetError() unconditionally returns -1.
+ + +
+ +
proc getError(): cstring {...}{.importc: "SDL_GetError", cdecl.}
+
+ + + +
+ +
proc clearError() {...}{.importc: "SDL_ClearError", cdecl.}
+
+ + + +
+ +
proc error(code: errorcode): cint {...}{.importc: "SDL_Error", cdecl.}
+
+ +
SDL_Error() unconditionally returns -1.
+ + +
+ +
proc createMutex(): ptr mutex {...}{.importc: "SDL_CreateMutex", cdecl.}
+
+ +
Create a mutex, initialized unlocked.
+ + +
+ +
proc lockMutex(mutex: ptr mutex): cint {...}{.importc: "SDL_LockMutex", cdecl.}
+
+ + + +
+ +
proc tryLockMutex(mutex: ptr mutex): cint {...}{.importc: "SDL_TryLockMutex", cdecl.}
+
+ +
Try to lock the mutex
+  
+  \return 0, SDL_MUTEX_TIMEDOUT, or -1 on error
+ + +
+ +
proc unlockMutex(mutex: ptr mutex): cint {...}{.importc: "SDL_UnlockMutex", cdecl.}
+
+ + + +
+ +
proc destroyMutex(mutex: ptr mutex) {...}{.importc: "SDL_DestroyMutex", cdecl.}
+
+ +
Destroy a mutex.
+ + +
+ +
proc createSemaphore(initialValue: Uint32): ptr sem {...}{.importc: "SDL_CreateSemaphore",
+    cdecl.}
+
+ +
Create a semaphore, initialized with value, returns NULL on failure.
+ + +
+ +
proc destroySemaphore(sem: ptr sem) {...}{.importc: "SDL_DestroySemaphore", cdecl.}
+
+ +
Destroy a semaphore.
+ + +
+ +
proc semWait(sem: ptr sem): cint {...}{.importc: "SDL_SemWait", cdecl.}
+
+ +
This function suspends the calling thread until the semaphore pointed
+  to by \c sem has a positive count. It then atomically decreases the
+  semaphore count.
+ + +
+ +
proc semTryWait(sem: ptr sem): cint {...}{.importc: "SDL_SemTryWait", cdecl.}
+
+ +
Non-blocking variant of SDL_SemWait().
+  
+  \return 0 if the wait succeeds, ::SDL_MUTEX_TIMEDOUT if the wait would
+          block, and -1 on error.
+ + +
+ +
proc semWaitTimeout(sem: ptr sem; ms: Uint32): cint {...}{.importc: "SDL_SemWaitTimeout",
+    cdecl.}
+
+ +
Variant of SDL_SemWait() with a timeout in milliseconds.
+  
+  \return 0 if the wait succeeds, ::SDL_MUTEX_TIMEDOUT if the wait does not
+          succeed in the allotted time, and -1 on error.
+  
+  \warning On some platforms this function is implemented by looping with a
+           delay of 1 ms, and so should be avoided if possible.
+ + +
+ +
proc semPost(sem: ptr sem): cint {...}{.importc: "SDL_SemPost", cdecl.}
+
+ +
Atomically increases the semaphore's count (not blocking).
+  
+  \return 0, or -1 on error.
+ + +
+ +
proc semValue(sem: ptr sem): Uint32 {...}{.importc: "SDL_SemValue", cdecl.}
+
+ +
Returns the current count of the semaphore.
+ + +
+ +
proc createCond(): ptr cond {...}{.importc: "SDL_CreateCond", cdecl.}
+
+ +
Create a condition variable.
+  
+  Typical use of condition variables:
+  
+  Thread A:
+    SDL_LockMutex(lock);
+    while ( ! condition ) {
+        SDL_CondWait(cond, lock);
+    }
+    SDL_UnlockMutex(lock);
+  
+  Thread B:
+    SDL_LockMutex(lock);
+    ...
+    condition = true;
+    ...
+    SDL_CondSignal(cond);
+    SDL_UnlockMutex(lock);
+  
+  There is some discussion whether to signal the condition variable
+  with the mutex locked or not.  There is some potential performance
+  benefit to unlocking first on some platforms, but there are some
+  potential race conditions depending on how your code is structured.
+  
+  In general it's safer to signal the condition variable while the
+  mutex is locked.
+ + +
+ +
proc destroyCond(cond: ptr cond) {...}{.importc: "SDL_DestroyCond", cdecl.}
+
+ +
Destroy a condition variable.
+ + +
+ +
proc condSignal(cond: ptr cond): cint {...}{.importc: "SDL_CondSignal", cdecl.}
+
+ +
Restart one of the threads that are waiting on the condition variable.
+  
+  \return 0 or -1 on error.
+ + +
+ +
proc condBroadcast(cond: ptr cond): cint {...}{.importc: "SDL_CondBroadcast", cdecl.}
+
+ +
Restart all threads that are waiting on the condition variable.
+  
+  \return 0 or -1 on error.
+ + +
+ +
proc condWait(cond: ptr cond; mutex: ptr mutex): cint {...}{.importc: "SDL_CondWait", cdecl.}
+
+ +
Wait on the condition variable, unlocking the provided mutex.
+  
+  \warning The mutex must be locked before entering this function!
+  
+  The mutex is re-locked once the condition variable is signaled.
+  
+  \return 0 when it is signaled, or -1 on error.
+ + +
+ +
proc condWaitTimeout(cond: ptr cond; mutex: ptr mutex; ms: Uint32): cint {...}{.
+    importc: "SDL_CondWaitTimeout", cdecl.}
+
+ +
Waits for at most \c ms milliseconds, and returns 0 if the condition
+  variable is signaled, ::SDL_MUTEX_TIMEDOUT if the condition is not
+  signaled in the allotted time, and -1 on error.
+  
+  \warning On some platforms this function is implemented by looping with a
+           delay of 1 ms, and so should be avoided if possible.
+ + +
+ +
proc createThread(fn: ThreadFunction; name: cstring; data: pointer): ptr Thread {...}{.
+    importc: "SDL_CreateThread", cdecl.}
+
+ +
Create a thread with a default stack size.
+  
+  This is equivalent to calling:
+  SDL_CreateThreadWithStackSize(fn, name, 0, data);
+ + +
+ +
proc createThreadWithStackSize(fn: ThreadFunction; name: cstring; stacksize: uint;
+                              data: pointer): ptr Thread {...}{.
+    importc: "SDL_CreateThreadWithStackSize", cdecl.}
+
+ +
Create a thread.
+   
+   Thread naming is a little complicated: Most systems have very small
+    limits for the string length (Haiku has 32 bytes, Linux currently has 16,
+    Visual C++ 6.0 has nine!), and possibly other arbitrary rules. You'll
+    have to see what happens with your system's debugger. The name should be
+    UTF-8 (but using the naming limits of C identifiers is a better bet).
+   There are no requirements for thread naming conventions, so long as the
+    string is null-terminated UTF-8, but these guidelines are helpful in
+    choosing a name:
+    
+    http:stackoverflow.com/questions/149932/naming-conventions-for-threads
+   
+   If a system imposes requirements, SDL will try to munge the string for
+    it (truncate, etc), but the original string contents will be available
+    from SDL_GetThreadName().
+   
+   The size (in bytes) of the new stack can be specified. Zero means "use
+    the system default" which might be wildly different between platforms
+    (x86 Linux generally defaults to eight megabytes, an embedded device
+    might be a few kilobytes instead).
+   
+   In SDL 2.1, stacksize will be folded into the original SDL_CreateThread
+    function.
+ + +
+ +
proc getThreadName(thread: ptr Thread): cstring {...}{.importc: "SDL_GetThreadName", cdecl.}
+
+ +
Get the thread name, as it was specified in SDL_CreateThread().
+  This function returns a pointer to a UTF-8 string that names the
+  specified thread, or NULL if it doesn't have a name. This is internal
+  memory, not to be free()'d by the caller, and remains valid until the
+  specified thread is cleaned up by SDL_WaitThread().
+ + +
+ +
proc getThreadID(thread: ptr Thread): threadID {...}{.importc: "SDL_GetThreadID", cdecl.}
+
+ +
Get the thread identifier for the specified thread.
+  
+  Equivalent to SDL_ThreadID() if the specified thread is NULL.
+ + +
+ +
proc setThreadPriority(priority: ThreadPriority): cint {...}{.
+    importc: "SDL_SetThreadPriority", cdecl.}
+
+ +
Set the priority for the current thread
+ + +
+ +
proc waitThread(thread: ptr Thread; status: ptr cint) {...}{.importc: "SDL_WaitThread", cdecl.}
+
+ +
Wait for a thread to finish. Threads that haven't been detached will
+  remain (as a "zombie") until this function cleans them up. Not doing so
+  is a resource leak.
+  
+  Once a thread has been cleaned up through this function, the SDL_Thread
+  that references it becomes invalid and should not be referenced again.
+  As such, only one thread may call SDL_WaitThread() on another.
+  
+  The return code for the thread function is placed in the area
+  pointed to by \c status, if \c status is not NULL.
+  
+  You may not wait on a thread that has been used in a call to
+  SDL_DetachThread(). Use either that function or this one, but not
+  both, or behavior is undefined.
+  
+  It is safe to pass NULL to this function; it is a no-op.
+ + +
+ +
proc detachThread(thread: ptr Thread) {...}{.importc: "SDL_DetachThread", cdecl.}
+
+ +
A thread may be "detached" to signify that it should not remain until
+  another thread has called SDL_WaitThread() on it. Detaching a thread
+  is useful for long-running threads that nothing needs to synchronize
+  with or further manage. When a detached thread is done, it simply
+  goes away.
+  
+  There is no way to recover the return code of a detached thread. If you
+  need this, don't detach the thread and instead use SDL_WaitThread().
+  
+  Once a thread is detached, you should usually assume the SDL_Thread isn't
+  safe to reference again, as it will become invalid immediately upon
+  the detached thread's exit, instead of remaining until someone has called
+  SDL_WaitThread() to finally clean it up. As such, don't detach the same
+  thread more than once.
+  
+  If a thread has already exited when passed to SDL_DetachThread(), it will
+  stop waiting for a call to SDL_WaitThread() and clean up immediately.
+  It is not safe to detach a thread that might be used with SDL_WaitThread().
+  
+  You may not call SDL_WaitThread() on a thread that has been detached.
+  Use either that function or this one, but not both, or behavior is
+  undefined.
+  
+  It is safe to pass NULL to this function; it is a no-op.
+ + +
+ +
proc tLSCreate(): TLSID {...}{.importc: "SDL_TLSCreate", cdecl.}
+
+ +
\brief Create an identifier that is globally visible to all threads but refers to data that is thread-specific.
+  
+  \return The newly created thread local storage identifier, or 0 on error
+  
+  \code
+  static SDL_SpinLock tls_lock;
+  static SDL_TLSID thread_local_storage;
+  
+  void SetMyThreadData(voidvalue)
+  {
+      if (!thread_local_storage) {
+          SDL_AtomicLock(&tls_lock);
+          if (!thread_local_storage) {
+              thread_local_storage = SDL_TLSCreate();
+          }
+          SDL_AtomicUnlock(&tls_lock);
+      }
+      SDL_TLSSet(thread_local_storage, value, 0);
+  }
+  
+  voidGetMyThreadData(void)
+  {
+      return SDL_TLSGet(thread_local_storage);
+  }
+  \endcode
+  
+  \sa SDL_TLSGet()
+  \sa SDL_TLSSet()
+ + +
+ +
proc tLSGet(id: TLSID): pointer {...}{.importc: "SDL_TLSGet", cdecl.}
+
+ +
\brief Get the value associated with a thread local storage ID for the current thread.
+  
+  \param id The thread local storage ID
+  
+  \return The value associated with the ID for the current thread, or NULL if no value has been set.
+  
+  \sa SDL_TLSCreate()
+  \sa SDL_TLSSet()
+ + +
+ +
proc tLSSet(id: TLSID; value: pointer; destructor: proc (a1: pointer) {...}{.cdecl.}): cint {...}{.
+    importc: "SDL_TLSSet", cdecl.}
+
+ +
\brief Set the value associated with a thread local storage ID for the current thread.
+  
+  \param id The thread local storage ID
+  \param value The value to associate with the ID for the current thread
+  \param destructor A function called when the thread exits, to free the value.
+  
+  \return 0 on success, -1 on error
+  
+  \sa SDL_TLSCreate()
+  \sa SDL_TLSGet()
+ + +
+ +
proc rWFromFile(file: cstring; mode: cstring): ptr RWops {...}{.importc: "SDL_RWFromFile",
+    cdecl.}
+
+ +
\name RWFrom functions
+  
+  Functions to create SDL_RWops structures from various data streams.
+@{
+ + +
+ +
proc rWFromFP(fp: File; autoclose: bool): ptr RWops {...}{.importc: "SDL_RWFromFP", cdecl.}
+
+ + + +
+ +
proc rWFromMem(mem: pointer; size: cint): ptr RWops {...}{.importc: "SDL_RWFromMem", cdecl.}
+
+ + + +
+ +
proc rWFromConstMem(mem: pointer; size: cint): ptr RWops {...}{.
+    importc: "SDL_RWFromConstMem", cdecl.}
+
+ + + +
+ +
proc allocRW(): ptr RWops {...}{.importc: "SDL_AllocRW", cdecl.}
+
+ +
@}
+RWFrom functions
+ + +
+ +
proc freeRW(area: ptr RWops) {...}{.importc: "SDL_FreeRW", cdecl.}
+
+ + + +
+ +
proc rWsize(context: ptr RWops): Sint64 {...}{.importc: "SDL_RWsize", cdecl.}
+
+ +
Return the size of the file in this rwops, or -1 if unknown
+ + +
+ +
proc rWseek(context: ptr RWops; offset: Sint64; whence: cint): Sint64 {...}{.
+    importc: "SDL_RWseek", cdecl.}
+
+ +
Seek to \c offset relative to \c whence, one of stdio's whence values:
+  RW_SEEK_SET, RW_SEEK_CUR, RW_SEEK_END
+  
+  \return the final offset in the data stream, or -1 on error.
+ + +
+ +
proc rWtell(context: ptr RWops): Sint64 {...}{.importc: "SDL_RWtell", cdecl.}
+
+ +
Return the current offset in the data stream, or -1 on error.
+ + +
+ +
proc rWread(context: ptr RWops; `ptr`: pointer; size: uint; maxnum: uint): uint {...}{.
+    importc: "SDL_RWread", cdecl.}
+
+ +
Read up to \c maxnum objects each of size \c size from the data
+  stream to the area pointed at by \c ptr.
+  
+  \return the number of objects read, or 0 at error or end of file.
+ + +
+ +
proc rWwrite(context: ptr RWops; `ptr`: pointer; size: uint; num: uint): uint {...}{.
+    importc: "SDL_RWwrite", cdecl.}
+
+ +
Write exactly \c num objects each of size \c size from the area
+  pointed at by \c ptr to data stream.
+  
+  \return the number of objects written, or 0 at error or end of file.
+ + +
+ +
proc rWclose(context: ptr RWops): cint {...}{.importc: "SDL_RWclose", cdecl.}
+
+ +
Close and free an allocated SDL_RWops structure.
+  
+  \return 0 if successful or -1 on write error when flushing data.
+ + +
+ +
proc loadFile_RW(src: ptr RWops; datasize: ptr uint; freesrc: cint): pointer {...}{.
+    importc: "SDL_LoadFile_RW", cdecl.}
+
+ +
Load all the data from an SDL data stream.
+  
+  The data is allocated with a zero byte at the end (null terminated)
+  
+  If \c datasize is not NULL, it is filled with the size of the data read.
+  
+  If \c freesrc is non-zero, the stream will be closed after being read.
+  
+  The data should be freed with SDL_free().
+  
+  \return the data, or NULL if there was an error.
+ + +
+ +
proc loadFile(file: cstring; datasize: ptr uint): pointer {...}{.importc: "SDL_LoadFile",
+    cdecl.}
+
+ +
Load an entire file.
+  
+  The data is allocated with a zero byte at the end (null terminated)
+  
+  If \c datasize is not NULL, it is filled with the size of the data read.
+  
+  If \c freesrc is non-zero, the stream will be closed after being read.
+  
+  The data should be freed with SDL_free().
+  
+  \return the data, or NULL if there was an error.
+ + +
+ +
proc readU8(src: ptr RWops): Uint8 {...}{.importc: "SDL_ReadU8", cdecl.}
+
+ +
\name Read endian functions
+  
+  Read an item of the specified endianness and return in native format.
+@{
+ + +
+ +
proc readLE16(src: ptr RWops): Uint16 {...}{.importc: "SDL_ReadLE16", cdecl.}
+
+ + + +
+ +
proc readBE16(src: ptr RWops): Uint16 {...}{.importc: "SDL_ReadBE16", cdecl.}
+
+ + + +
+ +
proc readLE32(src: ptr RWops): Uint32 {...}{.importc: "SDL_ReadLE32", cdecl.}
+
+ + + +
+ +
proc readBE32(src: ptr RWops): Uint32 {...}{.importc: "SDL_ReadBE32", cdecl.}
+
+ + + +
+ +
proc readLE64(src: ptr RWops): Uint64 {...}{.importc: "SDL_ReadLE64", cdecl.}
+
+ + + +
+ +
proc readBE64(src: ptr RWops): Uint64 {...}{.importc: "SDL_ReadBE64", cdecl.}
+
+ + + +
+ +
proc writeU8(dst: ptr RWops; value: Uint8): uint {...}{.importc: "SDL_WriteU8", cdecl.}
+
+ +
@}
+Read endian functions
+\name Write endian functions
+  
+  Write an item of native format to the specified endianness.
+@{
+ + +
+ +
proc writeLE16(dst: ptr RWops; value: Uint16): uint {...}{.importc: "SDL_WriteLE16", cdecl.}
+
+ + + +
+ +
proc writeBE16(dst: ptr RWops; value: Uint16): uint {...}{.importc: "SDL_WriteBE16", cdecl.}
+
+ + + +
+ +
proc writeLE32(dst: ptr RWops; value: Uint32): uint {...}{.importc: "SDL_WriteLE32", cdecl.}
+
+ + + +
+ +
proc writeBE32(dst: ptr RWops; value: Uint32): uint {...}{.importc: "SDL_WriteBE32", cdecl.}
+
+ + + +
+ +
proc writeLE64(dst: ptr RWops; value: Uint64): uint {...}{.importc: "SDL_WriteLE64", cdecl.}
+
+ + + +
+ +
proc writeBE64(dst: ptr RWops; value: Uint64): uint {...}{.importc: "SDL_WriteBE64", cdecl.}
+
+ + + +
+ +
proc getNumAudioDrivers(): cint {...}{.importc: "SDL_GetNumAudioDrivers", cdecl.}
+
+ +
Function prototypes
+\name Driver discovery functions
+  
+  These functions return the list of built in audio drivers, in the
+  order that they are normally initialized by default.
+@{
+ + +
+ +
proc getAudioDriver(index: cint): cstring {...}{.importc: "SDL_GetAudioDriver", cdecl.}
+
+ + + +
+ +
proc audioInit(driverName: cstring): cint {...}{.importc: "SDL_AudioInit", cdecl.}
+
+ +
@}
+\name Initialization and cleanup
+  
+  \internal These functions are used internally, and should not be used unless
+            you have a specific need to specify the audio driver you want to
+            use.  You should normally use SDL_Init() or SDL_InitSubSystem().
+@{
+ + +
+ +
proc audioQuit() {...}{.importc: "SDL_AudioQuit", cdecl.}
+
+ + + +
+ +
proc getCurrentAudioDriver(): cstring {...}{.importc: "SDL_GetCurrentAudioDriver", cdecl.}
+
+ +
@}
+This function returns the name of the current audio driver, or NULL
+  if no driver has been initialized.
+ + +
+ +
proc openAudio(desired: ptr AudioSpec; obtained: ptr AudioSpec): cint {...}{.
+    importc: "SDL_OpenAudio", cdecl.}
+
+ +
This function opens the audio device with the desired parameters, and
+  returns 0 if successful, placing the actual hardware parameters in the
+  structure pointed to by \c obtained.  If \c obtained is NULL, the audio
+  data passed to the callback function will be guaranteed to be in the
+  requested format, and will be automatically converted to the hardware
+  audio format if necessary.  This function returns -1 if it failed
+  to open the audio device, or couldn't set up the audio thread.
+  
+  When filling in the desired audio spec structure,
+    - \c desired->freq should be the desired audio frequency in samples-per-
+      second.
+    - \c desired->format should be the desired audio format.
+    - \c desired->samples is the desired size of the audio buffer, in
+      samples.  This number should be a power of two, and may be adjusted by
+      the audio driver to a value more suitable for the hardware.  Good values
+      seem to range between 512 and 8096 inclusive, depending on the
+      application and CPU speed.  Smaller values yield faster response time,
+      but can lead to underflow if the application is doing heavy processing
+      and cannot fill the audio buffer in time.  A stereo sample consists of
+      both right and left channels in LR ordering.
+      Note that the number of samples is directly related to time by the
+      following formula:  \code ms = (samples1000)/freq \endcode
+    - \c desired->size is the size in bytes of the audio buffer, and is
+      calculated by SDL_OpenAudio().
+    - \c desired->silence is the value used to set the buffer to silence,
+      and is calculated by SDL_OpenAudio().
+    - \c desired->callback should be set to a function that will be called
+      when the audio device is ready for more data.  It is passed a pointer
+      to the audio buffer, and the length in bytes of the audio buffer.
+      This function usually runs in a separate thread, and so you should
+      protect data structures that it accesses by calling SDL_LockAudio()
+      and SDL_UnlockAudio() in your code. Alternately, you may pass a NULL
+      pointer here, and call SDL_QueueAudio() with some frequency, to queue
+      more audio samples to be played (or for capture devices, call
+      SDL_DequeueAudio() with some frequency, to obtain audio samples).
+    - \c desired->userdata is passed as the first parameter to your callback
+      function. If you passed a NULL callback, this value is ignored.
+  
+  The audio device starts out playing silence when it's opened, and should
+  be enabled for playing by calling \c SDL_PauseAudio(0) when you are ready
+  for your audio callback function to be called.  Since the audio driver
+  may modify the requested size of the audio buffer, you should allocate
+  any local mixing buffers after you open the audio device.
+ + +
+ +
proc getNumAudioDevices(iscapture: cint): cint {...}{.importc: "SDL_GetNumAudioDevices",
+    cdecl.}
+
+ +
Get the number of available devices exposed by the current driver.
+  Only valid after a successfully initializing the audio subsystem.
+  Returns -1 if an explicit list of devices can't be determined; this is
+  not an error. For example, if SDL is set up to talk to a remote audio
+  server, it can't list every one available on the Internet, but it will
+  still allow a specific host to be specified to SDL_OpenAudioDevice().
+  
+  In many common cases, when this function returns a value <= 0, it can still
+  successfully open the default device (NULL for first argument of
+  SDL_OpenAudioDevice()).
+ + +
+ +
proc getAudioDeviceName(index: cint; iscapture: cint): cstring {...}{.
+    importc: "SDL_GetAudioDeviceName", cdecl.}
+
+ +
Get the human-readable name of a specific audio device.
+  Must be a value between 0 and (number of audio devices-1).
+  Only valid after a successfully initializing the audio subsystem.
+  The values returned by this function reflect the latest call to
+  SDL_GetNumAudioDevices(); recall that function to redetect available
+  hardware.
+  
+  The string returned by this function is UTF-8 encoded, read-only, and
+  managed internally. You are not to free it. If you need to keep the
+  string for any length of time, you should make your own copy of it, as it
+  will be invalid next time any of several other SDL functions is called.
+ + +
+ +
proc openAudioDevice(device: cstring; iscapture: cint; desired: ptr AudioSpec;
+                    obtained: ptr AudioSpec; allowedChanges: cint): AudioDeviceID {...}{.
+    importc: "SDL_OpenAudioDevice", cdecl.}
+
+ +
Open a specific audio device. Passing in a device name of NULL requests
+  the most reasonable default (and is equivalent to calling SDL_OpenAudio()).
+  
+  The device name is a UTF-8 string reported by SDL_GetAudioDeviceName(), but
+  some drivers allow arbitrary and driver-specific strings, such as a
+  hostname/IP address for a remote audio server, or a filename in the
+  diskaudio driver.
+  
+  \return 0 on error, a valid device ID that is >= 2 on success.
+  
+  SDL_OpenAudio(), unlike this function, always acts on device ID 1.
+ + +
+ +
proc getAudioStatus(): AudioStatus {...}{.importc: "SDL_GetAudioStatus", cdecl.}
+
+ + + +
+ +
proc getAudioDeviceStatus(dev: AudioDeviceID): AudioStatus {...}{.
+    importc: "SDL_GetAudioDeviceStatus", cdecl.}
+
+ + + +
+ +
proc pauseAudio(pauseOn: cint) {...}{.importc: "SDL_PauseAudio", cdecl.}
+
+ +
@}
+Audio State
+\name Pause audio functions
+  
+  These functions pause and unpause the audio callback processing.
+  They should be called with a parameter of 0 after opening the audio
+  device to start playing sound.  This is so you can safely initialize
+  data for your callback function after opening the audio device.
+  Silence will be written to the audio device during the pause.
+@{
+ + +
+ +
proc pauseAudioDevice(dev: AudioDeviceID; pauseOn: cint) {...}{.
+    importc: "SDL_PauseAudioDevice", cdecl.}
+
+ + + +
+ +
proc loadWAV_RW(src: ptr RWops; freesrc: cint; spec: ptr AudioSpec;
+               audioBuf: ptr ptr Uint8; audioLen: ptr Uint32): ptr AudioSpec {...}{.
+    importc: "SDL_LoadWAV_RW", cdecl.}
+
+ +
@}
+Pause audio functions
+\brief Load the audio data of a WAVE file into memory
+  
+  Loading a WAVE file requires \c src, \c spec, \c audio_buf and \c audio_len
+  to be valid pointers. The entire data portion of the file is then loaded
+  into memory and decoded if necessary.
+  
+  If \c freesrc is non-zero, the data source gets automatically closed and
+  freed before the function returns.
+  
+  Supported are RIFF WAVE files with the formats PCM (8, 16, 24, and 32 bits),
+  IEEE Float (32 bits), Microsoft ADPCM and IMA ADPCM (4 bits), and A-law and
+  µ-law (8 bits). Other formats are currently unsupported and cause an error.
+  
+  If this function succeeds, the pointer returned by it is equal to \c spec
+  and the pointer to the audio data allocated by the function is written to
+  \c audio_buf and its length in bytes to \c audio_len. The \ref SDL_AudioSpec
+  members \c freq, \c channels, and \c format are set to the values of the
+  audio data in the buffer. The \c samples member is set to a sane default and
+  all others are set to zero.
+  
+  It's necessary to use SDL_FreeWAV() to free the audio data returned in
+  \c audio_buf when it is no longer used.
+  
+  Because of the underspecification of the Waveform format, there are many
+  problematic files in the wild that cause issues with strict decoders. To
+  provide compatibility with these files, this decoder is lenient in regards
+  to the truncation of the file, the fact chunk, and the size of the RIFF
+  chunk. The hints SDL_HINT_WAVE_RIFF_CHUNK_SIZE, SDL_HINT_WAVE_TRUNCATION,
+  and SDL_HINT_WAVE_FACT_CHUNK can be used to tune the behavior of the
+  loading process.
+  
+  Any file that is invalid (due to truncation, corruption, or wrong values in
+  the headers), too big, or unsupported causes an error. Additionally, any
+  critical I/O error from the data source will terminate the loading process
+  with an error. The function returns NULL on error and in all cases (with the
+  exception of \c src being NULL), an appropriate error message will be set.
+  
+  It is required that the data source supports seeking.
+  
+  Example:
+  \code
+      SDL_LoadWAV_RW(SDL_RWFromFile("sample.wav", "rb"), 1, ...);
+  \endcode
+  
+  \param src The data source with the WAVE data
+  \param freesrc A integer value that makes the function close the data source if non-zero
+  \param spec A pointer filled with the audio format of the audio data
+  \param audio_buf A pointer filled with the audio data allocated by the function
+  \param audio_len A pointer filled with the length of the audio data buffer in bytes
+  \return NULL on error, or non-NULL on success.
+ + +
+ +
proc freeWAV(audioBuf: ptr Uint8) {...}{.importc: "SDL_FreeWAV", cdecl.}
+
+ +
This function frees data previously allocated with SDL_LoadWAV_RW()
+ + +
+ +
proc buildAudioCVT(cvt: ptr AudioCVT; srcFormat: AudioFormat; srcChannels: Uint8;
+                  srcRate: cint; dstFormat: AudioFormat; dstChannels: Uint8;
+                  dstRate: cint): cint {...}{.importc: "SDL_BuildAudioCVT", cdecl.}
+
+ +
This function takes a source format and rate and a destination format
+  and rate, and initializes the \c cvt structure with information needed
+  by SDL_ConvertAudio() to convert a buffer of audio data from one format
+  to the other. An unsupported format causes an error and -1 will be returned.
+  
+  \return 0 if no conversion is needed, 1 if the audio filter is set up,
+  or -1 on error.
+ + +
+ +
proc convertAudio(cvt: ptr AudioCVT): cint {...}{.importc: "SDL_ConvertAudio", cdecl.}
+
+ +
Once you have initialized the \c cvt structure using SDL_BuildAudioCVT(),
+  created an audio buffer \c cvt->buf, and filled it with \c cvt->len bytes of
+  audio data in the source format, this function will convert it in-place
+  to the desired format.
+  
+  The data conversion may expand the size of the audio data, so the buffer
+  \c cvt->buf should be allocated after the \c cvt structure is initialized by
+  SDL_BuildAudioCVT(), and should be \c cvt->lencvt->len_mult bytes long.
+  
+  \return 0 on success or -1 if \c cvt->buf is NULL.
+ + +
+ +
proc newAudioStream(srcFormat: AudioFormat; srcChannels: Uint8; srcRate: cint;
+                   dstFormat: AudioFormat; dstChannels: Uint8; dstRate: cint): ptr AudioStream {...}{.
+    importc: "SDL_NewAudioStream", cdecl.}
+
+ +
Create a new audio stream
+  
+  \param src_format The format of the source audio
+  \param src_channels The number of channels of the source audio
+  \param src_rate The sampling rate of the source audio
+  \param dst_format The format of the desired audio output
+  \param dst_channels The number of channels of the desired audio output
+  \param dst_rate The sampling rate of the desired audio output
+  \return 0 on success, or -1 on error.
+  
+  \sa SDL_AudioStreamPut
+  \sa SDL_AudioStreamGet
+  \sa SDL_AudioStreamAvailable
+  \sa SDL_AudioStreamFlush
+  \sa SDL_AudioStreamClear
+  \sa SDL_FreeAudioStream
+ + +
+ +
proc audioStreamPut(stream: ptr AudioStream; buf: pointer; len: cint): cint {...}{.
+    importc: "SDL_AudioStreamPut", cdecl.}
+
+ +
Add data to be converted/resampled to the stream
+  
+  \param stream The stream the audio data is being added to
+  \param buf A pointer to the audio data to add
+  \param len The number of bytes to write to the stream
+  \return 0 on success, or -1 on error.
+  
+  \sa SDL_NewAudioStream
+  \sa SDL_AudioStreamGet
+  \sa SDL_AudioStreamAvailable
+  \sa SDL_AudioStreamFlush
+  \sa SDL_AudioStreamClear
+  \sa SDL_FreeAudioStream
+ + +
+ +
proc audioStreamGet(stream: ptr AudioStream; buf: pointer; len: cint): cint {...}{.
+    importc: "SDL_AudioStreamGet", cdecl.}
+
+ +
Get converted/resampled data from the stream
+  
+  \param stream The stream the audio is being requested from
+  \param buf A buffer to fill with audio data
+  \param len The maximum number of bytes to fill
+  \return The number of bytes read from the stream, or -1 on error
+  
+  \sa SDL_NewAudioStream
+  \sa SDL_AudioStreamPut
+  \sa SDL_AudioStreamAvailable
+  \sa SDL_AudioStreamFlush
+  \sa SDL_AudioStreamClear
+  \sa SDL_FreeAudioStream
+ + +
+ +
proc audioStreamAvailable(stream: ptr AudioStream): cint {...}{.
+    importc: "SDL_AudioStreamAvailable", cdecl.}
+
+ +
Get the number of converted/resampled bytes available. The stream may be
+  buffering data behind the scenes until it has enough to resample
+  correctly, so this number might be lower than what you expect, or even
+  be zero. Add more data or flush the stream if you need the data now.
+  
+  \sa SDL_NewAudioStream
+  \sa SDL_AudioStreamPut
+  \sa SDL_AudioStreamGet
+  \sa SDL_AudioStreamFlush
+  \sa SDL_AudioStreamClear
+  \sa SDL_FreeAudioStream
+ + +
+ +
proc audioStreamFlush(stream: ptr AudioStream): cint {...}{.
+    importc: "SDL_AudioStreamFlush", cdecl.}
+
+ +
Tell the stream that you're done sending data, and anything being buffered
+  should be converted/resampled and made available immediately.
+ 
+ It is legal to add more data to a stream after flushing, but there will
+  be audio gaps in the output. Generally this is intended to signal the
+  end of input, so the complete output becomes available.
+  
+  \sa SDL_NewAudioStream
+  \sa SDL_AudioStreamPut
+  \sa SDL_AudioStreamGet
+  \sa SDL_AudioStreamAvailable
+  \sa SDL_AudioStreamClear
+  \sa SDL_FreeAudioStream
+ + +
+ +
proc audioStreamClear(stream: ptr AudioStream) {...}{.importc: "SDL_AudioStreamClear",
+    cdecl.}
+
+ +
Clear any pending data in the stream without converting it
+  
+  \sa SDL_NewAudioStream
+  \sa SDL_AudioStreamPut
+  \sa SDL_AudioStreamGet
+  \sa SDL_AudioStreamAvailable
+  \sa SDL_AudioStreamFlush
+  \sa SDL_FreeAudioStream
+ + +
+ +
proc freeAudioStream(stream: ptr AudioStream) {...}{.importc: "SDL_FreeAudioStream", cdecl.}
+
+ +
Free an audio stream
+  
+  \sa SDL_NewAudioStream
+  \sa SDL_AudioStreamPut
+  \sa SDL_AudioStreamGet
+  \sa SDL_AudioStreamAvailable
+  \sa SDL_AudioStreamFlush
+  \sa SDL_AudioStreamClear
+ + +
+ +
proc mixAudio(dst: ptr Uint8; src: ptr Uint8; len: Uint32; volume: cint) {...}{.
+    importc: "SDL_MixAudio", cdecl.}
+
+ +
This takes two audio buffers of the playing audio format and mixes
+  them, performing addition, volume adjustment, and overflow clipping.
+  The volume ranges from 0 - 128, and should be set to ::SDL_MIX_MAXVOLUME
+  for full audio volume.  Note this does not change hardware volume.
+  This is provided for convenience -- you can mix your own audio data.
+ + +
+ +
proc mixAudioFormat(dst: ptr Uint8; src: ptr Uint8; format: AudioFormat; len: Uint32;
+                   volume: cint) {...}{.importc: "SDL_MixAudioFormat", cdecl.}
+
+ +
This works like SDL_MixAudio(), but you specify the audio format instead of
+  using the format of audio device 1. Thus it can be used when no audio
+  device is open at all.
+ + +
+ +
proc queueAudio(dev: AudioDeviceID; data: pointer; len: Uint32): cint {...}{.
+    importc: "SDL_QueueAudio", cdecl.}
+
+ +
Queue more audio on non-callback devices.
+  
+  (If you are looking to retrieve queued audio from a non-callback capture
+  device, you want SDL_DequeueAudio() instead. This will return -1 to
+  signify an error if you use it with capture devices.)
+  
+  SDL offers two ways to feed audio to the device: you can either supply a
+  callback that SDL triggers with some frequency to obtain more audio
+  (pull method), or you can supply no callback, and then SDL will expect
+  you to supply data at regular intervals (push method) with this function.
+  
+  There are no limits on the amount of data you can queue, short of
+  exhaustion of address space. Queued data will drain to the device as
+  necessary without further intervention from you. If the device needs
+  audio but there is not enough queued, it will play silence to make up
+  the difference. This means you will have skips in your audio playback
+  if you aren't routinely queueing sufficient data.
+  
+  This function copies the supplied data, so you are safe to free it when
+  the function returns. This function is thread-safe, but queueing to the
+  same device from two threads at once does not promise which buffer will
+  be queued first.
+  
+  You may not queue audio on a device that is using an application-supplied
+  callback; doing so returns an error. You have to use the audio callback
+  or queue audio with this function, but not both.
+  
+  You should not call SDL_LockAudio() on the device before queueing; SDL
+  handles locking internally for this function.
+  
+  \param dev The device ID to which we will queue audio.
+  \param data The data to queue to the device for later playback.
+  \param len The number of bytes (not samples!) to which (data) points.
+  \return 0 on success, or -1 on error.
+  
+  \sa SDL_GetQueuedAudioSize
+  \sa SDL_ClearQueuedAudio
+ + +
+ +
proc dequeueAudio(dev: AudioDeviceID; data: pointer; len: Uint32): Uint32 {...}{.
+    importc: "SDL_DequeueAudio", cdecl.}
+
+ +
Dequeue more audio on non-callback devices.
+  
+  (If you are looking to queue audio for output on a non-callback playback
+  device, you want SDL_QueueAudio() instead. This will always return 0
+  if you use it with playback devices.)
+  
+  SDL offers two ways to retrieve audio from a capture device: you can
+  either supply a callback that SDL triggers with some frequency as the
+  device records more audio data, (push method), or you can supply no
+  callback, and then SDL will expect you to retrieve data at regular
+  intervals (pull method) with this function.
+  
+  There are no limits on the amount of data you can queue, short of
+  exhaustion of address space. Data from the device will keep queuing as
+  necessary without further intervention from you. This means you will
+  eventually run out of memory if you aren't routinely dequeueing data.
+  
+  Capture devices will not queue data when paused; if you are expecting
+  to not need captured audio for some length of time, use
+  SDL_PauseAudioDevice() to stop the capture device from queueing more
+  data. This can be useful during, say, level loading times. When
+  unpaused, capture devices will start queueing data from that point,
+  having flushed any capturable data available while paused.
+  
+  This function is thread-safe, but dequeueing from the same device from
+  two threads at once does not promise which thread will dequeued data
+  first.
+  
+  You may not dequeue audio from a device that is using an
+  application-supplied callback; doing so returns an error. You have to use
+  the audio callback, or dequeue audio with this function, but not both.
+  
+  You should not call SDL_LockAudio() on the device before queueing; SDL
+  handles locking internally for this function.
+  
+  \param dev The device ID from which we will dequeue audio.
+  \param data A pointer into where audio data should be copied.
+  \param len The number of bytes (not samples!) to which (data) points.
+  \return number of bytes dequeued, which could be less than requested.
+  
+  \sa SDL_GetQueuedAudioSize
+  \sa SDL_ClearQueuedAudio
+ + +
+ +
proc getQueuedAudioSize(dev: AudioDeviceID): Uint32 {...}{.
+    importc: "SDL_GetQueuedAudioSize", cdecl.}
+
+ +
Get the number of bytes of still-queued audio.
+  
+  For playback device:
+    
+    This is the number of bytes that have been queued for playback with
+    SDL_QueueAudio(), but have not yet been sent to the hardware. This
+    number may shrink at any time, so this only informs of pending data.
+    
+    Once we've sent it to the hardware, this function can not decide the
+    exact byte boundary of what has been played. It's possible that we just
+    gave the hardware several kilobytes right before you called this
+    function, but it hasn't played any of it yet, or maybe half of it, etc.
+  
+  For capture devices:
+    
+    This is the number of bytes that have been captured by the device and
+    are waiting for you to dequeue. This number may grow at any time, so
+    this only informs of the lower-bound of available data.
+  
+  You may not queue audio on a device that is using an application-supplied
+  callback; calling this function on such a device always returns 0.
+  You have to queue audio with SDL_QueueAudio()/SDL_DequeueAudio(), or use
+  the audio callback, but not both.
+  
+  You should not call SDL_LockAudio() on the device before querying; SDL
+  handles locking internally for this function.
+  
+  \param dev The device ID of which we will query queued audio size.
+  \return Number of bytes (not samples!) of queued audio.
+  
+  \sa SDL_QueueAudio
+  \sa SDL_ClearQueuedAudio
+ + +
+ +
proc clearQueuedAudio(dev: AudioDeviceID) {...}{.importc: "SDL_ClearQueuedAudio", cdecl.}
+
+ +
Drop any queued audio data. For playback devices, this is any queued data
+  still waiting to be submitted to the hardware. For capture devices, this
+  is any data that was queued by the device that hasn't yet been dequeued by
+  the application.
+  
+  Immediately after this call, SDL_GetQueuedAudioSize() will return 0. For
+  playback devices, the hardware will start playing silence if more audio
+  isn't queued. Unpaused capture devices will start filling the queue again
+  as soon as they have more data available (which, depending on the state
+  of the hardware and the thread, could be before this function call
+  returns!).
+  
+  This will not prevent playback of queued audio that's already been sent
+  to the hardware, as we can not undo that, so expect there to be some
+  fraction of a second of audio that might still be heard. This can be
+  useful if you want to, say, drop any pending music during a level change
+  in your game.
+  
+  You may not queue audio on a device that is using an application-supplied
+  callback; calling this function on such a device is always a no-op.
+  You have to queue audio with SDL_QueueAudio()/SDL_DequeueAudio(), or use
+  the audio callback, but not both.
+  
+  You should not call SDL_LockAudio() on the device before clearing the
+  queue; SDL handles locking internally for this function.
+  
+  This function always succeeds and thus returns void.
+  
+  \param dev The device ID of which to clear the audio queue.
+  
+  \sa SDL_QueueAudio
+  \sa SDL_GetQueuedAudioSize
+ + +
+ +
proc lockAudio() {...}{.importc: "SDL_LockAudio", cdecl.}
+
+ +
\name Audio lock functions
+  
+  The lock manipulated by these functions protects the callback function.
+  During a SDL_LockAudio()/SDL_UnlockAudio() pair, you can be guaranteed that
+  the callback function is not running.  Do not call these from the callback
+  function or you will cause deadlock.
+@{
+ + +
+ +
proc lockAudioDevice(dev: AudioDeviceID) {...}{.importc: "SDL_LockAudioDevice", cdecl.}
+
+ + + +
+ +
proc unlockAudio() {...}{.importc: "SDL_UnlockAudio", cdecl.}
+
+ + + +
+ +
proc unlockAudioDevice(dev: AudioDeviceID) {...}{.importc: "SDL_UnlockAudioDevice", cdecl.}
+
+ + + +
+ +
proc closeAudio() {...}{.importc: "SDL_CloseAudio", cdecl.}
+
+ +
@}
+Audio lock functions
+This function shuts down audio processing and closes the audio device.
+ + +
+ +
proc closeAudioDevice(dev: AudioDeviceID) {...}{.importc: "SDL_CloseAudioDevice", cdecl.}
+
+ + + +
+ +
proc setClipboardText(text: cstring): cint {...}{.importc: "SDL_SetClipboardText", cdecl.}
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+Function prototypes
+\brief Put UTF-8 text into the clipboard
+ 
+ \sa SDL_GetClipboardText()
+ + +
+ +
proc getClipboardText(): cstring {...}{.importc: "SDL_GetClipboardText", cdecl.}
+
+ +
\brief Get UTF-8 text from the clipboard, which must be freed with SDL_free()
+ 
+ \sa SDL_SetClipboardText()
+ + +
+ +
proc hasClipboardText(): bool {...}{.importc: "SDL_HasClipboardText", cdecl.}
+
+ +
\brief Returns a flag indicating whether the clipboard exists and contains a text string that is non-empty
+ 
+ \sa SDL_GetClipboardText()
+ + +
+ +
proc getCPUCount(): cint {...}{.importc: "SDL_GetCPUCount", cdecl.}
+
+ +
This function returns the number of CPU cores available.
+ + +
+ +
proc getCPUCacheLineSize(): cint {...}{.importc: "SDL_GetCPUCacheLineSize", cdecl.}
+
+ +
This function returns the L1 cache line size of the CPU
+  
+  This is useful for determining multi-threaded structure padding
+  or SIMD prefetch sizes.
+ + +
+ +
proc hasRDTSC(): bool {...}{.importc: "SDL_HasRDTSC", cdecl.}
+
+ +
This function returns true if the CPU has the RDTSC instruction.
+ + +
+ +
proc hasAltiVec(): bool {...}{.importc: "SDL_HasAltiVec", cdecl.}
+
+ +
This function returns true if the CPU has AltiVec features.
+ + +
+ +
proc hasMMX(): bool {...}{.importc: "SDL_HasMMX", cdecl.}
+
+ +
This function returns true if the CPU has MMX features.
+ + +
+ +
proc has3DNow(): bool {...}{.importc: "SDL_Has3DNow", cdecl.}
+
+ +
This function returns true if the CPU has 3DNow! features.
+ + +
+ +
proc hasSSE(): bool {...}{.importc: "SDL_HasSSE", cdecl.}
+
+ +
This function returns true if the CPU has SSE features.
+ + +
+ +
proc hasSSE2(): bool {...}{.importc: "SDL_HasSSE2", cdecl.}
+
+ +
This function returns true if the CPU has SSE2 features.
+ + +
+ +
proc hasSSE3(): bool {...}{.importc: "SDL_HasSSE3", cdecl.}
+
+ +
This function returns true if the CPU has SSE3 features.
+ + +
+ +
proc hasSSE41(): bool {...}{.importc: "SDL_HasSSE41", cdecl.}
+
+ +
This function returns true if the CPU has SSE4.1 features.
+ + +
+ +
proc hasSSE42(): bool {...}{.importc: "SDL_HasSSE42", cdecl.}
+
+ +
This function returns true if the CPU has SSE4.2 features.
+ + +
+ +
proc hasAVX(): bool {...}{.importc: "SDL_HasAVX", cdecl.}
+
+ +
This function returns true if the CPU has AVX features.
+ + +
+ +
proc hasAVX2(): bool {...}{.importc: "SDL_HasAVX2", cdecl.}
+
+ +
This function returns true if the CPU has AVX2 features.
+ + +
+ +
proc hasAVX512F(): bool {...}{.importc: "SDL_HasAVX512F", cdecl.}
+
+ +
This function returns true if the CPU has AVX-512F (foundation) features.
+ + +
+ +
proc hasARMSIMD(): bool {...}{.importc: "SDL_HasARMSIMD", cdecl.}
+
+ +
This function returns true if the CPU has ARM SIMD (ARMv6) features.
+ + +
+ +
proc hasNEON(): bool {...}{.importc: "SDL_HasNEON", cdecl.}
+
+ +
This function returns true if the CPU has NEON (ARM SIMD) features.
+ + +
+ +
proc getSystemRAM(): cint {...}{.importc: "SDL_GetSystemRAM", cdecl.}
+
+ +
This function returns the amount of RAM configured in the system, in MB.
+ + +
+ +
proc sIMDGetAlignment(): uint {...}{.importc: "SDL_SIMDGetAlignment", cdecl.}
+
+ +
\brief Report the alignment this system needs for SIMD allocations.
+ 
+ This will return the minimum number of bytes to which a pointer must be
+  aligned to be compatible with SIMD instructions on the current machine.
+  For example, if the machine supports SSE only, it will return 16, but if
+  it supports AVX-512F, it'll return 64 (etc). This only reports values for
+  instruction sets SDL knows about, so if your SDL build doesn't have
+  SDL_HasAVX512F(), then it might return 16 for the SSE support it sees and
+  not 64 for the AVX-512 instructions that exist but SDL doesn't know about.
+  Plan accordingly.
+ + +
+ +
proc sIMDAlloc(len: uint): pointer {...}{.importc: "SDL_SIMDAlloc", cdecl.}
+
+ +
\brief Allocate memory in a SIMD-friendly way.
+ 
+ This will allocate a block of memory that is suitable for use with SIMD
+  instructions. Specifically, it will be properly aligned and padded for
+  the system's supported vector instructions.
+ 
+ The memory returned will be padded such that it is safe to read or write
+  an incomplete vector at the end of the memory block. This can be useful
+  so you don't have to drop back to a scalar fallback at the end of your
+  SIMD processing loop to deal with the final elements without overflowing
+  the allocated buffer.
+ 
+ You must free this memory with SDL_FreeSIMD(), not free() or SDL_free()
+  or delete[], etc.
+ 
+ Note that SDL will only deal with SIMD instruction sets it is aware of;
+  for example, SDL 2.0.8 knows that SSE wants 16-byte vectors
+  (SDL_HasSSE()), and AVX2 wants 32 bytes (SDL_HasAVX2()), but doesn't
+  know that AVX-512 wants 64. To be clear: if you can't decide to use an
+  instruction set with an SDL_Has() function, don't use that instruction
+  set with memory allocated through here.
+ 
+ SDL_AllocSIMD(0) will return a non-NULL pointer, assuming the system isn't
+  out of memory.
+  
+  \param len The length, in bytes, of the block to allocated. The actual
+             allocated block might be larger due to padding, etc.
+ \return Pointer to newly-allocated block, NULL if out of memory.
+ 
+ \sa SDL_SIMDAlignment
+ \sa SDL_SIMDFree
+ + +
+ +
proc sIMDFree(`ptr`: pointer) {...}{.importc: "SDL_SIMDFree", cdecl.}
+
+ +
\brief Deallocate memory obtained from SDL_SIMDAlloc
+ 
+ It is not valid to use this function on a pointer from anything but
+  SDL_SIMDAlloc(). It can't be used on pointers from malloc, realloc,
+  SDL_malloc, memalign, new[], etc.
+ 
+ However, SDL_SIMDFree(NULL) is a legal no-op.
+ 
+ \sa SDL_SIMDAlloc
+ + +
+ +
proc getPixelFormatName(format: Uint32): cstring {...}{.
+    importc: "SDL_GetPixelFormatName", cdecl.}
+
+ +
\brief Get the human readable name of a pixel format
+ + +
+ +
proc pixelFormatEnumToMasks(format: Uint32; bpp: ptr cint; Rmask: ptr Uint32;
+                           Gmask: ptr Uint32; Bmask: ptr Uint32; Amask: ptr Uint32): bool {...}{.
+    importc: "SDL_PixelFormatEnumToMasks", cdecl.}
+
+ +
\brief Convert one of the enumerated pixel formats to a bpp and RGBA masks.
+  
+  \return SDL_TRUE, or SDL_FALSE if the conversion wasn't possible.
+  
+  \sa SDL_MasksToPixelFormatEnum()
+ + +
+ +
proc masksToPixelFormatEnum(bpp: cint; Rmask: Uint32; Gmask: Uint32; Bmask: Uint32;
+                           Amask: Uint32): Uint32 {...}{.
+    importc: "SDL_MasksToPixelFormatEnum", cdecl.}
+
+ +
\brief Convert a bpp and RGBA masks to an enumerated pixel format.
+  
+  \return The pixel format, or ::SDL_PIXELFORMAT_UNKNOWN if the conversion
+          wasn't possible.
+  
+  \sa SDL_PixelFormatEnumToMasks()
+ + +
+ +
proc allocFormat(pixelFormat: Uint32): ptr PixelFormat {...}{.importc: "SDL_AllocFormat",
+    cdecl.}
+
+ +
\brief Create an SDL_PixelFormat structure from a pixel format enum.
+ + +
+ +
proc freeFormat(format: ptr PixelFormat) {...}{.importc: "SDL_FreeFormat", cdecl.}
+
+ +
\brief Free an SDL_PixelFormat structure.
+ + +
+ +
proc allocPalette(ncolors: cint): ptr Palette {...}{.importc: "SDL_AllocPalette", cdecl.}
+
+ +
\brief Create a palette structure with the specified number of color
+         entries.
+  
+  \return A new palette, or NULL if there wasn't enough memory.
+  
+  \note The palette entries are initialized to white.
+  
+  \sa SDL_FreePalette()
+ + +
+ +
proc setPixelFormatPalette(format: ptr PixelFormat; palette: ptr Palette): cint {...}{.
+    importc: "SDL_SetPixelFormatPalette", cdecl.}
+
+ +
\brief Set the palette for a pixel format structure.
+ + +
+ +
proc setPaletteColors(palette: ptr Palette; colors: ptr Color; firstcolor: cint;
+                     ncolors: cint): cint {...}{.importc: "SDL_SetPaletteColors", cdecl.}
+
+ +
\brief Set a range of colors in a palette.
+  
+  \param palette    The palette to modify.
+  \param colors     An array of colors to copy into the palette.
+  \param firstcolor The index of the first palette entry to modify.
+  \param ncolors    The number of entries to modify.
+  
+  \return 0 on success, or -1 if not all of the colors could be set.
+ + +
+ +
proc freePalette(palette: ptr Palette) {...}{.importc: "SDL_FreePalette", cdecl.}
+
+ +
\brief Free a palette created with SDL_AllocPalette().
+  
+  \sa SDL_AllocPalette()
+ + +
+ +
proc mapRGB(format: ptr PixelFormat; r: Uint8; g: Uint8; b: Uint8): Uint32 {...}{.
+    importc: "SDL_MapRGB", cdecl.}
+
+ +
\brief Maps an RGB triple to an opaque pixel value for a given pixel format.
+  
+  \sa SDL_MapRGBA
+ + +
+ +
proc mapRGBA(format: ptr PixelFormat; r: Uint8; g: Uint8; b: Uint8; a: Uint8): Uint32 {...}{.
+    importc: "SDL_MapRGBA", cdecl.}
+
+ +
\brief Maps an RGBA quadruple to a pixel value for a given pixel format.
+  
+  \sa SDL_MapRGB
+ + +
+ +
proc getRGB(pixel: Uint32; format: ptr PixelFormat; r: ptr Uint8; g: ptr Uint8; b: ptr Uint8) {...}{.
+    importc: "SDL_GetRGB", cdecl.}
+
+ +
\brief Get the RGB components from a pixel of the specified format.
+  
+  \sa SDL_GetRGBA
+ + +
+ +
proc getRGBA(pixel: Uint32; format: ptr PixelFormat; r: ptr Uint8; g: ptr Uint8;
+            b: ptr Uint8; a: ptr Uint8) {...}{.importc: "SDL_GetRGBA", cdecl.}
+
+ +
\brief Get the RGBA components from a pixel of the specified format.
+  
+  \sa SDL_GetRGB
+ + +
+ +
proc calculateGammaRamp(gamma: cfloat; ramp: ptr Uint16) {...}{.
+    importc: "SDL_CalculateGammaRamp", cdecl.}
+
+ +
\brief Calculate a 256 entry gamma ramp for a gamma value.
+ + +
+ +
proc hasIntersection(A: ptr Rect; B: ptr Rect): bool {...}{.importc: "SDL_HasIntersection",
+    cdecl.}
+
+ +
\brief Determine whether two rectangles intersect.
+  
+  \return SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
+ + +
+ +
proc intersectRect(A: ptr Rect; B: ptr Rect; result: ptr Rect): bool {...}{.
+    importc: "SDL_IntersectRect", cdecl.}
+
+ +
\brief Calculate the intersection of two rectangles.
+  
+  \return SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
+ + +
+ +
proc unionRect(A: ptr Rect; B: ptr Rect; result: ptr Rect) {...}{.importc: "SDL_UnionRect", cdecl.}
+
+ +
\brief Calculate the union of two rectangles.
+ + +
+ +
proc enclosePoints(points: ptr Point; count: cint; clip: ptr Rect; result: ptr Rect): bool {...}{.
+    importc: "SDL_EnclosePoints", cdecl.}
+
+ +
\brief Calculate a minimal rectangle enclosing a set of points
+  
+  \return SDL_TRUE if any points were within the clipping rect
+ + +
+ +
proc intersectRectAndLine(rect: ptr Rect; X1: ptr cint; Y1: ptr cint; X2: ptr cint;
+                         Y2: ptr cint): bool {...}{.importc: "SDL_IntersectRectAndLine",
+    cdecl.}
+
+ +
\brief Calculate the intersection of a rectangle and line segment.
+  
+  \return SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
+ + +
+ +
proc composeCustomBlendMode(srcColorFactor: BlendFactor;
+                           dstColorFactor: BlendFactor;
+                           colorOperation: BlendOperation;
+                           srcAlphaFactor: BlendFactor;
+                           dstAlphaFactor: BlendFactor;
+                           alphaOperation: BlendOperation): BlendMode {...}{.
+    importc: "SDL_ComposeCustomBlendMode", cdecl.}
+
+ +
\brief Create a custom blend mode, which may or may not be supported by a given renderer
+  
+  \param srcColorFactor source color factor
+  \param dstColorFactor destination color factor
+  \param colorOperation color operation
+  \param srcAlphaFactor source alpha factor
+  \param dstAlphaFactor destination alpha factor
+  \param alphaOperation alpha operation
+  
+  The result of the blend mode operation will be:
+      dstRGB = dstRGB dstColorFactor colorOperation srcRGB srcColorFactor
+  and
+      dstA = dstA dstAlphaFactor alphaOperation srcA srcAlphaFactor
+ + +
+ +
proc createRGBSurface(flags: Uint32; width: cint; height: cint; depth: cint;
+                     Rmask: Uint32; Gmask: Uint32; Bmask: Uint32; Amask: Uint32): ptr Surface {...}{.
+    importc: "SDL_CreateRGBSurface", cdecl.}
+
+ +
Allocate and free an RGB surface.
+  
+  If the depth is 4 or 8 bits, an empty palette is allocated for the surface.
+  If the depth is greater than 8 bits, the pixel format is set using the
+  flags '[RGB]mask'.
+  
+  If the function runs out of memory, it will return NULL.
+  
+  \param flags The \c flags are obsolete and should be set to 0.
+  \param width The width in pixels of the surface to create.
+  \param height The height in pixels of the surface to create.
+  \param depth The depth in bits of the surface to create.
+  \param Rmask The red mask of the surface to create.
+  \param Gmask The green mask of the surface to create.
+  \param Bmask The blue mask of the surface to create.
+  \param Amask The alpha mask of the surface to create.
+ + +
+ +
proc createRGBSurfaceWithFormat(flags: Uint32; width: cint; height: cint; depth: cint;
+                               format: Uint32): ptr Surface {...}{.
+    importc: "SDL_CreateRGBSurfaceWithFormat", cdecl.}
+
+ +
!!! FIXME for 2.1: why does this ask for depth? Format provides that.
+ + +
+ +
proc createRGBSurfaceFrom(pixels: pointer; width: cint; height: cint; depth: cint;
+                         pitch: cint; Rmask: Uint32; Gmask: Uint32; Bmask: Uint32;
+                         Amask: Uint32): ptr Surface {...}{.
+    importc: "SDL_CreateRGBSurfaceFrom", cdecl.}
+
+ + + +
+ +
proc createRGBSurfaceWithFormatFrom(pixels: pointer; width: cint; height: cint;
+                                   depth: cint; pitch: cint; format: Uint32): ptr Surface {...}{.
+    importc: "SDL_CreateRGBSurfaceWithFormatFrom", cdecl.}
+
+ + + +
+ +
proc freeSurface(surface: ptr Surface) {...}{.importc: "SDL_FreeSurface", cdecl.}
+
+ + + +
+ +
proc setSurfacePalette(surface: ptr Surface; palette: ptr Palette): cint {...}{.
+    importc: "SDL_SetSurfacePalette", cdecl.}
+
+ +
\brief Set the palette used by a surface.
+  
+  \return 0, or -1 if the surface format doesn't use a palette.
+  
+  \note A single palette can be shared with many surfaces.
+ + +
+ +
proc lockSurface(surface: ptr Surface): cint {...}{.importc: "SDL_LockSurface", cdecl.}
+
+ +
\brief Sets up a surface for directly accessing the pixels.
+  
+  Between calls to SDL_LockSurface() / SDL_UnlockSurface(), you can write
+  to and read from \c surface->pixels, using the pixel format stored in
+  \c surface->format.  Once you are done accessing the surface, you should
+  use SDL_UnlockSurface() to release it.
+  
+  Not all surfaces require locking.  If SDL_MUSTLOCK(surface) evaluates
+  to 0, then you can read and write to the surface at any time, and the
+  pixel format of the surface will not change.
+  
+  No operating system or library calls should be made between lock/unlock
+  pairs, as critical system locks may be held during this time.
+  
+  SDL_LockSurface() returns 0, or -1 if the surface couldn't be locked.
+  
+  \sa SDL_UnlockSurface()
+ + +
+ +
proc unlockSurface(surface: ptr Surface) {...}{.importc: "SDL_UnlockSurface", cdecl.}
+
+ +
\sa SDL_LockSurface()
+ + +
+ +
proc loadBMP_RW(src: ptr RWops; freesrc: cint): ptr Surface {...}{.importc: "SDL_LoadBMP_RW",
+    cdecl.}
+
+ +
Load a surface from a seekable SDL data stream (memory or file).
+  
+  If \c freesrc is non-zero, the stream will be closed after being read.
+  
+  The new surface should be freed with SDL_FreeSurface().
+  
+  \return the new surface, or NULL if there was an error.
+ + +
+ +
proc saveBMP_RW(surface: ptr Surface; dst: ptr RWops; freedst: cint): cint {...}{.
+    importc: "SDL_SaveBMP_RW", cdecl.}
+
+ +
Save a surface to a seekable SDL data stream (memory or file).
+  
+  Surfaces with a 24-bit, 32-bit and paletted 8-bit format get saved in the
+  BMP directly. Other RGB formats with 8-bit or higher get converted to a
+  24-bit surface or, if they have an alpha mask or a colorkey, to a 32-bit
+  surface before they are saved. YUV and paletted 1-bit and 4-bit formats are
+  not supported.
+  
+  If \c freedst is non-zero, the stream will be closed after being written.
+  
+  \return 0 if successful or -1 if there was an error.
+ + +
+ +
proc setSurfaceRLE(surface: ptr Surface; flag: cint): cint {...}{.
+    importc: "SDL_SetSurfaceRLE", cdecl.}
+
+ +
\brief Sets the RLE acceleration hint for a surface.
+  
+  \return 0 on success, or -1 if the surface is not valid
+  
+  \note If RLE is enabled, colorkey and alpha blending blits are much faster,
+        but the surface must be locked before directly accessing the pixels.
+ + +
+ +
proc setColorKey(surface: ptr Surface; flag: cint; key: Uint32): cint {...}{.
+    importc: "SDL_SetColorKey", cdecl.}
+
+ +
\brief Sets the color key (transparent pixel) in a blittable surface.
+  
+  \param surface The surface to update
+  \param flag Non-zero to enable colorkey and 0 to disable colorkey
+  \param key The transparent pixel in the native surface format
+  
+  \return 0 on success, or -1 if the surface is not valid
+  
+  You can pass SDL_RLEACCEL to enable RLE accelerated blits.
+ + +
+ +
proc hasColorKey(surface: ptr Surface): bool {...}{.importc: "SDL_HasColorKey", cdecl.}
+
+ +
\brief Returns whether the surface has a color key
+  
+  \return SDL_TRUE if the surface has a color key, or SDL_FALSE if the surface is NULL or has no color key
+ + +
+ +
proc getColorKey(surface: ptr Surface; key: ptr Uint32): cint {...}{.
+    importc: "SDL_GetColorKey", cdecl.}
+
+ +
\brief Gets the color key (transparent pixel) in a blittable surface.
+  
+  \param surface The surface to update
+  \param key A pointer filled in with the transparent pixel in the native
+             surface format
+  
+  \return 0 on success, or -1 if the surface is not valid or colorkey is not
+          enabled.
+ + +
+ +
proc setSurfaceColorMod(surface: ptr Surface; r: Uint8; g: Uint8; b: Uint8): cint {...}{.
+    importc: "SDL_SetSurfaceColorMod", cdecl.}
+
+ +
\brief Set an additional color value used in blit operations.
+  
+  \param surface The surface to update.
+  \param r The red color value multiplied into blit operations.
+  \param g The green color value multiplied into blit operations.
+  \param b The blue color value multiplied into blit operations.
+  
+  \return 0 on success, or -1 if the surface is not valid.
+  
+  \sa SDL_GetSurfaceColorMod()
+ + +
+ +
proc getSurfaceColorMod(surface: ptr Surface; r: ptr Uint8; g: ptr Uint8; b: ptr Uint8): cint {...}{.
+    importc: "SDL_GetSurfaceColorMod", cdecl.}
+
+ +
\brief Get the additional color value used in blit operations.
+  
+  \param surface The surface to query.
+  \param r A pointer filled in with the current red color value.
+  \param g A pointer filled in with the current green color value.
+  \param b A pointer filled in with the current blue color value.
+  
+  \return 0 on success, or -1 if the surface is not valid.
+  
+  \sa SDL_SetSurfaceColorMod()
+ + +
+ +
proc setSurfaceAlphaMod(surface: ptr Surface; alpha: Uint8): cint {...}{.
+    importc: "SDL_SetSurfaceAlphaMod", cdecl.}
+
+ +
\brief Set an additional alpha value used in blit operations.
+  
+  \param surface The surface to update.
+  \param alpha The alpha value multiplied into blit operations.
+  
+  \return 0 on success, or -1 if the surface is not valid.
+  
+  \sa SDL_GetSurfaceAlphaMod()
+ + +
+ +
proc getSurfaceAlphaMod(surface: ptr Surface; alpha: ptr Uint8): cint {...}{.
+    importc: "SDL_GetSurfaceAlphaMod", cdecl.}
+
+ +
\brief Get the additional alpha value used in blit operations.
+  
+  \param surface The surface to query.
+  \param alpha A pointer filled in with the current alpha value.
+  
+  \return 0 on success, or -1 if the surface is not valid.
+  
+  \sa SDL_SetSurfaceAlphaMod()
+ + +
+ +
proc setSurfaceBlendMode(surface: ptr Surface; blendMode: BlendMode): cint {...}{.
+    importc: "SDL_SetSurfaceBlendMode", cdecl.}
+
+ +
\brief Set the blend mode used for blit operations.
+  
+  \param surface The surface to update.
+  \param blendMode ::SDL_BlendMode to use for blit blending.
+  
+  \return 0 on success, or -1 if the parameters are not valid.
+  
+  \sa SDL_GetSurfaceBlendMode()
+ + +
+ +
proc getSurfaceBlendMode(surface: ptr Surface; blendMode: ptr BlendMode): cint {...}{.
+    importc: "SDL_GetSurfaceBlendMode", cdecl.}
+
+ +
\brief Get the blend mode used for blit operations.
+  
+  \param surface   The surface to query.
+  \param blendMode A pointer filled in with the current blend mode.
+  
+  \return 0 on success, or -1 if the surface is not valid.
+  
+  \sa SDL_SetSurfaceBlendMode()
+ + +
+ +
proc setClipRect(surface: ptr Surface; rect: ptr Rect): bool {...}{.
+    importc: "SDL_SetClipRect", cdecl.}
+
+ +
Sets the clipping rectangle for the destination surface in a blit.
+  
+  If the clip rectangle is NULL, clipping will be disabled.
+  
+  If the clip rectangle doesn't intersect the surface, the function will
+  return SDL_FALSE and blits will be completely clipped.  Otherwise the
+  function returns SDL_TRUE and blits to the surface will be clipped to
+  the intersection of the surface area and the clipping rectangle.
+  
+  Note that blits are automatically clipped to the edges of the source
+  and destination surfaces.
+ + +
+ +
proc getClipRect(surface: ptr Surface; rect: ptr Rect) {...}{.importc: "SDL_GetClipRect",
+    cdecl.}
+
+ +
Gets the clipping rectangle for the destination surface in a blit.
+  
+  \c rect must be a pointer to a valid rectangle which will be filled
+  with the correct values.
+ + +
+ +
proc duplicateSurface(surface: ptr Surface): ptr Surface {...}{.
+    importc: "SDL_DuplicateSurface", cdecl.}
+
+ +
Creates a new surface identical to the existing surface
+ + +
+ +
proc convertSurface(src: ptr Surface; fmt: ptr PixelFormat; flags: Uint32): ptr Surface {...}{.
+    importc: "SDL_ConvertSurface", cdecl.}
+
+ +
Creates a new surface of the specified format, and then copies and maps
+  the given surface to it so the blit of the converted surface will be as
+  fast as possible.  If this function fails, it returns NULL.
+  
+  The \c flags parameter is passed to SDL_CreateRGBSurface() and has those
+  semantics.  You can also pass ::SDL_RLEACCEL in the flags parameter and
+  SDL will try to RLE accelerate colorkey and alpha blits in the resulting
+  surface.
+ + +
+ +
proc convertSurfaceFormat(src: ptr Surface; pixelFormat: Uint32; flags: Uint32): ptr Surface {...}{.
+    importc: "SDL_ConvertSurfaceFormat", cdecl.}
+
+ + + +
+ +
proc convertPixels(width: cint; height: cint; srcFormat: Uint32; src: pointer;
+                  srcPitch: cint; dstFormat: Uint32; dst: pointer; dstPitch: cint): cint {...}{.
+    importc: "SDL_ConvertPixels", cdecl.}
+
+ +
\brief Copy a block of pixels of one format to another format
+  
+  \return 0 on success, or -1 if there was an error
+ + +
+ +
proc fillRect(dst: ptr Surface; rect: ptr Rect; color: Uint32): cint {...}{.
+    importc: "SDL_FillRect", cdecl.}
+
+ +
Performs a fast fill of the given rectangle with \c color.
+  
+  If \c rect is NULL, the whole surface will be filled with \c color.
+  
+  The color should be a pixel of the format used by the surface, and
+  can be generated by the SDL_MapRGB() function.
+  
+  \return 0 on success, or -1 on error.
+ + +
+ +
proc fillRects(dst: ptr Surface; rects: ptr Rect; count: cint; color: Uint32): cint {...}{.
+    importc: "SDL_FillRects", cdecl.}
+
+ + + +
+ +
proc upperBlit(src: ptr Surface; srcrect: ptr Rect; dst: ptr Surface; dstrect: ptr Rect): cint {...}{.
+    importc: "SDL_UpperBlit", cdecl.}
+
+ +
This is the public blit function, SDL_BlitSurface(), and it performs
+  rectangle validation and clipping before passing it to SDL_LowerBlit()
+ + +
+ +
proc lowerBlit(src: ptr Surface; srcrect: ptr Rect; dst: ptr Surface; dstrect: ptr Rect): cint {...}{.
+    importc: "SDL_LowerBlit", cdecl.}
+
+ +
This is a semi-private blit function and it performs low-level surface
+  blitting only.
+ + +
+ +
proc softStretch(src: ptr Surface; srcrect: ptr Rect; dst: ptr Surface; dstrect: ptr Rect): cint {...}{.
+    importc: "SDL_SoftStretch", cdecl.}
+
+ +
\brief Perform a fast, low quality, stretch blit between two surfaces of the
+         same pixel format.
+  
+  \note This function uses a static buffer, and is not thread-safe.
+ + +
+ +
proc upperBlitScaled(src: ptr Surface; srcrect: ptr Rect; dst: ptr Surface;
+                    dstrect: ptr Rect): cint {...}{.importc: "SDL_UpperBlitScaled", cdecl.}
+
+ +
This is the public scaled blit function, SDL_BlitScaled(), and it performs
+  rectangle validation and clipping before passing it to SDL_LowerBlitScaled()
+ + +
+ +
proc lowerBlitScaled(src: ptr Surface; srcrect: ptr Rect; dst: ptr Surface;
+                    dstrect: ptr Rect): cint {...}{.importc: "SDL_LowerBlitScaled", cdecl.}
+
+ +
This is a semi-private blit function and it performs low-level surface
+  scaled blitting only.
+ + +
+ +
proc setYUVConversionMode(mode: YUV_CONVERSION_MODE) {...}{.
+    importc: "SDL_SetYUVConversionMode", cdecl.}
+
+ +
\brief Set the YUV conversion mode
+ + +
+ +
proc getYUVConversionMode(): YUV_CONVERSION_MODE {...}{.
+    importc: "SDL_GetYUVConversionMode", cdecl.}
+
+ +
\brief Get the YUV conversion mode
+ + +
+ +
proc getYUVConversionModeForResolution(width: cint; height: cint): YUV_CONVERSION_MODE {...}{.
+    importc: "SDL_GetYUVConversionModeForResolution", cdecl.}
+
+ +
\brief Get the YUV conversion mode, returning the correct mode for the resolution when the current conversion mode is SDL_YUV_CONVERSION_AUTOMATIC
+ + +
+ +
proc getNumVideoDrivers(): cint {...}{.importc: "SDL_GetNumVideoDrivers", cdecl.}
+
+ +
Function prototypes
+\brief Get the number of video drivers compiled into SDL
+  
+  \sa SDL_GetVideoDriver()
+ + +
+ +
proc getVideoDriver(index: cint): cstring {...}{.importc: "SDL_GetVideoDriver", cdecl.}
+
+ +
\brief Get the name of a built in video driver.
+  
+  \note The video drivers are presented in the order in which they are
+        normally checked during initialization.
+  
+  \sa SDL_GetNumVideoDrivers()
+ + +
+ +
proc videoInit(driverName: cstring): cint {...}{.importc: "SDL_VideoInit", cdecl.}
+
+ +
\brief Initialize the video subsystem, optionally specifying a video driver.
+  
+  \param driver_name Initialize a specific driver by name, or NULL for the
+                     default video driver.
+  
+  \return 0 on success, -1 on error
+  
+  This function initializes the video subsystem; setting up a connection
+  to the window manager, etc, and determines the available display modes
+  and pixel formats, but does not initialize a window or graphics mode.
+  
+  \sa SDL_VideoQuit()
+ + +
+ +
proc videoQuit() {...}{.importc: "SDL_VideoQuit", cdecl.}
+
+ +
\brief Shuts down the video subsystem.
+  
+  This function closes all windows, and restores the original video mode.
+  
+  \sa SDL_VideoInit()
+ + +
+ +
proc getCurrentVideoDriver(): cstring {...}{.importc: "SDL_GetCurrentVideoDriver", cdecl.}
+
+ +
\brief Returns the name of the currently initialized video driver.
+  
+  \return The name of the current video driver or NULL if no driver
+          has been initialized
+  
+  \sa SDL_GetNumVideoDrivers()
+  \sa SDL_GetVideoDriver()
+ + +
+ +
proc getNumVideoDisplays(): cint {...}{.importc: "SDL_GetNumVideoDisplays", cdecl.}
+
+ +
\brief Returns the number of available video displays.
+  
+  \sa SDL_GetDisplayBounds()
+ + +
+ +
proc getDisplayName(displayIndex: cint): cstring {...}{.importc: "SDL_GetDisplayName",
+    cdecl.}
+
+ +
\brief Get the name of a display in UTF-8 encoding
+  
+  \return The name of a display, or NULL for an invalid display index.
+  
+  \sa SDL_GetNumVideoDisplays()
+ + +
+ +
proc getDisplayBounds(displayIndex: cint; rect: ptr Rect): cint {...}{.
+    importc: "SDL_GetDisplayBounds", cdecl.}
+
+ +
\brief Get the desktop area represented by a display, with the primary
+         display located at 0,0
+  
+  \return 0 on success, or -1 if the index is out of range.
+  
+  \sa SDL_GetNumVideoDisplays()
+ + +
+ +
proc getDisplayUsableBounds(displayIndex: cint; rect: ptr Rect): cint {...}{.
+    importc: "SDL_GetDisplayUsableBounds", cdecl.}
+
+ +
\brief Get the usable desktop area represented by a display, with the
+         primary display located at 0,0
+  
+  This is the same area as SDL_GetDisplayBounds() reports, but with portions
+  reserved by the system removed. For example, on Mac OS X, this subtracts
+  the area occupied by the menu bar and dock.
+  
+  Setting a window to be fullscreen generally bypasses these unusable areas,
+  so these are good guidelines for the maximum space available to a
+  non-fullscreen window.
+  
+  \return 0 on success, or -1 if the index is out of range.
+  
+  \sa SDL_GetDisplayBounds()
+  \sa SDL_GetNumVideoDisplays()
+ + +
+ +
proc getDisplayDPI(displayIndex: cint; ddpi: ptr cfloat; hdpi: ptr cfloat;
+                  vdpi: ptr cfloat): cint {...}{.importc: "SDL_GetDisplayDPI", cdecl.}
+
+ +
\brief Get the dots/pixels-per-inch for a display
+  
+  \note Diagonal, horizontal and vertical DPI can all be optionally
+        returned if the parameter is non-NULL.
+  
+  \return 0 on success, or -1 if no DPI information is available or the index is out of range.
+  
+  \sa SDL_GetNumVideoDisplays()
+ + +
+ +
proc getDisplayOrientation(displayIndex: cint): DisplayOrientation {...}{.
+    importc: "SDL_GetDisplayOrientation", cdecl.}
+
+ +
\brief Get the orientation of a display
+  
+  \return The orientation of the display, or SDL_ORIENTATION_UNKNOWN if it isn't available.
+  
+  \sa SDL_GetNumVideoDisplays()
+ + +
+ +
proc getNumDisplayModes(displayIndex: cint): cint {...}{.
+    importc: "SDL_GetNumDisplayModes", cdecl.}
+
+ +
\brief Returns the number of available display modes.
+  
+  \sa SDL_GetDisplayMode()
+ + +
+ +
proc getDisplayMode(displayIndex: cint; modeIndex: cint; mode: ptr DisplayMode): cint {...}{.
+    importc: "SDL_GetDisplayMode", cdecl.}
+
+ +
\brief Fill in information about a specific display mode.
+  
+  \note The display modes are sorted in this priority:
+        \li bits per pixel -> more colors to fewer colors
+        \li width -> largest to smallest
+        \li height -> largest to smallest
+        \li refresh rate -> highest to lowest
+  
+  \sa SDL_GetNumDisplayModes()
+ + +
+ +
proc getDesktopDisplayMode(displayIndex: cint; mode: ptr DisplayMode): cint {...}{.
+    importc: "SDL_GetDesktopDisplayMode", cdecl.}
+
+ +
\brief Fill in information about the desktop display mode.
+ + +
+ +
proc getCurrentDisplayMode(displayIndex: cint; mode: ptr DisplayMode): cint {...}{.
+    importc: "SDL_GetCurrentDisplayMode", cdecl.}
+
+ +
\brief Fill in information about the current display mode.
+ + +
+ +
proc getClosestDisplayMode(displayIndex: cint; mode: ptr DisplayMode;
+                          closest: ptr DisplayMode): ptr DisplayMode {...}{.
+    importc: "SDL_GetClosestDisplayMode", cdecl.}
+
+ +
\brief Get the closest match to the requested display mode.
+  
+  \param displayIndex The index of display from which mode should be queried.
+  \param mode The desired display mode
+  \param closest A pointer to a display mode to be filled in with the closest
+                 match of the available display modes.
+  
+  \return The passed in value \c closest, or NULL if no matching video mode
+          was available.
+  
+  The available display modes are scanned, and \c closest is filled in with the
+  closest mode matching the requested mode and returned.  The mode format and
+  refresh_rate default to the desktop mode if they are 0.  The modes are
+  scanned with size being first priority, format being second priority, and
+  finally checking the refresh_rate.  If all the available modes are too
+  small, then NULL is returned.
+  
+  \sa SDL_GetNumDisplayModes()
+  \sa SDL_GetDisplayMode()
+ + +
+ +
proc getWindowDisplayIndex(window: ptr Window): cint {...}{.
+    importc: "SDL_GetWindowDisplayIndex", cdecl.}
+
+ +
\brief Get the display index associated with a window.
+  
+  \return the display index of the display containing the center of the
+          window, or -1 on error.
+ + +
+ +
proc setWindowDisplayMode(window: ptr Window; mode: ptr DisplayMode): cint {...}{.
+    importc: "SDL_SetWindowDisplayMode", cdecl.}
+
+ +
\brief Set the display mode used when a fullscreen window is visible.
+  
+  By default the window's dimensions and the desktop format and refresh rate
+  are used.
+  
+  \param window The window for which the display mode should be set.
+  \param mode The mode to use, or NULL for the default mode.
+  
+  \return 0 on success, or -1 if setting the display mode failed.
+  
+  \sa SDL_GetWindowDisplayMode()
+  \sa SDL_SetWindowFullscreen()
+ + +
+ +
proc getWindowDisplayMode(window: ptr Window; mode: ptr DisplayMode): cint {...}{.
+    importc: "SDL_GetWindowDisplayMode", cdecl.}
+
+ +
\brief Fill in information about the display mode used when a fullscreen
+         window is visible.
+  
+  \sa SDL_SetWindowDisplayMode()
+  \sa SDL_SetWindowFullscreen()
+ + +
+ +
proc getWindowPixelFormat(window: ptr Window): Uint32 {...}{.
+    importc: "SDL_GetWindowPixelFormat", cdecl.}
+
+ +
\brief Get the pixel format associated with the window.
+ + +
+ +
proc createWindow(title: cstring; x: cint; y: cint; w: cint; h: cint; flags: Uint32): ptr Window {...}{.
+    importc: "SDL_CreateWindow", cdecl.}
+
+ +
\brief Create a window with the specified position, dimensions, and flags.
+  
+  \param title The title of the window, in UTF-8 encoding.
+  \param x     The x position of the window, ::SDL_WINDOWPOS_CENTERED, or
+               ::SDL_WINDOWPOS_UNDEFINED.
+  \param y     The y position of the window, ::SDL_WINDOWPOS_CENTERED, or
+               ::SDL_WINDOWPOS_UNDEFINED.
+  \param w     The width of the window, in screen coordinates.
+  \param h     The height of the window, in screen coordinates.
+  \param flags The flags for the window, a mask of any of the following:
+               ::SDL_WINDOW_FULLSCREEN,    ::SDL_WINDOW_OPENGL,
+               ::SDL_WINDOW_HIDDEN,        ::SDL_WINDOW_BORDERLESS,
+               ::SDL_WINDOW_RESIZABLE,     ::SDL_WINDOW_MAXIMIZED,
+               ::SDL_WINDOW_MINIMIZED,     ::SDL_WINDOW_INPUT_GRABBED,
+               ::SDL_WINDOW_ALLOW_HIGHDPI, ::SDL_WINDOW_VULKAN.
+  
+  \return The created window, or NULL if window creation failed.
+  
+  If the window is created with the SDL_WINDOW_ALLOW_HIGHDPI flag, its size
+  in pixels may differ from its size in screen coordinates on platforms with
+  high-DPI support (e.g. iOS and Mac OS X). Use SDL_GetWindowSize() to query
+  the client area's size in screen coordinates, and SDL_GL_GetDrawableSize(),
+  SDL_Vulkan_GetDrawableSize(), or SDL_GetRendererOutputSize() to query the
+  drawable size in pixels.
+  
+  If the window is created with any of the SDL_WINDOW_OPENGL or
+  SDL_WINDOW_VULKAN flags, then the corresponding LoadLibrary function
+  (SDL_GL_LoadLibrary or SDL_Vulkan_LoadLibrary) is called and the
+  corresponding UnloadLibrary function is called by SDL_DestroyWindow().
+  
+  If SDL_WINDOW_VULKAN is specified and there isn't a working Vulkan driver,
+  SDL_CreateWindow() will fail because SDL_Vulkan_LoadLibrary() will fail.
+  
+  \note On non-Apple devices, SDL requires you to either not link to the
+        Vulkan loader or link to a dynamic library version. This limitation
+        may be removed in a future version of SDL.
+  
+  \sa SDL_DestroyWindow()
+  \sa SDL_GL_LoadLibrary()
+  \sa SDL_Vulkan_LoadLibrary()
+ + +
+ +
proc createWindowFrom(data: pointer): ptr Window {...}{.importc: "SDL_CreateWindowFrom",
+    cdecl.}
+
+ +
\brief Create an SDL window from an existing native window.
+  
+  \param data A pointer to driver-dependent window creation data
+  
+  \return The created window, or NULL if window creation failed.
+  
+  \sa SDL_DestroyWindow()
+ + +
+ +
proc getWindowID(window: ptr Window): Uint32 {...}{.importc: "SDL_GetWindowID", cdecl.}
+
+ +
\brief Get the numeric ID of a window, for logging purposes.
+ + +
+ +
proc getWindowFromID(id: Uint32): ptr Window {...}{.importc: "SDL_GetWindowFromID", cdecl.}
+
+ +
\brief Get a window from a stored ID, or NULL if it doesn't exist.
+ + +
+ +
proc getWindowFlags(window: ptr Window): Uint32 {...}{.importc: "SDL_GetWindowFlags", cdecl.}
+
+ +
\brief Get the window flags.
+ + +
+ +
proc setWindowTitle(window: ptr Window; title: cstring) {...}{.
+    importc: "SDL_SetWindowTitle", cdecl.}
+
+ +
\brief Set the title of a window, in UTF-8 format.
+  
+  \sa SDL_GetWindowTitle()
+ + +
+ +
proc getWindowTitle(window: ptr Window): cstring {...}{.importc: "SDL_GetWindowTitle", cdecl.}
+
+ +
\brief Get the title of a window, in UTF-8 format.
+  
+  \sa SDL_SetWindowTitle()
+ + +
+ +
proc setWindowIcon(window: ptr Window; icon: ptr Surface) {...}{.
+    importc: "SDL_SetWindowIcon", cdecl.}
+
+ +
\brief Set the icon for a window.
+  
+  \param window The window for which the icon should be set.
+  \param icon The icon for the window.
+ + +
+ +
proc setWindowData(window: ptr Window; name: cstring; userdata: pointer): pointer {...}{.
+    importc: "SDL_SetWindowData", cdecl.}
+
+ +
\brief Associate an arbitrary named pointer with a window.
+  
+  \param window   The window to associate with the pointer.
+  \param name     The name of the pointer.
+  \param userdata The associated pointer.
+  
+  \return The previous value associated with 'name'
+  
+  \note The name is case-sensitive.
+  
+  \sa SDL_GetWindowData()
+ + +
+ +
proc getWindowData(window: ptr Window; name: cstring): pointer {...}{.
+    importc: "SDL_GetWindowData", cdecl.}
+
+ +
\brief Retrieve the data pointer associated with a window.
+  
+  \param window   The window to query.
+  \param name     The name of the pointer.
+  
+  \return The value associated with 'name'
+  
+  \sa SDL_SetWindowData()
+ + +
+ +
proc setWindowPosition(window: ptr Window; x: cint; y: cint) {...}{.
+    importc: "SDL_SetWindowPosition", cdecl.}
+
+ +
\brief Set the position of a window.
+  
+  \param window   The window to reposition.
+  \param x        The x coordinate of the window in screen coordinates, or
+                  ::SDL_WINDOWPOS_CENTERED or ::SDL_WINDOWPOS_UNDEFINED.
+  \param y        The y coordinate of the window in screen coordinates, or
+                  ::SDL_WINDOWPOS_CENTERED or ::SDL_WINDOWPOS_UNDEFINED.
+  
+  \note The window coordinate origin is the upper left of the display.
+  
+  \sa SDL_GetWindowPosition()
+ + +
+ +
proc getWindowPosition(window: ptr Window; x: ptr cint; y: ptr cint) {...}{.
+    importc: "SDL_GetWindowPosition", cdecl.}
+
+ +
\brief Get the position of a window.
+  
+  \param window   The window to query.
+  \param x        Pointer to variable for storing the x position, in screen
+                  coordinates. May be NULL.
+  \param y        Pointer to variable for storing the y position, in screen
+                  coordinates. May be NULL.
+  
+  \sa SDL_SetWindowPosition()
+ + +
+ +
proc setWindowSize(window: ptr Window; w: cint; h: cint) {...}{.importc: "SDL_SetWindowSize",
+    cdecl.}
+
+ +
\brief Set the size of a window's client area.
+  
+  \param window   The window to resize.
+  \param w        The width of the window, in screen coordinates. Must be >0.
+  \param h        The height of the window, in screen coordinates. Must be >0.
+  
+  \note Fullscreen windows automatically match the size of the display mode,
+        and you should use SDL_SetWindowDisplayMode() to change their size.
+  
+  The window size in screen coordinates may differ from the size in pixels, if
+  the window was created with SDL_WINDOW_ALLOW_HIGHDPI on a platform with
+  high-dpi support (e.g. iOS or OS X). Use SDL_GL_GetDrawableSize() or
+  SDL_GetRendererOutputSize() to get the real client area size in pixels.
+  
+  \sa SDL_GetWindowSize()
+  \sa SDL_SetWindowDisplayMode()
+ + +
+ +
proc getWindowSize(window: ptr Window; w: ptr cint; h: ptr cint) {...}{.
+    importc: "SDL_GetWindowSize", cdecl.}
+
+ +
\brief Get the size of a window's client area.
+  
+  \param window   The window to query.
+  \param w        Pointer to variable for storing the width, in screen
+                  coordinates. May be NULL.
+  \param h        Pointer to variable for storing the height, in screen
+                  coordinates. May be NULL.
+  
+  The window size in screen coordinates may differ from the size in pixels, if
+  the window was created with SDL_WINDOW_ALLOW_HIGHDPI on a platform with
+  high-dpi support (e.g. iOS or OS X). Use SDL_GL_GetDrawableSize() or
+  SDL_GetRendererOutputSize() to get the real client area size in pixels.
+  
+  \sa SDL_SetWindowSize()
+ + +
+ +
proc getWindowBordersSize(window: ptr Window; top: ptr cint; left: ptr cint;
+                         bottom: ptr cint; right: ptr cint): cint {...}{.
+    importc: "SDL_GetWindowBordersSize", cdecl.}
+
+ +
\brief Get the size of a window's borders (decorations) around the client area.
+  
+  \param window The window to query.
+  \param top Pointer to variable for storing the size of the top border. NULL is permitted.
+  \param left Pointer to variable for storing the size of the left border. NULL is permitted.
+  \param bottom Pointer to variable for storing the size of the bottom border. NULL is permitted.
+  \param right Pointer to variable for storing the size of the right border. NULL is permitted.
+  
+  \return 0 on success, or -1 if getting this information is not supported.
+  
+  \note if this function fails (returns -1), the size values will be
+        initialized to 0, 0, 0, 0 (if a non-NULL pointer is provided), as
+        if the window in question was borderless.
+ + +
+ +
proc setWindowMinimumSize(window: ptr Window; minW: cint; minH: cint) {...}{.
+    importc: "SDL_SetWindowMinimumSize", cdecl.}
+
+ +
\brief Set the minimum size of a window's client area.
+  
+  \param window    The window to set a new minimum size.
+  \param min_w     The minimum width of the window, must be >0
+  \param min_h     The minimum height of the window, must be >0
+  
+  \note You can't change the minimum size of a fullscreen window, it
+        automatically matches the size of the display mode.
+  
+  \sa SDL_GetWindowMinimumSize()
+  \sa SDL_SetWindowMaximumSize()
+ + +
+ +
proc getWindowMinimumSize(window: ptr Window; w: ptr cint; h: ptr cint) {...}{.
+    importc: "SDL_GetWindowMinimumSize", cdecl.}
+
+ +
\brief Get the minimum size of a window's client area.
+  
+  \param window   The window to query.
+  \param w        Pointer to variable for storing the minimum width, may be NULL
+  \param h        Pointer to variable for storing the minimum height, may be NULL
+  
+  \sa SDL_GetWindowMaximumSize()
+  \sa SDL_SetWindowMinimumSize()
+ + +
+ +
proc setWindowMaximumSize(window: ptr Window; maxW: cint; maxH: cint) {...}{.
+    importc: "SDL_SetWindowMaximumSize", cdecl.}
+
+ +
\brief Set the maximum size of a window's client area.
+  
+  \param window    The window to set a new maximum size.
+  \param max_w     The maximum width of the window, must be >0
+  \param max_h     The maximum height of the window, must be >0
+  
+  \note You can't change the maximum size of a fullscreen window, it
+        automatically matches the size of the display mode.
+  
+  \sa SDL_GetWindowMaximumSize()
+  \sa SDL_SetWindowMinimumSize()
+ + +
+ +
proc getWindowMaximumSize(window: ptr Window; w: ptr cint; h: ptr cint) {...}{.
+    importc: "SDL_GetWindowMaximumSize", cdecl.}
+
+ +
\brief Get the maximum size of a window's client area.
+  
+  \param window   The window to query.
+  \param w        Pointer to variable for storing the maximum width, may be NULL
+  \param h        Pointer to variable for storing the maximum height, may be NULL
+  
+  \sa SDL_GetWindowMinimumSize()
+  \sa SDL_SetWindowMaximumSize()
+ + +
+ +
proc setWindowBordered(window: ptr Window; bordered: bool) {...}{.
+    importc: "SDL_SetWindowBordered", cdecl.}
+
+ +
\brief Set the border state of a window.
+  
+  This will add or remove the window's SDL_WINDOW_BORDERLESS flag and
+  add or remove the border from the actual window. This is a no-op if the
+  window's border already matches the requested state.
+  
+  \param window The window of which to change the border state.
+  \param bordered SDL_FALSE to remove border, SDL_TRUE to add border.
+  
+  \note You can't change the border state of a fullscreen window.
+  
+  \sa SDL_GetWindowFlags()
+ + +
+ +
proc setWindowResizable(window: ptr Window; resizable: bool) {...}{.
+    importc: "SDL_SetWindowResizable", cdecl.}
+
+ +
\brief Set the user-resizable state of a window.
+  
+  This will add or remove the window's SDL_WINDOW_RESIZABLE flag and
+  allow/disallow user resizing of the window. This is a no-op if the
+  window's resizable state already matches the requested state.
+  
+  \param window The window of which to change the resizable state.
+  \param resizable SDL_TRUE to allow resizing, SDL_FALSE to disallow.
+  
+  \note You can't change the resizable state of a fullscreen window.
+  
+  \sa SDL_GetWindowFlags()
+ + +
+ +
proc showWindow(window: ptr Window) {...}{.importc: "SDL_ShowWindow", cdecl.}
+
+ +
\brief Show a window.
+  
+  \sa SDL_HideWindow()
+ + +
+ +
proc hideWindow(window: ptr Window) {...}{.importc: "SDL_HideWindow", cdecl.}
+
+ +
\brief Hide a window.
+  
+  \sa SDL_ShowWindow()
+ + +
+ +
proc raiseWindow(window: ptr Window) {...}{.importc: "SDL_RaiseWindow", cdecl.}
+
+ +
\brief Raise a window above other windows and set the input focus.
+ + +
+ +
proc maximizeWindow(window: ptr Window) {...}{.importc: "SDL_MaximizeWindow", cdecl.}
+
+ +
\brief Make a window as large as possible.
+  
+  \sa SDL_RestoreWindow()
+ + +
+ +
proc minimizeWindow(window: ptr Window) {...}{.importc: "SDL_MinimizeWindow", cdecl.}
+
+ +
\brief Minimize a window to an iconic representation.
+  
+  \sa SDL_RestoreWindow()
+ + +
+ +
proc restoreWindow(window: ptr Window) {...}{.importc: "SDL_RestoreWindow", cdecl.}
+
+ +
\brief Restore the size and position of a minimized or maximized window.
+  
+  \sa SDL_MaximizeWindow()
+  \sa SDL_MinimizeWindow()
+ + +
+ +
proc setWindowFullscreen(window: ptr Window; flags: Uint32): cint {...}{.
+    importc: "SDL_SetWindowFullscreen", cdecl.}
+
+ +
\brief Set a window's fullscreen state.
+  
+  \return 0 on success, or -1 if setting the display mode failed.
+  
+  \sa SDL_SetWindowDisplayMode()
+  \sa SDL_GetWindowDisplayMode()
+ + +
+ +
proc getWindowSurface(window: ptr Window): ptr Surface {...}{.
+    importc: "SDL_GetWindowSurface", cdecl.}
+
+ +
\brief Get the SDL surface associated with the window.
+  
+  \return The window's framebuffer surface, or NULL on error.
+  
+  A new surface will be created with the optimal format for the window,
+  if necessary. This surface will be freed when the window is destroyed.
+  
+  \note You may not combine this with 3D or the rendering API on this window.
+  
+  \sa SDL_UpdateWindowSurface()
+  \sa SDL_UpdateWindowSurfaceRects()
+ + +
+ +
proc updateWindowSurface(window: ptr Window): cint {...}{.
+    importc: "SDL_UpdateWindowSurface", cdecl.}
+
+ +
\brief Copy the window surface to the screen.
+  
+  \return 0 on success, or -1 on error.
+  
+  \sa SDL_GetWindowSurface()
+  \sa SDL_UpdateWindowSurfaceRects()
+ + +
+ +
proc updateWindowSurfaceRects(window: ptr Window; rects: ptr Rect; numrects: cint): cint {...}{.
+    importc: "SDL_UpdateWindowSurfaceRects", cdecl.}
+
+ +
\brief Copy a number of rectangles on the window surface to the screen.
+  
+  \return 0 on success, or -1 on error.
+  
+  \sa SDL_GetWindowSurface()
+  \sa SDL_UpdateWindowSurface()
+ + +
+ +
proc setWindowGrab(window: ptr Window; grabbed: bool) {...}{.importc: "SDL_SetWindowGrab",
+    cdecl.}
+
+ +
\brief Set a window's input grab mode.
+  
+  \param window The window for which the input grab mode should be set.
+  \param grabbed This is SDL_TRUE to grab input, and SDL_FALSE to release input.
+  
+  If the caller enables a grab while another window is currently grabbed,
+  the other window loses its grab in favor of the caller's window.
+  
+  \sa SDL_GetWindowGrab()
+ + +
+ +
proc getWindowGrab(window: ptr Window): bool {...}{.importc: "SDL_GetWindowGrab", cdecl.}
+
+ +
\brief Get a window's input grab mode.
+  
+  \return This returns SDL_TRUE if input is grabbed, and SDL_FALSE otherwise.
+  
+  \sa SDL_SetWindowGrab()
+ + +
+ +
proc getGrabbedWindow(): ptr Window {...}{.importc: "SDL_GetGrabbedWindow", cdecl.}
+
+ +
\brief Get the window that currently has an input grab enabled.
+  
+  \return This returns the window if input is grabbed, and NULL otherwise.
+  
+  \sa SDL_SetWindowGrab()
+ + +
+ +
proc setWindowBrightness(window: ptr Window; brightness: cfloat): cint {...}{.
+    importc: "SDL_SetWindowBrightness", cdecl.}
+
+ +
\brief Set the brightness (gamma correction) for a window.
+  
+  \return 0 on success, or -1 if setting the brightness isn't supported.
+  
+  \sa SDL_GetWindowBrightness()
+  \sa SDL_SetWindowGammaRamp()
+ + +
+ +
proc getWindowBrightness(window: ptr Window): cfloat {...}{.
+    importc: "SDL_GetWindowBrightness", cdecl.}
+
+ +
\brief Get the brightness (gamma correction) for a window.
+  
+  \return The last brightness value passed to SDL_SetWindowBrightness()
+  
+  \sa SDL_SetWindowBrightness()
+ + +
+ +
proc setWindowOpacity(window: ptr Window; opacity: cfloat): cint {...}{.
+    importc: "SDL_SetWindowOpacity", cdecl.}
+
+ +
\brief Set the opacity for a window
+  
+  \param window The window which will be made transparent or opaque
+  \param opacity Opacity (0.0f - transparent, 1.0f - opaque) This will be
+                 clamped internally between 0.0f and 1.0f.
+  
+  \return 0 on success, or -1 if setting the opacity isn't supported.
+  
+  \sa SDL_GetWindowOpacity()
+ + +
+ +
proc getWindowOpacity(window: ptr Window; outOpacity: ptr cfloat): cint {...}{.
+    importc: "SDL_GetWindowOpacity", cdecl.}
+
+ +
\brief Get the opacity of a window.
+  
+  If transparency isn't supported on this platform, opacity will be reported
+  as 1.0f without error.
+  
+  \param window The window in question.
+  \param out_opacity Opacity (0.0f - transparent, 1.0f - opaque)
+  
+  \return 0 on success, or -1 on error (invalid window, etc).
+  
+  \sa SDL_SetWindowOpacity()
+ + +
+ +
proc setWindowModalFor(modalWindow: ptr Window; parentWindow: ptr Window): cint {...}{.
+    importc: "SDL_SetWindowModalFor", cdecl.}
+
+ +
\brief Sets the window as a modal for another window (TODO: reconsider this function and/or its name)
+  
+  \param modal_window The window that should be modal
+  \param parent_window The parent window
+  
+  \return 0 on success, or -1 otherwise.
+ + +
+ +
proc setWindowInputFocus(window: ptr Window): cint {...}{.
+    importc: "SDL_SetWindowInputFocus", cdecl.}
+
+ +
\brief Explicitly sets input focus to the window.
+  
+  You almost certainly want SDL_RaiseWindow() instead of this function. Use
+  this with caution, as you might give focus to a window that's completely
+  obscured by other windows.
+  
+  \param window The window that should get the input focus
+  
+  \return 0 on success, or -1 otherwise.
+  \sa SDL_RaiseWindow()
+ + +
+ +
proc setWindowGammaRamp(window: ptr Window; red: ptr Uint16; green: ptr Uint16;
+                       blue: ptr Uint16): cint {...}{.importc: "SDL_SetWindowGammaRamp",
+    cdecl.}
+
+ +
\brief Set the gamma ramp for a window.
+  
+  \param window The window for which the gamma ramp should be set.
+  \param red The translation table for the red channel, or NULL.
+  \param green The translation table for the green channel, or NULL.
+  \param blue The translation table for the blue channel, or NULL.
+  
+  \return 0 on success, or -1 if gamma ramps are unsupported.
+  
+  Set the gamma translation table for the red, green, and blue channels
+  of the video hardware.  Each table is an array of 256 16-bit quantities,
+  representing a mapping between the input and output for that channel.
+  The input is the index into the array, and the output is the 16-bit
+  gamma value at that index, scaled to the output color precision.
+  
+  \sa SDL_GetWindowGammaRamp()
+ + +
+ +
proc getWindowGammaRamp(window: ptr Window; red: ptr Uint16; green: ptr Uint16;
+                       blue: ptr Uint16): cint {...}{.importc: "SDL_GetWindowGammaRamp",
+    cdecl.}
+
+ +
\brief Get the gamma ramp for a window.
+  
+  \param window The window from which the gamma ramp should be queried.
+  \param red   A pointer to a 256 element array of 16-bit quantities to hold
+               the translation table for the red channel, or NULL.
+  \param green A pointer to a 256 element array of 16-bit quantities to hold
+               the translation table for the green channel, or NULL.
+  \param blue  A pointer to a 256 element array of 16-bit quantities to hold
+               the translation table for the blue channel, or NULL.
+  
+  \return 0 on success, or -1 if gamma ramps are unsupported.
+  
+  \sa SDL_SetWindowGammaRamp()
+ + +
+ +
proc setWindowHitTest(window: ptr Window; callback: HitTest; callbackData: pointer): cint {...}{.
+    importc: "SDL_SetWindowHitTest", cdecl.}
+
+ +
\brief Provide a callback that decides if a window region has special properties.
+  
+  Normally windows are dragged and resized by decorations provided by the
+  system window manager (a title bar, borders, etc), but for some apps, it
+  makes sense to drag them from somewhere else inside the window itself; for
+  example, one might have a borderless window that wants to be draggable
+  from any part, or simulate its own title bar, etc.
+  
+  This function lets the app provide a callback that designates pieces of
+  a given window as special. This callback is run during event processing
+  if we need to tell the OS to treat a region of the window specially; the
+  use of this callback is known as "hit testing."
+  
+  Mouse input may not be delivered to your application if it is within
+  a special area; the OS will often apply that input to moving the window or
+  resizing the window and not deliver it to the application.
+  
+  Specifying NULL for a callback disables hit-testing. Hit-testing is
+  disabled by default.
+  
+  Platforms that don't support this functionality will return -1
+  unconditionally, even if you're attempting to disable hit-testing.
+  
+  Your callback may fire at any time, and its firing does not indicate any
+  specific behavior (for example, on Windows, this certainly might fire
+  when the OS is deciding whether to drag your window, but it fires for lots
+  of other reasons, too, some unrelated to anything you probably care about
+  _and when the mouse isn't actually at the location it is testing_).
+  Since this can fire at any time, you should try to keep your callback
+  efficient, devoid of allocations, etc.
+  
+  \param window The window to set hit-testing on.
+  \param callback The callback to call when doing a hit-test.
+  \param callback_data An app-defined void pointer passed to the callback.
+  \return 0 on success, -1 on error (including unsupported).
+ + +
+ +
proc destroyWindow(window: ptr Window) {...}{.importc: "SDL_DestroyWindow", cdecl.}
+
+ +
\brief Destroy a window.
+ + +
+ +
proc isScreenSaverEnabled(): bool {...}{.importc: "SDL_IsScreenSaverEnabled", cdecl.}
+
+ +
\brief Returns whether the screensaver is currently enabled (default off).
+  
+  \sa SDL_EnableScreenSaver()
+  \sa SDL_DisableScreenSaver()
+ + +
+ +
proc enableScreenSaver() {...}{.importc: "SDL_EnableScreenSaver", cdecl.}
+
+ +
\brief Allow the screen to be blanked by a screensaver
+  
+  \sa SDL_IsScreenSaverEnabled()
+  \sa SDL_DisableScreenSaver()
+ + +
+ +
proc disableScreenSaver() {...}{.importc: "SDL_DisableScreenSaver", cdecl.}
+
+ +
\brief Prevent the screen from being blanked by a screensaver
+  
+  \sa SDL_IsScreenSaverEnabled()
+  \sa SDL_EnableScreenSaver()
+ + +
+ +
proc gL_LoadLibrary(path: cstring): cint {...}{.importc: "SDL_GL_LoadLibrary", cdecl.}
+
+ +
\name OpenGL support functions
+@{
+\brief Dynamically load an OpenGL library.
+  
+  \param path The platform dependent OpenGL library name, or NULL to open the
+              default OpenGL library.
+  
+  \return 0 on success, or -1 if the library couldn't be loaded.
+  
+  This should be done after initializing the video driver, but before
+  creating any OpenGL windows.  If no OpenGL library is loaded, the default
+  library will be loaded upon creation of the first OpenGL window.
+  
+  \note If you do this, you need to retrieve all of the GL functions used in
+        your program from the dynamic library using SDL_GL_GetProcAddress().
+  
+  \sa SDL_GL_GetProcAddress()
+  \sa SDL_GL_UnloadLibrary()
+ + +
+ +
proc gL_GetProcAddress(`proc`: cstring): pointer {...}{.importc: "SDL_GL_GetProcAddress",
+    cdecl.}
+
+ +
\brief Get the address of an OpenGL function.
+ + +
+ +
proc gL_UnloadLibrary() {...}{.importc: "SDL_GL_UnloadLibrary", cdecl.}
+
+ +
\brief Unload the OpenGL library previously loaded by SDL_GL_LoadLibrary().
+  
+  \sa SDL_GL_LoadLibrary()
+ + +
+ +
proc gL_ExtensionSupported(extension: cstring): bool {...}{.
+    importc: "SDL_GL_ExtensionSupported", cdecl.}
+
+ +
\brief Return true if an OpenGL extension is supported for the current
+         context.
+ + +
+ +
proc gL_ResetAttributes() {...}{.importc: "SDL_GL_ResetAttributes", cdecl.}
+
+ +
\brief Reset all previously set OpenGL context attributes to their default values
+ + +
+ +
proc gL_SetAttribute(attr: GLattr; value: cint): cint {...}{.
+    importc: "SDL_GL_SetAttribute", cdecl.}
+
+ +
\brief Set an OpenGL window attribute before window creation.
+  
+  \return 0 on success, or -1 if the attribute could not be set.
+ + +
+ +
proc gL_GetAttribute(attr: GLattr; value: ptr cint): cint {...}{.
+    importc: "SDL_GL_GetAttribute", cdecl.}
+
+ +
\brief Get the actual value for an attribute from the current context.
+  
+  \return 0 on success, or -1 if the attribute could not be retrieved.
+          The integer at \c value will be modified in either case.
+ + +
+ +
proc gL_CreateContext(window: ptr Window): GLContext {...}{.
+    importc: "SDL_GL_CreateContext", cdecl.}
+
+ +
\brief Create an OpenGL context for use with an OpenGL window, and make it
+         current.
+  
+  \sa SDL_GL_DeleteContext()
+ + +
+ +
proc gL_MakeCurrent(window: ptr Window; context: GLContext): cint {...}{.
+    importc: "SDL_GL_MakeCurrent", cdecl.}
+
+ +
\brief Set up an OpenGL context for rendering into an OpenGL window.
+  
+  \note The context must have been created with a compatible window.
+ + +
+ +
proc gL_GetCurrentWindow(): ptr Window {...}{.importc: "SDL_GL_GetCurrentWindow", cdecl.}
+
+ +
\brief Get the currently active OpenGL window.
+ + +
+ +
proc gL_GetCurrentContext(): GLContext {...}{.importc: "SDL_GL_GetCurrentContext", cdecl.}
+
+ +
\brief Get the currently active OpenGL context.
+ + +
+ +
proc gL_GetDrawableSize(window: ptr Window; w: ptr cint; h: ptr cint) {...}{.
+    importc: "SDL_GL_GetDrawableSize", cdecl.}
+
+ +
\brief Get the size of a window's underlying drawable in pixels (for use
+         with glViewport).
+  
+  \param window   Window from which the drawable size should be queried
+  \param w        Pointer to variable for storing the width in pixels, may be NULL
+  \param h        Pointer to variable for storing the height in pixels, may be NULL
+ 
+ This may differ from SDL_GetWindowSize() if we're rendering to a high-DPI
+ drawable, i.e. the window was created with SDL_WINDOW_ALLOW_HIGHDPI on a
+ platform with high-DPI support (Apple calls this "Retina"), and not disabled
+ by the SDL_HINT_VIDEO_HIGHDPI_DISABLED hint.
+  
+  \sa SDL_GetWindowSize()
+  \sa SDL_CreateWindow()
+ + +
+ +
proc gL_SetSwapInterval(interval: cint): cint {...}{.importc: "SDL_GL_SetSwapInterval",
+    cdecl.}
+
+ +
\brief Set the swap interval for the current OpenGL context.
+  
+  \param interval 0 for immediate updates, 1 for updates synchronized with the
+                  vertical retrace. If the system supports it, you may
+                  specify -1 to allow late swaps to happen immediately
+                  instead of waiting for the next retrace.
+  
+  \return 0 on success, or -1 if setting the swap interval is not supported.
+  
+  \sa SDL_GL_GetSwapInterval()
+ + +
+ +
proc gL_GetSwapInterval(): cint {...}{.importc: "SDL_GL_GetSwapInterval", cdecl.}
+
+ +
\brief Get the swap interval for the current OpenGL context.
+  
+  \return 0 if there is no vertical retrace synchronization, 1 if the buffer
+          swap is synchronized with the vertical retrace, and -1 if late
+          swaps happen immediately instead of waiting for the next retrace.
+          If the system can't determine the swap interval, or there isn't a
+          valid current context, this will return 0 as a safe default.
+  
+  \sa SDL_GL_SetSwapInterval()
+ + +
+ +
proc gL_SwapWindow(window: ptr Window) {...}{.importc: "SDL_GL_SwapWindow", cdecl.}
+
+ +
\brief Swap the OpenGL buffers for a window, if double-buffering is
+        supported.
+ + +
+ +
proc gL_DeleteContext(context: GLContext) {...}{.importc: "SDL_GL_DeleteContext", cdecl.}
+
+ +
\brief Delete an OpenGL context.
+  
+  \sa SDL_GL_CreateContext()
+ + +
+ +
proc getKeyboardFocus(): ptr Window {...}{.importc: "SDL_GetKeyboardFocus", cdecl.}
+
+ +
Function prototypes
+\brief Get the window which currently has keyboard focus.
+ + +
+ +
proc getKeyboardState(numkeys: ptr cint): ptr Uint8 {...}{.importc: "SDL_GetKeyboardState",
+    cdecl.}
+
+ +
\brief Get a snapshot of the current state of the keyboard.
+  
+  \param numkeys if non-NULL, receives the length of the returned array.
+  
+  \return An array of key states. Indexes into this array are obtained by using ::SDL_Scancode values.
+  
+  \b Example:
+  \code
+  const Uint8state = SDL_GetKeyboardState(NULL);
+  if ( state[SDL_SCANCODE_RETURN] )   {
+      printf("<RETURN> is pressed.\n");
+  }
+  \endcode
+ + +
+ +
proc getModState(): Keymod {...}{.importc: "SDL_GetModState", cdecl.}
+
+ +
\brief Get the current key modifier state for the keyboard.
+ + +
+ +
proc setModState(modstate: Keymod) {...}{.importc: "SDL_SetModState", cdecl.}
+
+ +
\brief Set the current key modifier state for the keyboard.
+  
+  \note This does not change the keyboard state, only the key modifier flags.
+ + +
+ +
proc getKeyFromScancode(scancode: Scancode): Keycode {...}{.
+    importc: "SDL_GetKeyFromScancode", cdecl.}
+
+ +
\brief Get the key code corresponding to the given scancode according
+         to the current keyboard layout.
+  
+  See ::SDL_Keycode for details.
+  
+  \sa SDL_GetKeyName()
+ + +
+ +
proc getScancodeFromKey(key: Keycode): Scancode {...}{.importc: "SDL_GetScancodeFromKey",
+    cdecl.}
+
+ +
\brief Get the scancode corresponding to the given key code according to the
+         current keyboard layout.
+  
+  See ::SDL_Scancode for details.
+  
+  \sa SDL_GetScancodeName()
+ + +
+ +
proc getScancodeName(scancode: Scancode): cstring {...}{.importc: "SDL_GetScancodeName",
+    cdecl.}
+
+ +
\brief Get a human-readable name for a scancode.
+  
+  \return A pointer to the name for the scancode.
+          If the scancode doesn't have a name, this function returns
+          an empty string ("").
+  
+  \sa SDL_Scancode
+ + +
+ +
proc getScancodeFromName(name: cstring): Scancode {...}{.
+    importc: "SDL_GetScancodeFromName", cdecl.}
+
+ +
\brief Get a scancode from a human-readable name
+  
+  \return scancode, or SDL_SCANCODE_UNKNOWN if the name wasn't recognized
+  
+  \sa SDL_Scancode
+ + +
+ +
proc getKeyName(key: Keycode): cstring {...}{.importc: "SDL_GetKeyName", cdecl.}
+
+ +
\brief Get a human-readable name for a key.
+  
+  \return A pointer to a UTF-8 string that stays valid at least until the next
+          call to this function. If you need it around any longer, you must
+          copy it.  If the key doesn't have a name, this function returns an
+          empty string ("").
+  
+  \sa SDL_Keycode
+ + +
+ +
proc getKeyFromName(name: cstring): Keycode {...}{.importc: "SDL_GetKeyFromName", cdecl.}
+
+ +
\brief Get a key code from a human-readable name
+  
+  \return key code, or SDLK_UNKNOWN if the name wasn't recognized
+  
+  \sa SDL_Keycode
+ + +
+ +
proc startTextInput() {...}{.importc: "SDL_StartTextInput", cdecl.}
+
+ +
\brief Start accepting Unicode text input events.
+         This function will show the on-screen keyboard if supported.
+  
+  \sa SDL_StopTextInput()
+  \sa SDL_SetTextInputRect()
+  \sa SDL_HasScreenKeyboardSupport()
+ + +
+ +
proc isTextInputActive(): bool {...}{.importc: "SDL_IsTextInputActive", cdecl.}
+
+ +
\brief Return whether or not Unicode text input events are enabled.
+  
+  \sa SDL_StartTextInput()
+  \sa SDL_StopTextInput()
+ + +
+ +
proc stopTextInput() {...}{.importc: "SDL_StopTextInput", cdecl.}
+
+ +
\brief Stop receiving any text input events.
+         This function will hide the on-screen keyboard if supported.
+  
+  \sa SDL_StartTextInput()
+  \sa SDL_HasScreenKeyboardSupport()
+ + +
+ +
proc setTextInputRect(rect: ptr Rect) {...}{.importc: "SDL_SetTextInputRect", cdecl.}
+
+ +
\brief Set the rectangle used to type Unicode text inputs.
+         This is used as a hint for IME and on-screen keyboard placement.
+  
+  \sa SDL_StartTextInput()
+ + +
+ +
proc hasScreenKeyboardSupport(): bool {...}{.importc: "SDL_HasScreenKeyboardSupport",
+                                     cdecl.}
+
+ +
\brief Returns whether the platform has some screen keyboard support.
+  
+  \return SDL_TRUE if some keyboard support is available else SDL_FALSE.
+  
+  \note Not all screen keyboard functions are supported on all platforms.
+  
+  \sa SDL_IsScreenKeyboardShown()
+ + +
+ +
proc isScreenKeyboardShown(window: ptr Window): bool {...}{.
+    importc: "SDL_IsScreenKeyboardShown", cdecl.}
+
+ +
\brief Returns whether the screen keyboard is shown for given window.
+  
+  \param window The window for which screen keyboard should be queried.
+  
+  \return SDL_TRUE if screen keyboard is shown else SDL_FALSE.
+  
+  \sa SDL_HasScreenKeyboardSupport()
+ + +
+ +
proc getMouseFocus(): ptr Window {...}{.importc: "SDL_GetMouseFocus", cdecl.}
+
+ +
Function prototypes
+\brief Get the window which currently has mouse focus.
+ + +
+ +
proc getMouseState(x: ptr cint; y: ptr cint): Uint32 {...}{.importc: "SDL_GetMouseState", cdecl.}
+
+ +
\brief Retrieve the current state of the mouse.
+  
+  The current button state is returned as a button bitmask, which can
+  be tested using the SDL_BUTTON(X) macros, and x and y are set to the
+  mouse cursor position relative to the focus window for the currently
+  selected mouse.  You can pass NULL for either x or y.
+ + +
+ +
proc getGlobalMouseState(x: ptr cint; y: ptr cint): Uint32 {...}{.
+    importc: "SDL_GetGlobalMouseState", cdecl.}
+
+ +
\brief Get the current state of the mouse, in relation to the desktop
+  
+  This works just like SDL_GetMouseState(), but the coordinates will be
+  reported relative to the top-left of the desktop. This can be useful if
+  you need to track the mouse outside of a specific window and
+  SDL_CaptureMouse() doesn't fit your needs. For example, it could be
+  useful if you need to track the mouse while dragging a window, where
+  coordinates relative to a window might not be in sync at all times.
+  
+  \note SDL_GetMouseState() returns the mouse position as SDL understands
+        it from the last pump of the event queue. This function, however,
+        queries the OS for the current mouse position, and as such, might
+        be a slightly less efficient function. Unless you know what you're
+        doing and have a good reason to use this function, you probably want
+        SDL_GetMouseState() instead.
+  
+  \param x Returns the current X coord, relative to the desktop. Can be NULL.
+  \param y Returns the current Y coord, relative to the desktop. Can be NULL.
+  \return The current button state as a bitmask, which can be tested using the SDL_BUTTON(X) macros.
+  
+  \sa SDL_GetMouseState
+ + +
+ +
proc getRelativeMouseState(x: ptr cint; y: ptr cint): Uint32 {...}{.
+    importc: "SDL_GetRelativeMouseState", cdecl.}
+
+ +
\brief Retrieve the relative state of the mouse.
+  
+  The current button state is returned as a button bitmask, which can
+  be tested using the SDL_BUTTON(X) macros, and x and y are set to the
+  mouse deltas since the last call to SDL_GetRelativeMouseState().
+ + +
+ +
proc warpMouseInWindow(window: ptr Window; x: cint; y: cint) {...}{.
+    importc: "SDL_WarpMouseInWindow", cdecl.}
+
+ +
\brief Moves the mouse to the given position within the window.
+  
+  \param window The window to move the mouse into, or NULL for the current mouse focus
+  \param x The x coordinate within the window
+  \param y The y coordinate within the window
+  
+  \note This function generates a mouse motion event
+ + +
+ +
proc warpMouseGlobal(x: cint; y: cint): cint {...}{.importc: "SDL_WarpMouseGlobal", cdecl.}
+
+ +
\brief Moves the mouse to the given position in global screen space.
+  
+  \param x The x coordinate
+  \param y The y coordinate
+  \return 0 on success, -1 on error (usually: unsupported by a platform).
+  
+  \note This function generates a mouse motion event
+ + +
+ +
proc setRelativeMouseMode(enabled: bool): cint {...}{.
+    importc: "SDL_SetRelativeMouseMode", cdecl.}
+
+ +
\brief Set relative mouse mode.
+  
+  \param enabled Whether or not to enable relative mode
+  
+  \return 0 on success, or -1 if relative mode is not supported.
+  
+  While the mouse is in relative mode, the cursor is hidden, and the
+  driver will try to report continuous motion in the current window.
+  Only relative motion events will be delivered, the mouse position
+  will not change.
+  
+  \note This function will flush any pending mouse motion.
+  
+  \sa SDL_GetRelativeMouseMode()
+ + +
+ +
proc captureMouse(enabled: bool): cint {...}{.importc: "SDL_CaptureMouse", cdecl.}
+
+ +
\brief Capture the mouse, to track input outside an SDL window.
+  
+  \param enabled Whether or not to enable capturing
+  
+  Capturing enables your app to obtain mouse events globally, instead of
+  just within your window. Not all video targets support this function.
+  When capturing is enabled, the current window will get all mouse events,
+  but unlike relative mode, no change is made to the cursor and it is
+  not restrained to your window.
+  
+  This function may also deny mouse input to other windows--both those in
+  your application and others on the system--so you should use this
+  function sparingly, and in small bursts. For example, you might want to
+  track the mouse while the user is dragging something, until the user
+  releases a mouse button. It is not recommended that you capture the mouse
+  for long periods of time, such as the entire time your app is running.
+  
+  While captured, mouse events still report coordinates relative to the
+  current (foreground) window, but those coordinates may be outside the
+  bounds of the window (including negative values). Capturing is only
+  allowed for the foreground window. If the window loses focus while
+  capturing, the capture will be disabled automatically.
+  
+  While capturing is enabled, the current window will have the
+  SDL_WINDOW_MOUSE_CAPTURE flag set.
+  
+  \return 0 on success, or -1 if not supported.
+ + +
+ +
proc getRelativeMouseMode(): bool {...}{.importc: "SDL_GetRelativeMouseMode", cdecl.}
+
+ +
\brief Query whether relative mouse mode is enabled.
+  
+  \sa SDL_SetRelativeMouseMode()
+ + +
+ +
proc createCursor(data: ptr Uint8; mask: ptr Uint8; w: cint; h: cint; hotX: cint; hotY: cint): ptr Cursor {...}{.
+    importc: "SDL_CreateCursor", cdecl.}
+
+ +
\brief Create a cursor, using the specified bitmap data and
+         mask (in MSB format).
+  
+  The cursor width must be a multiple of 8 bits.
+  
+  The cursor is created in black and white according to the following:
+  <table>
+  <tr><td> data </td><td> mask </td><td> resulting pixel on screen </td></tr>
+  <tr><td>  0   </td><td>  1   </td><td> White </td></tr>
+  <tr><td>  1   </td><td>  1   </td><td> Black </td></tr>
+  <tr><td>  0   </td><td>  0   </td><td> Transparent </td></tr>
+  <tr><td>  1   </td><td>  0   </td><td> Inverted color if possible, black
+                                         if not. </td></tr>
+  </table>
+  
+  \sa SDL_FreeCursor()
+ + +
+ +
proc createColorCursor(surface: ptr Surface; hotX: cint; hotY: cint): ptr Cursor {...}{.
+    importc: "SDL_CreateColorCursor", cdecl.}
+
+ +
\brief Create a color cursor.
+  
+  \sa SDL_FreeCursor()
+ + +
+ +
proc createSystemCursor(id: SystemCursor): ptr Cursor {...}{.
+    importc: "SDL_CreateSystemCursor", cdecl.}
+
+ +
\brief Create a system cursor.
+  
+  \sa SDL_FreeCursor()
+ + +
+ +
proc setCursor(cursor: ptr Cursor) {...}{.importc: "SDL_SetCursor", cdecl.}
+
+ +
\brief Set the active cursor.
+ + +
+ +
proc getCursor(): ptr Cursor {...}{.importc: "SDL_GetCursor", cdecl.}
+
+ +
\brief Return the active cursor.
+ + +
+ +
proc getDefaultCursor(): ptr Cursor {...}{.importc: "SDL_GetDefaultCursor", cdecl.}
+
+ +
\brief Return the default cursor.
+ + +
+ +
proc freeCursor(cursor: ptr Cursor) {...}{.importc: "SDL_FreeCursor", cdecl.}
+
+ +
\brief Frees a cursor created with SDL_CreateCursor() or similar functions.
+  
+  \sa SDL_CreateCursor()
+  \sa SDL_CreateColorCursor()
+  \sa SDL_CreateSystemCursor()
+ + +
+ +
proc showCursor(toggle: cint): cint {...}{.importc: "SDL_ShowCursor", cdecl.}
+
+ +
\brief Toggle whether or not the cursor is shown.
+  
+  \param toggle 1 to show the cursor, 0 to hide it, -1 to query the current
+                state.
+  
+  \return 1 if the cursor is shown, or 0 if the cursor is hidden.
+ + +
+ +
proc lockJoysticks() {...}{.importc: "SDL_LockJoysticks", cdecl.}
+
+ +
Function prototypes
+Locking for multi-threaded access to the joystick API
+ 
+ If you are using the joystick API or handling events from multiple threads
+ you should use these locking functions to protect access to the joysticks.
+ 
+ In particular, you are guaranteed that the joystick list won't change, so
+ the API functions that take a joystick index will be valid, and joystick
+ and game controller events will not be delivered.
+ + +
+ +
proc unlockJoysticks() {...}{.importc: "SDL_UnlockJoysticks", cdecl.}
+
+ + + +
+ +
proc numJoysticks(): cint {...}{.importc: "SDL_NumJoysticks", cdecl.}
+
+ +
Count the number of joysticks attached to the system right now
+ + +
+ +
proc joystickNameForIndex(deviceIndex: cint): cstring {...}{.
+    importc: "SDL_JoystickNameForIndex", cdecl.}
+
+ +
Get the implementation dependent name of a joystick.
+  This can be called before any joysticks are opened.
+  If no name can be found, this function returns NULL.
+ + +
+ +
proc joystickGetDevicePlayerIndex(deviceIndex: cint): cint {...}{.
+    importc: "SDL_JoystickGetDevicePlayerIndex", cdecl.}
+
+ +
Get the player index of a joystick, or -1 if it's not available
+  This can be called before any joysticks are opened.
+ + +
+ +
proc joystickGetDeviceGUID(deviceIndex: cint): JoystickGUID {...}{.
+    importc: "SDL_JoystickGetDeviceGUID", cdecl.}
+
+ +
Return the GUID for the joystick at this index
+  This can be called before any joysticks are opened.
+ + +
+ +
proc joystickGetDeviceVendor(deviceIndex: cint): Uint16 {...}{.
+    importc: "SDL_JoystickGetDeviceVendor", cdecl.}
+
+ +
Get the USB vendor ID of a joystick, if available.
+  This can be called before any joysticks are opened.
+  If the vendor ID isn't available this function returns 0.
+ + +
+ +
proc joystickGetDeviceProduct(deviceIndex: cint): Uint16 {...}{.
+    importc: "SDL_JoystickGetDeviceProduct", cdecl.}
+
+ +
Get the USB product ID of a joystick, if available.
+  This can be called before any joysticks are opened.
+  If the product ID isn't available this function returns 0.
+ + +
+ +
proc joystickGetDeviceProductVersion(deviceIndex: cint): Uint16 {...}{.
+    importc: "SDL_JoystickGetDeviceProductVersion", cdecl.}
+
+ +
Get the product version of a joystick, if available.
+  This can be called before any joysticks are opened.
+  If the product version isn't available this function returns 0.
+ + +
+ +
proc joystickGetDeviceType(deviceIndex: cint): JoystickType {...}{.
+    importc: "SDL_JoystickGetDeviceType", cdecl.}
+
+ +
Get the type of a joystick, if available.
+  This can be called before any joysticks are opened.
+ + +
+ +
proc joystickGetDeviceInstanceID(deviceIndex: cint): JoystickID {...}{.
+    importc: "SDL_JoystickGetDeviceInstanceID", cdecl.}
+
+ +
Get the instance ID of a joystick.
+  This can be called before any joysticks are opened.
+  If the index is out of range, this function will return -1.
+ + +
+ +
proc joystickOpen(deviceIndex: cint): ptr Joystick {...}{.importc: "SDL_JoystickOpen", cdecl.}
+
+ +
Open a joystick for use.
+  The index passed as an argument refers to the N'th joystick on the system.
+  This index is not the value which will identify this joystick in future
+  joystick events.  The joystick's instance id (::SDL_JoystickID) will be used
+  there instead.
+  
+  \return A joystick identifier, or NULL if an error occurred.
+ + +
+ +
proc joystickFromInstanceID(instanceId: JoystickID): ptr Joystick {...}{.
+    importc: "SDL_JoystickFromInstanceID", cdecl.}
+
+ +
Return the SDL_Joystick associated with an instance id.
+ + +
+ +
proc joystickFromPlayerIndex(playerIndex: cint): ptr Joystick {...}{.
+    importc: "SDL_JoystickFromPlayerIndex", cdecl.}
+
+ +
Return the SDL_Joystick associated with a player index.
+ + +
+ +
proc joystickName(joystick: ptr Joystick): cstring {...}{.importc: "SDL_JoystickName", cdecl.}
+
+ +
Return the name for this currently opened joystick.
+  If no name can be found, this function returns NULL.
+ + +
+ +
proc joystickGetPlayerIndex(joystick: ptr Joystick): cint {...}{.
+    importc: "SDL_JoystickGetPlayerIndex", cdecl.}
+
+ +
Get the player index of an opened joystick, or -1 if it's not available
+  
+  For XInput controllers this returns the XInput user index.
+ + +
+ +
proc joystickSetPlayerIndex(joystick: ptr Joystick; playerIndex: cint) {...}{.
+    importc: "SDL_JoystickSetPlayerIndex", cdecl.}
+
+ +
Set the player index of an opened joystick
+ + +
+ +
proc joystickGetGUID(joystick: ptr Joystick): JoystickGUID {...}{.
+    importc: "SDL_JoystickGetGUID", cdecl.}
+
+ +
Return the GUID for this opened joystick
+ + +
+ +
proc joystickGetVendor(joystick: ptr Joystick): Uint16 {...}{.
+    importc: "SDL_JoystickGetVendor", cdecl.}
+
+ +
Get the USB vendor ID of an opened joystick, if available.
+  If the vendor ID isn't available this function returns 0.
+ + +
+ +
proc joystickGetProduct(joystick: ptr Joystick): Uint16 {...}{.
+    importc: "SDL_JoystickGetProduct", cdecl.}
+
+ +
Get the USB product ID of an opened joystick, if available.
+  If the product ID isn't available this function returns 0.
+ + +
+ +
proc joystickGetProductVersion(joystick: ptr Joystick): Uint16 {...}{.
+    importc: "SDL_JoystickGetProductVersion", cdecl.}
+
+ +
Get the product version of an opened joystick, if available.
+  If the product version isn't available this function returns 0.
+ + +
+ +
proc joystickGetType(joystick: ptr Joystick): JoystickType {...}{.
+    importc: "SDL_JoystickGetType", cdecl.}
+
+ +
Get the type of an opened joystick.
+ + +
+ +
proc joystickGetGUIDString(guid: JoystickGUID; pszGUID: cstring; cbGUID: cint) {...}{.
+    importc: "SDL_JoystickGetGUIDString", cdecl.}
+
+ +
Return a string representation for this guid. pszGUID must point to at least 33 bytes
+  (32 for the string plus a NULL terminator).
+ + +
+ +
proc joystickGetGUIDFromString(pchGUID: cstring): JoystickGUID {...}{.
+    importc: "SDL_JoystickGetGUIDFromString", cdecl.}
+
+ +
Convert a string into a joystick guid
+ + +
+ +
proc joystickGetAttached(joystick: ptr Joystick): bool {...}{.
+    importc: "SDL_JoystickGetAttached", cdecl.}
+
+ +
Returns SDL_TRUE if the joystick has been opened and currently connected, or SDL_FALSE if it has not.
+ + +
+ +
proc joystickInstanceID(joystick: ptr Joystick): JoystickID {...}{.
+    importc: "SDL_JoystickInstanceID", cdecl.}
+
+ +
Get the instance ID of an opened joystick or -1 if the joystick is invalid.
+ + +
+ +
proc joystickNumAxes(joystick: ptr Joystick): cint {...}{.importc: "SDL_JoystickNumAxes",
+    cdecl.}
+
+ +
Get the number of general axis controls on a joystick.
+ + +
+ +
proc joystickNumBalls(joystick: ptr Joystick): cint {...}{.
+    importc: "SDL_JoystickNumBalls", cdecl.}
+
+ +
Get the number of trackballs on a joystick.
+  
+  Joystick trackballs have only relative motion events associated
+  with them and their state cannot be polled.
+ + +
+ +
proc joystickNumHats(joystick: ptr Joystick): cint {...}{.importc: "SDL_JoystickNumHats",
+    cdecl.}
+
+ +
Get the number of POV hats on a joystick.
+ + +
+ +
proc joystickNumButtons(joystick: ptr Joystick): cint {...}{.
+    importc: "SDL_JoystickNumButtons", cdecl.}
+
+ +
Get the number of buttons on a joystick.
+ + +
+ +
proc joystickUpdate() {...}{.importc: "SDL_JoystickUpdate", cdecl.}
+
+ +
Update the current state of the open joysticks.
+  
+  This is called automatically by the event loop if any joystick
+  events are enabled.
+ + +
+ +
proc joystickEventState(state: cint): cint {...}{.importc: "SDL_JoystickEventState", cdecl.}
+
+ +
Enable/disable joystick event polling.
+  
+  If joystick events are disabled, you must call SDL_JoystickUpdate()
+  yourself and check the state of the joystick when you want joystick
+  information.
+  
+  The state can be one of ::SDL_QUERY, ::SDL_ENABLE or ::SDL_IGNORE.
+ + +
+ +
proc joystickGetAxis(joystick: ptr Joystick; axis: cint): Sint16 {...}{.
+    importc: "SDL_JoystickGetAxis", cdecl.}
+
+ +
Get the current state of an axis control on a joystick.
+  
+  The state is a value ranging from -32768 to 32767.
+  
+  The axis indices start at index 0.
+ + +
+ +
proc joystickGetAxisInitialState(joystick: ptr Joystick; axis: cint; state: ptr Sint16): bool {...}{.
+    importc: "SDL_JoystickGetAxisInitialState", cdecl.}
+
+ +
Get the initial state of an axis control on a joystick.
+  
+  The state is a value ranging from -32768 to 32767.
+  
+  The axis indices start at index 0.
+  
+  \return SDL_TRUE if this axis has any initial value, or SDL_FALSE if not.
+ + +
+ +
proc joystickGetHat(joystick: ptr Joystick; hat: cint): Uint8 {...}{.
+    importc: "SDL_JoystickGetHat", cdecl.}
+
+ +
@}
+Get the current state of a POV hat on a joystick.
+  
+  The hat indices start at index 0.
+  
+  \return The return value is one of the following positions:
+           - ::SDL_HAT_CENTERED
+           - ::SDL_HAT_UP
+           - ::SDL_HAT_RIGHT
+           - ::SDL_HAT_DOWN
+           - ::SDL_HAT_LEFT
+           - ::SDL_HAT_RIGHTUP
+           - ::SDL_HAT_RIGHTDOWN
+           - ::SDL_HAT_LEFTUP
+           - ::SDL_HAT_LEFTDOWN
+ + +
+ +
proc joystickGetBall(joystick: ptr Joystick; ball: cint; dx: ptr cint; dy: ptr cint): cint {...}{.
+    importc: "SDL_JoystickGetBall", cdecl.}
+
+ +
Get the ball axis change since the last poll.
+  
+  \return 0, or -1 if you passed it invalid parameters.
+  
+  The ball indices start at index 0.
+ + +
+ +
proc joystickGetButton(joystick: ptr Joystick; button: cint): Uint8 {...}{.
+    importc: "SDL_JoystickGetButton", cdecl.}
+
+ +
Get the current state of a button on a joystick.
+  
+  The button indices start at index 0.
+ + +
+ +
proc joystickRumble(joystick: ptr Joystick; lowFrequencyRumble: Uint16;
+                   highFrequencyRumble: Uint16; durationMs: Uint32): cint {...}{.
+    importc: "SDL_JoystickRumble", cdecl.}
+
+ +
Trigger a rumble effect
+  Each call to this function cancels any previous rumble effect, and calling it with 0 intensity stops any rumbling.
+  
+  \param joystick The joystick to vibrate
+  \param low_frequency_rumble The intensity of the low frequency (left) rumble motor, from 0 to 0xFFFF
+  \param high_frequency_rumble The intensity of the high frequency (right) rumble motor, from 0 to 0xFFFF
+  \param duration_ms The duration of the rumble effect, in milliseconds
+  
+  \return 0, or -1 if rumble isn't supported on this joystick
+ + +
+ +
proc joystickClose(joystick: ptr Joystick) {...}{.importc: "SDL_JoystickClose", cdecl.}
+
+ +
Close a joystick previously opened with SDL_JoystickOpen().
+ + +
+ +
proc joystickCurrentPowerLevel(joystick: ptr Joystick): JoystickPowerLevel {...}{.
+    importc: "SDL_JoystickCurrentPowerLevel", cdecl.}
+
+ +
Return the battery level of this joystick
+ + +
+ +
proc gameControllerAddMappingsFromRW(rw: ptr RWops; freerw: cint): cint {...}{.
+    importc: "SDL_GameControllerAddMappingsFromRW", cdecl.}
+
+ +
To count the number of game controllers in the system for the following:
+  int nJoysticks = SDL_NumJoysticks();
+  int nGameControllers = 0;
+  for (int i = 0; i < nJoysticks; i++) {
+      if (SDL_IsGameController(i)) {
+          nGameControllers++;
+      }
+  }
+  
+  Using the SDL_HINT_GAMECONTROLLERCONFIG hint or the SDL_GameControllerAddMapping() you can add support for controllers SDL is unaware of or cause an existing controller to have a different binding. The format is:
+  guid,name,mappings
+  
+  Where GUID is the string value from SDL_JoystickGetGUIDString(), name is the human readable string for the device and mappings are controller mappings to joystick ones.
+  Under Windows there is a reserved GUID of "xinput" that covers any XInput devices.
+  The mapping format for joystick is:
+      bX - a joystick button, index X
+      hX.Y - hat X with value Y
+      aX - axis X of the joystick
+  Buttons can be used as a controller axis and vice versa.
+  
+  This string shows an example of a valid mapping for a controller
+  "03000000341a00003608000000000000,PS3 Controller,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b8,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftshoulder:b4,rightshoulder:b5,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7",
+Load a set of mappings from a seekable SDL data stream (memory or file), filtered by the current SDL_GetPlatform()
+  A community sourced database of controllers is available at https:raw.github.com/gabomdq/SDL_GameControllerDB/master/gamecontrollerdb.txt
+  
+  If \c freerw is non-zero, the stream will be closed after being read.
+ 
+ \return number of mappings added, -1 on error
+ + +
+ +
proc gameControllerAddMapping(mappingString: cstring): cint {...}{.
+    importc: "SDL_GameControllerAddMapping", cdecl.}
+
+ +
Add or update an existing mapping configuration
+ 
+ \return 1 if mapping is added, 0 if updated, -1 on error
+ + +
+ +
proc gameControllerNumMappings(): cint {...}{.importc: "SDL_GameControllerNumMappings",
+                                      cdecl.}
+
+ +
Get the number of mappings installed
+  
+  \return the number of mappings
+ + +
+ +
proc gameControllerMappingForIndex(mappingIndex: cint): cstring {...}{.
+    importc: "SDL_GameControllerMappingForIndex", cdecl.}
+
+ +
Get the mapping at a particular index.
+  
+  \return the mapping string.  Must be freed with SDL_free().  Returns NULL if the index is out of range.
+ + +
+ +
proc gameControllerMappingForGUID(guid: JoystickGUID): cstring {...}{.
+    importc: "SDL_GameControllerMappingForGUID", cdecl.}
+
+ +
Get a mapping string for a GUID
+  
+  \return the mapping string.  Must be freed with SDL_free().  Returns NULL if no mapping is available
+ + +
+ +
proc gameControllerMapping(gamecontroller: ptr GameController): cstring {...}{.
+    importc: "SDL_GameControllerMapping", cdecl.}
+
+ +
Get a mapping string for an open GameController
+  
+  \return the mapping string.  Must be freed with SDL_free().  Returns NULL if no mapping is available
+ + +
+ +
proc isGameController(joystickIndex: cint): bool {...}{.importc: "SDL_IsGameController",
+    cdecl.}
+
+ +
Is the joystick on this index supported by the game controller interface?
+ + +
+ +
proc gameControllerNameForIndex(joystickIndex: cint): cstring {...}{.
+    importc: "SDL_GameControllerNameForIndex", cdecl.}
+
+ +
Get the implementation dependent name of a game controller.
+  This can be called before any controllers are opened.
+  If no name can be found, this function returns NULL.
+ + +
+ +
proc gameControllerTypeForIndex(joystickIndex: cint): GameControllerType {...}{.
+    importc: "SDL_GameControllerTypeForIndex", cdecl.}
+
+ +
Get the type of a game controller.
+  This can be called before any controllers are opened.
+ + +
+ +
proc gameControllerMappingForDeviceIndex(joystickIndex: cint): cstring {...}{.
+    importc: "SDL_GameControllerMappingForDeviceIndex", cdecl.}
+
+ +
Get the mapping of a game controller.
+  This can be called before any controllers are opened.
+  
+  \return the mapping string.  Must be freed with SDL_free().  Returns NULL if no mapping is available
+ + +
+ +
proc gameControllerOpen(joystickIndex: cint): ptr GameController {...}{.
+    importc: "SDL_GameControllerOpen", cdecl.}
+
+ +
Open a game controller for use.
+  The index passed as an argument refers to the N'th game controller on the system.
+  This index is not the value which will identify this controller in future
+  controller events.  The joystick's instance id (::SDL_JoystickID) will be
+  used there instead.
+  
+  \return A controller identifier, or NULL if an error occurred.
+ + +
+ +
proc gameControllerFromInstanceID(joyid: JoystickID): ptr GameController {...}{.
+    importc: "SDL_GameControllerFromInstanceID", cdecl.}
+
+ +
Return the SDL_GameController associated with an instance id.
+ + +
+ +
proc gameControllerFromPlayerIndex(playerIndex: cint): ptr GameController {...}{.
+    importc: "SDL_GameControllerFromPlayerIndex", cdecl.}
+
+ +
Return the SDL_GameController associated with a player index.
+ + +
+ +
proc gameControllerName(gamecontroller: ptr GameController): cstring {...}{.
+    importc: "SDL_GameControllerName", cdecl.}
+
+ +
Return the name for this currently opened controller
+ + +
+ +
proc gameControllerGetType(gamecontroller: ptr GameController): GameControllerType {...}{.
+    importc: "SDL_GameControllerGetType", cdecl.}
+
+ +
Return the type of this currently opened controller
+ + +
+ +
proc gameControllerGetPlayerIndex(gamecontroller: ptr GameController): cint {...}{.
+    importc: "SDL_GameControllerGetPlayerIndex", cdecl.}
+
+ +
Get the player index of an opened game controller, or -1 if it's not available
+  
+  For XInput controllers this returns the XInput user index.
+ + +
+ +
proc gameControllerSetPlayerIndex(gamecontroller: ptr GameController;
+                                 playerIndex: cint) {...}{.
+    importc: "SDL_GameControllerSetPlayerIndex", cdecl.}
+
+ +
Set the player index of an opened game controller
+ + +
+ +
proc gameControllerGetVendor(gamecontroller: ptr GameController): Uint16 {...}{.
+    importc: "SDL_GameControllerGetVendor", cdecl.}
+
+ +
Get the USB vendor ID of an opened controller, if available.
+  If the vendor ID isn't available this function returns 0.
+ + +
+ +
proc gameControllerGetProduct(gamecontroller: ptr GameController): Uint16 {...}{.
+    importc: "SDL_GameControllerGetProduct", cdecl.}
+
+ +
Get the USB product ID of an opened controller, if available.
+  If the product ID isn't available this function returns 0.
+ + +
+ +
proc gameControllerGetProductVersion(gamecontroller: ptr GameController): Uint16 {...}{.
+    importc: "SDL_GameControllerGetProductVersion", cdecl.}
+
+ +
Get the product version of an opened controller, if available.
+  If the product version isn't available this function returns 0.
+ + +
+ +
proc gameControllerGetAttached(gamecontroller: ptr GameController): bool {...}{.
+    importc: "SDL_GameControllerGetAttached", cdecl.}
+
+ +
Returns SDL_TRUE if the controller has been opened and currently connected,
+  or SDL_FALSE if it has not.
+ + +
+ +
proc gameControllerGetJoystick(gamecontroller: ptr GameController): ptr Joystick {...}{.
+    importc: "SDL_GameControllerGetJoystick", cdecl.}
+
+ +
Get the underlying joystick object used by a controller
+ + +
+ +
proc gameControllerEventState(state: cint): cint {...}{.
+    importc: "SDL_GameControllerEventState", cdecl.}
+
+ +
Enable/disable controller event polling.
+  
+  If controller events are disabled, you must call SDL_GameControllerUpdate()
+  yourself and check the state of the controller when you want controller
+  information.
+  
+  The state can be one of ::SDL_QUERY, ::SDL_ENABLE or ::SDL_IGNORE.
+ + +
+ +
proc gameControllerUpdate() {...}{.importc: "SDL_GameControllerUpdate", cdecl.}
+
+ +
Update the current state of the open game controllers.
+  
+  This is called automatically by the event loop if any game controller
+  events are enabled.
+ + +
+ +
proc gameControllerGetAxisFromString(pchString: cstring): GameControllerAxis {...}{.
+    importc: "SDL_GameControllerGetAxisFromString", cdecl.}
+
+ +
turn this string into a axis mapping
+ + +
+ +
proc gameControllerGetStringForAxis(axis: GameControllerAxis): cstring {...}{.
+    importc: "SDL_GameControllerGetStringForAxis", cdecl.}
+
+ +
turn this axis enum into a string mapping
+ + +
+ +
proc gameControllerGetBindForAxis(gamecontroller: ptr GameController;
+                                 axis: GameControllerAxis): GameControllerButtonBind {...}{.
+    importc: "SDL_GameControllerGetBindForAxis", cdecl.}
+
+ +
Get the SDL joystick layer binding for this controller button mapping
+ + +
+ +
proc gameControllerGetAxis(gamecontroller: ptr GameController;
+                          axis: GameControllerAxis): Sint16 {...}{.
+    importc: "SDL_GameControllerGetAxis", cdecl.}
+
+ +
Get the current state of an axis control on a game controller.
+  
+  The state is a value ranging from -32768 to 32767 (except for the triggers,
+  which range from 0 to 32767).
+  
+  The axis indices start at index 0.
+ + +
+ +
proc gameControllerGetButtonFromString(pchString: cstring): GameControllerButton {...}{.
+    importc: "SDL_GameControllerGetButtonFromString", cdecl.}
+
+ +
turn this string into a button mapping
+ + +
+ +
proc gameControllerGetStringForButton(button: GameControllerButton): cstring {...}{.
+    importc: "SDL_GameControllerGetStringForButton", cdecl.}
+
+ +
turn this button enum into a string mapping
+ + +
+ +
proc gameControllerGetBindForButton(gamecontroller: ptr GameController;
+                                   button: GameControllerButton): GameControllerButtonBind {...}{.
+    importc: "SDL_GameControllerGetBindForButton", cdecl.}
+
+ +
Get the SDL joystick layer binding for this controller button mapping
+ + +
+ +
proc gameControllerGetButton(gamecontroller: ptr GameController;
+                            button: GameControllerButton): Uint8 {...}{.
+    importc: "SDL_GameControllerGetButton", cdecl.}
+
+ +
Get the current state of a button on a game controller.
+  
+  The button indices start at index 0.
+ + +
+ +
proc gameControllerRumble(gamecontroller: ptr GameController;
+                         lowFrequencyRumble: Uint16; highFrequencyRumble: Uint16;
+                         durationMs: Uint32): cint {...}{.
+    importc: "SDL_GameControllerRumble", cdecl.}
+
+ +
Trigger a rumble effect
+  Each call to this function cancels any previous rumble effect, and calling it with 0 intensity stops any rumbling.
+  
+  \param gamecontroller The controller to vibrate
+  \param low_frequency_rumble The intensity of the low frequency (left) rumble motor, from 0 to 0xFFFF
+  \param high_frequency_rumble The intensity of the high frequency (right) rumble motor, from 0 to 0xFFFF
+  \param duration_ms The duration of the rumble effect, in milliseconds
+  
+  \return 0, or -1 if rumble isn't supported on this joystick
+ + +
+ +
proc gameControllerClose(gamecontroller: ptr GameController) {...}{.
+    importc: "SDL_GameControllerClose", cdecl.}
+
+ +
Close a controller previously opened with SDL_GameControllerOpen().
+ + +
+ +
proc getNumTouchDevices(): cint {...}{.importc: "SDL_GetNumTouchDevices", cdecl.}
+
+ +
Function prototypes
+\brief Get the number of registered touch devices.
+ + +
+ +
proc getTouchDevice(index: cint): TouchID {...}{.importc: "SDL_GetTouchDevice", cdecl.}
+
+ +
\brief Get the touch ID with the given index, or 0 if the index is invalid.
+ + +
+ +
proc getTouchDeviceType(touchID: TouchID): TouchDeviceType {...}{.
+    importc: "SDL_GetTouchDeviceType", cdecl.}
+
+ +
\brief Get the type of the given touch device.
+ + +
+ +
proc getNumTouchFingers(touchID: TouchID): cint {...}{.importc: "SDL_GetNumTouchFingers",
+    cdecl.}
+
+ +
\brief Get the number of active fingers for a given touch device.
+ + +
+ +
proc getTouchFinger(touchID: TouchID; index: cint): ptr Finger {...}{.
+    importc: "SDL_GetTouchFinger", cdecl.}
+
+ +
\brief Get the finger object of the given touch, with the given index.
+ + +
+ +
proc recordGesture(touchId: TouchID): cint {...}{.importc: "SDL_RecordGesture", cdecl.}
+
+ +
Function prototypes
+\brief Begin Recording a gesture on the specified touch, or all touches (-1)
+ + +
+ +
proc saveAllDollarTemplates(dst: ptr RWops): cint {...}{.
+    importc: "SDL_SaveAllDollarTemplates", cdecl.}
+
+ +
\brief Save all currently loaded Dollar Gesture templates
+ + +
+ +
proc saveDollarTemplate(gestureId: GestureID; dst: ptr RWops): cint {...}{.
+    importc: "SDL_SaveDollarTemplate", cdecl.}
+
+ +
\brief Save a currently loaded Dollar Gesture template
+ + +
+ +
proc loadDollarTemplates(touchId: TouchID; src: ptr RWops): cint {...}{.
+    importc: "SDL_LoadDollarTemplates", cdecl.}
+
+ +
\brief Load Dollar Gesture templates from a file
+ + +
+ +
proc pumpEvents() {...}{.importc: "SDL_PumpEvents", cdecl.}
+
+ +
Function prototypes
+Pumps the event loop, gathering events from the input devices.
+  
+  This function updates the event queue and internal input device state.
+  
+  This should only be run in the thread that sets the video mode.
+ + +
+ +
proc peepEvents(events: ptr Event; numevents: cint; action: eventaction;
+               minType: Uint32; maxType: Uint32): cint {...}{.importc: "SDL_PeepEvents",
+    cdecl.}
+
+ +
Checks the event queue for messages and optionally returns them.
+  
+  If \c action is ::SDL_ADDEVENT, up to \c numevents events will be added to
+  the back of the event queue.
+  
+  If \c action is ::SDL_PEEKEVENT, up to \c numevents events at the front
+  of the event queue, within the specified minimum and maximum type,
+  will be returned and will not be removed from the queue.
+  
+  If \c action is ::SDL_GETEVENT, up to \c numevents events at the front
+  of the event queue, within the specified minimum and maximum type,
+  will be returned and will be removed from the queue.
+  
+  \return The number of events actually stored, or -1 if there was an error.
+  
+  This function is thread-safe.
+ + +
+ +
proc hasEvent(kind: Uint32): bool {...}{.importc: "SDL_HasEvent", cdecl.}
+
+ +
@}
+Checks to see if certain event types are in the event queue.
+ + +
+ +
proc hasEvents(minType: Uint32; maxType: Uint32): bool {...}{.importc: "SDL_HasEvents", cdecl.}
+
+ + + +
+ +
proc flushEvent(kind: Uint32) {...}{.importc: "SDL_FlushEvent", cdecl.}
+
+ +
This function clears events from the event queue
+  This function only affects currently queued events. If you want to make
+  sure that all pending OS events are flushed, you can call SDL_PumpEvents()
+  on the main thread immediately before the flush call.
+ + +
+ +
proc flushEvents(minType: Uint32; maxType: Uint32) {...}{.importc: "SDL_FlushEvents", cdecl.}
+
+ + + +
+ +
proc pollEvent(event: ptr Event): cint {...}{.importc: "SDL_PollEvent", cdecl.}
+
+ +
\brief Polls for currently pending events.
+  
+  \return 1 if there are any pending events, or 0 if there are none available.
+  
+  \param event If not NULL, the next event is removed from the queue and
+               stored in that area.
+ + +
+ +
proc waitEvent(event: ptr Event): cint {...}{.importc: "SDL_WaitEvent", cdecl.}
+
+ +
\brief Waits indefinitely for the next available event.
+  
+  \return 1, or 0 if there was an error while waiting for events.
+  
+  \param event If not NULL, the next event is removed from the queue and
+               stored in that area.
+ + +
+ +
proc waitEventTimeout(event: ptr Event; timeout: cint): cint {...}{.
+    importc: "SDL_WaitEventTimeout", cdecl.}
+
+ +
\brief Waits until the specified timeout (in milliseconds) for the next
+         available event.
+  
+  \return 1, or 0 if there was an error while waiting for events.
+  
+  \param event If not NULL, the next event is removed from the queue and
+               stored in that area.
+  \param timeout The timeout (in milliseconds) to wait for next event.
+ + +
+ +
proc pushEvent(event: ptr Event): cint {...}{.importc: "SDL_PushEvent", cdecl.}
+
+ +
\brief Add an event to the event queue.
+  
+  \return 1 on success, 0 if the event was filtered, or -1 if the event queue
+          was full or there was some other error.
+ + +
+ +
proc setEventFilter(filter: EventFilter; userdata: pointer) {...}{.
+    importc: "SDL_SetEventFilter", cdecl.}
+
+ +
Sets up a filter to process all events before they change internal state and
+  are posted to the internal event queue.
+  
+  The filter is prototyped as:
+  \code
+      int SDL_EventFilter(voiduserdata, SDL_Event event);
+  \endcode
+  
+  If the filter returns 1, then the event will be added to the internal queue.
+  If it returns 0, then the event will be dropped from the queue, but the
+  internal state will still be updated.  This allows selective filtering of
+  dynamically arriving events.
+  
+  \warning  Be very careful of what you do in the event filter function, as
+            it may run in a different thread!
+  
+  There is one caveat when dealing with the ::SDL_QuitEvent event type.  The
+  event filter is only called when the window manager desires to close the
+  application window.  If the event filter returns 1, then the window will
+  be closed, otherwise the window will remain open if possible.
+  
+  If the quit event is generated by an interrupt signal, it will bypass the
+  internal queue and be delivered to the application at the next event poll.
+ + +
+ +
proc getEventFilter(filter: ptr EventFilter; userdata: ptr pointer): bool {...}{.
+    importc: "SDL_GetEventFilter", cdecl.}
+
+ +
Return the current event filter - can be used to "chain" filters.
+  If there is no event filter set, this function returns SDL_FALSE.
+ + +
+ +
proc addEventWatch(filter: EventFilter; userdata: pointer) {...}{.
+    importc: "SDL_AddEventWatch", cdecl.}
+
+ +
Add a function which is called when an event is added to the queue.
+ + +
+ +
proc delEventWatch(filter: EventFilter; userdata: pointer) {...}{.
+    importc: "SDL_DelEventWatch", cdecl.}
+
+ +
Remove an event watch function added with SDL_AddEventWatch()
+ + +
+ +
proc filterEvents(filter: EventFilter; userdata: pointer) {...}{.
+    importc: "SDL_FilterEvents", cdecl.}
+
+ +
Run the filter function on the current event queue, removing any
+  events for which the filter returns 0.
+ + +
+ +
proc eventState(kind: Uint32; state: cint): Uint8 {...}{.importc: "SDL_EventState", cdecl.}
+
+ +
This function allows you to set the state of processing certain events.
+   - If \c state is set to ::SDL_IGNORE, that event will be automatically
+     dropped from the event queue and will not be filtered.
+   - If \c state is set to ::SDL_ENABLE, that event will be processed
+     normally.
+   - If \c state is set to ::SDL_QUERY, SDL_EventState() will return the
+     current processing state of the specified event.
+ + +
+ +
proc registerEvents(numevents: cint): Uint32 {...}{.importc: "SDL_RegisterEvents", cdecl.}
+
+ +
This function allocates a set of user-defined events, and returns
+  the beginning event number for that set of events.
+  
+  If there aren't enough user-defined events left, this function
+  returns (Uint32)-1
+ + +
+ +
proc getBasePath(): cstring {...}{.importc: "SDL_GetBasePath", cdecl.}
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+\brief Get the path where the application resides.
+ 
+ Get the "base path". This is the directory where the application was run
+  from, which is probably the installation directory, and may or may not
+  be the process's current working directory.
+ 
+ This returns an absolute path in UTF-8 encoding, and is guaranteed to
+  end with a path separator ('\\' on Windows, '/' most other places).
+ 
+ The pointer returned by this function is owned by you. Please call
+  SDL_free() on the pointer when you are done with it, or it will be a
+  memory leak. This is not necessarily a fast call, though, so you should
+  call this once near startup and save the string if you need it.
+ 
+ Some platforms can't determine the application's path, and on other
+  platforms, this might be meaningless. In such cases, this function will
+  return NULL.
+  
+  \return String of base dir in UTF-8 encoding, or NULL on error.
+ 
+ \sa SDL_GetPrefPath
+ + +
+ +
proc getPrefPath(org: cstring; app: cstring): cstring {...}{.importc: "SDL_GetPrefPath",
+    cdecl.}
+
+ +
\brief Get the user-and-app-specific path where files can be written.
+ 
+ Get the "pref dir". This is meant to be where users can write personal
+  files (preferences and save games, etc) that are specific to your
+  application. This directory is unique per user, per application.
+ 
+ This function will decide the appropriate location in the native filesystem,
+  create the directory if necessary, and return a string of the absolute
+  path to the directory in UTF-8 encoding.
+ 
+ On Windows, the string might look like:
+  "C:\\Users\\bob\\AppData\\Roaming\\My Company\\My Program Name\\"
+ 
+ On Linux, the string might look like:
+  "/home/bob/.local/share/My Program Name/"
+ 
+ On Mac OS X, the string might look like:
+  "/Users/bob/Library/Application Support/My Program Name/"
+ 
+ (etc.)
+ 
+ You specify the name of your organization (if it's not a real organization,
+  your name or an Internet domain you own might do) and the name of your
+  application. These should be untranslated proper names.
+ 
+ Both the org and app strings may become part of a directory name, so
+  please follow these rules:
+    
+    - Try to use the same org string (including case-sensitivity) for
+      all your applications that use this function.
+    - Always use a unique app string for each one, and make sure it never
+      changes for an app once you've decided on it.
+    - Unicode characters are legal, as long as it's UTF-8 encoded, but...
+    - ...only use letters, numbers, and spaces. Avoid punctuation like
+      "Game Name 2: Bad Guy's Revenge!" ... "Game Name 2" is sufficient.
+ 
+ This returns an absolute path in UTF-8 encoding, and is guaranteed to
+  end with a path separator ('\\' on Windows, '/' most other places).
+ 
+ The pointer returned by this function is owned by you. Please call
+  SDL_free() on the pointer when you are done with it, or it will be a
+  memory leak. This is not necessarily a fast call, though, so you should
+  call this once near startup and save the string if you need it.
+ 
+ You should assume the path returned by this function is the only safe
+  place to write files (and that SDL_GetBasePath(), while it might be
+  writable, or even the parent of the returned path, aren't where you
+  should be writing things).
+ 
+ Some platforms can't determine the pref path, and on other
+  platforms, this might be meaningless. In such cases, this function will
+  return NULL.
+   
+   \param org The name of your organization.
+   \param app The name of your application.
+  \return UTF-8 string of user dir in platform-dependent notation. NULL
+          if there's a problem (creating directory failed, etc).
+ 
+ \sa SDL_GetBasePath
+ + +
+ +
proc numHaptics(): cint {...}{.importc: "SDL_NumHaptics", cdecl.}
+
+ +
Function prototypes
+\brief Count the number of haptic devices attached to the system.
+  
+  \return Number of haptic devices detected on the system.
+ + +
+ +
proc hapticName(deviceIndex: cint): cstring {...}{.importc: "SDL_HapticName", cdecl.}
+
+ +
\brief Get the implementation dependent name of a haptic device.
+  
+  This can be called before any joysticks are opened.
+  If no name can be found, this function returns NULL.
+  
+  \param device_index Index of the device to get its name.
+  \return Name of the device or NULL on error.
+  
+  \sa SDL_NumHaptics
+ + +
+ +
proc hapticOpen(deviceIndex: cint): ptr Haptic {...}{.importc: "SDL_HapticOpen", cdecl.}
+
+ +
\brief Opens a haptic device for use.
+  
+  The index passed as an argument refers to the N'th haptic device on this
+  system.
+  
+  When opening a haptic device, its gain will be set to maximum and
+  autocenter will be disabled.  To modify these values use
+  SDL_HapticSetGain() and SDL_HapticSetAutocenter().
+  
+  \param device_index Index of the device to open.
+  \return Device identifier or NULL on error.
+  
+  \sa SDL_HapticIndex
+  \sa SDL_HapticOpenFromMouse
+  \sa SDL_HapticOpenFromJoystick
+  \sa SDL_HapticClose
+  \sa SDL_HapticSetGain
+  \sa SDL_HapticSetAutocenter
+  \sa SDL_HapticPause
+  \sa SDL_HapticStopAll
+ + +
+ +
proc hapticOpened(deviceIndex: cint): cint {...}{.importc: "SDL_HapticOpened", cdecl.}
+
+ +
\brief Checks if the haptic device at index has been opened.
+  
+  \param device_index Index to check to see if it has been opened.
+  \return 1 if it has been opened or 0 if it hasn't.
+  
+  \sa SDL_HapticOpen
+  \sa SDL_HapticIndex
+ + +
+ +
proc hapticIndex(haptic: ptr Haptic): cint {...}{.importc: "SDL_HapticIndex", cdecl.}
+
+ +
\brief Gets the index of a haptic device.
+  
+  \param haptic Haptic device to get the index of.
+  \return The index of the haptic device or -1 on error.
+  
+  \sa SDL_HapticOpen
+  \sa SDL_HapticOpened
+ + +
+ +
proc mouseIsHaptic(): cint {...}{.importc: "SDL_MouseIsHaptic", cdecl.}
+
+ +
\brief Gets whether or not the current mouse has haptic capabilities.
+  
+  \return SDL_TRUE if the mouse is haptic, SDL_FALSE if it isn't.
+  
+  \sa SDL_HapticOpenFromMouse
+ + +
+ +
proc hapticOpenFromMouse(): ptr Haptic {...}{.importc: "SDL_HapticOpenFromMouse", cdecl.}
+
+ +
\brief Tries to open a haptic device from the current mouse.
+  
+  \return The haptic device identifier or NULL on error.
+  
+  \sa SDL_MouseIsHaptic
+  \sa SDL_HapticOpen
+ + +
+ +
proc joystickIsHaptic(joystick: ptr Joystick): cint {...}{.
+    importc: "SDL_JoystickIsHaptic", cdecl.}
+
+ +
\brief Checks to see if a joystick has haptic features.
+  
+  \param joystick Joystick to test for haptic capabilities.
+  \return SDL_TRUE if the joystick is haptic, SDL_FALSE if it isn't
+          or -1 if an error occurred.
+  
+  \sa SDL_HapticOpenFromJoystick
+ + +
+ +
proc hapticOpenFromJoystick(joystick: ptr Joystick): ptr Haptic {...}{.
+    importc: "SDL_HapticOpenFromJoystick", cdecl.}
+
+ +
\brief Opens a haptic device for use from a joystick device.
+  
+  You must still close the haptic device separately.  It will not be closed
+  with the joystick.
+  
+  When opening from a joystick you should first close the haptic device before
+  closing the joystick device.  If not, on some implementations the haptic
+  device will also get unallocated and you'll be unable to use force feedback
+  on that device.
+  
+  \param joystick Joystick to create a haptic device from.
+  \return A valid haptic device identifier on success or NULL on error.
+  
+  \sa SDL_HapticOpen
+  \sa SDL_HapticClose
+ + +
+ +
proc hapticClose(haptic: ptr Haptic) {...}{.importc: "SDL_HapticClose", cdecl.}
+
+ +
\brief Closes a haptic device previously opened with SDL_HapticOpen().
+  
+  \param haptic Haptic device to close.
+ + +
+ +
proc hapticNumEffects(haptic: ptr Haptic): cint {...}{.importc: "SDL_HapticNumEffects",
+    cdecl.}
+
+ +
\brief Returns the number of effects a haptic device can store.
+  
+  On some platforms this isn't fully supported, and therefore is an
+  approximation.  Always check to see if your created effect was actually
+  created and do not rely solely on SDL_HapticNumEffects().
+  
+  \param haptic The haptic device to query effect max.
+  \return The number of effects the haptic device can store or
+          -1 on error.
+  
+  \sa SDL_HapticNumEffectsPlaying
+  \sa SDL_HapticQuery
+ + +
+ +
proc hapticNumEffectsPlaying(haptic: ptr Haptic): cint {...}{.
+    importc: "SDL_HapticNumEffectsPlaying", cdecl.}
+
+ +
\brief Returns the number of effects a haptic device can play at the same
+         time.
+  
+  This is not supported on all platforms, but will always return a value.
+  Added here for the sake of completeness.
+  
+  \param haptic The haptic device to query maximum playing effects.
+  \return The number of effects the haptic device can play at the same time
+          or -1 on error.
+  
+  \sa SDL_HapticNumEffects
+  \sa SDL_HapticQuery
+ + +
+ +
proc hapticQuery(haptic: ptr Haptic): cuint {...}{.importc: "SDL_HapticQuery", cdecl.}
+
+ +
\brief Gets the haptic device's supported features in bitwise manner.
+  
+  Example:
+  \code
+  if (SDL_HapticQuery(haptic) & SDL_HAPTIC_CONSTANT) {
+      printf("We have constant haptic effect!\n");
+  }
+  \endcode
+  
+  \param haptic The haptic device to query.
+  \return Haptic features in bitwise manner (OR'd).
+  
+  \sa SDL_HapticNumEffects
+  \sa SDL_HapticEffectSupported
+ + +
+ +
proc hapticNumAxes(haptic: ptr Haptic): cint {...}{.importc: "SDL_HapticNumAxes", cdecl.}
+
+ +
\brief Gets the number of haptic axes the device has.
+  
+  \sa SDL_HapticDirection
+ + +
+ +
proc hapticEffectSupported(haptic: ptr Haptic; effect: ptr HapticEffect): cint {...}{.
+    importc: "SDL_HapticEffectSupported", cdecl.}
+
+ +
\brief Checks to see if effect is supported by haptic.
+  
+  \param haptic Haptic device to check on.
+  \param effect Effect to check to see if it is supported.
+  \return SDL_TRUE if effect is supported, SDL_FALSE if it isn't or -1 on error.
+  
+  \sa SDL_HapticQuery
+  \sa SDL_HapticNewEffect
+ + +
+ +
proc hapticNewEffect(haptic: ptr Haptic; effect: ptr HapticEffect): cint {...}{.
+    importc: "SDL_HapticNewEffect", cdecl.}
+
+ +
\brief Creates a new haptic effect on the device.
+  
+  \param haptic Haptic device to create the effect on.
+  \param effect Properties of the effect to create.
+  \return The identifier of the effect on success or -1 on error.
+  
+  \sa SDL_HapticUpdateEffect
+  \sa SDL_HapticRunEffect
+  \sa SDL_HapticDestroyEffect
+ + +
+ +
proc hapticUpdateEffect(haptic: ptr Haptic; effect: cint; data: ptr HapticEffect): cint {...}{.
+    importc: "SDL_HapticUpdateEffect", cdecl.}
+
+ +
\brief Updates the properties of an effect.
+  
+  Can be used dynamically, although behavior when dynamically changing
+  direction may be strange.  Specifically the effect may reupload itself
+  and start playing from the start.  You cannot change the type either when
+  running SDL_HapticUpdateEffect().
+  
+  \param haptic Haptic device that has the effect.
+  \param effect Identifier of the effect to update.
+  \param data New effect properties to use.
+  \return 0 on success or -1 on error.
+  
+  \sa SDL_HapticNewEffect
+  \sa SDL_HapticRunEffect
+  \sa SDL_HapticDestroyEffect
+ + +
+ +
proc hapticRunEffect(haptic: ptr Haptic; effect: cint; iterations: Uint32): cint {...}{.
+    importc: "SDL_HapticRunEffect", cdecl.}
+
+ +
\brief Runs the haptic effect on its associated haptic device.
+  
+  If iterations are ::SDL_HAPTIC_INFINITY, it'll run the effect over and over
+  repeating the envelope (attack and fade) every time.  If you only want the
+  effect to last forever, set ::SDL_HAPTIC_INFINITY in the effect's length
+  parameter.
+  
+  \param haptic Haptic device to run the effect on.
+  \param effect Identifier of the haptic effect to run.
+  \param iterations Number of iterations to run the effect. Use
+         ::SDL_HAPTIC_INFINITY for infinity.
+  \return 0 on success or -1 on error.
+  
+  \sa SDL_HapticStopEffect
+  \sa SDL_HapticDestroyEffect
+  \sa SDL_HapticGetEffectStatus
+ + +
+ +
proc hapticStopEffect(haptic: ptr Haptic; effect: cint): cint {...}{.
+    importc: "SDL_HapticStopEffect", cdecl.}
+
+ +
\brief Stops the haptic effect on its associated haptic device.
+  
+  \param haptic Haptic device to stop the effect on.
+  \param effect Identifier of the effect to stop.
+  \return 0 on success or -1 on error.
+  
+  \sa SDL_HapticRunEffect
+  \sa SDL_HapticDestroyEffect
+ + +
+ +
proc hapticDestroyEffect(haptic: ptr Haptic; effect: cint) {...}{.
+    importc: "SDL_HapticDestroyEffect", cdecl.}
+
+ +
\brief Destroys a haptic effect on the device.
+  
+  This will stop the effect if it's running.  Effects are automatically
+  destroyed when the device is closed.
+  
+  \param haptic Device to destroy the effect on.
+  \param effect Identifier of the effect to destroy.
+  
+  \sa SDL_HapticNewEffect
+ + +
+ +
proc hapticGetEffectStatus(haptic: ptr Haptic; effect: cint): cint {...}{.
+    importc: "SDL_HapticGetEffectStatus", cdecl.}
+
+ +
\brief Gets the status of the current effect on the haptic device.
+  
+  Device must support the ::SDL_HAPTIC_STATUS feature.
+  
+  \param haptic Haptic device to query the effect status on.
+  \param effect Identifier of the effect to query its status.
+  \return 0 if it isn't playing, 1 if it is playing or -1 on error.
+  
+  \sa SDL_HapticRunEffect
+  \sa SDL_HapticStopEffect
+ + +
+ +
proc hapticSetGain(haptic: ptr Haptic; gain: cint): cint {...}{.
+    importc: "SDL_HapticSetGain", cdecl.}
+
+ +
\brief Sets the global gain of the device.
+  
+  Device must support the ::SDL_HAPTIC_GAIN feature.
+  
+  The user may specify the maximum gain by setting the environment variable
+  SDL_HAPTIC_GAIN_MAX which should be between 0 and 100.  All calls to
+  SDL_HapticSetGain() will scale linearly using SDL_HAPTIC_GAIN_MAX as the
+  maximum.
+  
+  \param haptic Haptic device to set the gain on.
+  \param gain Value to set the gain to, should be between 0 and 100.
+  \return 0 on success or -1 on error.
+  
+  \sa SDL_HapticQuery
+ + +
+ +
proc hapticSetAutocenter(haptic: ptr Haptic; autocenter: cint): cint {...}{.
+    importc: "SDL_HapticSetAutocenter", cdecl.}
+
+ +
\brief Sets the global autocenter of the device.
+  
+  Autocenter should be between 0 and 100.  Setting it to 0 will disable
+  autocentering.
+  
+  Device must support the ::SDL_HAPTIC_AUTOCENTER feature.
+  
+  \param haptic Haptic device to set autocentering on.
+  \param autocenter Value to set autocenter to, 0 disables autocentering.
+  \return 0 on success or -1 on error.
+  
+  \sa SDL_HapticQuery
+ + +
+ +
proc hapticPause(haptic: ptr Haptic): cint {...}{.importc: "SDL_HapticPause", cdecl.}
+
+ +
\brief Pauses a haptic device.
+  
+  Device must support the ::SDL_HAPTIC_PAUSE feature.  Call
+  SDL_HapticUnpause() to resume playback.
+  
+  Do not modify the effects nor add new ones while the device is paused.
+  That can cause all sorts of weird errors.
+  
+  \param haptic Haptic device to pause.
+  \return 0 on success or -1 on error.
+  
+  \sa SDL_HapticUnpause
+ + +
+ +
proc hapticUnpause(haptic: ptr Haptic): cint {...}{.importc: "SDL_HapticUnpause", cdecl.}
+
+ +
\brief Unpauses a haptic device.
+  
+  Call to unpause after SDL_HapticPause().
+  
+  \param haptic Haptic device to unpause.
+  \return 0 on success or -1 on error.
+  
+  \sa SDL_HapticPause
+ + +
+ +
proc hapticStopAll(haptic: ptr Haptic): cint {...}{.importc: "SDL_HapticStopAll", cdecl.}
+
+ +
\brief Stops all the currently playing effects on a haptic device.
+  
+  \param haptic Haptic device to stop.
+  \return 0 on success or -1 on error.
+ + +
+ +
proc hapticRumbleSupported(haptic: ptr Haptic): cint {...}{.
+    importc: "SDL_HapticRumbleSupported", cdecl.}
+
+ +
\brief Checks to see if rumble is supported on a haptic device.
+  
+  \param haptic Haptic device to check to see if it supports rumble.
+  \return SDL_TRUE if effect is supported, SDL_FALSE if it isn't or -1 on error.
+  
+  \sa SDL_HapticRumbleInit
+  \sa SDL_HapticRumblePlay
+  \sa SDL_HapticRumbleStop
+ + +
+ +
proc hapticRumbleInit(haptic: ptr Haptic): cint {...}{.importc: "SDL_HapticRumbleInit",
+    cdecl.}
+
+ +
\brief Initializes the haptic device for simple rumble playback.
+  
+  \param haptic Haptic device to initialize for simple rumble playback.
+  \return 0 on success or -1 on error.
+  
+  \sa SDL_HapticOpen
+  \sa SDL_HapticRumbleSupported
+  \sa SDL_HapticRumblePlay
+  \sa SDL_HapticRumbleStop
+ + +
+ +
proc hapticRumblePlay(haptic: ptr Haptic; strength: cfloat; length: Uint32): cint {...}{.
+    importc: "SDL_HapticRumblePlay", cdecl.}
+
+ +
\brief Runs simple rumble on a haptic device
+  
+  \param haptic Haptic device to play rumble effect on.
+  \param strength Strength of the rumble to play as a 0-1 float value.
+  \param length Length of the rumble to play in milliseconds.
+  \return 0 on success or -1 on error.
+  
+  \sa SDL_HapticRumbleSupported
+  \sa SDL_HapticRumbleInit
+  \sa SDL_HapticRumbleStop
+ + +
+ +
proc hapticRumbleStop(haptic: ptr Haptic): cint {...}{.importc: "SDL_HapticRumbleStop",
+    cdecl.}
+
+ +
\brief Stops the simple rumble on a haptic device.
+  
+  \param haptic Haptic to stop the rumble on.
+  \return 0 on success or -1 on error.
+  
+  \sa SDL_HapticRumbleSupported
+  \sa SDL_HapticRumbleInit
+  \sa SDL_HapticRumblePlay
+ + +
+ +
proc setHintWithPriority(name: cstring; value: cstring; priority: HintPriority): bool {...}{.
+    importc: "SDL_SetHintWithPriority", cdecl.}
+
+ +
\brief Set a hint with a specific priority
+  
+  The priority controls the behavior when setting a hint that already
+  has a value.  Hints will replace existing hints of their priority and
+  lower.  Environment variables are considered to have override priority.
+  
+  \return SDL_TRUE if the hint was set, SDL_FALSE otherwise
+ + +
+ +
proc setHint(name: cstring; value: cstring): bool {...}{.importc: "SDL_SetHint", cdecl.}
+
+ +
\brief Set a hint with normal priority
+  
+  \return SDL_TRUE if the hint was set, SDL_FALSE otherwise
+ + +
+ +
proc getHint(name: cstring): cstring {...}{.importc: "SDL_GetHint", cdecl.}
+
+ +
\brief Get a hint
+  
+  \return The string value of a hint variable.
+ + +
+ +
proc getHintBoolean(name: cstring; defaultValue: bool): bool {...}{.
+    importc: "SDL_GetHintBoolean", cdecl.}
+
+ +
\brief Get a hint
+  
+  \return The boolean value of a hint variable.
+ + +
+ +
proc addHintCallback(name: cstring; callback: HintCallback; userdata: pointer) {...}{.
+    importc: "SDL_AddHintCallback", cdecl.}
+
+ +
\brief Add a function to watch a particular hint
+  
+  \param name The hint to watch
+  \param callback The function to call when the hint value changes
+  \param userdata A pointer to pass to the callback function
+ + +
+ +
proc delHintCallback(name: cstring; callback: HintCallback; userdata: pointer) {...}{.
+    importc: "SDL_DelHintCallback", cdecl.}
+
+ +
\brief Remove a function watching a particular hint
+  
+  \param name The hint being watched
+  \param callback The function being called when the hint value changes
+  \param userdata A pointer being passed to the callback function
+ + +
+ +
proc clearHints() {...}{.importc: "SDL_ClearHints", cdecl.}
+
+ +
\brief  Clear all hints
+  
+  This function is called during SDL_Quit() to free stored hints.
+ + +
+ +
proc loadObject(sofile: cstring): pointer {...}{.importc: "SDL_LoadObject", cdecl.}
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+This function dynamically loads a shared object and returns a pointer
+  to the object handle (or NULL if there was an error).
+  The 'sofile' parameter is a system dependent name of the object file.
+ + +
+ +
proc loadFunction(handle: pointer; name: cstring): pointer {...}{.
+    importc: "SDL_LoadFunction", cdecl.}
+
+ +
Given an object handle, this function looks up the address of the
+  named function in the shared object and returns it.  This address
+  is no longer valid after calling SDL_UnloadObject().
+ + +
+ +
proc unloadObject(handle: pointer) {...}{.importc: "SDL_UnloadObject", cdecl.}
+
+ +
Unload a shared object from memory.
+ + +
+ +
proc logSetAllPriority(priority: LogPriority) {...}{.importc: "SDL_LogSetAllPriority",
+    cdecl.}
+
+ +
\brief Set the priority of all log categories
+ + +
+ +
proc logSetPriority(category: cint; priority: LogPriority) {...}{.
+    importc: "SDL_LogSetPriority", cdecl.}
+
+ +
\brief Set the priority of a particular log category
+ + +
+ +
proc logGetPriority(category: cint): LogPriority {...}{.importc: "SDL_LogGetPriority",
+    cdecl.}
+
+ +
\brief Get the priority of a particular log category
+ + +
+ +
proc logResetPriorities() {...}{.importc: "SDL_LogResetPriorities", cdecl.}
+
+ +
\brief Reset all priorities to default.
+  
+  \note This is called in SDL_Quit().
+ + +
+ +
proc logVerbose(category: cint; fmt: cstring) {...}{.importc: "SDL_LogVerbose", cdecl,
+    varargs.}
+
+ +
\brief Log a message with SDL_LOG_PRIORITY_VERBOSE
+ + +
+ +
proc logDebug(category: cint; fmt: cstring) {...}{.importc: "SDL_LogDebug", cdecl, varargs.}
+
+ +
\brief Log a message with SDL_LOG_PRIORITY_DEBUG
+ + +
+ +
proc logInfo(category: cint; fmt: cstring) {...}{.importc: "SDL_LogInfo", cdecl, varargs.}
+
+ +
\brief Log a message with SDL_LOG_PRIORITY_INFO
+ + +
+ +
proc logWarn(category: cint; fmt: cstring) {...}{.importc: "SDL_LogWarn", cdecl, varargs.}
+
+ +
\brief Log a message with SDL_LOG_PRIORITY_WARN
+ + +
+ +
proc logError(category: cint; fmt: cstring) {...}{.importc: "SDL_LogError", cdecl, varargs.}
+
+ +
\brief Log a message with SDL_LOG_PRIORITY_ERROR
+ + +
+ +
proc logCritical(category: cint; fmt: cstring) {...}{.importc: "SDL_LogCritical", cdecl,
+    varargs.}
+
+ +
\brief Log a message with SDL_LOG_PRIORITY_CRITICAL
+ + +
+ +
proc logMessage(category: cint; priority: LogPriority; fmt: cstring) {...}{.
+    importc: "SDL_LogMessage", cdecl, varargs.}
+
+ +
\brief Log a message with the specified category and priority.
+ + +
+ +
proc logMessageV(category: cint; priority: LogPriority; fmt: cstring; ap: va_list) {...}{.
+    importc: "SDL_LogMessageV", cdecl.}
+
+ +
\brief Log a message with the specified category and priority.
+ + +
+ +
proc logGetOutputFunction(callback: ptr LogOutputFunction; userdata: ptr pointer) {...}{.
+    importc: "SDL_LogGetOutputFunction", cdecl.}
+
+ +
\brief Get the current log output function.
+ + +
+ +
proc logSetOutputFunction(callback: LogOutputFunction; userdata: pointer) {...}{.
+    importc: "SDL_LogSetOutputFunction", cdecl.}
+
+ +
\brief This function allows you to replace the default log output
+         function with one of your own.
+ + +
+ +
proc showMessageBox(messageboxdata: ptr MessageBoxData; buttonid: ptr cint): cint {...}{.
+    importc: "SDL_ShowMessageBox", cdecl.}
+
+ +
\brief Create a modal message box.
+  
+  \param messageboxdata The SDL_MessageBoxData structure with title, text, etc.
+  \param buttonid The pointer to which user id of hit button should be copied.
+  
+  \return -1 on error, otherwise 0 and buttonid contains user id of button
+          hit or -1 if dialog was closed.
+  
+  \note This function should be called on the thread that created the parent
+        window, or on the main thread if the messagebox has no parent.  It will
+        block execution of that thread until the user clicks a button or
+        closes the messagebox.
+ + +
+ +
proc showSimpleMessageBox(flags: Uint32; title: cstring; message: cstring;
+                         window: ptr Window): cint {...}{.
+    importc: "SDL_ShowSimpleMessageBox", cdecl.}
+
+ +
\brief Create a simple modal message box
+  
+  \param flags    ::SDL_MessageBoxFlags
+  \param title    UTF-8 title text
+  \param message  UTF-8 message text
+  \param window   The parent window, or NULL for no parent
+  
+  \return 0 on success, -1 on error
+  
+  \sa SDL_ShowMessageBox
+ + +
+ +
proc metal_CreateView(window: ptr Window): MetalView {...}{.
+    importc: "SDL_Metal_CreateView", cdecl.}
+
+ +
\name Metal support functions
+@{
+\brief Create a CAMetalLayer-backed NSView/UIView and attach it to the
+        specified window.
+  
+  On macOS, this doesnot associate a MTLDevice with the CAMetalLayer on its
+  own. It is up to user code to do that.
+  
+  The returned handle can be casted directly to a NSView or UIView, and the
+  CAMetalLayer can be accessed from the view's 'layer' property.
+  
+  \code
+  SDL_MetalView metalview = SDL_Metal_CreateView(window);
+  UIViewuiview = (__bridge UIView)metalview;
+  CAMetalLayermetallayer = (CAMetalLayer)uiview.layer;
+ [...]
+  SDL_Metal_DestroyView(metalview);
+  \endcode
+  
+  \sa SDL_Metal_DestroyView
+ + +
+ +
proc metal_DestroyView(view: MetalView) {...}{.importc: "SDL_Metal_DestroyView", cdecl.}
+
+ +
\brief Destroy an existing SDL_MetalView object.
+  
+  This should be called before SDL_DestroyWindow, if SDL_Metal_CreateView was
+  called after SDL_CreateWindow.
+  
+  \sa SDL_Metal_CreateView
+ + +
+ +
proc getPowerInfo(secs: ptr cint; pct: ptr cint): PowerState {...}{.
+    importc: "SDL_GetPowerInfo", cdecl.}
+
+ +
\brief Get the current power supply details.
+  
+  \param secs Seconds of battery life left. You can pass a NULL here if
+              you don't care. Will return -1 if we can't determine a
+              value, or we're not running on a battery.
+  
+  \param pct Percentage of battery life left, between 0 and 100. You can
+             pass a NULL here if you don't care. Will return -1 if we
+             can't determine a value, or we're not running on a battery.
+  
+  \return The state of the battery (if any).
+ + +
+ +
proc getNumRenderDrivers(): cint {...}{.importc: "SDL_GetNumRenderDrivers", cdecl.}
+
+ +
Function prototypes
+\brief Get the number of 2D rendering drivers available for the current
+         display.
+  
+  A render driver is a set of code that handles rendering and texture
+  management on a particular display.  Normally there is only one, but
+  some drivers may have several available with different capabilities.
+  
+  \sa SDL_GetRenderDriverInfo()
+  \sa SDL_CreateRenderer()
+ + +
+ +
proc getRenderDriverInfo(index: cint; info: ptr RendererInfo): cint {...}{.
+    importc: "SDL_GetRenderDriverInfo", cdecl.}
+
+ +
\brief Get information about a specific 2D rendering driver for the current
+         display.
+  
+  \param index The index of the driver to query information about.
+  \param info  A pointer to an SDL_RendererInfo struct to be filled with
+               information on the rendering driver.
+  
+  \return 0 on success, -1 if the index was out of range.
+  
+  \sa SDL_CreateRenderer()
+ + +
+ +
proc createWindowAndRenderer(width: cint; height: cint; windowFlags: Uint32;
+                            window: ptr ptr Window; renderer: ptr ptr Renderer): cint {...}{.
+    importc: "SDL_CreateWindowAndRenderer", cdecl.}
+
+ +
\brief Create a window and default renderer
+  
+  \param width    The width of the window
+  \param height   The height of the window
+  \param window_flags The flags used to create the window
+  \param window   A pointer filled with the window, or NULL on error
+  \param renderer A pointer filled with the renderer, or NULL on error
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc createRenderer(window: ptr Window; index: cint; flags: Uint32): ptr Renderer {...}{.
+    importc: "SDL_CreateRenderer", cdecl.}
+
+ +
\brief Create a 2D rendering context for a window.
+  
+  \param window The window where rendering is displayed.
+  \param index    The index of the rendering driver to initialize, or -1 to
+                  initialize the first one supporting the requested flags.
+  \param flags    ::SDL_RendererFlags.
+  
+  \return A valid rendering context or NULL if there was an error.
+  
+  \sa SDL_CreateSoftwareRenderer()
+  \sa SDL_GetRendererInfo()
+  \sa SDL_DestroyRenderer()
+ + +
+ +
proc createSoftwareRenderer(surface: ptr Surface): ptr Renderer {...}{.
+    importc: "SDL_CreateSoftwareRenderer", cdecl.}
+
+ +
\brief Create a 2D software rendering context for a surface.
+  
+  \param surface The surface where rendering is done.
+  
+  \return A valid rendering context or NULL if there was an error.
+  
+  \sa SDL_CreateRenderer()
+  \sa SDL_DestroyRenderer()
+ + +
+ +
proc getRenderer(window: ptr Window): ptr Renderer {...}{.importc: "SDL_GetRenderer", cdecl.}
+
+ +
\brief Get the renderer associated with a window.
+ + +
+ +
proc getRendererInfo(renderer: ptr Renderer; info: ptr RendererInfo): cint {...}{.
+    importc: "SDL_GetRendererInfo", cdecl.}
+
+ +
\brief Get information about a rendering context.
+ + +
+ +
proc getRendererOutputSize(renderer: ptr Renderer; w: ptr cint; h: ptr cint): cint {...}{.
+    importc: "SDL_GetRendererOutputSize", cdecl.}
+
+ +
\brief Get the output size in pixels of a rendering context.
+ + +
+ +
proc createTexture(renderer: ptr Renderer; format: Uint32; access: cint; w: cint; h: cint): ptr Texture {...}{.
+    importc: "SDL_CreateTexture", cdecl.}
+
+ +
\brief Create a texture for a rendering context.
+  
+  \param renderer The renderer.
+  \param format The format of the texture.
+  \param access One of the enumerated values in ::SDL_TextureAccess.
+  \param w      The width of the texture in pixels.
+  \param h      The height of the texture in pixels.
+  
+  \return The created texture is returned, or NULL if no rendering context was
+          active,  the format was unsupported, or the width or height were out
+          of range.
+  
+  \note The contents of the texture are not defined at creation.
+  
+  \sa SDL_QueryTexture()
+  \sa SDL_UpdateTexture()
+  \sa SDL_DestroyTexture()
+ + +
+ +
proc createTextureFromSurface(renderer: ptr Renderer; surface: ptr Surface): ptr Texture {...}{.
+    importc: "SDL_CreateTextureFromSurface", cdecl.}
+
+ +
\brief Create a texture from an existing surface.
+  
+  \param renderer The renderer.
+  \param surface The surface containing pixel data used to fill the texture.
+  
+  \return The created texture is returned, or NULL on error.
+  
+  \note The surface is not modified or freed by this function.
+  
+  \sa SDL_QueryTexture()
+  \sa SDL_DestroyTexture()
+ + +
+ +
proc queryTexture(texture: ptr Texture; format: ptr Uint32; access: ptr cint; w: ptr cint;
+                 h: ptr cint): cint {...}{.importc: "SDL_QueryTexture", cdecl.}
+
+ +
\brief Query the attributes of a texture
+  
+  \param texture A texture to be queried.
+  \param format  A pointer filled in with the raw format of the texture.  The
+                 actual format may differ, but pixel transfers will use this
+                 format.
+  \param access  A pointer filled in with the actual access to the texture.
+  \param w       A pointer filled in with the width of the texture in pixels.
+  \param h       A pointer filled in with the height of the texture in pixels.
+  
+  \return 0 on success, or -1 if the texture is not valid.
+ + +
+ +
proc setTextureColorMod(texture: ptr Texture; r: Uint8; g: Uint8; b: Uint8): cint {...}{.
+    importc: "SDL_SetTextureColorMod", cdecl.}
+
+ +
\brief Set an additional color value used in render copy operations.
+  
+  \param texture The texture to update.
+  \param r       The red color value multiplied into copy operations.
+  \param g       The green color value multiplied into copy operations.
+  \param b       The blue color value multiplied into copy operations.
+  
+  \return 0 on success, or -1 if the texture is not valid or color modulation
+          is not supported.
+  
+  \sa SDL_GetTextureColorMod()
+ + +
+ +
proc getTextureColorMod(texture: ptr Texture; r: ptr Uint8; g: ptr Uint8; b: ptr Uint8): cint {...}{.
+    importc: "SDL_GetTextureColorMod", cdecl.}
+
+ +
\brief Get the additional color value used in render copy operations.
+  
+  \param texture The texture to query.
+  \param r         A pointer filled in with the current red color value.
+  \param g         A pointer filled in with the current green color value.
+  \param b         A pointer filled in with the current blue color value.
+  
+  \return 0 on success, or -1 if the texture is not valid.
+  
+  \sa SDL_SetTextureColorMod()
+ + +
+ +
proc setTextureAlphaMod(texture: ptr Texture; alpha: Uint8): cint {...}{.
+    importc: "SDL_SetTextureAlphaMod", cdecl.}
+
+ +
\brief Set an additional alpha value used in render copy operations.
+  
+  \param texture The texture to update.
+  \param alpha     The alpha value multiplied into copy operations.
+  
+  \return 0 on success, or -1 if the texture is not valid or alpha modulation
+          is not supported.
+  
+  \sa SDL_GetTextureAlphaMod()
+ + +
+ +
proc getTextureAlphaMod(texture: ptr Texture; alpha: ptr Uint8): cint {...}{.
+    importc: "SDL_GetTextureAlphaMod", cdecl.}
+
+ +
\brief Get the additional alpha value used in render copy operations.
+  
+  \param texture The texture to query.
+  \param alpha     A pointer filled in with the current alpha value.
+  
+  \return 0 on success, or -1 if the texture is not valid.
+  
+  \sa SDL_SetTextureAlphaMod()
+ + +
+ +
proc setTextureBlendMode(texture: ptr Texture; blendMode: BlendMode): cint {...}{.
+    importc: "SDL_SetTextureBlendMode", cdecl.}
+
+ +
\brief Set the blend mode used for texture copy operations.
+  
+  \param texture The texture to update.
+  \param blendMode ::SDL_BlendMode to use for texture blending.
+  
+  \return 0 on success, or -1 if the texture is not valid or the blend mode is
+          not supported.
+  
+  \note If the blend mode is not supported, the closest supported mode is
+        chosen.
+  
+  \sa SDL_GetTextureBlendMode()
+ + +
+ +
proc getTextureBlendMode(texture: ptr Texture; blendMode: ptr BlendMode): cint {...}{.
+    importc: "SDL_GetTextureBlendMode", cdecl.}
+
+ +
\brief Get the blend mode used for texture copy operations.
+  
+  \param texture   The texture to query.
+  \param blendMode A pointer filled in with the current blend mode.
+  
+  \return 0 on success, or -1 if the texture is not valid.
+  
+  \sa SDL_SetTextureBlendMode()
+ + +
+ +
proc setTextureScaleMode(texture: ptr Texture; scaleMode: ScaleMode): cint {...}{.
+    importc: "SDL_SetTextureScaleMode", cdecl.}
+
+ +
\brief Set the scale mode used for texture scale operations.
+  
+  \param texture The texture to update.
+  \param scaleMode ::SDL_ScaleMode to use for texture scaling.
+  
+  \return 0 on success, or -1 if the texture is not valid.
+  
+  \note If the scale mode is not supported, the closest supported mode is
+        chosen.
+  
+  \sa SDL_GetTextureScaleMode()
+ + +
+ +
proc getTextureScaleMode(texture: ptr Texture; scaleMode: ptr ScaleMode): cint {...}{.
+    importc: "SDL_GetTextureScaleMode", cdecl.}
+
+ +
\brief Get the scale mode used for texture scale operations.
+  
+  \param texture   The texture to query.
+  \param scaleMode A pointer filled in with the current scale mode.
+  
+  \return 0 on success, or -1 if the texture is not valid.
+  
+  \sa SDL_SetTextureScaleMode()
+ + +
+ +
proc updateTexture(texture: ptr Texture; rect: ptr Rect; pixels: pointer; pitch: cint): cint {...}{.
+    importc: "SDL_UpdateTexture", cdecl.}
+
+ +
\brief Update the given texture rectangle with new pixel data.
+  
+  \param texture   The texture to update
+  \param rect      A pointer to the rectangle of pixels to update, or NULL to
+                   update the entire texture.
+  \param pixels    The raw pixel data in the format of the texture.
+  \param pitch     The number of bytes in a row of pixel data, including padding between lines.
+  
+  The pixel data must be in the format of the texture. The pixel format can be
+  queried with SDL_QueryTexture.
+  
+  \return 0 on success, or -1 if the texture is not valid.
+  
+  \note This is a fairly slow function.
+ + +
+ +
proc updateYUVTexture(texture: ptr Texture; rect: ptr Rect; Yplane: ptr Uint8;
+                     Ypitch: cint; Uplane: ptr Uint8; Upitch: cint; Vplane: ptr Uint8;
+                     Vpitch: cint): cint {...}{.importc: "SDL_UpdateYUVTexture", cdecl.}
+
+ +
\brief Update a rectangle within a planar YV12 or IYUV texture with new pixel data.
+  
+  \param texture   The texture to update
+  \param rect      A pointer to the rectangle of pixels to update, or NULL to
+                   update the entire texture.
+  \param Yplane    The raw pixel data for the Y plane.
+  \param Ypitch    The number of bytes between rows of pixel data for the Y plane.
+  \param Uplane    The raw pixel data for the U plane.
+  \param Upitch    The number of bytes between rows of pixel data for the U plane.
+  \param Vplane    The raw pixel data for the V plane.
+  \param Vpitch    The number of bytes between rows of pixel data for the V plane.
+  
+  \return 0 on success, or -1 if the texture is not valid.
+  
+  \note You can use SDL_UpdateTexture() as long as your pixel data is
+        a contiguous block of Y and U/V planes in the proper order, but
+        this function is available if your pixel data is not contiguous.
+ + +
+ +
proc lockTexture(texture: ptr Texture; rect: ptr Rect; pixels: ptr pointer;
+                pitch: ptr cint): cint {...}{.importc: "SDL_LockTexture", cdecl.}
+
+ +
\brief Lock a portion of the texture for write-only pixel access.
+  
+  \param texture   The texture to lock for access, which was created with
+                   ::SDL_TEXTUREACCESS_STREAMING.
+  \param rect      A pointer to the rectangle to lock for access. If the rect
+                   is NULL, the entire texture will be locked.
+  \param pixels    This is filled in with a pointer to the locked pixels,
+                   appropriately offset by the locked area.
+  \param pitch     This is filled in with the pitch of the locked pixels.
+  
+  \return 0 on success, or -1 if the texture is not valid or was not created with ::SDL_TEXTUREACCESS_STREAMING.
+  
+  \sa SDL_UnlockTexture()
+ + +
+ +
proc lockTextureToSurface(texture: ptr Texture; rect: ptr Rect;
+                         surface: ptr ptr Surface): cint {...}{.
+    importc: "SDL_LockTextureToSurface", cdecl.}
+
+ +
\brief Lock a portion of the texture for write-only pixel access.
+         Expose it as a SDL surface.
+  
+  \param texture   The texture to lock for access, which was created with
+                   ::SDL_TEXTUREACCESS_STREAMING.
+  \param rect      A pointer to the rectangle to lock for access. If the rect
+                   is NULL, the entire texture will be locked.
+  \param surface   This is filled in with a SDL surface representing the locked area
+                   Surface is freed internally after calling SDL_UnlockTexture or SDL_DestroyTexture.
+  
+  \return 0 on success, or -1 if the texture is not valid or was not created with ::SDL_TEXTUREACCESS_STREAMING.
+  
+  \sa SDL_UnlockTexture()
+ + +
+ +
proc unlockTexture(texture: ptr Texture) {...}{.importc: "SDL_UnlockTexture", cdecl.}
+
+ +
\brief Unlock a texture, uploading the changes to video memory, if needed.
+         If SDL_LockTextureToSurface() was called for locking, the SDL surface is freed.
+  
+  \sa SDL_LockTexture()
+  \sa SDL_LockTextureToSurface()
+ + +
+ +
proc renderTargetSupported(renderer: ptr Renderer): bool {...}{.
+    importc: "SDL_RenderTargetSupported", cdecl.}
+
+ +
\brief Determines whether a window supports the use of render targets
+ 
+ \param renderer The renderer that will be checked
+ 
+ \return SDL_TRUE if supported, SDL_FALSE if not.
+ + +
+ +
proc setRenderTarget(renderer: ptr Renderer; texture: ptr Texture): cint {...}{.
+    importc: "SDL_SetRenderTarget", cdecl.}
+
+ +
\brief Set a texture as the current rendering target.
+ 
+ \param renderer The renderer.
+ \param texture The targeted texture, which must be created with the SDL_TEXTUREACCESS_TARGET flag, or NULL for the default render target
+ 
+ \return 0 on success, or -1 on error
+  
+  \sa SDL_GetRenderTarget()
+ + +
+ +
proc getRenderTarget(renderer: ptr Renderer): ptr Texture {...}{.
+    importc: "SDL_GetRenderTarget", cdecl.}
+
+ +
\brief Get the current render target or NULL for the default render target.
+ 
+ \return The current render target
+  
+  \sa SDL_SetRenderTarget()
+ + +
+ +
proc renderSetLogicalSize(renderer: ptr Renderer; w: cint; h: cint): cint {...}{.
+    importc: "SDL_RenderSetLogicalSize", cdecl.}
+
+ +
\brief Set device independent resolution for rendering
+  
+  \param renderer The renderer for which resolution should be set.
+  \param w      The width of the logical resolution
+  \param h      The height of the logical resolution
+  
+  This function uses the viewport and scaling functionality to allow a fixed logical
+  resolution for rendering, regardless of the actual output resolution.  If the actual
+  output resolution doesn't have the same aspect ratio the output rendering will be
+  centered within the output display.
+  
+  If the output display is a window, mouse events in the window will be filtered
+  and scaled so they seem to arrive within the logical resolution.
+  
+  \note If this function results in scaling or subpixel drawing by the
+        rendering backend, it will be handled using the appropriate
+        quality hints.
+  
+  \sa SDL_RenderGetLogicalSize()
+  \sa SDL_RenderSetScale()
+  \sa SDL_RenderSetViewport()
+ + +
+ +
proc renderGetLogicalSize(renderer: ptr Renderer; w: ptr cint; h: ptr cint) {...}{.
+    importc: "SDL_RenderGetLogicalSize", cdecl.}
+
+ +
\brief Get device independent resolution for rendering
+  
+  \param renderer The renderer from which resolution should be queried.
+  \param w      A pointer filled with the width of the logical resolution
+  \param h      A pointer filled with the height of the logical resolution
+  
+  \sa SDL_RenderSetLogicalSize()
+ + +
+ +
proc renderSetIntegerScale(renderer: ptr Renderer; enable: bool): cint {...}{.
+    importc: "SDL_RenderSetIntegerScale", cdecl.}
+
+ +
\brief Set whether to force integer scales for resolution-independent rendering
+  
+  \param renderer The renderer for which integer scaling should be set.
+  \param enable   Enable or disable integer scaling
+  
+  This function restricts the logical viewport to integer values - that is, when
+  a resolution is between two multiples of a logical size, the viewport size is
+  rounded down to the lower multiple.
+  
+  \sa SDL_RenderSetLogicalSize()
+ + +
+ +
proc renderGetIntegerScale(renderer: ptr Renderer): bool {...}{.
+    importc: "SDL_RenderGetIntegerScale", cdecl.}
+
+ +
\brief Get whether integer scales are forced for resolution-independent rendering
+  
+  \param renderer The renderer from which integer scaling should be queried.
+  
+  \sa SDL_RenderSetIntegerScale()
+ + +
+ +
proc renderSetViewport(renderer: ptr Renderer; rect: ptr Rect): cint {...}{.
+    importc: "SDL_RenderSetViewport", cdecl.}
+
+ +
\brief Set the drawing area for rendering on the current target.
+  
+  \param renderer The renderer for which the drawing area should be set.
+  \param rect The rectangle representing the drawing area, or NULL to set the viewport to the entire target.
+  
+  The x,y of the viewport rect represents the origin for rendering.
+  
+  \return 0 on success, or -1 on error
+  
+  \note If the window associated with the renderer is resized, the viewport is automatically reset.
+  
+  \sa SDL_RenderGetViewport()
+  \sa SDL_RenderSetLogicalSize()
+ + +
+ +
proc renderGetViewport(renderer: ptr Renderer; rect: ptr Rect) {...}{.
+    importc: "SDL_RenderGetViewport", cdecl.}
+
+ +
\brief Get the drawing area for the current target.
+  
+  \sa SDL_RenderSetViewport()
+ + +
+ +
proc renderSetClipRect(renderer: ptr Renderer; rect: ptr Rect): cint {...}{.
+    importc: "SDL_RenderSetClipRect", cdecl.}
+
+ +
\brief Set the clip rectangle for the current target.
+  
+  \param renderer The renderer for which clip rectangle should be set.
+  \param rect   A pointer to the rectangle to set as the clip rectangle,
+                relative to the viewport, or NULL to disable clipping.
+  
+  \return 0 on success, or -1 on error
+  
+  \sa SDL_RenderGetClipRect()
+ + +
+ +
proc renderGetClipRect(renderer: ptr Renderer; rect: ptr Rect) {...}{.
+    importc: "SDL_RenderGetClipRect", cdecl.}
+
+ +
\brief Get the clip rectangle for the current target.
+  
+  \param renderer The renderer from which clip rectangle should be queried.
+  \param rect   A pointer filled in with the current clip rectangle, or
+                an empty rectangle if clipping is disabled.
+  
+  \sa SDL_RenderSetClipRect()
+ + +
+ +
proc renderIsClipEnabled(renderer: ptr Renderer): bool {...}{.
+    importc: "SDL_RenderIsClipEnabled", cdecl.}
+
+ +
\brief Get whether clipping is enabled on the given renderer.
+  
+  \param renderer The renderer from which clip state should be queried.
+  
+  \sa SDL_RenderGetClipRect()
+ + +
+ +
proc renderSetScale(renderer: ptr Renderer; scaleX: cfloat; scaleY: cfloat): cint {...}{.
+    importc: "SDL_RenderSetScale", cdecl.}
+
+ +
\brief Set the drawing scale for rendering on the current target.
+  
+  \param renderer The renderer for which the drawing scale should be set.
+  \param scaleX The horizontal scaling factor
+  \param scaleY The vertical scaling factor
+  
+  The drawing coordinates are scaled by the x/y scaling factors
+  before they are used by the renderer.  This allows resolution
+  independent drawing with a single coordinate system.
+  
+  \note If this results in scaling or subpixel drawing by the
+        rendering backend, it will be handled using the appropriate
+        quality hints.  For best results use integer scaling factors.
+  
+  \sa SDL_RenderGetScale()
+  \sa SDL_RenderSetLogicalSize()
+ + +
+ +
proc renderGetScale(renderer: ptr Renderer; scaleX: ptr cfloat; scaleY: ptr cfloat) {...}{.
+    importc: "SDL_RenderGetScale", cdecl.}
+
+ +
\brief Get the drawing scale for the current target.
+  
+  \param renderer The renderer from which drawing scale should be queried.
+  \param scaleX A pointer filled in with the horizontal scaling factor
+  \param scaleY A pointer filled in with the vertical scaling factor
+  
+  \sa SDL_RenderSetScale()
+ + +
+ +
proc setRenderDrawColor(renderer: ptr Renderer; r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint {...}{.
+    importc: "SDL_SetRenderDrawColor", cdecl.}
+
+ +
\brief Set the color used for drawing operations (Rect, Line and Clear).
+  
+  \param renderer The renderer for which drawing color should be set.
+  \param r The red value used to draw on the rendering target.
+  \param g The green value used to draw on the rendering target.
+  \param b The blue value used to draw on the rendering target.
+  \param a The alpha value used to draw on the rendering target, usually
+           ::SDL_ALPHA_OPAQUE (255).
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc getRenderDrawColor(renderer: ptr Renderer; r: ptr Uint8; g: ptr Uint8; b: ptr Uint8;
+                       a: ptr Uint8): cint {...}{.importc: "SDL_GetRenderDrawColor", cdecl.}
+
+ +
\brief Get the color used for drawing operations (Rect, Line and Clear).
+  
+  \param renderer The renderer from which drawing color should be queried.
+  \param r A pointer to the red value used to draw on the rendering target.
+  \param g A pointer to the green value used to draw on the rendering target.
+  \param b A pointer to the blue value used to draw on the rendering target.
+  \param a A pointer to the alpha value used to draw on the rendering target,
+           usually ::SDL_ALPHA_OPAQUE (255).
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc setRenderDrawBlendMode(renderer: ptr Renderer; blendMode: BlendMode): cint {...}{.
+    importc: "SDL_SetRenderDrawBlendMode", cdecl.}
+
+ +
\brief Set the blend mode used for drawing operations (Fill and Line).
+  
+  \param renderer The renderer for which blend mode should be set.
+  \param blendMode ::SDL_BlendMode to use for blending.
+  
+  \return 0 on success, or -1 on error
+  
+  \note If the blend mode is not supported, the closest supported mode is
+        chosen.
+  
+  \sa SDL_GetRenderDrawBlendMode()
+ + +
+ +
proc getRenderDrawBlendMode(renderer: ptr Renderer; blendMode: ptr BlendMode): cint {...}{.
+    importc: "SDL_GetRenderDrawBlendMode", cdecl.}
+
+ +
\brief Get the blend mode used for drawing operations.
+  
+  \param renderer The renderer from which blend mode should be queried.
+  \param blendMode A pointer filled in with the current blend mode.
+  
+  \return 0 on success, or -1 on error
+  
+  \sa SDL_SetRenderDrawBlendMode()
+ + +
+ +
proc renderClear(renderer: ptr Renderer): cint {...}{.importc: "SDL_RenderClear", cdecl.}
+
+ +
\brief Clear the current rendering target with the drawing color
+  
+  This function clears the entire rendering target, ignoring the viewport and
+  the clip rectangle.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderDrawPoint(renderer: ptr Renderer; x: cint; y: cint): cint {...}{.
+    importc: "SDL_RenderDrawPoint", cdecl.}
+
+ +
\brief Draw a point on the current rendering target.
+  
+  \param renderer The renderer which should draw a point.
+  \param x The x coordinate of the point.
+  \param y The y coordinate of the point.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderDrawPoints(renderer: ptr Renderer; points: ptr Point; count: cint): cint {...}{.
+    importc: "SDL_RenderDrawPoints", cdecl.}
+
+ +
\brief Draw multiple points on the current rendering target.
+  
+  \param renderer The renderer which should draw multiple points.
+  \param points The points to draw
+  \param count The number of points to draw
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderDrawLine(renderer: ptr Renderer; x1: cint; y1: cint; x2: cint; y2: cint): cint {...}{.
+    importc: "SDL_RenderDrawLine", cdecl.}
+
+ +
\brief Draw a line on the current rendering target.
+  
+  \param renderer The renderer which should draw a line.
+  \param x1 The x coordinate of the start point.
+  \param y1 The y coordinate of the start point.
+  \param x2 The x coordinate of the end point.
+  \param y2 The y coordinate of the end point.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderDrawLines(renderer: ptr Renderer; points: ptr Point; count: cint): cint {...}{.
+    importc: "SDL_RenderDrawLines", cdecl.}
+
+ +
\brief Draw a series of connected lines on the current rendering target.
+  
+  \param renderer The renderer which should draw multiple lines.
+  \param points The points along the lines
+  \param count The number of points, drawing count-1 lines
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderDrawRect(renderer: ptr Renderer; rect: ptr Rect): cint {...}{.
+    importc: "SDL_RenderDrawRect", cdecl.}
+
+ +
\brief Draw a rectangle on the current rendering target.
+  
+  \param renderer The renderer which should draw a rectangle.
+  \param rect A pointer to the destination rectangle, or NULL to outline the entire rendering target.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderDrawRects(renderer: ptr Renderer; rects: ptr Rect; count: cint): cint {...}{.
+    importc: "SDL_RenderDrawRects", cdecl.}
+
+ +
\brief Draw some number of rectangles on the current rendering target.
+  
+  \param renderer The renderer which should draw multiple rectangles.
+  \param rects A pointer to an array of destination rectangles.
+  \param count The number of rectangles.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderFillRect(renderer: ptr Renderer; rect: ptr Rect): cint {...}{.
+    importc: "SDL_RenderFillRect", cdecl.}
+
+ +
\brief Fill a rectangle on the current rendering target with the drawing color.
+  
+  \param renderer The renderer which should fill a rectangle.
+  \param rect A pointer to the destination rectangle, or NULL for the entire
+              rendering target.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderFillRects(renderer: ptr Renderer; rects: ptr Rect; count: cint): cint {...}{.
+    importc: "SDL_RenderFillRects", cdecl.}
+
+ +
\brief Fill some number of rectangles on the current rendering target with the drawing color.
+  
+  \param renderer The renderer which should fill multiple rectangles.
+  \param rects A pointer to an array of destination rectangles.
+  \param count The number of rectangles.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderCopy(renderer: ptr Renderer; texture: ptr Texture; srcrect: ptr Rect;
+               dstrect: ptr Rect): cint {...}{.importc: "SDL_RenderCopy", cdecl.}
+
+ +
\brief Copy a portion of the texture to the current rendering target.
+  
+  \param renderer The renderer which should copy parts of a texture.
+  \param texture The source texture.
+  \param srcrect   A pointer to the source rectangle, or NULL for the entire
+                   texture.
+  \param dstrect   A pointer to the destination rectangle, or NULL for the
+                   entire rendering target.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderCopyEx(renderer: ptr Renderer; texture: ptr Texture; srcrect: ptr Rect;
+                 dstrect: ptr Rect; angle: cdouble; center: ptr Point;
+                 flip: RendererFlip): cint {...}{.importc: "SDL_RenderCopyEx", cdecl.}
+
+ +
\brief Copy a portion of the source texture to the current rendering target, rotating it by angle around the given center
+  
+  \param renderer The renderer which should copy parts of a texture.
+  \param texture The source texture.
+  \param srcrect   A pointer to the source rectangle, or NULL for the entire
+                   texture.
+  \param dstrect   A pointer to the destination rectangle, or NULL for the
+                   entire rendering target.
+  \param angle    An angle in degrees that indicates the rotation that will be applied to dstrect, rotating it in a clockwise direction
+  \param center   A pointer to a point indicating the point around which dstrect will be rotated (if NULL, rotation will be done around dstrect.w/2, dstrect.h/2).
+  \param flip     An SDL_RendererFlip value stating which flipping actions should be performed on the texture
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderDrawPointF(renderer: ptr Renderer; x: cfloat; y: cfloat): cint {...}{.
+    importc: "SDL_RenderDrawPointF", cdecl.}
+
+ +
\brief Draw a point on the current rendering target.
+  
+  \param renderer The renderer which should draw a point.
+  \param x The x coordinate of the point.
+  \param y The y coordinate of the point.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderDrawPointsF(renderer: ptr Renderer; points: ptr FPoint; count: cint): cint {...}{.
+    importc: "SDL_RenderDrawPointsF", cdecl.}
+
+ +
\brief Draw multiple points on the current rendering target.
+  
+  \param renderer The renderer which should draw multiple points.
+  \param points The points to draw
+  \param count The number of points to draw
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderDrawLineF(renderer: ptr Renderer; x1: cfloat; y1: cfloat; x2: cfloat;
+                    y2: cfloat): cint {...}{.importc: "SDL_RenderDrawLineF", cdecl.}
+
+ +
\brief Draw a line on the current rendering target.
+  
+  \param renderer The renderer which should draw a line.
+  \param x1 The x coordinate of the start point.
+  \param y1 The y coordinate of the start point.
+  \param x2 The x coordinate of the end point.
+  \param y2 The y coordinate of the end point.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderDrawLinesF(renderer: ptr Renderer; points: ptr FPoint; count: cint): cint {...}{.
+    importc: "SDL_RenderDrawLinesF", cdecl.}
+
+ +
\brief Draw a series of connected lines on the current rendering target.
+  
+  \param renderer The renderer which should draw multiple lines.
+  \param points The points along the lines
+  \param count The number of points, drawing count-1 lines
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderDrawRectF(renderer: ptr Renderer; rect: ptr FRect): cint {...}{.
+    importc: "SDL_RenderDrawRectF", cdecl.}
+
+ +
\brief Draw a rectangle on the current rendering target.
+  
+  \param renderer The renderer which should draw a rectangle.
+  \param rect A pointer to the destination rectangle, or NULL to outline the entire rendering target.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderDrawRectsF(renderer: ptr Renderer; rects: ptr FRect; count: cint): cint {...}{.
+    importc: "SDL_RenderDrawRectsF", cdecl.}
+
+ +
\brief Draw some number of rectangles on the current rendering target.
+  
+  \param renderer The renderer which should draw multiple rectangles.
+  \param rects A pointer to an array of destination rectangles.
+  \param count The number of rectangles.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderFillRectF(renderer: ptr Renderer; rect: ptr FRect): cint {...}{.
+    importc: "SDL_RenderFillRectF", cdecl.}
+
+ +
\brief Fill a rectangle on the current rendering target with the drawing color.
+  
+  \param renderer The renderer which should fill a rectangle.
+  \param rect A pointer to the destination rectangle, or NULL for the entire
+              rendering target.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderFillRectsF(renderer: ptr Renderer; rects: ptr FRect; count: cint): cint {...}{.
+    importc: "SDL_RenderFillRectsF", cdecl.}
+
+ +
\brief Fill some number of rectangles on the current rendering target with the drawing color.
+  
+  \param renderer The renderer which should fill multiple rectangles.
+  \param rects A pointer to an array of destination rectangles.
+  \param count The number of rectangles.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderCopyF(renderer: ptr Renderer; texture: ptr Texture; srcrect: ptr Rect;
+                dstrect: ptr FRect): cint {...}{.importc: "SDL_RenderCopyF", cdecl.}
+
+ +
\brief Copy a portion of the texture to the current rendering target.
+  
+  \param renderer The renderer which should copy parts of a texture.
+  \param texture The source texture.
+  \param srcrect   A pointer to the source rectangle, or NULL for the entire
+                   texture.
+  \param dstrect   A pointer to the destination rectangle, or NULL for the
+                   entire rendering target.
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderCopyExF(renderer: ptr Renderer; texture: ptr Texture; srcrect: ptr Rect;
+                  dstrect: ptr FRect; angle: cdouble; center: ptr FPoint;
+                  flip: RendererFlip): cint {...}{.importc: "SDL_RenderCopyExF", cdecl.}
+
+ +
\brief Copy a portion of the source texture to the current rendering target, rotating it by angle around the given center
+  
+  \param renderer The renderer which should copy parts of a texture.
+  \param texture The source texture.
+  \param srcrect   A pointer to the source rectangle, or NULL for the entire
+                   texture.
+  \param dstrect   A pointer to the destination rectangle, or NULL for the
+                   entire rendering target.
+  \param angle    An angle in degrees that indicates the rotation that will be applied to dstrect, rotating it in a clockwise direction
+  \param center   A pointer to a point indicating the point around which dstrect will be rotated (if NULL, rotation will be done around dstrect.w/2, dstrect.h/2).
+  \param flip     An SDL_RendererFlip value stating which flipping actions should be performed on the texture
+  
+  \return 0 on success, or -1 on error
+ + +
+ +
proc renderReadPixels(renderer: ptr Renderer; rect: ptr Rect; format: Uint32;
+                     pixels: pointer; pitch: cint): cint {...}{.
+    importc: "SDL_RenderReadPixels", cdecl.}
+
+ +
\brief Read pixels from the current rendering target.
+  
+  \param renderer The renderer from which pixels should be read.
+  \param rect   A pointer to the rectangle to read, or NULL for the entire
+                render target.
+  \param format The desired format of the pixel data, or 0 to use the format
+                of the rendering target
+  \param pixels A pointer to be filled in with the pixel data
+  \param pitch  The pitch of the pixels parameter.
+  
+  \return 0 on success, or -1 if pixel reading is not supported.
+  
+  \warning This is a very slow operation, and should not be used frequently.
+ + +
+ +
proc renderPresent(renderer: ptr Renderer) {...}{.importc: "SDL_RenderPresent", cdecl.}
+
+ +
\brief Update the screen with rendering performed.
+ + +
+ +
proc destroyTexture(texture: ptr Texture) {...}{.importc: "SDL_DestroyTexture", cdecl.}
+
+ +
\brief Destroy the specified texture.
+  
+  \sa SDL_CreateTexture()
+  \sa SDL_CreateTextureFromSurface()
+ + +
+ +
proc destroyRenderer(renderer: ptr Renderer) {...}{.importc: "SDL_DestroyRenderer", cdecl.}
+
+ +
\brief Destroy the rendering context for a window and free associated
+         textures.
+  
+  \sa SDL_CreateRenderer()
+ + +
+ +
proc renderFlush(renderer: ptr Renderer): cint {...}{.importc: "SDL_RenderFlush", cdecl.}
+
+ +
\brief Force the rendering context to flush any pending commands to the
+         underlying rendering API.
+  
+  You do not need to (and in fact, shouldn't) call this function unless
+  you are planning to call into OpenGL/Direct3D/Metal/whatever directly
+  in addition to using an SDL_Renderer.
+  
+  This is for a very-specific case: if you are using SDL's render API,
+  you asked for a specific renderer backend (OpenGL, Direct3D, etc),
+  you set SDL_HINT_RENDER_BATCHING to "1", and you plan to make
+  OpenGL/D3D/whatever calls in addition to SDL render API calls. If all of
+  this applies, you should call SDL_RenderFlush() between calls to SDL's
+  render API and the low-level API you're using in cooperation.
+  
+  In all other cases, you can ignore this function. This is only here to
+  get maximum performance out of a specific situation. In all other cases,
+  SDL will do the right thing, perhaps at a performance loss.
+  
+  This function is first available in SDL 2.0.10, and is not needed in
+  2.0.9 and earlier, as earlier versions did not queue rendering commands
+  at all, instead flushing them to the OS immediately.
+ + +
+ +
proc gL_BindTexture(texture: ptr Texture; texw: ptr cfloat; texh: ptr cfloat): cint {...}{.
+    importc: "SDL_GL_BindTexture", cdecl.}
+
+ +
\brief Bind the texture to the current OpenGL/ES/ES2 context for use with
+         OpenGL instructions.
+  
+  \param texture  The SDL texture to bind
+  \param texw     A pointer to a float that will be filled with the texture width
+  \param texh     A pointer to a float that will be filled with the texture height
+  
+  \return 0 on success, or -1 if the operation is not supported
+ + +
+ +
proc gL_UnbindTexture(texture: ptr Texture): cint {...}{.importc: "SDL_GL_UnbindTexture",
+    cdecl.}
+
+ +
\brief Unbind a texture from the current OpenGL/ES/ES2 context.
+  
+  \param texture  The SDL texture to unbind
+  
+  \return 0 on success, or -1 if the operation is not supported
+ + +
+ +
proc renderGetMetalLayer(renderer: ptr Renderer): pointer {...}{.
+    importc: "SDL_RenderGetMetalLayer", cdecl.}
+
+ +
\brief Get the CAMetalLayer associated with the given Metal renderer
+  
+  \param renderer The renderer to query
+  
+  \return CAMetalLayer on success, or NULL if the renderer isn't a Metal renderer
+  
+  \sa SDL_RenderGetMetalCommandEncoder()
+ + +
+ +
proc renderGetMetalCommandEncoder(renderer: ptr Renderer): pointer {...}{.
+    importc: "SDL_RenderGetMetalCommandEncoder", cdecl.}
+
+ +
\brief Get the Metal command encoder for the current frame
+  
+  \param renderer The renderer to query
+  
+  \return id<MTLRenderCommandEncoder> on success, or NULL if the renderer isn't a Metal renderer
+  
+  \sa SDL_RenderGetMetalLayer()
+ + +
+ +
proc numSensors(): cint {...}{.importc: "SDL_NumSensors", cdecl.}
+
+ +
Gyroscope sensor
+ 
+ The gyroscope returns the current rate of rotation in radians per second.
+ The rotation is positive in the counter-clockwise direction. That is,
+ an observer looking from a positive location on one of the axes would
+ see positive rotation on that axis when it appeared to be rotating
+ counter-clockwise.
+ 
+ values[0]: Angular speed around the x axis
+ values[1]: Angular speed around the y axis
+ values[2]: Angular speed around the z axis
+ 
+ For phones held in portrait mode, the axes are defined as follows:
+ -X ... +X : left ... right
+ -Y ... +Y : bottom ... top
+ -Z ... +Z : farther ... closer
+ 
+ The axis data is not changed when the phone is rotated.
+ 
+ \sa SDL_GetDisplayOrientation()
+Function prototypes
+\brief Count the number of sensors attached to the system right now
+ + +
+ +
proc sensorGetDeviceName(deviceIndex: cint): cstring {...}{.
+    importc: "SDL_SensorGetDeviceName", cdecl.}
+
+ +
\brief Get the implementation dependent name of a sensor.
+  
+  This can be called before any sensors are opened.
+  
+  \return The sensor name, or NULL if device_index is out of range.
+ + +
+ +
proc sensorGetDeviceType(deviceIndex: cint): SensorType {...}{.
+    importc: "SDL_SensorGetDeviceType", cdecl.}
+
+ +
\brief Get the type of a sensor.
+  
+  This can be called before any sensors are opened.
+  
+  \return The sensor type, or SDL_SENSOR_INVALID if device_index is out of range.
+ + +
+ +
proc sensorGetDeviceNonPortableType(deviceIndex: cint): cint {...}{.
+    importc: "SDL_SensorGetDeviceNonPortableType", cdecl.}
+
+ +
\brief Get the platform dependent type of a sensor.
+  
+  This can be called before any sensors are opened.
+  
+  \return The sensor platform dependent type, or -1 if device_index is out of range.
+ + +
+ +
proc sensorGetDeviceInstanceID(deviceIndex: cint): SensorID {...}{.
+    importc: "SDL_SensorGetDeviceInstanceID", cdecl.}
+
+ +
\brief Get the instance ID of a sensor.
+  
+  This can be called before any sensors are opened.
+  
+  \return The sensor instance ID, or -1 if device_index is out of range.
+ + +
+ +
proc sensorOpen(deviceIndex: cint): ptr Sensor {...}{.importc: "SDL_SensorOpen", cdecl.}
+
+ +
\brief Open a sensor for use.
+  
+  The index passed as an argument refers to the N'th sensor on the system.
+  
+  \return A sensor identifier, or NULL if an error occurred.
+ + +
+ +
proc sensorFromInstanceID(instanceId: SensorID): ptr Sensor {...}{.
+    importc: "SDL_SensorFromInstanceID", cdecl.}
+
+ +
Return the SDL_Sensor associated with an instance id.
+ + +
+ +
proc sensorGetName(sensor: ptr Sensor): cstring {...}{.importc: "SDL_SensorGetName", cdecl.}
+
+ +
\brief Get the implementation dependent name of a sensor.
+  
+  \return The sensor name, or NULL if the sensor is NULL.
+ + +
+ +
proc sensorGetType(sensor: ptr Sensor): SensorType {...}{.importc: "SDL_SensorGetType",
+    cdecl.}
+
+ +
\brief Get the type of a sensor.
+  
+  This can be called before any sensors are opened.
+  
+  \return The sensor type, or SDL_SENSOR_INVALID if the sensor is NULL.
+ + +
+ +
proc sensorGetNonPortableType(sensor: ptr Sensor): cint {...}{.
+    importc: "SDL_SensorGetNonPortableType", cdecl.}
+
+ +
\brief Get the platform dependent type of a sensor.
+  
+  This can be called before any sensors are opened.
+  
+  \return The sensor platform dependent type, or -1 if the sensor is NULL.
+ + +
+ +
proc sensorGetInstanceID(sensor: ptr Sensor): SensorID {...}{.
+    importc: "SDL_SensorGetInstanceID", cdecl.}
+
+ +
\brief Get the instance ID of a sensor.
+  
+  This can be called before any sensors are opened.
+  
+  \return The sensor instance ID, or -1 if the sensor is NULL.
+ + +
+ +
proc sensorGetData(sensor: ptr Sensor; data: ptr cfloat; numValues: cint): cint {...}{.
+    importc: "SDL_SensorGetData", cdecl.}
+
+ +
Get the current state of an opened sensor.
+  
+  The number of values and interpretation of the data is sensor dependent.
+  
+  \param sensor The sensor to query
+  \param data A pointer filled with the current sensor state
+  \param num_values The number of values to write to data
+  
+  \return 0 or -1 if an error occurred.
+ + +
+ +
proc sensorClose(sensor: ptr Sensor) {...}{.importc: "SDL_SensorClose", cdecl.}
+
+ +
Close a sensor previously opened with SDL_SensorOpen()
+ + +
+ +
proc sensorUpdate() {...}{.importc: "SDL_SensorUpdate", cdecl.}
+
+ +
Update the current state of the open sensors.
+  
+  This is called automatically by the event loop if sensor events are enabled.
+  
+  This needs to be called from the thread that initialized the sensor subsystem.
+ + +
+ +
proc createShapedWindow(title: cstring; x: cuint; y: cuint; w: cuint; h: cuint;
+                       flags: Uint32): ptr Window {...}{.
+    importc: "SDL_CreateShapedWindow", cdecl.}
+
+ +
\brief Create a window that can be shaped with the specified position, dimensions, and flags.
+  
+  \param title The title of the window, in UTF-8 encoding.
+  \param x     The x position of the window, ::SDL_WINDOWPOS_CENTERED, or
+               ::SDL_WINDOWPOS_UNDEFINED.
+  \param y     The y position of the window, ::SDL_WINDOWPOS_CENTERED, or
+               ::SDL_WINDOWPOS_UNDEFINED.
+  \param w     The width of the window.
+  \param h     The height of the window.
+  \param flags The flags for the window, a mask of SDL_WINDOW_BORDERLESS with any of the following:
+               ::SDL_WINDOW_OPENGL,     ::SDL_WINDOW_INPUT_GRABBED,
+               ::SDL_WINDOW_HIDDEN,     ::SDL_WINDOW_RESIZABLE,
+               ::SDL_WINDOW_MAXIMIZED,  ::SDL_WINDOW_MINIMIZED,
+       ::SDL_WINDOW_BORDERLESS is always set, and ::SDL_WINDOW_FULLSCREEN is always unset.
+  
+  \return The window created, or NULL if window creation failed.
+  
+  \sa SDL_DestroyWindow()
+ + +
+ +
proc isShapedWindow(window: ptr Window): bool {...}{.importc: "SDL_IsShapedWindow", cdecl.}
+
+ +
\brief Return whether the given window is a shaped window.
+ 
+ \param window The window to query for being shaped.
+ 
+ \return SDL_TRUE if the window is a window that can be shaped, SDL_FALSE if the window is unshaped or NULL.
+ 
+ \sa SDL_CreateShapedWindow
+ + +
+ +
proc setWindowShape(window: ptr Window; shape: ptr Surface;
+                   shapeMode: ptr WindowShapeMode): cint {...}{.
+    importc: "SDL_SetWindowShape", cdecl.}
+
+ +
\brief Set the shape and parameters of a shaped window.
+ 
+ \param window The shaped window whose parameters should be set.
+ \param shape A surface encoding the desired shape for the window.
+ \param shape_mode The parameters to set for the shaped window.
+ 
+ \return 0 on success, SDL_INVALID_SHAPE_ARGUMENT on an invalid shape argument, or SDL_NONSHAPEABLE_WINDOW
+           if the SDL_Window given does not reference a valid shaped window.
+ 
+ \sa SDL_WindowShapeMode
+ \sa SDL_GetShapedWindowMode.
+ + +
+ +
proc getShapedWindowMode(window: ptr Window; shapeMode: ptr WindowShapeMode): cint {...}{.
+    importc: "SDL_GetShapedWindowMode", cdecl.}
+
+ +
\brief Get the shape parameters of a shaped window.
+ 
+ \param window The shaped window whose parameters should be retrieved.
+ \param shape_mode An empty shape-mode structure to fill, or NULL to check whether the window has a shape.
+ 
+ \return 0 if the window has a shape and, provided shape_mode was not NULL, shape_mode has been filled with the mode
+           data, SDL_NONSHAPEABLE_WINDOW if the SDL_Window given is not a shaped window, or SDL_WINDOW_LACKS_SHAPE if
+           the SDL_Window given is a shapeable window currently lacking a shape.
+ 
+ \sa SDL_WindowShapeMode
+ \sa SDL_SetWindowShape
+ + +
+ +
proc isTablet(): bool {...}{.importc: "SDL_IsTablet", cdecl.}
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+Platform specific functions for Windows
+Platform specific functions for Linux
+Platform specific functions for iOS
+Platform specific functions for Android
+Platform specific functions for WinRT
+\brief Return true if the current device is a tablet.
+ + +
+ +
proc onApplicationWillTerminate() {...}{.importc: "SDL_OnApplicationWillTerminate", cdecl.}
+
+ +
Functions used by iOS application delegates to notify SDL about state changes
+ + +
+ +
proc onApplicationDidReceiveMemoryWarning() {...}{.
+    importc: "SDL_OnApplicationDidReceiveMemoryWarning", cdecl.}
+
+ + + +
+ +
proc onApplicationWillResignActive() {...}{.importc: "SDL_OnApplicationWillResignActive",
+                                     cdecl.}
+
+ + + +
+ +
proc onApplicationDidEnterBackground() {...}{.importc: "SDL_OnApplicationDidEnterBackground",
+                                       cdecl.}
+
+ + + +
+ +
proc onApplicationWillEnterForeground() {...}{.importc: "SDL_OnApplicationWillEnterForeground",
+                                        cdecl.}
+
+ + + +
+ +
proc onApplicationDidBecomeActive() {...}{.importc: "SDL_OnApplicationDidBecomeActive",
+                                    cdecl.}
+
+ + + +
+ +
proc getTicks(): Uint32 {...}{.importc: "SDL_GetTicks", cdecl.}
+
+ +
Some compilers use a special export keyword
+By default SDL uses the C calling convention
+Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC
+Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+Apparently this is needed by several Windows compilers
+Set up for C function definitions, even when using C++
+\brief Get the number of milliseconds since the SDL library initialization.
+ 
+ \note This value wraps if the program runs for more than ~49 days.
+ + +
+ +
proc getPerformanceCounter(): Uint64 {...}{.importc: "SDL_GetPerformanceCounter", cdecl.}
+
+ +
\brief Get the current value of the high resolution counter
+ + +
+ +
proc getPerformanceFrequency(): Uint64 {...}{.importc: "SDL_GetPerformanceFrequency",
+                                      cdecl.}
+
+ +
\brief Get the count per second of the high resolution counter
+ + +
+ +
proc delay(ms: Uint32) {...}{.importc: "SDL_Delay", cdecl.}
+
+ +
\brief Wait a specified number of milliseconds before returning.
+ + +
+ +
proc addTimer(interval: Uint32; callback: TimerCallback; param: pointer): TimerID {...}{.
+    importc: "SDL_AddTimer", cdecl.}
+
+ +
\brief Add a new timer to the pool of timers already running.
+ 
+ \return A timer ID, or 0 when an error occurs.
+ + +
+ +
proc removeTimer(id: TimerID): bool {...}{.importc: "SDL_RemoveTimer", cdecl.}
+
+ +
\brief Remove a timer knowing its ID.
+ 
+ \return A boolean value indicating success or failure.
+ 
+ \warning It is not safe to remove a timer multiple times.
+ + +
+ +
proc getVersion(ver: ptr Version) {...}{.importc: "SDL_GetVersion", cdecl.}
+
+ +
\brief Get the version of SDL that is linked against your program.
+  
+  If you are linking to SDL dynamically, then it is possible that the
+  current version will be different than the version you compiled against.
+  This function returns the current version, while SDL_VERSION() is a
+  macro that tells you what version you compiled with.
+  
+  \code
+  SDL_version compiled;
+  SDL_version linked;
+  
+  SDL_VERSION(&compiled);
+  SDL_GetVersion(&linked);
+  printf("We compiled against SDL version %d.%d.%d ...\n",
+         compiled.major, compiled.minor, compiled.patch);
+  printf("But we linked against SDL version %d.%d.%d.\n",
+         linked.major, linked.minor, linked.patch);
+  \endcode
+  
+  This function may be called safely at any time, even before SDL_Init().
+  
+  \sa SDL_VERSION
+ + +
+ +
proc getRevision(): cstring {...}{.importc: "SDL_GetRevision", cdecl.}
+
+ +
\brief Get the code revision of SDL that is linked against your program.
+  
+  Returns an arbitrary string (a hash value) uniquely identifying the
+  exact revision of the SDL library in use, and is only useful in comparing
+  against other revisions. It is NOT an incrementing number.
+ + +
+ +
proc getRevisionNumber(): cint {...}{.importc: "SDL_GetRevisionNumber", cdecl.}
+
+ +
\brief Get the revision number of SDL that is linked against your program.
+  
+  Returns a number uniquely identifying the exact revision of the SDL
+  library in use. It is an incrementing number based on commits to
+  hg.libsdl.org.
+ + +
+ +
proc init(flags: Uint32): cint {...}{.importc: "SDL_Init", cdecl.}
+
+ +
@}
+This function initializes  the subsystems specified by \c flags
+ + +
+ +
proc initSubSystem(flags: Uint32): cint {...}{.importc: "SDL_InitSubSystem", cdecl.}
+
+ +
This function initializes specific SDL subsystems
+  
+  Subsystem initialization is ref-counted, you must call
+  SDL_QuitSubSystem() for each SDL_InitSubSystem() to correctly
+  shutdown a subsystem manually (or call SDL_Quit() to force shutdown).
+  If a subsystem is already loaded then this call will
+  increase the ref-count and return.
+ + +
+ +
proc quitSubSystem(flags: Uint32) {...}{.importc: "SDL_QuitSubSystem", cdecl.}
+
+ +
This function cleans up specific SDL subsystems
+ + +
+ +
proc wasInit(flags: Uint32): Uint32 {...}{.importc: "SDL_WasInit", cdecl.}
+
+ +
This function returns a mask of the specified subsystems which have
+  previously been initialized.
+  
+  If \c flags is 0, it returns a mask of all initialized subsystems.
+ + +
+ +
proc quit() {...}{.importc: "SDL_Quit", cdecl.}
+
+ +
This function cleans up all initialized subsystems. You should
+  call it upon all exit conditions.
+ + +
+ +
+
+

Templates

+
+ +
template sdl_button(x: untyped): untyped
+
+ + + +
+ +
template WINDOWPOS_UNDEFINED_DISPLAY(x: untyped): untyped
+
+ + + +
+ +
template WINDOWPOS_ISUNDEFINED(x: untyped): untyped
+
+ + + +
+ +
template WINDOWPOS_CENTERED_DISPLAY(x: untyped): untyped
+
+ + + +
+ +
template WINDOWPOS_ISCENTERED(x: untyped): untyped
+
+ + + +
+ +
+ +
+
+ +
+ +
+
+
+ + + diff --git a/docs/sdl2/sdl2.idx b/docs/sdl2/sdl2.idx new file mode 100644 index 0000000..7abada3 --- /dev/null +++ b/docs/sdl2/sdl2.idx @@ -0,0 +1,2173 @@ +SDLCacheDir sdl2/sdl2.html#SDLCacheDir sdl2: SDLCacheDir +SDLStd sdl2/sdl2.html#SDLStd sdl2: SDLStd +SDLGit sdl2/sdl2.html#SDLGit sdl2: SDLGit +SDLDL sdl2/sdl2.html#SDLDL sdl2: SDLDL +SDLStatic sdl2/sdl2.html#SDLStatic sdl2: SDLStatic +SDLSetVer sdl2/sdl2.html#SDLSetVer sdl2: SDLSetVer +SDLLPath sdl2/sdl2.html#SDLLPath sdl2: SDLLPath +SDLPath sdl2/sdl2.html#SDLPath sdl2: SDLPath +sdl_button sdl2/sdl2.html#sdl_button.t,untyped sdl2: sdl_button(x: untyped): untyped +WINDOWPOS_UNDEFINED_DISPLAY sdl2/sdl2.html#WINDOWPOS_UNDEFINED_DISPLAY.t,untyped sdl2: WINDOWPOS_UNDEFINED_DISPLAY(x: untyped): untyped +WINDOWPOS_ISUNDEFINED sdl2/sdl2.html#WINDOWPOS_ISUNDEFINED.t,untyped sdl2: WINDOWPOS_ISUNDEFINED(x: untyped): untyped +WINDOWPOS_CENTERED_DISPLAY sdl2/sdl2.html#WINDOWPOS_CENTERED_DISPLAY.t,untyped sdl2: WINDOWPOS_CENTERED_DISPLAY(x: untyped): untyped +WINDOWPOS_ISCENTERED sdl2/sdl2.html#WINDOWPOS_ISCENTERED.t,untyped sdl2: WINDOWPOS_ISCENTERED(x: untyped): untyped +AssertState sdl2/sdl2.html#AssertState sdl2: AssertState +errorcode sdl2/sdl2.html#errorcode sdl2: errorcode +ThreadPriority sdl2/sdl2.html#ThreadPriority sdl2: ThreadPriority +AudioStatus sdl2/sdl2.html#AudioStatus sdl2: AudioStatus +PixelType sdl2/sdl2.html#PixelType sdl2: PixelType +BitmapOrder sdl2/sdl2.html#BitmapOrder sdl2: BitmapOrder +PackedOrder sdl2/sdl2.html#PackedOrder sdl2: PackedOrder +ArrayOrder sdl2/sdl2.html#ArrayOrder sdl2: ArrayOrder +PackedLayout sdl2/sdl2.html#PackedLayout sdl2: PackedLayout +PixelFormatEnum sdl2/sdl2.html#PixelFormatEnum sdl2: PixelFormatEnum +BlendMode sdl2/sdl2.html#BlendMode sdl2: BlendMode +BlendOperation sdl2/sdl2.html#BlendOperation sdl2: BlendOperation +BlendFactor sdl2/sdl2.html#BlendFactor sdl2: BlendFactor +YUV_CONVERSION_MODE sdl2/sdl2.html#YUV_CONVERSION_MODE sdl2: YUV_CONVERSION_MODE +WindowFlags sdl2/sdl2.html#WindowFlags sdl2: WindowFlags +WindowEventID sdl2/sdl2.html#WindowEventID sdl2: WindowEventID +DisplayEventID sdl2/sdl2.html#DisplayEventID sdl2: DisplayEventID +DisplayOrientation sdl2/sdl2.html#DisplayOrientation sdl2: DisplayOrientation +GLattr sdl2/sdl2.html#GLattr sdl2: GLattr +GLprofile sdl2/sdl2.html#GLprofile sdl2: GLprofile +GLcontextFlag sdl2/sdl2.html#GLcontextFlag sdl2: GLcontextFlag +GLcontextReleaseFlag sdl2/sdl2.html#GLcontextReleaseFlag sdl2: GLcontextReleaseFlag +GLContextResetNotificationEnum sdl2/sdl2.html#GLContextResetNotificationEnum sdl2: GLContextResetNotificationEnum +HitTestResult sdl2/sdl2.html#HitTestResult sdl2: HitTestResult +Scancode sdl2/sdl2.html#Scancode sdl2: Scancode +KeyCodeEnum sdl2/sdl2.html#KeyCodeEnum sdl2: KeyCodeEnum +Keymod sdl2/sdl2.html#Keymod sdl2: Keymod +SystemCursor sdl2/sdl2.html#SystemCursor sdl2: SystemCursor +MouseWheelDirection sdl2/sdl2.html#MouseWheelDirection sdl2: MouseWheelDirection +JoystickType sdl2/sdl2.html#JoystickType sdl2: JoystickType +JoystickPowerLevel sdl2/sdl2.html#JoystickPowerLevel sdl2: JoystickPowerLevel +GameControllerType sdl2/sdl2.html#GameControllerType sdl2: GameControllerType +GameControllerAxis sdl2/sdl2.html#GameControllerAxis sdl2: GameControllerAxis +GameControllerButton sdl2/sdl2.html#GameControllerButton sdl2: GameControllerButton +TouchDeviceType sdl2/sdl2.html#TouchDeviceType sdl2: TouchDeviceType +EventType sdl2/sdl2.html#EventType sdl2: EventType +eventaction sdl2/sdl2.html#eventaction sdl2: eventaction +HintPriority sdl2/sdl2.html#HintPriority sdl2: HintPriority +LogCategory sdl2/sdl2.html#LogCategory sdl2: LogCategory +LogPriority sdl2/sdl2.html#LogPriority sdl2: LogPriority +MessageBoxFlags sdl2/sdl2.html#MessageBoxFlags sdl2: MessageBoxFlags +MessageBoxButtonFlags sdl2/sdl2.html#MessageBoxButtonFlags sdl2: MessageBoxButtonFlags +MessageBoxColorType sdl2/sdl2.html#MessageBoxColorType sdl2: MessageBoxColorType +PowerState sdl2/sdl2.html#PowerState sdl2: PowerState +RendererFlags sdl2/sdl2.html#RendererFlags sdl2: RendererFlags +ScaleMode sdl2/sdl2.html#ScaleMode sdl2: ScaleMode +TextureAccess sdl2/sdl2.html#TextureAccess sdl2: TextureAccess +TextureModulate sdl2/sdl2.html#TextureModulate sdl2: TextureModulate +RendererFlip sdl2/sdl2.html#RendererFlip sdl2: RendererFlip +SensorType sdl2/sdl2.html#SensorType sdl2: SensorType +WindowShapeMode sdl2/sdl2.html#WindowShapeMode sdl2: WindowShapeMode +MIN_UINT8 sdl2/sdl2.html#MIN_UINT8 sdl2: MIN_UINT8 +MIN_UINT64 sdl2/sdl2.html#MIN_UINT64 sdl2: MIN_UINT64 +MAX_SINT16 sdl2/sdl2.html#MAX_SINT16 sdl2: MAX_SINT16 +MAX_SINT32 sdl2/sdl2.html#MAX_SINT32 sdl2: MAX_SINT32 +Colour sdl2/sdl2.html#Colour sdl2: Colour +MOUSE_TOUCHID sdl2/sdl2.html#MOUSE_TOUCHID sdl2: MOUSE_TOUCHID +WINDOWPOS_CENTERED_MASK sdl2/sdl2.html#WINDOWPOS_CENTERED_MASK sdl2: WINDOWPOS_CENTERED_MASK +MAX_UINT8 sdl2/sdl2.html#MAX_UINT8 sdl2: MAX_UINT8 +BlitScaled sdl2/sdl2.html#BlitScaled sdl2: BlitScaled +MIN_SINT8 sdl2/sdl2.html#MIN_SINT8 sdl2: MIN_SINT8 +MIN_UINT16 sdl2/sdl2.html#MIN_UINT16 sdl2: MIN_UINT16 +MIN_UINT32 sdl2/sdl2.html#MIN_UINT32 sdl2: MIN_UINT32 +TOUCH_MOUSEID sdl2/sdl2.html#TOUCH_MOUSEID sdl2: TOUCH_MOUSEID +BlitSurface sdl2/sdl2.html#BlitSurface sdl2: BlitSurface +WINDOWPOS_UNDEFINED_MASK sdl2/sdl2.html#WINDOWPOS_UNDEFINED_MASK sdl2: WINDOWPOS_UNDEFINED_MASK +MIN_SINT32 sdl2/sdl2.html#MIN_SINT32 sdl2: MIN_SINT32 +MUTEX_MAXWAIT sdl2/sdl2.html#MUTEX_MAXWAIT sdl2: MUTEX_MAXWAIT +MAX_SINT8 sdl2/sdl2.html#MAX_SINT8 sdl2: MAX_SINT8 +MAX_UINT16 sdl2/sdl2.html#MAX_UINT16 sdl2: MAX_UINT16 +MAX_UINT32 sdl2/sdl2.html#MAX_UINT32 sdl2: MAX_UINT32 +MIN_SINT16 sdl2/sdl2.html#MIN_SINT16 sdl2: MIN_SINT16 +MAX_UINT64 sdl2/sdl2.html#MAX_UINT64 sdl2: MAX_UINT64 +MAX_SINT64 sdl2/sdl2.html#MAX_SINT64 sdl2: MAX_SINT64 +MACOSX sdl2/sdl2.html#MACOSX sdl2: MACOSX +SIZEOF_VOIDP sdl2/sdl2.html#SIZEOF_VOIDP sdl2: SIZEOF_VOIDP +HAVE_GCC_ATOMICS sdl2/sdl2.html#HAVE_GCC_ATOMICS sdl2: HAVE_GCC_ATOMICS +HAVE_LIBC sdl2/sdl2.html#HAVE_LIBC sdl2: HAVE_LIBC +STDC_HEADERS sdl2/sdl2.html#STDC_HEADERS sdl2: STDC_HEADERS +HAVE_ALLOCA_H sdl2/sdl2.html#HAVE_ALLOCA_H sdl2: HAVE_ALLOCA_H +HAVE_CTYPE_H sdl2/sdl2.html#HAVE_CTYPE_H sdl2: HAVE_CTYPE_H +HAVE_FLOAT_H sdl2/sdl2.html#HAVE_FLOAT_H sdl2: HAVE_FLOAT_H +HAVE_ICONV_H sdl2/sdl2.html#HAVE_ICONV_H sdl2: HAVE_ICONV_H +HAVE_INTTYPES_H sdl2/sdl2.html#HAVE_INTTYPES_H sdl2: HAVE_INTTYPES_H +HAVE_LIMITS_H sdl2/sdl2.html#HAVE_LIMITS_H sdl2: HAVE_LIMITS_H +HAVE_MATH_H sdl2/sdl2.html#HAVE_MATH_H sdl2: HAVE_MATH_H +HAVE_MEMORY_H sdl2/sdl2.html#HAVE_MEMORY_H sdl2: HAVE_MEMORY_H +HAVE_SIGNAL_H sdl2/sdl2.html#HAVE_SIGNAL_H sdl2: HAVE_SIGNAL_H +HAVE_STDARG_H sdl2/sdl2.html#HAVE_STDARG_H sdl2: HAVE_STDARG_H +HAVE_STDINT_H sdl2/sdl2.html#HAVE_STDINT_H sdl2: HAVE_STDINT_H +HAVE_STDIO_H sdl2/sdl2.html#HAVE_STDIO_H sdl2: HAVE_STDIO_H +HAVE_STDLIB_H sdl2/sdl2.html#HAVE_STDLIB_H sdl2: HAVE_STDLIB_H +HAVE_STRINGS_H sdl2/sdl2.html#HAVE_STRINGS_H sdl2: HAVE_STRINGS_H +HAVE_STRING_H sdl2/sdl2.html#HAVE_STRING_H sdl2: HAVE_STRING_H +HAVE_SYS_TYPES_H sdl2/sdl2.html#HAVE_SYS_TYPES_H sdl2: HAVE_SYS_TYPES_H +HAVE_WCHAR_H sdl2/sdl2.html#HAVE_WCHAR_H sdl2: HAVE_WCHAR_H +HAVE_LIBUNWIND_H sdl2/sdl2.html#HAVE_LIBUNWIND_H sdl2: HAVE_LIBUNWIND_H +HAVE_MALLOC sdl2/sdl2.html#HAVE_MALLOC sdl2: HAVE_MALLOC +HAVE_CALLOC sdl2/sdl2.html#HAVE_CALLOC sdl2: HAVE_CALLOC +HAVE_REALLOC sdl2/sdl2.html#HAVE_REALLOC sdl2: HAVE_REALLOC +HAVE_FREE sdl2/sdl2.html#HAVE_FREE sdl2: HAVE_FREE +HAVE_ALLOCA sdl2/sdl2.html#HAVE_ALLOCA sdl2: HAVE_ALLOCA +HAVE_GETENV sdl2/sdl2.html#HAVE_GETENV sdl2: HAVE_GETENV +HAVE_SETENV sdl2/sdl2.html#HAVE_SETENV sdl2: HAVE_SETENV +HAVE_PUTENV sdl2/sdl2.html#HAVE_PUTENV sdl2: HAVE_PUTENV +HAVE_UNSETENV sdl2/sdl2.html#HAVE_UNSETENV sdl2: HAVE_UNSETENV +HAVE_QSORT sdl2/sdl2.html#HAVE_QSORT sdl2: HAVE_QSORT +HAVE_ABS sdl2/sdl2.html#HAVE_ABS sdl2: HAVE_ABS +HAVE_BCOPY sdl2/sdl2.html#HAVE_BCOPY sdl2: HAVE_BCOPY +HAVE_MEMSET sdl2/sdl2.html#HAVE_MEMSET sdl2: HAVE_MEMSET +HAVE_MEMCPY sdl2/sdl2.html#HAVE_MEMCPY sdl2: HAVE_MEMCPY +HAVE_MEMMOVE sdl2/sdl2.html#HAVE_MEMMOVE sdl2: HAVE_MEMMOVE +HAVE_MEMCMP sdl2/sdl2.html#HAVE_MEMCMP sdl2: HAVE_MEMCMP +HAVE_WCSLEN sdl2/sdl2.html#HAVE_WCSLEN sdl2: HAVE_WCSLEN +HAVE_WCSLCPY sdl2/sdl2.html#HAVE_WCSLCPY sdl2: HAVE_WCSLCPY +HAVE_WCSLCAT sdl2/sdl2.html#HAVE_WCSLCAT sdl2: HAVE_WCSLCAT +HAVE_WCSDUP sdl2/sdl2.html#HAVE_WCSDUP sdl2: HAVE_WCSDUP +HAVE_WCSSTR sdl2/sdl2.html#HAVE_WCSSTR sdl2: HAVE_WCSSTR +HAVE_WCSCMP sdl2/sdl2.html#HAVE_WCSCMP sdl2: HAVE_WCSCMP +HAVE_WCSNCMP sdl2/sdl2.html#HAVE_WCSNCMP sdl2: HAVE_WCSNCMP +HAVE_STRLEN sdl2/sdl2.html#HAVE_STRLEN sdl2: HAVE_STRLEN +HAVE_STRLCPY sdl2/sdl2.html#HAVE_STRLCPY sdl2: HAVE_STRLCPY +HAVE_STRLCAT sdl2/sdl2.html#HAVE_STRLCAT sdl2: HAVE_STRLCAT +HAVE_STRCHR sdl2/sdl2.html#HAVE_STRCHR sdl2: HAVE_STRCHR +HAVE_STRRCHR sdl2/sdl2.html#HAVE_STRRCHR sdl2: HAVE_STRRCHR +HAVE_STRSTR sdl2/sdl2.html#HAVE_STRSTR sdl2: HAVE_STRSTR +HAVE_STRTOK_R sdl2/sdl2.html#HAVE_STRTOK_R sdl2: HAVE_STRTOK_R +HAVE_STRTOL sdl2/sdl2.html#HAVE_STRTOL sdl2: HAVE_STRTOL +HAVE_STRTOUL sdl2/sdl2.html#HAVE_STRTOUL sdl2: HAVE_STRTOUL +HAVE_STRTOLL sdl2/sdl2.html#HAVE_STRTOLL sdl2: HAVE_STRTOLL +HAVE_STRTOULL sdl2/sdl2.html#HAVE_STRTOULL sdl2: HAVE_STRTOULL +HAVE_STRTOD sdl2/sdl2.html#HAVE_STRTOD sdl2: HAVE_STRTOD +HAVE_ATOI sdl2/sdl2.html#HAVE_ATOI sdl2: HAVE_ATOI +HAVE_ATOF sdl2/sdl2.html#HAVE_ATOF sdl2: HAVE_ATOF +HAVE_STRCMP sdl2/sdl2.html#HAVE_STRCMP sdl2: HAVE_STRCMP +HAVE_STRNCMP sdl2/sdl2.html#HAVE_STRNCMP sdl2: HAVE_STRNCMP +HAVE_STRCASECMP sdl2/sdl2.html#HAVE_STRCASECMP sdl2: HAVE_STRCASECMP +HAVE_STRNCASECMP sdl2/sdl2.html#HAVE_STRNCASECMP sdl2: HAVE_STRNCASECMP +HAVE_VSSCANF sdl2/sdl2.html#HAVE_VSSCANF sdl2: HAVE_VSSCANF +HAVE_VSNPRINTF sdl2/sdl2.html#HAVE_VSNPRINTF sdl2: HAVE_VSNPRINTF +HAVE_ACOS sdl2/sdl2.html#HAVE_ACOS sdl2: HAVE_ACOS +HAVE_ACOSF sdl2/sdl2.html#HAVE_ACOSF sdl2: HAVE_ACOSF +HAVE_ASIN sdl2/sdl2.html#HAVE_ASIN sdl2: HAVE_ASIN +HAVE_ASINF sdl2/sdl2.html#HAVE_ASINF sdl2: HAVE_ASINF +HAVE_ATAN sdl2/sdl2.html#HAVE_ATAN sdl2: HAVE_ATAN +HAVE_ATANF sdl2/sdl2.html#HAVE_ATANF sdl2: HAVE_ATANF +HAVE_ATAN2 sdl2/sdl2.html#HAVE_ATAN2 sdl2: HAVE_ATAN2 +HAVE_ATAN2F sdl2/sdl2.html#HAVE_ATAN2F sdl2: HAVE_ATAN2F +HAVE_CEIL sdl2/sdl2.html#HAVE_CEIL sdl2: HAVE_CEIL +HAVE_CEILF sdl2/sdl2.html#HAVE_CEILF sdl2: HAVE_CEILF +HAVE_COPYSIGN sdl2/sdl2.html#HAVE_COPYSIGN sdl2: HAVE_COPYSIGN +HAVE_COPYSIGNF sdl2/sdl2.html#HAVE_COPYSIGNF sdl2: HAVE_COPYSIGNF +HAVE_COS sdl2/sdl2.html#HAVE_COS sdl2: HAVE_COS +HAVE_COSF sdl2/sdl2.html#HAVE_COSF sdl2: HAVE_COSF +HAVE_EXP sdl2/sdl2.html#HAVE_EXP sdl2: HAVE_EXP +HAVE_EXPF sdl2/sdl2.html#HAVE_EXPF sdl2: HAVE_EXPF +HAVE_FABS sdl2/sdl2.html#HAVE_FABS sdl2: HAVE_FABS +HAVE_FABSF sdl2/sdl2.html#HAVE_FABSF sdl2: HAVE_FABSF +HAVE_FLOOR sdl2/sdl2.html#HAVE_FLOOR sdl2: HAVE_FLOOR +HAVE_FLOORF sdl2/sdl2.html#HAVE_FLOORF sdl2: HAVE_FLOORF +HAVE_FMOD sdl2/sdl2.html#HAVE_FMOD sdl2: HAVE_FMOD +HAVE_FMODF sdl2/sdl2.html#HAVE_FMODF sdl2: HAVE_FMODF +HAVE_LOG sdl2/sdl2.html#HAVE_LOG sdl2: HAVE_LOG +HAVE_LOGF sdl2/sdl2.html#HAVE_LOGF sdl2: HAVE_LOGF +HAVE_LOG10 sdl2/sdl2.html#HAVE_LOG10 sdl2: HAVE_LOG10 +HAVE_LOG10F sdl2/sdl2.html#HAVE_LOG10F sdl2: HAVE_LOG10F +HAVE_POW sdl2/sdl2.html#HAVE_POW sdl2: HAVE_POW +HAVE_POWF sdl2/sdl2.html#HAVE_POWF sdl2: HAVE_POWF +HAVE_SCALBN sdl2/sdl2.html#HAVE_SCALBN sdl2: HAVE_SCALBN +HAVE_SCALBNF sdl2/sdl2.html#HAVE_SCALBNF sdl2: HAVE_SCALBNF +HAVE_SIN sdl2/sdl2.html#HAVE_SIN sdl2: HAVE_SIN +HAVE_SINF sdl2/sdl2.html#HAVE_SINF sdl2: HAVE_SINF +HAVE_SQRT sdl2/sdl2.html#HAVE_SQRT sdl2: HAVE_SQRT +HAVE_SQRTF sdl2/sdl2.html#HAVE_SQRTF sdl2: HAVE_SQRTF +HAVE_TAN sdl2/sdl2.html#HAVE_TAN sdl2: HAVE_TAN +HAVE_TANF sdl2/sdl2.html#HAVE_TANF sdl2: HAVE_TANF +HAVE_FSEEKO sdl2/sdl2.html#HAVE_FSEEKO sdl2: HAVE_FSEEKO +HAVE_SIGACTION sdl2/sdl2.html#HAVE_SIGACTION sdl2: HAVE_SIGACTION +HAVE_SA_SIGACTION sdl2/sdl2.html#HAVE_SA_SIGACTION sdl2: HAVE_SA_SIGACTION +HAVE_SETJMP sdl2/sdl2.html#HAVE_SETJMP sdl2: HAVE_SETJMP +HAVE_NANOSLEEP sdl2/sdl2.html#HAVE_NANOSLEEP sdl2: HAVE_NANOSLEEP +HAVE_SYSCONF sdl2/sdl2.html#HAVE_SYSCONF sdl2: HAVE_SYSCONF +HAVE_SYSCTLBYNAME sdl2/sdl2.html#HAVE_SYSCTLBYNAME sdl2: HAVE_SYSCTLBYNAME +HAVE_MPROTECT sdl2/sdl2.html#HAVE_MPROTECT sdl2: HAVE_MPROTECT +HAVE_ICONV sdl2/sdl2.html#HAVE_ICONV sdl2: HAVE_ICONV +HAVE_PTHREAD_SETNAME_NP sdl2/sdl2.html#HAVE_PTHREAD_SETNAME_NP sdl2: HAVE_PTHREAD_SETNAME_NP +HAVE_POLL sdl2/sdl2.html#HAVE_POLL sdl2: HAVE_POLL +HAVE_EXIT sdl2/sdl2.html#HAVE_EXIT sdl2: HAVE_EXIT +HAVE_IMMINTRIN_H sdl2/sdl2.html#HAVE_IMMINTRIN_H sdl2: HAVE_IMMINTRIN_H +AUDIO_DRIVER_COREAUDIO sdl2/sdl2.html#AUDIO_DRIVER_COREAUDIO sdl2: AUDIO_DRIVER_COREAUDIO +AUDIO_DRIVER_DISK sdl2/sdl2.html#AUDIO_DRIVER_DISK sdl2: AUDIO_DRIVER_DISK +AUDIO_DRIVER_DUMMY sdl2/sdl2.html#AUDIO_DRIVER_DUMMY sdl2: AUDIO_DRIVER_DUMMY +JOYSTICK_IOKIT sdl2/sdl2.html#JOYSTICK_IOKIT sdl2: JOYSTICK_IOKIT +HAPTIC_TYPE_IOKIT sdl2/sdl2.html#HAPTIC_TYPE_IOKIT sdl2: HAPTIC_TYPE_IOKIT +SENSOR_DUMMY sdl2/sdl2.html#SENSOR_DUMMY sdl2: SENSOR_DUMMY +LOADSO_DLOPEN sdl2/sdl2.html#LOADSO_DLOPEN sdl2: LOADSO_DLOPEN +THREAD_PTHREAD sdl2/sdl2.html#THREAD_PTHREAD sdl2: THREAD_PTHREAD +THREAD_PTHREAD_RECURSIVE_MUTEX sdl2/sdl2.html#THREAD_PTHREAD_RECURSIVE_MUTEX sdl2: THREAD_PTHREAD_RECURSIVE_MUTEX +TIMER_UNIX sdl2/sdl2.html#TIMER_UNIX sdl2: TIMER_UNIX +VIDEO_DRIVER_COCOA sdl2/sdl2.html#VIDEO_DRIVER_COCOA sdl2: VIDEO_DRIVER_COCOA +VIDEO_DRIVER_DUMMY sdl2/sdl2.html#VIDEO_DRIVER_DUMMY sdl2: VIDEO_DRIVER_DUMMY +VIDEO_RENDER_OGL sdl2/sdl2.html#VIDEO_RENDER_OGL sdl2: VIDEO_RENDER_OGL +VIDEO_RENDER_OGL_ES2 sdl2/sdl2.html#VIDEO_RENDER_OGL_ES2 sdl2: VIDEO_RENDER_OGL_ES2 +VIDEO_RENDER_METAL sdl2/sdl2.html#VIDEO_RENDER_METAL sdl2: VIDEO_RENDER_METAL +VIDEO_OPENGL sdl2/sdl2.html#VIDEO_OPENGL sdl2: VIDEO_OPENGL +VIDEO_OPENGL_ES2 sdl2/sdl2.html#VIDEO_OPENGL_ES2 sdl2: VIDEO_OPENGL_ES2 +VIDEO_OPENGL_CGL sdl2/sdl2.html#VIDEO_OPENGL_CGL sdl2: VIDEO_OPENGL_CGL +VIDEO_OPENGL_EGL sdl2/sdl2.html#VIDEO_OPENGL_EGL sdl2: VIDEO_OPENGL_EGL +VIDEO_VULKAN sdl2/sdl2.html#VIDEO_VULKAN sdl2: VIDEO_VULKAN +VIDEO_METAL sdl2/sdl2.html#VIDEO_METAL sdl2: VIDEO_METAL +POWER_MACOSX sdl2/sdl2.html#POWER_MACOSX sdl2: POWER_MACOSX +FILESYSTEM_COCOA sdl2/sdl2.html#FILESYSTEM_COCOA sdl2: FILESYSTEM_COCOA +ASSEMBLY_ROUTINES sdl2/sdl2.html#ASSEMBLY_ROUTINES sdl2: ASSEMBLY_ROUTINES +PRIs64 sdl2/sdl2.html#PRIs64 sdl2: PRIs64 +ICONV_ERROR sdl2/sdl2.html#ICONV_ERROR sdl2: ICONV_ERROR +ICONV_E2BIG sdl2/sdl2.html#ICONV_E2BIG sdl2: ICONV_E2BIG +ICONV_EILSEQ sdl2/sdl2.html#ICONV_EILSEQ sdl2: ICONV_EILSEQ +ICONV_EINVAL sdl2/sdl2.html#ICONV_EINVAL sdl2: ICONV_EINVAL +ASSERT_LEVEL sdl2/sdl2.html#ASSERT_LEVEL sdl2: ASSERT_LEVEL +NULL_WHILE_LOOP_CONDITION sdl2/sdl2.html#NULL_WHILE_LOOP_CONDITION sdl2: NULL_WHILE_LOOP_CONDITION +ASSERTION_RETRY sdl2/sdl2.html#ASSERTION_RETRY sdl2: ASSERTION_RETRY +ASSERTION_BREAK sdl2/sdl2.html#ASSERTION_BREAK sdl2: ASSERTION_BREAK +ASSERTION_ABORT sdl2/sdl2.html#ASSERTION_ABORT sdl2: ASSERTION_ABORT +ASSERTION_IGNORE sdl2/sdl2.html#ASSERTION_IGNORE sdl2: ASSERTION_IGNORE +ASSERTION_ALWAYS_IGNORE sdl2/sdl2.html#ASSERTION_ALWAYS_IGNORE sdl2: ASSERTION_ALWAYS_IGNORE +ENOMEM sdl2/sdl2.html#ENOMEM sdl2: ENOMEM +EFREAD sdl2/sdl2.html#EFREAD sdl2: EFREAD +EFWRITE sdl2/sdl2.html#EFWRITE sdl2: EFWRITE +EFSEEK sdl2/sdl2.html#EFSEEK sdl2: EFSEEK +UNSUPPORTED sdl2/sdl2.html#UNSUPPORTED sdl2: UNSUPPORTED +LASTERROR sdl2/sdl2.html#LASTERROR sdl2: LASTERROR +LIL_ENDIAN sdl2/sdl2.html#LIL_ENDIAN sdl2: LIL_ENDIAN +BIG_ENDIAN sdl2/sdl2.html#BIG_ENDIAN sdl2: BIG_ENDIAN +BYTEORDER sdl2/sdl2.html#BYTEORDER sdl2: BYTEORDER +MUTEX_TIMEDOUT sdl2/sdl2.html#MUTEX_TIMEDOUT sdl2: MUTEX_TIMEDOUT +THREAD_PRIORITY_LOW sdl2/sdl2.html#THREAD_PRIORITY_LOW sdl2: THREAD_PRIORITY_LOW +THREAD_PRIORITY_NORMAL sdl2/sdl2.html#THREAD_PRIORITY_NORMAL sdl2: THREAD_PRIORITY_NORMAL +THREAD_PRIORITY_HIGH sdl2/sdl2.html#THREAD_PRIORITY_HIGH sdl2: THREAD_PRIORITY_HIGH +THREAD_PRIORITY_TIME_CRITICAL sdl2/sdl2.html#THREAD_PRIORITY_TIME_CRITICAL sdl2: THREAD_PRIORITY_TIME_CRITICAL +RWOPS_UNKNOWN sdl2/sdl2.html#RWOPS_UNKNOWN sdl2: RWOPS_UNKNOWN +RWOPS_WINFILE sdl2/sdl2.html#RWOPS_WINFILE sdl2: RWOPS_WINFILE +RWOPS_STDFILE sdl2/sdl2.html#RWOPS_STDFILE sdl2: RWOPS_STDFILE +RWOPS_JNIFILE sdl2/sdl2.html#RWOPS_JNIFILE sdl2: RWOPS_JNIFILE +RWOPS_MEMORY sdl2/sdl2.html#RWOPS_MEMORY sdl2: RWOPS_MEMORY +RWOPS_MEMORY_RO sdl2/sdl2.html#RWOPS_MEMORY_RO sdl2: RWOPS_MEMORY_RO +RW_SEEK_SET sdl2/sdl2.html#RW_SEEK_SET sdl2: RW_SEEK_SET +RW_SEEK_CUR sdl2/sdl2.html#RW_SEEK_CUR sdl2: RW_SEEK_CUR +RW_SEEK_END sdl2/sdl2.html#RW_SEEK_END sdl2: RW_SEEK_END +AUDIO_MASK_BITSIZE sdl2/sdl2.html#AUDIO_MASK_BITSIZE sdl2: AUDIO_MASK_BITSIZE +AUDIO_MASK_DATATYPE sdl2/sdl2.html#AUDIO_MASK_DATATYPE sdl2: AUDIO_MASK_DATATYPE +AUDIO_MASK_ENDIAN sdl2/sdl2.html#AUDIO_MASK_ENDIAN sdl2: AUDIO_MASK_ENDIAN +AUDIO_MASK_SIGNED sdl2/sdl2.html#AUDIO_MASK_SIGNED sdl2: AUDIO_MASK_SIGNED +AUDIO_U8 sdl2/sdl2.html#AUDIO_U8 sdl2: AUDIO_U8 +AUDIO_S8 sdl2/sdl2.html#AUDIO_S8 sdl2: AUDIO_S8 +AUDIO_U16LSB sdl2/sdl2.html#AUDIO_U16LSB sdl2: AUDIO_U16LSB +AUDIO_S16LSB sdl2/sdl2.html#AUDIO_S16LSB sdl2: AUDIO_S16LSB +AUDIO_U16MSB sdl2/sdl2.html#AUDIO_U16MSB sdl2: AUDIO_U16MSB +AUDIO_S16MSB sdl2/sdl2.html#AUDIO_S16MSB sdl2: AUDIO_S16MSB +AUDIO_U16 sdl2/sdl2.html#AUDIO_U16 sdl2: AUDIO_U16 +AUDIO_S16 sdl2/sdl2.html#AUDIO_S16 sdl2: AUDIO_S16 +AUDIO_S32LSB sdl2/sdl2.html#AUDIO_S32LSB sdl2: AUDIO_S32LSB +AUDIO_S32MSB sdl2/sdl2.html#AUDIO_S32MSB sdl2: AUDIO_S32MSB +AUDIO_S32 sdl2/sdl2.html#AUDIO_S32 sdl2: AUDIO_S32 +AUDIO_F32LSB sdl2/sdl2.html#AUDIO_F32LSB sdl2: AUDIO_F32LSB +AUDIO_F32MSB sdl2/sdl2.html#AUDIO_F32MSB sdl2: AUDIO_F32MSB +AUDIO_F32 sdl2/sdl2.html#AUDIO_F32 sdl2: AUDIO_F32 +AUDIO_U16SYS sdl2/sdl2.html#AUDIO_U16SYS sdl2: AUDIO_U16SYS +AUDIO_S16SYS sdl2/sdl2.html#AUDIO_S16SYS sdl2: AUDIO_S16SYS +AUDIO_S32SYS sdl2/sdl2.html#AUDIO_S32SYS sdl2: AUDIO_S32SYS +AUDIO_F32SYS sdl2/sdl2.html#AUDIO_F32SYS sdl2: AUDIO_F32SYS +AUDIO_ALLOW_FREQUENCY_CHANGE sdl2/sdl2.html#AUDIO_ALLOW_FREQUENCY_CHANGE sdl2: AUDIO_ALLOW_FREQUENCY_CHANGE +AUDIO_ALLOW_FORMAT_CHANGE sdl2/sdl2.html#AUDIO_ALLOW_FORMAT_CHANGE sdl2: AUDIO_ALLOW_FORMAT_CHANGE +AUDIO_ALLOW_CHANNELS_CHANGE sdl2/sdl2.html#AUDIO_ALLOW_CHANNELS_CHANGE sdl2: AUDIO_ALLOW_CHANNELS_CHANGE +AUDIO_ALLOW_SAMPLES_CHANGE sdl2/sdl2.html#AUDIO_ALLOW_SAMPLES_CHANGE sdl2: AUDIO_ALLOW_SAMPLES_CHANGE +AUDIO_ALLOW_ANY_CHANGE sdl2/sdl2.html#AUDIO_ALLOW_ANY_CHANGE sdl2: AUDIO_ALLOW_ANY_CHANGE +AUDIOCVT_MAX_FILTERS sdl2/sdl2.html#AUDIOCVT_MAX_FILTERS sdl2: AUDIOCVT_MAX_FILTERS +AUDIO_STOPPED sdl2/sdl2.html#AUDIO_STOPPED sdl2: AUDIO_STOPPED +AUDIO_PLAYING sdl2/sdl2.html#AUDIO_PLAYING sdl2: AUDIO_PLAYING +AUDIO_PAUSED sdl2/sdl2.html#AUDIO_PAUSED sdl2: AUDIO_PAUSED +MIX_MAXVOLUME sdl2/sdl2.html#MIX_MAXVOLUME sdl2: MIX_MAXVOLUME +CACHELINE_SIZE sdl2/sdl2.html#CACHELINE_SIZE sdl2: CACHELINE_SIZE +ALPHA_OPAQUE sdl2/sdl2.html#ALPHA_OPAQUE sdl2: ALPHA_OPAQUE +ALPHA_TRANSPARENT sdl2/sdl2.html#ALPHA_TRANSPARENT sdl2: ALPHA_TRANSPARENT +PIXELTYPE_UNKNOWN sdl2/sdl2.html#PIXELTYPE_UNKNOWN sdl2: PIXELTYPE_UNKNOWN +PIXELTYPE_INDEX1 sdl2/sdl2.html#PIXELTYPE_INDEX1 sdl2: PIXELTYPE_INDEX1 +PIXELTYPE_INDEX4 sdl2/sdl2.html#PIXELTYPE_INDEX4 sdl2: PIXELTYPE_INDEX4 +PIXELTYPE_INDEX8 sdl2/sdl2.html#PIXELTYPE_INDEX8 sdl2: PIXELTYPE_INDEX8 +PIXELTYPE_PACKED8 sdl2/sdl2.html#PIXELTYPE_PACKED8 sdl2: PIXELTYPE_PACKED8 +PIXELTYPE_PACKED16 sdl2/sdl2.html#PIXELTYPE_PACKED16 sdl2: PIXELTYPE_PACKED16 +PIXELTYPE_PACKED32 sdl2/sdl2.html#PIXELTYPE_PACKED32 sdl2: PIXELTYPE_PACKED32 +PIXELTYPE_ARRAYU8 sdl2/sdl2.html#PIXELTYPE_ARRAYU8 sdl2: PIXELTYPE_ARRAYU8 +PIXELTYPE_ARRAYU16 sdl2/sdl2.html#PIXELTYPE_ARRAYU16 sdl2: PIXELTYPE_ARRAYU16 +PIXELTYPE_ARRAYU32 sdl2/sdl2.html#PIXELTYPE_ARRAYU32 sdl2: PIXELTYPE_ARRAYU32 +PIXELTYPE_ARRAYF16 sdl2/sdl2.html#PIXELTYPE_ARRAYF16 sdl2: PIXELTYPE_ARRAYF16 +PIXELTYPE_ARRAYF32 sdl2/sdl2.html#PIXELTYPE_ARRAYF32 sdl2: PIXELTYPE_ARRAYF32 +BITMAPORDER_NONE sdl2/sdl2.html#BITMAPORDER_NONE sdl2: BITMAPORDER_NONE +BITMAPORDER_4321 sdl2/sdl2.html#BITMAPORDER_4321 sdl2: BITMAPORDER_4321 +BITMAPORDER_1234 sdl2/sdl2.html#BITMAPORDER_1234 sdl2: BITMAPORDER_1234 +PACKEDORDER_NONE sdl2/sdl2.html#PACKEDORDER_NONE sdl2: PACKEDORDER_NONE +PACKEDORDER_XRGB sdl2/sdl2.html#PACKEDORDER_XRGB sdl2: PACKEDORDER_XRGB +PACKEDORDER_RGBX sdl2/sdl2.html#PACKEDORDER_RGBX sdl2: PACKEDORDER_RGBX +PACKEDORDER_ARGB sdl2/sdl2.html#PACKEDORDER_ARGB sdl2: PACKEDORDER_ARGB +PACKEDORDER_RGBA sdl2/sdl2.html#PACKEDORDER_RGBA sdl2: PACKEDORDER_RGBA +PACKEDORDER_XBGR sdl2/sdl2.html#PACKEDORDER_XBGR sdl2: PACKEDORDER_XBGR +PACKEDORDER_BGRX sdl2/sdl2.html#PACKEDORDER_BGRX sdl2: PACKEDORDER_BGRX +PACKEDORDER_ABGR sdl2/sdl2.html#PACKEDORDER_ABGR sdl2: PACKEDORDER_ABGR +PACKEDORDER_BGRA sdl2/sdl2.html#PACKEDORDER_BGRA sdl2: PACKEDORDER_BGRA +ARRAYORDER_NONE sdl2/sdl2.html#ARRAYORDER_NONE sdl2: ARRAYORDER_NONE +ARRAYORDER_RGB sdl2/sdl2.html#ARRAYORDER_RGB sdl2: ARRAYORDER_RGB +ARRAYORDER_RGBA sdl2/sdl2.html#ARRAYORDER_RGBA sdl2: ARRAYORDER_RGBA +ARRAYORDER_ARGB sdl2/sdl2.html#ARRAYORDER_ARGB sdl2: ARRAYORDER_ARGB +ARRAYORDER_BGR sdl2/sdl2.html#ARRAYORDER_BGR sdl2: ARRAYORDER_BGR +ARRAYORDER_BGRA sdl2/sdl2.html#ARRAYORDER_BGRA sdl2: ARRAYORDER_BGRA +ARRAYORDER_ABGR sdl2/sdl2.html#ARRAYORDER_ABGR sdl2: ARRAYORDER_ABGR +PACKEDLAYOUT_NONE sdl2/sdl2.html#PACKEDLAYOUT_NONE sdl2: PACKEDLAYOUT_NONE +PACKEDLAYOUT_332 sdl2/sdl2.html#PACKEDLAYOUT_332 sdl2: PACKEDLAYOUT_332 +PACKEDLAYOUT_4444 sdl2/sdl2.html#PACKEDLAYOUT_4444 sdl2: PACKEDLAYOUT_4444 +PACKEDLAYOUT_1555 sdl2/sdl2.html#PACKEDLAYOUT_1555 sdl2: PACKEDLAYOUT_1555 +PACKEDLAYOUT_5551 sdl2/sdl2.html#PACKEDLAYOUT_5551 sdl2: PACKEDLAYOUT_5551 +PACKEDLAYOUT_565 sdl2/sdl2.html#PACKEDLAYOUT_565 sdl2: PACKEDLAYOUT_565 +PACKEDLAYOUT_8888 sdl2/sdl2.html#PACKEDLAYOUT_8888 sdl2: PACKEDLAYOUT_8888 +PACKEDLAYOUT_2101010 sdl2/sdl2.html#PACKEDLAYOUT_2101010 sdl2: PACKEDLAYOUT_2101010 +PACKEDLAYOUT_1010102 sdl2/sdl2.html#PACKEDLAYOUT_1010102 sdl2: PACKEDLAYOUT_1010102 +PIXELFORMAT_UNKNOWN sdl2/sdl2.html#PIXELFORMAT_UNKNOWN sdl2: PIXELFORMAT_UNKNOWN +PIXELFORMAT_INDEX1LSB sdl2/sdl2.html#PIXELFORMAT_INDEX1LSB sdl2: PIXELFORMAT_INDEX1LSB +PIXELFORMAT_INDEX1MSB sdl2/sdl2.html#PIXELFORMAT_INDEX1MSB sdl2: PIXELFORMAT_INDEX1MSB +PIXELFORMAT_INDEX4LSB sdl2/sdl2.html#PIXELFORMAT_INDEX4LSB sdl2: PIXELFORMAT_INDEX4LSB +PIXELFORMAT_INDEX4MSB sdl2/sdl2.html#PIXELFORMAT_INDEX4MSB sdl2: PIXELFORMAT_INDEX4MSB +PIXELFORMAT_INDEX8 sdl2/sdl2.html#PIXELFORMAT_INDEX8 sdl2: PIXELFORMAT_INDEX8 +PIXELFORMAT_RGB332 sdl2/sdl2.html#PIXELFORMAT_RGB332 sdl2: PIXELFORMAT_RGB332 +PIXELFORMAT_RGB444 sdl2/sdl2.html#PIXELFORMAT_RGB444 sdl2: PIXELFORMAT_RGB444 +PIXELFORMAT_BGR444 sdl2/sdl2.html#PIXELFORMAT_BGR444 sdl2: PIXELFORMAT_BGR444 +PIXELFORMAT_RGB555 sdl2/sdl2.html#PIXELFORMAT_RGB555 sdl2: PIXELFORMAT_RGB555 +PIXELFORMAT_BGR555 sdl2/sdl2.html#PIXELFORMAT_BGR555 sdl2: PIXELFORMAT_BGR555 +PIXELFORMAT_ARGB4444 sdl2/sdl2.html#PIXELFORMAT_ARGB4444 sdl2: PIXELFORMAT_ARGB4444 +PIXELFORMAT_RGBA4444 sdl2/sdl2.html#PIXELFORMAT_RGBA4444 sdl2: PIXELFORMAT_RGBA4444 +PIXELFORMAT_ABGR4444 sdl2/sdl2.html#PIXELFORMAT_ABGR4444 sdl2: PIXELFORMAT_ABGR4444 +PIXELFORMAT_BGRA4444 sdl2/sdl2.html#PIXELFORMAT_BGRA4444 sdl2: PIXELFORMAT_BGRA4444 +PIXELFORMAT_ARGB1555 sdl2/sdl2.html#PIXELFORMAT_ARGB1555 sdl2: PIXELFORMAT_ARGB1555 +PIXELFORMAT_RGBA5551 sdl2/sdl2.html#PIXELFORMAT_RGBA5551 sdl2: PIXELFORMAT_RGBA5551 +PIXELFORMAT_ABGR1555 sdl2/sdl2.html#PIXELFORMAT_ABGR1555 sdl2: PIXELFORMAT_ABGR1555 +PIXELFORMAT_BGRA5551 sdl2/sdl2.html#PIXELFORMAT_BGRA5551 sdl2: PIXELFORMAT_BGRA5551 +PIXELFORMAT_RGB565 sdl2/sdl2.html#PIXELFORMAT_RGB565 sdl2: PIXELFORMAT_RGB565 +PIXELFORMAT_BGR565 sdl2/sdl2.html#PIXELFORMAT_BGR565 sdl2: PIXELFORMAT_BGR565 +PIXELFORMAT_RGB24 sdl2/sdl2.html#PIXELFORMAT_RGB24 sdl2: PIXELFORMAT_RGB24 +PIXELFORMAT_BGR24 sdl2/sdl2.html#PIXELFORMAT_BGR24 sdl2: PIXELFORMAT_BGR24 +PIXELFORMAT_RGB888 sdl2/sdl2.html#PIXELFORMAT_RGB888 sdl2: PIXELFORMAT_RGB888 +PIXELFORMAT_RGBX8888 sdl2/sdl2.html#PIXELFORMAT_RGBX8888 sdl2: PIXELFORMAT_RGBX8888 +PIXELFORMAT_BGR888 sdl2/sdl2.html#PIXELFORMAT_BGR888 sdl2: PIXELFORMAT_BGR888 +PIXELFORMAT_BGRX8888 sdl2/sdl2.html#PIXELFORMAT_BGRX8888 sdl2: PIXELFORMAT_BGRX8888 +PIXELFORMAT_ARGB8888 sdl2/sdl2.html#PIXELFORMAT_ARGB8888 sdl2: PIXELFORMAT_ARGB8888 +PIXELFORMAT_RGBA8888 sdl2/sdl2.html#PIXELFORMAT_RGBA8888 sdl2: PIXELFORMAT_RGBA8888 +PIXELFORMAT_ABGR8888 sdl2/sdl2.html#PIXELFORMAT_ABGR8888 sdl2: PIXELFORMAT_ABGR8888 +PIXELFORMAT_BGRA8888 sdl2/sdl2.html#PIXELFORMAT_BGRA8888 sdl2: PIXELFORMAT_BGRA8888 +PIXELFORMAT_ARGB2101010 sdl2/sdl2.html#PIXELFORMAT_ARGB2101010 sdl2: PIXELFORMAT_ARGB2101010 +PIXELFORMAT_RGBA32 sdl2/sdl2.html#PIXELFORMAT_RGBA32 sdl2: PIXELFORMAT_RGBA32 +PIXELFORMAT_ARGB32 sdl2/sdl2.html#PIXELFORMAT_ARGB32 sdl2: PIXELFORMAT_ARGB32 +PIXELFORMAT_BGRA32 sdl2/sdl2.html#PIXELFORMAT_BGRA32 sdl2: PIXELFORMAT_BGRA32 +PIXELFORMAT_ABGR32 sdl2/sdl2.html#PIXELFORMAT_ABGR32 sdl2: PIXELFORMAT_ABGR32 +PIXELFORMAT_YV12 sdl2/sdl2.html#PIXELFORMAT_YV12 sdl2: PIXELFORMAT_YV12 +PIXELFORMAT_IYUV sdl2/sdl2.html#PIXELFORMAT_IYUV sdl2: PIXELFORMAT_IYUV +PIXELFORMAT_YUY2 sdl2/sdl2.html#PIXELFORMAT_YUY2 sdl2: PIXELFORMAT_YUY2 +PIXELFORMAT_UYVY sdl2/sdl2.html#PIXELFORMAT_UYVY sdl2: PIXELFORMAT_UYVY +PIXELFORMAT_YVYU sdl2/sdl2.html#PIXELFORMAT_YVYU sdl2: PIXELFORMAT_YVYU +PIXELFORMAT_NV12 sdl2/sdl2.html#PIXELFORMAT_NV12 sdl2: PIXELFORMAT_NV12 +PIXELFORMAT_NV21 sdl2/sdl2.html#PIXELFORMAT_NV21 sdl2: PIXELFORMAT_NV21 +PIXELFORMAT_EXTERNAL_OES sdl2/sdl2.html#PIXELFORMAT_EXTERNAL_OES sdl2: PIXELFORMAT_EXTERNAL_OES +BLENDMODE_NONE sdl2/sdl2.html#BLENDMODE_NONE sdl2: BLENDMODE_NONE +BLENDMODE_BLEND sdl2/sdl2.html#BLENDMODE_BLEND sdl2: BLENDMODE_BLEND +BLENDMODE_ADD sdl2/sdl2.html#BLENDMODE_ADD sdl2: BLENDMODE_ADD +BLENDMODE_MOD sdl2/sdl2.html#BLENDMODE_MOD sdl2: BLENDMODE_MOD +BLENDMODE_MUL sdl2/sdl2.html#BLENDMODE_MUL sdl2: BLENDMODE_MUL +BLENDMODE_INVALID sdl2/sdl2.html#BLENDMODE_INVALID sdl2: BLENDMODE_INVALID +BLENDOPERATION_ADD sdl2/sdl2.html#BLENDOPERATION_ADD sdl2: BLENDOPERATION_ADD +BLENDOPERATION_SUBTRACT sdl2/sdl2.html#BLENDOPERATION_SUBTRACT sdl2: BLENDOPERATION_SUBTRACT +BLENDOPERATION_REV_SUBTRACT sdl2/sdl2.html#BLENDOPERATION_REV_SUBTRACT sdl2: BLENDOPERATION_REV_SUBTRACT +BLENDOPERATION_MINIMUM sdl2/sdl2.html#BLENDOPERATION_MINIMUM sdl2: BLENDOPERATION_MINIMUM +BLENDOPERATION_MAXIMUM sdl2/sdl2.html#BLENDOPERATION_MAXIMUM sdl2: BLENDOPERATION_MAXIMUM +BLENDFACTOR_ZERO sdl2/sdl2.html#BLENDFACTOR_ZERO sdl2: BLENDFACTOR_ZERO +BLENDFACTOR_ONE sdl2/sdl2.html#BLENDFACTOR_ONE sdl2: BLENDFACTOR_ONE +BLENDFACTOR_SRC_COLOR sdl2/sdl2.html#BLENDFACTOR_SRC_COLOR sdl2: BLENDFACTOR_SRC_COLOR +BLENDFACTOR_ONE_MINUS_SRC_COLOR sdl2/sdl2.html#BLENDFACTOR_ONE_MINUS_SRC_COLOR sdl2: BLENDFACTOR_ONE_MINUS_SRC_COLOR +BLENDFACTOR_SRC_ALPHA sdl2/sdl2.html#BLENDFACTOR_SRC_ALPHA sdl2: BLENDFACTOR_SRC_ALPHA +BLENDFACTOR_ONE_MINUS_SRC_ALPHA sdl2/sdl2.html#BLENDFACTOR_ONE_MINUS_SRC_ALPHA sdl2: BLENDFACTOR_ONE_MINUS_SRC_ALPHA +BLENDFACTOR_DST_COLOR sdl2/sdl2.html#BLENDFACTOR_DST_COLOR sdl2: BLENDFACTOR_DST_COLOR +BLENDFACTOR_ONE_MINUS_DST_COLOR sdl2/sdl2.html#BLENDFACTOR_ONE_MINUS_DST_COLOR sdl2: BLENDFACTOR_ONE_MINUS_DST_COLOR +BLENDFACTOR_DST_ALPHA sdl2/sdl2.html#BLENDFACTOR_DST_ALPHA sdl2: BLENDFACTOR_DST_ALPHA +BLENDFACTOR_ONE_MINUS_DST_ALPHA sdl2/sdl2.html#BLENDFACTOR_ONE_MINUS_DST_ALPHA sdl2: BLENDFACTOR_ONE_MINUS_DST_ALPHA +SWSURFACE sdl2/sdl2.html#SWSURFACE sdl2: SWSURFACE +PREALLOC sdl2/sdl2.html#PREALLOC sdl2: PREALLOC +RLEACCEL sdl2/sdl2.html#RLEACCEL sdl2: RLEACCEL +DONTFREE sdl2/sdl2.html#DONTFREE sdl2: DONTFREE +SIMD_ALIGNED sdl2/sdl2.html#SIMD_ALIGNED sdl2: SIMD_ALIGNED +YUV_CONVERSION_JPEG sdl2/sdl2.html#YUV_CONVERSION_JPEG sdl2: YUV_CONVERSION_JPEG +YUV_CONVERSION_BT601 sdl2/sdl2.html#YUV_CONVERSION_BT601 sdl2: YUV_CONVERSION_BT601 +YUV_CONVERSION_BT709 sdl2/sdl2.html#YUV_CONVERSION_BT709 sdl2: YUV_CONVERSION_BT709 +YUV_CONVERSION_AUTOMATIC sdl2/sdl2.html#YUV_CONVERSION_AUTOMATIC sdl2: YUV_CONVERSION_AUTOMATIC +WINDOW_FULLSCREEN sdl2/sdl2.html#WINDOW_FULLSCREEN sdl2: WINDOW_FULLSCREEN +WINDOW_OPENGL sdl2/sdl2.html#WINDOW_OPENGL sdl2: WINDOW_OPENGL +WINDOW_SHOWN sdl2/sdl2.html#WINDOW_SHOWN sdl2: WINDOW_SHOWN +WINDOW_HIDDEN sdl2/sdl2.html#WINDOW_HIDDEN sdl2: WINDOW_HIDDEN +WINDOW_BORDERLESS sdl2/sdl2.html#WINDOW_BORDERLESS sdl2: WINDOW_BORDERLESS +WINDOW_RESIZABLE sdl2/sdl2.html#WINDOW_RESIZABLE sdl2: WINDOW_RESIZABLE +WINDOW_MINIMIZED sdl2/sdl2.html#WINDOW_MINIMIZED sdl2: WINDOW_MINIMIZED +WINDOW_MAXIMIZED sdl2/sdl2.html#WINDOW_MAXIMIZED sdl2: WINDOW_MAXIMIZED +WINDOW_INPUT_GRABBED sdl2/sdl2.html#WINDOW_INPUT_GRABBED sdl2: WINDOW_INPUT_GRABBED +WINDOW_INPUT_FOCUS sdl2/sdl2.html#WINDOW_INPUT_FOCUS sdl2: WINDOW_INPUT_FOCUS +WINDOW_MOUSE_FOCUS sdl2/sdl2.html#WINDOW_MOUSE_FOCUS sdl2: WINDOW_MOUSE_FOCUS +WINDOW_FULLSCREEN_DESKTOP sdl2/sdl2.html#WINDOW_FULLSCREEN_DESKTOP sdl2: WINDOW_FULLSCREEN_DESKTOP +WINDOW_FOREIGN sdl2/sdl2.html#WINDOW_FOREIGN sdl2: WINDOW_FOREIGN +WINDOW_ALLOW_HIGHDPI sdl2/sdl2.html#WINDOW_ALLOW_HIGHDPI sdl2: WINDOW_ALLOW_HIGHDPI +WINDOW_MOUSE_CAPTURE sdl2/sdl2.html#WINDOW_MOUSE_CAPTURE sdl2: WINDOW_MOUSE_CAPTURE +WINDOW_ALWAYS_ON_TOP sdl2/sdl2.html#WINDOW_ALWAYS_ON_TOP sdl2: WINDOW_ALWAYS_ON_TOP +WINDOW_SKIP_TASKBAR sdl2/sdl2.html#WINDOW_SKIP_TASKBAR sdl2: WINDOW_SKIP_TASKBAR +WINDOW_UTILITY sdl2/sdl2.html#WINDOW_UTILITY sdl2: WINDOW_UTILITY +WINDOW_TOOLTIP sdl2/sdl2.html#WINDOW_TOOLTIP sdl2: WINDOW_TOOLTIP +WINDOW_POPUP_MENU sdl2/sdl2.html#WINDOW_POPUP_MENU sdl2: WINDOW_POPUP_MENU +WINDOW_VULKAN sdl2/sdl2.html#WINDOW_VULKAN sdl2: WINDOW_VULKAN +WINDOWEVENT_NONE sdl2/sdl2.html#WINDOWEVENT_NONE sdl2: WINDOWEVENT_NONE +WINDOWEVENT_SHOWN sdl2/sdl2.html#WINDOWEVENT_SHOWN sdl2: WINDOWEVENT_SHOWN +WINDOWEVENT_HIDDEN sdl2/sdl2.html#WINDOWEVENT_HIDDEN sdl2: WINDOWEVENT_HIDDEN +WINDOWEVENT_EXPOSED sdl2/sdl2.html#WINDOWEVENT_EXPOSED sdl2: WINDOWEVENT_EXPOSED +WINDOWEVENT_MOVED sdl2/sdl2.html#WINDOWEVENT_MOVED sdl2: WINDOWEVENT_MOVED +WINDOWEVENT_RESIZED sdl2/sdl2.html#WINDOWEVENT_RESIZED sdl2: WINDOWEVENT_RESIZED +WINDOWEVENT_SIZE_CHANGED sdl2/sdl2.html#WINDOWEVENT_SIZE_CHANGED sdl2: WINDOWEVENT_SIZE_CHANGED +WINDOWEVENT_MINIMIZED sdl2/sdl2.html#WINDOWEVENT_MINIMIZED sdl2: WINDOWEVENT_MINIMIZED +WINDOWEVENT_MAXIMIZED sdl2/sdl2.html#WINDOWEVENT_MAXIMIZED sdl2: WINDOWEVENT_MAXIMIZED +WINDOWEVENT_RESTORED sdl2/sdl2.html#WINDOWEVENT_RESTORED sdl2: WINDOWEVENT_RESTORED +WINDOWEVENT_ENTER sdl2/sdl2.html#WINDOWEVENT_ENTER sdl2: WINDOWEVENT_ENTER +WINDOWEVENT_LEAVE sdl2/sdl2.html#WINDOWEVENT_LEAVE sdl2: WINDOWEVENT_LEAVE +WINDOWEVENT_FOCUS_GAINED sdl2/sdl2.html#WINDOWEVENT_FOCUS_GAINED sdl2: WINDOWEVENT_FOCUS_GAINED +WINDOWEVENT_FOCUS_LOST sdl2/sdl2.html#WINDOWEVENT_FOCUS_LOST sdl2: WINDOWEVENT_FOCUS_LOST +WINDOWEVENT_CLOSE sdl2/sdl2.html#WINDOWEVENT_CLOSE sdl2: WINDOWEVENT_CLOSE +WINDOWEVENT_TAKE_FOCUS sdl2/sdl2.html#WINDOWEVENT_TAKE_FOCUS sdl2: WINDOWEVENT_TAKE_FOCUS +WINDOWEVENT_HIT_TEST sdl2/sdl2.html#WINDOWEVENT_HIT_TEST sdl2: WINDOWEVENT_HIT_TEST +DISPLAYEVENT_NONE sdl2/sdl2.html#DISPLAYEVENT_NONE sdl2: DISPLAYEVENT_NONE +DISPLAYEVENT_ORIENTATION sdl2/sdl2.html#DISPLAYEVENT_ORIENTATION sdl2: DISPLAYEVENT_ORIENTATION +ORIENTATION_UNKNOWN sdl2/sdl2.html#ORIENTATION_UNKNOWN sdl2: ORIENTATION_UNKNOWN +ORIENTATION_LANDSCAPE sdl2/sdl2.html#ORIENTATION_LANDSCAPE sdl2: ORIENTATION_LANDSCAPE +ORIENTATION_LANDSCAPE_FLIPPED sdl2/sdl2.html#ORIENTATION_LANDSCAPE_FLIPPED sdl2: ORIENTATION_LANDSCAPE_FLIPPED +ORIENTATION_PORTRAIT sdl2/sdl2.html#ORIENTATION_PORTRAIT sdl2: ORIENTATION_PORTRAIT +ORIENTATION_PORTRAIT_FLIPPED sdl2/sdl2.html#ORIENTATION_PORTRAIT_FLIPPED sdl2: ORIENTATION_PORTRAIT_FLIPPED +GL_RED_SIZE sdl2/sdl2.html#GL_RED_SIZE sdl2: GL_RED_SIZE +GL_GREEN_SIZE sdl2/sdl2.html#GL_GREEN_SIZE sdl2: GL_GREEN_SIZE +GL_BLUE_SIZE sdl2/sdl2.html#GL_BLUE_SIZE sdl2: GL_BLUE_SIZE +GL_ALPHA_SIZE sdl2/sdl2.html#GL_ALPHA_SIZE sdl2: GL_ALPHA_SIZE +GL_BUFFER_SIZE sdl2/sdl2.html#GL_BUFFER_SIZE sdl2: GL_BUFFER_SIZE +GL_DOUBLEBUFFER sdl2/sdl2.html#GL_DOUBLEBUFFER sdl2: GL_DOUBLEBUFFER +GL_DEPTH_SIZE sdl2/sdl2.html#GL_DEPTH_SIZE sdl2: GL_DEPTH_SIZE +GL_STENCIL_SIZE sdl2/sdl2.html#GL_STENCIL_SIZE sdl2: GL_STENCIL_SIZE +GL_ACCUM_RED_SIZE sdl2/sdl2.html#GL_ACCUM_RED_SIZE sdl2: GL_ACCUM_RED_SIZE +GL_ACCUM_GREEN_SIZE sdl2/sdl2.html#GL_ACCUM_GREEN_SIZE sdl2: GL_ACCUM_GREEN_SIZE +GL_ACCUM_BLUE_SIZE sdl2/sdl2.html#GL_ACCUM_BLUE_SIZE sdl2: GL_ACCUM_BLUE_SIZE +GL_ACCUM_ALPHA_SIZE sdl2/sdl2.html#GL_ACCUM_ALPHA_SIZE sdl2: GL_ACCUM_ALPHA_SIZE +GL_STEREO sdl2/sdl2.html#GL_STEREO sdl2: GL_STEREO +GL_MULTISAMPLEBUFFERS sdl2/sdl2.html#GL_MULTISAMPLEBUFFERS sdl2: GL_MULTISAMPLEBUFFERS +GL_MULTISAMPLESAMPLES sdl2/sdl2.html#GL_MULTISAMPLESAMPLES sdl2: GL_MULTISAMPLESAMPLES +GL_ACCELERATED_VISUAL sdl2/sdl2.html#GL_ACCELERATED_VISUAL sdl2: GL_ACCELERATED_VISUAL +GL_RETAINED_BACKING sdl2/sdl2.html#GL_RETAINED_BACKING sdl2: GL_RETAINED_BACKING +GL_CONTEXT_MAJOR_VERSION sdl2/sdl2.html#GL_CONTEXT_MAJOR_VERSION sdl2: GL_CONTEXT_MAJOR_VERSION +GL_CONTEXT_MINOR_VERSION sdl2/sdl2.html#GL_CONTEXT_MINOR_VERSION sdl2: GL_CONTEXT_MINOR_VERSION +GL_CONTEXT_EGL sdl2/sdl2.html#GL_CONTEXT_EGL sdl2: GL_CONTEXT_EGL +GL_CONTEXT_FLAGS sdl2/sdl2.html#GL_CONTEXT_FLAGS sdl2: GL_CONTEXT_FLAGS +GL_CONTEXT_PROFILE_MASK sdl2/sdl2.html#GL_CONTEXT_PROFILE_MASK sdl2: GL_CONTEXT_PROFILE_MASK +GL_SHARE_WITH_CURRENT_CONTEXT sdl2/sdl2.html#GL_SHARE_WITH_CURRENT_CONTEXT sdl2: GL_SHARE_WITH_CURRENT_CONTEXT +GL_FRAMEBUFFER_SRGB_CAPABLE sdl2/sdl2.html#GL_FRAMEBUFFER_SRGB_CAPABLE sdl2: GL_FRAMEBUFFER_SRGB_CAPABLE +GL_CONTEXT_RELEASE_BEHAVIOR sdl2/sdl2.html#GL_CONTEXT_RELEASE_BEHAVIOR sdl2: GL_CONTEXT_RELEASE_BEHAVIOR +GL_CONTEXT_RESET_NOTIFICATION sdl2/sdl2.html#GL_CONTEXT_RESET_NOTIFICATION sdl2: GL_CONTEXT_RESET_NOTIFICATION +GL_CONTEXT_NO_ERROR sdl2/sdl2.html#GL_CONTEXT_NO_ERROR sdl2: GL_CONTEXT_NO_ERROR +GL_CONTEXT_PROFILE_CORE sdl2/sdl2.html#GL_CONTEXT_PROFILE_CORE sdl2: GL_CONTEXT_PROFILE_CORE +GL_CONTEXT_PROFILE_COMPATIBILITY sdl2/sdl2.html#GL_CONTEXT_PROFILE_COMPATIBILITY sdl2: GL_CONTEXT_PROFILE_COMPATIBILITY +GL_CONTEXT_PROFILE_ES sdl2/sdl2.html#GL_CONTEXT_PROFILE_ES sdl2: GL_CONTEXT_PROFILE_ES +GL_CONTEXT_DEBUG_FLAG sdl2/sdl2.html#GL_CONTEXT_DEBUG_FLAG sdl2: GL_CONTEXT_DEBUG_FLAG +GL_CONTEXT_FORWARD_COMPATIBLE_FLAG sdl2/sdl2.html#GL_CONTEXT_FORWARD_COMPATIBLE_FLAG sdl2: GL_CONTEXT_FORWARD_COMPATIBLE_FLAG +GL_CONTEXT_ROBUST_ACCESS_FLAG sdl2/sdl2.html#GL_CONTEXT_ROBUST_ACCESS_FLAG sdl2: GL_CONTEXT_ROBUST_ACCESS_FLAG +GL_CONTEXT_RESET_ISOLATION_FLAG sdl2/sdl2.html#GL_CONTEXT_RESET_ISOLATION_FLAG sdl2: GL_CONTEXT_RESET_ISOLATION_FLAG +GL_CONTEXT_RELEASE_BEHAVIOR_NONE sdl2/sdl2.html#GL_CONTEXT_RELEASE_BEHAVIOR_NONE sdl2: GL_CONTEXT_RELEASE_BEHAVIOR_NONE +GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH sdl2/sdl2.html#GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH sdl2: GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH +GL_CONTEXT_RESET_NO_NOTIFICATION sdl2/sdl2.html#GL_CONTEXT_RESET_NO_NOTIFICATION sdl2: GL_CONTEXT_RESET_NO_NOTIFICATION +GL_CONTEXT_RESET_LOSE_CONTEXT sdl2/sdl2.html#GL_CONTEXT_RESET_LOSE_CONTEXT sdl2: GL_CONTEXT_RESET_LOSE_CONTEXT +HITTEST_NORMAL sdl2/sdl2.html#HITTEST_NORMAL sdl2: HITTEST_NORMAL +HITTEST_DRAGGABLE sdl2/sdl2.html#HITTEST_DRAGGABLE sdl2: HITTEST_DRAGGABLE +HITTEST_RESIZE_TOPLEFT sdl2/sdl2.html#HITTEST_RESIZE_TOPLEFT sdl2: HITTEST_RESIZE_TOPLEFT +HITTEST_RESIZE_TOP sdl2/sdl2.html#HITTEST_RESIZE_TOP sdl2: HITTEST_RESIZE_TOP +HITTEST_RESIZE_TOPRIGHT sdl2/sdl2.html#HITTEST_RESIZE_TOPRIGHT sdl2: HITTEST_RESIZE_TOPRIGHT +HITTEST_RESIZE_RIGHT sdl2/sdl2.html#HITTEST_RESIZE_RIGHT sdl2: HITTEST_RESIZE_RIGHT +HITTEST_RESIZE_BOTTOMRIGHT sdl2/sdl2.html#HITTEST_RESIZE_BOTTOMRIGHT sdl2: HITTEST_RESIZE_BOTTOMRIGHT +HITTEST_RESIZE_BOTTOM sdl2/sdl2.html#HITTEST_RESIZE_BOTTOM sdl2: HITTEST_RESIZE_BOTTOM +HITTEST_RESIZE_BOTTOMLEFT sdl2/sdl2.html#HITTEST_RESIZE_BOTTOMLEFT sdl2: HITTEST_RESIZE_BOTTOMLEFT +HITTEST_RESIZE_LEFT sdl2/sdl2.html#HITTEST_RESIZE_LEFT sdl2: HITTEST_RESIZE_LEFT +SCANCODE_UNKNOWN sdl2/sdl2.html#SCANCODE_UNKNOWN sdl2: SCANCODE_UNKNOWN +SCANCODE_A sdl2/sdl2.html#SCANCODE_A sdl2: SCANCODE_A +SCANCODE_B sdl2/sdl2.html#SCANCODE_B sdl2: SCANCODE_B +SCANCODE_C sdl2/sdl2.html#SCANCODE_C sdl2: SCANCODE_C +SCANCODE_D sdl2/sdl2.html#SCANCODE_D sdl2: SCANCODE_D +SCANCODE_E sdl2/sdl2.html#SCANCODE_E sdl2: SCANCODE_E +SCANCODE_F sdl2/sdl2.html#SCANCODE_F sdl2: SCANCODE_F +SCANCODE_G sdl2/sdl2.html#SCANCODE_G sdl2: SCANCODE_G +SCANCODE_H sdl2/sdl2.html#SCANCODE_H sdl2: SCANCODE_H +SCANCODE_I sdl2/sdl2.html#SCANCODE_I sdl2: SCANCODE_I +SCANCODE_J sdl2/sdl2.html#SCANCODE_J sdl2: SCANCODE_J +SCANCODE_K sdl2/sdl2.html#SCANCODE_K sdl2: SCANCODE_K +SCANCODE_L sdl2/sdl2.html#SCANCODE_L sdl2: SCANCODE_L +SCANCODE_M sdl2/sdl2.html#SCANCODE_M sdl2: SCANCODE_M +SCANCODE_N sdl2/sdl2.html#SCANCODE_N sdl2: SCANCODE_N +SCANCODE_O sdl2/sdl2.html#SCANCODE_O sdl2: SCANCODE_O +SCANCODE_P sdl2/sdl2.html#SCANCODE_P sdl2: SCANCODE_P +SCANCODE_Q sdl2/sdl2.html#SCANCODE_Q sdl2: SCANCODE_Q +SCANCODE_R sdl2/sdl2.html#SCANCODE_R sdl2: SCANCODE_R +SCANCODE_S sdl2/sdl2.html#SCANCODE_S sdl2: SCANCODE_S +SCANCODE_T sdl2/sdl2.html#SCANCODE_T sdl2: SCANCODE_T +SCANCODE_U sdl2/sdl2.html#SCANCODE_U sdl2: SCANCODE_U +SCANCODE_V sdl2/sdl2.html#SCANCODE_V sdl2: SCANCODE_V +SCANCODE_W sdl2/sdl2.html#SCANCODE_W sdl2: SCANCODE_W +SCANCODE_X sdl2/sdl2.html#SCANCODE_X sdl2: SCANCODE_X +SCANCODE_Y sdl2/sdl2.html#SCANCODE_Y sdl2: SCANCODE_Y +SCANCODE_Z sdl2/sdl2.html#SCANCODE_Z sdl2: SCANCODE_Z +SCANCODE_1 sdl2/sdl2.html#SCANCODE_1 sdl2: SCANCODE_1 +SCANCODE_2 sdl2/sdl2.html#SCANCODE_2 sdl2: SCANCODE_2 +SCANCODE_3 sdl2/sdl2.html#SCANCODE_3 sdl2: SCANCODE_3 +SCANCODE_4 sdl2/sdl2.html#SCANCODE_4 sdl2: SCANCODE_4 +SCANCODE_5 sdl2/sdl2.html#SCANCODE_5 sdl2: SCANCODE_5 +SCANCODE_6 sdl2/sdl2.html#SCANCODE_6 sdl2: SCANCODE_6 +SCANCODE_7 sdl2/sdl2.html#SCANCODE_7 sdl2: SCANCODE_7 +SCANCODE_8 sdl2/sdl2.html#SCANCODE_8 sdl2: SCANCODE_8 +SCANCODE_9 sdl2/sdl2.html#SCANCODE_9 sdl2: SCANCODE_9 +SCANCODE_0 sdl2/sdl2.html#SCANCODE_0 sdl2: SCANCODE_0 +SCANCODE_RETURN sdl2/sdl2.html#SCANCODE_RETURN sdl2: SCANCODE_RETURN +SCANCODE_ESCAPE sdl2/sdl2.html#SCANCODE_ESCAPE sdl2: SCANCODE_ESCAPE +SCANCODE_BACKSPACE sdl2/sdl2.html#SCANCODE_BACKSPACE sdl2: SCANCODE_BACKSPACE +SCANCODE_TAB sdl2/sdl2.html#SCANCODE_TAB sdl2: SCANCODE_TAB +SCANCODE_SPACE sdl2/sdl2.html#SCANCODE_SPACE sdl2: SCANCODE_SPACE +SCANCODE_MINUS sdl2/sdl2.html#SCANCODE_MINUS sdl2: SCANCODE_MINUS +SCANCODE_EQUALS sdl2/sdl2.html#SCANCODE_EQUALS sdl2: SCANCODE_EQUALS +SCANCODE_LEFTBRACKET sdl2/sdl2.html#SCANCODE_LEFTBRACKET sdl2: SCANCODE_LEFTBRACKET +SCANCODE_RIGHTBRACKET sdl2/sdl2.html#SCANCODE_RIGHTBRACKET sdl2: SCANCODE_RIGHTBRACKET +SCANCODE_BACKSLASH sdl2/sdl2.html#SCANCODE_BACKSLASH sdl2: SCANCODE_BACKSLASH +SCANCODE_NONUSHASH sdl2/sdl2.html#SCANCODE_NONUSHASH sdl2: SCANCODE_NONUSHASH +SCANCODE_SEMICOLON sdl2/sdl2.html#SCANCODE_SEMICOLON sdl2: SCANCODE_SEMICOLON +SCANCODE_APOSTROPHE sdl2/sdl2.html#SCANCODE_APOSTROPHE sdl2: SCANCODE_APOSTROPHE +SCANCODE_GRAVE sdl2/sdl2.html#SCANCODE_GRAVE sdl2: SCANCODE_GRAVE +SCANCODE_COMMA sdl2/sdl2.html#SCANCODE_COMMA sdl2: SCANCODE_COMMA +SCANCODE_PERIOD sdl2/sdl2.html#SCANCODE_PERIOD sdl2: SCANCODE_PERIOD +SCANCODE_SLASH sdl2/sdl2.html#SCANCODE_SLASH sdl2: SCANCODE_SLASH +SCANCODE_CAPSLOCK sdl2/sdl2.html#SCANCODE_CAPSLOCK sdl2: SCANCODE_CAPSLOCK +SCANCODE_F1 sdl2/sdl2.html#SCANCODE_F1 sdl2: SCANCODE_F1 +SCANCODE_F2 sdl2/sdl2.html#SCANCODE_F2 sdl2: SCANCODE_F2 +SCANCODE_F3 sdl2/sdl2.html#SCANCODE_F3 sdl2: SCANCODE_F3 +SCANCODE_F4 sdl2/sdl2.html#SCANCODE_F4 sdl2: SCANCODE_F4 +SCANCODE_F5 sdl2/sdl2.html#SCANCODE_F5 sdl2: SCANCODE_F5 +SCANCODE_F6 sdl2/sdl2.html#SCANCODE_F6 sdl2: SCANCODE_F6 +SCANCODE_F7 sdl2/sdl2.html#SCANCODE_F7 sdl2: SCANCODE_F7 +SCANCODE_F8 sdl2/sdl2.html#SCANCODE_F8 sdl2: SCANCODE_F8 +SCANCODE_F9 sdl2/sdl2.html#SCANCODE_F9 sdl2: SCANCODE_F9 +SCANCODE_F10 sdl2/sdl2.html#SCANCODE_F10 sdl2: SCANCODE_F10 +SCANCODE_F11 sdl2/sdl2.html#SCANCODE_F11 sdl2: SCANCODE_F11 +SCANCODE_F12 sdl2/sdl2.html#SCANCODE_F12 sdl2: SCANCODE_F12 +SCANCODE_PRINTSCREEN sdl2/sdl2.html#SCANCODE_PRINTSCREEN sdl2: SCANCODE_PRINTSCREEN +SCANCODE_SCROLLLOCK sdl2/sdl2.html#SCANCODE_SCROLLLOCK sdl2: SCANCODE_SCROLLLOCK +SCANCODE_PAUSE sdl2/sdl2.html#SCANCODE_PAUSE sdl2: SCANCODE_PAUSE +SCANCODE_INSERT sdl2/sdl2.html#SCANCODE_INSERT sdl2: SCANCODE_INSERT +SCANCODE_HOME sdl2/sdl2.html#SCANCODE_HOME sdl2: SCANCODE_HOME +SCANCODE_PAGEUP sdl2/sdl2.html#SCANCODE_PAGEUP sdl2: SCANCODE_PAGEUP +SCANCODE_DELETE sdl2/sdl2.html#SCANCODE_DELETE sdl2: SCANCODE_DELETE +SCANCODE_END sdl2/sdl2.html#SCANCODE_END sdl2: SCANCODE_END +SCANCODE_PAGEDOWN sdl2/sdl2.html#SCANCODE_PAGEDOWN sdl2: SCANCODE_PAGEDOWN +SCANCODE_RIGHT sdl2/sdl2.html#SCANCODE_RIGHT sdl2: SCANCODE_RIGHT +SCANCODE_LEFT sdl2/sdl2.html#SCANCODE_LEFT sdl2: SCANCODE_LEFT +SCANCODE_DOWN sdl2/sdl2.html#SCANCODE_DOWN sdl2: SCANCODE_DOWN +SCANCODE_UP sdl2/sdl2.html#SCANCODE_UP sdl2: SCANCODE_UP +SCANCODE_NUMLOCKCLEAR sdl2/sdl2.html#SCANCODE_NUMLOCKCLEAR sdl2: SCANCODE_NUMLOCKCLEAR +SCANCODE_KP_DIVIDE sdl2/sdl2.html#SCANCODE_KP_DIVIDE sdl2: SCANCODE_KP_DIVIDE +SCANCODE_KP_MULTIPLY sdl2/sdl2.html#SCANCODE_KP_MULTIPLY sdl2: SCANCODE_KP_MULTIPLY +SCANCODE_KP_MINUS sdl2/sdl2.html#SCANCODE_KP_MINUS sdl2: SCANCODE_KP_MINUS +SCANCODE_KP_PLUS sdl2/sdl2.html#SCANCODE_KP_PLUS sdl2: SCANCODE_KP_PLUS +SCANCODE_KP_ENTER sdl2/sdl2.html#SCANCODE_KP_ENTER sdl2: SCANCODE_KP_ENTER +SCANCODE_KP_1 sdl2/sdl2.html#SCANCODE_KP_1 sdl2: SCANCODE_KP_1 +SCANCODE_KP_2 sdl2/sdl2.html#SCANCODE_KP_2 sdl2: SCANCODE_KP_2 +SCANCODE_KP_3 sdl2/sdl2.html#SCANCODE_KP_3 sdl2: SCANCODE_KP_3 +SCANCODE_KP_4 sdl2/sdl2.html#SCANCODE_KP_4 sdl2: SCANCODE_KP_4 +SCANCODE_KP_5 sdl2/sdl2.html#SCANCODE_KP_5 sdl2: SCANCODE_KP_5 +SCANCODE_KP_6 sdl2/sdl2.html#SCANCODE_KP_6 sdl2: SCANCODE_KP_6 +SCANCODE_KP_7 sdl2/sdl2.html#SCANCODE_KP_7 sdl2: SCANCODE_KP_7 +SCANCODE_KP_8 sdl2/sdl2.html#SCANCODE_KP_8 sdl2: SCANCODE_KP_8 +SCANCODE_KP_9 sdl2/sdl2.html#SCANCODE_KP_9 sdl2: SCANCODE_KP_9 +SCANCODE_KP_0 sdl2/sdl2.html#SCANCODE_KP_0 sdl2: SCANCODE_KP_0 +SCANCODE_KP_PERIOD sdl2/sdl2.html#SCANCODE_KP_PERIOD sdl2: SCANCODE_KP_PERIOD +SCANCODE_NONUSBACKSLASH sdl2/sdl2.html#SCANCODE_NONUSBACKSLASH sdl2: SCANCODE_NONUSBACKSLASH +SCANCODE_APPLICATION sdl2/sdl2.html#SCANCODE_APPLICATION sdl2: SCANCODE_APPLICATION +SCANCODE_POWER sdl2/sdl2.html#SCANCODE_POWER sdl2: SCANCODE_POWER +SCANCODE_KP_EQUALS sdl2/sdl2.html#SCANCODE_KP_EQUALS sdl2: SCANCODE_KP_EQUALS +SCANCODE_F13 sdl2/sdl2.html#SCANCODE_F13 sdl2: SCANCODE_F13 +SCANCODE_F14 sdl2/sdl2.html#SCANCODE_F14 sdl2: SCANCODE_F14 +SCANCODE_F15 sdl2/sdl2.html#SCANCODE_F15 sdl2: SCANCODE_F15 +SCANCODE_F16 sdl2/sdl2.html#SCANCODE_F16 sdl2: SCANCODE_F16 +SCANCODE_F17 sdl2/sdl2.html#SCANCODE_F17 sdl2: SCANCODE_F17 +SCANCODE_F18 sdl2/sdl2.html#SCANCODE_F18 sdl2: SCANCODE_F18 +SCANCODE_F19 sdl2/sdl2.html#SCANCODE_F19 sdl2: SCANCODE_F19 +SCANCODE_F20 sdl2/sdl2.html#SCANCODE_F20 sdl2: SCANCODE_F20 +SCANCODE_F21 sdl2/sdl2.html#SCANCODE_F21 sdl2: SCANCODE_F21 +SCANCODE_F22 sdl2/sdl2.html#SCANCODE_F22 sdl2: SCANCODE_F22 +SCANCODE_F23 sdl2/sdl2.html#SCANCODE_F23 sdl2: SCANCODE_F23 +SCANCODE_F24 sdl2/sdl2.html#SCANCODE_F24 sdl2: SCANCODE_F24 +SCANCODE_EXECUTE sdl2/sdl2.html#SCANCODE_EXECUTE sdl2: SCANCODE_EXECUTE +SCANCODE_HELP sdl2/sdl2.html#SCANCODE_HELP sdl2: SCANCODE_HELP +SCANCODE_MENU sdl2/sdl2.html#SCANCODE_MENU sdl2: SCANCODE_MENU +SCANCODE_SELECT sdl2/sdl2.html#SCANCODE_SELECT sdl2: SCANCODE_SELECT +SCANCODE_STOP sdl2/sdl2.html#SCANCODE_STOP sdl2: SCANCODE_STOP +SCANCODE_AGAIN sdl2/sdl2.html#SCANCODE_AGAIN sdl2: SCANCODE_AGAIN +SCANCODE_UNDO sdl2/sdl2.html#SCANCODE_UNDO sdl2: SCANCODE_UNDO +SCANCODE_CUT sdl2/sdl2.html#SCANCODE_CUT sdl2: SCANCODE_CUT +SCANCODE_COPY sdl2/sdl2.html#SCANCODE_COPY sdl2: SCANCODE_COPY +SCANCODE_PASTE sdl2/sdl2.html#SCANCODE_PASTE sdl2: SCANCODE_PASTE +SCANCODE_FIND sdl2/sdl2.html#SCANCODE_FIND sdl2: SCANCODE_FIND +SCANCODE_MUTE sdl2/sdl2.html#SCANCODE_MUTE sdl2: SCANCODE_MUTE +SCANCODE_VOLUMEUP sdl2/sdl2.html#SCANCODE_VOLUMEUP sdl2: SCANCODE_VOLUMEUP +SCANCODE_VOLUMEDOWN sdl2/sdl2.html#SCANCODE_VOLUMEDOWN sdl2: SCANCODE_VOLUMEDOWN +SCANCODE_KP_COMMA sdl2/sdl2.html#SCANCODE_KP_COMMA sdl2: SCANCODE_KP_COMMA +SCANCODE_KP_EQUALSAS400 sdl2/sdl2.html#SCANCODE_KP_EQUALSAS400 sdl2: SCANCODE_KP_EQUALSAS400 +SCANCODE_INTERNATIONAL1 sdl2/sdl2.html#SCANCODE_INTERNATIONAL1 sdl2: SCANCODE_INTERNATIONAL1 +SCANCODE_INTERNATIONAL2 sdl2/sdl2.html#SCANCODE_INTERNATIONAL2 sdl2: SCANCODE_INTERNATIONAL2 +SCANCODE_INTERNATIONAL3 sdl2/sdl2.html#SCANCODE_INTERNATIONAL3 sdl2: SCANCODE_INTERNATIONAL3 +SCANCODE_INTERNATIONAL4 sdl2/sdl2.html#SCANCODE_INTERNATIONAL4 sdl2: SCANCODE_INTERNATIONAL4 +SCANCODE_INTERNATIONAL5 sdl2/sdl2.html#SCANCODE_INTERNATIONAL5 sdl2: SCANCODE_INTERNATIONAL5 +SCANCODE_INTERNATIONAL6 sdl2/sdl2.html#SCANCODE_INTERNATIONAL6 sdl2: SCANCODE_INTERNATIONAL6 +SCANCODE_INTERNATIONAL7 sdl2/sdl2.html#SCANCODE_INTERNATIONAL7 sdl2: SCANCODE_INTERNATIONAL7 +SCANCODE_INTERNATIONAL8 sdl2/sdl2.html#SCANCODE_INTERNATIONAL8 sdl2: SCANCODE_INTERNATIONAL8 +SCANCODE_INTERNATIONAL9 sdl2/sdl2.html#SCANCODE_INTERNATIONAL9 sdl2: SCANCODE_INTERNATIONAL9 +SCANCODE_LANG1 sdl2/sdl2.html#SCANCODE_LANG1 sdl2: SCANCODE_LANG1 +SCANCODE_LANG2 sdl2/sdl2.html#SCANCODE_LANG2 sdl2: SCANCODE_LANG2 +SCANCODE_LANG3 sdl2/sdl2.html#SCANCODE_LANG3 sdl2: SCANCODE_LANG3 +SCANCODE_LANG4 sdl2/sdl2.html#SCANCODE_LANG4 sdl2: SCANCODE_LANG4 +SCANCODE_LANG5 sdl2/sdl2.html#SCANCODE_LANG5 sdl2: SCANCODE_LANG5 +SCANCODE_LANG6 sdl2/sdl2.html#SCANCODE_LANG6 sdl2: SCANCODE_LANG6 +SCANCODE_LANG7 sdl2/sdl2.html#SCANCODE_LANG7 sdl2: SCANCODE_LANG7 +SCANCODE_LANG8 sdl2/sdl2.html#SCANCODE_LANG8 sdl2: SCANCODE_LANG8 +SCANCODE_LANG9 sdl2/sdl2.html#SCANCODE_LANG9 sdl2: SCANCODE_LANG9 +SCANCODE_ALTERASE sdl2/sdl2.html#SCANCODE_ALTERASE sdl2: SCANCODE_ALTERASE +SCANCODE_SYSREQ sdl2/sdl2.html#SCANCODE_SYSREQ sdl2: SCANCODE_SYSREQ +SCANCODE_CANCEL sdl2/sdl2.html#SCANCODE_CANCEL sdl2: SCANCODE_CANCEL +SCANCODE_CLEAR sdl2/sdl2.html#SCANCODE_CLEAR sdl2: SCANCODE_CLEAR +SCANCODE_PRIOR sdl2/sdl2.html#SCANCODE_PRIOR sdl2: SCANCODE_PRIOR +SCANCODE_RETURN2 sdl2/sdl2.html#SCANCODE_RETURN2 sdl2: SCANCODE_RETURN2 +SCANCODE_SEPARATOR sdl2/sdl2.html#SCANCODE_SEPARATOR sdl2: SCANCODE_SEPARATOR +SCANCODE_OUT sdl2/sdl2.html#SCANCODE_OUT sdl2: SCANCODE_OUT +SCANCODE_OPER sdl2/sdl2.html#SCANCODE_OPER sdl2: SCANCODE_OPER +SCANCODE_CLEARAGAIN sdl2/sdl2.html#SCANCODE_CLEARAGAIN sdl2: SCANCODE_CLEARAGAIN +SCANCODE_CRSEL sdl2/sdl2.html#SCANCODE_CRSEL sdl2: SCANCODE_CRSEL +SCANCODE_EXSEL sdl2/sdl2.html#SCANCODE_EXSEL sdl2: SCANCODE_EXSEL +SCANCODE_KP_00 sdl2/sdl2.html#SCANCODE_KP_00 sdl2: SCANCODE_KP_00 +SCANCODE_KP_000 sdl2/sdl2.html#SCANCODE_KP_000 sdl2: SCANCODE_KP_000 +SCANCODE_THOUSANDSSEPARATOR sdl2/sdl2.html#SCANCODE_THOUSANDSSEPARATOR sdl2: SCANCODE_THOUSANDSSEPARATOR +SCANCODE_DECIMALSEPARATOR sdl2/sdl2.html#SCANCODE_DECIMALSEPARATOR sdl2: SCANCODE_DECIMALSEPARATOR +SCANCODE_CURRENCYUNIT sdl2/sdl2.html#SCANCODE_CURRENCYUNIT sdl2: SCANCODE_CURRENCYUNIT +SCANCODE_CURRENCYSUBUNIT sdl2/sdl2.html#SCANCODE_CURRENCYSUBUNIT sdl2: SCANCODE_CURRENCYSUBUNIT +SCANCODE_KP_LEFTPAREN sdl2/sdl2.html#SCANCODE_KP_LEFTPAREN sdl2: SCANCODE_KP_LEFTPAREN +SCANCODE_KP_RIGHTPAREN sdl2/sdl2.html#SCANCODE_KP_RIGHTPAREN sdl2: SCANCODE_KP_RIGHTPAREN +SCANCODE_KP_LEFTBRACE sdl2/sdl2.html#SCANCODE_KP_LEFTBRACE sdl2: SCANCODE_KP_LEFTBRACE +SCANCODE_KP_RIGHTBRACE sdl2/sdl2.html#SCANCODE_KP_RIGHTBRACE sdl2: SCANCODE_KP_RIGHTBRACE +SCANCODE_KP_TAB sdl2/sdl2.html#SCANCODE_KP_TAB sdl2: SCANCODE_KP_TAB +SCANCODE_KP_BACKSPACE sdl2/sdl2.html#SCANCODE_KP_BACKSPACE sdl2: SCANCODE_KP_BACKSPACE +SCANCODE_KP_A sdl2/sdl2.html#SCANCODE_KP_A sdl2: SCANCODE_KP_A +SCANCODE_KP_B sdl2/sdl2.html#SCANCODE_KP_B sdl2: SCANCODE_KP_B +SCANCODE_KP_C sdl2/sdl2.html#SCANCODE_KP_C sdl2: SCANCODE_KP_C +SCANCODE_KP_D sdl2/sdl2.html#SCANCODE_KP_D sdl2: SCANCODE_KP_D +SCANCODE_KP_E sdl2/sdl2.html#SCANCODE_KP_E sdl2: SCANCODE_KP_E +SCANCODE_KP_F sdl2/sdl2.html#SCANCODE_KP_F sdl2: SCANCODE_KP_F +SCANCODE_KP_XOR sdl2/sdl2.html#SCANCODE_KP_XOR sdl2: SCANCODE_KP_XOR +SCANCODE_KP_POWER sdl2/sdl2.html#SCANCODE_KP_POWER sdl2: SCANCODE_KP_POWER +SCANCODE_KP_PERCENT sdl2/sdl2.html#SCANCODE_KP_PERCENT sdl2: SCANCODE_KP_PERCENT +SCANCODE_KP_LESS sdl2/sdl2.html#SCANCODE_KP_LESS sdl2: SCANCODE_KP_LESS +SCANCODE_KP_GREATER sdl2/sdl2.html#SCANCODE_KP_GREATER sdl2: SCANCODE_KP_GREATER +SCANCODE_KP_AMPERSAND sdl2/sdl2.html#SCANCODE_KP_AMPERSAND sdl2: SCANCODE_KP_AMPERSAND +SCANCODE_KP_DBLAMPERSAND sdl2/sdl2.html#SCANCODE_KP_DBLAMPERSAND sdl2: SCANCODE_KP_DBLAMPERSAND +SCANCODE_KP_VERTICALBAR sdl2/sdl2.html#SCANCODE_KP_VERTICALBAR sdl2: SCANCODE_KP_VERTICALBAR +SCANCODE_KP_DBLVERTICALBAR sdl2/sdl2.html#SCANCODE_KP_DBLVERTICALBAR sdl2: SCANCODE_KP_DBLVERTICALBAR +SCANCODE_KP_COLON sdl2/sdl2.html#SCANCODE_KP_COLON sdl2: SCANCODE_KP_COLON +SCANCODE_KP_HASH sdl2/sdl2.html#SCANCODE_KP_HASH sdl2: SCANCODE_KP_HASH +SCANCODE_KP_SPACE sdl2/sdl2.html#SCANCODE_KP_SPACE sdl2: SCANCODE_KP_SPACE +SCANCODE_KP_AT sdl2/sdl2.html#SCANCODE_KP_AT sdl2: SCANCODE_KP_AT +SCANCODE_KP_EXCLAM sdl2/sdl2.html#SCANCODE_KP_EXCLAM sdl2: SCANCODE_KP_EXCLAM +SCANCODE_KP_MEMSTORE sdl2/sdl2.html#SCANCODE_KP_MEMSTORE sdl2: SCANCODE_KP_MEMSTORE +SCANCODE_KP_MEMRECALL sdl2/sdl2.html#SCANCODE_KP_MEMRECALL sdl2: SCANCODE_KP_MEMRECALL +SCANCODE_KP_MEMCLEAR sdl2/sdl2.html#SCANCODE_KP_MEMCLEAR sdl2: SCANCODE_KP_MEMCLEAR +SCANCODE_KP_MEMADD sdl2/sdl2.html#SCANCODE_KP_MEMADD sdl2: SCANCODE_KP_MEMADD +SCANCODE_KP_MEMSUBTRACT sdl2/sdl2.html#SCANCODE_KP_MEMSUBTRACT sdl2: SCANCODE_KP_MEMSUBTRACT +SCANCODE_KP_MEMMULTIPLY sdl2/sdl2.html#SCANCODE_KP_MEMMULTIPLY sdl2: SCANCODE_KP_MEMMULTIPLY +SCANCODE_KP_MEMDIVIDE sdl2/sdl2.html#SCANCODE_KP_MEMDIVIDE sdl2: SCANCODE_KP_MEMDIVIDE +SCANCODE_KP_PLUSMINUS sdl2/sdl2.html#SCANCODE_KP_PLUSMINUS sdl2: SCANCODE_KP_PLUSMINUS +SCANCODE_KP_CLEAR sdl2/sdl2.html#SCANCODE_KP_CLEAR sdl2: SCANCODE_KP_CLEAR +SCANCODE_KP_CLEARENTRY sdl2/sdl2.html#SCANCODE_KP_CLEARENTRY sdl2: SCANCODE_KP_CLEARENTRY +SCANCODE_KP_BINARY sdl2/sdl2.html#SCANCODE_KP_BINARY sdl2: SCANCODE_KP_BINARY +SCANCODE_KP_OCTAL sdl2/sdl2.html#SCANCODE_KP_OCTAL sdl2: SCANCODE_KP_OCTAL +SCANCODE_KP_DECIMAL sdl2/sdl2.html#SCANCODE_KP_DECIMAL sdl2: SCANCODE_KP_DECIMAL +SCANCODE_KP_HEXADECIMAL sdl2/sdl2.html#SCANCODE_KP_HEXADECIMAL sdl2: SCANCODE_KP_HEXADECIMAL +SCANCODE_LCTRL sdl2/sdl2.html#SCANCODE_LCTRL sdl2: SCANCODE_LCTRL +SCANCODE_LSHIFT sdl2/sdl2.html#SCANCODE_LSHIFT sdl2: SCANCODE_LSHIFT +SCANCODE_LALT sdl2/sdl2.html#SCANCODE_LALT sdl2: SCANCODE_LALT +SCANCODE_LGUI sdl2/sdl2.html#SCANCODE_LGUI sdl2: SCANCODE_LGUI +SCANCODE_RCTRL sdl2/sdl2.html#SCANCODE_RCTRL sdl2: SCANCODE_RCTRL +SCANCODE_RSHIFT sdl2/sdl2.html#SCANCODE_RSHIFT sdl2: SCANCODE_RSHIFT +SCANCODE_RALT sdl2/sdl2.html#SCANCODE_RALT sdl2: SCANCODE_RALT +SCANCODE_RGUI sdl2/sdl2.html#SCANCODE_RGUI sdl2: SCANCODE_RGUI +SCANCODE_MODE sdl2/sdl2.html#SCANCODE_MODE sdl2: SCANCODE_MODE +SCANCODE_AUDIONEXT sdl2/sdl2.html#SCANCODE_AUDIONEXT sdl2: SCANCODE_AUDIONEXT +SCANCODE_AUDIOPREV sdl2/sdl2.html#SCANCODE_AUDIOPREV sdl2: SCANCODE_AUDIOPREV +SCANCODE_AUDIOSTOP sdl2/sdl2.html#SCANCODE_AUDIOSTOP sdl2: SCANCODE_AUDIOSTOP +SCANCODE_AUDIOPLAY sdl2/sdl2.html#SCANCODE_AUDIOPLAY sdl2: SCANCODE_AUDIOPLAY +SCANCODE_AUDIOMUTE sdl2/sdl2.html#SCANCODE_AUDIOMUTE sdl2: SCANCODE_AUDIOMUTE +SCANCODE_MEDIASELECT sdl2/sdl2.html#SCANCODE_MEDIASELECT sdl2: SCANCODE_MEDIASELECT +SCANCODE_WWW sdl2/sdl2.html#SCANCODE_WWW sdl2: SCANCODE_WWW +SCANCODE_MAIL sdl2/sdl2.html#SCANCODE_MAIL sdl2: SCANCODE_MAIL +SCANCODE_CALCULATOR sdl2/sdl2.html#SCANCODE_CALCULATOR sdl2: SCANCODE_CALCULATOR +SCANCODE_COMPUTER sdl2/sdl2.html#SCANCODE_COMPUTER sdl2: SCANCODE_COMPUTER +SCANCODE_AC_SEARCH sdl2/sdl2.html#SCANCODE_AC_SEARCH sdl2: SCANCODE_AC_SEARCH +SCANCODE_AC_HOME sdl2/sdl2.html#SCANCODE_AC_HOME sdl2: SCANCODE_AC_HOME +SCANCODE_AC_BACK sdl2/sdl2.html#SCANCODE_AC_BACK sdl2: SCANCODE_AC_BACK +SCANCODE_AC_FORWARD sdl2/sdl2.html#SCANCODE_AC_FORWARD sdl2: SCANCODE_AC_FORWARD +SCANCODE_AC_STOP sdl2/sdl2.html#SCANCODE_AC_STOP sdl2: SCANCODE_AC_STOP +SCANCODE_AC_REFRESH sdl2/sdl2.html#SCANCODE_AC_REFRESH sdl2: SCANCODE_AC_REFRESH +SCANCODE_AC_BOOKMARKS sdl2/sdl2.html#SCANCODE_AC_BOOKMARKS sdl2: SCANCODE_AC_BOOKMARKS +SCANCODE_BRIGHTNESSDOWN sdl2/sdl2.html#SCANCODE_BRIGHTNESSDOWN sdl2: SCANCODE_BRIGHTNESSDOWN +SCANCODE_BRIGHTNESSUP sdl2/sdl2.html#SCANCODE_BRIGHTNESSUP sdl2: SCANCODE_BRIGHTNESSUP +SCANCODE_DISPLAYSWITCH sdl2/sdl2.html#SCANCODE_DISPLAYSWITCH sdl2: SCANCODE_DISPLAYSWITCH +SCANCODE_KBDILLUMTOGGLE sdl2/sdl2.html#SCANCODE_KBDILLUMTOGGLE sdl2: SCANCODE_KBDILLUMTOGGLE +SCANCODE_KBDILLUMDOWN sdl2/sdl2.html#SCANCODE_KBDILLUMDOWN sdl2: SCANCODE_KBDILLUMDOWN +SCANCODE_KBDILLUMUP sdl2/sdl2.html#SCANCODE_KBDILLUMUP sdl2: SCANCODE_KBDILLUMUP +SCANCODE_EJECT sdl2/sdl2.html#SCANCODE_EJECT sdl2: SCANCODE_EJECT +SCANCODE_SLEEP sdl2/sdl2.html#SCANCODE_SLEEP sdl2: SCANCODE_SLEEP +SCANCODE_APP1 sdl2/sdl2.html#SCANCODE_APP1 sdl2: SCANCODE_APP1 +SCANCODE_APP2 sdl2/sdl2.html#SCANCODE_APP2 sdl2: SCANCODE_APP2 +SCANCODE_AUDIOREWIND sdl2/sdl2.html#SCANCODE_AUDIOREWIND sdl2: SCANCODE_AUDIOREWIND +SCANCODE_AUDIOFASTFORWARD sdl2/sdl2.html#SCANCODE_AUDIOFASTFORWARD sdl2: SCANCODE_AUDIOFASTFORWARD +NUM_SCANCODES sdl2/sdl2.html#NUM_SCANCODES sdl2: NUM_SCANCODES +KEYCODE_SCANCODE_MASK sdl2/sdl2.html#KEYCODE_SCANCODE_MASK sdl2: KEYCODE_SCANCODE_MASK +KEYCODE_UNKNOWN sdl2/sdl2.html#KEYCODE_UNKNOWN sdl2: KEYCODE_UNKNOWN +KEYCODE_RETURN sdl2/sdl2.html#KEYCODE_RETURN sdl2: KEYCODE_RETURN +KEYCODE_ESCAPE sdl2/sdl2.html#KEYCODE_ESCAPE sdl2: KEYCODE_ESCAPE +KEYCODE_BACKSPACE sdl2/sdl2.html#KEYCODE_BACKSPACE sdl2: KEYCODE_BACKSPACE +KEYCODE_TAB sdl2/sdl2.html#KEYCODE_TAB sdl2: KEYCODE_TAB +KEYCODE_SPACE sdl2/sdl2.html#KEYCODE_SPACE sdl2: KEYCODE_SPACE +KEYCODE_EXCLAIM sdl2/sdl2.html#KEYCODE_EXCLAIM sdl2: KEYCODE_EXCLAIM +KEYCODE_QUOTEDBL sdl2/sdl2.html#KEYCODE_QUOTEDBL sdl2: KEYCODE_QUOTEDBL +KEYCODE_HASH sdl2/sdl2.html#KEYCODE_HASH sdl2: KEYCODE_HASH +KEYCODE_PERCENT sdl2/sdl2.html#KEYCODE_PERCENT sdl2: KEYCODE_PERCENT +KEYCODE_DOLLAR sdl2/sdl2.html#KEYCODE_DOLLAR sdl2: KEYCODE_DOLLAR +KEYCODE_AMPERSAND sdl2/sdl2.html#KEYCODE_AMPERSAND sdl2: KEYCODE_AMPERSAND +KEYCODE_QUOTE sdl2/sdl2.html#KEYCODE_QUOTE sdl2: KEYCODE_QUOTE +KEYCODE_LEFTPAREN sdl2/sdl2.html#KEYCODE_LEFTPAREN sdl2: KEYCODE_LEFTPAREN +KEYCODE_RIGHTPAREN sdl2/sdl2.html#KEYCODE_RIGHTPAREN sdl2: KEYCODE_RIGHTPAREN +KEYCODE_ASTERISK sdl2/sdl2.html#KEYCODE_ASTERISK sdl2: KEYCODE_ASTERISK +KEYCODE_PLUS sdl2/sdl2.html#KEYCODE_PLUS sdl2: KEYCODE_PLUS +KEYCODE_COMMA sdl2/sdl2.html#KEYCODE_COMMA sdl2: KEYCODE_COMMA +KEYCODE_MINUS sdl2/sdl2.html#KEYCODE_MINUS sdl2: KEYCODE_MINUS +KEYCODE_PERIOD sdl2/sdl2.html#KEYCODE_PERIOD sdl2: KEYCODE_PERIOD +KEYCODE_SLASH sdl2/sdl2.html#KEYCODE_SLASH sdl2: KEYCODE_SLASH +KEYCODE_0 sdl2/sdl2.html#KEYCODE_0 sdl2: KEYCODE_0 +KEYCODE_1 sdl2/sdl2.html#KEYCODE_1 sdl2: KEYCODE_1 +KEYCODE_2 sdl2/sdl2.html#KEYCODE_2 sdl2: KEYCODE_2 +KEYCODE_3 sdl2/sdl2.html#KEYCODE_3 sdl2: KEYCODE_3 +KEYCODE_4 sdl2/sdl2.html#KEYCODE_4 sdl2: KEYCODE_4 +KEYCODE_5 sdl2/sdl2.html#KEYCODE_5 sdl2: KEYCODE_5 +KEYCODE_6 sdl2/sdl2.html#KEYCODE_6 sdl2: KEYCODE_6 +KEYCODE_7 sdl2/sdl2.html#KEYCODE_7 sdl2: KEYCODE_7 +KEYCODE_8 sdl2/sdl2.html#KEYCODE_8 sdl2: KEYCODE_8 +KEYCODE_9 sdl2/sdl2.html#KEYCODE_9 sdl2: KEYCODE_9 +KEYCODE_COLON sdl2/sdl2.html#KEYCODE_COLON sdl2: KEYCODE_COLON +KEYCODE_SEMICOLON sdl2/sdl2.html#KEYCODE_SEMICOLON sdl2: KEYCODE_SEMICOLON +KEYCODE_LESS sdl2/sdl2.html#KEYCODE_LESS sdl2: KEYCODE_LESS +KEYCODE_EQUALS sdl2/sdl2.html#KEYCODE_EQUALS sdl2: KEYCODE_EQUALS +KEYCODE_GREATER sdl2/sdl2.html#KEYCODE_GREATER sdl2: KEYCODE_GREATER +KEYCODE_QUESTION sdl2/sdl2.html#KEYCODE_QUESTION sdl2: KEYCODE_QUESTION +KEYCODE_AT sdl2/sdl2.html#KEYCODE_AT sdl2: KEYCODE_AT +KEYCODE_LEFTBRACKET sdl2/sdl2.html#KEYCODE_LEFTBRACKET sdl2: KEYCODE_LEFTBRACKET +KEYCODE_BACKSLASH sdl2/sdl2.html#KEYCODE_BACKSLASH sdl2: KEYCODE_BACKSLASH +KEYCODE_RIGHTBRACKET sdl2/sdl2.html#KEYCODE_RIGHTBRACKET sdl2: KEYCODE_RIGHTBRACKET +KEYCODE_CARET sdl2/sdl2.html#KEYCODE_CARET sdl2: KEYCODE_CARET +KEYCODE_UNDERSCORE sdl2/sdl2.html#KEYCODE_UNDERSCORE sdl2: KEYCODE_UNDERSCORE +KEYCODE_BACKQUOTE sdl2/sdl2.html#KEYCODE_BACKQUOTE sdl2: KEYCODE_BACKQUOTE +KEYCODE_a sdl2/sdl2.html#KEYCODE_a sdl2: KEYCODE_a +KEYCODE_b sdl2/sdl2.html#KEYCODE_b sdl2: KEYCODE_b +KEYCODE_c sdl2/sdl2.html#KEYCODE_c sdl2: KEYCODE_c +KEYCODE_d sdl2/sdl2.html#KEYCODE_d sdl2: KEYCODE_d +KEYCODE_e sdl2/sdl2.html#KEYCODE_e sdl2: KEYCODE_e +KEYCODE_f sdl2/sdl2.html#KEYCODE_f sdl2: KEYCODE_f +KEYCODE_g sdl2/sdl2.html#KEYCODE_g sdl2: KEYCODE_g +KEYCODE_h sdl2/sdl2.html#KEYCODE_h sdl2: KEYCODE_h +KEYCODE_i sdl2/sdl2.html#KEYCODE_i sdl2: KEYCODE_i +KEYCODE_j sdl2/sdl2.html#KEYCODE_j sdl2: KEYCODE_j +KEYCODE_k sdl2/sdl2.html#KEYCODE_k sdl2: KEYCODE_k +KEYCODE_l sdl2/sdl2.html#KEYCODE_l sdl2: KEYCODE_l +KEYCODE_m sdl2/sdl2.html#KEYCODE_m sdl2: KEYCODE_m +KEYCODE_n sdl2/sdl2.html#KEYCODE_n sdl2: KEYCODE_n +KEYCODE_o sdl2/sdl2.html#KEYCODE_o sdl2: KEYCODE_o +KEYCODE_p sdl2/sdl2.html#KEYCODE_p sdl2: KEYCODE_p +KEYCODE_q sdl2/sdl2.html#KEYCODE_q sdl2: KEYCODE_q +KEYCODE_r sdl2/sdl2.html#KEYCODE_r sdl2: KEYCODE_r +KEYCODE_s sdl2/sdl2.html#KEYCODE_s sdl2: KEYCODE_s +KEYCODE_t sdl2/sdl2.html#KEYCODE_t sdl2: KEYCODE_t +KEYCODE_u sdl2/sdl2.html#KEYCODE_u sdl2: KEYCODE_u +KEYCODE_v sdl2/sdl2.html#KEYCODE_v sdl2: KEYCODE_v +KEYCODE_w sdl2/sdl2.html#KEYCODE_w sdl2: KEYCODE_w +KEYCODE_x sdl2/sdl2.html#KEYCODE_x sdl2: KEYCODE_x +KEYCODE_y sdl2/sdl2.html#KEYCODE_y sdl2: KEYCODE_y +KEYCODE_z sdl2/sdl2.html#KEYCODE_z sdl2: KEYCODE_z +KEYCODE_CAPSLOCK sdl2/sdl2.html#KEYCODE_CAPSLOCK sdl2: KEYCODE_CAPSLOCK +KEYCODE_F1 sdl2/sdl2.html#KEYCODE_F1 sdl2: KEYCODE_F1 +KEYCODE_F2 sdl2/sdl2.html#KEYCODE_F2 sdl2: KEYCODE_F2 +KEYCODE_F3 sdl2/sdl2.html#KEYCODE_F3 sdl2: KEYCODE_F3 +KEYCODE_F4 sdl2/sdl2.html#KEYCODE_F4 sdl2: KEYCODE_F4 +KEYCODE_F5 sdl2/sdl2.html#KEYCODE_F5 sdl2: KEYCODE_F5 +KEYCODE_F6 sdl2/sdl2.html#KEYCODE_F6 sdl2: KEYCODE_F6 +KEYCODE_F7 sdl2/sdl2.html#KEYCODE_F7 sdl2: KEYCODE_F7 +KEYCODE_F8 sdl2/sdl2.html#KEYCODE_F8 sdl2: KEYCODE_F8 +KEYCODE_F9 sdl2/sdl2.html#KEYCODE_F9 sdl2: KEYCODE_F9 +KEYCODE_F10 sdl2/sdl2.html#KEYCODE_F10 sdl2: KEYCODE_F10 +KEYCODE_F11 sdl2/sdl2.html#KEYCODE_F11 sdl2: KEYCODE_F11 +KEYCODE_F12 sdl2/sdl2.html#KEYCODE_F12 sdl2: KEYCODE_F12 +KEYCODE_PRINTSCREEN sdl2/sdl2.html#KEYCODE_PRINTSCREEN sdl2: KEYCODE_PRINTSCREEN +KEYCODE_SCROLLLOCK sdl2/sdl2.html#KEYCODE_SCROLLLOCK sdl2: KEYCODE_SCROLLLOCK +KEYCODE_PAUSE sdl2/sdl2.html#KEYCODE_PAUSE sdl2: KEYCODE_PAUSE +KEYCODE_INSERT sdl2/sdl2.html#KEYCODE_INSERT sdl2: KEYCODE_INSERT +KEYCODE_HOME sdl2/sdl2.html#KEYCODE_HOME sdl2: KEYCODE_HOME +KEYCODE_PAGEUP sdl2/sdl2.html#KEYCODE_PAGEUP sdl2: KEYCODE_PAGEUP +KEYCODE_DELETE sdl2/sdl2.html#KEYCODE_DELETE sdl2: KEYCODE_DELETE +KEYCODE_END sdl2/sdl2.html#KEYCODE_END sdl2: KEYCODE_END +KEYCODE_PAGEDOWN sdl2/sdl2.html#KEYCODE_PAGEDOWN sdl2: KEYCODE_PAGEDOWN +KEYCODE_RIGHT sdl2/sdl2.html#KEYCODE_RIGHT sdl2: KEYCODE_RIGHT +KEYCODE_LEFT sdl2/sdl2.html#KEYCODE_LEFT sdl2: KEYCODE_LEFT +KEYCODE_DOWN sdl2/sdl2.html#KEYCODE_DOWN sdl2: KEYCODE_DOWN +KEYCODE_UP sdl2/sdl2.html#KEYCODE_UP sdl2: KEYCODE_UP +KEYCODE_NUMLOCKCLEAR sdl2/sdl2.html#KEYCODE_NUMLOCKCLEAR sdl2: KEYCODE_NUMLOCKCLEAR +KEYCODE_KP_DIVIDE sdl2/sdl2.html#KEYCODE_KP_DIVIDE sdl2: KEYCODE_KP_DIVIDE +KEYCODE_KP_MULTIPLY sdl2/sdl2.html#KEYCODE_KP_MULTIPLY sdl2: KEYCODE_KP_MULTIPLY +KEYCODE_KP_MINUS sdl2/sdl2.html#KEYCODE_KP_MINUS sdl2: KEYCODE_KP_MINUS +KEYCODE_KP_PLUS sdl2/sdl2.html#KEYCODE_KP_PLUS sdl2: KEYCODE_KP_PLUS +KEYCODE_KP_ENTER sdl2/sdl2.html#KEYCODE_KP_ENTER sdl2: KEYCODE_KP_ENTER +KEYCODE_KP_1 sdl2/sdl2.html#KEYCODE_KP_1 sdl2: KEYCODE_KP_1 +KEYCODE_KP_2 sdl2/sdl2.html#KEYCODE_KP_2 sdl2: KEYCODE_KP_2 +KEYCODE_KP_3 sdl2/sdl2.html#KEYCODE_KP_3 sdl2: KEYCODE_KP_3 +KEYCODE_KP_4 sdl2/sdl2.html#KEYCODE_KP_4 sdl2: KEYCODE_KP_4 +KEYCODE_KP_5 sdl2/sdl2.html#KEYCODE_KP_5 sdl2: KEYCODE_KP_5 +KEYCODE_KP_6 sdl2/sdl2.html#KEYCODE_KP_6 sdl2: KEYCODE_KP_6 +KEYCODE_KP_7 sdl2/sdl2.html#KEYCODE_KP_7 sdl2: KEYCODE_KP_7 +KEYCODE_KP_8 sdl2/sdl2.html#KEYCODE_KP_8 sdl2: KEYCODE_KP_8 +KEYCODE_KP_9 sdl2/sdl2.html#KEYCODE_KP_9 sdl2: KEYCODE_KP_9 +KEYCODE_KP_0 sdl2/sdl2.html#KEYCODE_KP_0 sdl2: KEYCODE_KP_0 +KEYCODE_KP_PERIOD sdl2/sdl2.html#KEYCODE_KP_PERIOD sdl2: KEYCODE_KP_PERIOD +KEYCODE_APPLICATION sdl2/sdl2.html#KEYCODE_APPLICATION sdl2: KEYCODE_APPLICATION +KEYCODE_POWER sdl2/sdl2.html#KEYCODE_POWER sdl2: KEYCODE_POWER +KEYCODE_KP_EQUALS sdl2/sdl2.html#KEYCODE_KP_EQUALS sdl2: KEYCODE_KP_EQUALS +KEYCODE_F13 sdl2/sdl2.html#KEYCODE_F13 sdl2: KEYCODE_F13 +KEYCODE_F14 sdl2/sdl2.html#KEYCODE_F14 sdl2: KEYCODE_F14 +KEYCODE_F15 sdl2/sdl2.html#KEYCODE_F15 sdl2: KEYCODE_F15 +KEYCODE_F16 sdl2/sdl2.html#KEYCODE_F16 sdl2: KEYCODE_F16 +KEYCODE_F17 sdl2/sdl2.html#KEYCODE_F17 sdl2: KEYCODE_F17 +KEYCODE_F18 sdl2/sdl2.html#KEYCODE_F18 sdl2: KEYCODE_F18 +KEYCODE_F19 sdl2/sdl2.html#KEYCODE_F19 sdl2: KEYCODE_F19 +KEYCODE_F20 sdl2/sdl2.html#KEYCODE_F20 sdl2: KEYCODE_F20 +KEYCODE_F21 sdl2/sdl2.html#KEYCODE_F21 sdl2: KEYCODE_F21 +KEYCODE_F22 sdl2/sdl2.html#KEYCODE_F22 sdl2: KEYCODE_F22 +KEYCODE_F23 sdl2/sdl2.html#KEYCODE_F23 sdl2: KEYCODE_F23 +KEYCODE_F24 sdl2/sdl2.html#KEYCODE_F24 sdl2: KEYCODE_F24 +KEYCODE_EXECUTE sdl2/sdl2.html#KEYCODE_EXECUTE sdl2: KEYCODE_EXECUTE +KEYCODE_HELP sdl2/sdl2.html#KEYCODE_HELP sdl2: KEYCODE_HELP +KEYCODE_MENU sdl2/sdl2.html#KEYCODE_MENU sdl2: KEYCODE_MENU +KEYCODE_SELECT sdl2/sdl2.html#KEYCODE_SELECT sdl2: KEYCODE_SELECT +KEYCODE_STOP sdl2/sdl2.html#KEYCODE_STOP sdl2: KEYCODE_STOP +KEYCODE_AGAIN sdl2/sdl2.html#KEYCODE_AGAIN sdl2: KEYCODE_AGAIN +KEYCODE_UNDO sdl2/sdl2.html#KEYCODE_UNDO sdl2: KEYCODE_UNDO +KEYCODE_CUT sdl2/sdl2.html#KEYCODE_CUT sdl2: KEYCODE_CUT +KEYCODE_COPY sdl2/sdl2.html#KEYCODE_COPY sdl2: KEYCODE_COPY +KEYCODE_PASTE sdl2/sdl2.html#KEYCODE_PASTE sdl2: KEYCODE_PASTE +KEYCODE_FIND sdl2/sdl2.html#KEYCODE_FIND sdl2: KEYCODE_FIND +KEYCODE_MUTE sdl2/sdl2.html#KEYCODE_MUTE sdl2: KEYCODE_MUTE +KEYCODE_VOLUMEUP sdl2/sdl2.html#KEYCODE_VOLUMEUP sdl2: KEYCODE_VOLUMEUP +KEYCODE_VOLUMEDOWN sdl2/sdl2.html#KEYCODE_VOLUMEDOWN sdl2: KEYCODE_VOLUMEDOWN +KEYCODE_KP_COMMA sdl2/sdl2.html#KEYCODE_KP_COMMA sdl2: KEYCODE_KP_COMMA +KEYCODE_KP_EQUALSAS400 sdl2/sdl2.html#KEYCODE_KP_EQUALSAS400 sdl2: KEYCODE_KP_EQUALSAS400 +KEYCODE_ALTERASE sdl2/sdl2.html#KEYCODE_ALTERASE sdl2: KEYCODE_ALTERASE +KEYCODE_SYSREQ sdl2/sdl2.html#KEYCODE_SYSREQ sdl2: KEYCODE_SYSREQ +KEYCODE_CANCEL sdl2/sdl2.html#KEYCODE_CANCEL sdl2: KEYCODE_CANCEL +KEYCODE_CLEAR sdl2/sdl2.html#KEYCODE_CLEAR sdl2: KEYCODE_CLEAR +KEYCODE_PRIOR sdl2/sdl2.html#KEYCODE_PRIOR sdl2: KEYCODE_PRIOR +KEYCODE_RETURN2 sdl2/sdl2.html#KEYCODE_RETURN2 sdl2: KEYCODE_RETURN2 +KEYCODE_SEPARATOR sdl2/sdl2.html#KEYCODE_SEPARATOR sdl2: KEYCODE_SEPARATOR +KEYCODE_OUT sdl2/sdl2.html#KEYCODE_OUT sdl2: KEYCODE_OUT +KEYCODE_OPER sdl2/sdl2.html#KEYCODE_OPER sdl2: KEYCODE_OPER +KEYCODE_CLEARAGAIN sdl2/sdl2.html#KEYCODE_CLEARAGAIN sdl2: KEYCODE_CLEARAGAIN +KEYCODE_CRSEL sdl2/sdl2.html#KEYCODE_CRSEL sdl2: KEYCODE_CRSEL +KEYCODE_EXSEL sdl2/sdl2.html#KEYCODE_EXSEL sdl2: KEYCODE_EXSEL +KEYCODE_KP_00 sdl2/sdl2.html#KEYCODE_KP_00 sdl2: KEYCODE_KP_00 +KEYCODE_KP_000 sdl2/sdl2.html#KEYCODE_KP_000 sdl2: KEYCODE_KP_000 +KEYCODE_THOUSANDSSEPARATOR sdl2/sdl2.html#KEYCODE_THOUSANDSSEPARATOR sdl2: KEYCODE_THOUSANDSSEPARATOR +KEYCODE_DECIMALSEPARATOR sdl2/sdl2.html#KEYCODE_DECIMALSEPARATOR sdl2: KEYCODE_DECIMALSEPARATOR +KEYCODE_CURRENCYUNIT sdl2/sdl2.html#KEYCODE_CURRENCYUNIT sdl2: KEYCODE_CURRENCYUNIT +KEYCODE_CURRENCYSUBUNIT sdl2/sdl2.html#KEYCODE_CURRENCYSUBUNIT sdl2: KEYCODE_CURRENCYSUBUNIT +KEYCODE_KP_LEFTPAREN sdl2/sdl2.html#KEYCODE_KP_LEFTPAREN sdl2: KEYCODE_KP_LEFTPAREN +KEYCODE_KP_RIGHTPAREN sdl2/sdl2.html#KEYCODE_KP_RIGHTPAREN sdl2: KEYCODE_KP_RIGHTPAREN +KEYCODE_KP_LEFTBRACE sdl2/sdl2.html#KEYCODE_KP_LEFTBRACE sdl2: KEYCODE_KP_LEFTBRACE +KEYCODE_KP_RIGHTBRACE sdl2/sdl2.html#KEYCODE_KP_RIGHTBRACE sdl2: KEYCODE_KP_RIGHTBRACE +KEYCODE_KP_TAB sdl2/sdl2.html#KEYCODE_KP_TAB sdl2: KEYCODE_KP_TAB +KEYCODE_KP_BACKSPACE sdl2/sdl2.html#KEYCODE_KP_BACKSPACE sdl2: KEYCODE_KP_BACKSPACE +KEYCODE_KP_A sdl2/sdl2.html#KEYCODE_KP_A sdl2: KEYCODE_KP_A +KEYCODE_KP_B sdl2/sdl2.html#KEYCODE_KP_B sdl2: KEYCODE_KP_B +KEYCODE_KP_C sdl2/sdl2.html#KEYCODE_KP_C sdl2: KEYCODE_KP_C +KEYCODE_KP_D sdl2/sdl2.html#KEYCODE_KP_D sdl2: KEYCODE_KP_D +KEYCODE_KP_E sdl2/sdl2.html#KEYCODE_KP_E sdl2: KEYCODE_KP_E +KEYCODE_KP_F sdl2/sdl2.html#KEYCODE_KP_F sdl2: KEYCODE_KP_F +KEYCODE_KP_XOR sdl2/sdl2.html#KEYCODE_KP_XOR sdl2: KEYCODE_KP_XOR +KEYCODE_KP_POWER sdl2/sdl2.html#KEYCODE_KP_POWER sdl2: KEYCODE_KP_POWER +KEYCODE_KP_PERCENT sdl2/sdl2.html#KEYCODE_KP_PERCENT sdl2: KEYCODE_KP_PERCENT +KEYCODE_KP_LESS sdl2/sdl2.html#KEYCODE_KP_LESS sdl2: KEYCODE_KP_LESS +KEYCODE_KP_GREATER sdl2/sdl2.html#KEYCODE_KP_GREATER sdl2: KEYCODE_KP_GREATER +KEYCODE_KP_AMPERSAND sdl2/sdl2.html#KEYCODE_KP_AMPERSAND sdl2: KEYCODE_KP_AMPERSAND +KEYCODE_KP_DBLAMPERSAND sdl2/sdl2.html#KEYCODE_KP_DBLAMPERSAND sdl2: KEYCODE_KP_DBLAMPERSAND +KEYCODE_KP_VERTICALBAR sdl2/sdl2.html#KEYCODE_KP_VERTICALBAR sdl2: KEYCODE_KP_VERTICALBAR +KEYCODE_KP_DBLVERTICALBAR sdl2/sdl2.html#KEYCODE_KP_DBLVERTICALBAR sdl2: KEYCODE_KP_DBLVERTICALBAR +KEYCODE_KP_COLON sdl2/sdl2.html#KEYCODE_KP_COLON sdl2: KEYCODE_KP_COLON +KEYCODE_KP_HASH sdl2/sdl2.html#KEYCODE_KP_HASH sdl2: KEYCODE_KP_HASH +KEYCODE_KP_SPACE sdl2/sdl2.html#KEYCODE_KP_SPACE sdl2: KEYCODE_KP_SPACE +KEYCODE_KP_AT sdl2/sdl2.html#KEYCODE_KP_AT sdl2: KEYCODE_KP_AT +KEYCODE_KP_EXCLAM sdl2/sdl2.html#KEYCODE_KP_EXCLAM sdl2: KEYCODE_KP_EXCLAM +KEYCODE_KP_MEMSTORE sdl2/sdl2.html#KEYCODE_KP_MEMSTORE sdl2: KEYCODE_KP_MEMSTORE +KEYCODE_KP_MEMRECALL sdl2/sdl2.html#KEYCODE_KP_MEMRECALL sdl2: KEYCODE_KP_MEMRECALL +KEYCODE_KP_MEMCLEAR sdl2/sdl2.html#KEYCODE_KP_MEMCLEAR sdl2: KEYCODE_KP_MEMCLEAR +KEYCODE_KP_MEMADD sdl2/sdl2.html#KEYCODE_KP_MEMADD sdl2: KEYCODE_KP_MEMADD +KEYCODE_KP_MEMSUBTRACT sdl2/sdl2.html#KEYCODE_KP_MEMSUBTRACT sdl2: KEYCODE_KP_MEMSUBTRACT +KEYCODE_KP_MEMMULTIPLY sdl2/sdl2.html#KEYCODE_KP_MEMMULTIPLY sdl2: KEYCODE_KP_MEMMULTIPLY +KEYCODE_KP_MEMDIVIDE sdl2/sdl2.html#KEYCODE_KP_MEMDIVIDE sdl2: KEYCODE_KP_MEMDIVIDE +KEYCODE_KP_PLUSMINUS sdl2/sdl2.html#KEYCODE_KP_PLUSMINUS sdl2: KEYCODE_KP_PLUSMINUS +KEYCODE_KP_CLEAR sdl2/sdl2.html#KEYCODE_KP_CLEAR sdl2: KEYCODE_KP_CLEAR +KEYCODE_KP_CLEARENTRY sdl2/sdl2.html#KEYCODE_KP_CLEARENTRY sdl2: KEYCODE_KP_CLEARENTRY +KEYCODE_KP_BINARY sdl2/sdl2.html#KEYCODE_KP_BINARY sdl2: KEYCODE_KP_BINARY +KEYCODE_KP_OCTAL sdl2/sdl2.html#KEYCODE_KP_OCTAL sdl2: KEYCODE_KP_OCTAL +KEYCODE_KP_DECIMAL sdl2/sdl2.html#KEYCODE_KP_DECIMAL sdl2: KEYCODE_KP_DECIMAL +KEYCODE_KP_HEXADECIMAL sdl2/sdl2.html#KEYCODE_KP_HEXADECIMAL sdl2: KEYCODE_KP_HEXADECIMAL +KEYCODE_LCTRL sdl2/sdl2.html#KEYCODE_LCTRL sdl2: KEYCODE_LCTRL +KEYCODE_LSHIFT sdl2/sdl2.html#KEYCODE_LSHIFT sdl2: KEYCODE_LSHIFT +KEYCODE_LALT sdl2/sdl2.html#KEYCODE_LALT sdl2: KEYCODE_LALT +KEYCODE_LGUI sdl2/sdl2.html#KEYCODE_LGUI sdl2: KEYCODE_LGUI +KEYCODE_RCTRL sdl2/sdl2.html#KEYCODE_RCTRL sdl2: KEYCODE_RCTRL +KEYCODE_RSHIFT sdl2/sdl2.html#KEYCODE_RSHIFT sdl2: KEYCODE_RSHIFT +KEYCODE_RALT sdl2/sdl2.html#KEYCODE_RALT sdl2: KEYCODE_RALT +KEYCODE_RGUI sdl2/sdl2.html#KEYCODE_RGUI sdl2: KEYCODE_RGUI +KEYCODE_MODE sdl2/sdl2.html#KEYCODE_MODE sdl2: KEYCODE_MODE +KEYCODE_AUDIONEXT sdl2/sdl2.html#KEYCODE_AUDIONEXT sdl2: KEYCODE_AUDIONEXT +KEYCODE_AUDIOPREV sdl2/sdl2.html#KEYCODE_AUDIOPREV sdl2: KEYCODE_AUDIOPREV +KEYCODE_AUDIOSTOP sdl2/sdl2.html#KEYCODE_AUDIOSTOP sdl2: KEYCODE_AUDIOSTOP +KEYCODE_AUDIOPLAY sdl2/sdl2.html#KEYCODE_AUDIOPLAY sdl2: KEYCODE_AUDIOPLAY +KEYCODE_AUDIOMUTE sdl2/sdl2.html#KEYCODE_AUDIOMUTE sdl2: KEYCODE_AUDIOMUTE +KEYCODE_MEDIASELECT sdl2/sdl2.html#KEYCODE_MEDIASELECT sdl2: KEYCODE_MEDIASELECT +KEYCODE_WWW sdl2/sdl2.html#KEYCODE_WWW sdl2: KEYCODE_WWW +KEYCODE_MAIL sdl2/sdl2.html#KEYCODE_MAIL sdl2: KEYCODE_MAIL +KEYCODE_CALCULATOR sdl2/sdl2.html#KEYCODE_CALCULATOR sdl2: KEYCODE_CALCULATOR +KEYCODE_COMPUTER sdl2/sdl2.html#KEYCODE_COMPUTER sdl2: KEYCODE_COMPUTER +KEYCODE_AC_SEARCH sdl2/sdl2.html#KEYCODE_AC_SEARCH sdl2: KEYCODE_AC_SEARCH +KEYCODE_AC_HOME sdl2/sdl2.html#KEYCODE_AC_HOME sdl2: KEYCODE_AC_HOME +KEYCODE_AC_BACK sdl2/sdl2.html#KEYCODE_AC_BACK sdl2: KEYCODE_AC_BACK +KEYCODE_AC_FORWARD sdl2/sdl2.html#KEYCODE_AC_FORWARD sdl2: KEYCODE_AC_FORWARD +KEYCODE_AC_STOP sdl2/sdl2.html#KEYCODE_AC_STOP sdl2: KEYCODE_AC_STOP +KEYCODE_AC_REFRESH sdl2/sdl2.html#KEYCODE_AC_REFRESH sdl2: KEYCODE_AC_REFRESH +KEYCODE_AC_BOOKMARKS sdl2/sdl2.html#KEYCODE_AC_BOOKMARKS sdl2: KEYCODE_AC_BOOKMARKS +KEYCODE_BRIGHTNESSDOWN sdl2/sdl2.html#KEYCODE_BRIGHTNESSDOWN sdl2: KEYCODE_BRIGHTNESSDOWN +KEYCODE_BRIGHTNESSUP sdl2/sdl2.html#KEYCODE_BRIGHTNESSUP sdl2: KEYCODE_BRIGHTNESSUP +KEYCODE_DISPLAYSWITCH sdl2/sdl2.html#KEYCODE_DISPLAYSWITCH sdl2: KEYCODE_DISPLAYSWITCH +KEYCODE_KBDILLUMTOGGLE sdl2/sdl2.html#KEYCODE_KBDILLUMTOGGLE sdl2: KEYCODE_KBDILLUMTOGGLE +KEYCODE_KBDILLUMDOWN sdl2/sdl2.html#KEYCODE_KBDILLUMDOWN sdl2: KEYCODE_KBDILLUMDOWN +KEYCODE_KBDILLUMUP sdl2/sdl2.html#KEYCODE_KBDILLUMUP sdl2: KEYCODE_KBDILLUMUP +KEYCODE_EJECT sdl2/sdl2.html#KEYCODE_EJECT sdl2: KEYCODE_EJECT +KEYCODE_SLEEP sdl2/sdl2.html#KEYCODE_SLEEP sdl2: KEYCODE_SLEEP +KEYCODE_APP1 sdl2/sdl2.html#KEYCODE_APP1 sdl2: KEYCODE_APP1 +KEYCODE_APP2 sdl2/sdl2.html#KEYCODE_APP2 sdl2: KEYCODE_APP2 +KEYCODE_AUDIOREWIND sdl2/sdl2.html#KEYCODE_AUDIOREWIND sdl2: KEYCODE_AUDIOREWIND +KEYCODE_AUDIOFASTFORWARD sdl2/sdl2.html#KEYCODE_AUDIOFASTFORWARD sdl2: KEYCODE_AUDIOFASTFORWARD +KMOD_NONE sdl2/sdl2.html#KMOD_NONE sdl2: KMOD_NONE +KMOD_LSHIFT sdl2/sdl2.html#KMOD_LSHIFT sdl2: KMOD_LSHIFT +KMOD_RSHIFT sdl2/sdl2.html#KMOD_RSHIFT sdl2: KMOD_RSHIFT +KMOD_LCTRL sdl2/sdl2.html#KMOD_LCTRL sdl2: KMOD_LCTRL +KMOD_RCTRL sdl2/sdl2.html#KMOD_RCTRL sdl2: KMOD_RCTRL +KMOD_LALT sdl2/sdl2.html#KMOD_LALT sdl2: KMOD_LALT +KMOD_RALT sdl2/sdl2.html#KMOD_RALT sdl2: KMOD_RALT +KMOD_LGUI sdl2/sdl2.html#KMOD_LGUI sdl2: KMOD_LGUI +KMOD_RGUI sdl2/sdl2.html#KMOD_RGUI sdl2: KMOD_RGUI +KMOD_NUM sdl2/sdl2.html#KMOD_NUM sdl2: KMOD_NUM +KMOD_CAPS sdl2/sdl2.html#KMOD_CAPS sdl2: KMOD_CAPS +KMOD_MODE sdl2/sdl2.html#KMOD_MODE sdl2: KMOD_MODE +KMOD_RESERVED sdl2/sdl2.html#KMOD_RESERVED sdl2: KMOD_RESERVED +KMOD_CTRL sdl2/sdl2.html#KMOD_CTRL sdl2: KMOD_CTRL +KMOD_SHIFT sdl2/sdl2.html#KMOD_SHIFT sdl2: KMOD_SHIFT +KMOD_ALT sdl2/sdl2.html#KMOD_ALT sdl2: KMOD_ALT +KMOD_GUI sdl2/sdl2.html#KMOD_GUI sdl2: KMOD_GUI +SYSTEM_CURSOR_ARROW sdl2/sdl2.html#SYSTEM_CURSOR_ARROW sdl2: SYSTEM_CURSOR_ARROW +SYSTEM_CURSOR_IBEAM sdl2/sdl2.html#SYSTEM_CURSOR_IBEAM sdl2: SYSTEM_CURSOR_IBEAM +SYSTEM_CURSOR_WAIT sdl2/sdl2.html#SYSTEM_CURSOR_WAIT sdl2: SYSTEM_CURSOR_WAIT +SYSTEM_CURSOR_CROSSHAIR sdl2/sdl2.html#SYSTEM_CURSOR_CROSSHAIR sdl2: SYSTEM_CURSOR_CROSSHAIR +SYSTEM_CURSOR_WAITARROW sdl2/sdl2.html#SYSTEM_CURSOR_WAITARROW sdl2: SYSTEM_CURSOR_WAITARROW +SYSTEM_CURSOR_SIZENWSE sdl2/sdl2.html#SYSTEM_CURSOR_SIZENWSE sdl2: SYSTEM_CURSOR_SIZENWSE +SYSTEM_CURSOR_SIZENESW sdl2/sdl2.html#SYSTEM_CURSOR_SIZENESW sdl2: SYSTEM_CURSOR_SIZENESW +SYSTEM_CURSOR_SIZEWE sdl2/sdl2.html#SYSTEM_CURSOR_SIZEWE sdl2: SYSTEM_CURSOR_SIZEWE +SYSTEM_CURSOR_SIZENS sdl2/sdl2.html#SYSTEM_CURSOR_SIZENS sdl2: SYSTEM_CURSOR_SIZENS +SYSTEM_CURSOR_SIZEALL sdl2/sdl2.html#SYSTEM_CURSOR_SIZEALL sdl2: SYSTEM_CURSOR_SIZEALL +SYSTEM_CURSOR_NO sdl2/sdl2.html#SYSTEM_CURSOR_NO sdl2: SYSTEM_CURSOR_NO +SYSTEM_CURSOR_HAND sdl2/sdl2.html#SYSTEM_CURSOR_HAND sdl2: SYSTEM_CURSOR_HAND +NUM_SYSTEM_CURSORS sdl2/sdl2.html#NUM_SYSTEM_CURSORS sdl2: NUM_SYSTEM_CURSORS +MOUSEWHEEL_NORMAL sdl2/sdl2.html#MOUSEWHEEL_NORMAL sdl2: MOUSEWHEEL_NORMAL +MOUSEWHEEL_FLIPPED sdl2/sdl2.html#MOUSEWHEEL_FLIPPED sdl2: MOUSEWHEEL_FLIPPED +BUTTON_LEFT sdl2/sdl2.html#BUTTON_LEFT sdl2: BUTTON_LEFT +BUTTON_MIDDLE sdl2/sdl2.html#BUTTON_MIDDLE sdl2: BUTTON_MIDDLE +BUTTON_RIGHT sdl2/sdl2.html#BUTTON_RIGHT sdl2: BUTTON_RIGHT +BUTTON_X1 sdl2/sdl2.html#BUTTON_X1 sdl2: BUTTON_X1 +BUTTON_X2 sdl2/sdl2.html#BUTTON_X2 sdl2: BUTTON_X2 +JOYSTICK_TYPE_UNKNOWN sdl2/sdl2.html#JOYSTICK_TYPE_UNKNOWN sdl2: JOYSTICK_TYPE_UNKNOWN +JOYSTICK_TYPE_GAMECONTROLLER sdl2/sdl2.html#JOYSTICK_TYPE_GAMECONTROLLER sdl2: JOYSTICK_TYPE_GAMECONTROLLER +JOYSTICK_TYPE_WHEEL sdl2/sdl2.html#JOYSTICK_TYPE_WHEEL sdl2: JOYSTICK_TYPE_WHEEL +JOYSTICK_TYPE_ARCADE_STICK sdl2/sdl2.html#JOYSTICK_TYPE_ARCADE_STICK sdl2: JOYSTICK_TYPE_ARCADE_STICK +JOYSTICK_TYPE_FLIGHT_STICK sdl2/sdl2.html#JOYSTICK_TYPE_FLIGHT_STICK sdl2: JOYSTICK_TYPE_FLIGHT_STICK +JOYSTICK_TYPE_DANCE_PAD sdl2/sdl2.html#JOYSTICK_TYPE_DANCE_PAD sdl2: JOYSTICK_TYPE_DANCE_PAD +JOYSTICK_TYPE_GUITAR sdl2/sdl2.html#JOYSTICK_TYPE_GUITAR sdl2: JOYSTICK_TYPE_GUITAR +JOYSTICK_TYPE_DRUM_KIT sdl2/sdl2.html#JOYSTICK_TYPE_DRUM_KIT sdl2: JOYSTICK_TYPE_DRUM_KIT +JOYSTICK_TYPE_ARCADE_PAD sdl2/sdl2.html#JOYSTICK_TYPE_ARCADE_PAD sdl2: JOYSTICK_TYPE_ARCADE_PAD +JOYSTICK_TYPE_THROTTLE sdl2/sdl2.html#JOYSTICK_TYPE_THROTTLE sdl2: JOYSTICK_TYPE_THROTTLE +JOYSTICK_POWER_UNKNOWN sdl2/sdl2.html#JOYSTICK_POWER_UNKNOWN sdl2: JOYSTICK_POWER_UNKNOWN +JOYSTICK_POWER_EMPTY sdl2/sdl2.html#JOYSTICK_POWER_EMPTY sdl2: JOYSTICK_POWER_EMPTY +JOYSTICK_POWER_LOW sdl2/sdl2.html#JOYSTICK_POWER_LOW sdl2: JOYSTICK_POWER_LOW +JOYSTICK_POWER_MEDIUM sdl2/sdl2.html#JOYSTICK_POWER_MEDIUM sdl2: JOYSTICK_POWER_MEDIUM +JOYSTICK_POWER_FULL sdl2/sdl2.html#JOYSTICK_POWER_FULL sdl2: JOYSTICK_POWER_FULL +JOYSTICK_POWER_WIRED sdl2/sdl2.html#JOYSTICK_POWER_WIRED sdl2: JOYSTICK_POWER_WIRED +JOYSTICK_POWER_MAX sdl2/sdl2.html#JOYSTICK_POWER_MAX sdl2: JOYSTICK_POWER_MAX +JOYSTICK_AXIS_MAX sdl2/sdl2.html#JOYSTICK_AXIS_MAX sdl2: JOYSTICK_AXIS_MAX +JOYSTICK_AXIS_MIN sdl2/sdl2.html#JOYSTICK_AXIS_MIN sdl2: JOYSTICK_AXIS_MIN +HAT_CENTERED sdl2/sdl2.html#HAT_CENTERED sdl2: HAT_CENTERED +HAT_UP sdl2/sdl2.html#HAT_UP sdl2: HAT_UP +HAT_RIGHT sdl2/sdl2.html#HAT_RIGHT sdl2: HAT_RIGHT +HAT_DOWN sdl2/sdl2.html#HAT_DOWN sdl2: HAT_DOWN +HAT_LEFT sdl2/sdl2.html#HAT_LEFT sdl2: HAT_LEFT +HAT_RIGHTUP sdl2/sdl2.html#HAT_RIGHTUP sdl2: HAT_RIGHTUP +HAT_RIGHTDOWN sdl2/sdl2.html#HAT_RIGHTDOWN sdl2: HAT_RIGHTDOWN +HAT_LEFTUP sdl2/sdl2.html#HAT_LEFTUP sdl2: HAT_LEFTUP +HAT_LEFTDOWN sdl2/sdl2.html#HAT_LEFTDOWN sdl2: HAT_LEFTDOWN +CONTROLLER_TYPE_UNKNOWN sdl2/sdl2.html#CONTROLLER_TYPE_UNKNOWN sdl2: CONTROLLER_TYPE_UNKNOWN +CONTROLLER_TYPE_XBOX360 sdl2/sdl2.html#CONTROLLER_TYPE_XBOX360 sdl2: CONTROLLER_TYPE_XBOX360 +CONTROLLER_TYPE_XBOXONE sdl2/sdl2.html#CONTROLLER_TYPE_XBOXONE sdl2: CONTROLLER_TYPE_XBOXONE +CONTROLLER_TYPE_PS3 sdl2/sdl2.html#CONTROLLER_TYPE_PS3 sdl2: CONTROLLER_TYPE_PS3 +CONTROLLER_TYPE_PS4 sdl2/sdl2.html#CONTROLLER_TYPE_PS4 sdl2: CONTROLLER_TYPE_PS4 +CONTROLLER_TYPE_NINTENDO_SWITCH_PRO sdl2/sdl2.html#CONTROLLER_TYPE_NINTENDO_SWITCH_PRO sdl2: CONTROLLER_TYPE_NINTENDO_SWITCH_PRO +CONTROLLER_AXIS_INVALID sdl2/sdl2.html#CONTROLLER_AXIS_INVALID sdl2: CONTROLLER_AXIS_INVALID +CONTROLLER_AXIS_LEFTX sdl2/sdl2.html#CONTROLLER_AXIS_LEFTX sdl2: CONTROLLER_AXIS_LEFTX +CONTROLLER_AXIS_LEFTY sdl2/sdl2.html#CONTROLLER_AXIS_LEFTY sdl2: CONTROLLER_AXIS_LEFTY +CONTROLLER_AXIS_RIGHTX sdl2/sdl2.html#CONTROLLER_AXIS_RIGHTX sdl2: CONTROLLER_AXIS_RIGHTX +CONTROLLER_AXIS_RIGHTY sdl2/sdl2.html#CONTROLLER_AXIS_RIGHTY sdl2: CONTROLLER_AXIS_RIGHTY +CONTROLLER_AXIS_TRIGGERLEFT sdl2/sdl2.html#CONTROLLER_AXIS_TRIGGERLEFT sdl2: CONTROLLER_AXIS_TRIGGERLEFT +CONTROLLER_AXIS_TRIGGERRIGHT sdl2/sdl2.html#CONTROLLER_AXIS_TRIGGERRIGHT sdl2: CONTROLLER_AXIS_TRIGGERRIGHT +CONTROLLER_AXIS_MAX sdl2/sdl2.html#CONTROLLER_AXIS_MAX sdl2: CONTROLLER_AXIS_MAX +CONTROLLER_BUTTON_INVALID sdl2/sdl2.html#CONTROLLER_BUTTON_INVALID sdl2: CONTROLLER_BUTTON_INVALID +CONTROLLER_BUTTON_A sdl2/sdl2.html#CONTROLLER_BUTTON_A sdl2: CONTROLLER_BUTTON_A +CONTROLLER_BUTTON_B sdl2/sdl2.html#CONTROLLER_BUTTON_B sdl2: CONTROLLER_BUTTON_B +CONTROLLER_BUTTON_X sdl2/sdl2.html#CONTROLLER_BUTTON_X sdl2: CONTROLLER_BUTTON_X +CONTROLLER_BUTTON_Y sdl2/sdl2.html#CONTROLLER_BUTTON_Y sdl2: CONTROLLER_BUTTON_Y +CONTROLLER_BUTTON_BACK sdl2/sdl2.html#CONTROLLER_BUTTON_BACK sdl2: CONTROLLER_BUTTON_BACK +CONTROLLER_BUTTON_GUIDE sdl2/sdl2.html#CONTROLLER_BUTTON_GUIDE sdl2: CONTROLLER_BUTTON_GUIDE +CONTROLLER_BUTTON_START sdl2/sdl2.html#CONTROLLER_BUTTON_START sdl2: CONTROLLER_BUTTON_START +CONTROLLER_BUTTON_LEFTSTICK sdl2/sdl2.html#CONTROLLER_BUTTON_LEFTSTICK sdl2: CONTROLLER_BUTTON_LEFTSTICK +CONTROLLER_BUTTON_RIGHTSTICK sdl2/sdl2.html#CONTROLLER_BUTTON_RIGHTSTICK sdl2: CONTROLLER_BUTTON_RIGHTSTICK +CONTROLLER_BUTTON_LEFTSHOULDER sdl2/sdl2.html#CONTROLLER_BUTTON_LEFTSHOULDER sdl2: CONTROLLER_BUTTON_LEFTSHOULDER +CONTROLLER_BUTTON_RIGHTSHOULDER sdl2/sdl2.html#CONTROLLER_BUTTON_RIGHTSHOULDER sdl2: CONTROLLER_BUTTON_RIGHTSHOULDER +CONTROLLER_BUTTON_DPAD_UP sdl2/sdl2.html#CONTROLLER_BUTTON_DPAD_UP sdl2: CONTROLLER_BUTTON_DPAD_UP +CONTROLLER_BUTTON_DPAD_DOWN sdl2/sdl2.html#CONTROLLER_BUTTON_DPAD_DOWN sdl2: CONTROLLER_BUTTON_DPAD_DOWN +CONTROLLER_BUTTON_DPAD_LEFT sdl2/sdl2.html#CONTROLLER_BUTTON_DPAD_LEFT sdl2: CONTROLLER_BUTTON_DPAD_LEFT +CONTROLLER_BUTTON_DPAD_RIGHT sdl2/sdl2.html#CONTROLLER_BUTTON_DPAD_RIGHT sdl2: CONTROLLER_BUTTON_DPAD_RIGHT +CONTROLLER_BUTTON_MAX sdl2/sdl2.html#CONTROLLER_BUTTON_MAX sdl2: CONTROLLER_BUTTON_MAX +TOUCH_DEVICE_INVALID sdl2/sdl2.html#TOUCH_DEVICE_INVALID sdl2: TOUCH_DEVICE_INVALID +TOUCH_DEVICE_DIRECT sdl2/sdl2.html#TOUCH_DEVICE_DIRECT sdl2: TOUCH_DEVICE_DIRECT +TOUCH_DEVICE_INDIRECT_ABSOLUTE sdl2/sdl2.html#TOUCH_DEVICE_INDIRECT_ABSOLUTE sdl2: TOUCH_DEVICE_INDIRECT_ABSOLUTE +TOUCH_DEVICE_INDIRECT_RELATIVE sdl2/sdl2.html#TOUCH_DEVICE_INDIRECT_RELATIVE sdl2: TOUCH_DEVICE_INDIRECT_RELATIVE +RELEASED sdl2/sdl2.html#RELEASED sdl2: RELEASED +PRESSED sdl2/sdl2.html#PRESSED sdl2: PRESSED +EVENT_FIRSTEVENT sdl2/sdl2.html#EVENT_FIRSTEVENT sdl2: EVENT_FIRSTEVENT +EVENT_QUIT sdl2/sdl2.html#EVENT_QUIT sdl2: EVENT_QUIT +EVENT_APP_TERMINATING sdl2/sdl2.html#EVENT_APP_TERMINATING sdl2: EVENT_APP_TERMINATING +EVENT_APP_LOWMEMORY sdl2/sdl2.html#EVENT_APP_LOWMEMORY sdl2: EVENT_APP_LOWMEMORY +EVENT_APP_WILLENTERBACKGROUND sdl2/sdl2.html#EVENT_APP_WILLENTERBACKGROUND sdl2: EVENT_APP_WILLENTERBACKGROUND +EVENT_APP_DIDENTERBACKGROUND sdl2/sdl2.html#EVENT_APP_DIDENTERBACKGROUND sdl2: EVENT_APP_DIDENTERBACKGROUND +EVENT_APP_WILLENTERFOREGROUND sdl2/sdl2.html#EVENT_APP_WILLENTERFOREGROUND sdl2: EVENT_APP_WILLENTERFOREGROUND +EVENT_APP_DIDENTERFOREGROUND sdl2/sdl2.html#EVENT_APP_DIDENTERFOREGROUND sdl2: EVENT_APP_DIDENTERFOREGROUND +EVENT_DISPLAYEVENT sdl2/sdl2.html#EVENT_DISPLAYEVENT sdl2: EVENT_DISPLAYEVENT +EVENT_WINDOWEVENT sdl2/sdl2.html#EVENT_WINDOWEVENT sdl2: EVENT_WINDOWEVENT +EVENT_SYSWMEVENT sdl2/sdl2.html#EVENT_SYSWMEVENT sdl2: EVENT_SYSWMEVENT +EVENT_KEYDOWN sdl2/sdl2.html#EVENT_KEYDOWN sdl2: EVENT_KEYDOWN +EVENT_KEYUP sdl2/sdl2.html#EVENT_KEYUP sdl2: EVENT_KEYUP +EVENT_TEXTEDITING sdl2/sdl2.html#EVENT_TEXTEDITING sdl2: EVENT_TEXTEDITING +EVENT_TEXTINPUT sdl2/sdl2.html#EVENT_TEXTINPUT sdl2: EVENT_TEXTINPUT +EVENT_KEYMAPCHANGED sdl2/sdl2.html#EVENT_KEYMAPCHANGED sdl2: EVENT_KEYMAPCHANGED +EVENT_MOUSEMOTION sdl2/sdl2.html#EVENT_MOUSEMOTION sdl2: EVENT_MOUSEMOTION +EVENT_MOUSEBUTTONDOWN sdl2/sdl2.html#EVENT_MOUSEBUTTONDOWN sdl2: EVENT_MOUSEBUTTONDOWN +EVENT_MOUSEBUTTONUP sdl2/sdl2.html#EVENT_MOUSEBUTTONUP sdl2: EVENT_MOUSEBUTTONUP +EVENT_MOUSEWHEEL sdl2/sdl2.html#EVENT_MOUSEWHEEL sdl2: EVENT_MOUSEWHEEL +EVENT_JOYAXISMOTION sdl2/sdl2.html#EVENT_JOYAXISMOTION sdl2: EVENT_JOYAXISMOTION +EVENT_JOYBALLMOTION sdl2/sdl2.html#EVENT_JOYBALLMOTION sdl2: EVENT_JOYBALLMOTION +EVENT_JOYHATMOTION sdl2/sdl2.html#EVENT_JOYHATMOTION sdl2: EVENT_JOYHATMOTION +EVENT_JOYBUTTONDOWN sdl2/sdl2.html#EVENT_JOYBUTTONDOWN sdl2: EVENT_JOYBUTTONDOWN +EVENT_JOYBUTTONUP sdl2/sdl2.html#EVENT_JOYBUTTONUP sdl2: EVENT_JOYBUTTONUP +EVENT_JOYDEVICEADDED sdl2/sdl2.html#EVENT_JOYDEVICEADDED sdl2: EVENT_JOYDEVICEADDED +EVENT_JOYDEVICEREMOVED sdl2/sdl2.html#EVENT_JOYDEVICEREMOVED sdl2: EVENT_JOYDEVICEREMOVED +EVENT_CONTROLLERAXISMOTION sdl2/sdl2.html#EVENT_CONTROLLERAXISMOTION sdl2: EVENT_CONTROLLERAXISMOTION +EVENT_CONTROLLERBUTTONDOWN sdl2/sdl2.html#EVENT_CONTROLLERBUTTONDOWN sdl2: EVENT_CONTROLLERBUTTONDOWN +EVENT_CONTROLLERBUTTONUP sdl2/sdl2.html#EVENT_CONTROLLERBUTTONUP sdl2: EVENT_CONTROLLERBUTTONUP +EVENT_CONTROLLERDEVICEADDED sdl2/sdl2.html#EVENT_CONTROLLERDEVICEADDED sdl2: EVENT_CONTROLLERDEVICEADDED +EVENT_CONTROLLERDEVICEREMOVED sdl2/sdl2.html#EVENT_CONTROLLERDEVICEREMOVED sdl2: EVENT_CONTROLLERDEVICEREMOVED +EVENT_CONTROLLERDEVICEREMAPPED sdl2/sdl2.html#EVENT_CONTROLLERDEVICEREMAPPED sdl2: EVENT_CONTROLLERDEVICEREMAPPED +EVENT_FINGERDOWN sdl2/sdl2.html#EVENT_FINGERDOWN sdl2: EVENT_FINGERDOWN +EVENT_FINGERUP sdl2/sdl2.html#EVENT_FINGERUP sdl2: EVENT_FINGERUP +EVENT_FINGERMOTION sdl2/sdl2.html#EVENT_FINGERMOTION sdl2: EVENT_FINGERMOTION +EVENT_DOLLARGESTURE sdl2/sdl2.html#EVENT_DOLLARGESTURE sdl2: EVENT_DOLLARGESTURE +EVENT_DOLLARRECORD sdl2/sdl2.html#EVENT_DOLLARRECORD sdl2: EVENT_DOLLARRECORD +EVENT_MULTIGESTURE sdl2/sdl2.html#EVENT_MULTIGESTURE sdl2: EVENT_MULTIGESTURE +EVENT_CLIPBOARDUPDATE sdl2/sdl2.html#EVENT_CLIPBOARDUPDATE sdl2: EVENT_CLIPBOARDUPDATE +EVENT_DROPFILE sdl2/sdl2.html#EVENT_DROPFILE sdl2: EVENT_DROPFILE +EVENT_DROPTEXT sdl2/sdl2.html#EVENT_DROPTEXT sdl2: EVENT_DROPTEXT +EVENT_DROPBEGIN sdl2/sdl2.html#EVENT_DROPBEGIN sdl2: EVENT_DROPBEGIN +EVENT_DROPCOMPLETE sdl2/sdl2.html#EVENT_DROPCOMPLETE sdl2: EVENT_DROPCOMPLETE +EVENT_AUDIODEVICEADDED sdl2/sdl2.html#EVENT_AUDIODEVICEADDED sdl2: EVENT_AUDIODEVICEADDED +EVENT_AUDIODEVICEREMOVED sdl2/sdl2.html#EVENT_AUDIODEVICEREMOVED sdl2: EVENT_AUDIODEVICEREMOVED +EVENT_SENSORUPDATE sdl2/sdl2.html#EVENT_SENSORUPDATE sdl2: EVENT_SENSORUPDATE +EVENT_RENDER_TARGETS_RESET sdl2/sdl2.html#EVENT_RENDER_TARGETS_RESET sdl2: EVENT_RENDER_TARGETS_RESET +EVENT_RENDER_DEVICE_RESET sdl2/sdl2.html#EVENT_RENDER_DEVICE_RESET sdl2: EVENT_RENDER_DEVICE_RESET +EVENT_USEREVENT sdl2/sdl2.html#EVENT_USEREVENT sdl2: EVENT_USEREVENT +EVENT_LASTEVENT sdl2/sdl2.html#EVENT_LASTEVENT sdl2: EVENT_LASTEVENT +TEXTEDITINGEVENT_TEXT_SIZE sdl2/sdl2.html#TEXTEDITINGEVENT_TEXT_SIZE sdl2: TEXTEDITINGEVENT_TEXT_SIZE +TEXTINPUTEVENT_TEXT_SIZE sdl2/sdl2.html#TEXTINPUTEVENT_TEXT_SIZE sdl2: TEXTINPUTEVENT_TEXT_SIZE +ADDEVENT sdl2/sdl2.html#ADDEVENT sdl2: ADDEVENT +PEEKEVENT sdl2/sdl2.html#PEEKEVENT sdl2: PEEKEVENT +GETEVENT sdl2/sdl2.html#GETEVENT sdl2: GETEVENT +QUERY sdl2/sdl2.html#QUERY sdl2: QUERY +IGNORE sdl2/sdl2.html#IGNORE sdl2: IGNORE +DISABLE sdl2/sdl2.html#DISABLE sdl2: DISABLE +ENABLE sdl2/sdl2.html#ENABLE sdl2: ENABLE +HAPTIC_TYPE_CONSTANT sdl2/sdl2.html#HAPTIC_TYPE_CONSTANT sdl2: HAPTIC_TYPE_CONSTANT +HAPTIC_TYPE_SINE sdl2/sdl2.html#HAPTIC_TYPE_SINE sdl2: HAPTIC_TYPE_SINE +HAPTIC_TYPE_LEFTRIGHT sdl2/sdl2.html#HAPTIC_TYPE_LEFTRIGHT sdl2: HAPTIC_TYPE_LEFTRIGHT +HAPTIC_TYPE_TRIANGLE sdl2/sdl2.html#HAPTIC_TYPE_TRIANGLE sdl2: HAPTIC_TYPE_TRIANGLE +HAPTIC_TYPE_SAWTOOTHUP sdl2/sdl2.html#HAPTIC_TYPE_SAWTOOTHUP sdl2: HAPTIC_TYPE_SAWTOOTHUP +HAPTIC_TYPE_SAWTOOTHDOWN sdl2/sdl2.html#HAPTIC_TYPE_SAWTOOTHDOWN sdl2: HAPTIC_TYPE_SAWTOOTHDOWN +HAPTIC_TYPE_RAMP sdl2/sdl2.html#HAPTIC_TYPE_RAMP sdl2: HAPTIC_TYPE_RAMP +HAPTIC_TYPE_SPRING sdl2/sdl2.html#HAPTIC_TYPE_SPRING sdl2: HAPTIC_TYPE_SPRING +HAPTIC_TYPE_DAMPER sdl2/sdl2.html#HAPTIC_TYPE_DAMPER sdl2: HAPTIC_TYPE_DAMPER +HAPTIC_TYPE_INERTIA sdl2/sdl2.html#HAPTIC_TYPE_INERTIA sdl2: HAPTIC_TYPE_INERTIA +HAPTIC_TYPE_FRICTION sdl2/sdl2.html#HAPTIC_TYPE_FRICTION sdl2: HAPTIC_TYPE_FRICTION +HAPTIC_TYPE_CUSTOM sdl2/sdl2.html#HAPTIC_TYPE_CUSTOM sdl2: HAPTIC_TYPE_CUSTOM +HAPTIC_TYPE_GAIN sdl2/sdl2.html#HAPTIC_TYPE_GAIN sdl2: HAPTIC_TYPE_GAIN +HAPTIC_TYPE_AUTOCENTER sdl2/sdl2.html#HAPTIC_TYPE_AUTOCENTER sdl2: HAPTIC_TYPE_AUTOCENTER +HAPTIC_TYPE_STATUS sdl2/sdl2.html#HAPTIC_TYPE_STATUS sdl2: HAPTIC_TYPE_STATUS +HAPTIC_TYPE_PAUSE sdl2/sdl2.html#HAPTIC_TYPE_PAUSE sdl2: HAPTIC_TYPE_PAUSE +HAPTIC_TYPE_POLAR sdl2/sdl2.html#HAPTIC_TYPE_POLAR sdl2: HAPTIC_TYPE_POLAR +HAPTIC_TYPE_CARTESIAN sdl2/sdl2.html#HAPTIC_TYPE_CARTESIAN sdl2: HAPTIC_TYPE_CARTESIAN +HAPTIC_TYPE_SPHERICAL sdl2/sdl2.html#HAPTIC_TYPE_SPHERICAL sdl2: HAPTIC_TYPE_SPHERICAL +HAPTIC_TYPE_INFINITY sdl2/sdl2.html#HAPTIC_TYPE_INFINITY sdl2: HAPTIC_TYPE_INFINITY +HINT_FRAMEBUFFER_ACCELERATION sdl2/sdl2.html#HINT_FRAMEBUFFER_ACCELERATION sdl2: HINT_FRAMEBUFFER_ACCELERATION +HINT_RENDER_DRIVER sdl2/sdl2.html#HINT_RENDER_DRIVER sdl2: HINT_RENDER_DRIVER +HINT_RENDER_OPENGL_SHADERS sdl2/sdl2.html#HINT_RENDER_OPENGL_SHADERS sdl2: HINT_RENDER_OPENGL_SHADERS +HINT_RENDER_DIRECT3D_THREADSAFE sdl2/sdl2.html#HINT_RENDER_DIRECT3D_THREADSAFE sdl2: HINT_RENDER_DIRECT3D_THREADSAFE +HINT_RENDER_DIRECT3D11_DEBUG sdl2/sdl2.html#HINT_RENDER_DIRECT3D11_DEBUG sdl2: HINT_RENDER_DIRECT3D11_DEBUG +HINT_RENDER_LOGICAL_SIZE_MODE sdl2/sdl2.html#HINT_RENDER_LOGICAL_SIZE_MODE sdl2: HINT_RENDER_LOGICAL_SIZE_MODE +HINT_RENDER_SCALE_QUALITY sdl2/sdl2.html#HINT_RENDER_SCALE_QUALITY sdl2: HINT_RENDER_SCALE_QUALITY +HINT_RENDER_VSYNC sdl2/sdl2.html#HINT_RENDER_VSYNC sdl2: HINT_RENDER_VSYNC +HINT_VIDEO_ALLOW_SCREENSAVER sdl2/sdl2.html#HINT_VIDEO_ALLOW_SCREENSAVER sdl2: HINT_VIDEO_ALLOW_SCREENSAVER +HINT_VIDEO_EXTERNAL_CONTEXT sdl2/sdl2.html#HINT_VIDEO_EXTERNAL_CONTEXT sdl2: HINT_VIDEO_EXTERNAL_CONTEXT +HINT_VIDEO_X11_XVIDMODE sdl2/sdl2.html#HINT_VIDEO_X11_XVIDMODE sdl2: HINT_VIDEO_X11_XVIDMODE +HINT_VIDEO_X11_XINERAMA sdl2/sdl2.html#HINT_VIDEO_X11_XINERAMA sdl2: HINT_VIDEO_X11_XINERAMA +HINT_VIDEO_X11_XRANDR sdl2/sdl2.html#HINT_VIDEO_X11_XRANDR sdl2: HINT_VIDEO_X11_XRANDR +HINT_VIDEO_X11_WINDOW_VISUALID sdl2/sdl2.html#HINT_VIDEO_X11_WINDOW_VISUALID sdl2: HINT_VIDEO_X11_WINDOW_VISUALID +HINT_VIDEO_X11_NET_WM_PING sdl2/sdl2.html#HINT_VIDEO_X11_NET_WM_PING sdl2: HINT_VIDEO_X11_NET_WM_PING +HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR sdl2/sdl2.html#HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR sdl2: HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR +HINT_VIDEO_X11_FORCE_EGL sdl2/sdl2.html#HINT_VIDEO_X11_FORCE_EGL sdl2: HINT_VIDEO_X11_FORCE_EGL +HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN sdl2/sdl2.html#HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN sdl2: HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN +HINT_WINDOWS_INTRESOURCE_ICON sdl2/sdl2.html#HINT_WINDOWS_INTRESOURCE_ICON sdl2: HINT_WINDOWS_INTRESOURCE_ICON +HINT_WINDOWS_INTRESOURCE_ICON_SMALL sdl2/sdl2.html#HINT_WINDOWS_INTRESOURCE_ICON_SMALL sdl2: HINT_WINDOWS_INTRESOURCE_ICON_SMALL +HINT_WINDOWS_ENABLE_MESSAGELOOP sdl2/sdl2.html#HINT_WINDOWS_ENABLE_MESSAGELOOP sdl2: HINT_WINDOWS_ENABLE_MESSAGELOOP +HINT_GRAB_KEYBOARD sdl2/sdl2.html#HINT_GRAB_KEYBOARD sdl2: HINT_GRAB_KEYBOARD +HINT_MOUSE_DOUBLE_CLICK_TIME sdl2/sdl2.html#HINT_MOUSE_DOUBLE_CLICK_TIME sdl2: HINT_MOUSE_DOUBLE_CLICK_TIME +HINT_MOUSE_DOUBLE_CLICK_RADIUS sdl2/sdl2.html#HINT_MOUSE_DOUBLE_CLICK_RADIUS sdl2: HINT_MOUSE_DOUBLE_CLICK_RADIUS +HINT_MOUSE_NORMAL_SPEED_SCALE sdl2/sdl2.html#HINT_MOUSE_NORMAL_SPEED_SCALE sdl2: HINT_MOUSE_NORMAL_SPEED_SCALE +HINT_MOUSE_RELATIVE_SPEED_SCALE sdl2/sdl2.html#HINT_MOUSE_RELATIVE_SPEED_SCALE sdl2: HINT_MOUSE_RELATIVE_SPEED_SCALE +HINT_MOUSE_RELATIVE_MODE_WARP sdl2/sdl2.html#HINT_MOUSE_RELATIVE_MODE_WARP sdl2: HINT_MOUSE_RELATIVE_MODE_WARP +HINT_MOUSE_FOCUS_CLICKTHROUGH sdl2/sdl2.html#HINT_MOUSE_FOCUS_CLICKTHROUGH sdl2: HINT_MOUSE_FOCUS_CLICKTHROUGH +HINT_TOUCH_MOUSE_EVENTS sdl2/sdl2.html#HINT_TOUCH_MOUSE_EVENTS sdl2: HINT_TOUCH_MOUSE_EVENTS +HINT_MOUSE_TOUCH_EVENTS sdl2/sdl2.html#HINT_MOUSE_TOUCH_EVENTS sdl2: HINT_MOUSE_TOUCH_EVENTS +HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS sdl2/sdl2.html#HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS sdl2: HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS +HINT_IDLE_TIMER_DISABLED sdl2/sdl2.html#HINT_IDLE_TIMER_DISABLED sdl2: HINT_IDLE_TIMER_DISABLED +HINT_ORIENTATIONS sdl2/sdl2.html#HINT_ORIENTATIONS sdl2: HINT_ORIENTATIONS +HINT_APPLE_TV_CONTROLLER_UI_EVENTS sdl2/sdl2.html#HINT_APPLE_TV_CONTROLLER_UI_EVENTS sdl2: HINT_APPLE_TV_CONTROLLER_UI_EVENTS +HINT_APPLE_TV_REMOTE_ALLOW_ROTATION sdl2/sdl2.html#HINT_APPLE_TV_REMOTE_ALLOW_ROTATION sdl2: HINT_APPLE_TV_REMOTE_ALLOW_ROTATION +HINT_IOS_HIDE_HOME_INDICATOR sdl2/sdl2.html#HINT_IOS_HIDE_HOME_INDICATOR sdl2: HINT_IOS_HIDE_HOME_INDICATOR +HINT_ACCELEROMETER_AS_JOYSTICK sdl2/sdl2.html#HINT_ACCELEROMETER_AS_JOYSTICK sdl2: HINT_ACCELEROMETER_AS_JOYSTICK +HINT_TV_REMOTE_AS_JOYSTICK sdl2/sdl2.html#HINT_TV_REMOTE_AS_JOYSTICK sdl2: HINT_TV_REMOTE_AS_JOYSTICK +HINT_XINPUT_ENABLED sdl2/sdl2.html#HINT_XINPUT_ENABLED sdl2: HINT_XINPUT_ENABLED +HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING sdl2/sdl2.html#HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING sdl2: HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING +HINT_GAMECONTROLLERTYPE sdl2/sdl2.html#HINT_GAMECONTROLLERTYPE sdl2: HINT_GAMECONTROLLERTYPE +HINT_GAMECONTROLLERCONFIG sdl2/sdl2.html#HINT_GAMECONTROLLERCONFIG sdl2: HINT_GAMECONTROLLERCONFIG +HINT_GAMECONTROLLERCONFIG_FILE sdl2/sdl2.html#HINT_GAMECONTROLLERCONFIG_FILE sdl2: HINT_GAMECONTROLLERCONFIG_FILE +HINT_GAMECONTROLLER_IGNORE_DEVICES sdl2/sdl2.html#HINT_GAMECONTROLLER_IGNORE_DEVICES sdl2: HINT_GAMECONTROLLER_IGNORE_DEVICES +HINT_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT sdl2/sdl2.html#HINT_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT sdl2: HINT_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT +HINT_GAMECONTROLLER_USE_BUTTON_LABELS sdl2/sdl2.html#HINT_GAMECONTROLLER_USE_BUTTON_LABELS sdl2: HINT_GAMECONTROLLER_USE_BUTTON_LABELS +HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS sdl2/sdl2.html#HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS sdl2: HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS +HINT_JOYSTICK_HIDAPI sdl2/sdl2.html#HINT_JOYSTICK_HIDAPI sdl2: HINT_JOYSTICK_HIDAPI +HINT_JOYSTICK_HIDAPI_PS4 sdl2/sdl2.html#HINT_JOYSTICK_HIDAPI_PS4 sdl2: HINT_JOYSTICK_HIDAPI_PS4 +HINT_JOYSTICK_HIDAPI_PS4_RUMBLE sdl2/sdl2.html#HINT_JOYSTICK_HIDAPI_PS4_RUMBLE sdl2: HINT_JOYSTICK_HIDAPI_PS4_RUMBLE +HINT_JOYSTICK_HIDAPI_STEAM sdl2/sdl2.html#HINT_JOYSTICK_HIDAPI_STEAM sdl2: HINT_JOYSTICK_HIDAPI_STEAM +HINT_JOYSTICK_HIDAPI_SWITCH sdl2/sdl2.html#HINT_JOYSTICK_HIDAPI_SWITCH sdl2: HINT_JOYSTICK_HIDAPI_SWITCH +HINT_JOYSTICK_HIDAPI_XBOX sdl2/sdl2.html#HINT_JOYSTICK_HIDAPI_XBOX sdl2: HINT_JOYSTICK_HIDAPI_XBOX +HINT_JOYSTICK_HIDAPI_GAMECUBE sdl2/sdl2.html#HINT_JOYSTICK_HIDAPI_GAMECUBE sdl2: HINT_JOYSTICK_HIDAPI_GAMECUBE +HINT_ENABLE_STEAM_CONTROLLERS sdl2/sdl2.html#HINT_ENABLE_STEAM_CONTROLLERS sdl2: HINT_ENABLE_STEAM_CONTROLLERS +HINT_ALLOW_TOPMOST sdl2/sdl2.html#HINT_ALLOW_TOPMOST sdl2: HINT_ALLOW_TOPMOST +HINT_TIMER_RESOLUTION sdl2/sdl2.html#HINT_TIMER_RESOLUTION sdl2: HINT_TIMER_RESOLUTION +HINT_QTWAYLAND_CONTENT_ORIENTATION sdl2/sdl2.html#HINT_QTWAYLAND_CONTENT_ORIENTATION sdl2: HINT_QTWAYLAND_CONTENT_ORIENTATION +HINT_QTWAYLAND_WINDOW_FLAGS sdl2/sdl2.html#HINT_QTWAYLAND_WINDOW_FLAGS sdl2: HINT_QTWAYLAND_WINDOW_FLAGS +HINT_THREAD_STACK_SIZE sdl2/sdl2.html#HINT_THREAD_STACK_SIZE sdl2: HINT_THREAD_STACK_SIZE +HINT_VIDEO_HIGHDPI_DISABLED sdl2/sdl2.html#HINT_VIDEO_HIGHDPI_DISABLED sdl2: HINT_VIDEO_HIGHDPI_DISABLED +HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK sdl2/sdl2.html#HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK sdl2: HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK +HINT_VIDEO_WIN_D3DCOMPILER sdl2/sdl2.html#HINT_VIDEO_WIN_D3DCOMPILER sdl2: HINT_VIDEO_WIN_D3DCOMPILER +HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT sdl2/sdl2.html#HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT sdl2: HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT +HINT_WINRT_PRIVACY_POLICY_URL sdl2/sdl2.html#HINT_WINRT_PRIVACY_POLICY_URL sdl2: HINT_WINRT_PRIVACY_POLICY_URL +HINT_WINRT_PRIVACY_POLICY_LABEL sdl2/sdl2.html#HINT_WINRT_PRIVACY_POLICY_LABEL sdl2: HINT_WINRT_PRIVACY_POLICY_LABEL +HINT_WINRT_HANDLE_BACK_BUTTON sdl2/sdl2.html#HINT_WINRT_HANDLE_BACK_BUTTON sdl2: HINT_WINRT_HANDLE_BACK_BUTTON +HINT_VIDEO_MAC_FULLSCREEN_SPACES sdl2/sdl2.html#HINT_VIDEO_MAC_FULLSCREEN_SPACES sdl2: HINT_VIDEO_MAC_FULLSCREEN_SPACES +HINT_MAC_BACKGROUND_APP sdl2/sdl2.html#HINT_MAC_BACKGROUND_APP sdl2: HINT_MAC_BACKGROUND_APP +HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION sdl2/sdl2.html#HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION sdl2: HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION +HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION sdl2/sdl2.html#HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION sdl2: HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION +HINT_IME_INTERNAL_EDITING sdl2/sdl2.html#HINT_IME_INTERNAL_EDITING sdl2: HINT_IME_INTERNAL_EDITING +HINT_ANDROID_TRAP_BACK_BUTTON sdl2/sdl2.html#HINT_ANDROID_TRAP_BACK_BUTTON sdl2: HINT_ANDROID_TRAP_BACK_BUTTON +HINT_ANDROID_BLOCK_ON_PAUSE sdl2/sdl2.html#HINT_ANDROID_BLOCK_ON_PAUSE sdl2: HINT_ANDROID_BLOCK_ON_PAUSE +HINT_RETURN_KEY_HIDES_IME sdl2/sdl2.html#HINT_RETURN_KEY_HIDES_IME sdl2: HINT_RETURN_KEY_HIDES_IME +HINT_EMSCRIPTEN_KEYBOARD_ELEMENT sdl2/sdl2.html#HINT_EMSCRIPTEN_KEYBOARD_ELEMENT sdl2: HINT_EMSCRIPTEN_KEYBOARD_ELEMENT +HINT_NO_SIGNAL_HANDLERS sdl2/sdl2.html#HINT_NO_SIGNAL_HANDLERS sdl2: HINT_NO_SIGNAL_HANDLERS +HINT_WINDOWS_NO_CLOSE_ON_ALT_F4 sdl2/sdl2.html#HINT_WINDOWS_NO_CLOSE_ON_ALT_F4 sdl2: HINT_WINDOWS_NO_CLOSE_ON_ALT_F4 +HINT_BMP_SAVE_LEGACY_FORMAT sdl2/sdl2.html#HINT_BMP_SAVE_LEGACY_FORMAT sdl2: HINT_BMP_SAVE_LEGACY_FORMAT +HINT_WINDOWS_DISABLE_THREAD_NAMING sdl2/sdl2.html#HINT_WINDOWS_DISABLE_THREAD_NAMING sdl2: HINT_WINDOWS_DISABLE_THREAD_NAMING +HINT_RPI_VIDEO_LAYER sdl2/sdl2.html#HINT_RPI_VIDEO_LAYER sdl2: HINT_RPI_VIDEO_LAYER +HINT_VIDEO_DOUBLE_BUFFER sdl2/sdl2.html#HINT_VIDEO_DOUBLE_BUFFER sdl2: HINT_VIDEO_DOUBLE_BUFFER +HINT_OPENGL_ES_DRIVER sdl2/sdl2.html#HINT_OPENGL_ES_DRIVER sdl2: HINT_OPENGL_ES_DRIVER +HINT_AUDIO_RESAMPLING_MODE sdl2/sdl2.html#HINT_AUDIO_RESAMPLING_MODE sdl2: HINT_AUDIO_RESAMPLING_MODE +HINT_AUDIO_CATEGORY sdl2/sdl2.html#HINT_AUDIO_CATEGORY sdl2: HINT_AUDIO_CATEGORY +HINT_RENDER_BATCHING sdl2/sdl2.html#HINT_RENDER_BATCHING sdl2: HINT_RENDER_BATCHING +HINT_EVENT_LOGGING sdl2/sdl2.html#HINT_EVENT_LOGGING sdl2: HINT_EVENT_LOGGING +HINT_WAVE_RIFF_CHUNK_SIZE sdl2/sdl2.html#HINT_WAVE_RIFF_CHUNK_SIZE sdl2: HINT_WAVE_RIFF_CHUNK_SIZE +HINT_WAVE_TRUNCATION sdl2/sdl2.html#HINT_WAVE_TRUNCATION sdl2: HINT_WAVE_TRUNCATION +HINT_WAVE_FACT_CHUNK sdl2/sdl2.html#HINT_WAVE_FACT_CHUNK sdl2: HINT_WAVE_FACT_CHUNK +HINT_DISPLAY_USABLE_BOUNDS sdl2/sdl2.html#HINT_DISPLAY_USABLE_BOUNDS sdl2: HINT_DISPLAY_USABLE_BOUNDS +HINT_DEFAULT sdl2/sdl2.html#HINT_DEFAULT sdl2: HINT_DEFAULT +HINT_NORMAL sdl2/sdl2.html#HINT_NORMAL sdl2: HINT_NORMAL +HINT_OVERRIDE sdl2/sdl2.html#HINT_OVERRIDE sdl2: HINT_OVERRIDE +MAX_LOG_MESSAGE sdl2/sdl2.html#MAX_LOG_MESSAGE sdl2: MAX_LOG_MESSAGE +LOG_CATEGORY_APPLICATION sdl2/sdl2.html#LOG_CATEGORY_APPLICATION sdl2: LOG_CATEGORY_APPLICATION +LOG_CATEGORY_ERROR sdl2/sdl2.html#LOG_CATEGORY_ERROR sdl2: LOG_CATEGORY_ERROR +LOG_CATEGORY_ASSERT sdl2/sdl2.html#LOG_CATEGORY_ASSERT sdl2: LOG_CATEGORY_ASSERT +LOG_CATEGORY_SYSTEM sdl2/sdl2.html#LOG_CATEGORY_SYSTEM sdl2: LOG_CATEGORY_SYSTEM +LOG_CATEGORY_AUDIO sdl2/sdl2.html#LOG_CATEGORY_AUDIO sdl2: LOG_CATEGORY_AUDIO +LOG_CATEGORY_VIDEO sdl2/sdl2.html#LOG_CATEGORY_VIDEO sdl2: LOG_CATEGORY_VIDEO +LOG_CATEGORY_RENDER sdl2/sdl2.html#LOG_CATEGORY_RENDER sdl2: LOG_CATEGORY_RENDER +LOG_CATEGORY_INPUT sdl2/sdl2.html#LOG_CATEGORY_INPUT sdl2: LOG_CATEGORY_INPUT +LOG_CATEGORY_TEST sdl2/sdl2.html#LOG_CATEGORY_TEST sdl2: LOG_CATEGORY_TEST +LOG_CATEGORY_RESERVED1 sdl2/sdl2.html#LOG_CATEGORY_RESERVED1 sdl2: LOG_CATEGORY_RESERVED1 +LOG_CATEGORY_RESERVED2 sdl2/sdl2.html#LOG_CATEGORY_RESERVED2 sdl2: LOG_CATEGORY_RESERVED2 +LOG_CATEGORY_RESERVED3 sdl2/sdl2.html#LOG_CATEGORY_RESERVED3 sdl2: LOG_CATEGORY_RESERVED3 +LOG_CATEGORY_RESERVED4 sdl2/sdl2.html#LOG_CATEGORY_RESERVED4 sdl2: LOG_CATEGORY_RESERVED4 +LOG_CATEGORY_RESERVED5 sdl2/sdl2.html#LOG_CATEGORY_RESERVED5 sdl2: LOG_CATEGORY_RESERVED5 +LOG_CATEGORY_RESERVED6 sdl2/sdl2.html#LOG_CATEGORY_RESERVED6 sdl2: LOG_CATEGORY_RESERVED6 +LOG_CATEGORY_RESERVED7 sdl2/sdl2.html#LOG_CATEGORY_RESERVED7 sdl2: LOG_CATEGORY_RESERVED7 +LOG_CATEGORY_RESERVED8 sdl2/sdl2.html#LOG_CATEGORY_RESERVED8 sdl2: LOG_CATEGORY_RESERVED8 +LOG_CATEGORY_RESERVED9 sdl2/sdl2.html#LOG_CATEGORY_RESERVED9 sdl2: LOG_CATEGORY_RESERVED9 +LOG_CATEGORY_RESERVED10 sdl2/sdl2.html#LOG_CATEGORY_RESERVED10 sdl2: LOG_CATEGORY_RESERVED10 +LOG_CATEGORY_CUSTOM sdl2/sdl2.html#LOG_CATEGORY_CUSTOM sdl2: LOG_CATEGORY_CUSTOM +LOG_PRIORITY_VERBOSE sdl2/sdl2.html#LOG_PRIORITY_VERBOSE sdl2: LOG_PRIORITY_VERBOSE +LOG_PRIORITY_DEBUG sdl2/sdl2.html#LOG_PRIORITY_DEBUG sdl2: LOG_PRIORITY_DEBUG +LOG_PRIORITY_INFO sdl2/sdl2.html#LOG_PRIORITY_INFO sdl2: LOG_PRIORITY_INFO +LOG_PRIORITY_WARN sdl2/sdl2.html#LOG_PRIORITY_WARN sdl2: LOG_PRIORITY_WARN +LOG_PRIORITY_ERROR sdl2/sdl2.html#LOG_PRIORITY_ERROR sdl2: LOG_PRIORITY_ERROR +LOG_PRIORITY_CRITICAL sdl2/sdl2.html#LOG_PRIORITY_CRITICAL sdl2: LOG_PRIORITY_CRITICAL +NUM_LOG_PRIORITIES sdl2/sdl2.html#NUM_LOG_PRIORITIES sdl2: NUM_LOG_PRIORITIES +MESSAGEBOX_ERROR sdl2/sdl2.html#MESSAGEBOX_ERROR sdl2: MESSAGEBOX_ERROR +MESSAGEBOX_WARNING sdl2/sdl2.html#MESSAGEBOX_WARNING sdl2: MESSAGEBOX_WARNING +MESSAGEBOX_INFORMATION sdl2/sdl2.html#MESSAGEBOX_INFORMATION sdl2: MESSAGEBOX_INFORMATION +MESSAGEBOX_BUTTONS_LEFT_TO_RIGHT sdl2/sdl2.html#MESSAGEBOX_BUTTONS_LEFT_TO_RIGHT sdl2: MESSAGEBOX_BUTTONS_LEFT_TO_RIGHT +MESSAGEBOX_BUTTONS_RIGHT_TO_LEFT sdl2/sdl2.html#MESSAGEBOX_BUTTONS_RIGHT_TO_LEFT sdl2: MESSAGEBOX_BUTTONS_RIGHT_TO_LEFT +MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT sdl2/sdl2.html#MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT sdl2: MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT +MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT sdl2/sdl2.html#MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT sdl2: MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT +MESSAGEBOX_COLOR_BACKGROUND sdl2/sdl2.html#MESSAGEBOX_COLOR_BACKGROUND sdl2: MESSAGEBOX_COLOR_BACKGROUND +MESSAGEBOX_COLOR_TEXT sdl2/sdl2.html#MESSAGEBOX_COLOR_TEXT sdl2: MESSAGEBOX_COLOR_TEXT +MESSAGEBOX_COLOR_BUTTON_BORDER sdl2/sdl2.html#MESSAGEBOX_COLOR_BUTTON_BORDER sdl2: MESSAGEBOX_COLOR_BUTTON_BORDER +MESSAGEBOX_COLOR_BUTTON_BACKGROUND sdl2/sdl2.html#MESSAGEBOX_COLOR_BUTTON_BACKGROUND sdl2: MESSAGEBOX_COLOR_BUTTON_BACKGROUND +MESSAGEBOX_COLOR_BUTTON_SELECTED sdl2/sdl2.html#MESSAGEBOX_COLOR_BUTTON_SELECTED sdl2: MESSAGEBOX_COLOR_BUTTON_SELECTED +MESSAGEBOX_COLOR_MAX sdl2/sdl2.html#MESSAGEBOX_COLOR_MAX sdl2: MESSAGEBOX_COLOR_MAX +POWERSTATE_UNKNOWN sdl2/sdl2.html#POWERSTATE_UNKNOWN sdl2: POWERSTATE_UNKNOWN +POWERSTATE_ON_BATTERY sdl2/sdl2.html#POWERSTATE_ON_BATTERY sdl2: POWERSTATE_ON_BATTERY +POWERSTATE_NO_BATTERY sdl2/sdl2.html#POWERSTATE_NO_BATTERY sdl2: POWERSTATE_NO_BATTERY +POWERSTATE_CHARGING sdl2/sdl2.html#POWERSTATE_CHARGING sdl2: POWERSTATE_CHARGING +POWERSTATE_CHARGED sdl2/sdl2.html#POWERSTATE_CHARGED sdl2: POWERSTATE_CHARGED +RENDERER_SOFTWARE sdl2/sdl2.html#RENDERER_SOFTWARE sdl2: RENDERER_SOFTWARE +RENDERER_ACCELERATED sdl2/sdl2.html#RENDERER_ACCELERATED sdl2: RENDERER_ACCELERATED +RENDERER_PRESENTVSYNC sdl2/sdl2.html#RENDERER_PRESENTVSYNC sdl2: RENDERER_PRESENTVSYNC +RENDERER_TARGETTEXTURE sdl2/sdl2.html#RENDERER_TARGETTEXTURE sdl2: RENDERER_TARGETTEXTURE +ScaleModeNearest sdl2/sdl2.html#ScaleModeNearest sdl2: ScaleModeNearest +ScaleModeLinear sdl2/sdl2.html#ScaleModeLinear sdl2: ScaleModeLinear +ScaleModeBest sdl2/sdl2.html#ScaleModeBest sdl2: ScaleModeBest +TEXTUREACCESS_STATIC sdl2/sdl2.html#TEXTUREACCESS_STATIC sdl2: TEXTUREACCESS_STATIC +TEXTUREACCESS_STREAMING sdl2/sdl2.html#TEXTUREACCESS_STREAMING sdl2: TEXTUREACCESS_STREAMING +TEXTUREACCESS_TARGET sdl2/sdl2.html#TEXTUREACCESS_TARGET sdl2: TEXTUREACCESS_TARGET +TEXTUREMODULATE_NONE sdl2/sdl2.html#TEXTUREMODULATE_NONE sdl2: TEXTUREMODULATE_NONE +TEXTUREMODULATE_COLOR sdl2/sdl2.html#TEXTUREMODULATE_COLOR sdl2: TEXTUREMODULATE_COLOR +TEXTUREMODULATE_ALPHA sdl2/sdl2.html#TEXTUREMODULATE_ALPHA sdl2: TEXTUREMODULATE_ALPHA +FLIP_NONE sdl2/sdl2.html#FLIP_NONE sdl2: FLIP_NONE +FLIP_HORIZONTAL sdl2/sdl2.html#FLIP_HORIZONTAL sdl2: FLIP_HORIZONTAL +FLIP_VERTICAL sdl2/sdl2.html#FLIP_VERTICAL sdl2: FLIP_VERTICAL +SENSOR_INVALID sdl2/sdl2.html#SENSOR_INVALID sdl2: SENSOR_INVALID +SENSOR_UNKNOWN sdl2/sdl2.html#SENSOR_UNKNOWN sdl2: SENSOR_UNKNOWN +SENSOR_ACCEL sdl2/sdl2.html#SENSOR_ACCEL sdl2: SENSOR_ACCEL +SENSOR_GYRO sdl2/sdl2.html#SENSOR_GYRO sdl2: SENSOR_GYRO +STANDARD_GRAVITY sdl2/sdl2.html#STANDARD_GRAVITY sdl2: STANDARD_GRAVITY +NONSHAPEABLE_WINDOW sdl2/sdl2.html#NONSHAPEABLE_WINDOW sdl2: NONSHAPEABLE_WINDOW +INVALID_SHAPE_ARGUMENT sdl2/sdl2.html#INVALID_SHAPE_ARGUMENT sdl2: INVALID_SHAPE_ARGUMENT +WINDOW_LACKS_SHAPE sdl2/sdl2.html#WINDOW_LACKS_SHAPE sdl2: WINDOW_LACKS_SHAPE +ShapeModeDefault sdl2/sdl2.html#ShapeModeDefault sdl2: ShapeModeDefault +ShapeModeBinarizeAlpha sdl2/sdl2.html#ShapeModeBinarizeAlpha sdl2: ShapeModeBinarizeAlpha +ShapeModeReverseBinarizeAlpha sdl2/sdl2.html#ShapeModeReverseBinarizeAlpha sdl2: ShapeModeReverseBinarizeAlpha +ShapeModeColorKey sdl2/sdl2.html#ShapeModeColorKey sdl2: ShapeModeColorKey +MAJOR_VERSION sdl2/sdl2.html#MAJOR_VERSION sdl2: MAJOR_VERSION +MINOR_VERSION sdl2/sdl2.html#MINOR_VERSION sdl2: MINOR_VERSION +PATCHLEVEL sdl2/sdl2.html#PATCHLEVEL sdl2: PATCHLEVEL +INIT_TIMER sdl2/sdl2.html#INIT_TIMER sdl2: INIT_TIMER +INIT_AUDIO sdl2/sdl2.html#INIT_AUDIO sdl2: INIT_AUDIO +INIT_VIDEO sdl2/sdl2.html#INIT_VIDEO sdl2: INIT_VIDEO +INIT_JOYSTICK sdl2/sdl2.html#INIT_JOYSTICK sdl2: INIT_JOYSTICK +INIT_HAPTIC sdl2/sdl2.html#INIT_HAPTIC sdl2: INIT_HAPTIC +INIT_GAMECONTROLLER sdl2/sdl2.html#INIT_GAMECONTROLLER sdl2: INIT_GAMECONTROLLER +INIT_EVENTS sdl2/sdl2.html#INIT_EVENTS sdl2: INIT_EVENTS +INIT_SENSOR sdl2/sdl2.html#INIT_SENSOR sdl2: INIT_SENSOR +INIT_NOPARACHUTE sdl2/sdl2.html#INIT_NOPARACHUTE sdl2: INIT_NOPARACHUTE +INIT_EVERYTHING sdl2/sdl2.html#INIT_EVERYTHING sdl2: INIT_EVERYTHING +RWops sdl2/sdl2.html#RWops sdl2: RWops +BlitMap sdl2/sdl2.html#BlitMap sdl2: BlitMap +CONTROLLER_BINDTYPE_NONE sdl2/sdl2.html#CONTROLLER_BINDTYPE_NONE GameControllerBindType.CONTROLLER_BINDTYPE_NONE +CONTROLLER_BINDTYPE_BUTTON sdl2/sdl2.html#CONTROLLER_BINDTYPE_BUTTON GameControllerBindType.CONTROLLER_BINDTYPE_BUTTON +CONTROLLER_BINDTYPE_AXIS sdl2/sdl2.html#CONTROLLER_BINDTYPE_AXIS GameControllerBindType.CONTROLLER_BINDTYPE_AXIS +CONTROLLER_BINDTYPE_HAT sdl2/sdl2.html#CONTROLLER_BINDTYPE_HAT GameControllerBindType.CONTROLLER_BINDTYPE_HAT +GameControllerBindType sdl2/sdl2.html#GameControllerBindType sdl2: GameControllerBindType +false sdl2/sdl2.html#false Bool.false +true sdl2/sdl2.html#true Bool.true +Bool sdl2/sdl2.html#Bool sdl2: Bool +GameControllerButtonBind sdl2/sdl2.html#GameControllerButtonBind sdl2: GameControllerButtonBind +ButtonBindHat sdl2/sdl2.html#ButtonBindHat sdl2: ButtonBindHat +Sint8 sdl2/sdl2.html#Sint8 sdl2: Sint8 +Uint8 sdl2/sdl2.html#Uint8 sdl2: Uint8 +Sint16 sdl2/sdl2.html#Sint16 sdl2: Sint16 +Uint16 sdl2/sdl2.html#Uint16 sdl2: Uint16 +Sint32 sdl2/sdl2.html#Sint32 sdl2: Sint32 +Uint32 sdl2/sdl2.html#Uint32 sdl2: Uint32 +Sint64 sdl2/sdl2.html#Sint64 sdl2: Sint64 +Uint64 sdl2/sdl2.html#Uint64 sdl2: Uint64 +malloc_func sdl2/sdl2.html#malloc_func sdl2: malloc_func +calloc_func sdl2/sdl2.html#calloc_func sdl2: calloc_func +realloc_func sdl2/sdl2.html#realloc_func sdl2: realloc_func +free_func sdl2/sdl2.html#free_func sdl2: free_func +iconv_t sdl2/sdl2.html#iconv_t sdl2: iconv_t +main_func sdl2/sdl2.html#main_func sdl2: main_func +AssertData sdl2/sdl2.html#AssertData sdl2: AssertData +AssertionHandler sdl2/sdl2.html#AssertionHandler sdl2: AssertionHandler +SpinLock sdl2/sdl2.html#SpinLock sdl2: SpinLock +atomic_t sdl2/sdl2.html#atomic_t sdl2: atomic_t +mutex sdl2/sdl2.html#mutex sdl2: mutex +semaphore sdl2/sdl2.html#semaphore sdl2: semaphore +sem sdl2/sdl2.html#sem sdl2: sem +cond sdl2/sdl2.html#cond sdl2: cond +Thread sdl2/sdl2.html#Thread sdl2: Thread +threadID sdl2/sdl2.html#threadID sdl2: threadID +TLSID sdl2/sdl2.html#TLSID sdl2: TLSID +ThreadFunction sdl2/sdl2.html#ThreadFunction sdl2: ThreadFunction +AudioFormat sdl2/sdl2.html#AudioFormat sdl2: AudioFormat +AudioCallback sdl2/sdl2.html#AudioCallback sdl2: AudioCallback +AudioSpec sdl2/sdl2.html#AudioSpec sdl2: AudioSpec +AudioCVT sdl2/sdl2.html#AudioCVT sdl2: AudioCVT +AudioFilter sdl2/sdl2.html#AudioFilter sdl2: AudioFilter +AudioDeviceID sdl2/sdl2.html#AudioDeviceID sdl2: AudioDeviceID +AudioStream sdl2/sdl2.html#AudioStream sdl2: AudioStream +Color sdl2/sdl2.html#Color sdl2: Color +Palette sdl2/sdl2.html#Palette sdl2: Palette +PixelFormat sdl2/sdl2.html#PixelFormat sdl2: PixelFormat +Point sdl2/sdl2.html#Point sdl2: Point +FPoint sdl2/sdl2.html#FPoint sdl2: FPoint +Rect sdl2/sdl2.html#Rect sdl2: Rect +FRect sdl2/sdl2.html#FRect sdl2: FRect +Surface sdl2/sdl2.html#Surface sdl2: Surface +blit sdl2/sdl2.html#blit sdl2: blit +DisplayMode sdl2/sdl2.html#DisplayMode sdl2: DisplayMode +Window sdl2/sdl2.html#Window sdl2: Window +GLContext sdl2/sdl2.html#GLContext sdl2: GLContext +HitTest sdl2/sdl2.html#HitTest sdl2: HitTest +Keycode sdl2/sdl2.html#Keycode sdl2: Keycode +Keysym sdl2/sdl2.html#Keysym sdl2: Keysym +Cursor sdl2/sdl2.html#Cursor sdl2: Cursor +Joystick sdl2/sdl2.html#Joystick sdl2: Joystick +JoystickGUID sdl2/sdl2.html#JoystickGUID sdl2: JoystickGUID +JoystickID sdl2/sdl2.html#JoystickID sdl2: JoystickID +GameController sdl2/sdl2.html#GameController sdl2: GameController +TouchID sdl2/sdl2.html#TouchID sdl2: TouchID +FingerID sdl2/sdl2.html#FingerID sdl2: FingerID +Finger sdl2/sdl2.html#Finger sdl2: Finger +GestureID sdl2/sdl2.html#GestureID sdl2: GestureID +CommonEvent sdl2/sdl2.html#CommonEvent sdl2: CommonEvent +DisplayEvent sdl2/sdl2.html#DisplayEvent sdl2: DisplayEvent +WindowEvent sdl2/sdl2.html#WindowEvent sdl2: WindowEvent +KeyboardEvent sdl2/sdl2.html#KeyboardEvent sdl2: KeyboardEvent +TextEditingEvent sdl2/sdl2.html#TextEditingEvent sdl2: TextEditingEvent +TextInputEvent sdl2/sdl2.html#TextInputEvent sdl2: TextInputEvent +MouseMotionEvent sdl2/sdl2.html#MouseMotionEvent sdl2: MouseMotionEvent +MouseButtonEvent sdl2/sdl2.html#MouseButtonEvent sdl2: MouseButtonEvent +MouseWheelEvent sdl2/sdl2.html#MouseWheelEvent sdl2: MouseWheelEvent +JoyAxisEvent sdl2/sdl2.html#JoyAxisEvent sdl2: JoyAxisEvent +JoyBallEvent sdl2/sdl2.html#JoyBallEvent sdl2: JoyBallEvent +JoyHatEvent sdl2/sdl2.html#JoyHatEvent sdl2: JoyHatEvent +JoyButtonEvent sdl2/sdl2.html#JoyButtonEvent sdl2: JoyButtonEvent +JoyDeviceEvent sdl2/sdl2.html#JoyDeviceEvent sdl2: JoyDeviceEvent +ControllerAxisEvent sdl2/sdl2.html#ControllerAxisEvent sdl2: ControllerAxisEvent +ControllerButtonEvent sdl2/sdl2.html#ControllerButtonEvent sdl2: ControllerButtonEvent +ControllerDeviceEvent sdl2/sdl2.html#ControllerDeviceEvent sdl2: ControllerDeviceEvent +AudioDeviceEvent sdl2/sdl2.html#AudioDeviceEvent sdl2: AudioDeviceEvent +TouchFingerEvent sdl2/sdl2.html#TouchFingerEvent sdl2: TouchFingerEvent +MultiGestureEvent sdl2/sdl2.html#MultiGestureEvent sdl2: MultiGestureEvent +DollarGestureEvent sdl2/sdl2.html#DollarGestureEvent sdl2: DollarGestureEvent +DropEvent sdl2/sdl2.html#DropEvent sdl2: DropEvent +SensorEvent sdl2/sdl2.html#SensorEvent sdl2: SensorEvent +QuitEvent sdl2/sdl2.html#QuitEvent sdl2: QuitEvent +OSEvent sdl2/sdl2.html#OSEvent sdl2: OSEvent +UserEvent sdl2/sdl2.html#UserEvent sdl2: UserEvent +SysWMmsg sdl2/sdl2.html#SysWMmsg sdl2: SysWMmsg +SysWMEvent sdl2/sdl2.html#SysWMEvent sdl2: SysWMEvent +Event sdl2/sdl2.html#Event sdl2: Event +EventFilter sdl2/sdl2.html#EventFilter sdl2: EventFilter +PHaptic sdl2/sdl2.html#PHaptic sdl2: PHaptic +Haptic sdl2/sdl2.html#Haptic sdl2: Haptic +HapticDirection sdl2/sdl2.html#HapticDirection sdl2: HapticDirection +HapticConstant sdl2/sdl2.html#HapticConstant sdl2: HapticConstant +HapticPeriodic sdl2/sdl2.html#HapticPeriodic sdl2: HapticPeriodic +HapticCondition sdl2/sdl2.html#HapticCondition sdl2: HapticCondition +HapticRamp sdl2/sdl2.html#HapticRamp sdl2: HapticRamp +HapticLeftRight sdl2/sdl2.html#HapticLeftRight sdl2: HapticLeftRight +HapticCustom sdl2/sdl2.html#HapticCustom sdl2: HapticCustom +HapticEffect sdl2/sdl2.html#HapticEffect sdl2: HapticEffect +HintCallback sdl2/sdl2.html#HintCallback sdl2: HintCallback +LogOutputFunction sdl2/sdl2.html#LogOutputFunction sdl2: LogOutputFunction +MessageBoxButtonData sdl2/sdl2.html#MessageBoxButtonData sdl2: MessageBoxButtonData +MessageBoxColor sdl2/sdl2.html#MessageBoxColor sdl2: MessageBoxColor +MessageBoxColorScheme sdl2/sdl2.html#MessageBoxColorScheme sdl2: MessageBoxColorScheme +MessageBoxData sdl2/sdl2.html#MessageBoxData sdl2: MessageBoxData +MetalView sdl2/sdl2.html#MetalView sdl2: MetalView +RendererInfo sdl2/sdl2.html#RendererInfo sdl2: RendererInfo +Renderer sdl2/sdl2.html#Renderer sdl2: Renderer +Texture sdl2/sdl2.html#Texture sdl2: Texture +Sensor sdl2/sdl2.html#Sensor sdl2: Sensor +SensorID sdl2/sdl2.html#SensorID sdl2: SensorID +WindowShapeParams sdl2/sdl2.html#WindowShapeParams sdl2: WindowShapeParams +TimerCallback sdl2/sdl2.html#TimerCallback sdl2: TimerCallback +TimerID sdl2/sdl2.html#TimerID sdl2: TimerID +Version sdl2/sdl2.html#Version sdl2: Version +getPlatform sdl2/sdl2.html#getPlatform sdl2: getPlatform(): cstring +malloc sdl2/sdl2.html#malloc,uint sdl2: malloc(size: uint): pointer +calloc sdl2/sdl2.html#calloc,uint,uint sdl2: calloc(nmemb: uint; size: uint): pointer +realloc sdl2/sdl2.html#realloc,pointer,uint sdl2: realloc(mem: pointer; size: uint): pointer +free sdl2/sdl2.html#free,pointer sdl2: free(mem: pointer) +getMemoryFunctions sdl2/sdl2.html#getMemoryFunctions,ptr.malloc_func,ptr.calloc_func,ptr.realloc_func,ptr.free_func sdl2: getMemoryFunctions(mallocFunc: ptr malloc_func; callocFunc: ptr calloc_func;\n reallocFunc: ptr realloc_func; freeFunc: ptr free_func) +setMemoryFunctions sdl2/sdl2.html#setMemoryFunctions,malloc_func,calloc_func,realloc_func,free_func sdl2: setMemoryFunctions(mallocFunc: malloc_func; callocFunc: calloc_func;\n reallocFunc: realloc_func; freeFunc: free_func): cint +getNumAllocations sdl2/sdl2.html#getNumAllocations sdl2: getNumAllocations(): cint +getenv sdl2/sdl2.html#getenv,cstring sdl2: getenv(name: cstring): cstring +setenv sdl2/sdl2.html#setenv,cstring,cstring,cint sdl2: setenv(name: cstring; value: cstring; overwrite: cint): cint +qsort sdl2/sdl2.html#qsort,pointer,uint,uint,proc(pointer,pointer) sdl2: qsort(base: pointer; nmemb: uint; size: uint;\n compare: proc (a1: pointer; a2: pointer): cint {.cdecl.}) +abs sdl2/sdl2.html#abs,cint sdl2: abs(x: cint): cint +isdigit sdl2/sdl2.html#isdigit,cint sdl2: isdigit(x: cint): cint +isspace sdl2/sdl2.html#isspace,cint sdl2: isspace(x: cint): cint +isupper sdl2/sdl2.html#isupper,cint sdl2: isupper(x: cint): cint +islower sdl2/sdl2.html#islower,cint sdl2: islower(x: cint): cint +toupper sdl2/sdl2.html#toupper,cint sdl2: toupper(x: cint): cint +tolower sdl2/sdl2.html#tolower,cint sdl2: tolower(x: cint): cint +memset sdl2/sdl2.html#memset,pointer,cint,uint sdl2: memset(dst: pointer; c: cint; len: uint): pointer +memcpy sdl2/sdl2.html#memcpy,pointer,pointer,uint sdl2: memcpy(dst: pointer; src: pointer; len: uint): pointer +memmove sdl2/sdl2.html#memmove,pointer,pointer,uint sdl2: memmove(dst: pointer; src: pointer; len: uint): pointer +memcmp sdl2/sdl2.html#memcmp,pointer,pointer,uint sdl2: memcmp(s1: pointer; s2: pointer; len: uint): cint +wcslen sdl2/sdl2.html#wcslen,ptr.wchar_t sdl2: wcslen(wstr: ptr wchar_t): uint +wcslcpy sdl2/sdl2.html#wcslcpy,ptr.wchar_t,ptr.wchar_t,uint sdl2: wcslcpy(dst: ptr wchar_t; src: ptr wchar_t; maxlen: uint): uint +wcslcat sdl2/sdl2.html#wcslcat,ptr.wchar_t,ptr.wchar_t,uint sdl2: wcslcat(dst: ptr wchar_t; src: ptr wchar_t; maxlen: uint): uint +wcsdup sdl2/sdl2.html#wcsdup,ptr.wchar_t sdl2: wcsdup(wstr: ptr wchar_t): ptr wchar_t +wcsstr sdl2/sdl2.html#wcsstr,ptr.wchar_t,ptr.wchar_t sdl2: wcsstr(haystack: ptr wchar_t; needle: ptr wchar_t): ptr wchar_t +wcscmp sdl2/sdl2.html#wcscmp,ptr.wchar_t,ptr.wchar_t sdl2: wcscmp(str1: ptr wchar_t; str2: ptr wchar_t): cint +wcsncmp sdl2/sdl2.html#wcsncmp,ptr.wchar_t,ptr.wchar_t,uint sdl2: wcsncmp(str1: ptr wchar_t; str2: ptr wchar_t; maxlen: uint): cint +strlen sdl2/sdl2.html#strlen,cstring sdl2: strlen(str: cstring): uint +strlcpy sdl2/sdl2.html#strlcpy,cstring,cstring,uint sdl2: strlcpy(dst: cstring; src: cstring; maxlen: uint): uint +utf8strlcpy sdl2/sdl2.html#utf8strlcpy,cstring,cstring,uint sdl2: utf8strlcpy(dst: cstring; src: cstring; dstBytes: uint): uint +strlcat sdl2/sdl2.html#strlcat,cstring,cstring,uint sdl2: strlcat(dst: cstring; src: cstring; maxlen: uint): uint +strdup sdl2/sdl2.html#strdup,cstring sdl2: strdup(str: cstring): cstring +strrev sdl2/sdl2.html#strrev,cstring sdl2: strrev(str: cstring): cstring +strupr sdl2/sdl2.html#strupr,cstring sdl2: strupr(str: cstring): cstring +strlwr sdl2/sdl2.html#strlwr,cstring sdl2: strlwr(str: cstring): cstring +strchr sdl2/sdl2.html#strchr,cstring,cint sdl2: strchr(str: cstring; c: cint): cstring +strrchr sdl2/sdl2.html#strrchr,cstring,cint sdl2: strrchr(str: cstring; c: cint): cstring +strstr sdl2/sdl2.html#strstr,cstring,cstring sdl2: strstr(haystack: cstring; needle: cstring): cstring +strtokr sdl2/sdl2.html#strtokr,cstring,cstring,ptr.cstring sdl2: strtokr(s1: cstring; s2: cstring; saveptr: ptr cstring): cstring +utf8strlen sdl2/sdl2.html#utf8strlen,cstring sdl2: utf8strlen(str: cstring): uint +itoa sdl2/sdl2.html#itoa,cint,cstring,cint sdl2: itoa(value: cint; str: cstring; radix: cint): cstring +uitoa sdl2/sdl2.html#uitoa,cuint,cstring,cint sdl2: uitoa(value: cuint; str: cstring; radix: cint): cstring +ltoa sdl2/sdl2.html#ltoa,clong,cstring,cint sdl2: ltoa(value: clong; str: cstring; radix: cint): cstring +ultoa sdl2/sdl2.html#ultoa,culong,cstring,cint sdl2: ultoa(value: culong; str: cstring; radix: cint): cstring +lltoa sdl2/sdl2.html#lltoa,Sint64,cstring,cint sdl2: lltoa(value: Sint64; str: cstring; radix: cint): cstring +ulltoa sdl2/sdl2.html#ulltoa,Uint64,cstring,cint sdl2: ulltoa(value: Uint64; str: cstring; radix: cint): cstring +atoi sdl2/sdl2.html#atoi,cstring sdl2: atoi(str: cstring): cint +atof sdl2/sdl2.html#atof,cstring sdl2: atof(str: cstring): cdouble +strtol sdl2/sdl2.html#strtol,cstring,ptr.cstring,cint sdl2: strtol(str: cstring; endp: ptr cstring; base: cint): clong +strtoul sdl2/sdl2.html#strtoul,cstring,ptr.cstring,cint sdl2: strtoul(str: cstring; endp: ptr cstring; base: cint): culong +strtoll sdl2/sdl2.html#strtoll,cstring,ptr.cstring,cint sdl2: strtoll(str: cstring; endp: ptr cstring; base: cint): Sint64 +strtoull sdl2/sdl2.html#strtoull,cstring,ptr.cstring,cint sdl2: strtoull(str: cstring; endp: ptr cstring; base: cint): Uint64 +strtod sdl2/sdl2.html#strtod,cstring,ptr.cstring sdl2: strtod(str: cstring; endp: ptr cstring): cdouble +strcmp sdl2/sdl2.html#strcmp,cstring,cstring sdl2: strcmp(str1: cstring; str2: cstring): cint +strncmp sdl2/sdl2.html#strncmp,cstring,cstring,uint sdl2: strncmp(str1: cstring; str2: cstring; maxlen: uint): cint +strcasecmp sdl2/sdl2.html#strcasecmp,cstring,cstring sdl2: strcasecmp(str1: cstring; str2: cstring): cint +strncasecmp sdl2/sdl2.html#strncasecmp,cstring,cstring,uint sdl2: strncasecmp(str1: cstring; str2: cstring; len: uint): cint +sscanf sdl2/sdl2.html#sscanf,cstring,cstring sdl2: sscanf(text: cstring; fmt: cstring): cint +vsscanf sdl2/sdl2.html#vsscanf,cstring,cstring,va_list sdl2: vsscanf(text: cstring; fmt: cstring; ap: va_list): cint +snprintf sdl2/sdl2.html#snprintf,cstring,uint,cstring sdl2: snprintf(text: cstring; maxlen: uint; fmt: cstring): cint +vsnprintf sdl2/sdl2.html#vsnprintf,cstring,uint,cstring,va_list sdl2: vsnprintf(text: cstring; maxlen: uint; fmt: cstring; ap: va_list): cint +acos sdl2/sdl2.html#acos,cdouble sdl2: acos(x: cdouble): cdouble +acosf sdl2/sdl2.html#acosf,cfloat sdl2: acosf(x: cfloat): cfloat +asin sdl2/sdl2.html#asin,cdouble sdl2: asin(x: cdouble): cdouble +asinf sdl2/sdl2.html#asinf,cfloat sdl2: asinf(x: cfloat): cfloat +atan sdl2/sdl2.html#atan,cdouble sdl2: atan(x: cdouble): cdouble +atanf sdl2/sdl2.html#atanf,cfloat sdl2: atanf(x: cfloat): cfloat +atan2 sdl2/sdl2.html#atan2,cdouble,cdouble sdl2: atan2(x: cdouble; y: cdouble): cdouble +atan2f sdl2/sdl2.html#atan2f,cfloat,cfloat sdl2: atan2f(x: cfloat; y: cfloat): cfloat +ceil sdl2/sdl2.html#ceil,cdouble sdl2: ceil(x: cdouble): cdouble +ceilf sdl2/sdl2.html#ceilf,cfloat sdl2: ceilf(x: cfloat): cfloat +copysign sdl2/sdl2.html#copysign,cdouble,cdouble sdl2: copysign(x: cdouble; y: cdouble): cdouble +copysignf sdl2/sdl2.html#copysignf,cfloat,cfloat sdl2: copysignf(x: cfloat; y: cfloat): cfloat +cos sdl2/sdl2.html#cos,cdouble sdl2: cos(x: cdouble): cdouble +cosf sdl2/sdl2.html#cosf,cfloat sdl2: cosf(x: cfloat): cfloat +exp sdl2/sdl2.html#exp,cdouble sdl2: exp(x: cdouble): cdouble +expf sdl2/sdl2.html#expf,cfloat sdl2: expf(x: cfloat): cfloat +fabs sdl2/sdl2.html#fabs,cdouble sdl2: fabs(x: cdouble): cdouble +fabsf sdl2/sdl2.html#fabsf,cfloat sdl2: fabsf(x: cfloat): cfloat +floor sdl2/sdl2.html#floor,cdouble sdl2: floor(x: cdouble): cdouble +floorf sdl2/sdl2.html#floorf,cfloat sdl2: floorf(x: cfloat): cfloat +fmod sdl2/sdl2.html#fmod,cdouble,cdouble sdl2: fmod(x: cdouble; y: cdouble): cdouble +fmodf sdl2/sdl2.html#fmodf,cfloat,cfloat sdl2: fmodf(x: cfloat; y: cfloat): cfloat +log sdl2/sdl2.html#log,cdouble sdl2: log(x: cdouble): cdouble +logf sdl2/sdl2.html#logf,cfloat sdl2: logf(x: cfloat): cfloat +log10 sdl2/sdl2.html#log10,cdouble sdl2: log10(x: cdouble): cdouble +log10f sdl2/sdl2.html#log10f,cfloat sdl2: log10f(x: cfloat): cfloat +pow sdl2/sdl2.html#pow,cdouble,cdouble sdl2: pow(x: cdouble; y: cdouble): cdouble +powf sdl2/sdl2.html#powf,cfloat,cfloat sdl2: powf(x: cfloat; y: cfloat): cfloat +scalbn sdl2/sdl2.html#scalbn,cdouble,cint sdl2: scalbn(x: cdouble; n: cint): cdouble +scalbnf sdl2/sdl2.html#scalbnf,cfloat,cint sdl2: scalbnf(x: cfloat; n: cint): cfloat +sin sdl2/sdl2.html#sin,cdouble sdl2: sin(x: cdouble): cdouble +sinf sdl2/sdl2.html#sinf,cfloat sdl2: sinf(x: cfloat): cfloat +sqrt sdl2/sdl2.html#sqrt,cdouble sdl2: sqrt(x: cdouble): cdouble +sqrtf sdl2/sdl2.html#sqrtf,cfloat sdl2: sqrtf(x: cfloat): cfloat +tan sdl2/sdl2.html#tan,cdouble sdl2: tan(x: cdouble): cdouble +tanf sdl2/sdl2.html#tanf,cfloat sdl2: tanf(x: cfloat): cfloat +iconv_open sdl2/sdl2.html#iconv_open,cstring,cstring sdl2: iconv_open(tocode: cstring; fromcode: cstring): iconv_t +iconv_close sdl2/sdl2.html#iconv_close,iconv_t sdl2: iconv_close(cd: iconv_t): cint +iconv sdl2/sdl2.html#iconv,iconv_t,ptr.cstring,ptr.uint,ptr.cstring,ptr.uint sdl2: iconv(cd: iconv_t; inbuf: ptr cstring; inbytesleft: ptr uint; outbuf: ptr cstring;\n outbytesleft: ptr uint): uint +iconv_string sdl2/sdl2.html#iconv_string,cstring,cstring,cstring,uint sdl2: iconv_string(tocode: cstring; fromcode: cstring; inbuf: cstring; inbytesleft: uint): cstring +main sdl2/sdl2.html#main,cint,UncheckedArray[cstring] sdl2: main(argc: cint; argv: UncheckedArray[cstring]): cint +setMainReady sdl2/sdl2.html#setMainReady sdl2: setMainReady() +reportAssertion sdl2/sdl2.html#reportAssertion,ptr.AssertData,cstring,cstring,cint sdl2: reportAssertion(a1: ptr AssertData; a2: cstring; a3: cstring; a4: cint): AssertState +setAssertionHandler sdl2/sdl2.html#setAssertionHandler,AssertionHandler,pointer sdl2: setAssertionHandler(handler: AssertionHandler; userdata: pointer) +getDefaultAssertionHandler sdl2/sdl2.html#getDefaultAssertionHandler sdl2: getDefaultAssertionHandler(): AssertionHandler +getAssertionHandler sdl2/sdl2.html#getAssertionHandler,ptr.pointer sdl2: getAssertionHandler(puserdata: ptr pointer): AssertionHandler +getAssertionReport sdl2/sdl2.html#getAssertionReport sdl2: getAssertionReport(): ptr AssertData +resetAssertionReport sdl2/sdl2.html#resetAssertionReport sdl2: resetAssertionReport() +atomicTryLock sdl2/sdl2.html#atomicTryLock,ptr.SpinLock sdl2: atomicTryLock(lock: ptr SpinLock): bool +atomicLock sdl2/sdl2.html#atomicLock,ptr.SpinLock sdl2: atomicLock(lock: ptr SpinLock) +atomicUnlock sdl2/sdl2.html#atomicUnlock,ptr.SpinLock sdl2: atomicUnlock(lock: ptr SpinLock) +memoryBarrierReleaseFunction sdl2/sdl2.html#memoryBarrierReleaseFunction sdl2: memoryBarrierReleaseFunction() +memoryBarrierAcquireFunction sdl2/sdl2.html#memoryBarrierAcquireFunction sdl2: memoryBarrierAcquireFunction() +atomicCAS sdl2/sdl2.html#atomicCAS,ptr.atomic_t,cint,cint sdl2: atomicCAS(a: ptr atomic_t; oldval: cint; newval: cint): bool +atomicSet sdl2/sdl2.html#atomicSet,ptr.atomic_t,cint sdl2: atomicSet(a: ptr atomic_t; v: cint): cint +atomicGet sdl2/sdl2.html#atomicGet,ptr.atomic_t sdl2: atomicGet(a: ptr atomic_t): cint +atomicAdd sdl2/sdl2.html#atomicAdd,ptr.atomic_t,cint sdl2: atomicAdd(a: ptr atomic_t; v: cint): cint +atomicCASPtr sdl2/sdl2.html#atomicCASPtr,ptr.pointer,pointer,pointer sdl2: atomicCASPtr(a: ptr pointer; oldval: pointer; newval: pointer): bool +atomicSetPtr sdl2/sdl2.html#atomicSetPtr,ptr.pointer,pointer sdl2: atomicSetPtr(a: ptr pointer; v: pointer): pointer +atomicGetPtr sdl2/sdl2.html#atomicGetPtr,ptr.pointer sdl2: atomicGetPtr(a: ptr pointer): pointer +setError sdl2/sdl2.html#setError,cstring sdl2: setError(fmt: cstring): cint +getError sdl2/sdl2.html#getError sdl2: getError(): cstring +clearError sdl2/sdl2.html#clearError sdl2: clearError() +error sdl2/sdl2.html#error,errorcode sdl2: error(code: errorcode): cint +createMutex sdl2/sdl2.html#createMutex sdl2: createMutex(): ptr mutex +lockMutex sdl2/sdl2.html#lockMutex,ptr.mutex sdl2: lockMutex(mutex: ptr mutex): cint +tryLockMutex sdl2/sdl2.html#tryLockMutex,ptr.mutex sdl2: tryLockMutex(mutex: ptr mutex): cint +unlockMutex sdl2/sdl2.html#unlockMutex,ptr.mutex sdl2: unlockMutex(mutex: ptr mutex): cint +destroyMutex sdl2/sdl2.html#destroyMutex,ptr.mutex sdl2: destroyMutex(mutex: ptr mutex) +createSemaphore sdl2/sdl2.html#createSemaphore,Uint32 sdl2: createSemaphore(initialValue: Uint32): ptr sem +destroySemaphore sdl2/sdl2.html#destroySemaphore,ptr.semaphore sdl2: destroySemaphore(sem: ptr sem) +semWait sdl2/sdl2.html#semWait,ptr.semaphore sdl2: semWait(sem: ptr sem): cint +semTryWait sdl2/sdl2.html#semTryWait,ptr.semaphore sdl2: semTryWait(sem: ptr sem): cint +semWaitTimeout sdl2/sdl2.html#semWaitTimeout,ptr.semaphore,Uint32 sdl2: semWaitTimeout(sem: ptr sem; ms: Uint32): cint +semPost sdl2/sdl2.html#semPost,ptr.semaphore sdl2: semPost(sem: ptr sem): cint +semValue sdl2/sdl2.html#semValue,ptr.semaphore sdl2: semValue(sem: ptr sem): Uint32 +createCond sdl2/sdl2.html#createCond sdl2: createCond(): ptr cond +destroyCond sdl2/sdl2.html#destroyCond,ptr.cond sdl2: destroyCond(cond: ptr cond) +condSignal sdl2/sdl2.html#condSignal,ptr.cond sdl2: condSignal(cond: ptr cond): cint +condBroadcast sdl2/sdl2.html#condBroadcast,ptr.cond sdl2: condBroadcast(cond: ptr cond): cint +condWait sdl2/sdl2.html#condWait,ptr.cond,ptr.mutex sdl2: condWait(cond: ptr cond; mutex: ptr mutex): cint +condWaitTimeout sdl2/sdl2.html#condWaitTimeout,ptr.cond,ptr.mutex,Uint32 sdl2: condWaitTimeout(cond: ptr cond; mutex: ptr mutex; ms: Uint32): cint +createThread sdl2/sdl2.html#createThread,ThreadFunction,cstring,pointer sdl2: createThread(fn: ThreadFunction; name: cstring; data: pointer): ptr Thread +createThreadWithStackSize sdl2/sdl2.html#createThreadWithStackSize,ThreadFunction,cstring,uint,pointer sdl2: createThreadWithStackSize(fn: ThreadFunction; name: cstring; stacksize: uint;\n data: pointer): ptr Thread +getThreadName sdl2/sdl2.html#getThreadName,ptr.Thread sdl2: getThreadName(thread: ptr Thread): cstring +getThreadID sdl2/sdl2.html#getThreadID,ptr.Thread sdl2: getThreadID(thread: ptr Thread): threadID +setThreadPriority sdl2/sdl2.html#setThreadPriority,ThreadPriority sdl2: setThreadPriority(priority: ThreadPriority): cint +waitThread sdl2/sdl2.html#waitThread,ptr.Thread,ptr.cint sdl2: waitThread(thread: ptr Thread; status: ptr cint) +detachThread sdl2/sdl2.html#detachThread,ptr.Thread sdl2: detachThread(thread: ptr Thread) +tLSCreate sdl2/sdl2.html#tLSCreate sdl2: tLSCreate(): TLSID +tLSGet sdl2/sdl2.html#tLSGet,TLSID sdl2: tLSGet(id: TLSID): pointer +tLSSet sdl2/sdl2.html#tLSSet,TLSID,pointer,proc(pointer) sdl2: tLSSet(id: TLSID; value: pointer; destructor: proc (a1: pointer) {.cdecl.}): cint +rWFromFile sdl2/sdl2.html#rWFromFile,cstring,cstring sdl2: rWFromFile(file: cstring; mode: cstring): ptr RWops +rWFromFP sdl2/sdl2.html#rWFromFP,File,bool sdl2: rWFromFP(fp: File; autoclose: bool): ptr RWops +rWFromMem sdl2/sdl2.html#rWFromMem,pointer,cint sdl2: rWFromMem(mem: pointer; size: cint): ptr RWops +rWFromConstMem sdl2/sdl2.html#rWFromConstMem,pointer,cint sdl2: rWFromConstMem(mem: pointer; size: cint): ptr RWops +allocRW sdl2/sdl2.html#allocRW sdl2: allocRW(): ptr RWops +freeRW sdl2/sdl2.html#freeRW,ptr.RWops sdl2: freeRW(area: ptr RWops) +rWsize sdl2/sdl2.html#rWsize,ptr.RWops sdl2: rWsize(context: ptr RWops): Sint64 +rWseek sdl2/sdl2.html#rWseek,ptr.RWops,Sint64,cint sdl2: rWseek(context: ptr RWops; offset: Sint64; whence: cint): Sint64 +rWtell sdl2/sdl2.html#rWtell,ptr.RWops sdl2: rWtell(context: ptr RWops): Sint64 +rWread sdl2/sdl2.html#rWread,ptr.RWops,pointer,uint,uint sdl2: rWread(context: ptr RWops; `ptr`: pointer; size: uint; maxnum: uint): uint +rWwrite sdl2/sdl2.html#rWwrite,ptr.RWops,pointer,uint,uint sdl2: rWwrite(context: ptr RWops; `ptr`: pointer; size: uint; num: uint): uint +rWclose sdl2/sdl2.html#rWclose,ptr.RWops sdl2: rWclose(context: ptr RWops): cint +loadFile_RW sdl2/sdl2.html#loadFile_RW,ptr.RWops,ptr.uint,cint sdl2: loadFile_RW(src: ptr RWops; datasize: ptr uint; freesrc: cint): pointer +loadFile sdl2/sdl2.html#loadFile,cstring,ptr.uint sdl2: loadFile(file: cstring; datasize: ptr uint): pointer +readU8 sdl2/sdl2.html#readU8,ptr.RWops sdl2: readU8(src: ptr RWops): Uint8 +readLE16 sdl2/sdl2.html#readLE16,ptr.RWops sdl2: readLE16(src: ptr RWops): Uint16 +readBE16 sdl2/sdl2.html#readBE16,ptr.RWops sdl2: readBE16(src: ptr RWops): Uint16 +readLE32 sdl2/sdl2.html#readLE32,ptr.RWops sdl2: readLE32(src: ptr RWops): Uint32 +readBE32 sdl2/sdl2.html#readBE32,ptr.RWops sdl2: readBE32(src: ptr RWops): Uint32 +readLE64 sdl2/sdl2.html#readLE64,ptr.RWops sdl2: readLE64(src: ptr RWops): Uint64 +readBE64 sdl2/sdl2.html#readBE64,ptr.RWops sdl2: readBE64(src: ptr RWops): Uint64 +writeU8 sdl2/sdl2.html#writeU8,ptr.RWops,Uint8 sdl2: writeU8(dst: ptr RWops; value: Uint8): uint +writeLE16 sdl2/sdl2.html#writeLE16,ptr.RWops,Uint16 sdl2: writeLE16(dst: ptr RWops; value: Uint16): uint +writeBE16 sdl2/sdl2.html#writeBE16,ptr.RWops,Uint16 sdl2: writeBE16(dst: ptr RWops; value: Uint16): uint +writeLE32 sdl2/sdl2.html#writeLE32,ptr.RWops,Uint32 sdl2: writeLE32(dst: ptr RWops; value: Uint32): uint +writeBE32 sdl2/sdl2.html#writeBE32,ptr.RWops,Uint32 sdl2: writeBE32(dst: ptr RWops; value: Uint32): uint +writeLE64 sdl2/sdl2.html#writeLE64,ptr.RWops,Uint64 sdl2: writeLE64(dst: ptr RWops; value: Uint64): uint +writeBE64 sdl2/sdl2.html#writeBE64,ptr.RWops,Uint64 sdl2: writeBE64(dst: ptr RWops; value: Uint64): uint +getNumAudioDrivers sdl2/sdl2.html#getNumAudioDrivers sdl2: getNumAudioDrivers(): cint +getAudioDriver sdl2/sdl2.html#getAudioDriver,cint sdl2: getAudioDriver(index: cint): cstring +audioInit sdl2/sdl2.html#audioInit,cstring sdl2: audioInit(driverName: cstring): cint +audioQuit sdl2/sdl2.html#audioQuit sdl2: audioQuit() +getCurrentAudioDriver sdl2/sdl2.html#getCurrentAudioDriver sdl2: getCurrentAudioDriver(): cstring +openAudio sdl2/sdl2.html#openAudio,ptr.AudioSpec,ptr.AudioSpec sdl2: openAudio(desired: ptr AudioSpec; obtained: ptr AudioSpec): cint +getNumAudioDevices sdl2/sdl2.html#getNumAudioDevices,cint sdl2: getNumAudioDevices(iscapture: cint): cint +getAudioDeviceName sdl2/sdl2.html#getAudioDeviceName,cint,cint sdl2: getAudioDeviceName(index: cint; iscapture: cint): cstring +openAudioDevice sdl2/sdl2.html#openAudioDevice,cstring,cint,ptr.AudioSpec,ptr.AudioSpec,cint sdl2: openAudioDevice(device: cstring; iscapture: cint; desired: ptr AudioSpec;\n obtained: ptr AudioSpec; allowedChanges: cint): AudioDeviceID +getAudioStatus sdl2/sdl2.html#getAudioStatus sdl2: getAudioStatus(): AudioStatus +getAudioDeviceStatus sdl2/sdl2.html#getAudioDeviceStatus,AudioDeviceID sdl2: getAudioDeviceStatus(dev: AudioDeviceID): AudioStatus +pauseAudio sdl2/sdl2.html#pauseAudio,cint sdl2: pauseAudio(pauseOn: cint) +pauseAudioDevice sdl2/sdl2.html#pauseAudioDevice,AudioDeviceID,cint sdl2: pauseAudioDevice(dev: AudioDeviceID; pauseOn: cint) +loadWAV_RW sdl2/sdl2.html#loadWAV_RW,ptr.RWops,cint,ptr.AudioSpec,ptr.ptr.Uint8,ptr.Uint32 sdl2: loadWAV_RW(src: ptr RWops; freesrc: cint; spec: ptr AudioSpec; audioBuf: ptr ptr Uint8;\n audioLen: ptr Uint32): ptr AudioSpec +freeWAV sdl2/sdl2.html#freeWAV,ptr.Uint8 sdl2: freeWAV(audioBuf: ptr Uint8) +buildAudioCVT sdl2/sdl2.html#buildAudioCVT,ptr.AudioCVT,AudioFormat,Uint8,cint,AudioFormat,Uint8,cint sdl2: buildAudioCVT(cvt: ptr AudioCVT; srcFormat: AudioFormat; srcChannels: Uint8;\n srcRate: cint; dstFormat: AudioFormat; dstChannels: Uint8; dstRate: cint): cint +convertAudio sdl2/sdl2.html#convertAudio,ptr.AudioCVT sdl2: convertAudio(cvt: ptr AudioCVT): cint +newAudioStream sdl2/sdl2.html#newAudioStream,AudioFormat,Uint8,cint,AudioFormat,Uint8,cint sdl2: newAudioStream(srcFormat: AudioFormat; srcChannels: Uint8; srcRate: cint;\n dstFormat: AudioFormat; dstChannels: Uint8; dstRate: cint): ptr AudioStream +audioStreamPut sdl2/sdl2.html#audioStreamPut,ptr.AudioStream,pointer,cint sdl2: audioStreamPut(stream: ptr AudioStream; buf: pointer; len: cint): cint +audioStreamGet sdl2/sdl2.html#audioStreamGet,ptr.AudioStream,pointer,cint sdl2: audioStreamGet(stream: ptr AudioStream; buf: pointer; len: cint): cint +audioStreamAvailable sdl2/sdl2.html#audioStreamAvailable,ptr.AudioStream sdl2: audioStreamAvailable(stream: ptr AudioStream): cint +audioStreamFlush sdl2/sdl2.html#audioStreamFlush,ptr.AudioStream sdl2: audioStreamFlush(stream: ptr AudioStream): cint +audioStreamClear sdl2/sdl2.html#audioStreamClear,ptr.AudioStream sdl2: audioStreamClear(stream: ptr AudioStream) +freeAudioStream sdl2/sdl2.html#freeAudioStream,ptr.AudioStream sdl2: freeAudioStream(stream: ptr AudioStream) +mixAudio sdl2/sdl2.html#mixAudio,ptr.Uint8,ptr.Uint8,Uint32,cint sdl2: mixAudio(dst: ptr Uint8; src: ptr Uint8; len: Uint32; volume: cint) +mixAudioFormat sdl2/sdl2.html#mixAudioFormat,ptr.Uint8,ptr.Uint8,AudioFormat,Uint32,cint sdl2: mixAudioFormat(dst: ptr Uint8; src: ptr Uint8; format: AudioFormat; len: Uint32;\n volume: cint) +queueAudio sdl2/sdl2.html#queueAudio,AudioDeviceID,pointer,Uint32 sdl2: queueAudio(dev: AudioDeviceID; data: pointer; len: Uint32): cint +dequeueAudio sdl2/sdl2.html#dequeueAudio,AudioDeviceID,pointer,Uint32 sdl2: dequeueAudio(dev: AudioDeviceID; data: pointer; len: Uint32): Uint32 +getQueuedAudioSize sdl2/sdl2.html#getQueuedAudioSize,AudioDeviceID sdl2: getQueuedAudioSize(dev: AudioDeviceID): Uint32 +clearQueuedAudio sdl2/sdl2.html#clearQueuedAudio,AudioDeviceID sdl2: clearQueuedAudio(dev: AudioDeviceID) +lockAudio sdl2/sdl2.html#lockAudio sdl2: lockAudio() +lockAudioDevice sdl2/sdl2.html#lockAudioDevice,AudioDeviceID sdl2: lockAudioDevice(dev: AudioDeviceID) +unlockAudio sdl2/sdl2.html#unlockAudio sdl2: unlockAudio() +unlockAudioDevice sdl2/sdl2.html#unlockAudioDevice,AudioDeviceID sdl2: unlockAudioDevice(dev: AudioDeviceID) +closeAudio sdl2/sdl2.html#closeAudio sdl2: closeAudio() +closeAudioDevice sdl2/sdl2.html#closeAudioDevice,AudioDeviceID sdl2: closeAudioDevice(dev: AudioDeviceID) +setClipboardText sdl2/sdl2.html#setClipboardText,cstring sdl2: setClipboardText(text: cstring): cint +getClipboardText sdl2/sdl2.html#getClipboardText sdl2: getClipboardText(): cstring +hasClipboardText sdl2/sdl2.html#hasClipboardText sdl2: hasClipboardText(): bool +getCPUCount sdl2/sdl2.html#getCPUCount sdl2: getCPUCount(): cint +getCPUCacheLineSize sdl2/sdl2.html#getCPUCacheLineSize sdl2: getCPUCacheLineSize(): cint +hasRDTSC sdl2/sdl2.html#hasRDTSC sdl2: hasRDTSC(): bool +hasAltiVec sdl2/sdl2.html#hasAltiVec sdl2: hasAltiVec(): bool +hasMMX sdl2/sdl2.html#hasMMX sdl2: hasMMX(): bool +has3DNow sdl2/sdl2.html#has3DNow sdl2: has3DNow(): bool +hasSSE sdl2/sdl2.html#hasSSE sdl2: hasSSE(): bool +hasSSE2 sdl2/sdl2.html#hasSSE2 sdl2: hasSSE2(): bool +hasSSE3 sdl2/sdl2.html#hasSSE3 sdl2: hasSSE3(): bool +hasSSE41 sdl2/sdl2.html#hasSSE41 sdl2: hasSSE41(): bool +hasSSE42 sdl2/sdl2.html#hasSSE42 sdl2: hasSSE42(): bool +hasAVX sdl2/sdl2.html#hasAVX sdl2: hasAVX(): bool +hasAVX2 sdl2/sdl2.html#hasAVX2 sdl2: hasAVX2(): bool +hasAVX512F sdl2/sdl2.html#hasAVX512F sdl2: hasAVX512F(): bool +hasARMSIMD sdl2/sdl2.html#hasARMSIMD sdl2: hasARMSIMD(): bool +hasNEON sdl2/sdl2.html#hasNEON sdl2: hasNEON(): bool +getSystemRAM sdl2/sdl2.html#getSystemRAM sdl2: getSystemRAM(): cint +sIMDGetAlignment sdl2/sdl2.html#sIMDGetAlignment sdl2: sIMDGetAlignment(): uint +sIMDAlloc sdl2/sdl2.html#sIMDAlloc,uint sdl2: sIMDAlloc(len: uint): pointer +sIMDFree sdl2/sdl2.html#sIMDFree,pointer sdl2: sIMDFree(`ptr`: pointer) +getPixelFormatName sdl2/sdl2.html#getPixelFormatName,Uint32 sdl2: getPixelFormatName(format: Uint32): cstring +pixelFormatEnumToMasks sdl2/sdl2.html#pixelFormatEnumToMasks,Uint32,ptr.cint,ptr.Uint32,ptr.Uint32,ptr.Uint32,ptr.Uint32 sdl2: pixelFormatEnumToMasks(format: Uint32; bpp: ptr cint; Rmask: ptr Uint32;\n Gmask: ptr Uint32; Bmask: ptr Uint32; Amask: ptr Uint32): bool +masksToPixelFormatEnum sdl2/sdl2.html#masksToPixelFormatEnum,cint,Uint32,Uint32,Uint32,Uint32 sdl2: masksToPixelFormatEnum(bpp: cint; Rmask: Uint32; Gmask: Uint32; Bmask: Uint32;\n Amask: Uint32): Uint32 +allocFormat sdl2/sdl2.html#allocFormat,Uint32 sdl2: allocFormat(pixelFormat: Uint32): ptr PixelFormat +freeFormat sdl2/sdl2.html#freeFormat,ptr.PixelFormat sdl2: freeFormat(format: ptr PixelFormat) +allocPalette sdl2/sdl2.html#allocPalette,cint sdl2: allocPalette(ncolors: cint): ptr Palette +setPixelFormatPalette sdl2/sdl2.html#setPixelFormatPalette,ptr.PixelFormat,ptr.Palette sdl2: setPixelFormatPalette(format: ptr PixelFormat; palette: ptr Palette): cint +setPaletteColors sdl2/sdl2.html#setPaletteColors,ptr.Palette,ptr.Color,cint,cint sdl2: setPaletteColors(palette: ptr Palette; colors: ptr Color; firstcolor: cint;\n ncolors: cint): cint +freePalette sdl2/sdl2.html#freePalette,ptr.Palette sdl2: freePalette(palette: ptr Palette) +mapRGB sdl2/sdl2.html#mapRGB,ptr.PixelFormat,Uint8,Uint8,Uint8 sdl2: mapRGB(format: ptr PixelFormat; r: Uint8; g: Uint8; b: Uint8): Uint32 +mapRGBA sdl2/sdl2.html#mapRGBA,ptr.PixelFormat,Uint8,Uint8,Uint8,Uint8 sdl2: mapRGBA(format: ptr PixelFormat; r: Uint8; g: Uint8; b: Uint8; a: Uint8): Uint32 +getRGB sdl2/sdl2.html#getRGB,Uint32,ptr.PixelFormat,ptr.Uint8,ptr.Uint8,ptr.Uint8 sdl2: getRGB(pixel: Uint32; format: ptr PixelFormat; r: ptr Uint8; g: ptr Uint8; b: ptr Uint8) +getRGBA sdl2/sdl2.html#getRGBA,Uint32,ptr.PixelFormat,ptr.Uint8,ptr.Uint8,ptr.Uint8,ptr.Uint8 sdl2: getRGBA(pixel: Uint32; format: ptr PixelFormat; r: ptr Uint8; g: ptr Uint8; b: ptr Uint8;\n a: ptr Uint8) +calculateGammaRamp sdl2/sdl2.html#calculateGammaRamp,cfloat,ptr.Uint16 sdl2: calculateGammaRamp(gamma: cfloat; ramp: ptr Uint16) +hasIntersection sdl2/sdl2.html#hasIntersection,ptr.Rect,ptr.Rect sdl2: hasIntersection(A: ptr Rect; B: ptr Rect): bool +intersectRect sdl2/sdl2.html#intersectRect,ptr.Rect,ptr.Rect,ptr.Rect sdl2: intersectRect(A: ptr Rect; B: ptr Rect; result: ptr Rect): bool +unionRect sdl2/sdl2.html#unionRect,ptr.Rect,ptr.Rect,ptr.Rect sdl2: unionRect(A: ptr Rect; B: ptr Rect; result: ptr Rect) +enclosePoints sdl2/sdl2.html#enclosePoints,ptr.Point,cint,ptr.Rect,ptr.Rect sdl2: enclosePoints(points: ptr Point; count: cint; clip: ptr Rect; result: ptr Rect): bool +intersectRectAndLine sdl2/sdl2.html#intersectRectAndLine,ptr.Rect,ptr.cint,ptr.cint,ptr.cint,ptr.cint sdl2: intersectRectAndLine(rect: ptr Rect; X1: ptr cint; Y1: ptr cint; X2: ptr cint; Y2: ptr cint): bool +composeCustomBlendMode sdl2/sdl2.html#composeCustomBlendMode,BlendFactor,BlendFactor,BlendOperation,BlendFactor,BlendFactor,BlendOperation sdl2: composeCustomBlendMode(srcColorFactor: BlendFactor; dstColorFactor: BlendFactor;\n colorOperation: BlendOperation;\n srcAlphaFactor: BlendFactor; dstAlphaFactor: BlendFactor;\n alphaOperation: BlendOperation): BlendMode +createRGBSurface sdl2/sdl2.html#createRGBSurface,Uint32,cint,cint,cint,Uint32,Uint32,Uint32,Uint32 sdl2: createRGBSurface(flags: Uint32; width: cint; height: cint; depth: cint; Rmask: Uint32;\n Gmask: Uint32; Bmask: Uint32; Amask: Uint32): ptr Surface +createRGBSurfaceWithFormat sdl2/sdl2.html#createRGBSurfaceWithFormat,Uint32,cint,cint,cint,Uint32 sdl2: createRGBSurfaceWithFormat(flags: Uint32; width: cint; height: cint; depth: cint;\n format: Uint32): ptr Surface +createRGBSurfaceFrom sdl2/sdl2.html#createRGBSurfaceFrom,pointer,cint,cint,cint,cint,Uint32,Uint32,Uint32,Uint32 sdl2: createRGBSurfaceFrom(pixels: pointer; width: cint; height: cint; depth: cint;\n pitch: cint; Rmask: Uint32; Gmask: Uint32; Bmask: Uint32;\n Amask: Uint32): ptr Surface +createRGBSurfaceWithFormatFrom sdl2/sdl2.html#createRGBSurfaceWithFormatFrom,pointer,cint,cint,cint,cint,Uint32 sdl2: createRGBSurfaceWithFormatFrom(pixels: pointer; width: cint; height: cint;\n depth: cint; pitch: cint; format: Uint32): ptr Surface +freeSurface sdl2/sdl2.html#freeSurface,ptr.Surface sdl2: freeSurface(surface: ptr Surface) +setSurfacePalette sdl2/sdl2.html#setSurfacePalette,ptr.Surface,ptr.Palette sdl2: setSurfacePalette(surface: ptr Surface; palette: ptr Palette): cint +lockSurface sdl2/sdl2.html#lockSurface,ptr.Surface sdl2: lockSurface(surface: ptr Surface): cint +unlockSurface sdl2/sdl2.html#unlockSurface,ptr.Surface sdl2: unlockSurface(surface: ptr Surface) +loadBMP_RW sdl2/sdl2.html#loadBMP_RW,ptr.RWops,cint sdl2: loadBMP_RW(src: ptr RWops; freesrc: cint): ptr Surface +saveBMP_RW sdl2/sdl2.html#saveBMP_RW,ptr.Surface,ptr.RWops,cint sdl2: saveBMP_RW(surface: ptr Surface; dst: ptr RWops; freedst: cint): cint +setSurfaceRLE sdl2/sdl2.html#setSurfaceRLE,ptr.Surface,cint sdl2: setSurfaceRLE(surface: ptr Surface; flag: cint): cint +setColorKey sdl2/sdl2.html#setColorKey,ptr.Surface,cint,Uint32 sdl2: setColorKey(surface: ptr Surface; flag: cint; key: Uint32): cint +hasColorKey sdl2/sdl2.html#hasColorKey,ptr.Surface sdl2: hasColorKey(surface: ptr Surface): bool +getColorKey sdl2/sdl2.html#getColorKey,ptr.Surface,ptr.Uint32 sdl2: getColorKey(surface: ptr Surface; key: ptr Uint32): cint +setSurfaceColorMod sdl2/sdl2.html#setSurfaceColorMod,ptr.Surface,Uint8,Uint8,Uint8 sdl2: setSurfaceColorMod(surface: ptr Surface; r: Uint8; g: Uint8; b: Uint8): cint +getSurfaceColorMod sdl2/sdl2.html#getSurfaceColorMod,ptr.Surface,ptr.Uint8,ptr.Uint8,ptr.Uint8 sdl2: getSurfaceColorMod(surface: ptr Surface; r: ptr Uint8; g: ptr Uint8; b: ptr Uint8): cint +setSurfaceAlphaMod sdl2/sdl2.html#setSurfaceAlphaMod,ptr.Surface,Uint8 sdl2: setSurfaceAlphaMod(surface: ptr Surface; alpha: Uint8): cint +getSurfaceAlphaMod sdl2/sdl2.html#getSurfaceAlphaMod,ptr.Surface,ptr.Uint8 sdl2: getSurfaceAlphaMod(surface: ptr Surface; alpha: ptr Uint8): cint +setSurfaceBlendMode sdl2/sdl2.html#setSurfaceBlendMode,ptr.Surface,BlendMode sdl2: setSurfaceBlendMode(surface: ptr Surface; blendMode: BlendMode): cint +getSurfaceBlendMode sdl2/sdl2.html#getSurfaceBlendMode,ptr.Surface,ptr.BlendMode sdl2: getSurfaceBlendMode(surface: ptr Surface; blendMode: ptr BlendMode): cint +setClipRect sdl2/sdl2.html#setClipRect,ptr.Surface,ptr.Rect sdl2: setClipRect(surface: ptr Surface; rect: ptr Rect): bool +getClipRect sdl2/sdl2.html#getClipRect,ptr.Surface,ptr.Rect sdl2: getClipRect(surface: ptr Surface; rect: ptr Rect) +duplicateSurface sdl2/sdl2.html#duplicateSurface,ptr.Surface sdl2: duplicateSurface(surface: ptr Surface): ptr Surface +convertSurface sdl2/sdl2.html#convertSurface,ptr.Surface,ptr.PixelFormat,Uint32 sdl2: convertSurface(src: ptr Surface; fmt: ptr PixelFormat; flags: Uint32): ptr Surface +convertSurfaceFormat sdl2/sdl2.html#convertSurfaceFormat,ptr.Surface,Uint32,Uint32 sdl2: convertSurfaceFormat(src: ptr Surface; pixelFormat: Uint32; flags: Uint32): ptr Surface +convertPixels sdl2/sdl2.html#convertPixels,cint,cint,Uint32,pointer,cint,Uint32,pointer,cint sdl2: convertPixels(width: cint; height: cint; srcFormat: Uint32; src: pointer;\n srcPitch: cint; dstFormat: Uint32; dst: pointer; dstPitch: cint): cint +fillRect sdl2/sdl2.html#fillRect,ptr.Surface,ptr.Rect,Uint32 sdl2: fillRect(dst: ptr Surface; rect: ptr Rect; color: Uint32): cint +fillRects sdl2/sdl2.html#fillRects,ptr.Surface,ptr.Rect,cint,Uint32 sdl2: fillRects(dst: ptr Surface; rects: ptr Rect; count: cint; color: Uint32): cint +upperBlit sdl2/sdl2.html#upperBlit,ptr.Surface,ptr.Rect,ptr.Surface,ptr.Rect sdl2: upperBlit(src: ptr Surface; srcrect: ptr Rect; dst: ptr Surface; dstrect: ptr Rect): cint +lowerBlit sdl2/sdl2.html#lowerBlit,ptr.Surface,ptr.Rect,ptr.Surface,ptr.Rect sdl2: lowerBlit(src: ptr Surface; srcrect: ptr Rect; dst: ptr Surface; dstrect: ptr Rect): cint +softStretch sdl2/sdl2.html#softStretch,ptr.Surface,ptr.Rect,ptr.Surface,ptr.Rect sdl2: softStretch(src: ptr Surface; srcrect: ptr Rect; dst: ptr Surface; dstrect: ptr Rect): cint +upperBlitScaled sdl2/sdl2.html#upperBlitScaled,ptr.Surface,ptr.Rect,ptr.Surface,ptr.Rect sdl2: upperBlitScaled(src: ptr Surface; srcrect: ptr Rect; dst: ptr Surface; dstrect: ptr Rect): cint +lowerBlitScaled sdl2/sdl2.html#lowerBlitScaled,ptr.Surface,ptr.Rect,ptr.Surface,ptr.Rect sdl2: lowerBlitScaled(src: ptr Surface; srcrect: ptr Rect; dst: ptr Surface; dstrect: ptr Rect): cint +setYUVConversionMode sdl2/sdl2.html#setYUVConversionMode,YUV_CONVERSION_MODE sdl2: setYUVConversionMode(mode: YUV_CONVERSION_MODE) +getYUVConversionMode sdl2/sdl2.html#getYUVConversionMode sdl2: getYUVConversionMode(): YUV_CONVERSION_MODE +getYUVConversionModeForResolution sdl2/sdl2.html#getYUVConversionModeForResolution,cint,cint sdl2: getYUVConversionModeForResolution(width: cint; height: cint): YUV_CONVERSION_MODE +getNumVideoDrivers sdl2/sdl2.html#getNumVideoDrivers sdl2: getNumVideoDrivers(): cint +getVideoDriver sdl2/sdl2.html#getVideoDriver,cint sdl2: getVideoDriver(index: cint): cstring +videoInit sdl2/sdl2.html#videoInit,cstring sdl2: videoInit(driverName: cstring): cint +videoQuit sdl2/sdl2.html#videoQuit sdl2: videoQuit() +getCurrentVideoDriver sdl2/sdl2.html#getCurrentVideoDriver sdl2: getCurrentVideoDriver(): cstring +getNumVideoDisplays sdl2/sdl2.html#getNumVideoDisplays sdl2: getNumVideoDisplays(): cint +getDisplayName sdl2/sdl2.html#getDisplayName,cint sdl2: getDisplayName(displayIndex: cint): cstring +getDisplayBounds sdl2/sdl2.html#getDisplayBounds,cint,ptr.Rect sdl2: getDisplayBounds(displayIndex: cint; rect: ptr Rect): cint +getDisplayUsableBounds sdl2/sdl2.html#getDisplayUsableBounds,cint,ptr.Rect sdl2: getDisplayUsableBounds(displayIndex: cint; rect: ptr Rect): cint +getDisplayDPI sdl2/sdl2.html#getDisplayDPI,cint,ptr.cfloat,ptr.cfloat,ptr.cfloat sdl2: getDisplayDPI(displayIndex: cint; ddpi: ptr cfloat; hdpi: ptr cfloat; vdpi: ptr cfloat): cint +getDisplayOrientation sdl2/sdl2.html#getDisplayOrientation,cint sdl2: getDisplayOrientation(displayIndex: cint): DisplayOrientation +getNumDisplayModes sdl2/sdl2.html#getNumDisplayModes,cint sdl2: getNumDisplayModes(displayIndex: cint): cint +getDisplayMode sdl2/sdl2.html#getDisplayMode,cint,cint,ptr.DisplayMode sdl2: getDisplayMode(displayIndex: cint; modeIndex: cint; mode: ptr DisplayMode): cint +getDesktopDisplayMode sdl2/sdl2.html#getDesktopDisplayMode,cint,ptr.DisplayMode sdl2: getDesktopDisplayMode(displayIndex: cint; mode: ptr DisplayMode): cint +getCurrentDisplayMode sdl2/sdl2.html#getCurrentDisplayMode,cint,ptr.DisplayMode sdl2: getCurrentDisplayMode(displayIndex: cint; mode: ptr DisplayMode): cint +getClosestDisplayMode sdl2/sdl2.html#getClosestDisplayMode,cint,ptr.DisplayMode,ptr.DisplayMode sdl2: getClosestDisplayMode(displayIndex: cint; mode: ptr DisplayMode;\n closest: ptr DisplayMode): ptr DisplayMode +getWindowDisplayIndex sdl2/sdl2.html#getWindowDisplayIndex,ptr.Window sdl2: getWindowDisplayIndex(window: ptr Window): cint +setWindowDisplayMode sdl2/sdl2.html#setWindowDisplayMode,ptr.Window,ptr.DisplayMode sdl2: setWindowDisplayMode(window: ptr Window; mode: ptr DisplayMode): cint +getWindowDisplayMode sdl2/sdl2.html#getWindowDisplayMode,ptr.Window,ptr.DisplayMode sdl2: getWindowDisplayMode(window: ptr Window; mode: ptr DisplayMode): cint +getWindowPixelFormat sdl2/sdl2.html#getWindowPixelFormat,ptr.Window sdl2: getWindowPixelFormat(window: ptr Window): Uint32 +createWindow sdl2/sdl2.html#createWindow,cstring,cint,cint,cint,cint,Uint32 sdl2: createWindow(title: cstring; x: cint; y: cint; w: cint; h: cint; flags: Uint32): ptr Window +createWindowFrom sdl2/sdl2.html#createWindowFrom,pointer sdl2: createWindowFrom(data: pointer): ptr Window +getWindowID sdl2/sdl2.html#getWindowID,ptr.Window sdl2: getWindowID(window: ptr Window): Uint32 +getWindowFromID sdl2/sdl2.html#getWindowFromID,Uint32 sdl2: getWindowFromID(id: Uint32): ptr Window +getWindowFlags sdl2/sdl2.html#getWindowFlags,ptr.Window sdl2: getWindowFlags(window: ptr Window): Uint32 +setWindowTitle sdl2/sdl2.html#setWindowTitle,ptr.Window,cstring sdl2: setWindowTitle(window: ptr Window; title: cstring) +getWindowTitle sdl2/sdl2.html#getWindowTitle,ptr.Window sdl2: getWindowTitle(window: ptr Window): cstring +setWindowIcon sdl2/sdl2.html#setWindowIcon,ptr.Window,ptr.Surface sdl2: setWindowIcon(window: ptr Window; icon: ptr Surface) +setWindowData sdl2/sdl2.html#setWindowData,ptr.Window,cstring,pointer sdl2: setWindowData(window: ptr Window; name: cstring; userdata: pointer): pointer +getWindowData sdl2/sdl2.html#getWindowData,ptr.Window,cstring sdl2: getWindowData(window: ptr Window; name: cstring): pointer +setWindowPosition sdl2/sdl2.html#setWindowPosition,ptr.Window,cint,cint sdl2: setWindowPosition(window: ptr Window; x: cint; y: cint) +getWindowPosition sdl2/sdl2.html#getWindowPosition,ptr.Window,ptr.cint,ptr.cint sdl2: getWindowPosition(window: ptr Window; x: ptr cint; y: ptr cint) +setWindowSize sdl2/sdl2.html#setWindowSize,ptr.Window,cint,cint sdl2: setWindowSize(window: ptr Window; w: cint; h: cint) +getWindowSize sdl2/sdl2.html#getWindowSize,ptr.Window,ptr.cint,ptr.cint sdl2: getWindowSize(window: ptr Window; w: ptr cint; h: ptr cint) +getWindowBordersSize sdl2/sdl2.html#getWindowBordersSize,ptr.Window,ptr.cint,ptr.cint,ptr.cint,ptr.cint sdl2: getWindowBordersSize(window: ptr Window; top: ptr cint; left: ptr cint; bottom: ptr cint;\n right: ptr cint): cint +setWindowMinimumSize sdl2/sdl2.html#setWindowMinimumSize,ptr.Window,cint,cint sdl2: setWindowMinimumSize(window: ptr Window; minW: cint; minH: cint) +getWindowMinimumSize sdl2/sdl2.html#getWindowMinimumSize,ptr.Window,ptr.cint,ptr.cint sdl2: getWindowMinimumSize(window: ptr Window; w: ptr cint; h: ptr cint) +setWindowMaximumSize sdl2/sdl2.html#setWindowMaximumSize,ptr.Window,cint,cint sdl2: setWindowMaximumSize(window: ptr Window; maxW: cint; maxH: cint) +getWindowMaximumSize sdl2/sdl2.html#getWindowMaximumSize,ptr.Window,ptr.cint,ptr.cint sdl2: getWindowMaximumSize(window: ptr Window; w: ptr cint; h: ptr cint) +setWindowBordered sdl2/sdl2.html#setWindowBordered,ptr.Window,bool sdl2: setWindowBordered(window: ptr Window; bordered: bool) +setWindowResizable sdl2/sdl2.html#setWindowResizable,ptr.Window,bool sdl2: setWindowResizable(window: ptr Window; resizable: bool) +showWindow sdl2/sdl2.html#showWindow,ptr.Window sdl2: showWindow(window: ptr Window) +hideWindow sdl2/sdl2.html#hideWindow,ptr.Window sdl2: hideWindow(window: ptr Window) +raiseWindow sdl2/sdl2.html#raiseWindow,ptr.Window sdl2: raiseWindow(window: ptr Window) +maximizeWindow sdl2/sdl2.html#maximizeWindow,ptr.Window sdl2: maximizeWindow(window: ptr Window) +minimizeWindow sdl2/sdl2.html#minimizeWindow,ptr.Window sdl2: minimizeWindow(window: ptr Window) +restoreWindow sdl2/sdl2.html#restoreWindow,ptr.Window sdl2: restoreWindow(window: ptr Window) +setWindowFullscreen sdl2/sdl2.html#setWindowFullscreen,ptr.Window,Uint32 sdl2: setWindowFullscreen(window: ptr Window; flags: Uint32): cint +getWindowSurface sdl2/sdl2.html#getWindowSurface,ptr.Window sdl2: getWindowSurface(window: ptr Window): ptr Surface +updateWindowSurface sdl2/sdl2.html#updateWindowSurface,ptr.Window sdl2: updateWindowSurface(window: ptr Window): cint +updateWindowSurfaceRects sdl2/sdl2.html#updateWindowSurfaceRects,ptr.Window,ptr.Rect,cint sdl2: updateWindowSurfaceRects(window: ptr Window; rects: ptr Rect; numrects: cint): cint +setWindowGrab sdl2/sdl2.html#setWindowGrab,ptr.Window,bool sdl2: setWindowGrab(window: ptr Window; grabbed: bool) +getWindowGrab sdl2/sdl2.html#getWindowGrab,ptr.Window sdl2: getWindowGrab(window: ptr Window): bool +getGrabbedWindow sdl2/sdl2.html#getGrabbedWindow sdl2: getGrabbedWindow(): ptr Window +setWindowBrightness sdl2/sdl2.html#setWindowBrightness,ptr.Window,cfloat sdl2: setWindowBrightness(window: ptr Window; brightness: cfloat): cint +getWindowBrightness sdl2/sdl2.html#getWindowBrightness,ptr.Window sdl2: getWindowBrightness(window: ptr Window): cfloat +setWindowOpacity sdl2/sdl2.html#setWindowOpacity,ptr.Window,cfloat sdl2: setWindowOpacity(window: ptr Window; opacity: cfloat): cint +getWindowOpacity sdl2/sdl2.html#getWindowOpacity,ptr.Window,ptr.cfloat sdl2: getWindowOpacity(window: ptr Window; outOpacity: ptr cfloat): cint +setWindowModalFor sdl2/sdl2.html#setWindowModalFor,ptr.Window,ptr.Window sdl2: setWindowModalFor(modalWindow: ptr Window; parentWindow: ptr Window): cint +setWindowInputFocus sdl2/sdl2.html#setWindowInputFocus,ptr.Window sdl2: setWindowInputFocus(window: ptr Window): cint +setWindowGammaRamp sdl2/sdl2.html#setWindowGammaRamp,ptr.Window,ptr.Uint16,ptr.Uint16,ptr.Uint16 sdl2: setWindowGammaRamp(window: ptr Window; red: ptr Uint16; green: ptr Uint16;\n blue: ptr Uint16): cint +getWindowGammaRamp sdl2/sdl2.html#getWindowGammaRamp,ptr.Window,ptr.Uint16,ptr.Uint16,ptr.Uint16 sdl2: getWindowGammaRamp(window: ptr Window; red: ptr Uint16; green: ptr Uint16;\n blue: ptr Uint16): cint +setWindowHitTest sdl2/sdl2.html#setWindowHitTest,ptr.Window,HitTest,pointer sdl2: setWindowHitTest(window: ptr Window; callback: HitTest; callbackData: pointer): cint +destroyWindow sdl2/sdl2.html#destroyWindow,ptr.Window sdl2: destroyWindow(window: ptr Window) +isScreenSaverEnabled sdl2/sdl2.html#isScreenSaverEnabled sdl2: isScreenSaverEnabled(): bool +enableScreenSaver sdl2/sdl2.html#enableScreenSaver sdl2: enableScreenSaver() +disableScreenSaver sdl2/sdl2.html#disableScreenSaver sdl2: disableScreenSaver() +gL_LoadLibrary sdl2/sdl2.html#gL_LoadLibrary,cstring sdl2: gL_LoadLibrary(path: cstring): cint +gL_GetProcAddress sdl2/sdl2.html#gL_GetProcAddress,cstring sdl2: gL_GetProcAddress(`proc`: cstring): pointer +gL_UnloadLibrary sdl2/sdl2.html#gL_UnloadLibrary sdl2: gL_UnloadLibrary() +gL_ExtensionSupported sdl2/sdl2.html#gL_ExtensionSupported,cstring sdl2: gL_ExtensionSupported(extension: cstring): bool +gL_ResetAttributes sdl2/sdl2.html#gL_ResetAttributes sdl2: gL_ResetAttributes() +gL_SetAttribute sdl2/sdl2.html#gL_SetAttribute,GLattr,cint sdl2: gL_SetAttribute(attr: GLattr; value: cint): cint +gL_GetAttribute sdl2/sdl2.html#gL_GetAttribute,GLattr,ptr.cint sdl2: gL_GetAttribute(attr: GLattr; value: ptr cint): cint +gL_CreateContext sdl2/sdl2.html#gL_CreateContext,ptr.Window sdl2: gL_CreateContext(window: ptr Window): GLContext +gL_MakeCurrent sdl2/sdl2.html#gL_MakeCurrent,ptr.Window,GLContext sdl2: gL_MakeCurrent(window: ptr Window; context: GLContext): cint +gL_GetCurrentWindow sdl2/sdl2.html#gL_GetCurrentWindow sdl2: gL_GetCurrentWindow(): ptr Window +gL_GetCurrentContext sdl2/sdl2.html#gL_GetCurrentContext sdl2: gL_GetCurrentContext(): GLContext +gL_GetDrawableSize sdl2/sdl2.html#gL_GetDrawableSize,ptr.Window,ptr.cint,ptr.cint sdl2: gL_GetDrawableSize(window: ptr Window; w: ptr cint; h: ptr cint) +gL_SetSwapInterval sdl2/sdl2.html#gL_SetSwapInterval,cint sdl2: gL_SetSwapInterval(interval: cint): cint +gL_GetSwapInterval sdl2/sdl2.html#gL_GetSwapInterval sdl2: gL_GetSwapInterval(): cint +gL_SwapWindow sdl2/sdl2.html#gL_SwapWindow,ptr.Window sdl2: gL_SwapWindow(window: ptr Window) +gL_DeleteContext sdl2/sdl2.html#gL_DeleteContext,GLContext sdl2: gL_DeleteContext(context: GLContext) +getKeyboardFocus sdl2/sdl2.html#getKeyboardFocus sdl2: getKeyboardFocus(): ptr Window +getKeyboardState sdl2/sdl2.html#getKeyboardState,ptr.cint sdl2: getKeyboardState(numkeys: ptr cint): ptr Uint8 +getModState sdl2/sdl2.html#getModState sdl2: getModState(): Keymod +setModState sdl2/sdl2.html#setModState,Keymod sdl2: setModState(modstate: Keymod) +getKeyFromScancode sdl2/sdl2.html#getKeyFromScancode,Scancode sdl2: getKeyFromScancode(scancode: Scancode): Keycode +getScancodeFromKey sdl2/sdl2.html#getScancodeFromKey,Keycode sdl2: getScancodeFromKey(key: Keycode): Scancode +getScancodeName sdl2/sdl2.html#getScancodeName,Scancode sdl2: getScancodeName(scancode: Scancode): cstring +getScancodeFromName sdl2/sdl2.html#getScancodeFromName,cstring sdl2: getScancodeFromName(name: cstring): Scancode +getKeyName sdl2/sdl2.html#getKeyName,Keycode sdl2: getKeyName(key: Keycode): cstring +getKeyFromName sdl2/sdl2.html#getKeyFromName,cstring sdl2: getKeyFromName(name: cstring): Keycode +startTextInput sdl2/sdl2.html#startTextInput sdl2: startTextInput() +isTextInputActive sdl2/sdl2.html#isTextInputActive sdl2: isTextInputActive(): bool +stopTextInput sdl2/sdl2.html#stopTextInput sdl2: stopTextInput() +setTextInputRect sdl2/sdl2.html#setTextInputRect,ptr.Rect sdl2: setTextInputRect(rect: ptr Rect) +hasScreenKeyboardSupport sdl2/sdl2.html#hasScreenKeyboardSupport sdl2: hasScreenKeyboardSupport(): bool +isScreenKeyboardShown sdl2/sdl2.html#isScreenKeyboardShown,ptr.Window sdl2: isScreenKeyboardShown(window: ptr Window): bool +getMouseFocus sdl2/sdl2.html#getMouseFocus sdl2: getMouseFocus(): ptr Window +getMouseState sdl2/sdl2.html#getMouseState,ptr.cint,ptr.cint sdl2: getMouseState(x: ptr cint; y: ptr cint): Uint32 +getGlobalMouseState sdl2/sdl2.html#getGlobalMouseState,ptr.cint,ptr.cint sdl2: getGlobalMouseState(x: ptr cint; y: ptr cint): Uint32 +getRelativeMouseState sdl2/sdl2.html#getRelativeMouseState,ptr.cint,ptr.cint sdl2: getRelativeMouseState(x: ptr cint; y: ptr cint): Uint32 +warpMouseInWindow sdl2/sdl2.html#warpMouseInWindow,ptr.Window,cint,cint sdl2: warpMouseInWindow(window: ptr Window; x: cint; y: cint) +warpMouseGlobal sdl2/sdl2.html#warpMouseGlobal,cint,cint sdl2: warpMouseGlobal(x: cint; y: cint): cint +setRelativeMouseMode sdl2/sdl2.html#setRelativeMouseMode,bool sdl2: setRelativeMouseMode(enabled: bool): cint +captureMouse sdl2/sdl2.html#captureMouse,bool sdl2: captureMouse(enabled: bool): cint +getRelativeMouseMode sdl2/sdl2.html#getRelativeMouseMode sdl2: getRelativeMouseMode(): bool +createCursor sdl2/sdl2.html#createCursor,ptr.Uint8,ptr.Uint8,cint,cint,cint,cint sdl2: createCursor(data: ptr Uint8; mask: ptr Uint8; w: cint; h: cint; hotX: cint; hotY: cint): ptr Cursor +createColorCursor sdl2/sdl2.html#createColorCursor,ptr.Surface,cint,cint sdl2: createColorCursor(surface: ptr Surface; hotX: cint; hotY: cint): ptr Cursor +createSystemCursor sdl2/sdl2.html#createSystemCursor,SystemCursor sdl2: createSystemCursor(id: SystemCursor): ptr Cursor +setCursor sdl2/sdl2.html#setCursor,ptr.Cursor sdl2: setCursor(cursor: ptr Cursor) +getCursor sdl2/sdl2.html#getCursor sdl2: getCursor(): ptr Cursor +getDefaultCursor sdl2/sdl2.html#getDefaultCursor sdl2: getDefaultCursor(): ptr Cursor +freeCursor sdl2/sdl2.html#freeCursor,ptr.Cursor sdl2: freeCursor(cursor: ptr Cursor) +showCursor sdl2/sdl2.html#showCursor,cint sdl2: showCursor(toggle: cint): cint +lockJoysticks sdl2/sdl2.html#lockJoysticks sdl2: lockJoysticks() +unlockJoysticks sdl2/sdl2.html#unlockJoysticks sdl2: unlockJoysticks() +numJoysticks sdl2/sdl2.html#numJoysticks sdl2: numJoysticks(): cint +joystickNameForIndex sdl2/sdl2.html#joystickNameForIndex,cint sdl2: joystickNameForIndex(deviceIndex: cint): cstring +joystickGetDevicePlayerIndex sdl2/sdl2.html#joystickGetDevicePlayerIndex,cint sdl2: joystickGetDevicePlayerIndex(deviceIndex: cint): cint +joystickGetDeviceGUID sdl2/sdl2.html#joystickGetDeviceGUID,cint sdl2: joystickGetDeviceGUID(deviceIndex: cint): JoystickGUID +joystickGetDeviceVendor sdl2/sdl2.html#joystickGetDeviceVendor,cint sdl2: joystickGetDeviceVendor(deviceIndex: cint): Uint16 +joystickGetDeviceProduct sdl2/sdl2.html#joystickGetDeviceProduct,cint sdl2: joystickGetDeviceProduct(deviceIndex: cint): Uint16 +joystickGetDeviceProductVersion sdl2/sdl2.html#joystickGetDeviceProductVersion,cint sdl2: joystickGetDeviceProductVersion(deviceIndex: cint): Uint16 +joystickGetDeviceType sdl2/sdl2.html#joystickGetDeviceType,cint sdl2: joystickGetDeviceType(deviceIndex: cint): JoystickType +joystickGetDeviceInstanceID sdl2/sdl2.html#joystickGetDeviceInstanceID,cint sdl2: joystickGetDeviceInstanceID(deviceIndex: cint): JoystickID +joystickOpen sdl2/sdl2.html#joystickOpen,cint sdl2: joystickOpen(deviceIndex: cint): ptr Joystick +joystickFromInstanceID sdl2/sdl2.html#joystickFromInstanceID,JoystickID sdl2: joystickFromInstanceID(instanceId: JoystickID): ptr Joystick +joystickFromPlayerIndex sdl2/sdl2.html#joystickFromPlayerIndex,cint sdl2: joystickFromPlayerIndex(playerIndex: cint): ptr Joystick +joystickName sdl2/sdl2.html#joystickName,ptr.Joystick sdl2: joystickName(joystick: ptr Joystick): cstring +joystickGetPlayerIndex sdl2/sdl2.html#joystickGetPlayerIndex,ptr.Joystick sdl2: joystickGetPlayerIndex(joystick: ptr Joystick): cint +joystickSetPlayerIndex sdl2/sdl2.html#joystickSetPlayerIndex,ptr.Joystick,cint sdl2: joystickSetPlayerIndex(joystick: ptr Joystick; playerIndex: cint) +joystickGetGUID sdl2/sdl2.html#joystickGetGUID,ptr.Joystick sdl2: joystickGetGUID(joystick: ptr Joystick): JoystickGUID +joystickGetVendor sdl2/sdl2.html#joystickGetVendor,ptr.Joystick sdl2: joystickGetVendor(joystick: ptr Joystick): Uint16 +joystickGetProduct sdl2/sdl2.html#joystickGetProduct,ptr.Joystick sdl2: joystickGetProduct(joystick: ptr Joystick): Uint16 +joystickGetProductVersion sdl2/sdl2.html#joystickGetProductVersion,ptr.Joystick sdl2: joystickGetProductVersion(joystick: ptr Joystick): Uint16 +joystickGetType sdl2/sdl2.html#joystickGetType,ptr.Joystick sdl2: joystickGetType(joystick: ptr Joystick): JoystickType +joystickGetGUIDString sdl2/sdl2.html#joystickGetGUIDString,JoystickGUID,cstring,cint sdl2: joystickGetGUIDString(guid: JoystickGUID; pszGUID: cstring; cbGUID: cint) +joystickGetGUIDFromString sdl2/sdl2.html#joystickGetGUIDFromString,cstring sdl2: joystickGetGUIDFromString(pchGUID: cstring): JoystickGUID +joystickGetAttached sdl2/sdl2.html#joystickGetAttached,ptr.Joystick sdl2: joystickGetAttached(joystick: ptr Joystick): bool +joystickInstanceID sdl2/sdl2.html#joystickInstanceID,ptr.Joystick sdl2: joystickInstanceID(joystick: ptr Joystick): JoystickID +joystickNumAxes sdl2/sdl2.html#joystickNumAxes,ptr.Joystick sdl2: joystickNumAxes(joystick: ptr Joystick): cint +joystickNumBalls sdl2/sdl2.html#joystickNumBalls,ptr.Joystick sdl2: joystickNumBalls(joystick: ptr Joystick): cint +joystickNumHats sdl2/sdl2.html#joystickNumHats,ptr.Joystick sdl2: joystickNumHats(joystick: ptr Joystick): cint +joystickNumButtons sdl2/sdl2.html#joystickNumButtons,ptr.Joystick sdl2: joystickNumButtons(joystick: ptr Joystick): cint +joystickUpdate sdl2/sdl2.html#joystickUpdate sdl2: joystickUpdate() +joystickEventState sdl2/sdl2.html#joystickEventState,cint sdl2: joystickEventState(state: cint): cint +joystickGetAxis sdl2/sdl2.html#joystickGetAxis,ptr.Joystick,cint sdl2: joystickGetAxis(joystick: ptr Joystick; axis: cint): Sint16 +joystickGetAxisInitialState sdl2/sdl2.html#joystickGetAxisInitialState,ptr.Joystick,cint,ptr.Sint16 sdl2: joystickGetAxisInitialState(joystick: ptr Joystick; axis: cint; state: ptr Sint16): bool +joystickGetHat sdl2/sdl2.html#joystickGetHat,ptr.Joystick,cint sdl2: joystickGetHat(joystick: ptr Joystick; hat: cint): Uint8 +joystickGetBall sdl2/sdl2.html#joystickGetBall,ptr.Joystick,cint,ptr.cint,ptr.cint sdl2: joystickGetBall(joystick: ptr Joystick; ball: cint; dx: ptr cint; dy: ptr cint): cint +joystickGetButton sdl2/sdl2.html#joystickGetButton,ptr.Joystick,cint sdl2: joystickGetButton(joystick: ptr Joystick; button: cint): Uint8 +joystickRumble sdl2/sdl2.html#joystickRumble,ptr.Joystick,Uint16,Uint16,Uint32 sdl2: joystickRumble(joystick: ptr Joystick; lowFrequencyRumble: Uint16;\n highFrequencyRumble: Uint16; durationMs: Uint32): cint +joystickClose sdl2/sdl2.html#joystickClose,ptr.Joystick sdl2: joystickClose(joystick: ptr Joystick) +joystickCurrentPowerLevel sdl2/sdl2.html#joystickCurrentPowerLevel,ptr.Joystick sdl2: joystickCurrentPowerLevel(joystick: ptr Joystick): JoystickPowerLevel +gameControllerAddMappingsFromRW sdl2/sdl2.html#gameControllerAddMappingsFromRW,ptr.RWops,cint sdl2: gameControllerAddMappingsFromRW(rw: ptr RWops; freerw: cint): cint +gameControllerAddMapping sdl2/sdl2.html#gameControllerAddMapping,cstring sdl2: gameControllerAddMapping(mappingString: cstring): cint +gameControllerNumMappings sdl2/sdl2.html#gameControllerNumMappings sdl2: gameControllerNumMappings(): cint +gameControllerMappingForIndex sdl2/sdl2.html#gameControllerMappingForIndex,cint sdl2: gameControllerMappingForIndex(mappingIndex: cint): cstring +gameControllerMappingForGUID sdl2/sdl2.html#gameControllerMappingForGUID,JoystickGUID sdl2: gameControllerMappingForGUID(guid: JoystickGUID): cstring +gameControllerMapping sdl2/sdl2.html#gameControllerMapping,ptr.GameController sdl2: gameControllerMapping(gamecontroller: ptr GameController): cstring +isGameController sdl2/sdl2.html#isGameController,cint sdl2: isGameController(joystickIndex: cint): bool +gameControllerNameForIndex sdl2/sdl2.html#gameControllerNameForIndex,cint sdl2: gameControllerNameForIndex(joystickIndex: cint): cstring +gameControllerTypeForIndex sdl2/sdl2.html#gameControllerTypeForIndex,cint sdl2: gameControllerTypeForIndex(joystickIndex: cint): GameControllerType +gameControllerMappingForDeviceIndex sdl2/sdl2.html#gameControllerMappingForDeviceIndex,cint sdl2: gameControllerMappingForDeviceIndex(joystickIndex: cint): cstring +gameControllerOpen sdl2/sdl2.html#gameControllerOpen,cint sdl2: gameControllerOpen(joystickIndex: cint): ptr GameController +gameControllerFromInstanceID sdl2/sdl2.html#gameControllerFromInstanceID,JoystickID sdl2: gameControllerFromInstanceID(joyid: JoystickID): ptr GameController +gameControllerFromPlayerIndex sdl2/sdl2.html#gameControllerFromPlayerIndex,cint sdl2: gameControllerFromPlayerIndex(playerIndex: cint): ptr GameController +gameControllerName sdl2/sdl2.html#gameControllerName,ptr.GameController sdl2: gameControllerName(gamecontroller: ptr GameController): cstring +gameControllerGetType sdl2/sdl2.html#gameControllerGetType,ptr.GameController sdl2: gameControllerGetType(gamecontroller: ptr GameController): GameControllerType +gameControllerGetPlayerIndex sdl2/sdl2.html#gameControllerGetPlayerIndex,ptr.GameController sdl2: gameControllerGetPlayerIndex(gamecontroller: ptr GameController): cint +gameControllerSetPlayerIndex sdl2/sdl2.html#gameControllerSetPlayerIndex,ptr.GameController,cint sdl2: gameControllerSetPlayerIndex(gamecontroller: ptr GameController; playerIndex: cint) +gameControllerGetVendor sdl2/sdl2.html#gameControllerGetVendor,ptr.GameController sdl2: gameControllerGetVendor(gamecontroller: ptr GameController): Uint16 +gameControllerGetProduct sdl2/sdl2.html#gameControllerGetProduct,ptr.GameController sdl2: gameControllerGetProduct(gamecontroller: ptr GameController): Uint16 +gameControllerGetProductVersion sdl2/sdl2.html#gameControllerGetProductVersion,ptr.GameController sdl2: gameControllerGetProductVersion(gamecontroller: ptr GameController): Uint16 +gameControllerGetAttached sdl2/sdl2.html#gameControllerGetAttached,ptr.GameController sdl2: gameControllerGetAttached(gamecontroller: ptr GameController): bool +gameControllerGetJoystick sdl2/sdl2.html#gameControllerGetJoystick,ptr.GameController sdl2: gameControllerGetJoystick(gamecontroller: ptr GameController): ptr Joystick +gameControllerEventState sdl2/sdl2.html#gameControllerEventState,cint sdl2: gameControllerEventState(state: cint): cint +gameControllerUpdate sdl2/sdl2.html#gameControllerUpdate sdl2: gameControllerUpdate() +gameControllerGetAxisFromString sdl2/sdl2.html#gameControllerGetAxisFromString,cstring sdl2: gameControllerGetAxisFromString(pchString: cstring): GameControllerAxis +gameControllerGetStringForAxis sdl2/sdl2.html#gameControllerGetStringForAxis,GameControllerAxis sdl2: gameControllerGetStringForAxis(axis: GameControllerAxis): cstring +gameControllerGetBindForAxis sdl2/sdl2.html#gameControllerGetBindForAxis,ptr.GameController,GameControllerAxis sdl2: gameControllerGetBindForAxis(gamecontroller: ptr GameController;\n axis: GameControllerAxis): GameControllerButtonBind +gameControllerGetAxis sdl2/sdl2.html#gameControllerGetAxis,ptr.GameController,GameControllerAxis sdl2: gameControllerGetAxis(gamecontroller: ptr GameController; axis: GameControllerAxis): Sint16 +gameControllerGetButtonFromString sdl2/sdl2.html#gameControllerGetButtonFromString,cstring sdl2: gameControllerGetButtonFromString(pchString: cstring): GameControllerButton +gameControllerGetStringForButton sdl2/sdl2.html#gameControllerGetStringForButton,GameControllerButton sdl2: gameControllerGetStringForButton(button: GameControllerButton): cstring +gameControllerGetBindForButton sdl2/sdl2.html#gameControllerGetBindForButton,ptr.GameController,GameControllerButton sdl2: gameControllerGetBindForButton(gamecontroller: ptr GameController;\n button: GameControllerButton): GameControllerButtonBind +gameControllerGetButton sdl2/sdl2.html#gameControllerGetButton,ptr.GameController,GameControllerButton sdl2: gameControllerGetButton(gamecontroller: ptr GameController;\n button: GameControllerButton): Uint8 +gameControllerRumble sdl2/sdl2.html#gameControllerRumble,ptr.GameController,Uint16,Uint16,Uint32 sdl2: gameControllerRumble(gamecontroller: ptr GameController;\n lowFrequencyRumble: Uint16; highFrequencyRumble: Uint16;\n durationMs: Uint32): cint +gameControllerClose sdl2/sdl2.html#gameControllerClose,ptr.GameController sdl2: gameControllerClose(gamecontroller: ptr GameController) +getNumTouchDevices sdl2/sdl2.html#getNumTouchDevices sdl2: getNumTouchDevices(): cint +getTouchDevice sdl2/sdl2.html#getTouchDevice,cint sdl2: getTouchDevice(index: cint): TouchID +getTouchDeviceType sdl2/sdl2.html#getTouchDeviceType,TouchID sdl2: getTouchDeviceType(touchID: TouchID): TouchDeviceType +getNumTouchFingers sdl2/sdl2.html#getNumTouchFingers,TouchID sdl2: getNumTouchFingers(touchID: TouchID): cint +getTouchFinger sdl2/sdl2.html#getTouchFinger,TouchID,cint sdl2: getTouchFinger(touchID: TouchID; index: cint): ptr Finger +recordGesture sdl2/sdl2.html#recordGesture,TouchID sdl2: recordGesture(touchId: TouchID): cint +saveAllDollarTemplates sdl2/sdl2.html#saveAllDollarTemplates,ptr.RWops sdl2: saveAllDollarTemplates(dst: ptr RWops): cint +saveDollarTemplate sdl2/sdl2.html#saveDollarTemplate,GestureID,ptr.RWops sdl2: saveDollarTemplate(gestureId: GestureID; dst: ptr RWops): cint +loadDollarTemplates sdl2/sdl2.html#loadDollarTemplates,TouchID,ptr.RWops sdl2: loadDollarTemplates(touchId: TouchID; src: ptr RWops): cint +pumpEvents sdl2/sdl2.html#pumpEvents sdl2: pumpEvents() +peepEvents sdl2/sdl2.html#peepEvents,ptr.Event,cint,eventaction,Uint32,Uint32 sdl2: peepEvents(events: ptr Event; numevents: cint; action: eventaction; minType: Uint32;\n maxType: Uint32): cint +hasEvent sdl2/sdl2.html#hasEvent,Uint32 sdl2: hasEvent(kind: Uint32): bool +hasEvents sdl2/sdl2.html#hasEvents,Uint32,Uint32 sdl2: hasEvents(minType: Uint32; maxType: Uint32): bool +flushEvent sdl2/sdl2.html#flushEvent,Uint32 sdl2: flushEvent(kind: Uint32) +flushEvents sdl2/sdl2.html#flushEvents,Uint32,Uint32 sdl2: flushEvents(minType: Uint32; maxType: Uint32) +pollEvent sdl2/sdl2.html#pollEvent,ptr.Event sdl2: pollEvent(event: ptr Event): cint +waitEvent sdl2/sdl2.html#waitEvent,ptr.Event sdl2: waitEvent(event: ptr Event): cint +waitEventTimeout sdl2/sdl2.html#waitEventTimeout,ptr.Event,cint sdl2: waitEventTimeout(event: ptr Event; timeout: cint): cint +pushEvent sdl2/sdl2.html#pushEvent,ptr.Event sdl2: pushEvent(event: ptr Event): cint +setEventFilter sdl2/sdl2.html#setEventFilter,EventFilter,pointer sdl2: setEventFilter(filter: EventFilter; userdata: pointer) +getEventFilter sdl2/sdl2.html#getEventFilter,ptr.EventFilter,ptr.pointer sdl2: getEventFilter(filter: ptr EventFilter; userdata: ptr pointer): bool +addEventWatch sdl2/sdl2.html#addEventWatch,EventFilter,pointer sdl2: addEventWatch(filter: EventFilter; userdata: pointer) +delEventWatch sdl2/sdl2.html#delEventWatch,EventFilter,pointer sdl2: delEventWatch(filter: EventFilter; userdata: pointer) +filterEvents sdl2/sdl2.html#filterEvents,EventFilter,pointer sdl2: filterEvents(filter: EventFilter; userdata: pointer) +eventState sdl2/sdl2.html#eventState,Uint32,cint sdl2: eventState(kind: Uint32; state: cint): Uint8 +registerEvents sdl2/sdl2.html#registerEvents,cint sdl2: registerEvents(numevents: cint): Uint32 +getBasePath sdl2/sdl2.html#getBasePath sdl2: getBasePath(): cstring +getPrefPath sdl2/sdl2.html#getPrefPath,cstring,cstring sdl2: getPrefPath(org: cstring; app: cstring): cstring +numHaptics sdl2/sdl2.html#numHaptics sdl2: numHaptics(): cint +hapticName sdl2/sdl2.html#hapticName,cint sdl2: hapticName(deviceIndex: cint): cstring +hapticOpen sdl2/sdl2.html#hapticOpen,cint sdl2: hapticOpen(deviceIndex: cint): ptr Haptic +hapticOpened sdl2/sdl2.html#hapticOpened,cint sdl2: hapticOpened(deviceIndex: cint): cint +hapticIndex sdl2/sdl2.html#hapticIndex,ptr.PHaptic sdl2: hapticIndex(haptic: ptr Haptic): cint +mouseIsHaptic sdl2/sdl2.html#mouseIsHaptic sdl2: mouseIsHaptic(): cint +hapticOpenFromMouse sdl2/sdl2.html#hapticOpenFromMouse sdl2: hapticOpenFromMouse(): ptr Haptic +joystickIsHaptic sdl2/sdl2.html#joystickIsHaptic,ptr.Joystick sdl2: joystickIsHaptic(joystick: ptr Joystick): cint +hapticOpenFromJoystick sdl2/sdl2.html#hapticOpenFromJoystick,ptr.Joystick sdl2: hapticOpenFromJoystick(joystick: ptr Joystick): ptr Haptic +hapticClose sdl2/sdl2.html#hapticClose,ptr.PHaptic sdl2: hapticClose(haptic: ptr Haptic) +hapticNumEffects sdl2/sdl2.html#hapticNumEffects,ptr.PHaptic sdl2: hapticNumEffects(haptic: ptr Haptic): cint +hapticNumEffectsPlaying sdl2/sdl2.html#hapticNumEffectsPlaying,ptr.PHaptic sdl2: hapticNumEffectsPlaying(haptic: ptr Haptic): cint +hapticQuery sdl2/sdl2.html#hapticQuery,ptr.PHaptic sdl2: hapticQuery(haptic: ptr Haptic): cuint +hapticNumAxes sdl2/sdl2.html#hapticNumAxes,ptr.PHaptic sdl2: hapticNumAxes(haptic: ptr Haptic): cint +hapticEffectSupported sdl2/sdl2.html#hapticEffectSupported,ptr.PHaptic,ptr.HapticEffect sdl2: hapticEffectSupported(haptic: ptr Haptic; effect: ptr HapticEffect): cint +hapticNewEffect sdl2/sdl2.html#hapticNewEffect,ptr.PHaptic,ptr.HapticEffect sdl2: hapticNewEffect(haptic: ptr Haptic; effect: ptr HapticEffect): cint +hapticUpdateEffect sdl2/sdl2.html#hapticUpdateEffect,ptr.PHaptic,cint,ptr.HapticEffect sdl2: hapticUpdateEffect(haptic: ptr Haptic; effect: cint; data: ptr HapticEffect): cint +hapticRunEffect sdl2/sdl2.html#hapticRunEffect,ptr.PHaptic,cint,Uint32 sdl2: hapticRunEffect(haptic: ptr Haptic; effect: cint; iterations: Uint32): cint +hapticStopEffect sdl2/sdl2.html#hapticStopEffect,ptr.PHaptic,cint sdl2: hapticStopEffect(haptic: ptr Haptic; effect: cint): cint +hapticDestroyEffect sdl2/sdl2.html#hapticDestroyEffect,ptr.PHaptic,cint sdl2: hapticDestroyEffect(haptic: ptr Haptic; effect: cint) +hapticGetEffectStatus sdl2/sdl2.html#hapticGetEffectStatus,ptr.PHaptic,cint sdl2: hapticGetEffectStatus(haptic: ptr Haptic; effect: cint): cint +hapticSetGain sdl2/sdl2.html#hapticSetGain,ptr.PHaptic,cint sdl2: hapticSetGain(haptic: ptr Haptic; gain: cint): cint +hapticSetAutocenter sdl2/sdl2.html#hapticSetAutocenter,ptr.PHaptic,cint sdl2: hapticSetAutocenter(haptic: ptr Haptic; autocenter: cint): cint +hapticPause sdl2/sdl2.html#hapticPause,ptr.PHaptic sdl2: hapticPause(haptic: ptr Haptic): cint +hapticUnpause sdl2/sdl2.html#hapticUnpause,ptr.PHaptic sdl2: hapticUnpause(haptic: ptr Haptic): cint +hapticStopAll sdl2/sdl2.html#hapticStopAll,ptr.PHaptic sdl2: hapticStopAll(haptic: ptr Haptic): cint +hapticRumbleSupported sdl2/sdl2.html#hapticRumbleSupported,ptr.PHaptic sdl2: hapticRumbleSupported(haptic: ptr Haptic): cint +hapticRumbleInit sdl2/sdl2.html#hapticRumbleInit,ptr.PHaptic sdl2: hapticRumbleInit(haptic: ptr Haptic): cint +hapticRumblePlay sdl2/sdl2.html#hapticRumblePlay,ptr.PHaptic,cfloat,Uint32 sdl2: hapticRumblePlay(haptic: ptr Haptic; strength: cfloat; length: Uint32): cint +hapticRumbleStop sdl2/sdl2.html#hapticRumbleStop,ptr.PHaptic sdl2: hapticRumbleStop(haptic: ptr Haptic): cint +setHintWithPriority sdl2/sdl2.html#setHintWithPriority,cstring,cstring,HintPriority sdl2: setHintWithPriority(name: cstring; value: cstring; priority: HintPriority): bool +setHint sdl2/sdl2.html#setHint,cstring,cstring sdl2: setHint(name: cstring; value: cstring): bool +getHint sdl2/sdl2.html#getHint,cstring sdl2: getHint(name: cstring): cstring +getHintBoolean sdl2/sdl2.html#getHintBoolean,cstring,bool sdl2: getHintBoolean(name: cstring; defaultValue: bool): bool +addHintCallback sdl2/sdl2.html#addHintCallback,cstring,HintCallback,pointer sdl2: addHintCallback(name: cstring; callback: HintCallback; userdata: pointer) +delHintCallback sdl2/sdl2.html#delHintCallback,cstring,HintCallback,pointer sdl2: delHintCallback(name: cstring; callback: HintCallback; userdata: pointer) +clearHints sdl2/sdl2.html#clearHints sdl2: clearHints() +loadObject sdl2/sdl2.html#loadObject,cstring sdl2: loadObject(sofile: cstring): pointer +loadFunction sdl2/sdl2.html#loadFunction,pointer,cstring sdl2: loadFunction(handle: pointer; name: cstring): pointer +unloadObject sdl2/sdl2.html#unloadObject,pointer sdl2: unloadObject(handle: pointer) +logSetAllPriority sdl2/sdl2.html#logSetAllPriority,LogPriority sdl2: logSetAllPriority(priority: LogPriority) +logSetPriority sdl2/sdl2.html#logSetPriority,cint,LogPriority sdl2: logSetPriority(category: cint; priority: LogPriority) +logGetPriority sdl2/sdl2.html#logGetPriority,cint sdl2: logGetPriority(category: cint): LogPriority +logResetPriorities sdl2/sdl2.html#logResetPriorities sdl2: logResetPriorities() +logVerbose sdl2/sdl2.html#logVerbose,cint,cstring sdl2: logVerbose(category: cint; fmt: cstring) +logDebug sdl2/sdl2.html#logDebug,cint,cstring sdl2: logDebug(category: cint; fmt: cstring) +logInfo sdl2/sdl2.html#logInfo,cint,cstring sdl2: logInfo(category: cint; fmt: cstring) +logWarn sdl2/sdl2.html#logWarn,cint,cstring sdl2: logWarn(category: cint; fmt: cstring) +logError sdl2/sdl2.html#logError,cint,cstring sdl2: logError(category: cint; fmt: cstring) +logCritical sdl2/sdl2.html#logCritical,cint,cstring sdl2: logCritical(category: cint; fmt: cstring) +logMessage sdl2/sdl2.html#logMessage,cint,LogPriority,cstring sdl2: logMessage(category: cint; priority: LogPriority; fmt: cstring) +logMessageV sdl2/sdl2.html#logMessageV,cint,LogPriority,cstring,va_list sdl2: logMessageV(category: cint; priority: LogPriority; fmt: cstring; ap: va_list) +logGetOutputFunction sdl2/sdl2.html#logGetOutputFunction,ptr.LogOutputFunction,ptr.pointer sdl2: logGetOutputFunction(callback: ptr LogOutputFunction; userdata: ptr pointer) +logSetOutputFunction sdl2/sdl2.html#logSetOutputFunction,LogOutputFunction,pointer sdl2: logSetOutputFunction(callback: LogOutputFunction; userdata: pointer) +showMessageBox sdl2/sdl2.html#showMessageBox,ptr.MessageBoxData,ptr.cint sdl2: showMessageBox(messageboxdata: ptr MessageBoxData; buttonid: ptr cint): cint +showSimpleMessageBox sdl2/sdl2.html#showSimpleMessageBox,Uint32,cstring,cstring,ptr.Window sdl2: showSimpleMessageBox(flags: Uint32; title: cstring; message: cstring;\n window: ptr Window): cint +metal_CreateView sdl2/sdl2.html#metal_CreateView,ptr.Window sdl2: metal_CreateView(window: ptr Window): MetalView +metal_DestroyView sdl2/sdl2.html#metal_DestroyView,MetalView sdl2: metal_DestroyView(view: MetalView) +getPowerInfo sdl2/sdl2.html#getPowerInfo,ptr.cint,ptr.cint sdl2: getPowerInfo(secs: ptr cint; pct: ptr cint): PowerState +getNumRenderDrivers sdl2/sdl2.html#getNumRenderDrivers sdl2: getNumRenderDrivers(): cint +getRenderDriverInfo sdl2/sdl2.html#getRenderDriverInfo,cint,ptr.RendererInfo sdl2: getRenderDriverInfo(index: cint; info: ptr RendererInfo): cint +createWindowAndRenderer sdl2/sdl2.html#createWindowAndRenderer,cint,cint,Uint32,ptr.ptr.Window,ptr.ptr.Renderer sdl2: createWindowAndRenderer(width: cint; height: cint; windowFlags: Uint32;\n window: ptr ptr Window; renderer: ptr ptr Renderer): cint +createRenderer sdl2/sdl2.html#createRenderer,ptr.Window,cint,Uint32 sdl2: createRenderer(window: ptr Window; index: cint; flags: Uint32): ptr Renderer +createSoftwareRenderer sdl2/sdl2.html#createSoftwareRenderer,ptr.Surface sdl2: createSoftwareRenderer(surface: ptr Surface): ptr Renderer +getRenderer sdl2/sdl2.html#getRenderer,ptr.Window sdl2: getRenderer(window: ptr Window): ptr Renderer +getRendererInfo sdl2/sdl2.html#getRendererInfo,ptr.Renderer,ptr.RendererInfo sdl2: getRendererInfo(renderer: ptr Renderer; info: ptr RendererInfo): cint +getRendererOutputSize sdl2/sdl2.html#getRendererOutputSize,ptr.Renderer,ptr.cint,ptr.cint sdl2: getRendererOutputSize(renderer: ptr Renderer; w: ptr cint; h: ptr cint): cint +createTexture sdl2/sdl2.html#createTexture,ptr.Renderer,Uint32,cint,cint,cint sdl2: createTexture(renderer: ptr Renderer; format: Uint32; access: cint; w: cint; h: cint): ptr Texture +createTextureFromSurface sdl2/sdl2.html#createTextureFromSurface,ptr.Renderer,ptr.Surface sdl2: createTextureFromSurface(renderer: ptr Renderer; surface: ptr Surface): ptr Texture +queryTexture sdl2/sdl2.html#queryTexture,ptr.Texture,ptr.Uint32,ptr.cint,ptr.cint,ptr.cint sdl2: queryTexture(texture: ptr Texture; format: ptr Uint32; access: ptr cint; w: ptr cint;\n h: ptr cint): cint +setTextureColorMod sdl2/sdl2.html#setTextureColorMod,ptr.Texture,Uint8,Uint8,Uint8 sdl2: setTextureColorMod(texture: ptr Texture; r: Uint8; g: Uint8; b: Uint8): cint +getTextureColorMod sdl2/sdl2.html#getTextureColorMod,ptr.Texture,ptr.Uint8,ptr.Uint8,ptr.Uint8 sdl2: getTextureColorMod(texture: ptr Texture; r: ptr Uint8; g: ptr Uint8; b: ptr Uint8): cint +setTextureAlphaMod sdl2/sdl2.html#setTextureAlphaMod,ptr.Texture,Uint8 sdl2: setTextureAlphaMod(texture: ptr Texture; alpha: Uint8): cint +getTextureAlphaMod sdl2/sdl2.html#getTextureAlphaMod,ptr.Texture,ptr.Uint8 sdl2: getTextureAlphaMod(texture: ptr Texture; alpha: ptr Uint8): cint +setTextureBlendMode sdl2/sdl2.html#setTextureBlendMode,ptr.Texture,BlendMode sdl2: setTextureBlendMode(texture: ptr Texture; blendMode: BlendMode): cint +getTextureBlendMode sdl2/sdl2.html#getTextureBlendMode,ptr.Texture,ptr.BlendMode sdl2: getTextureBlendMode(texture: ptr Texture; blendMode: ptr BlendMode): cint +setTextureScaleMode sdl2/sdl2.html#setTextureScaleMode,ptr.Texture,ScaleMode sdl2: setTextureScaleMode(texture: ptr Texture; scaleMode: ScaleMode): cint +getTextureScaleMode sdl2/sdl2.html#getTextureScaleMode,ptr.Texture,ptr.ScaleMode sdl2: getTextureScaleMode(texture: ptr Texture; scaleMode: ptr ScaleMode): cint +updateTexture sdl2/sdl2.html#updateTexture,ptr.Texture,ptr.Rect,pointer,cint sdl2: updateTexture(texture: ptr Texture; rect: ptr Rect; pixels: pointer; pitch: cint): cint +updateYUVTexture sdl2/sdl2.html#updateYUVTexture,ptr.Texture,ptr.Rect,ptr.Uint8,cint,ptr.Uint8,cint,ptr.Uint8,cint sdl2: updateYUVTexture(texture: ptr Texture; rect: ptr Rect; Yplane: ptr Uint8; Ypitch: cint;\n Uplane: ptr Uint8; Upitch: cint; Vplane: ptr Uint8; Vpitch: cint): cint +lockTexture sdl2/sdl2.html#lockTexture,ptr.Texture,ptr.Rect,ptr.pointer,ptr.cint sdl2: lockTexture(texture: ptr Texture; rect: ptr Rect; pixels: ptr pointer; pitch: ptr cint): cint +lockTextureToSurface sdl2/sdl2.html#lockTextureToSurface,ptr.Texture,ptr.Rect,ptr.ptr.Surface sdl2: lockTextureToSurface(texture: ptr Texture; rect: ptr Rect; surface: ptr ptr Surface): cint +unlockTexture sdl2/sdl2.html#unlockTexture,ptr.Texture sdl2: unlockTexture(texture: ptr Texture) +renderTargetSupported sdl2/sdl2.html#renderTargetSupported,ptr.Renderer sdl2: renderTargetSupported(renderer: ptr Renderer): bool +setRenderTarget sdl2/sdl2.html#setRenderTarget,ptr.Renderer,ptr.Texture sdl2: setRenderTarget(renderer: ptr Renderer; texture: ptr Texture): cint +getRenderTarget sdl2/sdl2.html#getRenderTarget,ptr.Renderer sdl2: getRenderTarget(renderer: ptr Renderer): ptr Texture +renderSetLogicalSize sdl2/sdl2.html#renderSetLogicalSize,ptr.Renderer,cint,cint sdl2: renderSetLogicalSize(renderer: ptr Renderer; w: cint; h: cint): cint +renderGetLogicalSize sdl2/sdl2.html#renderGetLogicalSize,ptr.Renderer,ptr.cint,ptr.cint sdl2: renderGetLogicalSize(renderer: ptr Renderer; w: ptr cint; h: ptr cint) +renderSetIntegerScale sdl2/sdl2.html#renderSetIntegerScale,ptr.Renderer,bool sdl2: renderSetIntegerScale(renderer: ptr Renderer; enable: bool): cint +renderGetIntegerScale sdl2/sdl2.html#renderGetIntegerScale,ptr.Renderer sdl2: renderGetIntegerScale(renderer: ptr Renderer): bool +renderSetViewport sdl2/sdl2.html#renderSetViewport,ptr.Renderer,ptr.Rect sdl2: renderSetViewport(renderer: ptr Renderer; rect: ptr Rect): cint +renderGetViewport sdl2/sdl2.html#renderGetViewport,ptr.Renderer,ptr.Rect sdl2: renderGetViewport(renderer: ptr Renderer; rect: ptr Rect) +renderSetClipRect sdl2/sdl2.html#renderSetClipRect,ptr.Renderer,ptr.Rect sdl2: renderSetClipRect(renderer: ptr Renderer; rect: ptr Rect): cint +renderGetClipRect sdl2/sdl2.html#renderGetClipRect,ptr.Renderer,ptr.Rect sdl2: renderGetClipRect(renderer: ptr Renderer; rect: ptr Rect) +renderIsClipEnabled sdl2/sdl2.html#renderIsClipEnabled,ptr.Renderer sdl2: renderIsClipEnabled(renderer: ptr Renderer): bool +renderSetScale sdl2/sdl2.html#renderSetScale,ptr.Renderer,cfloat,cfloat sdl2: renderSetScale(renderer: ptr Renderer; scaleX: cfloat; scaleY: cfloat): cint +renderGetScale sdl2/sdl2.html#renderGetScale,ptr.Renderer,ptr.cfloat,ptr.cfloat sdl2: renderGetScale(renderer: ptr Renderer; scaleX: ptr cfloat; scaleY: ptr cfloat) +setRenderDrawColor sdl2/sdl2.html#setRenderDrawColor,ptr.Renderer,Uint8,Uint8,Uint8,Uint8 sdl2: setRenderDrawColor(renderer: ptr Renderer; r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint +getRenderDrawColor sdl2/sdl2.html#getRenderDrawColor,ptr.Renderer,ptr.Uint8,ptr.Uint8,ptr.Uint8,ptr.Uint8 sdl2: getRenderDrawColor(renderer: ptr Renderer; r: ptr Uint8; g: ptr Uint8; b: ptr Uint8;\n a: ptr Uint8): cint +setRenderDrawBlendMode sdl2/sdl2.html#setRenderDrawBlendMode,ptr.Renderer,BlendMode sdl2: setRenderDrawBlendMode(renderer: ptr Renderer; blendMode: BlendMode): cint +getRenderDrawBlendMode sdl2/sdl2.html#getRenderDrawBlendMode,ptr.Renderer,ptr.BlendMode sdl2: getRenderDrawBlendMode(renderer: ptr Renderer; blendMode: ptr BlendMode): cint +renderClear sdl2/sdl2.html#renderClear,ptr.Renderer sdl2: renderClear(renderer: ptr Renderer): cint +renderDrawPoint sdl2/sdl2.html#renderDrawPoint,ptr.Renderer,cint,cint sdl2: renderDrawPoint(renderer: ptr Renderer; x: cint; y: cint): cint +renderDrawPoints sdl2/sdl2.html#renderDrawPoints,ptr.Renderer,ptr.Point,cint sdl2: renderDrawPoints(renderer: ptr Renderer; points: ptr Point; count: cint): cint +renderDrawLine sdl2/sdl2.html#renderDrawLine,ptr.Renderer,cint,cint,cint,cint sdl2: renderDrawLine(renderer: ptr Renderer; x1: cint; y1: cint; x2: cint; y2: cint): cint +renderDrawLines sdl2/sdl2.html#renderDrawLines,ptr.Renderer,ptr.Point,cint sdl2: renderDrawLines(renderer: ptr Renderer; points: ptr Point; count: cint): cint +renderDrawRect sdl2/sdl2.html#renderDrawRect,ptr.Renderer,ptr.Rect sdl2: renderDrawRect(renderer: ptr Renderer; rect: ptr Rect): cint +renderDrawRects sdl2/sdl2.html#renderDrawRects,ptr.Renderer,ptr.Rect,cint sdl2: renderDrawRects(renderer: ptr Renderer; rects: ptr Rect; count: cint): cint +renderFillRect sdl2/sdl2.html#renderFillRect,ptr.Renderer,ptr.Rect sdl2: renderFillRect(renderer: ptr Renderer; rect: ptr Rect): cint +renderFillRects sdl2/sdl2.html#renderFillRects,ptr.Renderer,ptr.Rect,cint sdl2: renderFillRects(renderer: ptr Renderer; rects: ptr Rect; count: cint): cint +renderCopy sdl2/sdl2.html#renderCopy,ptr.Renderer,ptr.Texture,ptr.Rect,ptr.Rect sdl2: renderCopy(renderer: ptr Renderer; texture: ptr Texture; srcrect: ptr Rect;\n dstrect: ptr Rect): cint +renderCopyEx sdl2/sdl2.html#renderCopyEx,ptr.Renderer,ptr.Texture,ptr.Rect,ptr.Rect,cdouble,ptr.Point,RendererFlip sdl2: renderCopyEx(renderer: ptr Renderer; texture: ptr Texture; srcrect: ptr Rect;\n dstrect: ptr Rect; angle: cdouble; center: ptr Point; flip: RendererFlip): cint +renderDrawPointF sdl2/sdl2.html#renderDrawPointF,ptr.Renderer,cfloat,cfloat sdl2: renderDrawPointF(renderer: ptr Renderer; x: cfloat; y: cfloat): cint +renderDrawPointsF sdl2/sdl2.html#renderDrawPointsF,ptr.Renderer,ptr.FPoint,cint sdl2: renderDrawPointsF(renderer: ptr Renderer; points: ptr FPoint; count: cint): cint +renderDrawLineF sdl2/sdl2.html#renderDrawLineF,ptr.Renderer,cfloat,cfloat,cfloat,cfloat sdl2: renderDrawLineF(renderer: ptr Renderer; x1: cfloat; y1: cfloat; x2: cfloat; y2: cfloat): cint +renderDrawLinesF sdl2/sdl2.html#renderDrawLinesF,ptr.Renderer,ptr.FPoint,cint sdl2: renderDrawLinesF(renderer: ptr Renderer; points: ptr FPoint; count: cint): cint +renderDrawRectF sdl2/sdl2.html#renderDrawRectF,ptr.Renderer,ptr.FRect sdl2: renderDrawRectF(renderer: ptr Renderer; rect: ptr FRect): cint +renderDrawRectsF sdl2/sdl2.html#renderDrawRectsF,ptr.Renderer,ptr.FRect,cint sdl2: renderDrawRectsF(renderer: ptr Renderer; rects: ptr FRect; count: cint): cint +renderFillRectF sdl2/sdl2.html#renderFillRectF,ptr.Renderer,ptr.FRect sdl2: renderFillRectF(renderer: ptr Renderer; rect: ptr FRect): cint +renderFillRectsF sdl2/sdl2.html#renderFillRectsF,ptr.Renderer,ptr.FRect,cint sdl2: renderFillRectsF(renderer: ptr Renderer; rects: ptr FRect; count: cint): cint +renderCopyF sdl2/sdl2.html#renderCopyF,ptr.Renderer,ptr.Texture,ptr.Rect,ptr.FRect sdl2: renderCopyF(renderer: ptr Renderer; texture: ptr Texture; srcrect: ptr Rect;\n dstrect: ptr FRect): cint +renderCopyExF sdl2/sdl2.html#renderCopyExF,ptr.Renderer,ptr.Texture,ptr.Rect,ptr.FRect,cdouble,ptr.FPoint,RendererFlip sdl2: renderCopyExF(renderer: ptr Renderer; texture: ptr Texture; srcrect: ptr Rect;\n dstrect: ptr FRect; angle: cdouble; center: ptr FPoint; flip: RendererFlip): cint +renderReadPixels sdl2/sdl2.html#renderReadPixels,ptr.Renderer,ptr.Rect,Uint32,pointer,cint sdl2: renderReadPixels(renderer: ptr Renderer; rect: ptr Rect; format: Uint32;\n pixels: pointer; pitch: cint): cint +renderPresent sdl2/sdl2.html#renderPresent,ptr.Renderer sdl2: renderPresent(renderer: ptr Renderer) +destroyTexture sdl2/sdl2.html#destroyTexture,ptr.Texture sdl2: destroyTexture(texture: ptr Texture) +destroyRenderer sdl2/sdl2.html#destroyRenderer,ptr.Renderer sdl2: destroyRenderer(renderer: ptr Renderer) +renderFlush sdl2/sdl2.html#renderFlush,ptr.Renderer sdl2: renderFlush(renderer: ptr Renderer): cint +gL_BindTexture sdl2/sdl2.html#gL_BindTexture,ptr.Texture,ptr.cfloat,ptr.cfloat sdl2: gL_BindTexture(texture: ptr Texture; texw: ptr cfloat; texh: ptr cfloat): cint +gL_UnbindTexture sdl2/sdl2.html#gL_UnbindTexture,ptr.Texture sdl2: gL_UnbindTexture(texture: ptr Texture): cint +renderGetMetalLayer sdl2/sdl2.html#renderGetMetalLayer,ptr.Renderer sdl2: renderGetMetalLayer(renderer: ptr Renderer): pointer +renderGetMetalCommandEncoder sdl2/sdl2.html#renderGetMetalCommandEncoder,ptr.Renderer sdl2: renderGetMetalCommandEncoder(renderer: ptr Renderer): pointer +numSensors sdl2/sdl2.html#numSensors sdl2: numSensors(): cint +sensorGetDeviceName sdl2/sdl2.html#sensorGetDeviceName,cint sdl2: sensorGetDeviceName(deviceIndex: cint): cstring +sensorGetDeviceType sdl2/sdl2.html#sensorGetDeviceType,cint sdl2: sensorGetDeviceType(deviceIndex: cint): SensorType +sensorGetDeviceNonPortableType sdl2/sdl2.html#sensorGetDeviceNonPortableType,cint sdl2: sensorGetDeviceNonPortableType(deviceIndex: cint): cint +sensorGetDeviceInstanceID sdl2/sdl2.html#sensorGetDeviceInstanceID,cint sdl2: sensorGetDeviceInstanceID(deviceIndex: cint): SensorID +sensorOpen sdl2/sdl2.html#sensorOpen,cint sdl2: sensorOpen(deviceIndex: cint): ptr Sensor +sensorFromInstanceID sdl2/sdl2.html#sensorFromInstanceID,SensorID sdl2: sensorFromInstanceID(instanceId: SensorID): ptr Sensor +sensorGetName sdl2/sdl2.html#sensorGetName,ptr.Sensor sdl2: sensorGetName(sensor: ptr Sensor): cstring +sensorGetType sdl2/sdl2.html#sensorGetType,ptr.Sensor sdl2: sensorGetType(sensor: ptr Sensor): SensorType +sensorGetNonPortableType sdl2/sdl2.html#sensorGetNonPortableType,ptr.Sensor sdl2: sensorGetNonPortableType(sensor: ptr Sensor): cint +sensorGetInstanceID sdl2/sdl2.html#sensorGetInstanceID,ptr.Sensor sdl2: sensorGetInstanceID(sensor: ptr Sensor): SensorID +sensorGetData sdl2/sdl2.html#sensorGetData,ptr.Sensor,ptr.cfloat,cint sdl2: sensorGetData(sensor: ptr Sensor; data: ptr cfloat; numValues: cint): cint +sensorClose sdl2/sdl2.html#sensorClose,ptr.Sensor sdl2: sensorClose(sensor: ptr Sensor) +sensorUpdate sdl2/sdl2.html#sensorUpdate sdl2: sensorUpdate() +createShapedWindow sdl2/sdl2.html#createShapedWindow,cstring,cuint,cuint,cuint,cuint,Uint32 sdl2: createShapedWindow(title: cstring; x: cuint; y: cuint; w: cuint; h: cuint; flags: Uint32): ptr Window +isShapedWindow sdl2/sdl2.html#isShapedWindow,ptr.Window sdl2: isShapedWindow(window: ptr Window): bool +setWindowShape sdl2/sdl2.html#setWindowShape,ptr.Window,ptr.Surface,ptr.WindowShapeMode sdl2: setWindowShape(window: ptr Window; shape: ptr Surface; shapeMode: ptr WindowShapeMode): cint +getShapedWindowMode sdl2/sdl2.html#getShapedWindowMode,ptr.Window,ptr.WindowShapeMode sdl2: getShapedWindowMode(window: ptr Window; shapeMode: ptr WindowShapeMode): cint +isTablet sdl2/sdl2.html#isTablet sdl2: isTablet(): bool +onApplicationWillTerminate sdl2/sdl2.html#onApplicationWillTerminate sdl2: onApplicationWillTerminate() +onApplicationDidReceiveMemoryWarning sdl2/sdl2.html#onApplicationDidReceiveMemoryWarning sdl2: onApplicationDidReceiveMemoryWarning() +onApplicationWillResignActive sdl2/sdl2.html#onApplicationWillResignActive sdl2: onApplicationWillResignActive() +onApplicationDidEnterBackground sdl2/sdl2.html#onApplicationDidEnterBackground sdl2: onApplicationDidEnterBackground() +onApplicationWillEnterForeground sdl2/sdl2.html#onApplicationWillEnterForeground sdl2: onApplicationWillEnterForeground() +onApplicationDidBecomeActive sdl2/sdl2.html#onApplicationDidBecomeActive sdl2: onApplicationDidBecomeActive() +getTicks sdl2/sdl2.html#getTicks sdl2: getTicks(): Uint32 +getPerformanceCounter sdl2/sdl2.html#getPerformanceCounter sdl2: getPerformanceCounter(): Uint64 +getPerformanceFrequency sdl2/sdl2.html#getPerformanceFrequency sdl2: getPerformanceFrequency(): Uint64 +delay sdl2/sdl2.html#delay,Uint32 sdl2: delay(ms: Uint32) +addTimer sdl2/sdl2.html#addTimer,Uint32,TimerCallback,pointer sdl2: addTimer(interval: Uint32; callback: TimerCallback; param: pointer): TimerID +removeTimer sdl2/sdl2.html#removeTimer,TimerID sdl2: removeTimer(id: TimerID): bool +getVersion sdl2/sdl2.html#getVersion,ptr.Version sdl2: getVersion(ver: ptr Version) +getRevision sdl2/sdl2.html#getRevision sdl2: getRevision(): cstring +getRevisionNumber sdl2/sdl2.html#getRevisionNumber sdl2: getRevisionNumber(): cint +init sdl2/sdl2.html#init,Uint32 sdl2: init(flags: Uint32): cint +initSubSystem sdl2/sdl2.html#initSubSystem,Uint32 sdl2: initSubSystem(flags: Uint32): cint +quitSubSystem sdl2/sdl2.html#quitSubSystem,Uint32 sdl2: quitSubSystem(flags: Uint32) +wasInit sdl2/sdl2.html#wasInit,Uint32 sdl2: wasInit(flags: Uint32): Uint32 +quit sdl2/sdl2.html#quit sdl2: quit() +SDLDyLibPath sdl2/sdl2.html#SDLDyLibPath sdl2: SDLDyLibPath +SDLMainLib sdl2/sdl2.html#SDLMainLib sdl2: SDLMainLib +SDLStaticLib sdl2/sdl2.html#SDLStaticLib sdl2: SDLStaticLib +WINDOWPOS_UNDEFINED sdl2/sdl2.html#WINDOWPOS_UNDEFINED sdl2: WINDOWPOS_UNDEFINED +WINDOWPOS_CENTERED sdl2/sdl2.html#WINDOWPOS_CENTERED sdl2: WINDOWPOS_CENTERED +SCANCODE_MASK sdl2/sdl2.html#SCANCODE_MASK sdl2: SCANCODE_MASK +BUTTON_LMASK sdl2/sdl2.html#BUTTON_LMASK sdl2: BUTTON_LMASK +BUTTON_MMASK sdl2/sdl2.html#BUTTON_MMASK sdl2: BUTTON_MMASK +BUTTON_RMASK sdl2/sdl2.html#BUTTON_RMASK sdl2: BUTTON_RMASK +BUTTON_X1MASK sdl2/sdl2.html#BUTTON_X1MASK sdl2: BUTTON_X1MASK +BUTTON_X2MASK sdl2/sdl2.html#BUTTON_X2MASK sdl2: BUTTON_X2MASK diff --git a/docs/sdl2/sdl2_gfx.html b/docs/sdl2/sdl2_gfx.html new file mode 100644 index 0000000..1cfd913 --- /dev/null +++ b/docs/sdl2/sdl2_gfx.html @@ -0,0 +1,1487 @@ + + + + + + + + + + + + + + + + + + +sdl2/sdl2_gfx + + + + + + + + +
+
+

sdl2/sdl2_gfx

+
+
+
+ +     Dark Mode +
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+ +

+
+

Imports

+
+sdl2 +
+
+

Types

+
+ +
FPSmanager {...}{.bycopy.} = object
+  framecount*: Uint32
+  rateticks*: cfloat
+  baseticks*: Uint32
+  lastticks*: Uint32
+  rate*: Uint32
+
+
+ +
!
+      \brief Structure holding the state and timing information of the framerate controller.
+ + +
+ +
+
+

Consts

+
+ +
SDL2gfxPrimitivesStd = false
+
+ + + +
+ +
SDL2gfxPrimitivesGit = false
+
+ + + +
+ +
SDL2gfxPrimitivesDL = true
+
+ + + +
+ +
SDL2gfxPrimitivesStatic = true
+
+ + + +
+ +
SDL2gfxPrimitivesSetVer = ""
+
+ + + +
+ +
SDL2gfxPrimitivesLPath = "/Users/joey/Projects/nim-sdl2/src/build/sdl2_gfx/.libs/libSDL2_gfx.a"
+
+ + + +
+ +
SDL2gfxPrimitivesPath = "/Users/joey/Projects/nim-sdl2/src/build/sdl2_gfx/SDL2_gfxPrimitives.h"
+
+ + + +
+ +
SDL2_GFXPRIMITIVES_MAJOR = 1
+
+ + + +
+ +
SDL2_GFXPRIMITIVES_MINOR = 0
+
+ + + +
+ +
SDL2_GFXPRIMITIVES_MICRO = 4
+
+ + + +
+ +
SMOOTHING_OFF = 0
+
+ + + +
+ +
SMOOTHING_ON = 1
+
+ + + +
+ +
FPS_UPPER_LIMIT = 200
+
+ + + +
+ +
FPS_LOWER_LIMIT = 1
+
+ + + +
+ +
FPS_DEFAULT = 30
+
+ + + +
+ +
+
+

Procs

+
+ +
proc pixelColor(renderer: ptr Renderer; x: Sint16; y: Sint16; color: Uint32): cint {...}{.
+    importc, cdecl.}
+
+ +
Note: all ___Color routines expect the color to be in format 0xRRGGBBAA
+Pixel
+ + +
+ +
proc pixelRGBA(renderer: ptr Renderer; x: Sint16; y: Sint16; r: Uint8; g: Uint8; b: Uint8;
+              a: Uint8): cint {...}{.importc, cdecl.}
+
+ + + +
+ +
proc hlineColor(renderer: ptr Renderer; x1: Sint16; x2: Sint16; y: Sint16; color: Uint32): cint {...}{.
+    importc, cdecl.}
+
+ +
Horizontal line
+ + +
+ +
proc hlineRGBA(renderer: ptr Renderer; x1: Sint16; x2: Sint16; y: Sint16; r: Uint8;
+              g: Uint8; b: Uint8; a: Uint8): cint {...}{.importc, cdecl.}
+
+ + + +
+ +
proc vlineColor(renderer: ptr Renderer; x: Sint16; y1: Sint16; y2: Sint16; color: Uint32): cint {...}{.
+    importc, cdecl.}
+
+ +
Vertical line
+ + +
+ +
proc vlineRGBA(renderer: ptr Renderer; x: Sint16; y1: Sint16; y2: Sint16; r: Uint8;
+              g: Uint8; b: Uint8; a: Uint8): cint {...}{.importc, cdecl.}
+
+ + + +
+ +
proc rectangleColor(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16;
+                   y2: Sint16; color: Uint32): cint {...}{.importc, cdecl.}
+
+ +
Rectangle
+ + +
+ +
proc rectangleRGBA(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;
+                  r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint {...}{.importc, cdecl.}
+
+ + + +
+ +
proc roundedRectangleColor(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16;
+                          y2: Sint16; rad: Sint16; color: Uint32): cint {...}{.importc, cdecl.}
+
+ +
Rounded-Corner Rectangle
+ + +
+ +
proc roundedRectangleRGBA(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16;
+                         y2: Sint16; rad: Sint16; r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint {...}{.
+    importc, cdecl.}
+
+ + + +
+ +
proc boxColor(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;
+             color: Uint32): cint {...}{.importc, cdecl.}
+
+ +
Filled rectangle (Box)
+ + +
+ +
proc boxRGBA(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;
+            r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint {...}{.importc, cdecl.}
+
+ + + +
+ +
proc roundedBoxColor(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16;
+                    y2: Sint16; rad: Sint16; color: Uint32): cint {...}{.importc, cdecl.}
+
+ +
Rounded-Corner Filled rectangle (Box)
+ + +
+ +
proc roundedBoxRGBA(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16;
+                   y2: Sint16; rad: Sint16; r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint {...}{.
+    importc, cdecl.}
+
+ + + +
+ +
proc lineColor(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;
+              color: Uint32): cint {...}{.importc, cdecl.}
+
+ +
Line
+ + +
+ +
proc lineRGBA(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;
+             r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint {...}{.importc, cdecl.}
+
+ + + +
+ +
proc aalineColor(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;
+                color: Uint32): cint {...}{.importc, cdecl.}
+
+ +
AA Line
+ + +
+ +
proc aalineRGBA(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;
+               r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint {...}{.importc, cdecl.}
+
+ + + +
+ +
proc thickLineColor(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16;
+                   y2: Sint16; width: Uint8; color: Uint32): cint {...}{.importc, cdecl.}
+
+ +
Thick Line
+ + +
+ +
proc thickLineRGBA(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;
+                  width: Uint8; r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint {...}{.importc,
+    cdecl.}
+
+ + + +
+ +
proc circleColor(renderer: ptr Renderer; x: Sint16; y: Sint16; rad: Sint16; color: Uint32): cint {...}{.
+    importc, cdecl.}
+
+ +
Circle
+ + +
+ +
proc circleRGBA(renderer: ptr Renderer; x: Sint16; y: Sint16; rad: Sint16; r: Uint8;
+               g: Uint8; b: Uint8; a: Uint8): cint {...}{.importc, cdecl.}
+
+ + + +
+ +
proc arcColor(renderer: ptr Renderer; x: Sint16; y: Sint16; rad: Sint16; start: Sint16;
+             `end`: Sint16; color: Uint32): cint {...}{.importc, cdecl.}
+
+ +
Arc
+ + +
+ +
proc arcRGBA(renderer: ptr Renderer; x: Sint16; y: Sint16; rad: Sint16; start: Sint16;
+            `end`: Sint16; r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint {...}{.importc, cdecl.}
+
+ + + +
+ +
proc aacircleColor(renderer: ptr Renderer; x: Sint16; y: Sint16; rad: Sint16;
+                  color: Uint32): cint {...}{.importc, cdecl.}
+
+ +
AA Circle
+ + +
+ +
proc aacircleRGBA(renderer: ptr Renderer; x: Sint16; y: Sint16; rad: Sint16; r: Uint8;
+                 g: Uint8; b: Uint8; a: Uint8): cint {...}{.importc, cdecl.}
+
+ + + +
+ +
proc filledCircleColor(renderer: ptr Renderer; x: Sint16; y: Sint16; r: Sint16;
+                      color: Uint32): cint {...}{.importc, cdecl.}
+
+ +
Filled Circle
+ + +
+ +
proc filledCircleRGBA(renderer: ptr Renderer; x: Sint16; y: Sint16; rad: Sint16; r: Uint8;
+                     g: Uint8; b: Uint8; a: Uint8): cint {...}{.importc, cdecl.}
+
+ + + +
+ +
proc ellipseColor(renderer: ptr Renderer; x: Sint16; y: Sint16; rx: Sint16; ry: Sint16;
+                 color: Uint32): cint {...}{.importc, cdecl.}
+
+ +
Ellipse
+ + +
+ +
proc ellipseRGBA(renderer: ptr Renderer; x: Sint16; y: Sint16; rx: Sint16; ry: Sint16;
+                r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint {...}{.importc, cdecl.}
+
+ + + +
+ +
proc aaellipseColor(renderer: ptr Renderer; x: Sint16; y: Sint16; rx: Sint16; ry: Sint16;
+                   color: Uint32): cint {...}{.importc, cdecl.}
+
+ +
AA Ellipse
+ + +
+ +
proc aaellipseRGBA(renderer: ptr Renderer; x: Sint16; y: Sint16; rx: Sint16; ry: Sint16;
+                  r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint {...}{.importc, cdecl.}
+
+ + + +
+ +
proc filledEllipseColor(renderer: ptr Renderer; x: Sint16; y: Sint16; rx: Sint16;
+                       ry: Sint16; color: Uint32): cint {...}{.importc, cdecl.}
+
+ +
Filled Ellipse
+ + +
+ +
proc filledEllipseRGBA(renderer: ptr Renderer; x: Sint16; y: Sint16; rx: Sint16;
+                      ry: Sint16; r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint {...}{.importc,
+    cdecl.}
+
+ + + +
+ +
proc pieColor(renderer: ptr Renderer; x: Sint16; y: Sint16; rad: Sint16; start: Sint16;
+             `end`: Sint16; color: Uint32): cint {...}{.importc, cdecl.}
+
+ +
Pie
+ + +
+ +
proc pieRGBA(renderer: ptr Renderer; x: Sint16; y: Sint16; rad: Sint16; start: Sint16;
+            `end`: Sint16; r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint {...}{.importc, cdecl.}
+
+ + + +
+ +
proc filledPieColor(renderer: ptr Renderer; x: Sint16; y: Sint16; rad: Sint16;
+                   start: Sint16; `end`: Sint16; color: Uint32): cint {...}{.importc, cdecl.}
+
+ +
Filled Pie
+ + +
+ +
proc filledPieRGBA(renderer: ptr Renderer; x: Sint16; y: Sint16; rad: Sint16;
+                  start: Sint16; `end`: Sint16; r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint {...}{.
+    importc, cdecl.}
+
+ + + +
+ +
proc trigonColor(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;
+                x3: Sint16; y3: Sint16; color: Uint32): cint {...}{.importc, cdecl.}
+
+ +
Trigon
+ + +
+ +
proc trigonRGBA(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;
+               x3: Sint16; y3: Sint16; r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint {...}{.
+    importc, cdecl.}
+
+ + + +
+ +
proc aatrigonColor(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;
+                  x3: Sint16; y3: Sint16; color: Uint32): cint {...}{.importc, cdecl.}
+
+ +
AA-Trigon
+ + +
+ +
proc aatrigonRGBA(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;
+                 x3: Sint16; y3: Sint16; r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint {...}{.
+    importc, cdecl.}
+
+ + + +
+ +
proc filledTrigonColor(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16;
+                      y2: Sint16; x3: Sint16; y3: Sint16; color: Uint32): cint {...}{.importc,
+    cdecl.}
+
+ +
Filled Trigon
+ + +
+ +
proc filledTrigonRGBA(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16;
+                     y2: Sint16; x3: Sint16; y3: Sint16; r: Uint8; g: Uint8; b: Uint8;
+                     a: Uint8): cint {...}{.importc, cdecl.}
+
+ + + +
+ +
proc polygonColor(renderer: ptr Renderer; vx: ptr Sint16; vy: ptr Sint16; n: cint;
+                 color: Uint32): cint {...}{.importc, cdecl.}
+
+ +
Polygon
+ + +
+ +
proc polygonRGBA(renderer: ptr Renderer; vx: ptr Sint16; vy: ptr Sint16; n: cint; r: Uint8;
+                g: Uint8; b: Uint8; a: Uint8): cint {...}{.importc, cdecl.}
+
+ + + +
+ +
proc aapolygonColor(renderer: ptr Renderer; vx: ptr Sint16; vy: ptr Sint16; n: cint;
+                   color: Uint32): cint {...}{.importc, cdecl.}
+
+ +
AA-Polygon
+ + +
+ +
proc aapolygonRGBA(renderer: ptr Renderer; vx: ptr Sint16; vy: ptr Sint16; n: cint;
+                  r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint {...}{.importc, cdecl.}
+
+ + + +
+ +
proc filledPolygonColor(renderer: ptr Renderer; vx: ptr Sint16; vy: ptr Sint16; n: cint;
+                       color: Uint32): cint {...}{.importc, cdecl.}
+
+ +
Filled Polygon
+ + +
+ +
proc filledPolygonRGBA(renderer: ptr Renderer; vx: ptr Sint16; vy: ptr Sint16; n: cint;
+                      r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint {...}{.importc, cdecl.}
+
+ + + +
+ +
proc texturedPolygon(renderer: ptr Renderer; vx: ptr Sint16; vy: ptr Sint16; n: cint;
+                    texture: ptr Surface; textureDx: cint; textureDy: cint): cint {...}{.
+    importc, cdecl.}
+
+ +
Textured Polygon
+ + +
+ +
proc bezierColor(renderer: ptr Renderer; vx: ptr Sint16; vy: ptr Sint16; n: cint; s: cint;
+                color: Uint32): cint {...}{.importc, cdecl.}
+
+ +
Bezier
+ + +
+ +
proc bezierRGBA(renderer: ptr Renderer; vx: ptr Sint16; vy: ptr Sint16; n: cint; s: cint;
+               r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint {...}{.importc, cdecl.}
+
+ + + +
+ +
proc gfxPrimitivesSetFont(fontdata: pointer; cw: Uint32; ch: Uint32) {...}{.importc, cdecl.}
+
+ +
Characters/Strings
+ + +
+ +
proc gfxPrimitivesSetFontRotation(rotation: Uint32) {...}{.importc, cdecl.}
+
+ + + +
+ +
proc characterColor(renderer: ptr Renderer; x: Sint16; y: Sint16; c: cchar; color: Uint32): cint {...}{.
+    importc, cdecl.}
+
+ + + +
+ +
proc characterRGBA(renderer: ptr Renderer; x: Sint16; y: Sint16; c: cchar; r: Uint8;
+                  g: Uint8; b: Uint8; a: Uint8): cint {...}{.importc, cdecl.}
+
+ + + +
+ +
proc stringColor(renderer: ptr Renderer; x: Sint16; y: Sint16; s: cstring; color: Uint32): cint {...}{.
+    importc, cdecl.}
+
+ + + +
+ +
proc stringRGBA(renderer: ptr Renderer; x: Sint16; y: Sint16; s: cstring; r: Uint8;
+               g: Uint8; b: Uint8; a: Uint8): cint {...}{.importc, cdecl.}
+
+ + + +
+ +
proc rotozoomSurface(src: ptr Surface; angle: cdouble; zoom: cdouble; smooth: cint): ptr Surface {...}{.
+    importc, cdecl.}
+
+ +
Rotozoom functions
+ + +
+ +
proc rotozoomSurfaceXY(src: ptr Surface; angle: cdouble; zoomx: cdouble; zoomy: cdouble;
+                      smooth: cint): ptr Surface {...}{.importc, cdecl.}
+
+ + + +
+ +
proc rotozoomSurfaceSize(width: cint; height: cint; angle: cdouble; zoom: cdouble;
+                        dstwidth: ptr cint; dstheight: ptr cint) {...}{.importc, cdecl.}
+
+ + + +
+ +
proc rotozoomSurfaceSizeXY(width: cint; height: cint; angle: cdouble; zoomx: cdouble;
+                          zoomy: cdouble; dstwidth: ptr cint; dstheight: ptr cint) {...}{.
+    importc, cdecl.}
+
+ + + +
+ +
proc zoomSurface(src: ptr Surface; zoomx: cdouble; zoomy: cdouble; smooth: cint): ptr Surface {...}{.
+    importc, cdecl.}
+
+ +
Zooming functions
+ + +
+ +
proc zoomSurfaceSize(width: cint; height: cint; zoomx: cdouble; zoomy: cdouble;
+                    dstwidth: ptr cint; dstheight: ptr cint) {...}{.importc, cdecl.}
+
+ + + +
+ +
proc shrinkSurface(src: ptr Surface; factorx: cint; factory: cint): ptr Surface {...}{.importc,
+    cdecl.}
+
+ +
Shrinking functions
+ + +
+ +
proc rotateSurface90Degrees(src: ptr Surface; numClockwiseTurns: cint): ptr Surface {...}{.
+    importc, cdecl.}
+
+ +
Specialized rotation functions
+ + +
+ +
proc initFramerate(manager: ptr FPSmanager) {...}{.importc: "SDL_initFramerate", cdecl.}
+
+ +
Functions return 0 or value for sucess and -1 for error
+ + +
+ +
proc setFramerate(manager: ptr FPSmanager; rate: Uint32): cint {...}{.
+    importc: "SDL_setFramerate", cdecl.}
+
+ + + +
+ +
proc getFramerate(manager: ptr FPSmanager): cint {...}{.importc: "SDL_getFramerate", cdecl.}
+
+ + + +
+ +
proc getFramecount(manager: ptr FPSmanager): cint {...}{.importc: "SDL_getFramecount", cdecl.}
+
+ + + +
+ +
proc framerateDelay(manager: ptr FPSmanager): Uint32 {...}{.importc: "SDL_framerateDelay",
+    cdecl.}
+
+ + + +
+ +
proc imageFilterMMXdetect(): cint {...}{.importc: "SDL_imageFilterMMXdetect", cdecl.}
+
+ +
Comments:
+1.) MMX functions work best if all data blocks are aligned on a 32 bytes boundary.
+2.) Data that is not within an 8 byte boundary is processed using the C routine.
+3.) Convolution routines do not have C routines at this time.
+Detect MMX capability in CPU
+ + +
+ +
proc imageFilterMMXoff() {...}{.importc: "SDL_imageFilterMMXoff", cdecl.}
+
+ +
Force use of MMX off (or turn possible use back on)
+ + +
+ +
proc imageFilterMMXon() {...}{.importc: "SDL_imageFilterMMXon", cdecl.}
+
+ + + +
+ +
proc imageFilterAdd(Src1: ptr cuchar; Src2: ptr cuchar; Dest: ptr cuchar; length: cuint): cint {...}{.
+    importc: "SDL_imageFilterAdd", cdecl.}
+
+ +
+All routines return:
+0   OK
+-1   Error (internal error, parameter error)
+
+SDL_imageFilterAdd: D = saturation255(S1 + S2)
+ + +
+ +
proc imageFilterMean(Src1: ptr cuchar; Src2: ptr cuchar; Dest: ptr cuchar; length: cuint): cint {...}{.
+    importc: "SDL_imageFilterMean", cdecl.}
+
+ +
SDL_imageFilterMean: D = S1/2 + S2/2
+ + +
+ +
proc imageFilterSub(Src1: ptr cuchar; Src2: ptr cuchar; Dest: ptr cuchar; length: cuint): cint {...}{.
+    importc: "SDL_imageFilterSub", cdecl.}
+
+ +
SDL_imageFilterSub: D = saturation0(S1 - S2)
+ + +
+ +
proc imageFilterAbsDiff(Src1: ptr cuchar; Src2: ptr cuchar; Dest: ptr cuchar;
+                       length: cuint): cint {...}{.importc: "SDL_imageFilterAbsDiff",
+    cdecl.}
+
+ +
SDL_imageFilterAbsDiff: D = | S1 - S2 |
+ + +
+ +
proc imageFilterMult(Src1: ptr cuchar; Src2: ptr cuchar; Dest: ptr cuchar; length: cuint): cint {...}{.
+    importc: "SDL_imageFilterMult", cdecl.}
+
+ +
SDL_imageFilterMult: D = saturation(S1 S2)
+ + +
+ +
proc imageFilterMultNor(Src1: ptr cuchar; Src2: ptr cuchar; Dest: ptr cuchar;
+                       length: cuint): cint {...}{.importc: "SDL_imageFilterMultNor",
+    cdecl.}
+
+ +
SDL_imageFilterMultNor: D = S1 S2   (non-MMX)
+ + +
+ +
proc imageFilterMultDivby2(Src1: ptr cuchar; Src2: ptr cuchar; Dest: ptr cuchar;
+                          length: cuint): cint {...}{.
+    importc: "SDL_imageFilterMultDivby2", cdecl.}
+
+ +
SDL_imageFilterMultDivby2: D = saturation255(S1/2 S2)
+ + +
+ +
proc imageFilterMultDivby4(Src1: ptr cuchar; Src2: ptr cuchar; Dest: ptr cuchar;
+                          length: cuint): cint {...}{.
+    importc: "SDL_imageFilterMultDivby4", cdecl.}
+
+ +
SDL_imageFilterMultDivby4: D = saturation255(S1/2 S2/2)
+ + +
+ +
proc imageFilterBitAnd(Src1: ptr cuchar; Src2: ptr cuchar; Dest: ptr cuchar; length: cuint): cint {...}{.
+    importc: "SDL_imageFilterBitAnd", cdecl.}
+
+ +
SDL_imageFilterBitAnd: D = S1 & S2
+ + +
+ +
proc imageFilterBitOr(Src1: ptr cuchar; Src2: ptr cuchar; Dest: ptr cuchar; length: cuint): cint {...}{.
+    importc: "SDL_imageFilterBitOr", cdecl.}
+
+ +
SDL_imageFilterBitOr: D = S1 | S2
+ + +
+ +
proc imageFilterDiv(Src1: ptr cuchar; Src2: ptr cuchar; Dest: ptr cuchar; length: cuint): cint {...}{.
+    importc: "SDL_imageFilterDiv", cdecl.}
+
+ +
SDL_imageFilterDiv: D = S1 / S2   (non-MMX)
+ + +
+ +
proc imageFilterBitNegation(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint): cint {...}{.
+    importc: "SDL_imageFilterBitNegation", cdecl.}
+
+ +
SDL_imageFilterBitNegation: D = !S
+ + +
+ +
proc imageFilterAddByte(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint; C: cuchar): cint {...}{.
+    importc: "SDL_imageFilterAddByte", cdecl.}
+
+ +
SDL_imageFilterAddByte: D = saturation255(S + C)
+ + +
+ +
proc imageFilterAddUint(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint; C: cuint): cint {...}{.
+    importc: "SDL_imageFilterAddUint", cdecl.}
+
+ +
SDL_imageFilterAddUint: D = saturation255(S + (uint)C)
+ + +
+ +
proc imageFilterAddByteToHalf(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint;
+                             C: cuchar): cint {...}{.
+    importc: "SDL_imageFilterAddByteToHalf", cdecl.}
+
+ +
SDL_imageFilterAddByteToHalf: D = saturation255(S/2 + C)
+ + +
+ +
proc imageFilterSubByte(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint; C: cuchar): cint {...}{.
+    importc: "SDL_imageFilterSubByte", cdecl.}
+
+ +
SDL_imageFilterSubByte: D = saturation0(S - C)
+ + +
+ +
proc imageFilterSubUint(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint; C: cuint): cint {...}{.
+    importc: "SDL_imageFilterSubUint", cdecl.}
+
+ +
SDL_imageFilterSubUint: D = saturation0(S - (uint)C)
+ + +
+ +
proc imageFilterShiftRight(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint; N: cuchar): cint {...}{.
+    importc: "SDL_imageFilterShiftRight", cdecl.}
+
+ +
SDL_imageFilterShiftRight: D = saturation0(S >> N)
+ + +
+ +
proc imageFilterShiftRightUint(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint;
+                              N: cuchar): cint {...}{.
+    importc: "SDL_imageFilterShiftRightUint", cdecl.}
+
+ +
SDL_imageFilterShiftRightUint: D = saturation0((uint)S >> N)
+ + +
+ +
proc imageFilterMultByByte(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint; C: cuchar): cint {...}{.
+    importc: "SDL_imageFilterMultByByte", cdecl.}
+
+ +
SDL_imageFilterMultByByte: D = saturation255(S C)
+ + +
+ +
proc imageFilterShiftRightAndMultByByte(Src1: ptr cuchar; Dest: ptr cuchar;
+                                       length: cuint; N: cuchar; C: cuchar): cint {...}{.
+    importc: "SDL_imageFilterShiftRightAndMultByByte", cdecl.}
+
+ +
SDL_imageFilterShiftRightAndMultByByte: D = saturation255((S >> N) C)
+ + +
+ +
proc imageFilterShiftLeftByte(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint;
+                             N: cuchar): cint {...}{.
+    importc: "SDL_imageFilterShiftLeftByte", cdecl.}
+
+ +
SDL_imageFilterShiftLeftByte: D = (S << N)
+ + +
+ +
proc imageFilterShiftLeftUint(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint;
+                             N: cuchar): cint {...}{.
+    importc: "SDL_imageFilterShiftLeftUint", cdecl.}
+
+ +
SDL_imageFilterShiftLeftUint: D = ((uint)S << N)
+ + +
+ +
proc imageFilterShiftLeft(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint; N: cuchar): cint {...}{.
+    importc: "SDL_imageFilterShiftLeft", cdecl.}
+
+ +
SDL_imageFilterShiftLeft: D = saturation255(S << N)
+ + +
+ +
proc imageFilterBinarizeUsingThreshold(Src1: ptr cuchar; Dest: ptr cuchar;
+                                      length: cuint; T: cuchar): cint {...}{.
+    importc: "SDL_imageFilterBinarizeUsingThreshold", cdecl.}
+
+ +
SDL_imageFilterBinarizeUsingThreshold: D = S >= T ? 255:0
+ + +
+ +
proc imageFilterClipToRange(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint;
+                           Tmin: cuchar; Tmax: cuchar): cint {...}{.
+    importc: "SDL_imageFilterClipToRange", cdecl.}
+
+ +
SDL_imageFilterClipToRange: D = (S >= Tmin) & (S <= Tmax) 255:0
+ + +
+ +
proc imageFilterNormalizeLinear(Src: ptr cuchar; Dest: ptr cuchar; length: cuint;
+                               Cmin: cint; Cmax: cint; Nmin: cint; Nmax: cint): cint {...}{.
+    importc: "SDL_imageFilterNormalizeLinear", cdecl.}
+
+ +
SDL_imageFilterNormalizeLinear: D = saturation255((Nmax - Nmin)/(Cmax - Cmin)(S - Cmin) + Nmin)
+ + +
+ +
+ +
+
+ +
+ +
+
+
+ + + diff --git a/docs/sdl2/sdl2_gfx.idx b/docs/sdl2/sdl2_gfx.idx new file mode 100644 index 0000000..99df66e --- /dev/null +++ b/docs/sdl2/sdl2_gfx.idx @@ -0,0 +1,118 @@ +SDL2gfxPrimitivesStd sdl2/sdl2_gfx.html#SDL2gfxPrimitivesStd sdl2_gfx: SDL2gfxPrimitivesStd +SDL2gfxPrimitivesGit sdl2/sdl2_gfx.html#SDL2gfxPrimitivesGit sdl2_gfx: SDL2gfxPrimitivesGit +SDL2gfxPrimitivesDL sdl2/sdl2_gfx.html#SDL2gfxPrimitivesDL sdl2_gfx: SDL2gfxPrimitivesDL +SDL2gfxPrimitivesStatic sdl2/sdl2_gfx.html#SDL2gfxPrimitivesStatic sdl2_gfx: SDL2gfxPrimitivesStatic +SDL2gfxPrimitivesSetVer sdl2/sdl2_gfx.html#SDL2gfxPrimitivesSetVer sdl2_gfx: SDL2gfxPrimitivesSetVer +SDL2gfxPrimitivesLPath sdl2/sdl2_gfx.html#SDL2gfxPrimitivesLPath sdl2_gfx: SDL2gfxPrimitivesLPath +SDL2gfxPrimitivesPath sdl2/sdl2_gfx.html#SDL2gfxPrimitivesPath sdl2_gfx: SDL2gfxPrimitivesPath +SDL2_GFXPRIMITIVES_MAJOR sdl2/sdl2_gfx.html#SDL2_GFXPRIMITIVES_MAJOR sdl2_gfx: SDL2_GFXPRIMITIVES_MAJOR +SDL2_GFXPRIMITIVES_MINOR sdl2/sdl2_gfx.html#SDL2_GFXPRIMITIVES_MINOR sdl2_gfx: SDL2_GFXPRIMITIVES_MINOR +SDL2_GFXPRIMITIVES_MICRO sdl2/sdl2_gfx.html#SDL2_GFXPRIMITIVES_MICRO sdl2_gfx: SDL2_GFXPRIMITIVES_MICRO +pixelColor sdl2/sdl2_gfx.html#pixelColor,ptr.Renderer,Sint16,Sint16,Uint32 sdl2_gfx: pixelColor(renderer: ptr Renderer; x: Sint16; y: Sint16; color: Uint32): cint +pixelRGBA sdl2/sdl2_gfx.html#pixelRGBA,ptr.Renderer,Sint16,Sint16,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: pixelRGBA(renderer: ptr Renderer; x: Sint16; y: Sint16; r: Uint8; g: Uint8; b: Uint8;\n a: Uint8): cint +hlineColor sdl2/sdl2_gfx.html#hlineColor,ptr.Renderer,Sint16,Sint16,Sint16,Uint32 sdl2_gfx: hlineColor(renderer: ptr Renderer; x1: Sint16; x2: Sint16; y: Sint16; color: Uint32): cint +hlineRGBA sdl2/sdl2_gfx.html#hlineRGBA,ptr.Renderer,Sint16,Sint16,Sint16,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: hlineRGBA(renderer: ptr Renderer; x1: Sint16; x2: Sint16; y: Sint16; r: Uint8; g: Uint8;\n b: Uint8; a: Uint8): cint +vlineColor sdl2/sdl2_gfx.html#vlineColor,ptr.Renderer,Sint16,Sint16,Sint16,Uint32 sdl2_gfx: vlineColor(renderer: ptr Renderer; x: Sint16; y1: Sint16; y2: Sint16; color: Uint32): cint +vlineRGBA sdl2/sdl2_gfx.html#vlineRGBA,ptr.Renderer,Sint16,Sint16,Sint16,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: vlineRGBA(renderer: ptr Renderer; x: Sint16; y1: Sint16; y2: Sint16; r: Uint8; g: Uint8;\n b: Uint8; a: Uint8): cint +rectangleColor sdl2/sdl2_gfx.html#rectangleColor,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Uint32 sdl2_gfx: rectangleColor(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;\n color: Uint32): cint +rectangleRGBA sdl2/sdl2_gfx.html#rectangleRGBA,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: rectangleRGBA(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;\n r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint +roundedRectangleColor sdl2/sdl2_gfx.html#roundedRectangleColor,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Sint16,Uint32 sdl2_gfx: roundedRectangleColor(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16;\n y2: Sint16; rad: Sint16; color: Uint32): cint +roundedRectangleRGBA sdl2/sdl2_gfx.html#roundedRectangleRGBA,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Sint16,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: roundedRectangleRGBA(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16;\n y2: Sint16; rad: Sint16; r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint +boxColor sdl2/sdl2_gfx.html#boxColor,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Uint32 sdl2_gfx: boxColor(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;\n color: Uint32): cint +boxRGBA sdl2/sdl2_gfx.html#boxRGBA,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: boxRGBA(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16; r: Uint8;\n g: Uint8; b: Uint8; a: Uint8): cint +roundedBoxColor sdl2/sdl2_gfx.html#roundedBoxColor,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Sint16,Uint32 sdl2_gfx: roundedBoxColor(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;\n rad: Sint16; color: Uint32): cint +roundedBoxRGBA sdl2/sdl2_gfx.html#roundedBoxRGBA,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Sint16,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: roundedBoxRGBA(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;\n rad: Sint16; r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint +lineColor sdl2/sdl2_gfx.html#lineColor,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Uint32 sdl2_gfx: lineColor(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;\n color: Uint32): cint +lineRGBA sdl2/sdl2_gfx.html#lineRGBA,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: lineRGBA(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16; r: Uint8;\n g: Uint8; b: Uint8; a: Uint8): cint +aalineColor sdl2/sdl2_gfx.html#aalineColor,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Uint32 sdl2_gfx: aalineColor(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;\n color: Uint32): cint +aalineRGBA sdl2/sdl2_gfx.html#aalineRGBA,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: aalineRGBA(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;\n r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint +thickLineColor sdl2/sdl2_gfx.html#thickLineColor,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Uint8,Uint32 sdl2_gfx: thickLineColor(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;\n width: Uint8; color: Uint32): cint +thickLineRGBA sdl2/sdl2_gfx.html#thickLineRGBA,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Uint8,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: thickLineRGBA(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;\n width: Uint8; r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint +circleColor sdl2/sdl2_gfx.html#circleColor,ptr.Renderer,Sint16,Sint16,Sint16,Uint32 sdl2_gfx: circleColor(renderer: ptr Renderer; x: Sint16; y: Sint16; rad: Sint16; color: Uint32): cint +circleRGBA sdl2/sdl2_gfx.html#circleRGBA,ptr.Renderer,Sint16,Sint16,Sint16,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: circleRGBA(renderer: ptr Renderer; x: Sint16; y: Sint16; rad: Sint16; r: Uint8; g: Uint8;\n b: Uint8; a: Uint8): cint +arcColor sdl2/sdl2_gfx.html#arcColor,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Sint16,Uint32 sdl2_gfx: arcColor(renderer: ptr Renderer; x: Sint16; y: Sint16; rad: Sint16; start: Sint16;\n `end`: Sint16; color: Uint32): cint +arcRGBA sdl2/sdl2_gfx.html#arcRGBA,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Sint16,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: arcRGBA(renderer: ptr Renderer; x: Sint16; y: Sint16; rad: Sint16; start: Sint16;\n `end`: Sint16; r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint +aacircleColor sdl2/sdl2_gfx.html#aacircleColor,ptr.Renderer,Sint16,Sint16,Sint16,Uint32 sdl2_gfx: aacircleColor(renderer: ptr Renderer; x: Sint16; y: Sint16; rad: Sint16; color: Uint32): cint +aacircleRGBA sdl2/sdl2_gfx.html#aacircleRGBA,ptr.Renderer,Sint16,Sint16,Sint16,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: aacircleRGBA(renderer: ptr Renderer; x: Sint16; y: Sint16; rad: Sint16; r: Uint8; g: Uint8;\n b: Uint8; a: Uint8): cint +filledCircleColor sdl2/sdl2_gfx.html#filledCircleColor,ptr.Renderer,Sint16,Sint16,Sint16,Uint32 sdl2_gfx: filledCircleColor(renderer: ptr Renderer; x: Sint16; y: Sint16; r: Sint16; color: Uint32): cint +filledCircleRGBA sdl2/sdl2_gfx.html#filledCircleRGBA,ptr.Renderer,Sint16,Sint16,Sint16,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: filledCircleRGBA(renderer: ptr Renderer; x: Sint16; y: Sint16; rad: Sint16; r: Uint8;\n g: Uint8; b: Uint8; a: Uint8): cint +ellipseColor sdl2/sdl2_gfx.html#ellipseColor,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Uint32 sdl2_gfx: ellipseColor(renderer: ptr Renderer; x: Sint16; y: Sint16; rx: Sint16; ry: Sint16;\n color: Uint32): cint +ellipseRGBA sdl2/sdl2_gfx.html#ellipseRGBA,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: ellipseRGBA(renderer: ptr Renderer; x: Sint16; y: Sint16; rx: Sint16; ry: Sint16; r: Uint8;\n g: Uint8; b: Uint8; a: Uint8): cint +aaellipseColor sdl2/sdl2_gfx.html#aaellipseColor,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Uint32 sdl2_gfx: aaellipseColor(renderer: ptr Renderer; x: Sint16; y: Sint16; rx: Sint16; ry: Sint16;\n color: Uint32): cint +aaellipseRGBA sdl2/sdl2_gfx.html#aaellipseRGBA,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: aaellipseRGBA(renderer: ptr Renderer; x: Sint16; y: Sint16; rx: Sint16; ry: Sint16;\n r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint +filledEllipseColor sdl2/sdl2_gfx.html#filledEllipseColor,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Uint32 sdl2_gfx: filledEllipseColor(renderer: ptr Renderer; x: Sint16; y: Sint16; rx: Sint16; ry: Sint16;\n color: Uint32): cint +filledEllipseRGBA sdl2/sdl2_gfx.html#filledEllipseRGBA,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: filledEllipseRGBA(renderer: ptr Renderer; x: Sint16; y: Sint16; rx: Sint16; ry: Sint16;\n r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint +pieColor sdl2/sdl2_gfx.html#pieColor,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Sint16,Uint32 sdl2_gfx: pieColor(renderer: ptr Renderer; x: Sint16; y: Sint16; rad: Sint16; start: Sint16;\n `end`: Sint16; color: Uint32): cint +pieRGBA sdl2/sdl2_gfx.html#pieRGBA,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Sint16,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: pieRGBA(renderer: ptr Renderer; x: Sint16; y: Sint16; rad: Sint16; start: Sint16;\n `end`: Sint16; r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint +filledPieColor sdl2/sdl2_gfx.html#filledPieColor,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Sint16,Uint32 sdl2_gfx: filledPieColor(renderer: ptr Renderer; x: Sint16; y: Sint16; rad: Sint16; start: Sint16;\n `end`: Sint16; color: Uint32): cint +filledPieRGBA sdl2/sdl2_gfx.html#filledPieRGBA,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Sint16,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: filledPieRGBA(renderer: ptr Renderer; x: Sint16; y: Sint16; rad: Sint16; start: Sint16;\n `end`: Sint16; r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint +trigonColor sdl2/sdl2_gfx.html#trigonColor,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Sint16,Sint16,Uint32 sdl2_gfx: trigonColor(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;\n x3: Sint16; y3: Sint16; color: Uint32): cint +trigonRGBA sdl2/sdl2_gfx.html#trigonRGBA,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Sint16,Sint16,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: trigonRGBA(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;\n x3: Sint16; y3: Sint16; r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint +aatrigonColor sdl2/sdl2_gfx.html#aatrigonColor,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Sint16,Sint16,Uint32 sdl2_gfx: aatrigonColor(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;\n x3: Sint16; y3: Sint16; color: Uint32): cint +aatrigonRGBA sdl2/sdl2_gfx.html#aatrigonRGBA,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Sint16,Sint16,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: aatrigonRGBA(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;\n x3: Sint16; y3: Sint16; r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint +filledTrigonColor sdl2/sdl2_gfx.html#filledTrigonColor,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Sint16,Sint16,Uint32 sdl2_gfx: filledTrigonColor(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;\n x3: Sint16; y3: Sint16; color: Uint32): cint +filledTrigonRGBA sdl2/sdl2_gfx.html#filledTrigonRGBA,ptr.Renderer,Sint16,Sint16,Sint16,Sint16,Sint16,Sint16,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: filledTrigonRGBA(renderer: ptr Renderer; x1: Sint16; y1: Sint16; x2: Sint16; y2: Sint16;\n x3: Sint16; y3: Sint16; r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint +polygonColor sdl2/sdl2_gfx.html#polygonColor,ptr.Renderer,ptr.Sint16,ptr.Sint16,cint,Uint32 sdl2_gfx: polygonColor(renderer: ptr Renderer; vx: ptr Sint16; vy: ptr Sint16; n: cint; color: Uint32): cint +polygonRGBA sdl2/sdl2_gfx.html#polygonRGBA,ptr.Renderer,ptr.Sint16,ptr.Sint16,cint,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: polygonRGBA(renderer: ptr Renderer; vx: ptr Sint16; vy: ptr Sint16; n: cint; r: Uint8;\n g: Uint8; b: Uint8; a: Uint8): cint +aapolygonColor sdl2/sdl2_gfx.html#aapolygonColor,ptr.Renderer,ptr.Sint16,ptr.Sint16,cint,Uint32 sdl2_gfx: aapolygonColor(renderer: ptr Renderer; vx: ptr Sint16; vy: ptr Sint16; n: cint;\n color: Uint32): cint +aapolygonRGBA sdl2/sdl2_gfx.html#aapolygonRGBA,ptr.Renderer,ptr.Sint16,ptr.Sint16,cint,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: aapolygonRGBA(renderer: ptr Renderer; vx: ptr Sint16; vy: ptr Sint16; n: cint; r: Uint8;\n g: Uint8; b: Uint8; a: Uint8): cint +filledPolygonColor sdl2/sdl2_gfx.html#filledPolygonColor,ptr.Renderer,ptr.Sint16,ptr.Sint16,cint,Uint32 sdl2_gfx: filledPolygonColor(renderer: ptr Renderer; vx: ptr Sint16; vy: ptr Sint16; n: cint;\n color: Uint32): cint +filledPolygonRGBA sdl2/sdl2_gfx.html#filledPolygonRGBA,ptr.Renderer,ptr.Sint16,ptr.Sint16,cint,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: filledPolygonRGBA(renderer: ptr Renderer; vx: ptr Sint16; vy: ptr Sint16; n: cint;\n r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint +texturedPolygon sdl2/sdl2_gfx.html#texturedPolygon,ptr.Renderer,ptr.Sint16,ptr.Sint16,cint,ptr.Surface,cint,cint sdl2_gfx: texturedPolygon(renderer: ptr Renderer; vx: ptr Sint16; vy: ptr Sint16; n: cint;\n texture: ptr Surface; textureDx: cint; textureDy: cint): cint +bezierColor sdl2/sdl2_gfx.html#bezierColor,ptr.Renderer,ptr.Sint16,ptr.Sint16,cint,cint,Uint32 sdl2_gfx: bezierColor(renderer: ptr Renderer; vx: ptr Sint16; vy: ptr Sint16; n: cint; s: cint;\n color: Uint32): cint +bezierRGBA sdl2/sdl2_gfx.html#bezierRGBA,ptr.Renderer,ptr.Sint16,ptr.Sint16,cint,cint,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: bezierRGBA(renderer: ptr Renderer; vx: ptr Sint16; vy: ptr Sint16; n: cint; s: cint;\n r: Uint8; g: Uint8; b: Uint8; a: Uint8): cint +gfxPrimitivesSetFont sdl2/sdl2_gfx.html#gfxPrimitivesSetFont,pointer,Uint32,Uint32 sdl2_gfx: gfxPrimitivesSetFont(fontdata: pointer; cw: Uint32; ch: Uint32) +gfxPrimitivesSetFontRotation sdl2/sdl2_gfx.html#gfxPrimitivesSetFontRotation,Uint32 sdl2_gfx: gfxPrimitivesSetFontRotation(rotation: Uint32) +characterColor sdl2/sdl2_gfx.html#characterColor,ptr.Renderer,Sint16,Sint16,cchar,Uint32 sdl2_gfx: characterColor(renderer: ptr Renderer; x: Sint16; y: Sint16; c: cchar; color: Uint32): cint +characterRGBA sdl2/sdl2_gfx.html#characterRGBA,ptr.Renderer,Sint16,Sint16,cchar,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: characterRGBA(renderer: ptr Renderer; x: Sint16; y: Sint16; c: cchar; r: Uint8; g: Uint8;\n b: Uint8; a: Uint8): cint +stringColor sdl2/sdl2_gfx.html#stringColor,ptr.Renderer,Sint16,Sint16,cstring,Uint32 sdl2_gfx: stringColor(renderer: ptr Renderer; x: Sint16; y: Sint16; s: cstring; color: Uint32): cint +stringRGBA sdl2/sdl2_gfx.html#stringRGBA,ptr.Renderer,Sint16,Sint16,cstring,Uint8,Uint8,Uint8,Uint8 sdl2_gfx: stringRGBA(renderer: ptr Renderer; x: Sint16; y: Sint16; s: cstring; r: Uint8; g: Uint8;\n b: Uint8; a: Uint8): cint +SMOOTHING_OFF sdl2/sdl2_gfx.html#SMOOTHING_OFF sdl2_gfx: SMOOTHING_OFF +SMOOTHING_ON sdl2/sdl2_gfx.html#SMOOTHING_ON sdl2_gfx: SMOOTHING_ON +rotozoomSurface sdl2/sdl2_gfx.html#rotozoomSurface,ptr.Surface,cdouble,cdouble,cint sdl2_gfx: rotozoomSurface(src: ptr Surface; angle: cdouble; zoom: cdouble; smooth: cint): ptr Surface +rotozoomSurfaceXY sdl2/sdl2_gfx.html#rotozoomSurfaceXY,ptr.Surface,cdouble,cdouble,cdouble,cint sdl2_gfx: rotozoomSurfaceXY(src: ptr Surface; angle: cdouble; zoomx: cdouble; zoomy: cdouble;\n smooth: cint): ptr Surface +rotozoomSurfaceSize sdl2/sdl2_gfx.html#rotozoomSurfaceSize,cint,cint,cdouble,cdouble,ptr.cint,ptr.cint sdl2_gfx: rotozoomSurfaceSize(width: cint; height: cint; angle: cdouble; zoom: cdouble;\n dstwidth: ptr cint; dstheight: ptr cint) +rotozoomSurfaceSizeXY sdl2/sdl2_gfx.html#rotozoomSurfaceSizeXY,cint,cint,cdouble,cdouble,cdouble,ptr.cint,ptr.cint sdl2_gfx: rotozoomSurfaceSizeXY(width: cint; height: cint; angle: cdouble; zoomx: cdouble;\n zoomy: cdouble; dstwidth: ptr cint; dstheight: ptr cint) +zoomSurface sdl2/sdl2_gfx.html#zoomSurface,ptr.Surface,cdouble,cdouble,cint sdl2_gfx: zoomSurface(src: ptr Surface; zoomx: cdouble; zoomy: cdouble; smooth: cint): ptr Surface +zoomSurfaceSize sdl2/sdl2_gfx.html#zoomSurfaceSize,cint,cint,cdouble,cdouble,ptr.cint,ptr.cint sdl2_gfx: zoomSurfaceSize(width: cint; height: cint; zoomx: cdouble; zoomy: cdouble;\n dstwidth: ptr cint; dstheight: ptr cint) +shrinkSurface sdl2/sdl2_gfx.html#shrinkSurface,ptr.Surface,cint,cint sdl2_gfx: shrinkSurface(src: ptr Surface; factorx: cint; factory: cint): ptr Surface +rotateSurface90Degrees sdl2/sdl2_gfx.html#rotateSurface90Degrees,ptr.Surface,cint sdl2_gfx: rotateSurface90Degrees(src: ptr Surface; numClockwiseTurns: cint): ptr Surface +FPS_UPPER_LIMIT sdl2/sdl2_gfx.html#FPS_UPPER_LIMIT sdl2_gfx: FPS_UPPER_LIMIT +FPS_LOWER_LIMIT sdl2/sdl2_gfx.html#FPS_LOWER_LIMIT sdl2_gfx: FPS_LOWER_LIMIT +FPS_DEFAULT sdl2/sdl2_gfx.html#FPS_DEFAULT sdl2_gfx: FPS_DEFAULT +FPSmanager sdl2/sdl2_gfx.html#FPSmanager sdl2_gfx: FPSmanager +initFramerate sdl2/sdl2_gfx.html#initFramerate,ptr.FPSmanager sdl2_gfx: initFramerate(manager: ptr FPSmanager) +setFramerate sdl2/sdl2_gfx.html#setFramerate,ptr.FPSmanager,Uint32 sdl2_gfx: setFramerate(manager: ptr FPSmanager; rate: Uint32): cint +getFramerate sdl2/sdl2_gfx.html#getFramerate,ptr.FPSmanager sdl2_gfx: getFramerate(manager: ptr FPSmanager): cint +getFramecount sdl2/sdl2_gfx.html#getFramecount,ptr.FPSmanager sdl2_gfx: getFramecount(manager: ptr FPSmanager): cint +framerateDelay sdl2/sdl2_gfx.html#framerateDelay,ptr.FPSmanager sdl2_gfx: framerateDelay(manager: ptr FPSmanager): Uint32 +imageFilterMMXdetect sdl2/sdl2_gfx.html#imageFilterMMXdetect sdl2_gfx: imageFilterMMXdetect(): cint +imageFilterMMXoff sdl2/sdl2_gfx.html#imageFilterMMXoff sdl2_gfx: imageFilterMMXoff() +imageFilterMMXon sdl2/sdl2_gfx.html#imageFilterMMXon sdl2_gfx: imageFilterMMXon() +imageFilterAdd sdl2/sdl2_gfx.html#imageFilterAdd,ptr.cuchar,ptr.cuchar,ptr.cuchar,cuint sdl2_gfx: imageFilterAdd(Src1: ptr cuchar; Src2: ptr cuchar; Dest: ptr cuchar; length: cuint): cint +imageFilterMean sdl2/sdl2_gfx.html#imageFilterMean,ptr.cuchar,ptr.cuchar,ptr.cuchar,cuint sdl2_gfx: imageFilterMean(Src1: ptr cuchar; Src2: ptr cuchar; Dest: ptr cuchar; length: cuint): cint +imageFilterSub sdl2/sdl2_gfx.html#imageFilterSub,ptr.cuchar,ptr.cuchar,ptr.cuchar,cuint sdl2_gfx: imageFilterSub(Src1: ptr cuchar; Src2: ptr cuchar; Dest: ptr cuchar; length: cuint): cint +imageFilterAbsDiff sdl2/sdl2_gfx.html#imageFilterAbsDiff,ptr.cuchar,ptr.cuchar,ptr.cuchar,cuint sdl2_gfx: imageFilterAbsDiff(Src1: ptr cuchar; Src2: ptr cuchar; Dest: ptr cuchar; length: cuint): cint +imageFilterMult sdl2/sdl2_gfx.html#imageFilterMult,ptr.cuchar,ptr.cuchar,ptr.cuchar,cuint sdl2_gfx: imageFilterMult(Src1: ptr cuchar; Src2: ptr cuchar; Dest: ptr cuchar; length: cuint): cint +imageFilterMultNor sdl2/sdl2_gfx.html#imageFilterMultNor,ptr.cuchar,ptr.cuchar,ptr.cuchar,cuint sdl2_gfx: imageFilterMultNor(Src1: ptr cuchar; Src2: ptr cuchar; Dest: ptr cuchar; length: cuint): cint +imageFilterMultDivby2 sdl2/sdl2_gfx.html#imageFilterMultDivby2,ptr.cuchar,ptr.cuchar,ptr.cuchar,cuint sdl2_gfx: imageFilterMultDivby2(Src1: ptr cuchar; Src2: ptr cuchar; Dest: ptr cuchar; length: cuint): cint +imageFilterMultDivby4 sdl2/sdl2_gfx.html#imageFilterMultDivby4,ptr.cuchar,ptr.cuchar,ptr.cuchar,cuint sdl2_gfx: imageFilterMultDivby4(Src1: ptr cuchar; Src2: ptr cuchar; Dest: ptr cuchar; length: cuint): cint +imageFilterBitAnd sdl2/sdl2_gfx.html#imageFilterBitAnd,ptr.cuchar,ptr.cuchar,ptr.cuchar,cuint sdl2_gfx: imageFilterBitAnd(Src1: ptr cuchar; Src2: ptr cuchar; Dest: ptr cuchar; length: cuint): cint +imageFilterBitOr sdl2/sdl2_gfx.html#imageFilterBitOr,ptr.cuchar,ptr.cuchar,ptr.cuchar,cuint sdl2_gfx: imageFilterBitOr(Src1: ptr cuchar; Src2: ptr cuchar; Dest: ptr cuchar; length: cuint): cint +imageFilterDiv sdl2/sdl2_gfx.html#imageFilterDiv,ptr.cuchar,ptr.cuchar,ptr.cuchar,cuint sdl2_gfx: imageFilterDiv(Src1: ptr cuchar; Src2: ptr cuchar; Dest: ptr cuchar; length: cuint): cint +imageFilterBitNegation sdl2/sdl2_gfx.html#imageFilterBitNegation,ptr.cuchar,ptr.cuchar,cuint sdl2_gfx: imageFilterBitNegation(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint): cint +imageFilterAddByte sdl2/sdl2_gfx.html#imageFilterAddByte,ptr.cuchar,ptr.cuchar,cuint,cuchar sdl2_gfx: imageFilterAddByte(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint; C: cuchar): cint +imageFilterAddUint sdl2/sdl2_gfx.html#imageFilterAddUint,ptr.cuchar,ptr.cuchar,cuint,cuint sdl2_gfx: imageFilterAddUint(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint; C: cuint): cint +imageFilterAddByteToHalf sdl2/sdl2_gfx.html#imageFilterAddByteToHalf,ptr.cuchar,ptr.cuchar,cuint,cuchar sdl2_gfx: imageFilterAddByteToHalf(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint; C: cuchar): cint +imageFilterSubByte sdl2/sdl2_gfx.html#imageFilterSubByte,ptr.cuchar,ptr.cuchar,cuint,cuchar sdl2_gfx: imageFilterSubByte(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint; C: cuchar): cint +imageFilterSubUint sdl2/sdl2_gfx.html#imageFilterSubUint,ptr.cuchar,ptr.cuchar,cuint,cuint sdl2_gfx: imageFilterSubUint(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint; C: cuint): cint +imageFilterShiftRight sdl2/sdl2_gfx.html#imageFilterShiftRight,ptr.cuchar,ptr.cuchar,cuint,cuchar sdl2_gfx: imageFilterShiftRight(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint; N: cuchar): cint +imageFilterShiftRightUint sdl2/sdl2_gfx.html#imageFilterShiftRightUint,ptr.cuchar,ptr.cuchar,cuint,cuchar sdl2_gfx: imageFilterShiftRightUint(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint; N: cuchar): cint +imageFilterMultByByte sdl2/sdl2_gfx.html#imageFilterMultByByte,ptr.cuchar,ptr.cuchar,cuint,cuchar sdl2_gfx: imageFilterMultByByte(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint; C: cuchar): cint +imageFilterShiftRightAndMultByByte sdl2/sdl2_gfx.html#imageFilterShiftRightAndMultByByte,ptr.cuchar,ptr.cuchar,cuint,cuchar,cuchar sdl2_gfx: imageFilterShiftRightAndMultByByte(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint;\n N: cuchar; C: cuchar): cint +imageFilterShiftLeftByte sdl2/sdl2_gfx.html#imageFilterShiftLeftByte,ptr.cuchar,ptr.cuchar,cuint,cuchar sdl2_gfx: imageFilterShiftLeftByte(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint; N: cuchar): cint +imageFilterShiftLeftUint sdl2/sdl2_gfx.html#imageFilterShiftLeftUint,ptr.cuchar,ptr.cuchar,cuint,cuchar sdl2_gfx: imageFilterShiftLeftUint(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint; N: cuchar): cint +imageFilterShiftLeft sdl2/sdl2_gfx.html#imageFilterShiftLeft,ptr.cuchar,ptr.cuchar,cuint,cuchar sdl2_gfx: imageFilterShiftLeft(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint; N: cuchar): cint +imageFilterBinarizeUsingThreshold sdl2/sdl2_gfx.html#imageFilterBinarizeUsingThreshold,ptr.cuchar,ptr.cuchar,cuint,cuchar sdl2_gfx: imageFilterBinarizeUsingThreshold(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint;\n T: cuchar): cint +imageFilterClipToRange sdl2/sdl2_gfx.html#imageFilterClipToRange,ptr.cuchar,ptr.cuchar,cuint,cuchar,cuchar sdl2_gfx: imageFilterClipToRange(Src1: ptr cuchar; Dest: ptr cuchar; length: cuint; Tmin: cuchar;\n Tmax: cuchar): cint +imageFilterNormalizeLinear sdl2/sdl2_gfx.html#imageFilterNormalizeLinear,ptr.cuchar,ptr.cuchar,cuint,cint,cint,cint,cint sdl2_gfx: imageFilterNormalizeLinear(Src: ptr cuchar; Dest: ptr cuchar; length: cuint; Cmin: cint;\n Cmax: cint; Nmin: cint; Nmax: cint): cint diff --git a/docs/sdl2/sdl2_image.html b/docs/sdl2/sdl2_image.html new file mode 100644 index 0000000..f316412 --- /dev/null +++ b/docs/sdl2/sdl2_image.html @@ -0,0 +1,761 @@ + + + + + + + + + + + + + + + + + + +sdl2/sdl2_image + + + + + + + + +
+
+

sdl2/sdl2_image

+
+ +
+
+ +

+
+

Imports

+
+sdl2 +
+
+

Types

+
+ +
InitFlags = distinct cint
+
+ + + +
+ +
+
+

Consts

+
+ +
SDLimageStd = false
+
+ + + +
+ +
SDLimageGit = false
+
+ + + +
+ +
SDLimageDL = true
+
+ + + +
+ +
SDLimageStatic = true
+
+ + + +
+ +
SDLimageSetVer = ""
+
+ + + +
+ +
SDLimageLPath = "/Users/joey/Projects/nim-sdl2/src/build/sdl2_image/.libs/libSDL2_image.a"
+
+ + + +
+ +
SDLimagePath = "/Users/joey/Projects/nim-sdl2/src/build/sdl2_image/SDL_image.h"
+
+ + + +
+ +
SetError = ""
+
+ + + +
+ +
GetError = ""
+
+ + + +
+ +
ClearError = ""
+
+ + + +
+ +
IMAGE_MAJOR_VERSION = 2
+
+ + + +
+ +
IMAGE_MINOR_VERSION = 0
+
+ + + +
+ +
IMAGE_PATCHLEVEL = 5
+
+ + + +
+ +
INIT_JPG = 1'i32
+
+ + + +
+ +
INIT_PNG = 2'i32
+
+ + + +
+ +
INIT_TIF = 4'i32
+
+ + + +
+ +
INIT_WEBP = 8'i32
+
+ + + +
+ +
+
+

Procs

+
+ +
proc linked_Version(): ptr Version {...}{.importc: "IMG_Linked_Version", cdecl.}
+
+ +
This function gets the version of the dynamically linked SDL_image library.
+   it should NOT be used to fill a version structure, instead you should
+   use the SDL_IMAGE_VERSION() macro.
+ + +
+ +
proc init(flags: cint): cint {...}{.importc: "IMG_Init", cdecl.}
+
+ +
Loads dynamic libraries and prepares them for use.  Flags should be
+   one or more flags from IMG_InitFlags OR'd together.
+   It returns the flags successfully initialized, or 0 on failure.
+ + +
+ +
proc quit() {...}{.importc: "IMG_Quit", cdecl.}
+
+ +
Unloads libraries loaded with IMG_Init
+ + +
+ +
proc loadTyped_RW(src: ptr RWops; freesrc: cint; kind: cstring): ptr Surface {...}{.
+    importc: "IMG_LoadTyped_RW", cdecl.}
+
+ +
Load an image from an SDL data source.
+   The 'type' may be one of: "BMP", "GIF", "PNG", etc.
+   If the image format supports a transparent pixel, SDL will set the
+   colorkey for the surface.  You can enable RLE acceleration on the
+   surface afterwards by calling:
+    SDL_SetColorKey(image, SDL_RLEACCEL, image->format->colorkey);
+ + +
+ +
proc load(file: cstring): ptr Surface {...}{.importc: "IMG_Load", cdecl.}
+
+ +
Convenience functions
+ + +
+ +
proc load_RW(src: ptr RWops; freesrc: cint): ptr Surface {...}{.importc: "IMG_Load_RW", cdecl.}
+
+ + + +
+ +
proc loadTexture(renderer: ptr Renderer; file: cstring): ptr Texture {...}{.
+    importc: "IMG_LoadTexture", cdecl.}
+
+ +
Load an image directly into a render texture.
+ + +
+ +
proc loadTexture_RW(renderer: ptr Renderer; src: ptr RWops; freesrc: cint): ptr Texture {...}{.
+    importc: "IMG_LoadTexture_RW", cdecl.}
+
+ + + +
+ +
proc loadTextureTyped_RW(renderer: ptr Renderer; src: ptr RWops; freesrc: cint;
+                        kind: cstring): ptr Texture {...}{.
+    importc: "IMG_LoadTextureTyped_RW", cdecl.}
+
+ + + +
+ +
proc isICO(src: ptr RWops): cint {...}{.importc: "IMG_isICO", cdecl.}
+
+ +
Functions to detect a file type, given a seekable source
+ + +
+ +
proc isCUR(src: ptr RWops): cint {...}{.importc: "IMG_isCUR", cdecl.}
+
+ + + +
+ +
proc isBMP(src: ptr RWops): cint {...}{.importc: "IMG_isBMP", cdecl.}
+
+ + + +
+ +
proc isGIF(src: ptr RWops): cint {...}{.importc: "IMG_isGIF", cdecl.}
+
+ + + +
+ +
proc isJPG(src: ptr RWops): cint {...}{.importc: "IMG_isJPG", cdecl.}
+
+ + + +
+ +
proc isLBM(src: ptr RWops): cint {...}{.importc: "IMG_isLBM", cdecl.}
+
+ + + +
+ +
proc isPCX(src: ptr RWops): cint {...}{.importc: "IMG_isPCX", cdecl.}
+
+ + + +
+ +
proc isPNG(src: ptr RWops): cint {...}{.importc: "IMG_isPNG", cdecl.}
+
+ + + +
+ +
proc isPNM(src: ptr RWops): cint {...}{.importc: "IMG_isPNM", cdecl.}
+
+ + + +
+ +
proc isSVG(src: ptr RWops): cint {...}{.importc: "IMG_isSVG", cdecl.}
+
+ + + +
+ +
proc isTIF(src: ptr RWops): cint {...}{.importc: "IMG_isTIF", cdecl.}
+
+ + + +
+ +
proc isXCF(src: ptr RWops): cint {...}{.importc: "IMG_isXCF", cdecl.}
+
+ + + +
+ +
proc isXPM(src: ptr RWops): cint {...}{.importc: "IMG_isXPM", cdecl.}
+
+ + + +
+ +
proc isXV(src: ptr RWops): cint {...}{.importc: "IMG_isXV", cdecl.}
+
+ + + +
+ +
proc isWEBP(src: ptr RWops): cint {...}{.importc: "IMG_isWEBP", cdecl.}
+
+ + + +
+ +
proc loadICO_RW(src: ptr RWops): ptr Surface {...}{.importc: "IMG_LoadICO_RW", cdecl.}
+
+ +
Individual loading functions
+ + +
+ +
proc loadCUR_RW(src: ptr RWops): ptr Surface {...}{.importc: "IMG_LoadCUR_RW", cdecl.}
+
+ + + +
+ +
proc loadBMP_RW(src: ptr RWops): ptr Surface {...}{.importc: "IMG_LoadBMP_RW", cdecl.}
+
+ + + +
+ +
proc loadGIF_RW(src: ptr RWops): ptr Surface {...}{.importc: "IMG_LoadGIF_RW", cdecl.}
+
+ + + +
+ +
proc loadJPG_RW(src: ptr RWops): ptr Surface {...}{.importc: "IMG_LoadJPG_RW", cdecl.}
+
+ + + +
+ +
proc loadLBM_RW(src: ptr RWops): ptr Surface {...}{.importc: "IMG_LoadLBM_RW", cdecl.}
+
+ + + +
+ +
proc loadPCX_RW(src: ptr RWops): ptr Surface {...}{.importc: "IMG_LoadPCX_RW", cdecl.}
+
+ + + +
+ +
proc loadPNG_RW(src: ptr RWops): ptr Surface {...}{.importc: "IMG_LoadPNG_RW", cdecl.}
+
+ + + +
+ +
proc loadPNM_RW(src: ptr RWops): ptr Surface {...}{.importc: "IMG_LoadPNM_RW", cdecl.}
+
+ + + +
+ +
proc loadSVG_RW(src: ptr RWops): ptr Surface {...}{.importc: "IMG_LoadSVG_RW", cdecl.}
+
+ + + +
+ +
proc loadTGA_RW(src: ptr RWops): ptr Surface {...}{.importc: "IMG_LoadTGA_RW", cdecl.}
+
+ + + +
+ +
proc loadTIF_RW(src: ptr RWops): ptr Surface {...}{.importc: "IMG_LoadTIF_RW", cdecl.}
+
+ + + +
+ +
proc loadXCF_RW(src: ptr RWops): ptr Surface {...}{.importc: "IMG_LoadXCF_RW", cdecl.}
+
+ + + +
+ +
proc loadXPM_RW(src: ptr RWops): ptr Surface {...}{.importc: "IMG_LoadXPM_RW", cdecl.}
+
+ + + +
+ +
proc loadXV_RW(src: ptr RWops): ptr Surface {...}{.importc: "IMG_LoadXV_RW", cdecl.}
+
+ + + +
+ +
proc loadWEBP_RW(src: ptr RWops): ptr Surface {...}{.importc: "IMG_LoadWEBP_RW", cdecl.}
+
+ + + +
+ +
proc readXPMFromArray(xpm: ptr cstring): ptr Surface {...}{.
+    importc: "IMG_ReadXPMFromArray", cdecl.}
+
+ + + +
+ +
proc savePNG(surface: ptr Surface; file: cstring): cint {...}{.importc: "IMG_SavePNG", cdecl.}
+
+ +
Individual saving functions
+ + +
+ +
proc savePNG_RW(surface: ptr Surface; dst: ptr RWops; freedst: cint): cint {...}{.
+    importc: "IMG_SavePNG_RW", cdecl.}
+
+ + + +
+ +
proc saveJPG(surface: ptr Surface; file: cstring; quality: cint): cint {...}{.
+    importc: "IMG_SaveJPG", cdecl.}
+
+ + + +
+ +
proc saveJPG_RW(surface: ptr Surface; dst: ptr RWops; freedst: cint; quality: cint): cint {...}{.
+    importc: "IMG_SaveJPG_RW", cdecl.}
+
+ + + +
+ +
+ +
+
+ +
+ +
+
+
+ + + diff --git a/docs/sdl2/sdl2_image.idx b/docs/sdl2/sdl2_image.idx new file mode 100644 index 0000000..1ab7db5 --- /dev/null +++ b/docs/sdl2/sdl2_image.idx @@ -0,0 +1,63 @@ +SDLimageStd sdl2/sdl2_image.html#SDLimageStd sdl2_image: SDLimageStd +SDLimageGit sdl2/sdl2_image.html#SDLimageGit sdl2_image: SDLimageGit +SDLimageDL sdl2/sdl2_image.html#SDLimageDL sdl2_image: SDLimageDL +SDLimageStatic sdl2/sdl2_image.html#SDLimageStatic sdl2_image: SDLimageStatic +SDLimageSetVer sdl2/sdl2_image.html#SDLimageSetVer sdl2_image: SDLimageSetVer +SDLimageLPath sdl2/sdl2_image.html#SDLimageLPath sdl2_image: SDLimageLPath +SDLimagePath sdl2/sdl2_image.html#SDLimagePath sdl2_image: SDLimagePath +InitFlags sdl2/sdl2_image.html#InitFlags sdl2_image: InitFlags +SetError sdl2/sdl2_image.html#SetError sdl2_image: SetError +GetError sdl2/sdl2_image.html#GetError sdl2_image: GetError +ClearError sdl2/sdl2_image.html#ClearError sdl2_image: ClearError +IMAGE_MAJOR_VERSION sdl2/sdl2_image.html#IMAGE_MAJOR_VERSION sdl2_image: IMAGE_MAJOR_VERSION +IMAGE_MINOR_VERSION sdl2/sdl2_image.html#IMAGE_MINOR_VERSION sdl2_image: IMAGE_MINOR_VERSION +IMAGE_PATCHLEVEL sdl2/sdl2_image.html#IMAGE_PATCHLEVEL sdl2_image: IMAGE_PATCHLEVEL +INIT_JPG sdl2/sdl2_image.html#INIT_JPG sdl2_image: INIT_JPG +INIT_PNG sdl2/sdl2_image.html#INIT_PNG sdl2_image: INIT_PNG +INIT_TIF sdl2/sdl2_image.html#INIT_TIF sdl2_image: INIT_TIF +INIT_WEBP sdl2/sdl2_image.html#INIT_WEBP sdl2_image: INIT_WEBP +linked_Version sdl2/sdl2_image.html#linked_Version sdl2_image: linked_Version(): ptr Version +init sdl2/sdl2_image.html#init,cint sdl2_image: init(flags: cint): cint +quit sdl2/sdl2_image.html#quit sdl2_image: quit() +loadTyped_RW sdl2/sdl2_image.html#loadTyped_RW,ptr.RWops,cint,cstring sdl2_image: loadTyped_RW(src: ptr RWops; freesrc: cint; kind: cstring): ptr Surface +load sdl2/sdl2_image.html#load,cstring sdl2_image: load(file: cstring): ptr Surface +load_RW sdl2/sdl2_image.html#load_RW,ptr.RWops,cint sdl2_image: load_RW(src: ptr RWops; freesrc: cint): ptr Surface +loadTexture sdl2/sdl2_image.html#loadTexture,ptr.Renderer,cstring sdl2_image: loadTexture(renderer: ptr Renderer; file: cstring): ptr Texture +loadTexture_RW sdl2/sdl2_image.html#loadTexture_RW,ptr.Renderer,ptr.RWops,cint sdl2_image: loadTexture_RW(renderer: ptr Renderer; src: ptr RWops; freesrc: cint): ptr Texture +loadTextureTyped_RW sdl2/sdl2_image.html#loadTextureTyped_RW,ptr.Renderer,ptr.RWops,cint,cstring sdl2_image: loadTextureTyped_RW(renderer: ptr Renderer; src: ptr RWops; freesrc: cint; kind: cstring): ptr Texture +isICO sdl2/sdl2_image.html#isICO,ptr.RWops sdl2_image: isICO(src: ptr RWops): cint +isCUR sdl2/sdl2_image.html#isCUR,ptr.RWops sdl2_image: isCUR(src: ptr RWops): cint +isBMP sdl2/sdl2_image.html#isBMP,ptr.RWops sdl2_image: isBMP(src: ptr RWops): cint +isGIF sdl2/sdl2_image.html#isGIF,ptr.RWops sdl2_image: isGIF(src: ptr RWops): cint +isJPG sdl2/sdl2_image.html#isJPG,ptr.RWops sdl2_image: isJPG(src: ptr RWops): cint +isLBM sdl2/sdl2_image.html#isLBM,ptr.RWops sdl2_image: isLBM(src: ptr RWops): cint +isPCX sdl2/sdl2_image.html#isPCX,ptr.RWops sdl2_image: isPCX(src: ptr RWops): cint +isPNG sdl2/sdl2_image.html#isPNG,ptr.RWops sdl2_image: isPNG(src: ptr RWops): cint +isPNM sdl2/sdl2_image.html#isPNM,ptr.RWops sdl2_image: isPNM(src: ptr RWops): cint +isSVG sdl2/sdl2_image.html#isSVG,ptr.RWops sdl2_image: isSVG(src: ptr RWops): cint +isTIF sdl2/sdl2_image.html#isTIF,ptr.RWops sdl2_image: isTIF(src: ptr RWops): cint +isXCF sdl2/sdl2_image.html#isXCF,ptr.RWops sdl2_image: isXCF(src: ptr RWops): cint +isXPM sdl2/sdl2_image.html#isXPM,ptr.RWops sdl2_image: isXPM(src: ptr RWops): cint +isXV sdl2/sdl2_image.html#isXV,ptr.RWops sdl2_image: isXV(src: ptr RWops): cint +isWEBP sdl2/sdl2_image.html#isWEBP,ptr.RWops sdl2_image: isWEBP(src: ptr RWops): cint +loadICO_RW sdl2/sdl2_image.html#loadICO_RW,ptr.RWops sdl2_image: loadICO_RW(src: ptr RWops): ptr Surface +loadCUR_RW sdl2/sdl2_image.html#loadCUR_RW,ptr.RWops sdl2_image: loadCUR_RW(src: ptr RWops): ptr Surface +loadBMP_RW sdl2/sdl2_image.html#loadBMP_RW,ptr.RWops sdl2_image: loadBMP_RW(src: ptr RWops): ptr Surface +loadGIF_RW sdl2/sdl2_image.html#loadGIF_RW,ptr.RWops sdl2_image: loadGIF_RW(src: ptr RWops): ptr Surface +loadJPG_RW sdl2/sdl2_image.html#loadJPG_RW,ptr.RWops sdl2_image: loadJPG_RW(src: ptr RWops): ptr Surface +loadLBM_RW sdl2/sdl2_image.html#loadLBM_RW,ptr.RWops sdl2_image: loadLBM_RW(src: ptr RWops): ptr Surface +loadPCX_RW sdl2/sdl2_image.html#loadPCX_RW,ptr.RWops sdl2_image: loadPCX_RW(src: ptr RWops): ptr Surface +loadPNG_RW sdl2/sdl2_image.html#loadPNG_RW,ptr.RWops sdl2_image: loadPNG_RW(src: ptr RWops): ptr Surface +loadPNM_RW sdl2/sdl2_image.html#loadPNM_RW,ptr.RWops sdl2_image: loadPNM_RW(src: ptr RWops): ptr Surface +loadSVG_RW sdl2/sdl2_image.html#loadSVG_RW,ptr.RWops sdl2_image: loadSVG_RW(src: ptr RWops): ptr Surface +loadTGA_RW sdl2/sdl2_image.html#loadTGA_RW,ptr.RWops sdl2_image: loadTGA_RW(src: ptr RWops): ptr Surface +loadTIF_RW sdl2/sdl2_image.html#loadTIF_RW,ptr.RWops sdl2_image: loadTIF_RW(src: ptr RWops): ptr Surface +loadXCF_RW sdl2/sdl2_image.html#loadXCF_RW,ptr.RWops sdl2_image: loadXCF_RW(src: ptr RWops): ptr Surface +loadXPM_RW sdl2/sdl2_image.html#loadXPM_RW,ptr.RWops sdl2_image: loadXPM_RW(src: ptr RWops): ptr Surface +loadXV_RW sdl2/sdl2_image.html#loadXV_RW,ptr.RWops sdl2_image: loadXV_RW(src: ptr RWops): ptr Surface +loadWEBP_RW sdl2/sdl2_image.html#loadWEBP_RW,ptr.RWops sdl2_image: loadWEBP_RW(src: ptr RWops): ptr Surface +readXPMFromArray sdl2/sdl2_image.html#readXPMFromArray,ptr.cstring sdl2_image: readXPMFromArray(xpm: ptr cstring): ptr Surface +savePNG sdl2/sdl2_image.html#savePNG,ptr.Surface,cstring sdl2_image: savePNG(surface: ptr Surface; file: cstring): cint +savePNG_RW sdl2/sdl2_image.html#savePNG_RW,ptr.Surface,ptr.RWops,cint sdl2_image: savePNG_RW(surface: ptr Surface; dst: ptr RWops; freedst: cint): cint +saveJPG sdl2/sdl2_image.html#saveJPG,ptr.Surface,cstring,cint sdl2_image: saveJPG(surface: ptr Surface; file: cstring; quality: cint): cint +saveJPG_RW sdl2/sdl2_image.html#saveJPG_RW,ptr.Surface,ptr.RWops,cint,cint sdl2_image: saveJPG_RW(surface: ptr Surface; dst: ptr RWops; freedst: cint; quality: cint): cint diff --git a/docs/sdl2/sdl2_mixer.html b/docs/sdl2/sdl2_mixer.html new file mode 100644 index 0000000..1b19afe --- /dev/null +++ b/docs/sdl2/sdl2_mixer.html @@ -0,0 +1,1601 @@ + + + + + + + + + + + + + + + + + + +sdl2/sdl2_mixer + + + + + + + + +
+
+

sdl2/sdl2_mixer

+
+
+
+ +     Dark Mode +
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+ +

+
+

Imports

+
+sdl2 +
+
+

Types

+
+ +
MIX_InitFlags = distinct cint
+
+ + + +
+ +
Fading = distinct cint
+
+ + + +
+ +
MusicType = distinct cint
+
+ + + +
+ +
Chunk {...}{.bycopy.} = object
+  allocated*: cint
+  abuf*: ptr Uint8
+  alen*: Uint32
+  volume*: Uint8               ## ::
+               ##   Per-sample volume, 0-128
+  
+
+ +
The internal format for an audio chunk
+ + +
+ +
Music {...}{.incompleteStruct.} = object
+
+ + + +
+ +
EffectFunc_t = proc (chan: cint; stream: pointer; len: cint; udata: pointer) {...}{.cdecl.}
+
+ + + +
+ +
EffectDone_t = proc (chan: cint; udata: pointer) {...}{.cdecl.}
+
+ + + +
+ +
+
+

Consts

+
+ +
SDLmixerStd = false
+
+ + + +
+ +
SDLmixerGit = false
+
+ + + +
+ +
SDLmixerDL = true
+
+ + + +
+ +
SDLmixerStatic = true
+
+ + + +
+ +
SDLmixerSetVer = ""
+
+ + + +
+ +
SDLmixerLPath = "/Users/joey/Projects/nim-sdl2/src/build/sdl2_mixer/build/.libs/libSDL2_mixer.a"
+
+ + + +
+ +
SDLmixerPath = "/Users/joey/Projects/nim-sdl2/src/build/sdl2_mixer/SDL_mixer.h"
+
+ + + +
+ +
SetError = ""
+
+ + + +
+ +
GetError = ""
+
+ + + +
+ +
ClearError = ""
+
+ + + +
+ +
MIXER_MAJOR_VERSION = 2
+
+ + + +
+ +
MIXER_MINOR_VERSION = 0
+
+ + + +
+ +
MIXER_PATCHLEVEL = 4
+
+ + + +
+ +
MIX_MAJOR_VERSION = 2
+
+ + + +
+ +
MIX_MINOR_VERSION = 0
+
+ + + +
+ +
MIX_PATCHLEVEL = 4
+
+ + + +
+ +
MIX_INIT_FLAC = 1'i32
+
+ + + +
+ +
MIX_INIT_MOD = 2'i32
+
+ + + +
+ +
MIX_INIT_MP3 = 8'i32
+
+ + + +
+ +
MIX_INIT_OGG = 16'i32
+
+ + + +
+ +
MIX_INIT_MID = 32'i32
+
+ + + +
+ +
MIX_INIT_OPUS = 64'i32
+
+ + + +
+ +
MIX_CHANNELS = 8
+
+ + + +
+ +
MIX_DEFAULT_FREQUENCY = 22050
+
+ + + +
+ +
MIX_DEFAULT_CHANNELS = 2
+
+ + + +
+ +
MIX_NO_FADING = 0'i32
+
+ + + +
+ +
MIX_FADING_OUT = 1
+
+ + + +
+ +
MIX_FADING_IN = 2
+
+ + + +
+ +
MUS_NONE = 0'i32
+
+ + + +
+ +
MUS_CMD = 1
+
+ + + +
+ +
MUS_WAV = 2
+
+ + + +
+ +
MUS_MOD = 3
+
+ + + +
+ +
MUS_MID = 4
+
+ + + +
+ +
MUS_OGG = 5
+
+ + + +
+ +
MUS_MP3 = 6
+
+ + + +
+ +
MUS_MP3_MAD_UNUSED = 7
+
+ + + +
+ +
MUS_FLAC = 8
+
+ + + +
+ +
MUS_MODPLUG_UNUSED = 9
+
+ + + +
+ +
MUS_OPUS = 10
+
+ + + +
+ +
MIX_CHANNEL_POST = -2
+
+ + + +
+ +
MIX_EFFECTSMAXSPEED = "MIX_EFFECTSMAXSPEED"
+
+ + + +
+ +
+
+

Procs

+
+ +
proc linked_Version(): ptr Version {...}{.importc: "Mix_Linked_Version", cdecl.}
+
+ +
This function gets the version of the dynamically linked SDL_mixer library.
+   it should NOT be used to fill a version structure, instead you should
+   use the SDL_MIXER_VERSION() macro.
+ + +
+ +
proc init(flags: cint): cint {...}{.importc: "Mix_Init", cdecl.}
+
+ +
Loads dynamic libraries and prepares them for use.  Flags should be
+   one or more flags from MIX_InitFlags OR'd together.
+   It returns the flags successfully initialized, or 0 on failure.
+ + +
+ +
proc quit() {...}{.importc: "Mix_Quit", cdecl.}
+
+ +
Unloads libraries loaded with Mix_Init
+ + +
+ +
proc openAudio(frequency: cint; format: Uint16; channels: cint; chunksize: cint): cint {...}{.
+    importc: "Mix_OpenAudio", cdecl.}
+
+ +
Open the mixer with a certain audio format
+ + +
+ +
proc openAudioDevice(frequency: cint; format: Uint16; channels: cint; chunksize: cint;
+                    device: cstring; allowedChanges: cint): cint {...}{.
+    importc: "Mix_OpenAudioDevice", cdecl.}
+
+ +
Open the mixer with specific device and certain audio format
+ + +
+ +
proc allocateChannels(numchans: cint): cint {...}{.importc: "Mix_AllocateChannels", cdecl.}
+
+ +
Dynamically change the number of channels managed by the mixer.
+   If decreasing the number of channels, the upper channels are
+   stopped.
+   This function returns the new number of allocated channels.
+ + +
+ +
proc querySpec(frequency: ptr cint; format: ptr Uint16; channels: ptr cint): cint {...}{.
+    importc: "Mix_QuerySpec", cdecl.}
+
+ +
Find out what the actual audio device parameters are.
+   This function returns 1 if the audio has been opened, 0 otherwise.
+ + +
+ +
proc loadWAV_RW(src: ptr RWops; freesrc: cint): ptr Chunk {...}{.importc: "Mix_LoadWAV_RW",
+    cdecl.}
+
+ +
Load a wave file or a music (.mod .s3m .it .xm) file
+ + +
+ +
proc loadMUS(file: cstring): ptr Music {...}{.importc: "Mix_LoadMUS", cdecl.}
+
+ + + +
+ +
proc loadMUS_RW(src: ptr RWops; freesrc: cint): ptr Music {...}{.importc: "Mix_LoadMUS_RW",
+    cdecl.}
+
+ +
Load a music file from an SDL_RWop object (Ogg and MikMod specific currently)
+   Matt Campbell (matt@campbellhome.dhs.org) April 2000
+ + +
+ +
proc loadMUSType_RW(src: ptr RWops; kind: MusicType; freesrc: cint): ptr Music {...}{.
+    importc: "Mix_LoadMUSType_RW", cdecl.}
+
+ +
Load a music file from an SDL_RWop object assuming a specific format
+ + +
+ +
proc quickLoad_WAV(mem: ptr Uint8): ptr Chunk {...}{.importc: "Mix_QuickLoad_WAV", cdecl.}
+
+ +
Load a wave file of the mixer format from a memory buffer
+ + +
+ +
proc quickLoad_RAW(mem: ptr Uint8; len: Uint32): ptr Chunk {...}{.
+    importc: "Mix_QuickLoad_RAW", cdecl.}
+
+ +
Load raw audio data of the mixer format from a memory buffer
+ + +
+ +
proc freeChunk(chunk: ptr Chunk) {...}{.importc: "Mix_FreeChunk", cdecl.}
+
+ +
Free an audio chunk previously loaded
+ + +
+ +
proc freeMusic(music: ptr Music) {...}{.importc: "Mix_FreeMusic", cdecl.}
+
+ + + +
+ +
proc getNumChunkDecoders(): cint {...}{.importc: "Mix_GetNumChunkDecoders", cdecl.}
+
+ +
Get a list of chunk/music decoders that this build of SDL_mixer provides.
+   This list can change between builds AND runs of the program, if external
+   libraries that add functionality become available.
+   You must successfully call Mix_OpenAudio() before calling these functions.
+   This API is only available in SDL_mixer 1.2.9 and later.
+ usage...
+   int i;
+   const int total = Mix_GetNumChunkDecoders();
+   for (i = 0; i < total; i++)
+       printf("Supported chunk decoder: [%s]\n", Mix_GetChunkDecoder(i));
+   Appearing in this list doesn't promise your specific audio file will
+   decode...but it's handy to know if you have, say, a functioning Timidity
+   install.
+   These return values are static, read-only data; do not modify or free it.
+   The pointers remain valid until you call Mix_CloseAudio().
+ + +
+ +
proc getChunkDecoder(index: cint): cstring {...}{.importc: "Mix_GetChunkDecoder", cdecl.}
+
+ + + +
+ +
proc hasChunkDecoder(name: cstring): bool {...}{.importc: "Mix_HasChunkDecoder", cdecl.}
+
+ + + +
+ +
proc getNumMusicDecoders(): cint {...}{.importc: "Mix_GetNumMusicDecoders", cdecl.}
+
+ + + +
+ +
proc getMusicDecoder(index: cint): cstring {...}{.importc: "Mix_GetMusicDecoder", cdecl.}
+
+ + + +
+ +
proc hasMusicDecoder(name: cstring): bool {...}{.importc: "Mix_HasMusicDecoder", cdecl.}
+
+ + + +
+ +
proc getMusicType(music: ptr Music): MusicType {...}{.importc: "Mix_GetMusicType", cdecl.}
+
+ +
Find out the music format of a mixer music, or the currently playing
+   music, if 'music' is NULL.
+ + +
+ +
proc setPostMix(mixFunc: proc (udata: pointer; stream: ptr Uint8; len: cint) {...}{.cdecl.};
+               arg: pointer) {...}{.importc: "Mix_SetPostMix", cdecl.}
+
+ +
Set a function that is called after all mixing is performed.
+   This can be used to provide real-time visual display of the audio stream
+   or add a custom mixer filter for the stream data.
+ + +
+ +
proc hookMusic(mixFunc: proc (udata: pointer; stream: ptr Uint8; len: cint) {...}{.cdecl.};
+              arg: pointer) {...}{.importc: "Mix_HookMusic", cdecl.}
+
+ +
Add your own music player or additional mixer function.
+   If 'mix_func' is NULL, the default music player is re-enabled.
+ + +
+ +
proc hookMusicFinished(musicFinished: proc () {...}{.cdecl.}) {...}{.
+    importc: "Mix_HookMusicFinished", cdecl.}
+
+ +
Add your own callback for when the music has finished playing or when it is
+ stopped from a call to Mix_HaltMusic.
+ + +
+ +
proc getMusicHookData(): pointer {...}{.importc: "Mix_GetMusicHookData", cdecl.}
+
+ +
Get a pointer to the user data for the current music hook
+ + +
+ +
proc channelFinished(channelFinished: proc (channel: cint) {...}{.cdecl.}) {...}{.
+    importc: "Mix_ChannelFinished", cdecl.}
+
+ +
Add your own callback when a channel has finished playing. NULL
+  to disable callback. The callback may be called from the mixer's audio
+  callback or it could be called as a result of Mix_HaltChannel(), etc.
+  do not call SDL_LockAudio() from this callback; you will either be
+  inside the audio callback, or SDL_mixer will explicitly lock the audio
+  before calling your callback.
+ + +
+ +
proc registerEffect(chan: cint; f: EffectFunc_t; d: EffectDone_t; arg: pointer): cint {...}{.
+    importc: "Mix_RegisterEffect", cdecl.}
+
+ +
Register a special effect function. At mixing time, the channel data is
+  copied into a buffer and passed through each registered effect function.
+  After it passes through all the functions, it is mixed into the final
+  output stream. The copy to buffer is performed once, then each effect
+  function performs on the output of the previous effect. Understand that
+  this extra copy to a buffer is not performed if there are no effects
+  registered for a given chunk, which saves CPU cycles, and any given
+  effect will be extra cycles, too, so it is crucial that your code run
+  fast. Also note that the data that your function is given is in the
+  format of the sound device, and not the format you gave to Mix_OpenAudio(),
+  although they may in reality be the same. This is an unfortunate but
+  necessary speed concern. Use Mix_QuerySpec() to determine if you can
+  handle the data before you register your effect, and take appropriate
+  actions.
+ You may also specify a callback (Mix_EffectDone_t) that is called when
+  the channel finishes playing. This gives you a more fine-grained control
+  than Mix_ChannelFinished(), in case you need to free effect-specific
+  resources, etc. If you don't need this, you can specify NULL.
+ You may set the callbacks before or after calling Mix_PlayChannel().
+ Things like Mix_SetPanning() are just internal special effect functions,
+  so if you are using that, you've already incurred the overhead of a copy
+  to a separate buffer, and that these effects will be in the queue with
+  any functions you've registered. The list of registered effects for a
+  channel is reset when a chunk finishes playing, so you need to explicitly
+  set them with each call to Mix_PlayChannel().
+ You may also register a special effect function that is to be run after
+  final mixing occurs. The rules for these callbacks are identical to those
+  in Mix_RegisterEffect, but they are run after all the channels and the
+  music have been mixed into a single stream, whereas channel-specific
+  effects run on a given channel before any other mixing occurs. These
+  global effect callbacks are call "posteffects". Posteffects only have
+  their Mix_EffectDone_t function called when they are unregistered (since
+  the main output stream is never "done" in the same sense as a channel).
+  You must unregister them manually when you've had enough. Your callback
+  will be told that the channel being mixed is (MIX_CHANNEL_POST) if the
+  processing is considered a posteffect.
+ 
+ After all these effects have finished processing, the callback registered
+  through Mix_SetPostMix() runs, and then the stream goes to the audio
+  device.
+ 
+ DO NOT EVER call SDL_LockAudio() from your callback function!
+ 
+ returns zero if error (no such channel), nonzero if added.
+  Error messages can be retrieved from Mix_GetError().
+ + +
+ +
proc unregisterEffect(channel: cint; f: EffectFunc_t): cint {...}{.
+    importc: "Mix_UnregisterEffect", cdecl.}
+
+ +
You may not need to call this explicitly, unless you need to stop an
+  effect from processing in the middle of a chunk's playback.
+ Posteffects are never implicitly unregistered as they are for channels,
+  but they may be explicitly unregistered through this function by
+  specifying MIX_CHANNEL_POST for a channel.
+ returns zero if error (no such channel or effect), nonzero if removed.
+  Error messages can be retrieved from Mix_GetError().
+ + +
+ +
proc unregisterAllEffects(channel: cint): cint {...}{.
+    importc: "Mix_UnregisterAllEffects", cdecl.}
+
+ +
You may not need to call this explicitly, unless you need to stop all
+  effects from processing in the middle of a chunk's playback. Note that
+  this will also shut off some internal effect processing, since
+  Mix_SetPanning() and others may use this API under the hood. This is
+  called internally when a channel completes playback.
+ Posteffects are never implicitly unregistered as they are for channels,
+  but they may be explicitly unregistered through this function by
+  specifying MIX_CHANNEL_POST for a channel.
+ returns zero if error (no such channel), nonzero if all effects removed.
+  Error messages can be retrieved from Mix_GetError().
+ + +
+ +
proc setPanning(channel: cint; left: Uint8; right: Uint8): cint {...}{.
+    importc: "Mix_SetPanning", cdecl.}
+
+ +
These are the internally-defined mixing effects. They use the same API that
+  effects defined in the application use, but are provided here as a
+  convenience. Some effects can reduce their quality or use more memory in
+  the name of speed; to enable this, make sure the environment variable
+  MIX_EFFECTSMAXSPEED (see above) is defined before you call
+  Mix_OpenAudio().
+Set the panning of a channel. The left and right channels are specified
+  as integers between 0 and 255, quietest to loudest, respectively.
+ 
+ Technically, this is just individual volume control for a sample with
+  two (stereo) channels, so it can be used for more than just panning.
+  If you want real panning, call it like this:
+   
+   Mix_SetPanning(channel, left, 255 - left);
+ 
+ ...which isn't so hard.
+ 
+ Setting (channel) to MIX_CHANNEL_POST registers this as a posteffect, and
+  the panning will be done to the final mixed stream before passing it on
+  to the audio device.
+ 
+ This uses the Mix_RegisterEffect() API internally, and returns without
+  registering the effect function if the audio device is not configured
+  for stereo output. Setting both (left) and (right) to 255 causes this
+  effect to be unregistered, since that is the data's normal state.
+ 
+ returns zero if error (no such channel or Mix_RegisterEffect() fails),
+  nonzero if panning effect enabled. Note that an audio device in mono
+  mode is a no-op, but this call will return successful in that case.
+  Error messages can be retrieved from Mix_GetError().
+ + +
+ +
proc setPosition(channel: cint; angle: Sint16; distance: Uint8): cint {...}{.
+    importc: "Mix_SetPosition", cdecl.}
+
+ +
Set the position of a channel. (angle) is an integer from 0 to 360, that
+  specifies the location of the sound in relation to the listener. (angle)
+  will be reduced as neccesary (540 becomes 180 degrees, -100 becomes 260).
+  Angle 0 is due north, and rotates clockwise as the value increases.
+  For efficiency, the precision of this effect may be limited (angles 1
+  through 7 might all produce the same effect, 8 through 15 are equal, etc).
+  (distance) is an integer between 0 and 255 that specifies the space
+  between the sound and the listener. The larger the number, the further
+  away the sound is. Using 255 does not guarantee that the channel will be
+  culled from the mixing process or be completely silent. For efficiency,
+  the precision of this effect may be limited (distance 0 through 5 might
+  all produce the same effect, 6 through 10 are equal, etc). Setting (angle)
+  and (distance) to 0 unregisters this effect, since the data would be
+  unchanged.
+ 
+ If you need more precise positional audio, consider using OpenAL for
+  spatialized effects instead of SDL_mixer. This is only meant to be a
+  basic effect for simple "3D" games.
+ 
+ If the audio device is configured for mono output, then you won't get
+  any effectiveness from the angle; however, distance attenuation on the
+  channel will still occur. While this effect will function with stereo
+  voices, it makes more sense to use voices with only one channel of sound,
+  so when they are mixed through this effect, the positioning will sound
+  correct. You can convert them to mono through SDL before giving them to
+  the mixer in the first place if you like.
+ 
+ Setting (channel) to MIX_CHANNEL_POST registers this as a posteffect, and
+  the positioning will be done to the final mixed stream before passing it
+  on to the audio device.
+ 
+ This is a convenience wrapper over Mix_SetDistance() and Mix_SetPanning().
+ 
+ returns zero if error (no such channel or Mix_RegisterEffect() fails),
+  nonzero if position effect is enabled.
+  Error messages can be retrieved from Mix_GetError().
+ + +
+ +
proc setDistance(channel: cint; distance: Uint8): cint {...}{.importc: "Mix_SetDistance",
+    cdecl.}
+
+ +
Set the "distance" of a channel. (distance) is an integer from 0 to 255
+  that specifies the location of the sound in relation to the listener.
+  Distance 0 is overlapping the listener, and 255 is as far away as possible
+  A distance of 255 does not guarantee silence; in such a case, you might
+  want to try changing the chunk's volume, or just cull the sample from the
+  mixing process with Mix_HaltChannel().
+ For efficiency, the precision of this effect may be limited (distances 1
+  through 7 might all produce the same effect, 8 through 15 are equal, etc).
+  (distance) is an integer between 0 and 255 that specifies the space
+  between the sound and the listener. The larger the number, the further
+  away the sound is.
+ Setting (distance) to 0 unregisters this effect, since the data would be
+  unchanged.
+ If you need more precise positional audio, consider using OpenAL for
+  spatialized effects instead of SDL_mixer. This is only meant to be a
+  basic effect for simple "3D" games.
+ 
+ Setting (channel) to MIX_CHANNEL_POST registers this as a posteffect, and
+  the distance attenuation will be done to the final mixed stream before
+  passing it on to the audio device.
+ 
+ This uses the Mix_RegisterEffect() API internally.
+ 
+ returns zero if error (no such channel or Mix_RegisterEffect() fails),
+  nonzero if position effect is enabled.
+  Error messages can be retrieved from Mix_GetError().
+ + +
+ +
proc setReverseStereo(channel: cint; flip: cint): cint {...}{.
+    importc: "Mix_SetReverseStereo", cdecl.}
+
+ +
!!! FIXME : Haven't implemented, since the effect goes past the
+              end of the sound buffer. Will have to think about this.
+               --ryan.
+Causes a channel to reverse its stereo. This is handy if the user has his
+  speakers hooked up backwards, or you would like to have a minor bit of
+  psychedelia in your sound code.  :)  Calling this function with (flip)
+  set to non-zero reverses the chunks's usual channels. If (flip) is zero,
+  the effect is unregistered.
+ 
+ This uses the Mix_RegisterEffect() API internally, and thus is probably
+  more CPU intensive than having the user just plug in his speakers
+  correctly. Mix_SetReverseStereo() returns without registering the effect
+  function if the audio device is not configured for stereo output.
+ 
+ If you specify MIX_CHANNEL_POST for (channel), then this the effect is used
+  on the final mixed stream before sending it on to the audio device (a
+  posteffect).
+ 
+ returns zero if error (no such channel or Mix_RegisterEffect() fails),
+  nonzero if reversing effect is enabled. Note that an audio device in mono
+  mode is a no-op, but this call will return successful in that case.
+  Error messages can be retrieved from Mix_GetError().
+ + +
+ +
proc reserveChannels(num: cint): cint {...}{.importc: "Mix_ReserveChannels", cdecl.}
+
+ +
end of effects API. --ryan.
+Reserve the first channels (0 -> n-1) for the application, i.e. don't allocate
+   them dynamically to the next sample if requested with a -1 value below.
+   Returns the number of reserved channels.
+ + +
+ +
proc groupChannel(which: cint; tag: cint): cint {...}{.importc: "Mix_GroupChannel", cdecl.}
+
+ +
Channel grouping functions
+Attach a tag to a channel. A tag can be assigned to several mixer
+   channels, to form groups of channels.
+   If 'tag' is -1, the tag is removed (actually -1 is the tag used to
+   represent the group of all the channels).
+   Returns true if everything was OK.
+ + +
+ +
proc groupChannels(`from`: cint; to: cint; tag: cint): cint {...}{.
+    importc: "Mix_GroupChannels", cdecl.}
+
+ +
Assign several consecutive channels to a group
+ + +
+ +
proc groupAvailable(tag: cint): cint {...}{.importc: "Mix_GroupAvailable", cdecl.}
+
+ +
Finds the first available channel in a group of channels,
+   returning -1 if none are available.
+ + +
+ +
proc groupCount(tag: cint): cint {...}{.importc: "Mix_GroupCount", cdecl.}
+
+ +
Returns the number of channels in a group. This is also a subtle
+   way to get the total number of channels when 'tag' is -1
+ + +
+ +
proc groupOldest(tag: cint): cint {...}{.importc: "Mix_GroupOldest", cdecl.}
+
+ +
Finds the "oldest" sample playing in a group of channels
+ + +
+ +
proc groupNewer(tag: cint): cint {...}{.importc: "Mix_GroupNewer", cdecl.}
+
+ +
Finds the "most recent" (i.e. last) sample playing in a group of channels
+ + +
+ +
proc playChannelTimed(channel: cint; chunk: ptr Chunk; loops: cint; ticks: cint): cint {...}{.
+    importc: "Mix_PlayChannelTimed", cdecl.}
+
+ +
The same as above, but the sound is played at most 'ticks' milliseconds
+ + +
+ +
proc playMusic(music: ptr Music; loops: cint): cint {...}{.importc: "Mix_PlayMusic", cdecl.}
+
+ + + +
+ +
proc fadeInMusic(music: ptr Music; loops: cint; ms: cint): cint {...}{.
+    importc: "Mix_FadeInMusic", cdecl.}
+
+ +
Fade in music or a channel over "ms" milliseconds, same semantics as the "Play" functions
+ + +
+ +
proc fadeInMusicPos(music: ptr Music; loops: cint; ms: cint; position: cdouble): cint {...}{.
+    importc: "Mix_FadeInMusicPos", cdecl.}
+
+ + + +
+ +
proc fadeInChannelTimed(channel: cint; chunk: ptr Chunk; loops: cint; ms: cint;
+                       ticks: cint): cint {...}{.importc: "Mix_FadeInChannelTimed", cdecl.}
+
+ + + +
+ +
proc volume(channel: cint; volume: cint): cint {...}{.importc: "Mix_Volume", cdecl.}
+
+ +
Set the volume in the range of 0-128 of a specific channel or chunk.
+   If the specified channel is -1, set volume for all channels.
+   Returns the original volume.
+   If the specified volume is -1, just return the current volume.
+ + +
+ +
proc volumeChunk(chunk: ptr Chunk; volume: cint): cint {...}{.importc: "Mix_VolumeChunk",
+    cdecl.}
+
+ + + +
+ +
proc volumeMusic(volume: cint): cint {...}{.importc: "Mix_VolumeMusic", cdecl.}
+
+ + + +
+ +
proc haltChannel(channel: cint): cint {...}{.importc: "Mix_HaltChannel", cdecl.}
+
+ +
Halt playing of a particular channel
+ + +
+ +
proc haltGroup(tag: cint): cint {...}{.importc: "Mix_HaltGroup", cdecl.}
+
+ + + +
+ +
proc haltMusic(): cint {...}{.importc: "Mix_HaltMusic", cdecl.}
+
+ + + +
+ +
proc expireChannel(channel: cint; ticks: cint): cint {...}{.importc: "Mix_ExpireChannel",
+    cdecl.}
+
+ +
Change the expiration delay for a particular channel.
+   The sample will stop playing after the 'ticks' milliseconds have elapsed,
+   or remove the expiration if 'ticks' is -1
+ + +
+ +
proc fadeOutChannel(which: cint; ms: cint): cint {...}{.importc: "Mix_FadeOutChannel", cdecl.}
+
+ +
Halt a channel, fading it out progressively till it's silent
+   The ms parameter indicates the number of milliseconds the fading
+   will take.
+ + +
+ +
proc fadeOutGroup(tag: cint; ms: cint): cint {...}{.importc: "Mix_FadeOutGroup", cdecl.}
+
+ + + +
+ +
proc fadeOutMusic(ms: cint): cint {...}{.importc: "Mix_FadeOutMusic", cdecl.}
+
+ + + +
+ +
proc fadingMusic(): Fading {...}{.importc: "Mix_FadingMusic", cdecl.}
+
+ +
Query the fading status of a channel
+ + +
+ +
proc fadingChannel(which: cint): Fading {...}{.importc: "Mix_FadingChannel", cdecl.}
+
+ + + +
+ +
proc pause(channel: cint) {...}{.importc: "Mix_Pause", cdecl.}
+
+ +
Pause/Resume a particular channel
+ + +
+ +
proc resume(channel: cint) {...}{.importc: "Mix_Resume", cdecl.}
+
+ + + +
+ +
proc paused(channel: cint): cint {...}{.importc: "Mix_Paused", cdecl.}
+
+ + + +
+ +
proc pauseMusic() {...}{.importc: "Mix_PauseMusic", cdecl.}
+
+ +
Pause/Resume the music stream
+ + +
+ +
proc resumeMusic() {...}{.importc: "Mix_ResumeMusic", cdecl.}
+
+ + + +
+ +
proc rewindMusic() {...}{.importc: "Mix_RewindMusic", cdecl.}
+
+ + + +
+ +
proc pausedMusic(): cint {...}{.importc: "Mix_PausedMusic", cdecl.}
+
+ + + +
+ +
proc setMusicPosition(position: cdouble): cint {...}{.importc: "Mix_SetMusicPosition",
+    cdecl.}
+
+ +
Set the current position in the music stream.
+   This returns 0 if successful, or -1 if it failed or isn't implemented.
+   This function is only implemented for MOD music formats (set pattern
+   order number) and for OGG, FLAC, MP3_MAD, MP3_MPG and MODPLUG music
+   (set position in seconds), at the moment.
+ + +
+ +
proc playing(channel: cint): cint {...}{.importc: "Mix_Playing", cdecl.}
+
+ +
Check the status of a specific channel.
+   If the specified channel is -1, check all channels.
+ + +
+ +
proc playingMusic(): cint {...}{.importc: "Mix_PlayingMusic", cdecl.}
+
+ + + +
+ +
proc setMusicCMD(command: cstring): cint {...}{.importc: "Mix_SetMusicCMD", cdecl.}
+
+ +
Stop music and set external music playback command
+ + +
+ +
proc setSynchroValue(value: cint): cint {...}{.importc: "Mix_SetSynchroValue", cdecl.}
+
+ +
Synchro value is set by MikMod from modules while playing
+ + +
+ +
proc getSynchroValue(): cint {...}{.importc: "Mix_GetSynchroValue", cdecl.}
+
+ + + +
+ +
proc setSoundFonts(paths: cstring): cint {...}{.importc: "Mix_SetSoundFonts", cdecl.}
+
+ +
Set/Get/Iterate SoundFonts paths to use by supported MIDI backends
+ + +
+ +
proc getSoundFonts(): cstring {...}{.importc: "Mix_GetSoundFonts", cdecl.}
+
+ + + +
+ +
proc eachSoundFont(function: proc (a1: cstring; a2: pointer): cint {...}{.cdecl.};
+                  data: pointer): cint {...}{.importc: "Mix_EachSoundFont", cdecl.}
+
+ + + +
+ +
proc getChunk(channel: cint): ptr Chunk {...}{.importc: "Mix_GetChunk", cdecl.}
+
+ +
Get the Mix_Chunk currently associated with a mixer channel
+    Returns NULL if it's an invalid channel, or there's no chunk associated.
+ + +
+ +
proc closeAudio() {...}{.importc: "Mix_CloseAudio", cdecl.}
+
+ +
Close the mixer, halting all playing audio
+ + +
+ +
+ +
+
+ +
+ +
+
+
+ + + diff --git a/docs/sdl2/sdl2_mixer.idx b/docs/sdl2/sdl2_mixer.idx new file mode 100644 index 0000000..bf9b67e --- /dev/null +++ b/docs/sdl2/sdl2_mixer.idx @@ -0,0 +1,124 @@ +SDLmixerStd sdl2/sdl2_mixer.html#SDLmixerStd sdl2_mixer: SDLmixerStd +SDLmixerGit sdl2/sdl2_mixer.html#SDLmixerGit sdl2_mixer: SDLmixerGit +SDLmixerDL sdl2/sdl2_mixer.html#SDLmixerDL sdl2_mixer: SDLmixerDL +SDLmixerStatic sdl2/sdl2_mixer.html#SDLmixerStatic sdl2_mixer: SDLmixerStatic +SDLmixerSetVer sdl2/sdl2_mixer.html#SDLmixerSetVer sdl2_mixer: SDLmixerSetVer +SDLmixerLPath sdl2/sdl2_mixer.html#SDLmixerLPath sdl2_mixer: SDLmixerLPath +SDLmixerPath sdl2/sdl2_mixer.html#SDLmixerPath sdl2_mixer: SDLmixerPath +MIX_InitFlags sdl2/sdl2_mixer.html#MIX_InitFlags sdl2_mixer: MIX_InitFlags +Fading sdl2/sdl2_mixer.html#Fading sdl2_mixer: Fading +MusicType sdl2/sdl2_mixer.html#MusicType sdl2_mixer: MusicType +SetError sdl2/sdl2_mixer.html#SetError sdl2_mixer: SetError +GetError sdl2/sdl2_mixer.html#GetError sdl2_mixer: GetError +ClearError sdl2/sdl2_mixer.html#ClearError sdl2_mixer: ClearError +MIXER_MAJOR_VERSION sdl2/sdl2_mixer.html#MIXER_MAJOR_VERSION sdl2_mixer: MIXER_MAJOR_VERSION +MIXER_MINOR_VERSION sdl2/sdl2_mixer.html#MIXER_MINOR_VERSION sdl2_mixer: MIXER_MINOR_VERSION +MIXER_PATCHLEVEL sdl2/sdl2_mixer.html#MIXER_PATCHLEVEL sdl2_mixer: MIXER_PATCHLEVEL +MIX_MAJOR_VERSION sdl2/sdl2_mixer.html#MIX_MAJOR_VERSION sdl2_mixer: MIX_MAJOR_VERSION +MIX_MINOR_VERSION sdl2/sdl2_mixer.html#MIX_MINOR_VERSION sdl2_mixer: MIX_MINOR_VERSION +MIX_PATCHLEVEL sdl2/sdl2_mixer.html#MIX_PATCHLEVEL sdl2_mixer: MIX_PATCHLEVEL +MIX_INIT_FLAC sdl2/sdl2_mixer.html#MIX_INIT_FLAC sdl2_mixer: MIX_INIT_FLAC +MIX_INIT_MOD sdl2/sdl2_mixer.html#MIX_INIT_MOD sdl2_mixer: MIX_INIT_MOD +MIX_INIT_MP3 sdl2/sdl2_mixer.html#MIX_INIT_MP3 sdl2_mixer: MIX_INIT_MP3 +MIX_INIT_OGG sdl2/sdl2_mixer.html#MIX_INIT_OGG sdl2_mixer: MIX_INIT_OGG +MIX_INIT_MID sdl2/sdl2_mixer.html#MIX_INIT_MID sdl2_mixer: MIX_INIT_MID +MIX_INIT_OPUS sdl2/sdl2_mixer.html#MIX_INIT_OPUS sdl2_mixer: MIX_INIT_OPUS +MIX_CHANNELS sdl2/sdl2_mixer.html#MIX_CHANNELS sdl2_mixer: MIX_CHANNELS +MIX_DEFAULT_FREQUENCY sdl2/sdl2_mixer.html#MIX_DEFAULT_FREQUENCY sdl2_mixer: MIX_DEFAULT_FREQUENCY +MIX_DEFAULT_CHANNELS sdl2/sdl2_mixer.html#MIX_DEFAULT_CHANNELS sdl2_mixer: MIX_DEFAULT_CHANNELS +MIX_NO_FADING sdl2/sdl2_mixer.html#MIX_NO_FADING sdl2_mixer: MIX_NO_FADING +MIX_FADING_OUT sdl2/sdl2_mixer.html#MIX_FADING_OUT sdl2_mixer: MIX_FADING_OUT +MIX_FADING_IN sdl2/sdl2_mixer.html#MIX_FADING_IN sdl2_mixer: MIX_FADING_IN +MUS_NONE sdl2/sdl2_mixer.html#MUS_NONE sdl2_mixer: MUS_NONE +MUS_CMD sdl2/sdl2_mixer.html#MUS_CMD sdl2_mixer: MUS_CMD +MUS_WAV sdl2/sdl2_mixer.html#MUS_WAV sdl2_mixer: MUS_WAV +MUS_MOD sdl2/sdl2_mixer.html#MUS_MOD sdl2_mixer: MUS_MOD +MUS_MID sdl2/sdl2_mixer.html#MUS_MID sdl2_mixer: MUS_MID +MUS_OGG sdl2/sdl2_mixer.html#MUS_OGG sdl2_mixer: MUS_OGG +MUS_MP3 sdl2/sdl2_mixer.html#MUS_MP3 sdl2_mixer: MUS_MP3 +MUS_MP3_MAD_UNUSED sdl2/sdl2_mixer.html#MUS_MP3_MAD_UNUSED sdl2_mixer: MUS_MP3_MAD_UNUSED +MUS_FLAC sdl2/sdl2_mixer.html#MUS_FLAC sdl2_mixer: MUS_FLAC +MUS_MODPLUG_UNUSED sdl2/sdl2_mixer.html#MUS_MODPLUG_UNUSED sdl2_mixer: MUS_MODPLUG_UNUSED +MUS_OPUS sdl2/sdl2_mixer.html#MUS_OPUS sdl2_mixer: MUS_OPUS +MIX_CHANNEL_POST sdl2/sdl2_mixer.html#MIX_CHANNEL_POST sdl2_mixer: MIX_CHANNEL_POST +MIX_EFFECTSMAXSPEED sdl2/sdl2_mixer.html#MIX_EFFECTSMAXSPEED sdl2_mixer: MIX_EFFECTSMAXSPEED +Chunk sdl2/sdl2_mixer.html#Chunk sdl2_mixer: Chunk +Music sdl2/sdl2_mixer.html#Music sdl2_mixer: Music +EffectFunc_t sdl2/sdl2_mixer.html#EffectFunc_t sdl2_mixer: EffectFunc_t +EffectDone_t sdl2/sdl2_mixer.html#EffectDone_t sdl2_mixer: EffectDone_t +linked_Version sdl2/sdl2_mixer.html#linked_Version sdl2_mixer: linked_Version(): ptr Version +init sdl2/sdl2_mixer.html#init,cint sdl2_mixer: init(flags: cint): cint +quit sdl2/sdl2_mixer.html#quit sdl2_mixer: quit() +openAudio sdl2/sdl2_mixer.html#openAudio,cint,Uint16,cint,cint sdl2_mixer: openAudio(frequency: cint; format: Uint16; channels: cint; chunksize: cint): cint +openAudioDevice sdl2/sdl2_mixer.html#openAudioDevice,cint,Uint16,cint,cint,cstring,cint sdl2_mixer: openAudioDevice(frequency: cint; format: Uint16; channels: cint; chunksize: cint;\n device: cstring; allowedChanges: cint): cint +allocateChannels sdl2/sdl2_mixer.html#allocateChannels,cint sdl2_mixer: allocateChannels(numchans: cint): cint +querySpec sdl2/sdl2_mixer.html#querySpec,ptr.cint,ptr.Uint16,ptr.cint sdl2_mixer: querySpec(frequency: ptr cint; format: ptr Uint16; channels: ptr cint): cint +loadWAV_RW sdl2/sdl2_mixer.html#loadWAV_RW,ptr.RWops,cint sdl2_mixer: loadWAV_RW(src: ptr RWops; freesrc: cint): ptr Chunk +loadMUS sdl2/sdl2_mixer.html#loadMUS,cstring sdl2_mixer: loadMUS(file: cstring): ptr Music +loadMUS_RW sdl2/sdl2_mixer.html#loadMUS_RW,ptr.RWops,cint sdl2_mixer: loadMUS_RW(src: ptr RWops; freesrc: cint): ptr Music +loadMUSType_RW sdl2/sdl2_mixer.html#loadMUSType_RW,ptr.RWops,MusicType,cint sdl2_mixer: loadMUSType_RW(src: ptr RWops; kind: MusicType; freesrc: cint): ptr Music +quickLoad_WAV sdl2/sdl2_mixer.html#quickLoad_WAV,ptr.Uint8 sdl2_mixer: quickLoad_WAV(mem: ptr Uint8): ptr Chunk +quickLoad_RAW sdl2/sdl2_mixer.html#quickLoad_RAW,ptr.Uint8,Uint32 sdl2_mixer: quickLoad_RAW(mem: ptr Uint8; len: Uint32): ptr Chunk +freeChunk sdl2/sdl2_mixer.html#freeChunk,ptr.Chunk sdl2_mixer: freeChunk(chunk: ptr Chunk) +freeMusic sdl2/sdl2_mixer.html#freeMusic,ptr.Music sdl2_mixer: freeMusic(music: ptr Music) +getNumChunkDecoders sdl2/sdl2_mixer.html#getNumChunkDecoders sdl2_mixer: getNumChunkDecoders(): cint +getChunkDecoder sdl2/sdl2_mixer.html#getChunkDecoder,cint sdl2_mixer: getChunkDecoder(index: cint): cstring +hasChunkDecoder sdl2/sdl2_mixer.html#hasChunkDecoder,cstring sdl2_mixer: hasChunkDecoder(name: cstring): bool +getNumMusicDecoders sdl2/sdl2_mixer.html#getNumMusicDecoders sdl2_mixer: getNumMusicDecoders(): cint +getMusicDecoder sdl2/sdl2_mixer.html#getMusicDecoder,cint sdl2_mixer: getMusicDecoder(index: cint): cstring +hasMusicDecoder sdl2/sdl2_mixer.html#hasMusicDecoder,cstring sdl2_mixer: hasMusicDecoder(name: cstring): bool +getMusicType sdl2/sdl2_mixer.html#getMusicType,ptr.Music sdl2_mixer: getMusicType(music: ptr Music): MusicType +setPostMix sdl2/sdl2_mixer.html#setPostMix,proc(pointer,ptr.Uint8,cint),pointer sdl2_mixer: setPostMix(mixFunc: proc (udata: pointer; stream: ptr Uint8; len: cint) {.cdecl.};\n arg: pointer) +hookMusic sdl2/sdl2_mixer.html#hookMusic,proc(pointer,ptr.Uint8,cint),pointer sdl2_mixer: hookMusic(mixFunc: proc (udata: pointer; stream: ptr Uint8; len: cint) {.cdecl.};\n arg: pointer) +hookMusicFinished sdl2/sdl2_mixer.html#hookMusicFinished,proc) sdl2_mixer: hookMusicFinished(musicFinished: proc () {.cdecl.}) +getMusicHookData sdl2/sdl2_mixer.html#getMusicHookData sdl2_mixer: getMusicHookData(): pointer +channelFinished sdl2/sdl2_mixer.html#channelFinished,proc(cint) sdl2_mixer: channelFinished(channelFinished: proc (channel: cint) {.cdecl.}) +registerEffect sdl2/sdl2_mixer.html#registerEffect,cint,EffectFunc_t,EffectDone_t,pointer sdl2_mixer: registerEffect(chan: cint; f: EffectFunc_t; d: EffectDone_t; arg: pointer): cint +unregisterEffect sdl2/sdl2_mixer.html#unregisterEffect,cint,EffectFunc_t sdl2_mixer: unregisterEffect(channel: cint; f: EffectFunc_t): cint +unregisterAllEffects sdl2/sdl2_mixer.html#unregisterAllEffects,cint sdl2_mixer: unregisterAllEffects(channel: cint): cint +setPanning sdl2/sdl2_mixer.html#setPanning,cint,Uint8,Uint8 sdl2_mixer: setPanning(channel: cint; left: Uint8; right: Uint8): cint +setPosition sdl2/sdl2_mixer.html#setPosition,cint,Sint16,Uint8 sdl2_mixer: setPosition(channel: cint; angle: Sint16; distance: Uint8): cint +setDistance sdl2/sdl2_mixer.html#setDistance,cint,Uint8 sdl2_mixer: setDistance(channel: cint; distance: Uint8): cint +setReverseStereo sdl2/sdl2_mixer.html#setReverseStereo,cint,cint sdl2_mixer: setReverseStereo(channel: cint; flip: cint): cint +reserveChannels sdl2/sdl2_mixer.html#reserveChannels,cint sdl2_mixer: reserveChannels(num: cint): cint +groupChannel sdl2/sdl2_mixer.html#groupChannel,cint,cint sdl2_mixer: groupChannel(which: cint; tag: cint): cint +groupChannels sdl2/sdl2_mixer.html#groupChannels,cint,cint,cint sdl2_mixer: groupChannels(`from`: cint; to: cint; tag: cint): cint +groupAvailable sdl2/sdl2_mixer.html#groupAvailable,cint sdl2_mixer: groupAvailable(tag: cint): cint +groupCount sdl2/sdl2_mixer.html#groupCount,cint sdl2_mixer: groupCount(tag: cint): cint +groupOldest sdl2/sdl2_mixer.html#groupOldest,cint sdl2_mixer: groupOldest(tag: cint): cint +groupNewer sdl2/sdl2_mixer.html#groupNewer,cint sdl2_mixer: groupNewer(tag: cint): cint +playChannelTimed sdl2/sdl2_mixer.html#playChannelTimed,cint,ptr.Chunk,cint,cint sdl2_mixer: playChannelTimed(channel: cint; chunk: ptr Chunk; loops: cint; ticks: cint): cint +playMusic sdl2/sdl2_mixer.html#playMusic,ptr.Music,cint sdl2_mixer: playMusic(music: ptr Music; loops: cint): cint +fadeInMusic sdl2/sdl2_mixer.html#fadeInMusic,ptr.Music,cint,cint sdl2_mixer: fadeInMusic(music: ptr Music; loops: cint; ms: cint): cint +fadeInMusicPos sdl2/sdl2_mixer.html#fadeInMusicPos,ptr.Music,cint,cint,cdouble sdl2_mixer: fadeInMusicPos(music: ptr Music; loops: cint; ms: cint; position: cdouble): cint +fadeInChannelTimed sdl2/sdl2_mixer.html#fadeInChannelTimed,cint,ptr.Chunk,cint,cint,cint sdl2_mixer: fadeInChannelTimed(channel: cint; chunk: ptr Chunk; loops: cint; ms: cint; ticks: cint): cint +volume sdl2/sdl2_mixer.html#volume,cint,cint sdl2_mixer: volume(channel: cint; volume: cint): cint +volumeChunk sdl2/sdl2_mixer.html#volumeChunk,ptr.Chunk,cint sdl2_mixer: volumeChunk(chunk: ptr Chunk; volume: cint): cint +volumeMusic sdl2/sdl2_mixer.html#volumeMusic,cint sdl2_mixer: volumeMusic(volume: cint): cint +haltChannel sdl2/sdl2_mixer.html#haltChannel,cint sdl2_mixer: haltChannel(channel: cint): cint +haltGroup sdl2/sdl2_mixer.html#haltGroup,cint sdl2_mixer: haltGroup(tag: cint): cint +haltMusic sdl2/sdl2_mixer.html#haltMusic sdl2_mixer: haltMusic(): cint +expireChannel sdl2/sdl2_mixer.html#expireChannel,cint,cint sdl2_mixer: expireChannel(channel: cint; ticks: cint): cint +fadeOutChannel sdl2/sdl2_mixer.html#fadeOutChannel,cint,cint sdl2_mixer: fadeOutChannel(which: cint; ms: cint): cint +fadeOutGroup sdl2/sdl2_mixer.html#fadeOutGroup,cint,cint sdl2_mixer: fadeOutGroup(tag: cint; ms: cint): cint +fadeOutMusic sdl2/sdl2_mixer.html#fadeOutMusic,cint sdl2_mixer: fadeOutMusic(ms: cint): cint +fadingMusic sdl2/sdl2_mixer.html#fadingMusic sdl2_mixer: fadingMusic(): Fading +fadingChannel sdl2/sdl2_mixer.html#fadingChannel,cint sdl2_mixer: fadingChannel(which: cint): Fading +pause sdl2/sdl2_mixer.html#pause,cint sdl2_mixer: pause(channel: cint) +resume sdl2/sdl2_mixer.html#resume,cint sdl2_mixer: resume(channel: cint) +paused sdl2/sdl2_mixer.html#paused,cint sdl2_mixer: paused(channel: cint): cint +pauseMusic sdl2/sdl2_mixer.html#pauseMusic sdl2_mixer: pauseMusic() +resumeMusic sdl2/sdl2_mixer.html#resumeMusic sdl2_mixer: resumeMusic() +rewindMusic sdl2/sdl2_mixer.html#rewindMusic sdl2_mixer: rewindMusic() +pausedMusic sdl2/sdl2_mixer.html#pausedMusic sdl2_mixer: pausedMusic(): cint +setMusicPosition sdl2/sdl2_mixer.html#setMusicPosition,cdouble sdl2_mixer: setMusicPosition(position: cdouble): cint +playing sdl2/sdl2_mixer.html#playing,cint sdl2_mixer: playing(channel: cint): cint +playingMusic sdl2/sdl2_mixer.html#playingMusic sdl2_mixer: playingMusic(): cint +setMusicCMD sdl2/sdl2_mixer.html#setMusicCMD,cstring sdl2_mixer: setMusicCMD(command: cstring): cint +setSynchroValue sdl2/sdl2_mixer.html#setSynchroValue,cint sdl2_mixer: setSynchroValue(value: cint): cint +getSynchroValue sdl2/sdl2_mixer.html#getSynchroValue sdl2_mixer: getSynchroValue(): cint +setSoundFonts sdl2/sdl2_mixer.html#setSoundFonts,cstring sdl2_mixer: setSoundFonts(paths: cstring): cint +getSoundFonts sdl2/sdl2_mixer.html#getSoundFonts sdl2_mixer: getSoundFonts(): cstring +eachSoundFont sdl2/sdl2_mixer.html#eachSoundFont,proc(cstring,pointer),pointer sdl2_mixer: eachSoundFont(function: proc (a1: cstring; a2: pointer): cint {.cdecl.}; data: pointer): cint +getChunk sdl2/sdl2_mixer.html#getChunk,cint sdl2_mixer: getChunk(channel: cint): ptr Chunk +closeAudio sdl2/sdl2_mixer.html#closeAudio sdl2_mixer: closeAudio() diff --git a/docs/sdl2/sdl2_net.html b/docs/sdl2/sdl2_net.html new file mode 100644 index 0000000..c17ffc9 --- /dev/null +++ b/docs/sdl2/sdl2_net.html @@ -0,0 +1,892 @@ + + + + + + + + + + + + + + + + + + +sdl2/sdl2_net + + + + + + + + +
+
+

sdl2/sdl2_net

+
+ +
+
+ +

+
+

Imports

+
+sdl2 +
+
+

Types

+
+ +
Version = sdl2.Version
+
+ + + +
+ +
IPaddress {...}{.bycopy.} = object
+  host*: Uint32                ## ::
+              ##   32-bit IPv4 host address
+  port*: Uint16                ## ::
+              ##   16-bit protocol port
+  
+
+ +
+IPv4 hostname resolution API
+ + +
+ +
TCPsocket {...}{.incompleteStruct.} = object
+
+ + + +
+ +
UDPsocket {...}{.incompleteStruct.} = object
+
+ + + +
+ +
UDPpacket {...}{.bycopy.} = object
+  channel*: cint               ## ::
+               ##   The src/dst channel of the packet
+  data*: ptr Uint8              ## ::
+                ##   The packet data
+  len*: cint                   ## ::
+           ##   The length of the packet data
+  maxlen*: cint                ## ::
+              ##   The size of the data buffer
+  status*: cint                ## ::
+              ##   packet status after sending
+  address*: IPaddress          ## ::
+                    ##   The source/dest address of an incoming/outgoing packet
+  
+
+ + + +
+ +
SocketSet {...}{.incompleteStruct.} = object
+
+ + + +
+ +
GenericSocket {...}{.bycopy.} = object
+  ready*: cint
+
+
+ +
Any network socket can be safely cast to this socket type
+ + +
+ +
+
+

Consts

+
+ +
SDLnetStd = false
+
+ + + +
+ +
SDLnetGit = false
+
+ + + +
+ +
SDLnetDL = true
+
+ + + +
+ +
SDLnetStatic = true
+
+ + + +
+ +
SDLnetSetVer = ""
+
+ + + +
+ +
SDLnetLPath = "/Users/joey/Projects/nim-sdl2/src/build/sdl2_net/.libs/libSDL2_net.a"
+
+ + + +
+ +
SDLnetPath = "/Users/joey/Projects/nim-sdl2/src/build/sdl2_net/SDL_net.h"
+
+ + + +
+ +
NET_MAJOR_VERSION = 2
+
+ + + +
+ +
NET_MINOR_VERSION = 0
+
+ + + +
+ +
NET_PATCHLEVEL = 1
+
+ + + +
+ +
INADDR_ANY = 0x00000000
+
+ + + +
+ +
INADDR_NONE = 0x00000000FFFFFFFF'i64
+
+ + + +
+ +
INADDR_LOOPBACK = 0x7F000001
+
+ + + +
+ +
INADDR_BROADCAST = 0x00000000FFFFFFFF'i64
+
+ + + +
+ +
SDLNET_MAX_UDPCHANNELS = 32
+
+ + + +
+ +
SDLNET_MAX_UDPADDRESSES = 4
+
+ + + +
+ +
DATA_ALIGNED = 0
+
+ + + +
+ +
INVALID_SOCKET = -1
+
+ + + +
+ +
SOCKET_ERROR = -1
+
+ + + +
+ +
+
+

Procs

+
+ +
proc linked_Version(): ptr Version {...}{.importc: "SDLNet_Linked_Version", cdecl.}
+
+ +
This function gets the version of the dynamically linked SDL_net library.
+   it should NOT be used to fill a version structure, instead you should
+   use the SDL_NET_VERSION() macro.
+ + +
+ +
proc init(): cint {...}{.importc: "SDLNet_Init", cdecl.}
+
+ +
Initialize/Cleanup the network API
+   SDL must be initialized before calls to functions in this library,
+   because this library uses utility functions from the SDL library.
+ + +
+ +
proc quit() {...}{.importc: "SDLNet_Quit", cdecl.}
+
+ + + +
+ +
proc resolveHost(address: ptr IPaddress; host: cstring; port: Uint16): cint {...}{.
+    importc: "SDLNet_ResolveHost", cdecl.}
+
+ + + +
+ +
proc resolveIP(ip: ptr IPaddress): cstring {...}{.importc: "SDLNet_ResolveIP", cdecl.}
+
+ +
Resolve an ip address to a host name in canonical form.
+   If the ip couldn't be resolved, this function returns NULL,
+   otherwise a pointer to a static buffer containing the hostname
+   is returned.  Note that this function is not thread-safe.
+ + +
+ +
proc getLocalAddresses(addresses: ptr IPaddress; maxcount: cint): cint {...}{.
+    importc: "SDLNet_GetLocalAddresses", cdecl.}
+
+ +
Get the addresses of network interfaces on this system.
+   This returns the number of addresses saved in 'addresses'
+ + +
+ +
proc tCP_Open(ip: ptr IPaddress): TCPsocket {...}{.importc: "SDLNet_TCP_Open", cdecl.}
+
+ +
Open a TCP network socket
+   If ip.host is INADDR_NONE or INADDR_ANY, this creates a local server
+   socket on the given port, otherwise a TCP connection to the remote
+   host and port is attempted. The address passed in should already be
+   swapped to network byte order (addresses returned from
+   SDLNet_ResolveHost() are already in the correct form).
+   The newly created socket is returned, or NULL if there was an error.
+ + +
+ +
proc tCP_Accept(server: TCPsocket): TCPsocket {...}{.importc: "SDLNet_TCP_Accept", cdecl.}
+
+ +
Accept an incoming connection on the given server socket.
+   The newly created socket is returned, or NULL if there was an error.
+ + +
+ +
proc tCP_GetPeerAddress(sock: TCPsocket): ptr IPaddress {...}{.
+    importc: "SDLNet_TCP_GetPeerAddress", cdecl.}
+
+ +
Get the IP address of the remote system associated with the socket.
+   If the socket is a server socket, this function returns NULL.
+ + +
+ +
proc tCP_Send(sock: TCPsocket; data: pointer; len: cint): cint {...}{.
+    importc: "SDLNet_TCP_Send", cdecl.}
+
+ +
Send 'len' bytes of 'data' over the non-server socket 'sock'
+   This function returns the actual amount of data sent.  If the return value
+   is less than the amount of data sent, then either the remote connection was
+   closed, or an unknown socket error occurred.
+ + +
+ +
proc tCP_Recv(sock: TCPsocket; data: pointer; maxlen: cint): cint {...}{.
+    importc: "SDLNet_TCP_Recv", cdecl.}
+
+ +
Receive up to 'maxlen' bytes of data over the non-server socket 'sock',
+   and store them in the buffer pointed to by 'data'.
+   This function returns the actual amount of data received.  If the return
+   value is less than or equal to zero, then either the remote connection was
+   closed, or an unknown socket error occurred.
+ + +
+ +
proc tCP_Close(sock: TCPsocket) {...}{.importc: "SDLNet_TCP_Close", cdecl.}
+
+ +
Close a TCP network socket
+ + +
+ +
proc allocPacket(size: cint): ptr UDPpacket {...}{.importc: "SDLNet_AllocPacket", cdecl.}
+
+ +
Allocate/resize/free a single UDP packet 'size' bytes long.
+   The new packet is returned, or NULL if the function ran out of memory.
+ + +
+ +
proc resizePacket(packet: ptr UDPpacket; newsize: cint): cint {...}{.
+    importc: "SDLNet_ResizePacket", cdecl.}
+
+ + + +
+ +
proc freePacket(packet: ptr UDPpacket) {...}{.importc: "SDLNet_FreePacket", cdecl.}
+
+ + + +
+ +
proc allocPacketV(howmany: cint; size: cint): ptr ptr UDPpacket {...}{.
+    importc: "SDLNet_AllocPacketV", cdecl.}
+
+ +
Allocate/Free a UDP packet vector (array of packets) of 'howmany' packets,
+   each 'size' bytes long.
+   A pointer to the first packet in the array is returned, or NULL if the
+   function ran out of memory.
+ + +
+ +
proc freePacketV(packetV: ptr ptr UDPpacket) {...}{.importc: "SDLNet_FreePacketV", cdecl.}
+
+ + + +
+ +
proc uDP_Open(port: Uint16): UDPsocket {...}{.importc: "SDLNet_UDP_Open", cdecl.}
+
+ +
Open a UDP network socket
+   If 'port' is non-zero, the UDP socket is bound to a local port.
+   The 'port' should be given in native byte order, but is used
+   internally in network (big endian) byte order, in addresses, etc.
+   This allows other systems to send to this socket via a known port.
+ + +
+ +
proc uDP_SetPacketLoss(sock: UDPsocket; percent: cint) {...}{.
+    importc: "SDLNet_UDP_SetPacketLoss", cdecl.}
+
+ +
Set the percentage of simulated packet loss for packets sent on the socket.
+ + +
+ +
proc uDP_Bind(sock: UDPsocket; channel: cint; address: ptr IPaddress): cint {...}{.
+    importc: "SDLNet_UDP_Bind", cdecl.}
+
+ +
Bind the address 'address' to the requested channel on the UDP socket.
+   If the channel is -1, then the first unbound channel that has not yet
+   been bound to the maximum number of addresses will be bound with
+   the given address as it's primary address.
+   If the channel is already bound, this new address will be added to the
+   list of valid source addresses for packets arriving on the channel.
+   If the channel is not already bound, then the address becomes the primary
+   address, to which all outbound packets on the channel are sent.
+   This function returns the channel which was bound, or -1 on error.
+ + +
+ +
proc uDP_Unbind(sock: UDPsocket; channel: cint) {...}{.importc: "SDLNet_UDP_Unbind", cdecl.}
+
+ +
Unbind all addresses from the given channel
+ + +
+ +
proc uDP_GetPeerAddress(sock: UDPsocket; channel: cint): ptr IPaddress {...}{.
+    importc: "SDLNet_UDP_GetPeerAddress", cdecl.}
+
+ +
Get the primary IP address of the remote system associated with the
+   socket and channel.  If the channel is -1, then the primary IP port
+   of the UDP socket is returned -- this is only meaningful for sockets
+   opened with a specific port.
+   If the channel is not bound and not -1, this function returns NULL.
+ + +
+ +
proc uDP_SendV(sock: UDPsocket; packets: ptr ptr UDPpacket; npackets: cint): cint {...}{.
+    importc: "SDLNet_UDP_SendV", cdecl.}
+
+ +
Send a vector of packets to the the channels specified within the packet.
+   If the channel specified in the packet is -1, the packet will be sent to
+   the address in the 'src' member of the packet.
+   Each packet will be updated with the status of the packet after it has
+   been sent, -1 if the packet send failed.
+   This function returns the number of packets sent.
+ + +
+ +
proc uDP_Send(sock: UDPsocket; channel: cint; packet: ptr UDPpacket): cint {...}{.
+    importc: "SDLNet_UDP_Send", cdecl.}
+
+ +
Send a single packet to the specified channel.
+   If the channel specified in the packet is -1, the packet will be sent to
+   the address in the 'src' member of the packet.
+   The packet will be updated with the status of the packet after it has
+   been sent.
+   This function returns 1 if the packet was sent, or 0 on error.
+   NOTE:
+   The maximum size of the packet is limited by the MTU (Maximum Transfer Unit)
+   of the transport medium.  It can be as low as 250 bytes for some PPP links,
+   and as high as 1500 bytes for ethernet.
+ + +
+ +
proc uDP_RecvV(sock: UDPsocket; packets: ptr ptr UDPpacket): cint {...}{.
+    importc: "SDLNet_UDP_RecvV", cdecl.}
+
+ +
Receive a vector of pending packets from the UDP socket.
+   The returned packets contain the source address and the channel they arrived
+   on.  If they did not arrive on a bound channel, the the channel will be set
+   to -1.
+   The channels are checked in highest to lowest order, so if an address is
+   bound to multiple channels, the highest channel with the source address
+   bound will be returned.
+   This function returns the number of packets read from the network, or -1
+   on error.  This function does not block, so can return 0 packets pending.
+ + +
+ +
proc uDP_Recv(sock: UDPsocket; packet: ptr UDPpacket): cint {...}{.
+    importc: "SDLNet_UDP_Recv", cdecl.}
+
+ +
Receive a single packet from the UDP socket.
+   The returned packet contains the source address and the channel it arrived
+   on.  If it did not arrive on a bound channel, the the channel will be set
+   to -1.
+   The channels are checked in highest to lowest order, so if an address is
+   bound to multiple channels, the highest channel with the source address
+   bound will be returned.
+   This function returns the number of packets read from the network, or -1
+   on error.  This function does not block, so can return 0 packets pending.
+ + +
+ +
proc uDP_Close(sock: UDPsocket) {...}{.importc: "SDLNet_UDP_Close", cdecl.}
+
+ +
Close a UDP network socket
+ + +
+ +
proc allocSocketSet(maxsockets: cint): SocketSet {...}{.importc: "SDLNet_AllocSocketSet",
+    cdecl.}
+
+ +
Allocate a socket set for use with SDLNet_CheckSockets()
+   This returns a socket set for up to 'maxsockets' sockets, or NULL if
+   the function ran out of memory.
+ + +
+ +
proc addSocket(set: SocketSet; sock: GenericSocket): cint {...}{.
+    importc: "SDLNet_AddSocket", cdecl.}
+
+ +
Add a socket to a set of sockets to be checked for available data
+ + +
+ +
proc delSocket(set: SocketSet; sock: GenericSocket): cint {...}{.
+    importc: "SDLNet_DelSocket", cdecl.}
+
+ +
Remove a socket from a set of sockets to be checked for available data
+ + +
+ +
proc checkSockets(set: SocketSet; timeout: Uint32): cint {...}{.
+    importc: "SDLNet_CheckSockets", cdecl.}
+
+ +
This function checks to see if data is available for reading on the
+   given set of sockets.  If 'timeout' is 0, it performs a quick poll,
+   otherwise the function returns when either data is available for
+   reading, or the timeout in milliseconds has elapsed, which ever occurs
+   first.  This function returns the number of sockets ready for reading,
+   or -1 if there was an error with the select() system call.
+ + +
+ +
proc freeSocketSet(set: SocketSet) {...}{.importc: "SDLNet_FreeSocketSet", cdecl.}
+
+ +
Free a set of sockets allocated by SDL_NetAllocSocketSet()
+ + +
+ +
proc setError(fmt: cstring) {...}{.importc: "SDLNet_SetError", cdecl, varargs.}
+
+ +
+Error reporting functions
+ + +
+ +
proc getError(): cstring {...}{.importc: "SDLNet_GetError", cdecl.}
+
+ + + +
+ +
proc getLastError(): cint {...}{.importc: "SDLNet_GetLastError", cdecl.}
+
+ + + +
+ +
proc setLastError(err: cint) {...}{.importc: "SDLNet_SetLastError", cdecl.}
+
+ + + +
+ +
+ +
+
+ +
+ +
+
+
+ + + diff --git a/docs/sdl2/sdl2_net.idx b/docs/sdl2/sdl2_net.idx new file mode 100644 index 0000000..81bcaf2 --- /dev/null +++ b/docs/sdl2/sdl2_net.idx @@ -0,0 +1,62 @@ +SDLnetStd sdl2/sdl2_net.html#SDLnetStd sdl2_net: SDLnetStd +SDLnetGit sdl2/sdl2_net.html#SDLnetGit sdl2_net: SDLnetGit +SDLnetDL sdl2/sdl2_net.html#SDLnetDL sdl2_net: SDLnetDL +SDLnetStatic sdl2/sdl2_net.html#SDLnetStatic sdl2_net: SDLnetStatic +SDLnetSetVer sdl2/sdl2_net.html#SDLnetSetVer sdl2_net: SDLnetSetVer +SDLnetLPath sdl2/sdl2_net.html#SDLnetLPath sdl2_net: SDLnetLPath +SDLnetPath sdl2/sdl2_net.html#SDLnetPath sdl2_net: SDLnetPath +NET_MAJOR_VERSION sdl2/sdl2_net.html#NET_MAJOR_VERSION sdl2_net: NET_MAJOR_VERSION +NET_MINOR_VERSION sdl2/sdl2_net.html#NET_MINOR_VERSION sdl2_net: NET_MINOR_VERSION +NET_PATCHLEVEL sdl2/sdl2_net.html#NET_PATCHLEVEL sdl2_net: NET_PATCHLEVEL +INADDR_ANY sdl2/sdl2_net.html#INADDR_ANY sdl2_net: INADDR_ANY +INADDR_NONE sdl2/sdl2_net.html#INADDR_NONE sdl2_net: INADDR_NONE +INADDR_LOOPBACK sdl2/sdl2_net.html#INADDR_LOOPBACK sdl2_net: INADDR_LOOPBACK +INADDR_BROADCAST sdl2/sdl2_net.html#INADDR_BROADCAST sdl2_net: INADDR_BROADCAST +SDLNET_MAX_UDPCHANNELS sdl2/sdl2_net.html#SDLNET_MAX_UDPCHANNELS sdl2_net: SDLNET_MAX_UDPCHANNELS +SDLNET_MAX_UDPADDRESSES sdl2/sdl2_net.html#SDLNET_MAX_UDPADDRESSES sdl2_net: SDLNET_MAX_UDPADDRESSES +DATA_ALIGNED sdl2/sdl2_net.html#DATA_ALIGNED sdl2_net: DATA_ALIGNED +Version sdl2/sdl2_net.html#Version sdl2_net: Version +IPaddress sdl2/sdl2_net.html#IPaddress sdl2_net: IPaddress +TCPsocket sdl2/sdl2_net.html#TCPsocket sdl2_net: TCPsocket +UDPsocket sdl2/sdl2_net.html#UDPsocket sdl2_net: UDPsocket +UDPpacket sdl2/sdl2_net.html#UDPpacket sdl2_net: UDPpacket +SocketSet sdl2/sdl2_net.html#SocketSet sdl2_net: SocketSet +GenericSocket sdl2/sdl2_net.html#GenericSocket sdl2_net: GenericSocket +linked_Version sdl2/sdl2_net.html#linked_Version sdl2_net: linked_Version(): ptr Version +init sdl2/sdl2_net.html#init sdl2_net: init(): cint +quit sdl2/sdl2_net.html#quit sdl2_net: quit() +resolveHost sdl2/sdl2_net.html#resolveHost,ptr.IPaddress,cstring,Uint16 sdl2_net: resolveHost(address: ptr IPaddress; host: cstring; port: Uint16): cint +resolveIP sdl2/sdl2_net.html#resolveIP,ptr.IPaddress sdl2_net: resolveIP(ip: ptr IPaddress): cstring +getLocalAddresses sdl2/sdl2_net.html#getLocalAddresses,ptr.IPaddress,cint sdl2_net: getLocalAddresses(addresses: ptr IPaddress; maxcount: cint): cint +tCP_Open sdl2/sdl2_net.html#tCP_Open,ptr.IPaddress sdl2_net: tCP_Open(ip: ptr IPaddress): TCPsocket +tCP_Accept sdl2/sdl2_net.html#tCP_Accept,TCPsocket sdl2_net: tCP_Accept(server: TCPsocket): TCPsocket +tCP_GetPeerAddress sdl2/sdl2_net.html#tCP_GetPeerAddress,TCPsocket sdl2_net: tCP_GetPeerAddress(sock: TCPsocket): ptr IPaddress +tCP_Send sdl2/sdl2_net.html#tCP_Send,TCPsocket,pointer,cint sdl2_net: tCP_Send(sock: TCPsocket; data: pointer; len: cint): cint +tCP_Recv sdl2/sdl2_net.html#tCP_Recv,TCPsocket,pointer,cint sdl2_net: tCP_Recv(sock: TCPsocket; data: pointer; maxlen: cint): cint +tCP_Close sdl2/sdl2_net.html#tCP_Close,TCPsocket sdl2_net: tCP_Close(sock: TCPsocket) +allocPacket sdl2/sdl2_net.html#allocPacket,cint sdl2_net: allocPacket(size: cint): ptr UDPpacket +resizePacket sdl2/sdl2_net.html#resizePacket,ptr.UDPpacket,cint sdl2_net: resizePacket(packet: ptr UDPpacket; newsize: cint): cint +freePacket sdl2/sdl2_net.html#freePacket,ptr.UDPpacket sdl2_net: freePacket(packet: ptr UDPpacket) +allocPacketV sdl2/sdl2_net.html#allocPacketV,cint,cint sdl2_net: allocPacketV(howmany: cint; size: cint): ptr ptr UDPpacket +freePacketV sdl2/sdl2_net.html#freePacketV,ptr.ptr.UDPpacket sdl2_net: freePacketV(packetV: ptr ptr UDPpacket) +uDP_Open sdl2/sdl2_net.html#uDP_Open,Uint16 sdl2_net: uDP_Open(port: Uint16): UDPsocket +uDP_SetPacketLoss sdl2/sdl2_net.html#uDP_SetPacketLoss,UDPsocket,cint sdl2_net: uDP_SetPacketLoss(sock: UDPsocket; percent: cint) +uDP_Bind sdl2/sdl2_net.html#uDP_Bind,UDPsocket,cint,ptr.IPaddress sdl2_net: uDP_Bind(sock: UDPsocket; channel: cint; address: ptr IPaddress): cint +uDP_Unbind sdl2/sdl2_net.html#uDP_Unbind,UDPsocket,cint sdl2_net: uDP_Unbind(sock: UDPsocket; channel: cint) +uDP_GetPeerAddress sdl2/sdl2_net.html#uDP_GetPeerAddress,UDPsocket,cint sdl2_net: uDP_GetPeerAddress(sock: UDPsocket; channel: cint): ptr IPaddress +uDP_SendV sdl2/sdl2_net.html#uDP_SendV,UDPsocket,ptr.ptr.UDPpacket,cint sdl2_net: uDP_SendV(sock: UDPsocket; packets: ptr ptr UDPpacket; npackets: cint): cint +uDP_Send sdl2/sdl2_net.html#uDP_Send,UDPsocket,cint,ptr.UDPpacket sdl2_net: uDP_Send(sock: UDPsocket; channel: cint; packet: ptr UDPpacket): cint +uDP_RecvV sdl2/sdl2_net.html#uDP_RecvV,UDPsocket,ptr.ptr.UDPpacket sdl2_net: uDP_RecvV(sock: UDPsocket; packets: ptr ptr UDPpacket): cint +uDP_Recv sdl2/sdl2_net.html#uDP_Recv,UDPsocket,ptr.UDPpacket sdl2_net: uDP_Recv(sock: UDPsocket; packet: ptr UDPpacket): cint +uDP_Close sdl2/sdl2_net.html#uDP_Close,UDPsocket sdl2_net: uDP_Close(sock: UDPsocket) +allocSocketSet sdl2/sdl2_net.html#allocSocketSet,cint sdl2_net: allocSocketSet(maxsockets: cint): SocketSet +addSocket sdl2/sdl2_net.html#addSocket,SocketSet,GenericSocket sdl2_net: addSocket(set: SocketSet; sock: GenericSocket): cint +delSocket sdl2/sdl2_net.html#delSocket,SocketSet,GenericSocket sdl2_net: delSocket(set: SocketSet; sock: GenericSocket): cint +checkSockets sdl2/sdl2_net.html#checkSockets,SocketSet,Uint32 sdl2_net: checkSockets(set: SocketSet; timeout: Uint32): cint +freeSocketSet sdl2/sdl2_net.html#freeSocketSet,SocketSet sdl2_net: freeSocketSet(set: SocketSet) +setError sdl2/sdl2_net.html#setError,cstring sdl2_net: setError(fmt: cstring) +getError sdl2/sdl2_net.html#getError sdl2_net: getError(): cstring +INVALID_SOCKET sdl2/sdl2_net.html#INVALID_SOCKET sdl2_net: INVALID_SOCKET +SOCKET_ERROR sdl2/sdl2_net.html#SOCKET_ERROR sdl2_net: SOCKET_ERROR +getLastError sdl2/sdl2_net.html#getLastError sdl2_net: getLastError(): cint +setLastError sdl2/sdl2_net.html#setLastError,cint sdl2_net: setLastError(err: cint) diff --git a/docs/sdl2/sdl2_ttf.html b/docs/sdl2/sdl2_ttf.html new file mode 100644 index 0000000..c77b56d --- /dev/null +++ b/docs/sdl2/sdl2_ttf.html @@ -0,0 +1,922 @@ + + + + + + + + + + + + + + + + + + +sdl2/sdl2_ttf + + + + + + + + +
+
+

sdl2/sdl2_ttf

+
+ +
+
+ +

+
+

Imports

+
+sdl2 +
+
+

Types

+
+ +
Font {...}{.incompleteStruct.} = object
+
+ + + +
+ +
+
+

Consts

+
+ +
SDLttfStd = false
+
+ + + +
+ +
SDLttfGit = false
+
+ + + +
+ +
SDLttfDL = true
+
+ + + +
+ +
SDLttfStatic = true
+
+ + + +
+ +
SDLttfSetVer = ""
+
+ + + +
+ +
SDLttfLPath = "/Users/joey/Projects/nim-sdl2/src/build/sdl2_ttf/buildcache/libSDL2_ttf.a"
+
+ + + +
+ +
SDLttfPath = "/Users/joey/Projects/nim-sdl2/src/build/sdl2_ttf/SDL_ttf.h"
+
+ + + +
+ +
SetError = ""
+
+ + + +
+ +
GetError = ""
+
+ + + +
+ +
MAJOR_VERSION = 2
+
+ + + +
+ +
MINOR_VERSION = 0
+
+ + + +
+ +
PATCHLEVEL = 15
+
+ + + +
+ +
UNICODE_BOM_NATIVE = 0x0000FEFF
+
+ + + +
+ +
UNICODE_BOM_SWAPPED = 0x0000FFFE
+
+ + + +
+ +
STYLE_NORMAL = 0x00000000
+
+ + + +
+ +
STYLE_BOLD = 0x00000001
+
+ + + +
+ +
STYLE_ITALIC = 0x00000002
+
+ + + +
+ +
STYLE_UNDERLINE = 0x00000004
+
+ + + +
+ +
STYLE_STRIKETHROUGH = 0x00000008
+
+ + + +
+ +
HINTING_NORMAL = 0
+
+ + + +
+ +
HINTING_LIGHT = 1
+
+ + + +
+ +
HINTING_MONO = 2
+
+ + + +
+ +
HINTING_NONE = 3
+
+ + + +
+ +
+
+

Procs

+
+ +
proc linked_Version(): ptr Version {...}{.importc: "TTF_Linked_Version", cdecl.}
+
+ +
Make sure this is defined (only available in newer SDL versions)
+This function gets the version of the dynamically linked SDL_ttf library.
+   it should NOT be used to fill a version structure, instead you should
+   use the SDL_TTF_VERSION() macro.
+ + +
+ +
proc byteSwappedUNICODE(swapped: cint) {...}{.importc: "TTF_ByteSwappedUNICODE", cdecl.}
+
+ +
This function tells the library whether UNICODE text is generally
+   byteswapped.  A UNICODE BOM character in a string will override
+   this setting for the remainder of that string.
+ + +
+ +
proc init(): cint {...}{.importc: "TTF_Init", cdecl.}
+
+ +
Initialize the TTF engine - returns 0 if successful, -1 on error
+ + +
+ +
proc openFont(file: cstring; ptsize: cint): ptr Font {...}{.importc: "TTF_OpenFont", cdecl.}
+
+ +
Open a font file and create a font of the specified point size.
+ Some .fon fonts will have several sizes embedded in the file, so the
+ point size becomes the index of choosing which size.  If the value
+ is too high, the last indexed size will be the default.
+ + +
+ +
proc openFontIndex(file: cstring; ptsize: cint; index: clong): ptr Font {...}{.
+    importc: "TTF_OpenFontIndex", cdecl.}
+
+ + + +
+ +
proc openFontRW(src: ptr RWops; freesrc: cint; ptsize: cint): ptr Font {...}{.
+    importc: "TTF_OpenFontRW", cdecl.}
+
+ + + +
+ +
proc openFontIndexRW(src: ptr RWops; freesrc: cint; ptsize: cint; index: clong): ptr Font {...}{.
+    importc: "TTF_OpenFontIndexRW", cdecl.}
+
+ + + +
+ +
proc getFontStyle(font: ptr Font): cint {...}{.importc: "TTF_GetFontStyle", cdecl.}
+
+ + + +
+ +
proc setFontStyle(font: ptr Font; style: cint) {...}{.importc: "TTF_SetFontStyle", cdecl.}
+
+ + + +
+ +
proc getFontOutline(font: ptr Font): cint {...}{.importc: "TTF_GetFontOutline", cdecl.}
+
+ + + +
+ +
proc setFontOutline(font: ptr Font; outline: cint) {...}{.importc: "TTF_SetFontOutline",
+    cdecl.}
+
+ + + +
+ +
proc getFontHinting(font: ptr Font): cint {...}{.importc: "TTF_GetFontHinting", cdecl.}
+
+ + + +
+ +
proc setFontHinting(font: ptr Font; hinting: cint) {...}{.importc: "TTF_SetFontHinting",
+    cdecl.}
+
+ + + +
+ +
proc fontHeight(font: ptr Font): cint {...}{.importc: "TTF_FontHeight", cdecl.}
+
+ +
Get the total height of the font - usually equal to point size
+ + +
+ +
proc fontAscent(font: ptr Font): cint {...}{.importc: "TTF_FontAscent", cdecl.}
+
+ +
Get the offset from the baseline to the top of the font
+   This is a positive value, relative to the baseline.
+ + +
+ +
proc fontDescent(font: ptr Font): cint {...}{.importc: "TTF_FontDescent", cdecl.}
+
+ +
Get the offset from the baseline to the bottom of the font
+   This is a negative value, relative to the baseline.
+ + +
+ +
proc fontLineSkip(font: ptr Font): cint {...}{.importc: "TTF_FontLineSkip", cdecl.}
+
+ +
Get the recommended spacing between lines of text for this font
+ + +
+ +
proc getFontKerning(font: ptr Font): cint {...}{.importc: "TTF_GetFontKerning", cdecl.}
+
+ +
Get/Set whether or not kerning is allowed for this font
+ + +
+ +
proc setFontKerning(font: ptr Font; allowed: cint) {...}{.importc: "TTF_SetFontKerning",
+    cdecl.}
+
+ + + +
+ +
proc fontFaces(font: ptr Font): clong {...}{.importc: "TTF_FontFaces", cdecl.}
+
+ +
Get the number of faces of the font
+ + +
+ +
proc fontFaceIsFixedWidth(font: ptr Font): cint {...}{.
+    importc: "TTF_FontFaceIsFixedWidth", cdecl.}
+
+ +
Get the font face attributes, if any
+ + +
+ +
proc fontFaceFamilyName(font: ptr Font): cstring {...}{.importc: "TTF_FontFaceFamilyName",
+    cdecl.}
+
+ + + +
+ +
proc fontFaceStyleName(font: ptr Font): cstring {...}{.importc: "TTF_FontFaceStyleName",
+    cdecl.}
+
+ + + +
+ +
proc glyphIsProvided(font: ptr Font; ch: Uint16): cint {...}{.
+    importc: "TTF_GlyphIsProvided", cdecl.}
+
+ +
Check wether a glyph is provided by the font or not
+ + +
+ +
proc glyphMetrics(font: ptr Font; ch: Uint16; minx: ptr cint; maxx: ptr cint;
+                 miny: ptr cint; maxy: ptr cint; advance: ptr cint): cint {...}{.
+    importc: "TTF_GlyphMetrics", cdecl.}
+
+ +
Get the metrics (dimensions) of a glyph
+   To understand what these metrics mean, here is a useful link:
+    http:freetype.sourceforge.net/freetype2/docs/tutorial/step2.html
+ + +
+ +
proc sizeText(font: ptr Font; text: cstring; w: ptr cint; h: ptr cint): cint {...}{.
+    importc: "TTF_SizeText", cdecl.}
+
+ +
Get the dimensions of a rendered string of text
+ + +
+ +
proc sizeUTF8(font: ptr Font; text: cstring; w: ptr cint; h: ptr cint): cint {...}{.
+    importc: "TTF_SizeUTF8", cdecl.}
+
+ + + +
+ +
proc sizeUNICODE(font: ptr Font; text: ptr Uint16; w: ptr cint; h: ptr cint): cint {...}{.
+    importc: "TTF_SizeUNICODE", cdecl.}
+
+ + + +
+ +
proc renderText_Solid(font: ptr Font; text: cstring; fg: Color): ptr Surface {...}{.
+    importc: "TTF_RenderText_Solid", cdecl.}
+
+ +
Create an 8-bit palettized surface and render the given text at
+   fast quality with the given font and color.  The 0 pixel is the
+   colorkey, giving a transparent background, and the 1 pixel is set
+   to the text color.
+   This function returns the new surface, or NULL if there was an error.
+ + +
+ +
proc renderUTF8_Solid(font: ptr Font; text: cstring; fg: Color): ptr Surface {...}{.
+    importc: "TTF_RenderUTF8_Solid", cdecl.}
+
+ + + +
+ +
proc renderUNICODE_Solid(font: ptr Font; text: ptr Uint16; fg: Color): ptr Surface {...}{.
+    importc: "TTF_RenderUNICODE_Solid", cdecl.}
+
+ + + +
+ +
proc renderGlyph_Solid(font: ptr Font; ch: Uint16; fg: Color): ptr Surface {...}{.
+    importc: "TTF_RenderGlyph_Solid", cdecl.}
+
+ +
Create an 8-bit palettized surface and render the given glyph at
+   fast quality with the given font and color.  The 0 pixel is the
+   colorkey, giving a transparent background, and the 1 pixel is set
+   to the text color.  The glyph is rendered without any padding or
+   centering in the X direction, and aligned normally in the Y direction.
+   This function returns the new surface, or NULL if there was an error.
+ + +
+ +
proc renderText_Shaded(font: ptr Font; text: cstring; fg: Color; bg: Color): ptr Surface {...}{.
+    importc: "TTF_RenderText_Shaded", cdecl.}
+
+ +
Create an 8-bit palettized surface and render the given text at
+   high quality with the given font and colors.  The 0 pixel is background,
+   while other pixels have varying degrees of the foreground color.
+   This function returns the new surface, or NULL if there was an error.
+ + +
+ +
proc renderUTF8_Shaded(font: ptr Font; text: cstring; fg: Color; bg: Color): ptr Surface {...}{.
+    importc: "TTF_RenderUTF8_Shaded", cdecl.}
+
+ + + +
+ +
proc renderUNICODE_Shaded(font: ptr Font; text: ptr Uint16; fg: Color; bg: Color): ptr Surface {...}{.
+    importc: "TTF_RenderUNICODE_Shaded", cdecl.}
+
+ + + +
+ +
proc renderGlyph_Shaded(font: ptr Font; ch: Uint16; fg: Color; bg: Color): ptr Surface {...}{.
+    importc: "TTF_RenderGlyph_Shaded", cdecl.}
+
+ +
Create an 8-bit palettized surface and render the given glyph at
+   high quality with the given font and colors.  The 0 pixel is background,
+   while other pixels have varying degrees of the foreground color.
+   The glyph is rendered without any padding or centering in the X
+   direction, and aligned normally in the Y direction.
+   This function returns the new surface, or NULL if there was an error.
+ + +
+ +
proc renderText_Blended(font: ptr Font; text: cstring; fg: Color): ptr Surface {...}{.
+    importc: "TTF_RenderText_Blended", cdecl.}
+
+ +
Create a 32-bit ARGB surface and render the given text at high quality,
+   using alpha blending to dither the font with the given color.
+   This function returns the new surface, or NULL if there was an error.
+ + +
+ +
proc renderUTF8_Blended(font: ptr Font; text: cstring; fg: Color): ptr Surface {...}{.
+    importc: "TTF_RenderUTF8_Blended", cdecl.}
+
+ + + +
+ +
proc renderUNICODE_Blended(font: ptr Font; text: ptr Uint16; fg: Color): ptr Surface {...}{.
+    importc: "TTF_RenderUNICODE_Blended", cdecl.}
+
+ + + +
+ +
proc renderText_Blended_Wrapped(font: ptr Font; text: cstring; fg: Color;
+                               wrapLength: Uint32): ptr Surface {...}{.
+    importc: "TTF_RenderText_Blended_Wrapped", cdecl.}
+
+ +
Create a 32-bit ARGB surface and render the given text at high quality,
+   using alpha blending to dither the font with the given color.
+   Text is wrapped to multiple lines on line endings and on word boundaries
+   if it extends beyond wrapLength in pixels.
+   This function returns the new surface, or NULL if there was an error.
+ + +
+ +
proc renderUTF8_Blended_Wrapped(font: ptr Font; text: cstring; fg: Color;
+                               wrapLength: Uint32): ptr Surface {...}{.
+    importc: "TTF_RenderUTF8_Blended_Wrapped", cdecl.}
+
+ + + +
+ +
proc renderUNICODE_Blended_Wrapped(font: ptr Font; text: ptr Uint16; fg: Color;
+                                  wrapLength: Uint32): ptr Surface {...}{.
+    importc: "TTF_RenderUNICODE_Blended_Wrapped", cdecl.}
+
+ + + +
+ +
proc renderGlyph_Blended(font: ptr Font; ch: Uint16; fg: Color): ptr Surface {...}{.
+    importc: "TTF_RenderGlyph_Blended", cdecl.}
+
+ +
Create a 32-bit ARGB surface and render the given glyph at high quality,
+   using alpha blending to dither the font with the given color.
+   The glyph is rendered without any padding or centering in the X
+   direction, and aligned normally in the Y direction.
+   This function returns the new surface, or NULL if there was an error.
+ + +
+ +
proc closeFont(font: ptr Font) {...}{.importc: "TTF_CloseFont", cdecl.}
+
+ +
Close an opened font file
+ + +
+ +
proc quit() {...}{.importc: "TTF_Quit", cdecl.}
+
+ +
De-initialize the TTF engine
+ + +
+ +
proc wasInit(): cint {...}{.importc: "TTF_WasInit", cdecl.}
+
+ +
Check if the TTF engine is initialized
+ + +
+ +
proc getFontKerningSize(font: ptr Font; prevIndex: cint; index: cint): cint {...}{.
+    importc: "TTF_GetFontKerningSize", cdecl.}
+
+ +
Get the kerning size of two glyphs indices
+DEPRECATED: this function requires FreeType font indexes, not glyphs,
+   by accident, which we don't expose through this API, so it could give
+   wildly incorrect results, especially with non-ASCII values.
+   Going forward, please use TTF_GetFontKerningSizeGlyphs() instead, which
+   does what you probably expected this function to do.
+ + +
+ +
proc getFontKerningSizeGlyphs(font: ptr Font; previousCh: Uint16; ch: Uint16): cint {...}{.
+    importc: "TTF_GetFontKerningSizeGlyphs", cdecl.}
+
+ +
Get the kerning size of two glyphs
+ + +
+ +
+ +
+
+ +
+ +
+
+
+ + + diff --git a/docs/sdl2/sdl2_ttf.idx b/docs/sdl2/sdl2_ttf.idx new file mode 100644 index 0000000..1047a85 --- /dev/null +++ b/docs/sdl2/sdl2_ttf.idx @@ -0,0 +1,72 @@ +SDLttfStd sdl2/sdl2_ttf.html#SDLttfStd sdl2_ttf: SDLttfStd +SDLttfGit sdl2/sdl2_ttf.html#SDLttfGit sdl2_ttf: SDLttfGit +SDLttfDL sdl2/sdl2_ttf.html#SDLttfDL sdl2_ttf: SDLttfDL +SDLttfStatic sdl2/sdl2_ttf.html#SDLttfStatic sdl2_ttf: SDLttfStatic +SDLttfSetVer sdl2/sdl2_ttf.html#SDLttfSetVer sdl2_ttf: SDLttfSetVer +SDLttfLPath sdl2/sdl2_ttf.html#SDLttfLPath sdl2_ttf: SDLttfLPath +SDLttfPath sdl2/sdl2_ttf.html#SDLttfPath sdl2_ttf: SDLttfPath +SetError sdl2/sdl2_ttf.html#SetError sdl2_ttf: SetError +GetError sdl2/sdl2_ttf.html#GetError sdl2_ttf: GetError +MAJOR_VERSION sdl2/sdl2_ttf.html#MAJOR_VERSION sdl2_ttf: MAJOR_VERSION +MINOR_VERSION sdl2/sdl2_ttf.html#MINOR_VERSION sdl2_ttf: MINOR_VERSION +PATCHLEVEL sdl2/sdl2_ttf.html#PATCHLEVEL sdl2_ttf: PATCHLEVEL +UNICODE_BOM_NATIVE sdl2/sdl2_ttf.html#UNICODE_BOM_NATIVE sdl2_ttf: UNICODE_BOM_NATIVE +UNICODE_BOM_SWAPPED sdl2/sdl2_ttf.html#UNICODE_BOM_SWAPPED sdl2_ttf: UNICODE_BOM_SWAPPED +STYLE_NORMAL sdl2/sdl2_ttf.html#STYLE_NORMAL sdl2_ttf: STYLE_NORMAL +STYLE_BOLD sdl2/sdl2_ttf.html#STYLE_BOLD sdl2_ttf: STYLE_BOLD +STYLE_ITALIC sdl2/sdl2_ttf.html#STYLE_ITALIC sdl2_ttf: STYLE_ITALIC +STYLE_UNDERLINE sdl2/sdl2_ttf.html#STYLE_UNDERLINE sdl2_ttf: STYLE_UNDERLINE +STYLE_STRIKETHROUGH sdl2/sdl2_ttf.html#STYLE_STRIKETHROUGH sdl2_ttf: STYLE_STRIKETHROUGH +HINTING_NORMAL sdl2/sdl2_ttf.html#HINTING_NORMAL sdl2_ttf: HINTING_NORMAL +HINTING_LIGHT sdl2/sdl2_ttf.html#HINTING_LIGHT sdl2_ttf: HINTING_LIGHT +HINTING_MONO sdl2/sdl2_ttf.html#HINTING_MONO sdl2_ttf: HINTING_MONO +HINTING_NONE sdl2/sdl2_ttf.html#HINTING_NONE sdl2_ttf: HINTING_NONE +Font sdl2/sdl2_ttf.html#Font sdl2_ttf: Font +linked_Version sdl2/sdl2_ttf.html#linked_Version sdl2_ttf: linked_Version(): ptr Version +byteSwappedUNICODE sdl2/sdl2_ttf.html#byteSwappedUNICODE,cint sdl2_ttf: byteSwappedUNICODE(swapped: cint) +init sdl2/sdl2_ttf.html#init sdl2_ttf: init(): cint +openFont sdl2/sdl2_ttf.html#openFont,cstring,cint sdl2_ttf: openFont(file: cstring; ptsize: cint): ptr Font +openFontIndex sdl2/sdl2_ttf.html#openFontIndex,cstring,cint,clong sdl2_ttf: openFontIndex(file: cstring; ptsize: cint; index: clong): ptr Font +openFontRW sdl2/sdl2_ttf.html#openFontRW,ptr.RWops,cint,cint sdl2_ttf: openFontRW(src: ptr RWops; freesrc: cint; ptsize: cint): ptr Font +openFontIndexRW sdl2/sdl2_ttf.html#openFontIndexRW,ptr.RWops,cint,cint,clong sdl2_ttf: openFontIndexRW(src: ptr RWops; freesrc: cint; ptsize: cint; index: clong): ptr Font +getFontStyle sdl2/sdl2_ttf.html#getFontStyle,ptr.Font sdl2_ttf: getFontStyle(font: ptr Font): cint +setFontStyle sdl2/sdl2_ttf.html#setFontStyle,ptr.Font,cint sdl2_ttf: setFontStyle(font: ptr Font; style: cint) +getFontOutline sdl2/sdl2_ttf.html#getFontOutline,ptr.Font sdl2_ttf: getFontOutline(font: ptr Font): cint +setFontOutline sdl2/sdl2_ttf.html#setFontOutline,ptr.Font,cint sdl2_ttf: setFontOutline(font: ptr Font; outline: cint) +getFontHinting sdl2/sdl2_ttf.html#getFontHinting,ptr.Font sdl2_ttf: getFontHinting(font: ptr Font): cint +setFontHinting sdl2/sdl2_ttf.html#setFontHinting,ptr.Font,cint sdl2_ttf: setFontHinting(font: ptr Font; hinting: cint) +fontHeight sdl2/sdl2_ttf.html#fontHeight,ptr.Font sdl2_ttf: fontHeight(font: ptr Font): cint +fontAscent sdl2/sdl2_ttf.html#fontAscent,ptr.Font sdl2_ttf: fontAscent(font: ptr Font): cint +fontDescent sdl2/sdl2_ttf.html#fontDescent,ptr.Font sdl2_ttf: fontDescent(font: ptr Font): cint +fontLineSkip sdl2/sdl2_ttf.html#fontLineSkip,ptr.Font sdl2_ttf: fontLineSkip(font: ptr Font): cint +getFontKerning sdl2/sdl2_ttf.html#getFontKerning,ptr.Font sdl2_ttf: getFontKerning(font: ptr Font): cint +setFontKerning sdl2/sdl2_ttf.html#setFontKerning,ptr.Font,cint sdl2_ttf: setFontKerning(font: ptr Font; allowed: cint) +fontFaces sdl2/sdl2_ttf.html#fontFaces,ptr.Font sdl2_ttf: fontFaces(font: ptr Font): clong +fontFaceIsFixedWidth sdl2/sdl2_ttf.html#fontFaceIsFixedWidth,ptr.Font sdl2_ttf: fontFaceIsFixedWidth(font: ptr Font): cint +fontFaceFamilyName sdl2/sdl2_ttf.html#fontFaceFamilyName,ptr.Font sdl2_ttf: fontFaceFamilyName(font: ptr Font): cstring +fontFaceStyleName sdl2/sdl2_ttf.html#fontFaceStyleName,ptr.Font sdl2_ttf: fontFaceStyleName(font: ptr Font): cstring +glyphIsProvided sdl2/sdl2_ttf.html#glyphIsProvided,ptr.Font,Uint16 sdl2_ttf: glyphIsProvided(font: ptr Font; ch: Uint16): cint +glyphMetrics sdl2/sdl2_ttf.html#glyphMetrics,ptr.Font,Uint16,ptr.cint,ptr.cint,ptr.cint,ptr.cint,ptr.cint sdl2_ttf: glyphMetrics(font: ptr Font; ch: Uint16; minx: ptr cint; maxx: ptr cint; miny: ptr cint;\n maxy: ptr cint; advance: ptr cint): cint +sizeText sdl2/sdl2_ttf.html#sizeText,ptr.Font,cstring,ptr.cint,ptr.cint sdl2_ttf: sizeText(font: ptr Font; text: cstring; w: ptr cint; h: ptr cint): cint +sizeUTF8 sdl2/sdl2_ttf.html#sizeUTF8,ptr.Font,cstring,ptr.cint,ptr.cint sdl2_ttf: sizeUTF8(font: ptr Font; text: cstring; w: ptr cint; h: ptr cint): cint +sizeUNICODE sdl2/sdl2_ttf.html#sizeUNICODE,ptr.Font,ptr.Uint16,ptr.cint,ptr.cint sdl2_ttf: sizeUNICODE(font: ptr Font; text: ptr Uint16; w: ptr cint; h: ptr cint): cint +renderText_Solid sdl2/sdl2_ttf.html#renderText_Solid,ptr.Font,cstring,Color sdl2_ttf: renderText_Solid(font: ptr Font; text: cstring; fg: Color): ptr Surface +renderUTF8_Solid sdl2/sdl2_ttf.html#renderUTF8_Solid,ptr.Font,cstring,Color sdl2_ttf: renderUTF8_Solid(font: ptr Font; text: cstring; fg: Color): ptr Surface +renderUNICODE_Solid sdl2/sdl2_ttf.html#renderUNICODE_Solid,ptr.Font,ptr.Uint16,Color sdl2_ttf: renderUNICODE_Solid(font: ptr Font; text: ptr Uint16; fg: Color): ptr Surface +renderGlyph_Solid sdl2/sdl2_ttf.html#renderGlyph_Solid,ptr.Font,Uint16,Color sdl2_ttf: renderGlyph_Solid(font: ptr Font; ch: Uint16; fg: Color): ptr Surface +renderText_Shaded sdl2/sdl2_ttf.html#renderText_Shaded,ptr.Font,cstring,Color,Color sdl2_ttf: renderText_Shaded(font: ptr Font; text: cstring; fg: Color; bg: Color): ptr Surface +renderUTF8_Shaded sdl2/sdl2_ttf.html#renderUTF8_Shaded,ptr.Font,cstring,Color,Color sdl2_ttf: renderUTF8_Shaded(font: ptr Font; text: cstring; fg: Color; bg: Color): ptr Surface +renderUNICODE_Shaded sdl2/sdl2_ttf.html#renderUNICODE_Shaded,ptr.Font,ptr.Uint16,Color,Color sdl2_ttf: renderUNICODE_Shaded(font: ptr Font; text: ptr Uint16; fg: Color; bg: Color): ptr Surface +renderGlyph_Shaded sdl2/sdl2_ttf.html#renderGlyph_Shaded,ptr.Font,Uint16,Color,Color sdl2_ttf: renderGlyph_Shaded(font: ptr Font; ch: Uint16; fg: Color; bg: Color): ptr Surface +renderText_Blended sdl2/sdl2_ttf.html#renderText_Blended,ptr.Font,cstring,Color sdl2_ttf: renderText_Blended(font: ptr Font; text: cstring; fg: Color): ptr Surface +renderUTF8_Blended sdl2/sdl2_ttf.html#renderUTF8_Blended,ptr.Font,cstring,Color sdl2_ttf: renderUTF8_Blended(font: ptr Font; text: cstring; fg: Color): ptr Surface +renderUNICODE_Blended sdl2/sdl2_ttf.html#renderUNICODE_Blended,ptr.Font,ptr.Uint16,Color sdl2_ttf: renderUNICODE_Blended(font: ptr Font; text: ptr Uint16; fg: Color): ptr Surface +renderText_Blended_Wrapped sdl2/sdl2_ttf.html#renderText_Blended_Wrapped,ptr.Font,cstring,Color,Uint32 sdl2_ttf: renderText_Blended_Wrapped(font: ptr Font; text: cstring; fg: Color; wrapLength: Uint32): ptr Surface +renderUTF8_Blended_Wrapped sdl2/sdl2_ttf.html#renderUTF8_Blended_Wrapped,ptr.Font,cstring,Color,Uint32 sdl2_ttf: renderUTF8_Blended_Wrapped(font: ptr Font; text: cstring; fg: Color; wrapLength: Uint32): ptr Surface +renderUNICODE_Blended_Wrapped sdl2/sdl2_ttf.html#renderUNICODE_Blended_Wrapped,ptr.Font,ptr.Uint16,Color,Uint32 sdl2_ttf: renderUNICODE_Blended_Wrapped(font: ptr Font; text: ptr Uint16; fg: Color;\n wrapLength: Uint32): ptr Surface +renderGlyph_Blended sdl2/sdl2_ttf.html#renderGlyph_Blended,ptr.Font,Uint16,Color sdl2_ttf: renderGlyph_Blended(font: ptr Font; ch: Uint16; fg: Color): ptr Surface +closeFont sdl2/sdl2_ttf.html#closeFont,ptr.Font sdl2_ttf: closeFont(font: ptr Font) +quit sdl2/sdl2_ttf.html#quit sdl2_ttf: quit() +wasInit sdl2/sdl2_ttf.html#wasInit sdl2_ttf: wasInit(): cint +getFontKerningSize sdl2/sdl2_ttf.html#getFontKerningSize,ptr.Font,cint,cint sdl2_ttf: getFontKerningSize(font: ptr Font; prevIndex: cint; index: cint): cint +getFontKerningSizeGlyphs sdl2/sdl2_ttf.html#getFontKerningSizeGlyphs,ptr.Font,Uint16,Uint16 sdl2_ttf: getFontKerningSizeGlyphs(font: ptr Font; previousCh: Uint16; ch: Uint16): cint diff --git a/docs/sdl2_gpu.html b/docs/sdl2_gpu.html new file mode 100644 index 0000000..32e047a --- /dev/null +++ b/docs/sdl2_gpu.html @@ -0,0 +1,5723 @@ + + + + + + + + + + + + + + + + + + +sdl2_gpu + + + + + + + + +
+
+

sdl2_gpu

+
+
+
+ +     Dark Mode +
+ +
+ Search: +
+
+ Group by: + +
+ + +
+
+
+ +

+
+

Imports

+
+sdl2 +
+
+

Types

+
+ +
ComparisonEnum = distinct cint
+
+ + + +
+ +
BlendFuncEnum = distinct cint
+
+ + + +
+ +
BlendEqEnum = distinct cint
+
+ + + +
+ +
BlendPresetEnum = distinct cint
+
+ + + +
+ +
FilterEnum = distinct cint
+
+ + + +
+ +
SnapEnum = distinct cint
+
+ + + +
+ +
WrapEnum = distinct cint
+
+ + + +
+ +
FormatEnum = distinct cint
+
+ + + +
+ +
FileFormatEnum = distinct cint
+
+ + + +
+ +
ShaderEnum = distinct cint
+
+ + + +
+ +
ShaderLanguageEnum = distinct cint
+
+ + + +
+ +
ErrorEnum = distinct cint
+
+ + + +
+ +
DebugLevelEnum = distinct cint
+
+ + + +
+ +
LogLevelEnum = enum
+  LOG_LEVEL_INFO = 0, LOG_LEVEL_WARNING, LOG_LEVEL_ERROR
+
+ + + +
+ +
WindowFlagEnum = WindowFlags
+
+ + + +
+ +
Renderer {...}{.bycopy.} = object
+  id*: RendererID
+  requestedId*: RendererID
+  sdlInitFlags*: WindowFlagEnum
+  gpuInitFlags*: InitFlagEnum
+  shaderLanguage*: ShaderLanguageEnum
+  minShaderVersion*: cint
+  maxShaderVersion*: cint
+  enabledFeatures*: FeatureEnum ## ::
+                              ##   ! Current display target
+  currentContextTarget*: ptr Target ## ::
+                                 ##   ! 0 for inverted, 1 for mathematical
+  coordinateMode*: Bool        ## ::
+                      ##   ! Default is (0.5, 0.5) - images draw centered.
+  defaultImageAnchorX*: cfloat
+  defaultImageAnchorY*: cfloat
+  impl*: ptr RendererImpl
+
+
+ +
! \ingroup Initialization
+  @{
+ + +
+ +
Target {...}{.bycopy.} = object
+  renderer*: ptr Renderer
+  contextTarget*: ptr Target
+  image*: ptr Image
+  data*: pointer
+  w*: Uint16
+  h*: Uint16
+  usingVirtualResolution*: Bool
+  baseW*: Uint16               ## ::
+               ##   The true dimensions of the underlying image or window
+  baseH*: Uint16               ## ::
+               ##   The true dimensions of the underlying image or window
+  useClipRect*: Bool
+  clipRect*: Rect
+  useColor*: Bool
+  color*: Color
+  viewport*: Rect              ## ::
+                ##   ! Perspective and object viewing transforms.
+  matrixMode*: cint
+  projectionMatrix*: MatrixStack
+  viewMatrix*: MatrixStack
+  modelMatrix*: MatrixStack
+  camera*: Camera
+  useCamera*: Bool
+  useDepthTest*: Bool
+  useDepthWrite*: Bool
+  depthFunction*: ComparisonEnum ## ::
+                               ##   ! Renderer context data.  NULL if the target does not represent a window or rendering context.
+  context*: ptr Context
+  refcount*: cint
+  isAlias*: Bool
+
+
+ +
! \ingroup Initialization
+ Important GPU features which may not be supported depending on a device's extension support.  Can be bitwise OR'd together.
+ \see GPU_IsFeatureEnabled()
+ \see GPU_SetRequiredFeatures()
+ + +
+ +
Rect {...}{.bycopy.} = object
+  x*: cfloat
+  y*: cfloat
+  w*: cfloat
+  h*: cfloat
+
+
+ +
!
+ \defgroup Initialization Initialization
+ \defgroup Logging Debugging, Logging, and Error Handling
+ \defgroup RendererSetup Renderer Setup
+ \defgroup RendererControls Renderer Controls
+ \defgroup ContextControls Context Controls
+ \defgroup TargetControls Target Controls
+ \defgroup SurfaceControls Surface Controls
+ \defgroup ImageControls Image Controls
+ \defgroup Conversions Surface, Image, and Target Conversions
+ \defgroup Matrix Matrix Controls
+ \defgroup Rendering Rendering
+ \defgroup Shapes Shapes
+ \defgroup ShaderInterface Shader Interface
+! \ingroup Rendering
+ A struct representing a rectangular area with floating point precision.
+ \see GPU_MakeRect()
+ + +
+ +
RendererEnum = Uint32
+
+ + + +
+ +
RendererID {...}{.bycopy.} = object
+  name*: cstring
+  renderer*: RendererEnum
+  majorVersion*: cint
+  minorVersion*: cint
+
+
+ +
! \ingroup Initialization
+ \ingroup RendererSetup
+ \ingroup RendererControls
+ Renderer ID object for identifying a specific renderer.
+ \see GPU_MakeRendererID()
+ \see GPU_InitRendererByID()
+ + +
+ +
BlendMode {...}{.bycopy.} = object
+  sourceColor*: BlendFuncEnum
+  destColor*: BlendFuncEnum
+  sourceAlpha*: BlendFuncEnum
+  destAlpha*: BlendFuncEnum
+  colorEquation*: BlendEqEnum
+  alphaEquation*: BlendEqEnum
+
+
+ +
! \ingroup ImageControls
+ Blend mode storage struct
+ + +
+ +
Image {...}{.bycopy.} = object
+  renderer*: ptr Renderer
+  contextTarget*: ptr Target
+  target*: ptr Target
+  w*: Uint16
+  h*: Uint16
+  usingVirtualResolution*: Bool
+  format*: FormatEnum
+  numLayers*: cint
+  bytesPerPixel*: cint
+  baseW*: Uint16               ## ::
+               ##   Original image dimensions
+  baseH*: Uint16               ## ::
+               ##   Original image dimensions
+  textureW*: Uint16            ## ::
+                  ##   Underlying texture dimensions
+  textureH*: Uint16            ## ::
+                  ##   Underlying texture dimensions
+  hasMipmaps*: Bool
+  anchorX*: cfloat             ## ::
+                 ##   Normalized coords for the point at which the image is blitted.  Default is (0.5, 0.5), that is, the image is drawn centered.
+  anchorY*: cfloat             ## ::
+                 ##   These are interpreted according to GPU_SetCoordinateMode() and range from (0.0 - 1.0) normally.
+  color*: Color
+  useBlending*: Bool
+  blendMode*: BlendMode
+  filterMode*: FilterEnum
+  snapMode*: SnapEnum
+  wrapModeX*: WrapEnum
+  wrapModeY*: WrapEnum
+  data*: pointer
+  refcount*: cint
+  isAlias*: Bool
+
+
+ +
! \ingroup ImageControls
+ Image object for containing pixel/texture data.
+ A GPU_Image can be created with GPU_CreateImage(), GPU_LoadImage(), GPU_CopyImage(), or GPU_CopyImageFromSurface().
+ Free the memory with GPU_FreeImage() when you're done.
+ \see GPU_CreateImage()
+ \see GPU_LoadImage()
+ \see GPU_CopyImage()
+ \see GPU_CopyImageFromSurface()
+ \see GPU_Target
+ + +
+ +
TextureHandle = ptr uint
+
+ +
! \ingroup ImageControls
+ A backend-neutral type that is intended to hold a backend-specific handle/pointer to a texture.
+ \see GPU_CreateImageUsingTexture()
+ \see GPU_GetTextureHandle()
+ + +
+ +
Camera {...}{.bycopy.} = object
+  x*: cfloat
+  y*: cfloat
+  z*: cfloat
+  angle*: cfloat
+  zoomX*: cfloat
+  zoomY*: cfloat
+  zNear*: cfloat               ## ::
+               ##   z clipping planes
+  zFar*: cfloat                ## ::
+              ##   z clipping planes
+  useCenteredOrigin*: Bool     ## ::
+                         ##   move rotation/scaling origin to the center of the camera's view
+  
+
+ +
! \ingroup TargetControls
+ Camera object that determines viewing transform.
+ \see GPU_SetCamera()
+ \see GPU_GetDefaultCamera()
+ \see GPU_GetCamera()
+ + +
+ +
ShaderBlock {...}{.bycopy.} = object
+  positionLoc*: cint
+  texcoordLoc*: cint
+  colorLoc*: cint              ## ::
+                ##   Uniforms
+  modelViewProjectionLoc*: cint
+
+
+ +
! \ingroup ShaderInterface
+ Container for the built-in shader attribute and uniform locations (indices).
+ \see GPU_LoadShaderBlock()
+ \see GPU_SetShaderBlock()
+ + +
+ +
MatrixStack {...}{.bycopy.} = object
+  storageSize*: cuint
+  size*: cuint
+  matrix*: ptr ptr cfloat
+
+
+ +
! \ingroup Matrix
+ Matrix stack data structure for global vertex transforms.
+ + +
+ +
Context {...}{.bycopy.} = object
+  context*: pointer
+  failed*: Bool                ## ::
+              ##   ! SDL window ID
+  windowID*: Uint32            ## ::
+                  ##   ! Actual window dimensions
+  windowW*: cint
+  windowH*: cint               ## ::
+               ##   ! Drawable region dimensions
+  drawableW*: cint
+  drawableH*: cint             ## ::
+                 ##   ! Window dimensions for restoring windowed mode after GPU_SetFullscreen(1,1).
+  storedWindowW*: cint
+  storedWindowH*: cint         ## ::
+                     ##   ! Last target used
+  activeTarget*: ptr Target     ## ::
+                         ##   ! Internal state
+  currentShaderProgram*: Uint32
+  defaultTexturedShaderProgram*: Uint32
+  defaultUntexturedShaderProgram*: Uint32
+  currentShaderBlock*: ShaderBlock
+  defaultTexturedShaderBlock*: ShaderBlock
+  defaultUntexturedShaderBlock*: ShaderBlock
+  shapesUseBlending*: Bool
+  shapesBlendMode*: BlendMode
+  lineThickness*: cfloat
+  useTexturing*: Bool
+  refcount*: cint
+  data*: pointer
+
+
+ +
! \ingroup ContextControls
+ Rendering context data.  Only GPU_Targets which represent windows will store this.
+ + +
+ +
FeatureEnum = Uint32
+
+ +
! \ingroup Initialization
+ Important GPU features which may not be supported depending on a device's extension support.  Can be bitwise OR'd together.
+ \see GPU_IsFeatureEnabled()
+ \see GPU_SetRequiredFeatures()
+ + +
+ +
InitFlagEnum = Uint32
+
+ +
! \ingroup Initialization
+ Initialization flags for changing default init parameters.  Can be bitwise OR'ed together.
+ Default (0) is to use late swap vsync and double buffering.
+ \see GPU_SetPreInitFlags()
+ \see GPU_GetPreInitFlags()
+ + +
+ +
PrimitiveEnum = Uint32
+
+ +
! \ingroup Rendering
+ Primitive types for rendering arbitrary geometry.  The values are intentionally identical to the GL_ primitives.
+ \see GPU_PrimitiveBatch()
+ \see GPU_PrimitiveBatchV()
+ + +
+ +
BatchFlagEnum = Uint32
+
+ +
! Bit flags for geometry batching.
+ \see GPU_TriangleBatch()
+ \see GPU_TriangleBatchX()
+ \see GPU_PrimitiveBatch()
+ \see GPU_PrimitiveBatchV()
+ + +
+ +
FlipEnum = Uint32
+
+ +
! Bit flags for blitting into a rectangular region.
+ \see GPU_BlitRect
+ \see GPU_BlitRectX
+ + +
+ +
TypeEnum = Uint32
+
+ +
! \ingroup ShaderInterface
+ Type enumeration for GPU_AttributeFormat specifications.
+ + +
+ +
AttributeFormat {...}{.bycopy.} = object
+  isPerSprite*: Bool           ## ::
+                   ##   Per-sprite values are expanded to 4 vertices
+  numElemsPerValue*: cint
+  kind*: TypeEnum              ## ::
+                ##   GPU_TYPE_FLOAT, GPU_TYPE_INT, GPU_TYPE_UNSIGNED_INT, etc.
+  normalize*: Bool
+  strideBytes*: cint           ## ::
+                   ##   Number of bytes between two vertex specifications
+  offsetBytes*: cint           ## ::
+                   ##   Number of bytes to skip at the beginning of 'values'
+  
+
+ +
! \ingroup ShaderInterface
+ + +
+ +
Attribute {...}{.bycopy.} = object
+  location*: cint
+  values*: pointer             ## ::
+                 ##   Expect 4 values for each sprite
+  format*: AttributeFormat
+
+
+ +
! \ingroup ShaderInterface
+ + +
+ +
AttributeSource {...}{.bycopy.} = object
+  enabled*: Bool
+  numValues*: cint
+  nextValue*: pointer          ## ::
+                    ##   Automatic storage format
+  perVertexStorageStrideBytes*: cint
+  perVertexStorageOffsetBytes*: cint
+  perVertexStorageSize*: cint  ## ::
+                            ##   Over 0 means that the per-vertex storage has been automatically allocated
+  perVertexStorage*: pointer   ## ::
+                           ##   Could point to the attribute's values or to allocated storage
+  attribute*: Attribute
+
+
+ +
! \ingroup ShaderInterface
+ + +
+ +
ErrorObject {...}{.bycopy.} = object
+  function*: cstring
+  error*: ErrorEnum
+  details*: cstring
+
+
+ +
! \ingroup Logging
+ + +
+ +
RendererImpl {...}{.incompleteStruct.} = object
+
+ + + +
+ +
+
+

Consts

+
+ +
SDLgpuStd = false
+
+ + + +
+ +
SDLgpuGit = true
+
+ + + +
+ +
SDLgpuDL = false
+
+ + + +
+ +
SDLgpuStatic = true
+
+ + + +
+ +
SDLgpuSetVer = ""
+
+ + + +
+ +
SDLgpuLPath = "/Users/joey/Projects/nim-sdl2/src/build/sdl2_gpu/buildcache/SDL_gpu-0.11.0/lib/libSDL2_gpu.a"
+
+ + + +
+ +
SDLgpuPath = "/Users/joey/Projects/nim-sdl2/src/build/sdl2_gpu/include/SDL_gpu.h"
+
+ + + +
+ +
NONE = 0'u
+
+ + + +
+ +
FEATURE_NON_POWER_OF_TWO = 1'u
+
+ + + +
+ +
FEATURE_RENDER_TARGETS = 2'u
+
+ + + +
+ +
FEATURE_BLEND_EQUATIONS = 4'u
+
+ + + +
+ +
FEATURE_BLEND_FUNC_SEPARATE = 8'u
+
+ + + +
+ +
FEATURE_BLEND_EQUATIONS_SEPARATE = 16'u
+
+ + + +
+ +
FEATURE_GL_BGR = 32'u
+
+ + + +
+ +
FEATURE_GL_BGRA = 64'u
+
+ + + +
+ +
FEATURE_GL_ABGR = 128'u
+
+ + + +
+ +
FEATURE_VERTEX_SHADER = 256'u
+
+ + + +
+ +
FEATURE_FRAGMENT_SHADER = 512'u
+
+ + + +
+ +
FEATURE_PIXEL_SHADER = 512'u
+
+ + + +
+ +
FEATURE_GEOMETRY_SHADER = 1024'u
+
+ + + +
+ +
FEATURE_WRAP_REPEAT_MIRRORED = 2048'u
+
+ + + +
+ +
FEATURE_CORE_FRAMEBUFFER_OBJECTS = 4096'u
+
+ + + +
+ +
FEATURE_ALL_BASE = 2'u
+
+ + + +
+ +
FEATURE_ALL_BLEND_PRESETS = 12'u32
+
+ + + +
+ +
FEATURE_ALL_GL_FORMATS = 224'u32
+
+ + + +
+ +
FEATURE_BASIC_SHADERS = 768'u32
+
+ + + +
+ +
FEATURE_ALL_SHADERS = 1792'u32
+
+ + + +
+ +
INIT_ENABLE_VSYNC = 1'u
+
+ + + +
+ +
INIT_DISABLE_VSYNC = 2'u
+
+ + + +
+ +
INIT_DISABLE_DOUBLE_BUFFER = 4'u
+
+ + + +
+ +
INIT_DISABLE_AUTO_VIRTUAL_RESOLUTION = 8'u
+
+ + + +
+ +
INIT_REQUEST_COMPATIBILITY_PROFILE = 16'u
+
+ + + +
+ +
INIT_USE_ROW_BY_ROW_TEXTURE_UPLOAD_FALLBACK = 32'u
+
+ + + +
+ +
INIT_USE_COPY_TEXTURE_UPLOAD_FALLBACK = 64'u
+
+ + + +
+ +
POINTS = 0'u
+
+ + + +
+ +
LINES = 1'u
+
+ + + +
+ +
LINE_LOOP = 2'u
+
+ + + +
+ +
LINE_STRIP = 3'u
+
+ + + +
+ +
TRIANGLES = 4'u
+
+ + + +
+ +
TRIANGLE_STRIP = 5'u
+
+ + + +
+ +
TRIANGLE_FAN = 6'u
+
+ + + +
+ +
BATCH_XY = 1'u
+
+ + + +
+ +
BATCH_XYZ = 2'u
+
+ + + +
+ +
BATCH_ST = 4'u
+
+ + + +
+ +
BATCH_RGB = 8'u
+
+ + + +
+ +
BATCH_RGBA = 16'u
+
+ + + +
+ +
BATCH_RGB8 = 32'u
+
+ + + +
+ +
BATCH_RGBA8 = 64'u
+
+ + + +
+ +
BATCH_XY_ST = 5'u32
+
+ + + +
+ +
BATCH_XYZ_ST = 6'u32
+
+ + + +
+ +
BATCH_XY_RGB = 9'u32
+
+ + + +
+ +
BATCH_XYZ_RGB = 10'u32
+
+ + + +
+ +
BATCH_XY_RGBA = 17'u32
+
+ + + +
+ +
BATCH_XYZ_RGBA = 18'u32
+
+ + + +
+ +
BATCH_XY_ST_RGBA = 21'u32
+
+ + + +
+ +
BATCH_XYZ_ST_RGBA = 22'u32
+
+ + + +
+ +
BATCH_XY_RGB8 = 33'u32
+
+ + + +
+ +
BATCH_XYZ_RGB8 = 34'u32
+
+ + + +
+ +
BATCH_XY_RGBA8 = 65'u32
+
+ + + +
+ +
BATCH_XYZ_RGBA8 = 66'u32
+
+ + + +
+ +
BATCH_XY_ST_RGBA8 = 69'u32
+
+ + + +
+ +
BATCH_XYZ_ST_RGBA8 = 70'u32
+
+ + + +
+ +
FLIP_NONE = 0'u
+
+ + + +
+ +
FLIP_HORIZONTAL = 1'u
+
+ + + +
+ +
FLIP_VERTICAL = 2'u
+
+ + + +
+ +
TYPE_BYTE = 5120'u
+
+ + + +
+ +
TYPE_UNSIGNED_BYTE = 5121'u
+
+ + + +
+ +
TYPE_SHORT = 5122'u
+
+ + + +
+ +
TYPE_UNSIGNED_SHORT = 5123'u
+
+ + + +
+ +
TYPE_INT = 5124'u
+
+ + + +
+ +
TYPE_UNSIGNED_INT = 5125'u
+
+ + + +
+ +
TYPE_FLOAT = 5126'u
+
+ + + +
+ +
TYPE_DOUBLE = 5130'u
+
+ + + +
+ +
RENDERER_UNKNOWN = 0'u
+
+ + + +
+ +
RENDERER_OPENGL_1_BASE = 1'u
+
+ + + +
+ +
RENDERER_OPENGL_1 = 2'u
+
+ + + +
+ +
RENDERER_OPENGL_2 = 3'u
+
+ + + +
+ +
RENDERER_OPENGL_3 = 4'u
+
+ + + +
+ +
RENDERER_OPENGL_4 = 5'u
+
+ + + +
+ +
RENDERER_GLES_1 = 11'u
+
+ + + +
+ +
RENDERER_GLES_2 = 12'u
+
+ + + +
+ +
RENDERER_GLES_3 = 13'u
+
+ + + +
+ +
RENDERER_D3D9 = 21'u
+
+ + + +
+ +
RENDERER_D3D10 = 22'u
+
+ + + +
+ +
RENDERER_D3D11 = 23'u
+
+ + + +
+ +
GPU_VERSION_MAJOR = 0
+
+ + + +
+ +
GPU_VERSION_MINOR = 11
+
+ + + +
+ +
GPU_VERSION_PATCH = 0
+
+ + + +
+ +
HAVE_STDC = 1
+
+ + + +
+ +
HAVE_GNUC = 1
+
+ + + +
+ +
HAVE_MSVC = 0
+
+ + + +
+ +
FALSE = 0
+
+ + + +
+ +
TRUE = 1
+
+ + + +
+ +
RENDERER_ORDER_MAX = 10
+
+ + + +
+ +
RENDERER_CUSTOM_0 = 1000
+
+ + + +
+ +
NEVER = 512'i32
+
+ + + +
+ +
LESS = 513'i32
+
+ + + +
+ +
EQUAL = 514'i32
+
+ + + +
+ +
LEQUAL = 515'i32
+
+ + + +
+ +
GREATER = 516'i32
+
+ + + +
+ +
NOTEQUAL = 517'i32
+
+ + + +
+ +
GEQUAL = 518'i32
+
+ + + +
+ +
ALWAYS = 519'i32
+
+ + + +
+ +
FUNC_ZERO = 0'i32
+
+ + + +
+ +
FUNC_ONE = 1'i32
+
+ + + +
+ +
FUNC_SRC_COLOR = 768'i32
+
+ + + +
+ +
FUNC_DST_COLOR = 774'i32
+
+ + + +
+ +
FUNC_ONE_MINUS_SRC = 769'i32
+
+ + + +
+ +
FUNC_ONE_MINUS_DST = 775'i32
+
+ + + +
+ +
FUNC_SRC_ALPHA = 770'i32
+
+ + + +
+ +
FUNC_DST_ALPHA = 772'i32
+
+ + + +
+ +
FUNC_ONE_MINUS_SRC_ALPHA = 771'i32
+
+ + + +
+ +
FUNC_ONE_MINUS_DST_ALPHA = 773'i32
+
+ + + +
+ +
EQ_ADD = 32774'i32
+
+ + + +
+ +
EQ_SUBTRACT = 32778'i32
+
+ + + +
+ +
EQ_REVERSE_SUBTRACT = 32779'i32
+
+ + + +
+ +
BLEND_NORMAL = 0'i32
+
+ + + +
+ +
BLEND_PREMULTIPLIED_ALPHA = 1'i32
+
+ + + +
+ +
BLEND_MULTIPLY = 2'i32
+
+ + + +
+ +
BLEND_ADD = 3'i32
+
+ + + +
+ +
BLEND_SUBTRACT = 4'i32
+
+ + + +
+ +
BLEND_MOD_ALPHA = 5'i32
+
+ + + +
+ +
BLEND_SET_ALPHA = 6'i32
+
+ + + +
+ +
BLEND_SET = 7'i32
+
+ + + +
+ +
BLEND_NORMAL_KEEP_ALPHA = 8'i32
+
+ + + +
+ +
BLEND_NORMAL_ADD_ALPHA = 9'i32
+
+ + + +
+ +
BLEND_NORMAL_FACTOR_ALPHA = 10'i32
+
+ + + +
+ +
FILTER_NEAREST = 0'i32
+
+ + + +
+ +
FILTER_LINEAR = 1'i32
+
+ + + +
+ +
FILTER_LINEAR_MIPMAP = 2'i32
+
+ + + +
+ +
SNAP_NONE = 0'i32
+
+ + + +
+ +
SNAP_POSITION = 1'i32
+
+ + + +
+ +
SNAP_DIMENSIONS = 2'i32
+
+ + + +
+ +
SNAP_POSITION_AND_DIMENSIONS = 3'i32
+
+ + + +
+ +
WRAP_NONE = 0'i32
+
+ + + +
+ +
WRAP_REPEAT = 1'i32
+
+ + + +
+ +
WRAP_MIRRORED = 2'i32
+
+ + + +
+ +
FORMAT_LUMINANCE = 1'i32
+
+ + + +
+ +
FORMAT_LUMINANCE_ALPHA = 2'i32
+
+ + + +
+ +
FORMAT_RGB = 3'i32
+
+ + + +
+ +
FORMAT_RGBA = 4'i32
+
+ + + +
+ +
FORMAT_ALPHA = 5'i32
+
+ + + +
+ +
FORMAT_RG = 6'i32
+
+ + + +
+ +
FORMAT_YCbCr422 = 7'i32
+
+ + + +
+ +
FORMAT_YCbCr420P = 8'i32
+
+ + + +
+ +
FORMAT_BGR = 9'i32
+
+ + + +
+ +
FORMAT_BGRA = 10'i32
+
+ + + +
+ +
FORMAT_ABGR = 11'i32
+
+ + + +
+ +
FILE_AUTO = 0'i32
+
+ + + +
+ +
FILE_PNG = 1
+
+ + + +
+ +
FILE_BMP = 2
+
+ + + +
+ +
FILE_TGA = 3
+
+ + + +
+ +
MODEL = 0
+
+ + + +
+ +
VIEW = 1
+
+ + + +
+ +
PROJECTION = 2
+
+ + + +
+ +
DEFAULT_INIT_FLAGS = 0
+
+ + + +
+ +
VERTEX_SHADER = 0'i32
+
+ + + +
+ +
FRAGMENT_SHADER = 1'i32
+
+ + + +
+ +
PIXEL_SHADER = 1'i32
+
+ + + +
+ +
GEOMETRY_SHADER = 2'i32
+
+ + + +
+ +
LANGUAGE_NONE = 0'i32
+
+ + + +
+ +
LANGUAGE_ARB_ASSEMBLY = 1'i32
+
+ + + +
+ +
LANGUAGE_GLSL = 2'i32
+
+ + + +
+ +
LANGUAGE_GLSLES = 3'i32
+
+ + + +
+ +
LANGUAGE_HLSL = 4'i32
+
+ + + +
+ +
LANGUAGE_CG = 5'i32
+
+ + + +
+ +
ERROR_NONE = 0'i32
+
+ + + +
+ +
ERROR_BACKEND_ERROR = 1'i32
+
+ + + +
+ +
ERROR_DATA_ERROR = 2'i32
+
+ + + +
+ +
ERROR_USER_ERROR = 3'i32
+
+ + + +
+ +
ERROR_UNSUPPORTED_FUNCTION = 4'i32
+
+ + + +
+ +
ERROR_NULL_ARGUMENT = 5'i32
+
+ + + +
+ +
ERROR_FILE_NOT_FOUND = 6'i32
+
+ + + +
+ +
DEBUG_LEVEL_0 = 0'i32
+
+ + + +
+ +
DEBUG_LEVEL_1 = 1'i32
+
+ + + +
+ +
DEBUG_LEVEL_2 = 2'i32
+
+ + + +
+ +
DEBUG_LEVEL_3 = 3'i32
+
+ + + +
+ +
DEBUG_LEVEL_MAX = 3'i32
+
+ + + +
+ +
+
+

Procs

+
+ +
proc getLinkedVersion(): Version {...}{.importc: "GPU_GetLinkedVersion", cdecl.}
+
+ + + +
+ +
proc setInitWindow(windowID: Uint32) {...}{.importc: "GPU_SetInitWindow", cdecl.}
+
+ +
! The window corresponding to 'windowID' will be used to create the rendering context instead of creating a new window.
+ + +
+ +
proc getInitWindow(): Uint32 {...}{.importc: "GPU_GetInitWindow", cdecl.}
+
+ +
! Returns the window ID that has been set via GPU_SetInitWindow().
+ + +
+ +
proc setPreInitFlags(flags: InitFlagEnum) {...}{.importc: "GPU_SetPreInitFlags", cdecl.}
+
+ +
! Set special flags to use for initialization. Set these before calling GPU_Init().
+ \param GPU_flags An OR'ed combination of GPU_InitFlagEnum flags.  Default flags (0) enable late swap vsync and double buffering.
+ + +
+ +
proc getPreInitFlags(): InitFlagEnum {...}{.importc: "GPU_GetPreInitFlags", cdecl.}
+
+ +
! Returns the current special flags to use for initialization.
+ + +
+ +
proc setRequiredFeatures(features: FeatureEnum) {...}{.
+    importc: "GPU_SetRequiredFeatures", cdecl.}
+
+ +
! Set required features to use for initialization. Set these before calling GPU_Init().
+ \param features An OR'ed combination of GPU_FeatureEnum flags.  Required features will force GPU_Init() to create a renderer that supports all of the given flags or else fail.
+ + +
+ +
proc getRequiredFeatures(): FeatureEnum {...}{.importc: "GPU_GetRequiredFeatures", cdecl.}
+
+ +
! Returns the current required features to use for initialization.
+ + +
+ +
proc getDefaultRendererOrder(orderSize: ptr cint; order: ptr RendererID) {...}{.
+    importc: "GPU_GetDefaultRendererOrder", cdecl.}
+
+ +
! Gets the default initialization renderer IDs for the current platform copied into the 'order' array and the number of renderer IDs into 'order_size'.  Pass NULL for 'order' to just get the size of the renderer order array.  Will return at most GPU_RENDERER_ORDER_MAX renderers.
+ + +
+ +
proc getRendererOrder(orderSize: ptr cint; order: ptr RendererID) {...}{.
+    importc: "GPU_GetRendererOrder", cdecl.}
+
+ +
! Gets the current renderer ID order for initialization copied into the 'order' array and the number of renderer IDs into 'order_size'.  Pass NULL for 'order' to just get the size of the renderer order array.
+ + +
+ +
proc setRendererOrder(orderSize: cint; order: ptr RendererID) {...}{.
+    importc: "GPU_SetRendererOrder", cdecl.}
+
+ +
! Sets the renderer ID order to use for initialization.  If 'order' is NULL, it will restore the default order.
+ + +
+ +
proc init(w: Uint16; h: Uint16; flags: WindowFlagEnum): ptr Target {...}{.importc: "GPU_Init",
+    cdecl.}
+
+ +
! Initializes SDL's video subsystem (if necessary) and all of SDL_gpu's internal structures.
+ Chooses a renderer and creates a window with the given dimensions and window creation flags.
+ A pointer to the resulting window's render target is returned.
+ 
+ \param w Desired window width in pixels
+ \param h Desired window height in pixels
+ \param SDL_flags The bit flags to pass to SDL when creating the window.  Use GPU_DEFAULT_INIT_FLAGS if you don't care.
+ \return On success, returns the new context target (i.e. render target backed by a window).  On failure, returns NULL.
+ 
+ Initializes these systems:
+  The 'error queue': Stores error codes and description strings.
+  The 'renderer registry': An array of information about the supported renderers on the current platform,
+    such as the renderer name and id and its life cycle functions.
+  The SDL library and its video subsystem: Calls SDL_Init() if SDL has not already been initialized.
+    Use SDL_InitSubsystem() to initialize more parts of SDL.
+  The current renderer:  Walks through each renderer in the renderer registry and tries to initialize them until one succeeds.
+ 
+ \see GPU_RendererID
+ \see GPU_InitRenderer()
+ \see GPU_InitRendererByID()
+ \see GPU_SetRendererOrder()
+ \see GPU_PushErrorCode()
+ + +
+ +
proc initRenderer(rendererEnum: RendererEnum; w: Uint16; h: Uint16;
+                 flags: WindowFlagEnum): ptr Target {...}{.importc: "GPU_InitRenderer",
+    cdecl.}
+
+ +
! Initializes SDL and SDL_gpu.  Creates a window and the requested renderer context.
+ + +
+ +
proc initRendererByID(rendererRequest: RendererID; w: Uint16; h: Uint16;
+                     flags: WindowFlagEnum): ptr Target {...}{.
+    importc: "GPU_InitRendererByID", cdecl.}
+
+ +
! Initializes SDL and SDL_gpu.  Creates a window and the requested renderer context.
+ By requesting a renderer via ID, you can specify the major and minor versions of an individual renderer backend.
+ \see GPU_MakeRendererID
+ + +
+ +
proc isFeatureEnabled(feature: FeatureEnum): Bool {...}{.importc: "GPU_IsFeatureEnabled",
+    cdecl.}
+
+ +
! Checks for important GPU features which may not be supported depending on a device's extension support.  Feature flags (GPU_FEATURE_) can be bitwise OR'd together.
+ \return 1 if all of the passed features are enabled/supported
+ \return 0 if any of the passed features are disabled/unsupported
+ + +
+ +
proc closeCurrentRenderer() {...}{.importc: "GPU_CloseCurrentRenderer", cdecl.}
+
+ +
! Clean up the renderer state.
+ + +
+ +
proc quit() {...}{.importc: "GPU_Quit", cdecl.}
+
+ +
! Clean up the renderer state and shut down SDL_gpu.
+ + +
+ +
proc setDebugLevel(level: DebugLevelEnum) {...}{.importc: "GPU_SetDebugLevel", cdecl.}
+
+ +
! \ingroup Logging
+  @{
+! Sets the global debug level.
+ GPU_DEBUG_LEVEL_0: Normal
+ GPU_DEBUG_LEVEL_1: Prints messages when errors are pushed via GPU_PushErrorCode()
+ GPU_DEBUG_LEVEL_2: Elevates warning logs to error priority
+ GPU_DEBUG_LEVEL_3: Elevates info logs to error priority
+ + +
+ +
proc getDebugLevel(): DebugLevelEnum {...}{.importc: "GPU_GetDebugLevel", cdecl.}
+
+ +
! Returns the current global debug level.
+ + +
+ +
proc logInfo(format: cstring) {...}{.importc: "GPU_LogInfo", cdecl, varargs.}
+
+ +
! Prints an informational log message.
+ + +
+ +
proc logWarning(format: cstring) {...}{.importc: "GPU_LogWarning", cdecl, varargs.}
+
+ +
! Prints a warning log message.
+ + +
+ +
proc logError(format: cstring) {...}{.importc: "GPU_LogError", cdecl, varargs.}
+
+ +
! Prints an error log message.
+ + +
+ +
proc setLogCallback(callback: proc (logLevel: LogLevelEnum; format: cstring;
+                                 args: va_list): cint {...}{.cdecl.}) {...}{.
+    importc: "GPU_SetLogCallback", cdecl.}
+
+ +
! Sets a custom callback for handling logging.  Use stdio's vsnprintf() to process the va_list into a string.  Passing NULL as the callback will reset to the default internal logging.
+ + +
+ +
proc pushErrorCode(function: cstring; error: ErrorEnum; details: cstring) {...}{.
+    importc: "GPU_PushErrorCode", cdecl, varargs.}
+
+ +
! Pushes a new error code into the error queue.  If the queue is full, the queue is not modified.
+ \param function The name of the function that pushed the error
+ \param error The error code to push on the error queue
+ \param details Additional information string, can be NULL.
+ + +
+ +
proc popErrorCode(): ErrorObject {...}{.importc: "GPU_PopErrorCode", cdecl.}
+
+ +
! Pops an error object from the error queue and returns it.  If the error queue is empty, it returns an error object with NULL function, GPU_ERROR_NONE error, and NULL details.
+ + +
+ +
proc getErrorString(error: ErrorEnum): cstring {...}{.importc: "GPU_GetErrorString", cdecl.}
+
+ +
! Gets the string representation of an error code.
+ + +
+ +
proc setErrorQueueMax(max: cuint) {...}{.importc: "GPU_SetErrorQueueMax", cdecl.}
+
+ +
! Changes the maximum number of error objects that SDL_gpu will store.  This deletes all currently stored errors.
+ + +
+ +
proc makeRendererID(name: cstring; renderer: RendererEnum; majorVersion: cint;
+                   minorVersion: cint): RendererID {...}{.importc: "GPU_MakeRendererID",
+    cdecl.}
+
+ +
End of Logging
+! @}
+! \ingroup RendererSetup
+  @{
+! Returns an initialized GPU_RendererID.
+ + +
+ +
proc getRendererID(renderer: RendererEnum): RendererID {...}{.
+    importc: "GPU_GetRendererID", cdecl.}
+
+ +
! Gets the first registered renderer identifier for the given enum value.
+ + +
+ +
proc getNumRegisteredRenderers(): cint {...}{.importc: "GPU_GetNumRegisteredRenderers",
+                                      cdecl.}
+
+ +
! Gets the number of registered (available) renderers.
+ + +
+ +
proc getRegisteredRendererList(renderersArray: ptr RendererID) {...}{.
+    importc: "GPU_GetRegisteredRendererList", cdecl.}
+
+ +
! Gets an array of identifiers for the registered (available) renderers.
+ + +
+ +
proc registerRenderer(id: RendererID; createRenderer: proc (request: RendererID): ptr Renderer {...}{.
+    cdecl.}; freeRenderer: proc (renderer: ptr Renderer) {...}{.cdecl.}) {...}{.
+    importc: "GPU_RegisterRenderer", cdecl.}
+
+ +
! Prepares a renderer for use by SDL_gpu.
+ + +
+ +
proc reserveNextRendererEnum(): RendererEnum {...}{.
+    importc: "GPU_ReserveNextRendererEnum", cdecl.}
+
+ +
End of RendererSetup
+! @}
+! \ingroup RendererControls
+  @{
+! Gets the next enum ID that can be used for a custom renderer.
+ + +
+ +
proc getNumActiveRenderers(): cint {...}{.importc: "GPU_GetNumActiveRenderers", cdecl.}
+
+ +
! Gets the number of active (created) renderers.
+ + +
+ +
proc getActiveRendererList(renderersArray: ptr RendererID) {...}{.
+    importc: "GPU_GetActiveRendererList", cdecl.}
+
+ +
! Gets an array of identifiers for the active renderers.
+ + +
+ +
proc getCurrentRenderer(): ptr Renderer {...}{.importc: "GPU_GetCurrentRenderer", cdecl.}
+
+ +
! \return The current renderer
+ + +
+ +
proc setCurrentRenderer(id: RendererID) {...}{.importc: "GPU_SetCurrentRenderer", cdecl.}
+
+ +
! Switches the current renderer to the renderer matching the given identifier.
+ + +
+ +
proc getRenderer(id: RendererID): ptr Renderer {...}{.importc: "GPU_GetRenderer", cdecl.}
+
+ +
! \return The renderer matching the given identifier.
+ + +
+ +
proc freeRenderer(renderer: ptr Renderer) {...}{.importc: "GPU_FreeRenderer", cdecl.}
+
+ + + +
+ +
proc resetRendererState() {...}{.importc: "GPU_ResetRendererState", cdecl.}
+
+ +
! Reapplies the renderer state to the backend API (e.g. OpenGL, Direct3D).  Use this if you want SDL_gpu to be able to render after you've used direct backend calls.
+ + +
+ +
proc setCoordinateMode(useMathCoords: Bool) {...}{.importc: "GPU_SetCoordinateMode", cdecl.}
+
+ +
! Sets the coordinate mode for this renderer.  Target and image coordinates will be either "inverted" (0,0 is the upper left corner, y increases downward) or "mathematical" (0,0 is the bottom-left corner, y increases upward).
+ The default is inverted (0), as this is traditional for 2D graphics.
+ \param inverted 0 is for inverted coordinates, 1 is for mathematical coordinates
+ + +
+ +
proc getCoordinateMode(): Bool {...}{.importc: "GPU_GetCoordinateMode", cdecl.}
+
+ + + +
+ +
proc setDefaultAnchor(anchorX: cfloat; anchorY: cfloat) {...}{.
+    importc: "GPU_SetDefaultAnchor", cdecl.}
+
+ +
! Sets the default image blitting anchor for newly created images.
+ \see GPU_SetAnchor
+ + +
+ +
proc getDefaultAnchor(anchorX: ptr cfloat; anchorY: ptr cfloat) {...}{.
+    importc: "GPU_GetDefaultAnchor", cdecl.}
+
+ +
! Returns the default image blitting anchor through the given variables.
+ \see GPU_GetAnchor
+ + +
+ +
proc getContextTarget(): ptr Target {...}{.importc: "GPU_GetContextTarget", cdecl.}
+
+ +
End of RendererControls
+! @}
+Context / window controls
+! \ingroup ContextControls
+  @{
+! \return The renderer's current context target.
+ + +
+ +
proc getWindowTarget(windowID: Uint32): ptr Target {...}{.importc: "GPU_GetWindowTarget",
+    cdecl.}
+
+ +
! \return The target that is associated with the given windowID.
+ + +
+ +
proc createTargetFromWindow(windowID: Uint32): ptr Target {...}{.
+    importc: "GPU_CreateTargetFromWindow", cdecl.}
+
+ +
! Creates a separate context for the given window using the current renderer and returns a GPU_Target that represents it.
+ + +
+ +
proc makeCurrent(target: ptr Target; windowID: Uint32) {...}{.importc: "GPU_MakeCurrent",
+    cdecl.}
+
+ +
! Makes the given window the current rendering destination for the given context target.
+ This also makes the target the current context for image loading and window operations.
+ If the target does not represent a window, this does nothing.
+ + +
+ +
proc setWindowResolution(w: Uint16; h: Uint16): Bool {...}{.
+    importc: "GPU_SetWindowResolution", cdecl.}
+
+ +
! Change the actual size of the current context target's window.  This resets the virtual resolution and viewport of the context target.
+ Aside from direct resolution changes, this should also be called in response to SDL_WINDOWEVENT_RESIZED window events for resizable windows.
+ + +
+ +
proc setFullscreen(enableFullscreen: Bool; useDesktopResolution: Bool): Bool {...}{.
+    importc: "GPU_SetFullscreen", cdecl.}
+
+ +
! Enable/disable fullscreen mode for the current context target's window.
+ On some platforms, this may destroy the renderer context and require that textures be reloaded.  Unfortunately, SDL does not provide a notification mechanism for this.
+ \param enable_fullscreen If true, make the application go fullscreen.  If false, make the application go to windowed mode.
+ \param use_desktop_resolution If true, lets the window change its resolution when it enters fullscreen mode (via SDL_WINDOW_FULLSCREEN_DESKTOP).
+ \return 0 if the new mode is windowed, 1 if the new mode is fullscreen.
+ + +
+ +
proc getFullscreen(): Bool {...}{.importc: "GPU_GetFullscreen", cdecl.}
+
+ +
! Returns true if the current context target's window is in fullscreen mode.
+ + +
+ +
proc getActiveTarget(): ptr Target {...}{.importc: "GPU_GetActiveTarget", cdecl.}
+
+ +
! \return Returns the last active target.
+ + +
+ +
proc setActiveTarget(target: ptr Target): Bool {...}{.importc: "GPU_SetActiveTarget", cdecl.}
+
+ +
! \return Sets the currently active target for matrix modification functions.
+ + +
+ +
proc setShapeBlending(enable: Bool) {...}{.importc: "GPU_SetShapeBlending", cdecl.}
+
+ +
! Enables/disables alpha blending for shape rendering on the current window.
+ + +
+ +
proc getBlendModeFromPreset(preset: BlendPresetEnum): BlendMode {...}{.
+    importc: "GPU_GetBlendModeFromPreset", cdecl.}
+
+ +
! Translates a blend preset into a blend mode.
+ + +
+ +
proc setShapeBlendFunction(sourceColor: BlendFuncEnum; destColor: BlendFuncEnum;
+                          sourceAlpha: BlendFuncEnum; destAlpha: BlendFuncEnum) {...}{.
+    importc: "GPU_SetShapeBlendFunction", cdecl.}
+
+ +
! Sets the blending component functions for shape rendering.
+ + +
+ +
proc setShapeBlendEquation(colorEquation: BlendEqEnum; alphaEquation: BlendEqEnum) {...}{.
+    importc: "GPU_SetShapeBlendEquation", cdecl.}
+
+ +
! Sets the blending component equations for shape rendering.
+ + +
+ +
proc setShapeBlendMode(mode: BlendPresetEnum) {...}{.importc: "GPU_SetShapeBlendMode",
+    cdecl.}
+
+ +
! Sets the blending mode for shape rendering on the current window, if supported by the renderer.
+ + +
+ +
proc setLineThickness(thickness: cfloat): cfloat {...}{.importc: "GPU_SetLineThickness",
+    cdecl.}
+
+ +
! Sets the thickness of lines for the current context.
+ \param thickness New line thickness in pixels measured across the line.  Default is 1.0f.
+ \return The old thickness value
+ + +
+ +
proc getLineThickness(): cfloat {...}{.importc: "GPU_GetLineThickness", cdecl.}
+
+ +
! Returns the current line thickness value.
+ + +
+ +
proc createAliasTarget(target: ptr Target): ptr Target {...}{.
+    importc: "GPU_CreateAliasTarget", cdecl.}
+
+ +
End of ContextControls
+! @}
+! \ingroup TargetControls
+  @{
+! Creates a target that aliases the given target.  Aliases can be used to store target settings (e.g. viewports) for easy switching.
+ GPU_FreeTarget() frees the alias's memory, but does not affect the original.
+ + +
+ +
proc loadTarget(image: ptr Image): ptr Target {...}{.importc: "GPU_LoadTarget", cdecl.}
+
+ +
! Creates a new render target from the given image.  It can then be accessed from image->target.  This increments the internal refcount of the target, so it should be matched with a GPU_FreeTarget().
+ + +
+ +
proc getTarget(image: ptr Image): ptr Target {...}{.importc: "GPU_GetTarget", cdecl.}
+
+ +
! Creates a new render target from the given image.  It can then be accessed from image->target.  This does not increment the internal refcount of the target, so it will be invalidated when the image is freed.
+ + +
+ +
proc freeTarget(target: ptr Target) {...}{.importc: "GPU_FreeTarget", cdecl.}
+
+ +
! Deletes a render target in the proper way for this renderer.
+ + +
+ +
proc setVirtualResolution(target: ptr Target; w: Uint16; h: Uint16) {...}{.
+    importc: "GPU_SetVirtualResolution", cdecl.}
+
+ +
! Change the logical size of the given target.  Rendering to this target will be scaled as if the dimensions were actually the ones given.
+ + +
+ +
proc getVirtualResolution(target: ptr Target; w: ptr Uint16; h: ptr Uint16) {...}{.
+    importc: "GPU_GetVirtualResolution", cdecl.}
+
+ +
! Query the logical size of the given target.
+ + +
+ +
proc getVirtualCoords(target: ptr Target; x: ptr cfloat; y: ptr cfloat; displayX: cfloat;
+                     displayY: cfloat) {...}{.importc: "GPU_GetVirtualCoords", cdecl.}
+
+ +
! Converts screen space coordinates (such as from mouse input) to logical drawing coordinates.  This interacts with GPU_SetCoordinateMode() when the y-axis is flipped (screen space is assumed to be inverted: (0,0) in the upper-left corner).
+ + +
+ +
proc unsetVirtualResolution(target: ptr Target) {...}{.
+    importc: "GPU_UnsetVirtualResolution", cdecl.}
+
+ +
! Reset the logical size of the given target to its original value.
+ + +
+ +
proc makeRect(x: cfloat; y: cfloat; w: cfloat; h: cfloat): Rect {...}{.importc: "GPU_MakeRect",
+    cdecl.}
+
+ +
! \return A GPU_Rect with the given values.
+ + +
+ +
proc makeColor(r: Uint8; g: Uint8; b: Uint8; a: Uint8): Color {...}{.importc: "GPU_MakeColor",
+    cdecl.}
+
+ +
! \return An SDL_Color with the given values.
+ + +
+ +
proc setViewport(target: ptr Target; viewport: Rect) {...}{.importc: "GPU_SetViewport", cdecl.}
+
+ +
! Sets the given target's viewport.
+ + +
+ +
proc unsetViewport(target: ptr Target) {...}{.importc: "GPU_UnsetViewport", cdecl.}
+
+ +
! Resets the given target's viewport to the entire target area.
+ + +
+ +
proc getDefaultCamera(): Camera {...}{.importc: "GPU_GetDefaultCamera", cdecl.}
+
+ +
! \return A GPU_Camera with position (0, 0, 0), angle of 0, zoom of 1, centered origin, and near/far clipping planes of -100 and 100.
+ + +
+ +
proc getCamera(target: ptr Target): Camera {...}{.importc: "GPU_GetCamera", cdecl.}
+
+ +
! \return The camera of the given render target.  If target is NULL, returns the default camera.
+ + +
+ +
proc setCamera(target: ptr Target; cam: ptr Camera): Camera {...}{.importc: "GPU_SetCamera",
+    cdecl.}
+
+ +
! Sets the current render target's current camera.
+ \param target A pointer to the target that will copy this camera.
+ \param cam A pointer to the camera data to use or NULL to use the default camera.
+ \return The old camera.
+ + +
+ +
proc enableCamera(target: ptr Target; useCamera: Bool) {...}{.importc: "GPU_EnableCamera",
+    cdecl.}
+
+ +
! Enables or disables using the built-in camera matrix transforms.
+ + +
+ +
proc isCameraEnabled(target: ptr Target): Bool {...}{.importc: "GPU_IsCameraEnabled", cdecl.}
+
+ +
! Returns 1 if the camera transforms are enabled, 0 otherwise.
+ + +
+ +
proc addDepthBuffer(target: ptr Target): Bool {...}{.importc: "GPU_AddDepthBuffer", cdecl.}
+
+ +
! Attach a new depth buffer to the given target so that it can use depth testing.  Context targets automatically have a depth buffer already.
+  If successful, also enables depth testing for this target.
+ + +
+ +
proc setDepthTest(target: ptr Target; enable: Bool) {...}{.importc: "GPU_SetDepthTest", cdecl.}
+
+ +
! Enables or disables the depth test, which will skip drawing pixels/fragments behind other fragments.  Disabled by default.
+  This has implications for alpha blending, where compositing might not work correctly depending on render order.
+ + +
+ +
proc setDepthWrite(target: ptr Target; enable: Bool) {...}{.importc: "GPU_SetDepthWrite",
+    cdecl.}
+
+ +
! Enables or disables writing the depth (effective view z-coordinate) of new pixels to the depth buffer.  Enabled by default, but you must call GPU_SetDepthTest() to use it.
+ + +
+ +
proc setDepthFunction(target: ptr Target; compareOperation: ComparisonEnum) {...}{.
+    importc: "GPU_SetDepthFunction", cdecl.}
+
+ +
! Sets the operation to perform when depth testing.
+ + +
+ +
proc getPixel(target: ptr Target; x: Sint16; y: Sint16): Color {...}{.importc: "GPU_GetPixel",
+    cdecl.}
+
+ +
! \return The RGBA color of a pixel.
+ + +
+ +
proc setClipRect(target: ptr Target; rect: Rect): Rect {...}{.importc: "GPU_SetClipRect",
+    cdecl.}
+
+ +
! Sets the clipping rect for the given render target.
+ + +
+ +
proc setClip(target: ptr Target; x: Sint16; y: Sint16; w: Uint16; h: Uint16): Rect {...}{.
+    importc: "GPU_SetClip", cdecl.}
+
+ +
! Sets the clipping rect for the given render target.
+ + +
+ +
proc unsetClip(target: ptr Target) {...}{.importc: "GPU_UnsetClip", cdecl.}
+
+ +
! Turns off clipping for the given target.
+ + +
+ +
proc intersectRect(A: Rect; B: Rect; result: ptr Rect): Bool {...}{.
+    importc: "GPU_IntersectRect", cdecl.}
+
+ +
! Returns GPU_TRUE if the given rects A and B overlap, in which case it also fills the given result rect with the intersection.  `result` can be NULL if you don't need the intersection.
+ + +
+ +
proc intersectClipRect(target: ptr Target; B: Rect; result: ptr Rect): Bool {...}{.
+    importc: "GPU_IntersectClipRect", cdecl.}
+
+ +
! Returns GPU_TRUE if the given target's clip rect and the given B rect overlap, in which case it also fills the given result rect with the intersection.  `result` can be NULL if you don't need the intersection.
+ If the target doesn't have a clip rect enabled, this uses the whole target area.
+ + +
+ +
proc setTargetColor(target: ptr Target; color: Color) {...}{.importc: "GPU_SetTargetColor",
+    cdecl.}
+
+ +
! Sets the modulation color for subsequent drawing of images and shapes on the given target.
+  This has a cumulative effect with the image coloring functions.
+  e.g. GPU_SetRGB(image, 255, 128, 0); GPU_SetTargetRGB(target, 128, 128, 128);
+  Would make the image draw with color of roughly (128, 64, 0).
+ + +
+ +
proc setTargetRGB(target: ptr Target; r: Uint8; g: Uint8; b: Uint8) {...}{.
+    importc: "GPU_SetTargetRGB", cdecl.}
+
+ +
! Sets the modulation color for subsequent drawing of images and shapes on the given target.
+  This has a cumulative effect with the image coloring functions.
+  e.g. GPU_SetRGB(image, 255, 128, 0); GPU_SetTargetRGB(target, 128, 128, 128);
+  Would make the image draw with color of roughly (128, 64, 0).
+ + +
+ +
proc setTargetRGBA(target: ptr Target; r: Uint8; g: Uint8; b: Uint8; a: Uint8) {...}{.
+    importc: "GPU_SetTargetRGBA", cdecl.}
+
+ +
! Sets the modulation color for subsequent drawing of images and shapes on the given target.
+  This has a cumulative effect with the image coloring functions.
+  e.g. GPU_SetRGB(image, 255, 128, 0); GPU_SetTargetRGB(target, 128, 128, 128);
+  Would make the image draw with color of roughly (128, 64, 0).
+ + +
+ +
proc unsetTargetColor(target: ptr Target) {...}{.importc: "GPU_UnsetTargetColor", cdecl.}
+
+ +
! Unsets the modulation color for subsequent drawing of images and shapes on the given target.
+  This has the same effect as coloring with pure opaque white (255, 255, 255, 255).
+ + +
+ +
proc loadSurface(filename: cstring): ptr Surface {...}{.importc: "GPU_LoadSurface", cdecl.}
+
+ +
End of TargetControls
+! @}
+! \ingroup SurfaceControls
+  @{
+! Load surface from an image file that is supported by this renderer.  Don't forget to SDL_FreeSurface() it.
+ + +
+ +
proc loadSurface_RW(rwops: ptr RWops; freeRwops: Bool): ptr Surface {...}{.
+    importc: "GPU_LoadSurface_RW", cdecl.}
+
+ +
! Load surface from an image file in memory.  Don't forget to SDL_FreeSurface() it.
+ + +
+ +
proc saveSurface(surface: ptr Surface; filename: cstring; format: FileFormatEnum): Bool {...}{.
+    importc: "GPU_SaveSurface", cdecl.}
+
+ +
! Save surface to a file.
+ With a format of GPU_FILE_AUTO, the file type is deduced from the extension.  Supported formats are: png, bmp, tga.
+ Returns 0 on failure.
+ + +
+ +
proc saveSurface_RW(surface: ptr Surface; rwops: ptr RWops; freeRwops: Bool;
+                   format: FileFormatEnum): Bool {...}{.importc: "GPU_SaveSurface_RW",
+    cdecl.}
+
+ +
! Save surface to a RWops stream.
+ Does not support format of GPU_FILE_AUTO, because the file type cannot be deduced.  Supported formats are: png, bmp, tga.
+ Returns 0 on failure.
+ + +
+ +
proc createImage(w: Uint16; h: Uint16; format: FormatEnum): ptr Image {...}{.
+    importc: "GPU_CreateImage", cdecl.}
+
+ +
End of SurfaceControls
+! @}
+! \ingroup ImageControls
+  @{
+! Create a new, blank image with the given format.  Don't forget to GPU_FreeImage() it.
+       \param w Image width in pixels
+       \param h Image height in pixels
+       \param format Format of color channels.
+ + +
+ +
proc createImageUsingTexture(handle: TextureHandle; takeOwnership: Bool): ptr Image {...}{.
+    importc: "GPU_CreateImageUsingTexture", cdecl.}
+
+ +
! Create a new image that uses the given native texture handle as the image texture.
+ + +
+ +
proc loadImage(filename: cstring): ptr Image {...}{.importc: "GPU_LoadImage", cdecl.}
+
+ +
! Load image from an image file that is supported by this renderer.  Don't forget to GPU_FreeImage() it.
+ + +
+ +
proc loadImage_RW(rwops: ptr RWops; freeRwops: Bool): ptr Image {...}{.
+    importc: "GPU_LoadImage_RW", cdecl.}
+
+ +
! Load image from an image file in memory.  Don't forget to GPU_FreeImage() it.
+ + +
+ +
proc createAliasImage(image: ptr Image): ptr Image {...}{.importc: "GPU_CreateAliasImage",
+    cdecl.}
+
+ +
! Creates an image that aliases the given image.  Aliases can be used to store image settings (e.g. modulation color) for easy switching.
+ GPU_FreeImage() frees the alias's memory, but does not affect the original.
+ + +
+ +
proc copyImage(image: ptr Image): ptr Image {...}{.importc: "GPU_CopyImage", cdecl.}
+
+ +
! Copy an image to a new image.  Don't forget to GPU_FreeImage() both.
+ + +
+ +
proc freeImage(image: ptr Image) {...}{.importc: "GPU_FreeImage", cdecl.}
+
+ +
! Deletes an image in the proper way for this renderer.  Also deletes the corresponding GPU_Target if applicable.  Be careful not to use that target afterward!
+ + +
+ +
proc setImageVirtualResolution(image: ptr Image; w: Uint16; h: Uint16) {...}{.
+    importc: "GPU_SetImageVirtualResolution", cdecl.}
+
+ +
! Change the logical size of the given image.  Rendering this image will scaled it as if the dimensions were actually the ones given.
+ + +
+ +
proc unsetImageVirtualResolution(image: ptr Image) {...}{.
+    importc: "GPU_UnsetImageVirtualResolution", cdecl.}
+
+ +
! Reset the logical size of the given image to its original value.
+ + +
+ +
proc updateImage(image: ptr Image; imageRect: ptr Rect; surface: ptr Surface;
+                surfaceRect: ptr Rect) {...}{.importc: "GPU_UpdateImage", cdecl.}
+
+ +
! Update an image from surface data.  Ignores virtual resolution on the image so the number of pixels needed from the surface is known.
+ + +
+ +
proc updateImageBytes(image: ptr Image; imageRect: ptr Rect; bytes: ptr cuchar;
+                     bytesPerRow: cint) {...}{.importc: "GPU_UpdateImageBytes", cdecl.}
+
+ +
! Update an image from an array of pixel data.  Ignores virtual resolution on the image so the number of pixels needed from the surface is known.
+ + +
+ +
proc replaceImage(image: ptr Image; surface: ptr Surface; surfaceRect: ptr Rect): Bool {...}{.
+    importc: "GPU_ReplaceImage", cdecl.}
+
+ +
! Update an image from surface data, replacing its underlying texture to allow for size changes.  Ignores virtual resolution on the image so the number of pixels needed from the surface is known.
+ + +
+ +
proc saveImage(image: ptr Image; filename: cstring; format: FileFormatEnum): Bool {...}{.
+    importc: "GPU_SaveImage", cdecl.}
+
+ +
! Save image to a file.
+ With a format of GPU_FILE_AUTO, the file type is deduced from the extension.  Supported formats are: png, bmp, tga.
+ Returns 0 on failure.
+ + +
+ +
proc saveImage_RW(image: ptr Image; rwops: ptr RWops; freeRwops: Bool;
+                 format: FileFormatEnum): Bool {...}{.importc: "GPU_SaveImage_RW", cdecl.}
+
+ +
! Save image to a RWops stream.
+ Does not support format of GPU_FILE_AUTO, because the file type cannot be deduced.  Supported formats are: png, bmp, tga.
+ Returns 0 on failure.
+ + +
+ +
proc generateMipmaps(image: ptr Image) {...}{.importc: "GPU_GenerateMipmaps", cdecl.}
+
+ +
! Loads mipmaps for the given image, if supported by the renderer.
+ + +
+ +
proc setColor(image: ptr Image; color: Color) {...}{.importc: "GPU_SetColor", cdecl.}
+
+ +
! Sets the modulation color for subsequent drawing of the given image.
+ + +
+ +
proc setRGB(image: ptr Image; r: Uint8; g: Uint8; b: Uint8) {...}{.importc: "GPU_SetRGB", cdecl.}
+
+ +
! Sets the modulation color for subsequent drawing of the given image.
+ + +
+ +
proc setRGBA(image: ptr Image; r: Uint8; g: Uint8; b: Uint8; a: Uint8) {...}{.
+    importc: "GPU_SetRGBA", cdecl.}
+
+ +
! Sets the modulation color for subsequent drawing of the given image.
+ + +
+ +
proc unsetColor(image: ptr Image) {...}{.importc: "GPU_UnsetColor", cdecl.}
+
+ +
! Unsets the modulation color for subsequent drawing of the given image.
+  This is equivalent to coloring with pure opaque white (255, 255, 255, 255).
+ + +
+ +
proc getBlending(image: ptr Image): Bool {...}{.importc: "GPU_GetBlending", cdecl.}
+
+ +
! Gets the current alpha blending setting.
+ + +
+ +
proc setBlending(image: ptr Image; enable: Bool) {...}{.importc: "GPU_SetBlending", cdecl.}
+
+ +
! Enables/disables alpha blending for the given image.
+ + +
+ +
proc setBlendFunction(image: ptr Image; sourceColor: BlendFuncEnum;
+                     destColor: BlendFuncEnum; sourceAlpha: BlendFuncEnum;
+                     destAlpha: BlendFuncEnum) {...}{.importc: "GPU_SetBlendFunction",
+    cdecl.}
+
+ +
! Sets the blending component functions.
+ + +
+ +
proc setBlendEquation(image: ptr Image; colorEquation: BlendEqEnum;
+                     alphaEquation: BlendEqEnum) {...}{.
+    importc: "GPU_SetBlendEquation", cdecl.}
+
+ +
! Sets the blending component equations.
+ + +
+ +
proc setBlendMode(image: ptr Image; mode: BlendPresetEnum) {...}{.
+    importc: "GPU_SetBlendMode", cdecl.}
+
+ +
! Sets the blending mode, if supported by the renderer.
+ + +
+ +
proc setImageFilter(image: ptr Image; filter: FilterEnum) {...}{.
+    importc: "GPU_SetImageFilter", cdecl.}
+
+ +
! Sets the image filtering mode, if supported by the renderer.
+ + +
+ +
proc setAnchor(image: ptr Image; anchorX: cfloat; anchorY: cfloat) {...}{.
+    importc: "GPU_SetAnchor", cdecl.}
+
+ +
! Sets the image anchor, which is the point about which the image is blitted.  The default is to blit the image on-center (0.5, 0.5).  The anchor is in normalized coordinates (0.0-1.0).
+ + +
+ +
proc getAnchor(image: ptr Image; anchorX: ptr cfloat; anchorY: ptr cfloat) {...}{.
+    importc: "GPU_GetAnchor", cdecl.}
+
+ +
! Returns the image anchor via the passed parameters.  The anchor is in normalized coordinates (0.0-1.0).
+ + +
+ +
proc getSnapMode(image: ptr Image): SnapEnum {...}{.importc: "GPU_GetSnapMode", cdecl.}
+
+ +
! Gets the current pixel snap setting.  The default value is GPU_SNAP_POSITION_AND_DIMENSIONS.
+ + +
+ +
proc setSnapMode(image: ptr Image; mode: SnapEnum) {...}{.importc: "GPU_SetSnapMode", cdecl.}
+
+ +
! Sets the pixel grid snapping mode for the given image.
+ + +
+ +
proc setWrapMode(image: ptr Image; wrapModeX: WrapEnum; wrapModeY: WrapEnum) {...}{.
+    importc: "GPU_SetWrapMode", cdecl.}
+
+ +
! Sets the image wrapping mode, if supported by the renderer.
+ + +
+ +
proc getTextureHandle(image: ptr Image): TextureHandle {...}{.
+    importc: "GPU_GetTextureHandle", cdecl.}
+
+ +
! Returns the backend-specific texture handle associated with the given image.  Note that SDL_gpu will be unaware of changes made to the texture.
+ + +
+ +
proc copyImageFromSurface(surface: ptr Surface): ptr Image {...}{.
+    importc: "GPU_CopyImageFromSurface", cdecl.}
+
+ +
End of ImageControls
+! @}
+Surface / Image / Target conversions
+! \ingroup Conversions
+  @{
+! Copy SDL_Surface data into a new GPU_Image.  Don't forget to SDL_FreeSurface() the surface and GPU_FreeImage() the image.
+ + +
+ +
proc copyImageFromTarget(target: ptr Target): ptr Image {...}{.
+    importc: "GPU_CopyImageFromTarget", cdecl.}
+
+ +
! Copy GPU_Target data into a new GPU_Image.  Don't forget to GPU_FreeImage() the image.
+ + +
+ +
proc copySurfaceFromTarget(target: ptr Target): ptr Surface {...}{.
+    importc: "GPU_CopySurfaceFromTarget", cdecl.}
+
+ +
! Copy GPU_Target data into a new SDL_Surface.  Don't forget to SDL_FreeSurface() the surface.
+ + +
+ +
proc copySurfaceFromImage(image: ptr Image): ptr Surface {...}{.
+    importc: "GPU_CopySurfaceFromImage", cdecl.}
+
+ +
! Copy GPU_Image data into a new SDL_Surface.  Don't forget to SDL_FreeSurface() the surface and GPU_FreeImage() the image.
+ + +
+ +
proc vectorLength(vec3: ptr cfloat): cfloat {...}{.importc: "GPU_VectorLength", cdecl.}
+
+ +
End of Conversions
+! @}
+! \ingroup Matrix
+  @{
+Basic vector operations (3D)
+! Returns the magnitude (length) of the given vector.
+ + +
+ +
proc vectorNormalize(vec3: ptr cfloat) {...}{.importc: "GPU_VectorNormalize", cdecl.}
+
+ +
! Modifies the given vector so that it has a new length of 1.
+ + +
+ +
proc vectorDot(A: ptr cfloat; B: ptr cfloat): cfloat {...}{.importc: "GPU_VectorDot", cdecl.}
+
+ +
! Returns the dot product of two vectors.
+ + +
+ +
proc vectorCross(result: ptr cfloat; A: ptr cfloat; B: ptr cfloat) {...}{.
+    importc: "GPU_VectorCross", cdecl.}
+
+ +
! Performs the cross product of vectors A and B (result = A x B).  Do not use A or B as 'result'.
+ + +
+ +
proc vectorCopy(result: ptr cfloat; A: ptr cfloat) {...}{.importc: "GPU_VectorCopy", cdecl.}
+
+ +
! Overwrite 'result' vector with the values from vector A.
+ + +
+ +
proc vectorApplyMatrix(vec3: ptr cfloat; matrix4x4: ptr cfloat) {...}{.
+    importc: "GPU_VectorApplyMatrix", cdecl.}
+
+ +
! Multiplies the given matrix into the given vector (vec3 = matrixvec3).
+ + +
+ +
proc vector4ApplyMatrix(vec4: ptr cfloat; matrix4x4: ptr cfloat) {...}{.
+    importc: "GPU_Vector4ApplyMatrix", cdecl.}
+
+ +
! Multiplies the given matrix into the given vector (vec4 = matrixvec4).
+ + +
+ +
proc matrixCopy(result: ptr cfloat; A: ptr cfloat) {...}{.importc: "GPU_MatrixCopy", cdecl.}
+
+ +
Basic matrix operations (4x4)
+! Overwrite 'result' matrix with the values from matrix A.
+ + +
+ +
proc matrixIdentity(result: ptr cfloat) {...}{.importc: "GPU_MatrixIdentity", cdecl.}
+
+ +
! Fills 'result' matrix with the identity matrix.
+ + +
+ +
proc matrixOrtho(result: ptr cfloat; left: cfloat; right: cfloat; bottom: cfloat;
+                top: cfloat; zNear: cfloat; zFar: cfloat) {...}{.
+    importc: "GPU_MatrixOrtho", cdecl.}
+
+ +
! Multiplies an orthographic projection matrix into the given matrix.
+ + +
+ +
proc matrixFrustum(result: ptr cfloat; left: cfloat; right: cfloat; bottom: cfloat;
+                  top: cfloat; zNear: cfloat; zFar: cfloat) {...}{.
+    importc: "GPU_MatrixFrustum", cdecl.}
+
+ +
! Multiplies a perspective projection matrix into the given matrix.
+ + +
+ +
proc matrixPerspective(result: ptr cfloat; fovy: cfloat; aspect: cfloat; zNear: cfloat;
+                      zFar: cfloat) {...}{.importc: "GPU_MatrixPerspective", cdecl.}
+
+ +
! Multiplies a perspective projection matrix into the given matrix.
+ + +
+ +
proc matrixLookAt(matrix: ptr cfloat; eyeX: cfloat; eyeY: cfloat; eyeZ: cfloat;
+                 targetX: cfloat; targetY: cfloat; targetZ: cfloat; upX: cfloat;
+                 upY: cfloat; upZ: cfloat) {...}{.importc: "GPU_MatrixLookAt", cdecl.}
+
+ +
! Multiplies a view matrix into the given matrix.
+ + +
+ +
proc matrixTranslate(result: ptr cfloat; x: cfloat; y: cfloat; z: cfloat) {...}{.
+    importc: "GPU_MatrixTranslate", cdecl.}
+
+ +
! Adds a translation into the given matrix.
+ + +
+ +
proc matrixScale(result: ptr cfloat; sx: cfloat; sy: cfloat; sz: cfloat) {...}{.
+    importc: "GPU_MatrixScale", cdecl.}
+
+ +
! Multiplies a scaling matrix into the given matrix.
+ + +
+ +
proc matrixRotate(result: ptr cfloat; degrees: cfloat; x: cfloat; y: cfloat; z: cfloat) {...}{.
+    importc: "GPU_MatrixRotate", cdecl.}
+
+ +
! Multiplies a rotation matrix into the given matrix.
+ + +
+ +
proc matrixMultiply(result: ptr cfloat; A: ptr cfloat; B: ptr cfloat) {...}{.
+    importc: "GPU_MatrixMultiply", cdecl.}
+
+ +
! Multiplies matrices A and B and stores the result in the given 'result' matrix (result = AB).  Do not use A or B as 'result'.
+ \see GPU_MultiplyAndAssign
+ + +
+ +
proc multiplyAndAssign(result: ptr cfloat; B: ptr cfloat) {...}{.
+    importc: "GPU_MultiplyAndAssign", cdecl.}
+
+ +
! Multiplies matrices 'result' and B and stores the result in the given 'result' matrix (result = result B).
+ + +
+ +
proc getMatrixString(A: ptr cfloat): cstring {...}{.importc: "GPU_GetMatrixString", cdecl.}
+
+ +
Matrix stack accessors
+! Returns an internal string that represents the contents of matrix A.
+ + +
+ +
proc getCurrentMatrix(): ptr cfloat {...}{.importc: "GPU_GetCurrentMatrix", cdecl.}
+
+ +
! Returns the current matrix from the active target.  Returns NULL if stack is empty.
+ + +
+ +
proc getTopMatrix(stack: ptr MatrixStack): ptr cfloat {...}{.importc: "GPU_GetTopMatrix",
+    cdecl.}
+
+ +
! Returns the current matrix from the top of the matrix stack.  Returns NULL if stack is empty.
+ + +
+ +
proc getModel(): ptr cfloat {...}{.importc: "GPU_GetModel", cdecl.}
+
+ +
! Returns the current model matrix from the active target.  Returns NULL if stack is empty.
+ + +
+ +
proc getView(): ptr cfloat {...}{.importc: "GPU_GetView", cdecl.}
+
+ +
! Returns the current view matrix from the active target.  Returns NULL if stack is empty.
+ + +
+ +
proc getProjection(): ptr cfloat {...}{.importc: "GPU_GetProjection", cdecl.}
+
+ +
! Returns the current projection matrix from the active target.  Returns NULL if stack is empty.
+ + +
+ +
proc getModelViewProjection(result: ptr cfloat) {...}{.
+    importc: "GPU_GetModelViewProjection", cdecl.}
+
+ +
! Copies the current modelview-projection matrix from the active target into the given 'result' matrix (result = PVM).
+ + +
+ +
proc createMatrixStack(): ptr MatrixStack {...}{.importc: "GPU_CreateMatrixStack", cdecl.}
+
+ +
Matrix stack manipulators
+! Returns a newly allocated matrix stack that has already been initialized.
+ + +
+ +
proc freeMatrixStack(stack: ptr MatrixStack) {...}{.importc: "GPU_FreeMatrixStack", cdecl.}
+
+ +
! Frees the memory for the matrix stack and any matrices it contains.
+ + +
+ +
proc initMatrixStack(stack: ptr MatrixStack) {...}{.importc: "GPU_InitMatrixStack", cdecl.}
+
+ +
! Allocate new matrices for the given stack.
+ + +
+ +
proc copyMatrixStack(source: ptr MatrixStack; dest: ptr MatrixStack) {...}{.
+    importc: "GPU_CopyMatrixStack", cdecl.}
+
+ +
! Copies matrices from one stack to another.
+ + +
+ +
proc clearMatrixStack(stack: ptr MatrixStack) {...}{.importc: "GPU_ClearMatrixStack", cdecl.}
+
+ +
! Deletes matrices in the given stack.
+ + +
+ +
proc resetProjection(target: ptr Target) {...}{.importc: "GPU_ResetProjection", cdecl.}
+
+ +
! Reapplies the default orthographic projection matrix, based on camera and coordinate settings.
+ + +
+ +
proc matrixMode(target: ptr Target; matrixMode: cint) {...}{.importc: "GPU_MatrixMode", cdecl.}
+
+ +
! Sets the active target and changes matrix mode to GPU_PROJECTION, GPU_VIEW, or GPU_MODEL.  Further matrix stack operations manipulate that particular stack.
+ + +
+ +
proc setProjection(A: ptr cfloat) {...}{.importc: "GPU_SetProjection", cdecl.}
+
+ +
! Copies the given matrix to the active target's projection matrix.
+ + +
+ +
proc setView(A: ptr cfloat) {...}{.importc: "GPU_SetView", cdecl.}
+
+ +
! Copies the given matrix to the active target's view matrix.
+ + +
+ +
proc setModel(A: ptr cfloat) {...}{.importc: "GPU_SetModel", cdecl.}
+
+ +
! Copies the given matrix to the active target's model matrix.
+ + +
+ +
proc setProjectionFromStack(stack: ptr MatrixStack) {...}{.
+    importc: "GPU_SetProjectionFromStack", cdecl.}
+
+ +
! Copies the given matrix to the active target's projection matrix.
+ + +
+ +
proc setViewFromStack(stack: ptr MatrixStack) {...}{.importc: "GPU_SetViewFromStack", cdecl.}
+
+ +
! Copies the given matrix to the active target's view matrix.
+ + +
+ +
proc setModelFromStack(stack: ptr MatrixStack) {...}{.importc: "GPU_SetModelFromStack",
+    cdecl.}
+
+ +
! Copies the given matrix to the active target's model matrix.
+ + +
+ +
proc pushMatrix() {...}{.importc: "GPU_PushMatrix", cdecl.}
+
+ +
! Pushes the current matrix as a new matrix stack item to be restored later.
+ + +
+ +
proc popMatrix() {...}{.importc: "GPU_PopMatrix", cdecl.}
+
+ +
! Removes the current matrix from the stack, restoring the previously pushed matrix.
+ + +
+ +
proc loadIdentity() {...}{.importc: "GPU_LoadIdentity", cdecl.}
+
+ +
! Fills current matrix with the identity matrix.
+ + +
+ +
proc loadMatrix(matrix4x4: ptr cfloat) {...}{.importc: "GPU_LoadMatrix", cdecl.}
+
+ +
! Copies a given matrix to be the current matrix.
+ + +
+ +
proc ortho(left: cfloat; right: cfloat; bottom: cfloat; top: cfloat; zNear: cfloat;
+          zFar: cfloat) {...}{.importc: "GPU_Ortho", cdecl.}
+
+ +
! Multiplies an orthographic projection matrix into the current matrix.
+ + +
+ +
proc frustum(left: cfloat; right: cfloat; bottom: cfloat; top: cfloat; zNear: cfloat;
+            zFar: cfloat) {...}{.importc: "GPU_Frustum", cdecl.}
+
+ +
! Multiplies a perspective projection matrix into the current matrix.
+ + +
+ +
proc perspective(fovy: cfloat; aspect: cfloat; zNear: cfloat; zFar: cfloat) {...}{.
+    importc: "GPU_Perspective", cdecl.}
+
+ +
! Multiplies a perspective projection matrix into the current matrix.
+ + +
+ +
proc lookAt(eyeX: cfloat; eyeY: cfloat; eyeZ: cfloat; targetX: cfloat; targetY: cfloat;
+           targetZ: cfloat; upX: cfloat; upY: cfloat; upZ: cfloat) {...}{.
+    importc: "GPU_LookAt", cdecl.}
+
+ +
! Multiplies a view matrix into the current matrix.
+ + +
+ +
proc translate(x: cfloat; y: cfloat; z: cfloat) {...}{.importc: "GPU_Translate", cdecl.}
+
+ +
! Adds a translation into the current matrix.
+ + +
+ +
proc scale(sx: cfloat; sy: cfloat; sz: cfloat) {...}{.importc: "GPU_Scale", cdecl.}
+
+ +
! Multiplies a scaling matrix into the current matrix.
+ + +
+ +
proc rotate(degrees: cfloat; x: cfloat; y: cfloat; z: cfloat) {...}{.importc: "GPU_Rotate",
+    cdecl.}
+
+ +
! Multiplies a rotation matrix into the current matrix.
+ + +
+ +
proc multMatrix(matrix4x4: ptr cfloat) {...}{.importc: "GPU_MultMatrix", cdecl.}
+
+ +
! Multiplies a given matrix into the current matrix.
+ + +
+ +
proc clear(target: ptr Target) {...}{.importc: "GPU_Clear", cdecl.}
+
+ +
End of Matrix
+! @}
+! \ingroup Rendering
+  @{
+! Clears the contents of the given render target.  Fills the target with color {0, 0, 0, 0}.
+ + +
+ +
proc clearColor(target: ptr Target; color: Color) {...}{.importc: "GPU_ClearColor", cdecl.}
+
+ +
! Fills the given render target with a color.
+ + +
+ +
proc clearRGB(target: ptr Target; r: Uint8; g: Uint8; b: Uint8) {...}{.importc: "GPU_ClearRGB",
+    cdecl.}
+
+ +
! Fills the given render target with a color (alpha is 255, fully opaque).
+ + +
+ +
proc clearRGBA(target: ptr Target; r: Uint8; g: Uint8; b: Uint8; a: Uint8) {...}{.
+    importc: "GPU_ClearRGBA", cdecl.}
+
+ +
! Fills the given render target with a color.
+ + +
+ +
proc blit(image: ptr Image; srcRect: ptr Rect; target: ptr Target; x: cfloat; y: cfloat) {...}{.
+    importc: "GPU_Blit", cdecl.}
+
+ +
! Draws the given image to the given render target.
+ \param src_rect The region of the source image to use.  Pass NULL for the entire image.
+ \param x Destination x-position
+ \param y Destination y-position
+ + +
+ +
proc blitRotate(image: ptr Image; srcRect: ptr Rect; target: ptr Target; x: cfloat;
+               y: cfloat; degrees: cfloat) {...}{.importc: "GPU_BlitRotate", cdecl.}
+
+ +
! Rotates and draws the given image to the given render target.
+ \param src_rect The region of the source image to use.  Pass NULL for the entire image.
+ \param x Destination x-position
+ \param y Destination y-position
+ \param degrees Rotation angle (in degrees)
+ + +
+ +
proc blitScale(image: ptr Image; srcRect: ptr Rect; target: ptr Target; x: cfloat;
+              y: cfloat; scaleX: cfloat; scaleY: cfloat) {...}{.importc: "GPU_BlitScale",
+    cdecl.}
+
+ +
! Scales and draws the given image to the given render target.
+ \param src_rect The region of the source image to use.  Pass NULL for the entire image.
+ \param x Destination x-position
+ \param y Destination y-position
+ \param scaleX Horizontal stretch factor
+ \param scaleY Vertical stretch factor
+ + +
+ +
proc blitTransform(image: ptr Image; srcRect: ptr Rect; target: ptr Target; x: cfloat;
+                  y: cfloat; degrees: cfloat; scaleX: cfloat; scaleY: cfloat) {...}{.
+    importc: "GPU_BlitTransform", cdecl.}
+
+ +
! Scales, rotates, and draws the given image to the given render target.
+ \param src_rect The region of the source image to use.  Pass NULL for the entire image.
+ \param x Destination x-position
+ \param y Destination y-position
+ \param degrees Rotation angle (in degrees)
+ \param scaleX Horizontal stretch factor
+ \param scaleY Vertical stretch factor
+ + +
+ +
proc blitTransformX(image: ptr Image; srcRect: ptr Rect; target: ptr Target; x: cfloat;
+                   y: cfloat; pivotX: cfloat; pivotY: cfloat; degrees: cfloat;
+                   scaleX: cfloat; scaleY: cfloat) {...}{.importc: "GPU_BlitTransformX",
+    cdecl.}
+
+ +
! Scales, rotates around a pivot point, and draws the given image to the given render target.  The drawing point (x, y) coincides with the pivot point on the src image (pivot_x, pivot_y).
+       \param src_rect The region of the source image to use.  Pass NULL for the entire image.
+       \param x Destination x-position
+       \param y Destination y-position
+       \param pivot_x Pivot x-position (in image coordinates)
+       \param pivot_y Pivot y-position (in image coordinates)
+       \param degrees Rotation angle (in degrees)
+       \param scaleX Horizontal stretch factor
+       \param scaleY Vertical stretch factor
+ + +
+ +
proc blitRect(image: ptr Image; srcRect: ptr Rect; target: ptr Target; destRect: ptr Rect) {...}{.
+    importc: "GPU_BlitRect", cdecl.}
+
+ +
! Draws the given image to the given render target, scaling it to fit the destination region.
+ \param src_rect The region of the source image to use.  Pass NULL for the entire image.
+ \param dest_rect The region of the destination target image to draw upon.  Pass NULL for the entire target.
+ + +
+ +
proc blitRectX(image: ptr Image; srcRect: ptr Rect; target: ptr Target;
+              destRect: ptr Rect; degrees: cfloat; pivotX: cfloat; pivotY: cfloat;
+              flipDirection: FlipEnum) {...}{.importc: "GPU_BlitRectX", cdecl.}
+
+ +
! Draws the given image to the given render target, scaling it to fit the destination region.
+ \param src_rect The region of the source image to use.  Pass NULL for the entire image.
+ \param dest_rect The region of the destination target image to draw upon.  Pass NULL for the entire target.
+       \param degrees Rotation angle (in degrees)
+       \param pivot_x Pivot x-position (in image coordinates)
+       \param pivot_y Pivot y-position (in image coordinates)
+       \param flip_direction A GPU_FlipEnum value (or bitwise OR'd combination) that specifies which direction the image should be flipped.
+ + +
+ +
proc triangleBatch(image: ptr Image; target: ptr Target; numVertices: cushort;
+                  values: ptr cfloat; numIndices: cuint; indices: ptr cushort;
+                  flags: BatchFlagEnum) {...}{.importc: "GPU_TriangleBatch", cdecl.}
+
+ +
! Renders triangles from the given set of vertices.  This lets you render arbitrary geometry.  It is a direct path to the GPU, so the format is different than typical SDL_gpu calls.
+ \param values A tightly-packed array of vertex position (e.g. x,y), texture coordinates (e.g. s,t), and color (e.g. r,g,b,a) values.  Texture coordinates and color values are expected to be already normalized to 0.0 - 1.0.  Pass NULL to render with only custom shader attributes.
+ \param indices If not NULL, this is used to specify which vertices to use and in what order (i.e. it indexes the vertices in the 'values' array).
+ \param flags Bit flags to control the interpretation of the 'values' array parameters.
+ + +
+ +
proc triangleBatchX(image: ptr Image; target: ptr Target; numVertices: cushort;
+                   values: pointer; numIndices: cuint; indices: ptr cushort;
+                   flags: BatchFlagEnum) {...}{.importc: "GPU_TriangleBatchX", cdecl.}
+
+ +
! Renders triangles from the given set of vertices.  This lets you render arbitrary geometry.  It is a direct path to the GPU, so the format is different than typical SDL_gpu calls.
+ \param values A tightly-packed array of vertex position (e.g. x,y), texture coordinates (e.g. s,t), and color (e.g. r,g,b,a) values.  Texture coordinates and color values are expected to be already normalized to 0.0 - 1.0 (or 0 - 255 for 8-bit color components).  Pass NULL to render with only custom shader attributes.
+ \param indices If not NULL, this is used to specify which vertices to use and in what order (i.e. it indexes the vertices in the 'values' array).
+ \param flags Bit flags to control the interpretation of the 'values' array parameters.
+ + +
+ +
proc primitiveBatch(image: ptr Image; target: ptr Target; primitiveType: PrimitiveEnum;
+                   numVertices: cushort; values: ptr cfloat; numIndices: cuint;
+                   indices: ptr cushort; flags: BatchFlagEnum) {...}{.
+    importc: "GPU_PrimitiveBatch", cdecl.}
+
+ +
! Renders primitives from the given set of vertices.  This lets you render arbitrary geometry.  It is a direct path to the GPU, so the format is different than typical SDL_gpu calls.
+ \param primitive_type The kind of primitive to render.
+ \param values A tightly-packed array of vertex position (e.g. x,y), texture coordinates (e.g. s,t), and color (e.g. r,g,b,a) values.  Texture coordinates and color values are expected to be already normalized to 0.0 - 1.0 (or 0 - 255 for 8-bit color components).  Pass NULL to render with only custom shader attributes.
+ \param indices If not NULL, this is used to specify which vertices to use and in what order (i.e. it indexes the vertices in the 'values' array).
+ \param flags Bit flags to control the interpretation of the 'values' array parameters.
+ + +
+ +
proc primitiveBatchV(image: ptr Image; target: ptr Target;
+                    primitiveType: PrimitiveEnum; numVertices: cushort;
+                    values: pointer; numIndices: cuint; indices: ptr cushort;
+                    flags: BatchFlagEnum) {...}{.importc: "GPU_PrimitiveBatchV", cdecl.}
+
+ +
! Renders primitives from the given set of vertices.  This lets you render arbitrary geometry.  It is a direct path to the GPU, so the format is different than typical SDL_gpu calls.
+ \param primitive_type The kind of primitive to render.
+ \param values A tightly-packed array of vertex position (e.g. x,y), texture coordinates (e.g. s,t), and color (e.g. r,g,b,a) values.  Texture coordinates and color values are expected to be already normalized to 0.0 - 1.0 (or 0 - 255 for 8-bit color components).  Pass NULL to render with only custom shader attributes.
+ \param indices If not NULL, this is used to specify which vertices to use and in what order (i.e. it indexes the vertices in the 'values' array).
+ \param flags Bit flags to control the interpretation of the 'values' array parameters.
+ + +
+ +
proc flushBlitBuffer() {...}{.importc: "GPU_FlushBlitBuffer", cdecl.}
+
+ +
! Send all buffered blitting data to the current context target.
+ + +
+ +
proc flip(target: ptr Target) {...}{.importc: "GPU_Flip", cdecl.}
+
+ +
! Updates the given target's associated window.  For non-context targets (e.g. image targets), this will flush the blit buffer.
+ + +
+ +
proc pixel(target: ptr Target; x: cfloat; y: cfloat; color: Color) {...}{.importc: "GPU_Pixel",
+    cdecl.}
+
+ +
End of Rendering
+! @}
+! \ingroup Shapes
+  @{
+! Renders a colored point.
+ \param target The destination render target
+ \param x x-coord of the point
+ \param y y-coord of the point
+ \param color The color of the shape to render
+ + +
+ +
proc line(target: ptr Target; x1: cfloat; y1: cfloat; x2: cfloat; y2: cfloat; color: Color) {...}{.
+    importc: "GPU_Line", cdecl.}
+
+ +
! Renders a colored line.
+ \param target The destination render target
+ \param x1 x-coord of starting point
+ \param y1 y-coord of starting point
+ \param x2 x-coord of ending point
+ \param y2 y-coord of ending point
+ \param color The color of the shape to render
+ + +
+ +
proc arc(target: ptr Target; x: cfloat; y: cfloat; radius: cfloat; startAngle: cfloat;
+        endAngle: cfloat; color: Color) {...}{.importc: "GPU_Arc", cdecl.}
+
+ +
! Renders a colored arc curve (circle segment).
+ \param target The destination render target
+ \param x x-coord of center point
+ \param y y-coord of center point
+ \param radius The radius of the circle / distance from the center point that rendering will occur
+ \param start_angle The angle to start from, in degrees.  Measured clockwise from the positive x-axis.
+ \param end_angle The angle to end at, in degrees.  Measured clockwise from the positive x-axis.
+ \param color The color of the shape to render
+ + +
+ +
proc arcFilled(target: ptr Target; x: cfloat; y: cfloat; radius: cfloat;
+              startAngle: cfloat; endAngle: cfloat; color: Color) {...}{.
+    importc: "GPU_ArcFilled", cdecl.}
+
+ +
! Renders a colored filled arc (circle segment / pie piece).
+ \param target The destination render target
+ \param x x-coord of center point
+ \param y y-coord of center point
+ \param radius The radius of the circle / distance from the center point that rendering will occur
+ \param start_angle The angle to start from, in degrees.  Measured clockwise from the positive x-axis.
+ \param end_angle The angle to end at, in degrees.  Measured clockwise from the positive x-axis.
+ \param color The color of the shape to render
+ + +
+ +
proc circle(target: ptr Target; x: cfloat; y: cfloat; radius: cfloat; color: Color) {...}{.
+    importc: "GPU_Circle", cdecl.}
+
+ +
! Renders a colored circle outline.
+ \param target The destination render target
+ \param x x-coord of center point
+ \param y y-coord of center point
+ \param radius The radius of the circle / distance from the center point that rendering will occur
+ \param color The color of the shape to render
+ + +
+ +
proc circleFilled(target: ptr Target; x: cfloat; y: cfloat; radius: cfloat; color: Color) {...}{.
+    importc: "GPU_CircleFilled", cdecl.}
+
+ +
! Renders a colored filled circle.
+ \param target The destination render target
+ \param x x-coord of center point
+ \param y y-coord of center point
+ \param radius The radius of the circle / distance from the center point that rendering will occur
+ \param color The color of the shape to render
+ + +
+ +
proc ellipse(target: ptr Target; x: cfloat; y: cfloat; rx: cfloat; ry: cfloat;
+            degrees: cfloat; color: Color) {...}{.importc: "GPU_Ellipse", cdecl.}
+
+ +
! Renders a colored ellipse outline.
+ \param target The destination render target
+ \param x x-coord of center point
+ \param y y-coord of center point
+ \param rx x-radius of ellipse
+ \param ry y-radius of ellipse
+ \param degrees The angle to rotate the ellipse
+ \param color The color of the shape to render
+ + +
+ +
proc ellipseFilled(target: ptr Target; x: cfloat; y: cfloat; rx: cfloat; ry: cfloat;
+                  degrees: cfloat; color: Color) {...}{.importc: "GPU_EllipseFilled", cdecl.}
+
+ +
! Renders a colored filled ellipse.
+ \param target The destination render target
+ \param x x-coord of center point
+ \param y y-coord of center point
+ \param rx x-radius of ellipse
+ \param ry y-radius of ellipse
+ \param degrees The angle to rotate the ellipse
+ \param color The color of the shape to render
+ + +
+ +
proc sector(target: ptr Target; x: cfloat; y: cfloat; innerRadius: cfloat;
+           outerRadius: cfloat; startAngle: cfloat; endAngle: cfloat; color: Color) {...}{.
+    importc: "GPU_Sector", cdecl.}
+
+ +
! Renders a colored annular sector outline (ring segment).
+ \param target The destination render target
+ \param x x-coord of center point
+ \param y y-coord of center point
+ \param inner_radius The inner radius of the ring
+ \param outer_radius The outer radius of the ring
+ \param start_angle The angle to start from, in degrees.  Measured clockwise from the positive x-axis.
+ \param end_angle The angle to end at, in degrees.  Measured clockwise from the positive x-axis.
+ \param color The color of the shape to render
+ + +
+ +
proc sectorFilled(target: ptr Target; x: cfloat; y: cfloat; innerRadius: cfloat;
+                 outerRadius: cfloat; startAngle: cfloat; endAngle: cfloat;
+                 color: Color) {...}{.importc: "GPU_SectorFilled", cdecl.}
+
+ +
! Renders a colored filled annular sector (ring segment).
+ \param target The destination render target
+ \param x x-coord of center point
+ \param y y-coord of center point
+ \param inner_radius The inner radius of the ring
+ \param outer_radius The outer radius of the ring
+ \param start_angle The angle to start from, in degrees.  Measured clockwise from the positive x-axis.
+ \param end_angle The angle to end at, in degrees.  Measured clockwise from the positive x-axis.
+ \param color The color of the shape to render
+ + +
+ +
proc tri(target: ptr Target; x1: cfloat; y1: cfloat; x2: cfloat; y2: cfloat; x3: cfloat;
+        y3: cfloat; color: Color) {...}{.importc: "GPU_Tri", cdecl.}
+
+ +
! Renders a colored triangle outline.
+ \param target The destination render target
+ \param x1 x-coord of first point
+ \param y1 y-coord of first point
+ \param x2 x-coord of second point
+ \param y2 y-coord of second point
+ \param x3 x-coord of third point
+ \param y3 y-coord of third point
+ \param color The color of the shape to render
+ + +
+ +
proc triFilled(target: ptr Target; x1: cfloat; y1: cfloat; x2: cfloat; y2: cfloat;
+              x3: cfloat; y3: cfloat; color: Color) {...}{.importc: "GPU_TriFilled", cdecl.}
+
+ +
! Renders a colored filled triangle.
+ \param target The destination render target
+ \param x1 x-coord of first point
+ \param y1 y-coord of first point
+ \param x2 x-coord of second point
+ \param y2 y-coord of second point
+ \param x3 x-coord of third point
+ \param y3 y-coord of third point
+ \param color The color of the shape to render
+ + +
+ +
proc rectangle(target: ptr Target; x1: cfloat; y1: cfloat; x2: cfloat; y2: cfloat;
+              color: Color) {...}{.importc: "GPU_Rectangle", cdecl.}
+
+ +
! Renders a colored rectangle outline.
+ \param target The destination render target
+ \param x1 x-coord of top-left corner
+ \param y1 y-coord of top-left corner
+ \param x2 x-coord of bottom-right corner
+ \param y2 y-coord of bottom-right corner
+ \param color The color of the shape to render
+ + +
+ +
proc rectangle2(target: ptr Target; rect: Rect; color: Color) {...}{.
+    importc: "GPU_Rectangle2", cdecl.}
+
+ +
! Renders a colored rectangle outline.
+ \param target The destination render target
+ \param rect The rectangular area to draw
+ \param color The color of the shape to render
+ + +
+ +
proc rectangleFilled(target: ptr Target; x1: cfloat; y1: cfloat; x2: cfloat; y2: cfloat;
+                    color: Color) {...}{.importc: "GPU_RectangleFilled", cdecl.}
+
+ +
! Renders a colored filled rectangle.
+ \param target The destination render target
+ \param x1 x-coord of top-left corner
+ \param y1 y-coord of top-left corner
+ \param x2 x-coord of bottom-right corner
+ \param y2 y-coord of bottom-right corner
+ \param color The color of the shape to render
+ + +
+ +
proc rectangleFilled2(target: ptr Target; rect: Rect; color: Color) {...}{.
+    importc: "GPU_RectangleFilled2", cdecl.}
+
+ +
! Renders a colored filled rectangle.
+ \param target The destination render target
+ \param rect The rectangular area to draw
+ \param color The color of the shape to render
+ + +
+ +
proc rectangleRound(target: ptr Target; x1: cfloat; y1: cfloat; x2: cfloat; y2: cfloat;
+                   radius: cfloat; color: Color) {...}{.importc: "GPU_RectangleRound",
+    cdecl.}
+
+ +
! Renders a colored rounded (filleted) rectangle outline.
+ \param target The destination render target
+ \param x1 x-coord of top-left corner
+ \param y1 y-coord of top-left corner
+ \param x2 x-coord of bottom-right corner
+ \param y2 y-coord of bottom-right corner
+ \param radius The radius of the corners
+ \param color The color of the shape to render
+ + +
+ +
proc rectangleRound2(target: ptr Target; rect: Rect; radius: cfloat; color: Color) {...}{.
+    importc: "GPU_RectangleRound2", cdecl.}
+
+ +
! Renders a colored rounded (filleted) rectangle outline.
+ \param target The destination render target
+ \param rect The rectangular area to draw
+ \param radius The radius of the corners
+ \param color The color of the shape to render
+ + +
+ +
proc rectangleRoundFilled(target: ptr Target; x1: cfloat; y1: cfloat; x2: cfloat;
+                         y2: cfloat; radius: cfloat; color: Color) {...}{.
+    importc: "GPU_RectangleRoundFilled", cdecl.}
+
+ +
! Renders a colored filled rounded (filleted) rectangle.
+ \param target The destination render target
+ \param x1 x-coord of top-left corner
+ \param y1 y-coord of top-left corner
+ \param x2 x-coord of bottom-right corner
+ \param y2 y-coord of bottom-right corner
+ \param radius The radius of the corners
+ \param color The color of the shape to render
+ + +
+ +
proc rectangleRoundFilled2(target: ptr Target; rect: Rect; radius: cfloat; color: Color) {...}{.
+    importc: "GPU_RectangleRoundFilled2", cdecl.}
+
+ +
! Renders a colored filled rounded (filleted) rectangle.
+ \param target The destination render target
+ \param rect The rectangular area to draw
+ \param radius The radius of the corners
+ \param color The color of the shape to render
+ + +
+ +
proc polygon(target: ptr Target; numVertices: cuint; vertices: ptr cfloat; color: Color) {...}{.
+    importc: "GPU_Polygon", cdecl.}
+
+ +
! Renders a colored polygon outline.  The vertices are expected to define a convex polygon.
+ \param target The destination render target
+ \param num_vertices Number of vertices (x and y pairs)
+ \param vertices An array of vertex positions stored as interlaced x and y coords, e.g. {x1, y1, x2, y2, ...}
+ \param color The color of the shape to render
+ + +
+ +
proc polyline(target: ptr Target; numVertices: cuint; vertices: ptr cfloat; color: Color;
+             closeLoop: Bool) {...}{.importc: "GPU_Polyline", cdecl.}
+
+ +
! Renders a colored sequence of line segments.
+ \param target The destination render target
+ \param num_vertices Number of vertices (x and y pairs)
+ \param vertices An array of vertex positions stored as interlaced x and y coords, e.g. {x1, y1, x2, y2, ...}
+ \param color The color of the shape to render
+ \param close_loop Make a closed polygon by drawing a line at the end back to the start point
+ + +
+ +
proc polygonFilled(target: ptr Target; numVertices: cuint; vertices: ptr cfloat;
+                  color: Color) {...}{.importc: "GPU_PolygonFilled", cdecl.}
+
+ +
! Renders a colored filled polygon.  The vertices are expected to define a convex polygon.
+ \param target The destination render target
+ \param num_vertices Number of vertices (x and y pairs)
+ \param vertices An array of vertex positions stored as interlaced x and y coords, e.g. {x1, y1, x2, y2, ...}
+ \param color The color of the shape to render
+ + +
+ +
proc createShaderProgram(): Uint32 {...}{.importc: "GPU_CreateShaderProgram", cdecl.}
+
+ +
End of Shapes
+! @}
+! \ingroup ShaderInterface
+  @{
+! Creates a new, empty shader program.  You will need to compile shaders, attach them to the program, then link the program.
+ \see GPU_AttachShader
+ \see GPU_LinkShaderProgram
+ + +
+ +
proc freeShaderProgram(programObject: Uint32) {...}{.importc: "GPU_FreeShaderProgram",
+    cdecl.}
+
+ +
! Deletes a shader program.
+ + +
+ +
proc compileShader_RW(shaderType: ShaderEnum; shaderSource: ptr RWops; freeRwops: Bool): Uint32 {...}{.
+    importc: "GPU_CompileShader_RW", cdecl.}
+
+ +
! Loads shader source from an SDL_RWops, compiles it, and returns the new shader object.
+ + +
+ +
proc compileShader(shaderType: ShaderEnum; shaderSource: cstring): Uint32 {...}{.
+    importc: "GPU_CompileShader", cdecl.}
+
+ +
! Compiles shader source and returns the new shader object.
+ + +
+ +
proc loadShader(shaderType: ShaderEnum; filename: cstring): Uint32 {...}{.
+    importc: "GPU_LoadShader", cdecl.}
+
+ +
! Loads shader source from a file, compiles it, and returns the new shader object.
+ + +
+ +
proc linkShaders(shaderObject1: Uint32; shaderObject2: Uint32): Uint32 {...}{.
+    importc: "GPU_LinkShaders", cdecl.}
+
+ +
! Creates and links a shader program with the given shader objects.
+ + +
+ +
proc linkManyShaders(shaderObjects: ptr Uint32; count: cint): Uint32 {...}{.
+    importc: "GPU_LinkManyShaders", cdecl.}
+
+ +
! Creates and links a shader program with the given shader objects.
+ + +
+ +
proc freeShader(shaderObject: Uint32) {...}{.importc: "GPU_FreeShader", cdecl.}
+
+ +
! Deletes a shader object.
+ + +
+ +
proc attachShader(programObject: Uint32; shaderObject: Uint32) {...}{.
+    importc: "GPU_AttachShader", cdecl.}
+
+ +
! Attaches a shader object to a shader program for future linking.
+ + +
+ +
proc detachShader(programObject: Uint32; shaderObject: Uint32) {...}{.
+    importc: "GPU_DetachShader", cdecl.}
+
+ +
! Detaches a shader object from a shader program.
+ + +
+ +
proc linkShaderProgram(programObject: Uint32): Bool {...}{.
+    importc: "GPU_LinkShaderProgram", cdecl.}
+
+ +
! Links a shader program with any attached shader objects.
+ + +
+ +
proc getCurrentShaderProgram(): Uint32 {...}{.importc: "GPU_GetCurrentShaderProgram",
+                                      cdecl.}
+
+ +
! \return The current shader program
+ + +
+ +
proc isDefaultShaderProgram(programObject: Uint32): Bool {...}{.
+    importc: "GPU_IsDefaultShaderProgram", cdecl.}
+
+ +
! Returns 1 if the given shader program is a default shader for the current context, 0 otherwise.
+ + +
+ +
proc activateShaderProgram(programObject: Uint32; `block`: ptr ShaderBlock) {...}{.
+    importc: "GPU_ActivateShaderProgram", cdecl.}
+
+ +
! Activates the given shader program.  Passing NULL for 'block' will disable the built-in shader variables for custom shaders until a GPU_ShaderBlock is set again.
+ + +
+ +
proc deactivateShaderProgram() {...}{.importc: "GPU_DeactivateShaderProgram", cdecl.}
+
+ +
! Deactivates the current shader program (activates program 0).
+ + +
+ +
proc getShaderMessage(): cstring {...}{.importc: "GPU_GetShaderMessage", cdecl.}
+
+ +
! Returns the last shader log message.
+ + +
+ +
proc getAttributeLocation(programObject: Uint32; attribName: cstring): cint {...}{.
+    importc: "GPU_GetAttributeLocation", cdecl.}
+
+ +
! Returns an integer representing the location of the specified attribute shader variable.
+ + +
+ +
proc makeAttributeFormat(numElemsPerVertex: cint; kind: TypeEnum; normalize: Bool;
+                        strideBytes: cint; offsetBytes: cint): AttributeFormat {...}{.
+    importc: "GPU_MakeAttributeFormat", cdecl.}
+
+ +
! Returns a filled GPU_AttributeFormat object.
+ + +
+ +
proc makeAttribute(location: cint; values: pointer; format: AttributeFormat): Attribute {...}{.
+    importc: "GPU_MakeAttribute", cdecl.}
+
+ +
! Returns a filled GPU_Attribute object.
+ + +
+ +
proc getUniformLocation(programObject: Uint32; uniformName: cstring): cint {...}{.
+    importc: "GPU_GetUniformLocation", cdecl.}
+
+ +
! Returns an integer representing the location of the specified uniform shader variable.
+ + +
+ +
proc loadShaderBlock(programObject: Uint32; positionName: cstring;
+                    texcoordName: cstring; colorName: cstring;
+                    modelViewMatrixName: cstring): ShaderBlock {...}{.
+    importc: "GPU_LoadShaderBlock", cdecl.}
+
+ +
! Loads the given shader program's built-in attribute and uniform locations.
+ + +
+ +
proc setShaderBlock(`block`: ShaderBlock) {...}{.importc: "GPU_SetShaderBlock", cdecl.}
+
+ +
! Sets the current shader block to use the given attribute and uniform locations.
+ + +
+ +
proc getShaderBlock(): ShaderBlock {...}{.importc: "GPU_GetShaderBlock", cdecl.}
+
+ +
! Gets the shader block for the current shader.
+ + +
+ +
proc setShaderImage(image: ptr Image; location: cint; imageUnit: cint) {...}{.
+    importc: "GPU_SetShaderImage", cdecl.}
+
+ +
! Sets the given image unit to the given image so that a custom shader can sample multiple textures.
+    \param image The source image/texture.  Pass NULL to disable the image unit.
+    \param location The uniform location of a texture sampler
+    \param image_unit The index of the texture unit to set.  0 is the first unit, which is used by SDL_gpu's blitting functions.  1 would be the second unit.
+ + +
+ +
proc getUniformiv(programObject: Uint32; location: cint; values: ptr cint) {...}{.
+    importc: "GPU_GetUniformiv", cdecl.}
+
+ +
! Fills "values" with the value of the uniform shader variable at the given location.
+ + +
+ +
proc setUniformi(location: cint; value: cint) {...}{.importc: "GPU_SetUniformi", cdecl.}
+
+ +
! Sets the value of the integer uniform shader variable at the given location.
+    This is equivalent to calling GPU_SetUniformiv(location, 1, 1, &value).
+ + +
+ +
proc setUniformiv(location: cint; numElementsPerValue: cint; numValues: cint;
+                 values: ptr cint) {...}{.importc: "GPU_SetUniformiv", cdecl.}
+
+ +
! Sets the value of the integer uniform shader variable at the given location.
+ + +
+ +
proc getUniformuiv(programObject: Uint32; location: cint; values: ptr cuint) {...}{.
+    importc: "GPU_GetUniformuiv", cdecl.}
+
+ +
! Fills "values" with the value of the uniform shader variable at the given location.
+ + +
+ +
proc setUniformui(location: cint; value: cuint) {...}{.importc: "GPU_SetUniformui", cdecl.}
+
+ +
! Sets the value of the unsigned integer uniform shader variable at the given location.
+    This is equivalent to calling GPU_SetUniformuiv(location, 1, 1, &value).
+ + +
+ +
proc setUniformuiv(location: cint; numElementsPerValue: cint; numValues: cint;
+                  values: ptr cuint) {...}{.importc: "GPU_SetUniformuiv", cdecl.}
+
+ +
! Sets the value of the unsigned integer uniform shader variable at the given location.
+ + +
+ +
proc getUniformfv(programObject: Uint32; location: cint; values: ptr cfloat) {...}{.
+    importc: "GPU_GetUniformfv", cdecl.}
+
+ +
! Fills "values" with the value of the uniform shader variable at the given location.
+ + +
+ +
proc setUniformf(location: cint; value: cfloat) {...}{.importc: "GPU_SetUniformf", cdecl.}
+
+ +
! Sets the value of the floating point uniform shader variable at the given location.
+    This is equivalent to calling GPU_SetUniformfv(location, 1, 1, &value).
+ + +
+ +
proc setUniformfv(location: cint; numElementsPerValue: cint; numValues: cint;
+                 values: ptr cfloat) {...}{.importc: "GPU_SetUniformfv", cdecl.}
+
+ +
! Sets the value of the floating point uniform shader variable at the given location.
+ + +
+ +
proc getUniformMatrixfv(programObject: Uint32; location: cint; values: ptr cfloat) {...}{.
+    importc: "GPU_GetUniformMatrixfv", cdecl.}
+
+ +
! Fills "values" with the value of the uniform shader variable at the given location.  The results are identical to calling GPU_GetUniformfv().  Matrices are gotten in column-major order.
+ + +
+ +
proc setUniformMatrixfv(location: cint; numMatrices: cint; numRows: cint;
+                       numColumns: cint; transpose: Bool; values: ptr cfloat) {...}{.
+    importc: "GPU_SetUniformMatrixfv", cdecl.}
+
+ +
! Sets the value of the matrix uniform shader variable at the given location.  The size of the matrices sent is specified by num_rows and num_columns.  Rows and columns must be between 2 and 4.
+ + +
+ +
proc setAttributef(location: cint; value: cfloat) {...}{.importc: "GPU_SetAttributef", cdecl.}
+
+ +
! Sets a constant-value shader attribute that will be used for each rendered vertex.
+ + +
+ +
proc setAttributei(location: cint; value: cint) {...}{.importc: "GPU_SetAttributei", cdecl.}
+
+ +
! Sets a constant-value shader attribute that will be used for each rendered vertex.
+ + +
+ +
proc setAttributeui(location: cint; value: cuint) {...}{.importc: "GPU_SetAttributeui",
+    cdecl.}
+
+ +
! Sets a constant-value shader attribute that will be used for each rendered vertex.
+ + +
+ +
proc setAttributefv(location: cint; numElements: cint; value: ptr cfloat) {...}{.
+    importc: "GPU_SetAttributefv", cdecl.}
+
+ +
! Sets a constant-value shader attribute that will be used for each rendered vertex.
+ + +
+ +
proc setAttributeiv(location: cint; numElements: cint; value: ptr cint) {...}{.
+    importc: "GPU_SetAttributeiv", cdecl.}
+
+ +
! Sets a constant-value shader attribute that will be used for each rendered vertex.
+ + +
+ +
proc setAttributeuiv(location: cint; numElements: cint; value: ptr cuint) {...}{.
+    importc: "GPU_SetAttributeuiv", cdecl.}
+
+ +
! Sets a constant-value shader attribute that will be used for each rendered vertex.
+ + +
+ +
proc setAttributeSource(numValues: cint; source: Attribute) {...}{.
+    importc: "GPU_SetAttributeSource", cdecl.}
+
+ +
! Enables a shader attribute and sets its source data.
+ + +
+ +
+ +
+
+ +
+ +
+
+
+ + + diff --git a/docs/sdl2_gpu.idx b/docs/sdl2_gpu.idx new file mode 100644 index 0000000..309373d --- /dev/null +++ b/docs/sdl2_gpu.idx @@ -0,0 +1,480 @@ +SDLgpuStd sdl2_gpu.html#SDLgpuStd sdl2_gpu: SDLgpuStd +SDLgpuGit sdl2_gpu.html#SDLgpuGit sdl2_gpu: SDLgpuGit +SDLgpuDL sdl2_gpu.html#SDLgpuDL sdl2_gpu: SDLgpuDL +SDLgpuStatic sdl2_gpu.html#SDLgpuStatic sdl2_gpu: SDLgpuStatic +SDLgpuSetVer sdl2_gpu.html#SDLgpuSetVer sdl2_gpu: SDLgpuSetVer +SDLgpuLPath sdl2_gpu.html#SDLgpuLPath sdl2_gpu: SDLgpuLPath +SDLgpuPath sdl2_gpu.html#SDLgpuPath sdl2_gpu: SDLgpuPath +NONE sdl2_gpu.html#NONE sdl2_gpu: NONE +FEATURE_NON_POWER_OF_TWO sdl2_gpu.html#FEATURE_NON_POWER_OF_TWO sdl2_gpu: FEATURE_NON_POWER_OF_TWO +FEATURE_RENDER_TARGETS sdl2_gpu.html#FEATURE_RENDER_TARGETS sdl2_gpu: FEATURE_RENDER_TARGETS +FEATURE_BLEND_EQUATIONS sdl2_gpu.html#FEATURE_BLEND_EQUATIONS sdl2_gpu: FEATURE_BLEND_EQUATIONS +FEATURE_BLEND_FUNC_SEPARATE sdl2_gpu.html#FEATURE_BLEND_FUNC_SEPARATE sdl2_gpu: FEATURE_BLEND_FUNC_SEPARATE +FEATURE_BLEND_EQUATIONS_SEPARATE sdl2_gpu.html#FEATURE_BLEND_EQUATIONS_SEPARATE sdl2_gpu: FEATURE_BLEND_EQUATIONS_SEPARATE +FEATURE_GL_BGR sdl2_gpu.html#FEATURE_GL_BGR sdl2_gpu: FEATURE_GL_BGR +FEATURE_GL_BGRA sdl2_gpu.html#FEATURE_GL_BGRA sdl2_gpu: FEATURE_GL_BGRA +FEATURE_GL_ABGR sdl2_gpu.html#FEATURE_GL_ABGR sdl2_gpu: FEATURE_GL_ABGR +FEATURE_VERTEX_SHADER sdl2_gpu.html#FEATURE_VERTEX_SHADER sdl2_gpu: FEATURE_VERTEX_SHADER +FEATURE_FRAGMENT_SHADER sdl2_gpu.html#FEATURE_FRAGMENT_SHADER sdl2_gpu: FEATURE_FRAGMENT_SHADER +FEATURE_PIXEL_SHADER sdl2_gpu.html#FEATURE_PIXEL_SHADER sdl2_gpu: FEATURE_PIXEL_SHADER +FEATURE_GEOMETRY_SHADER sdl2_gpu.html#FEATURE_GEOMETRY_SHADER sdl2_gpu: FEATURE_GEOMETRY_SHADER +FEATURE_WRAP_REPEAT_MIRRORED sdl2_gpu.html#FEATURE_WRAP_REPEAT_MIRRORED sdl2_gpu: FEATURE_WRAP_REPEAT_MIRRORED +FEATURE_CORE_FRAMEBUFFER_OBJECTS sdl2_gpu.html#FEATURE_CORE_FRAMEBUFFER_OBJECTS sdl2_gpu: FEATURE_CORE_FRAMEBUFFER_OBJECTS +FEATURE_ALL_BASE sdl2_gpu.html#FEATURE_ALL_BASE sdl2_gpu: FEATURE_ALL_BASE +FEATURE_ALL_BLEND_PRESETS sdl2_gpu.html#FEATURE_ALL_BLEND_PRESETS sdl2_gpu: FEATURE_ALL_BLEND_PRESETS +FEATURE_ALL_GL_FORMATS sdl2_gpu.html#FEATURE_ALL_GL_FORMATS sdl2_gpu: FEATURE_ALL_GL_FORMATS +FEATURE_BASIC_SHADERS sdl2_gpu.html#FEATURE_BASIC_SHADERS sdl2_gpu: FEATURE_BASIC_SHADERS +FEATURE_ALL_SHADERS sdl2_gpu.html#FEATURE_ALL_SHADERS sdl2_gpu: FEATURE_ALL_SHADERS +INIT_ENABLE_VSYNC sdl2_gpu.html#INIT_ENABLE_VSYNC sdl2_gpu: INIT_ENABLE_VSYNC +INIT_DISABLE_VSYNC sdl2_gpu.html#INIT_DISABLE_VSYNC sdl2_gpu: INIT_DISABLE_VSYNC +INIT_DISABLE_DOUBLE_BUFFER sdl2_gpu.html#INIT_DISABLE_DOUBLE_BUFFER sdl2_gpu: INIT_DISABLE_DOUBLE_BUFFER +INIT_DISABLE_AUTO_VIRTUAL_RESOLUTION sdl2_gpu.html#INIT_DISABLE_AUTO_VIRTUAL_RESOLUTION sdl2_gpu: INIT_DISABLE_AUTO_VIRTUAL_RESOLUTION +INIT_REQUEST_COMPATIBILITY_PROFILE sdl2_gpu.html#INIT_REQUEST_COMPATIBILITY_PROFILE sdl2_gpu: INIT_REQUEST_COMPATIBILITY_PROFILE +INIT_USE_ROW_BY_ROW_TEXTURE_UPLOAD_FALLBACK sdl2_gpu.html#INIT_USE_ROW_BY_ROW_TEXTURE_UPLOAD_FALLBACK sdl2_gpu: INIT_USE_ROW_BY_ROW_TEXTURE_UPLOAD_FALLBACK +INIT_USE_COPY_TEXTURE_UPLOAD_FALLBACK sdl2_gpu.html#INIT_USE_COPY_TEXTURE_UPLOAD_FALLBACK sdl2_gpu: INIT_USE_COPY_TEXTURE_UPLOAD_FALLBACK +POINTS sdl2_gpu.html#POINTS sdl2_gpu: POINTS +LINES sdl2_gpu.html#LINES sdl2_gpu: LINES +LINE_LOOP sdl2_gpu.html#LINE_LOOP sdl2_gpu: LINE_LOOP +LINE_STRIP sdl2_gpu.html#LINE_STRIP sdl2_gpu: LINE_STRIP +TRIANGLES sdl2_gpu.html#TRIANGLES sdl2_gpu: TRIANGLES +TRIANGLE_STRIP sdl2_gpu.html#TRIANGLE_STRIP sdl2_gpu: TRIANGLE_STRIP +TRIANGLE_FAN sdl2_gpu.html#TRIANGLE_FAN sdl2_gpu: TRIANGLE_FAN +BATCH_XY sdl2_gpu.html#BATCH_XY sdl2_gpu: BATCH_XY +BATCH_XYZ sdl2_gpu.html#BATCH_XYZ sdl2_gpu: BATCH_XYZ +BATCH_ST sdl2_gpu.html#BATCH_ST sdl2_gpu: BATCH_ST +BATCH_RGB sdl2_gpu.html#BATCH_RGB sdl2_gpu: BATCH_RGB +BATCH_RGBA sdl2_gpu.html#BATCH_RGBA sdl2_gpu: BATCH_RGBA +BATCH_RGB8 sdl2_gpu.html#BATCH_RGB8 sdl2_gpu: BATCH_RGB8 +BATCH_RGBA8 sdl2_gpu.html#BATCH_RGBA8 sdl2_gpu: BATCH_RGBA8 +BATCH_XY_ST sdl2_gpu.html#BATCH_XY_ST sdl2_gpu: BATCH_XY_ST +BATCH_XYZ_ST sdl2_gpu.html#BATCH_XYZ_ST sdl2_gpu: BATCH_XYZ_ST +BATCH_XY_RGB sdl2_gpu.html#BATCH_XY_RGB sdl2_gpu: BATCH_XY_RGB +BATCH_XYZ_RGB sdl2_gpu.html#BATCH_XYZ_RGB sdl2_gpu: BATCH_XYZ_RGB +BATCH_XY_RGBA sdl2_gpu.html#BATCH_XY_RGBA sdl2_gpu: BATCH_XY_RGBA +BATCH_XYZ_RGBA sdl2_gpu.html#BATCH_XYZ_RGBA sdl2_gpu: BATCH_XYZ_RGBA +BATCH_XY_ST_RGBA sdl2_gpu.html#BATCH_XY_ST_RGBA sdl2_gpu: BATCH_XY_ST_RGBA +BATCH_XYZ_ST_RGBA sdl2_gpu.html#BATCH_XYZ_ST_RGBA sdl2_gpu: BATCH_XYZ_ST_RGBA +BATCH_XY_RGB8 sdl2_gpu.html#BATCH_XY_RGB8 sdl2_gpu: BATCH_XY_RGB8 +BATCH_XYZ_RGB8 sdl2_gpu.html#BATCH_XYZ_RGB8 sdl2_gpu: BATCH_XYZ_RGB8 +BATCH_XY_RGBA8 sdl2_gpu.html#BATCH_XY_RGBA8 sdl2_gpu: BATCH_XY_RGBA8 +BATCH_XYZ_RGBA8 sdl2_gpu.html#BATCH_XYZ_RGBA8 sdl2_gpu: BATCH_XYZ_RGBA8 +BATCH_XY_ST_RGBA8 sdl2_gpu.html#BATCH_XY_ST_RGBA8 sdl2_gpu: BATCH_XY_ST_RGBA8 +BATCH_XYZ_ST_RGBA8 sdl2_gpu.html#BATCH_XYZ_ST_RGBA8 sdl2_gpu: BATCH_XYZ_ST_RGBA8 +FLIP_NONE sdl2_gpu.html#FLIP_NONE sdl2_gpu: FLIP_NONE +FLIP_HORIZONTAL sdl2_gpu.html#FLIP_HORIZONTAL sdl2_gpu: FLIP_HORIZONTAL +FLIP_VERTICAL sdl2_gpu.html#FLIP_VERTICAL sdl2_gpu: FLIP_VERTICAL +TYPE_BYTE sdl2_gpu.html#TYPE_BYTE sdl2_gpu: TYPE_BYTE +TYPE_UNSIGNED_BYTE sdl2_gpu.html#TYPE_UNSIGNED_BYTE sdl2_gpu: TYPE_UNSIGNED_BYTE +TYPE_SHORT sdl2_gpu.html#TYPE_SHORT sdl2_gpu: TYPE_SHORT +TYPE_UNSIGNED_SHORT sdl2_gpu.html#TYPE_UNSIGNED_SHORT sdl2_gpu: TYPE_UNSIGNED_SHORT +TYPE_INT sdl2_gpu.html#TYPE_INT sdl2_gpu: TYPE_INT +TYPE_UNSIGNED_INT sdl2_gpu.html#TYPE_UNSIGNED_INT sdl2_gpu: TYPE_UNSIGNED_INT +TYPE_FLOAT sdl2_gpu.html#TYPE_FLOAT sdl2_gpu: TYPE_FLOAT +TYPE_DOUBLE sdl2_gpu.html#TYPE_DOUBLE sdl2_gpu: TYPE_DOUBLE +RENDERER_UNKNOWN sdl2_gpu.html#RENDERER_UNKNOWN sdl2_gpu: RENDERER_UNKNOWN +RENDERER_OPENGL_1_BASE sdl2_gpu.html#RENDERER_OPENGL_1_BASE sdl2_gpu: RENDERER_OPENGL_1_BASE +RENDERER_OPENGL_1 sdl2_gpu.html#RENDERER_OPENGL_1 sdl2_gpu: RENDERER_OPENGL_1 +RENDERER_OPENGL_2 sdl2_gpu.html#RENDERER_OPENGL_2 sdl2_gpu: RENDERER_OPENGL_2 +RENDERER_OPENGL_3 sdl2_gpu.html#RENDERER_OPENGL_3 sdl2_gpu: RENDERER_OPENGL_3 +RENDERER_OPENGL_4 sdl2_gpu.html#RENDERER_OPENGL_4 sdl2_gpu: RENDERER_OPENGL_4 +RENDERER_GLES_1 sdl2_gpu.html#RENDERER_GLES_1 sdl2_gpu: RENDERER_GLES_1 +RENDERER_GLES_2 sdl2_gpu.html#RENDERER_GLES_2 sdl2_gpu: RENDERER_GLES_2 +RENDERER_GLES_3 sdl2_gpu.html#RENDERER_GLES_3 sdl2_gpu: RENDERER_GLES_3 +RENDERER_D3D9 sdl2_gpu.html#RENDERER_D3D9 sdl2_gpu: RENDERER_D3D9 +RENDERER_D3D10 sdl2_gpu.html#RENDERER_D3D10 sdl2_gpu: RENDERER_D3D10 +RENDERER_D3D11 sdl2_gpu.html#RENDERER_D3D11 sdl2_gpu: RENDERER_D3D11 +ComparisonEnum sdl2_gpu.html#ComparisonEnum sdl2_gpu: ComparisonEnum +BlendFuncEnum sdl2_gpu.html#BlendFuncEnum sdl2_gpu: BlendFuncEnum +BlendEqEnum sdl2_gpu.html#BlendEqEnum sdl2_gpu: BlendEqEnum +BlendPresetEnum sdl2_gpu.html#BlendPresetEnum sdl2_gpu: BlendPresetEnum +FilterEnum sdl2_gpu.html#FilterEnum sdl2_gpu: FilterEnum +SnapEnum sdl2_gpu.html#SnapEnum sdl2_gpu: SnapEnum +WrapEnum sdl2_gpu.html#WrapEnum sdl2_gpu: WrapEnum +FormatEnum sdl2_gpu.html#FormatEnum sdl2_gpu: FormatEnum +FileFormatEnum sdl2_gpu.html#FileFormatEnum sdl2_gpu: FileFormatEnum +ShaderEnum sdl2_gpu.html#ShaderEnum sdl2_gpu: ShaderEnum +ShaderLanguageEnum sdl2_gpu.html#ShaderLanguageEnum sdl2_gpu: ShaderLanguageEnum +ErrorEnum sdl2_gpu.html#ErrorEnum sdl2_gpu: ErrorEnum +DebugLevelEnum sdl2_gpu.html#DebugLevelEnum sdl2_gpu: DebugLevelEnum +GPU_VERSION_MAJOR sdl2_gpu.html#GPU_VERSION_MAJOR sdl2_gpu: GPU_VERSION_MAJOR +GPU_VERSION_MINOR sdl2_gpu.html#GPU_VERSION_MINOR sdl2_gpu: GPU_VERSION_MINOR +GPU_VERSION_PATCH sdl2_gpu.html#GPU_VERSION_PATCH sdl2_gpu: GPU_VERSION_PATCH +HAVE_STDC sdl2_gpu.html#HAVE_STDC sdl2_gpu: HAVE_STDC +HAVE_GNUC sdl2_gpu.html#HAVE_GNUC sdl2_gpu: HAVE_GNUC +HAVE_MSVC sdl2_gpu.html#HAVE_MSVC sdl2_gpu: HAVE_MSVC +FALSE sdl2_gpu.html#FALSE sdl2_gpu: FALSE +TRUE sdl2_gpu.html#TRUE sdl2_gpu: TRUE +RENDERER_ORDER_MAX sdl2_gpu.html#RENDERER_ORDER_MAX sdl2_gpu: RENDERER_ORDER_MAX +RENDERER_CUSTOM_0 sdl2_gpu.html#RENDERER_CUSTOM_0 sdl2_gpu: RENDERER_CUSTOM_0 +NEVER sdl2_gpu.html#NEVER sdl2_gpu: NEVER +LESS sdl2_gpu.html#LESS sdl2_gpu: LESS +EQUAL sdl2_gpu.html#EQUAL sdl2_gpu: EQUAL +LEQUAL sdl2_gpu.html#LEQUAL sdl2_gpu: LEQUAL +GREATER sdl2_gpu.html#GREATER sdl2_gpu: GREATER +NOTEQUAL sdl2_gpu.html#NOTEQUAL sdl2_gpu: NOTEQUAL +GEQUAL sdl2_gpu.html#GEQUAL sdl2_gpu: GEQUAL +ALWAYS sdl2_gpu.html#ALWAYS sdl2_gpu: ALWAYS +FUNC_ZERO sdl2_gpu.html#FUNC_ZERO sdl2_gpu: FUNC_ZERO +FUNC_ONE sdl2_gpu.html#FUNC_ONE sdl2_gpu: FUNC_ONE +FUNC_SRC_COLOR sdl2_gpu.html#FUNC_SRC_COLOR sdl2_gpu: FUNC_SRC_COLOR +FUNC_DST_COLOR sdl2_gpu.html#FUNC_DST_COLOR sdl2_gpu: FUNC_DST_COLOR +FUNC_ONE_MINUS_SRC sdl2_gpu.html#FUNC_ONE_MINUS_SRC sdl2_gpu: FUNC_ONE_MINUS_SRC +FUNC_ONE_MINUS_DST sdl2_gpu.html#FUNC_ONE_MINUS_DST sdl2_gpu: FUNC_ONE_MINUS_DST +FUNC_SRC_ALPHA sdl2_gpu.html#FUNC_SRC_ALPHA sdl2_gpu: FUNC_SRC_ALPHA +FUNC_DST_ALPHA sdl2_gpu.html#FUNC_DST_ALPHA sdl2_gpu: FUNC_DST_ALPHA +FUNC_ONE_MINUS_SRC_ALPHA sdl2_gpu.html#FUNC_ONE_MINUS_SRC_ALPHA sdl2_gpu: FUNC_ONE_MINUS_SRC_ALPHA +FUNC_ONE_MINUS_DST_ALPHA sdl2_gpu.html#FUNC_ONE_MINUS_DST_ALPHA sdl2_gpu: FUNC_ONE_MINUS_DST_ALPHA +EQ_ADD sdl2_gpu.html#EQ_ADD sdl2_gpu: EQ_ADD +EQ_SUBTRACT sdl2_gpu.html#EQ_SUBTRACT sdl2_gpu: EQ_SUBTRACT +EQ_REVERSE_SUBTRACT sdl2_gpu.html#EQ_REVERSE_SUBTRACT sdl2_gpu: EQ_REVERSE_SUBTRACT +BLEND_NORMAL sdl2_gpu.html#BLEND_NORMAL sdl2_gpu: BLEND_NORMAL +BLEND_PREMULTIPLIED_ALPHA sdl2_gpu.html#BLEND_PREMULTIPLIED_ALPHA sdl2_gpu: BLEND_PREMULTIPLIED_ALPHA +BLEND_MULTIPLY sdl2_gpu.html#BLEND_MULTIPLY sdl2_gpu: BLEND_MULTIPLY +BLEND_ADD sdl2_gpu.html#BLEND_ADD sdl2_gpu: BLEND_ADD +BLEND_SUBTRACT sdl2_gpu.html#BLEND_SUBTRACT sdl2_gpu: BLEND_SUBTRACT +BLEND_MOD_ALPHA sdl2_gpu.html#BLEND_MOD_ALPHA sdl2_gpu: BLEND_MOD_ALPHA +BLEND_SET_ALPHA sdl2_gpu.html#BLEND_SET_ALPHA sdl2_gpu: BLEND_SET_ALPHA +BLEND_SET sdl2_gpu.html#BLEND_SET sdl2_gpu: BLEND_SET +BLEND_NORMAL_KEEP_ALPHA sdl2_gpu.html#BLEND_NORMAL_KEEP_ALPHA sdl2_gpu: BLEND_NORMAL_KEEP_ALPHA +BLEND_NORMAL_ADD_ALPHA sdl2_gpu.html#BLEND_NORMAL_ADD_ALPHA sdl2_gpu: BLEND_NORMAL_ADD_ALPHA +BLEND_NORMAL_FACTOR_ALPHA sdl2_gpu.html#BLEND_NORMAL_FACTOR_ALPHA sdl2_gpu: BLEND_NORMAL_FACTOR_ALPHA +FILTER_NEAREST sdl2_gpu.html#FILTER_NEAREST sdl2_gpu: FILTER_NEAREST +FILTER_LINEAR sdl2_gpu.html#FILTER_LINEAR sdl2_gpu: FILTER_LINEAR +FILTER_LINEAR_MIPMAP sdl2_gpu.html#FILTER_LINEAR_MIPMAP sdl2_gpu: FILTER_LINEAR_MIPMAP +SNAP_NONE sdl2_gpu.html#SNAP_NONE sdl2_gpu: SNAP_NONE +SNAP_POSITION sdl2_gpu.html#SNAP_POSITION sdl2_gpu: SNAP_POSITION +SNAP_DIMENSIONS sdl2_gpu.html#SNAP_DIMENSIONS sdl2_gpu: SNAP_DIMENSIONS +SNAP_POSITION_AND_DIMENSIONS sdl2_gpu.html#SNAP_POSITION_AND_DIMENSIONS sdl2_gpu: SNAP_POSITION_AND_DIMENSIONS +WRAP_NONE sdl2_gpu.html#WRAP_NONE sdl2_gpu: WRAP_NONE +WRAP_REPEAT sdl2_gpu.html#WRAP_REPEAT sdl2_gpu: WRAP_REPEAT +WRAP_MIRRORED sdl2_gpu.html#WRAP_MIRRORED sdl2_gpu: WRAP_MIRRORED +FORMAT_LUMINANCE sdl2_gpu.html#FORMAT_LUMINANCE sdl2_gpu: FORMAT_LUMINANCE +FORMAT_LUMINANCE_ALPHA sdl2_gpu.html#FORMAT_LUMINANCE_ALPHA sdl2_gpu: FORMAT_LUMINANCE_ALPHA +FORMAT_RGB sdl2_gpu.html#FORMAT_RGB sdl2_gpu: FORMAT_RGB +FORMAT_RGBA sdl2_gpu.html#FORMAT_RGBA sdl2_gpu: FORMAT_RGBA +FORMAT_ALPHA sdl2_gpu.html#FORMAT_ALPHA sdl2_gpu: FORMAT_ALPHA +FORMAT_RG sdl2_gpu.html#FORMAT_RG sdl2_gpu: FORMAT_RG +FORMAT_YCbCr422 sdl2_gpu.html#FORMAT_YCbCr422 sdl2_gpu: FORMAT_YCbCr422 +FORMAT_YCbCr420P sdl2_gpu.html#FORMAT_YCbCr420P sdl2_gpu: FORMAT_YCbCr420P +FORMAT_BGR sdl2_gpu.html#FORMAT_BGR sdl2_gpu: FORMAT_BGR +FORMAT_BGRA sdl2_gpu.html#FORMAT_BGRA sdl2_gpu: FORMAT_BGRA +FORMAT_ABGR sdl2_gpu.html#FORMAT_ABGR sdl2_gpu: FORMAT_ABGR +FILE_AUTO sdl2_gpu.html#FILE_AUTO sdl2_gpu: FILE_AUTO +FILE_PNG sdl2_gpu.html#FILE_PNG sdl2_gpu: FILE_PNG +FILE_BMP sdl2_gpu.html#FILE_BMP sdl2_gpu: FILE_BMP +FILE_TGA sdl2_gpu.html#FILE_TGA sdl2_gpu: FILE_TGA +MODEL sdl2_gpu.html#MODEL sdl2_gpu: MODEL +VIEW sdl2_gpu.html#VIEW sdl2_gpu: VIEW +PROJECTION sdl2_gpu.html#PROJECTION sdl2_gpu: PROJECTION +DEFAULT_INIT_FLAGS sdl2_gpu.html#DEFAULT_INIT_FLAGS sdl2_gpu: DEFAULT_INIT_FLAGS +VERTEX_SHADER sdl2_gpu.html#VERTEX_SHADER sdl2_gpu: VERTEX_SHADER +FRAGMENT_SHADER sdl2_gpu.html#FRAGMENT_SHADER sdl2_gpu: FRAGMENT_SHADER +PIXEL_SHADER sdl2_gpu.html#PIXEL_SHADER sdl2_gpu: PIXEL_SHADER +GEOMETRY_SHADER sdl2_gpu.html#GEOMETRY_SHADER sdl2_gpu: GEOMETRY_SHADER +LANGUAGE_NONE sdl2_gpu.html#LANGUAGE_NONE sdl2_gpu: LANGUAGE_NONE +LANGUAGE_ARB_ASSEMBLY sdl2_gpu.html#LANGUAGE_ARB_ASSEMBLY sdl2_gpu: LANGUAGE_ARB_ASSEMBLY +LANGUAGE_GLSL sdl2_gpu.html#LANGUAGE_GLSL sdl2_gpu: LANGUAGE_GLSL +LANGUAGE_GLSLES sdl2_gpu.html#LANGUAGE_GLSLES sdl2_gpu: LANGUAGE_GLSLES +LANGUAGE_HLSL sdl2_gpu.html#LANGUAGE_HLSL sdl2_gpu: LANGUAGE_HLSL +LANGUAGE_CG sdl2_gpu.html#LANGUAGE_CG sdl2_gpu: LANGUAGE_CG +ERROR_NONE sdl2_gpu.html#ERROR_NONE sdl2_gpu: ERROR_NONE +ERROR_BACKEND_ERROR sdl2_gpu.html#ERROR_BACKEND_ERROR sdl2_gpu: ERROR_BACKEND_ERROR +ERROR_DATA_ERROR sdl2_gpu.html#ERROR_DATA_ERROR sdl2_gpu: ERROR_DATA_ERROR +ERROR_USER_ERROR sdl2_gpu.html#ERROR_USER_ERROR sdl2_gpu: ERROR_USER_ERROR +ERROR_UNSUPPORTED_FUNCTION sdl2_gpu.html#ERROR_UNSUPPORTED_FUNCTION sdl2_gpu: ERROR_UNSUPPORTED_FUNCTION +ERROR_NULL_ARGUMENT sdl2_gpu.html#ERROR_NULL_ARGUMENT sdl2_gpu: ERROR_NULL_ARGUMENT +ERROR_FILE_NOT_FOUND sdl2_gpu.html#ERROR_FILE_NOT_FOUND sdl2_gpu: ERROR_FILE_NOT_FOUND +DEBUG_LEVEL_0 sdl2_gpu.html#DEBUG_LEVEL_0 sdl2_gpu: DEBUG_LEVEL_0 +DEBUG_LEVEL_1 sdl2_gpu.html#DEBUG_LEVEL_1 sdl2_gpu: DEBUG_LEVEL_1 +DEBUG_LEVEL_2 sdl2_gpu.html#DEBUG_LEVEL_2 sdl2_gpu: DEBUG_LEVEL_2 +DEBUG_LEVEL_3 sdl2_gpu.html#DEBUG_LEVEL_3 sdl2_gpu: DEBUG_LEVEL_3 +DEBUG_LEVEL_MAX sdl2_gpu.html#DEBUG_LEVEL_MAX sdl2_gpu: DEBUG_LEVEL_MAX +LOG_LEVEL_INFO sdl2_gpu.html#LOG_LEVEL_INFO LogLevelEnum.LOG_LEVEL_INFO +LOG_LEVEL_WARNING sdl2_gpu.html#LOG_LEVEL_WARNING LogLevelEnum.LOG_LEVEL_WARNING +LOG_LEVEL_ERROR sdl2_gpu.html#LOG_LEVEL_ERROR LogLevelEnum.LOG_LEVEL_ERROR +LogLevelEnum sdl2_gpu.html#LogLevelEnum sdl2_gpu: LogLevelEnum +WindowFlagEnum sdl2_gpu.html#WindowFlagEnum sdl2_gpu: WindowFlagEnum +Renderer sdl2_gpu.html#Renderer sdl2_gpu: Renderer +Target sdl2_gpu.html#Target sdl2_gpu: Target +Rect sdl2_gpu.html#Rect sdl2_gpu: Rect +RendererEnum sdl2_gpu.html#RendererEnum sdl2_gpu: RendererEnum +RendererID sdl2_gpu.html#RendererID sdl2_gpu: RendererID +BlendMode sdl2_gpu.html#BlendMode sdl2_gpu: BlendMode +Image sdl2_gpu.html#Image sdl2_gpu: Image +TextureHandle sdl2_gpu.html#TextureHandle sdl2_gpu: TextureHandle +Camera sdl2_gpu.html#Camera sdl2_gpu: Camera +ShaderBlock sdl2_gpu.html#ShaderBlock sdl2_gpu: ShaderBlock +MatrixStack sdl2_gpu.html#MatrixStack sdl2_gpu: MatrixStack +Context sdl2_gpu.html#Context sdl2_gpu: Context +FeatureEnum sdl2_gpu.html#FeatureEnum sdl2_gpu: FeatureEnum +InitFlagEnum sdl2_gpu.html#InitFlagEnum sdl2_gpu: InitFlagEnum +PrimitiveEnum sdl2_gpu.html#PrimitiveEnum sdl2_gpu: PrimitiveEnum +BatchFlagEnum sdl2_gpu.html#BatchFlagEnum sdl2_gpu: BatchFlagEnum +FlipEnum sdl2_gpu.html#FlipEnum sdl2_gpu: FlipEnum +TypeEnum sdl2_gpu.html#TypeEnum sdl2_gpu: TypeEnum +AttributeFormat sdl2_gpu.html#AttributeFormat sdl2_gpu: AttributeFormat +Attribute sdl2_gpu.html#Attribute sdl2_gpu: Attribute +AttributeSource sdl2_gpu.html#AttributeSource sdl2_gpu: AttributeSource +ErrorObject sdl2_gpu.html#ErrorObject sdl2_gpu: ErrorObject +RendererImpl sdl2_gpu.html#RendererImpl sdl2_gpu: RendererImpl +getLinkedVersion sdl2_gpu.html#getLinkedVersion sdl2_gpu: getLinkedVersion(): Version +setInitWindow sdl2_gpu.html#setInitWindow,Uint32 sdl2_gpu: setInitWindow(windowID: Uint32) +getInitWindow sdl2_gpu.html#getInitWindow sdl2_gpu: getInitWindow(): Uint32 +setPreInitFlags sdl2_gpu.html#setPreInitFlags,InitFlagEnum sdl2_gpu: setPreInitFlags(flags: InitFlagEnum) +getPreInitFlags sdl2_gpu.html#getPreInitFlags sdl2_gpu: getPreInitFlags(): InitFlagEnum +setRequiredFeatures sdl2_gpu.html#setRequiredFeatures,FeatureEnum sdl2_gpu: setRequiredFeatures(features: FeatureEnum) +getRequiredFeatures sdl2_gpu.html#getRequiredFeatures sdl2_gpu: getRequiredFeatures(): FeatureEnum +getDefaultRendererOrder sdl2_gpu.html#getDefaultRendererOrder,ptr.cint,ptr.RendererID sdl2_gpu: getDefaultRendererOrder(orderSize: ptr cint; order: ptr RendererID) +getRendererOrder sdl2_gpu.html#getRendererOrder,ptr.cint,ptr.RendererID sdl2_gpu: getRendererOrder(orderSize: ptr cint; order: ptr RendererID) +setRendererOrder sdl2_gpu.html#setRendererOrder,cint,ptr.RendererID sdl2_gpu: setRendererOrder(orderSize: cint; order: ptr RendererID) +init sdl2_gpu.html#init,Uint16,Uint16,WindowFlags sdl2_gpu: init(w: Uint16; h: Uint16; flags: WindowFlagEnum): ptr Target +initRenderer sdl2_gpu.html#initRenderer,RendererEnum,Uint16,Uint16,WindowFlags sdl2_gpu: initRenderer(rendererEnum: RendererEnum; w: Uint16; h: Uint16; flags: WindowFlagEnum): ptr Target +initRendererByID sdl2_gpu.html#initRendererByID,RendererID,Uint16,Uint16,WindowFlags sdl2_gpu: initRendererByID(rendererRequest: RendererID; w: Uint16; h: Uint16;\n flags: WindowFlagEnum): ptr Target +isFeatureEnabled sdl2_gpu.html#isFeatureEnabled,FeatureEnum sdl2_gpu: isFeatureEnabled(feature: FeatureEnum): Bool +closeCurrentRenderer sdl2_gpu.html#closeCurrentRenderer sdl2_gpu: closeCurrentRenderer() +quit sdl2_gpu.html#quit sdl2_gpu: quit() +setDebugLevel sdl2_gpu.html#setDebugLevel,DebugLevelEnum sdl2_gpu: setDebugLevel(level: DebugLevelEnum) +getDebugLevel sdl2_gpu.html#getDebugLevel sdl2_gpu: getDebugLevel(): DebugLevelEnum +logInfo sdl2_gpu.html#logInfo,cstring sdl2_gpu: logInfo(format: cstring) +logWarning sdl2_gpu.html#logWarning,cstring sdl2_gpu: logWarning(format: cstring) +logError sdl2_gpu.html#logError,cstring sdl2_gpu: logError(format: cstring) +setLogCallback sdl2_gpu.html#setLogCallback,proc(LogLevelEnum,cstring,va_list) sdl2_gpu: setLogCallback(callback: proc (logLevel: LogLevelEnum; format: cstring; args: va_list): cint {.\n cdecl.}) +pushErrorCode sdl2_gpu.html#pushErrorCode,cstring,ErrorEnum,cstring sdl2_gpu: pushErrorCode(function: cstring; error: ErrorEnum; details: cstring) +popErrorCode sdl2_gpu.html#popErrorCode sdl2_gpu: popErrorCode(): ErrorObject +getErrorString sdl2_gpu.html#getErrorString,ErrorEnum sdl2_gpu: getErrorString(error: ErrorEnum): cstring +setErrorQueueMax sdl2_gpu.html#setErrorQueueMax,cuint sdl2_gpu: setErrorQueueMax(max: cuint) +makeRendererID sdl2_gpu.html#makeRendererID,cstring,RendererEnum,cint,cint sdl2_gpu: makeRendererID(name: cstring; renderer: RendererEnum; majorVersion: cint;\n minorVersion: cint): RendererID +getRendererID sdl2_gpu.html#getRendererID,RendererEnum sdl2_gpu: getRendererID(renderer: RendererEnum): RendererID +getNumRegisteredRenderers sdl2_gpu.html#getNumRegisteredRenderers sdl2_gpu: getNumRegisteredRenderers(): cint +getRegisteredRendererList sdl2_gpu.html#getRegisteredRendererList,ptr.RendererID sdl2_gpu: getRegisteredRendererList(renderersArray: ptr RendererID) +registerRenderer sdl2_gpu.html#registerRenderer,RendererID,proc(RendererID),proc(ptr.Renderer) sdl2_gpu: registerRenderer(id: RendererID; createRenderer: proc (request: RendererID): ptr Renderer {.\n cdecl.}; freeRenderer: proc (renderer: ptr Renderer) {.cdecl.}) +reserveNextRendererEnum sdl2_gpu.html#reserveNextRendererEnum sdl2_gpu: reserveNextRendererEnum(): RendererEnum +getNumActiveRenderers sdl2_gpu.html#getNumActiveRenderers sdl2_gpu: getNumActiveRenderers(): cint +getActiveRendererList sdl2_gpu.html#getActiveRendererList,ptr.RendererID sdl2_gpu: getActiveRendererList(renderersArray: ptr RendererID) +getCurrentRenderer sdl2_gpu.html#getCurrentRenderer sdl2_gpu: getCurrentRenderer(): ptr Renderer +setCurrentRenderer sdl2_gpu.html#setCurrentRenderer,RendererID sdl2_gpu: setCurrentRenderer(id: RendererID) +getRenderer sdl2_gpu.html#getRenderer,RendererID sdl2_gpu: getRenderer(id: RendererID): ptr Renderer +freeRenderer sdl2_gpu.html#freeRenderer,ptr.Renderer sdl2_gpu: freeRenderer(renderer: ptr Renderer) +resetRendererState sdl2_gpu.html#resetRendererState sdl2_gpu: resetRendererState() +setCoordinateMode sdl2_gpu.html#setCoordinateMode,Bool sdl2_gpu: setCoordinateMode(useMathCoords: Bool) +getCoordinateMode sdl2_gpu.html#getCoordinateMode sdl2_gpu: getCoordinateMode(): Bool +setDefaultAnchor sdl2_gpu.html#setDefaultAnchor,cfloat,cfloat sdl2_gpu: setDefaultAnchor(anchorX: cfloat; anchorY: cfloat) +getDefaultAnchor sdl2_gpu.html#getDefaultAnchor,ptr.cfloat,ptr.cfloat sdl2_gpu: getDefaultAnchor(anchorX: ptr cfloat; anchorY: ptr cfloat) +getContextTarget sdl2_gpu.html#getContextTarget sdl2_gpu: getContextTarget(): ptr Target +getWindowTarget sdl2_gpu.html#getWindowTarget,Uint32 sdl2_gpu: getWindowTarget(windowID: Uint32): ptr Target +createTargetFromWindow sdl2_gpu.html#createTargetFromWindow,Uint32 sdl2_gpu: createTargetFromWindow(windowID: Uint32): ptr Target +makeCurrent sdl2_gpu.html#makeCurrent,ptr.Target,Uint32 sdl2_gpu: makeCurrent(target: ptr Target; windowID: Uint32) +setWindowResolution sdl2_gpu.html#setWindowResolution,Uint16,Uint16 sdl2_gpu: setWindowResolution(w: Uint16; h: Uint16): Bool +setFullscreen sdl2_gpu.html#setFullscreen,Bool,Bool sdl2_gpu: setFullscreen(enableFullscreen: Bool; useDesktopResolution: Bool): Bool +getFullscreen sdl2_gpu.html#getFullscreen sdl2_gpu: getFullscreen(): Bool +getActiveTarget sdl2_gpu.html#getActiveTarget sdl2_gpu: getActiveTarget(): ptr Target +setActiveTarget sdl2_gpu.html#setActiveTarget,ptr.Target sdl2_gpu: setActiveTarget(target: ptr Target): Bool +setShapeBlending sdl2_gpu.html#setShapeBlending,Bool sdl2_gpu: setShapeBlending(enable: Bool) +getBlendModeFromPreset sdl2_gpu.html#getBlendModeFromPreset,BlendPresetEnum sdl2_gpu: getBlendModeFromPreset(preset: BlendPresetEnum): BlendMode +setShapeBlendFunction sdl2_gpu.html#setShapeBlendFunction,BlendFuncEnum,BlendFuncEnum,BlendFuncEnum,BlendFuncEnum sdl2_gpu: setShapeBlendFunction(sourceColor: BlendFuncEnum; destColor: BlendFuncEnum;\n sourceAlpha: BlendFuncEnum; destAlpha: BlendFuncEnum) +setShapeBlendEquation sdl2_gpu.html#setShapeBlendEquation,BlendEqEnum,BlendEqEnum sdl2_gpu: setShapeBlendEquation(colorEquation: BlendEqEnum; alphaEquation: BlendEqEnum) +setShapeBlendMode sdl2_gpu.html#setShapeBlendMode,BlendPresetEnum sdl2_gpu: setShapeBlendMode(mode: BlendPresetEnum) +setLineThickness sdl2_gpu.html#setLineThickness,cfloat sdl2_gpu: setLineThickness(thickness: cfloat): cfloat +getLineThickness sdl2_gpu.html#getLineThickness sdl2_gpu: getLineThickness(): cfloat +createAliasTarget sdl2_gpu.html#createAliasTarget,ptr.Target sdl2_gpu: createAliasTarget(target: ptr Target): ptr Target +loadTarget sdl2_gpu.html#loadTarget,ptr.Image sdl2_gpu: loadTarget(image: ptr Image): ptr Target +getTarget sdl2_gpu.html#getTarget,ptr.Image sdl2_gpu: getTarget(image: ptr Image): ptr Target +freeTarget sdl2_gpu.html#freeTarget,ptr.Target sdl2_gpu: freeTarget(target: ptr Target) +setVirtualResolution sdl2_gpu.html#setVirtualResolution,ptr.Target,Uint16,Uint16 sdl2_gpu: setVirtualResolution(target: ptr Target; w: Uint16; h: Uint16) +getVirtualResolution sdl2_gpu.html#getVirtualResolution,ptr.Target,ptr.Uint16,ptr.Uint16 sdl2_gpu: getVirtualResolution(target: ptr Target; w: ptr Uint16; h: ptr Uint16) +getVirtualCoords sdl2_gpu.html#getVirtualCoords,ptr.Target,ptr.cfloat,ptr.cfloat,cfloat,cfloat sdl2_gpu: getVirtualCoords(target: ptr Target; x: ptr cfloat; y: ptr cfloat; displayX: cfloat;\n displayY: cfloat) +unsetVirtualResolution sdl2_gpu.html#unsetVirtualResolution,ptr.Target sdl2_gpu: unsetVirtualResolution(target: ptr Target) +makeRect sdl2_gpu.html#makeRect,cfloat,cfloat,cfloat,cfloat sdl2_gpu: makeRect(x: cfloat; y: cfloat; w: cfloat; h: cfloat): Rect +makeColor sdl2_gpu.html#makeColor,Uint8,Uint8,Uint8,Uint8 sdl2_gpu: makeColor(r: Uint8; g: Uint8; b: Uint8; a: Uint8): Color +setViewport sdl2_gpu.html#setViewport,ptr.Target,Rect sdl2_gpu: setViewport(target: ptr Target; viewport: Rect) +unsetViewport sdl2_gpu.html#unsetViewport,ptr.Target sdl2_gpu: unsetViewport(target: ptr Target) +getDefaultCamera sdl2_gpu.html#getDefaultCamera sdl2_gpu: getDefaultCamera(): Camera +getCamera sdl2_gpu.html#getCamera,ptr.Target sdl2_gpu: getCamera(target: ptr Target): Camera +setCamera sdl2_gpu.html#setCamera,ptr.Target,ptr.Camera sdl2_gpu: setCamera(target: ptr Target; cam: ptr Camera): Camera +enableCamera sdl2_gpu.html#enableCamera,ptr.Target,Bool sdl2_gpu: enableCamera(target: ptr Target; useCamera: Bool) +isCameraEnabled sdl2_gpu.html#isCameraEnabled,ptr.Target sdl2_gpu: isCameraEnabled(target: ptr Target): Bool +addDepthBuffer sdl2_gpu.html#addDepthBuffer,ptr.Target sdl2_gpu: addDepthBuffer(target: ptr Target): Bool +setDepthTest sdl2_gpu.html#setDepthTest,ptr.Target,Bool sdl2_gpu: setDepthTest(target: ptr Target; enable: Bool) +setDepthWrite sdl2_gpu.html#setDepthWrite,ptr.Target,Bool sdl2_gpu: setDepthWrite(target: ptr Target; enable: Bool) +setDepthFunction sdl2_gpu.html#setDepthFunction,ptr.Target,ComparisonEnum sdl2_gpu: setDepthFunction(target: ptr Target; compareOperation: ComparisonEnum) +getPixel sdl2_gpu.html#getPixel,ptr.Target,Sint16,Sint16 sdl2_gpu: getPixel(target: ptr Target; x: Sint16; y: Sint16): Color +setClipRect sdl2_gpu.html#setClipRect,ptr.Target,Rect sdl2_gpu: setClipRect(target: ptr Target; rect: Rect): Rect +setClip sdl2_gpu.html#setClip,ptr.Target,Sint16,Sint16,Uint16,Uint16 sdl2_gpu: setClip(target: ptr Target; x: Sint16; y: Sint16; w: Uint16; h: Uint16): Rect +unsetClip sdl2_gpu.html#unsetClip,ptr.Target sdl2_gpu: unsetClip(target: ptr Target) +intersectRect sdl2_gpu.html#intersectRect,Rect,Rect,ptr.Rect sdl2_gpu: intersectRect(A: Rect; B: Rect; result: ptr Rect): Bool +intersectClipRect sdl2_gpu.html#intersectClipRect,ptr.Target,Rect,ptr.Rect sdl2_gpu: intersectClipRect(target: ptr Target; B: Rect; result: ptr Rect): Bool +setTargetColor sdl2_gpu.html#setTargetColor,ptr.Target,Color sdl2_gpu: setTargetColor(target: ptr Target; color: Color) +setTargetRGB sdl2_gpu.html#setTargetRGB,ptr.Target,Uint8,Uint8,Uint8 sdl2_gpu: setTargetRGB(target: ptr Target; r: Uint8; g: Uint8; b: Uint8) +setTargetRGBA sdl2_gpu.html#setTargetRGBA,ptr.Target,Uint8,Uint8,Uint8,Uint8 sdl2_gpu: setTargetRGBA(target: ptr Target; r: Uint8; g: Uint8; b: Uint8; a: Uint8) +unsetTargetColor sdl2_gpu.html#unsetTargetColor,ptr.Target sdl2_gpu: unsetTargetColor(target: ptr Target) +loadSurface sdl2_gpu.html#loadSurface,cstring sdl2_gpu: loadSurface(filename: cstring): ptr Surface +loadSurface_RW sdl2_gpu.html#loadSurface_RW,ptr.RWops,Bool sdl2_gpu: loadSurface_RW(rwops: ptr RWops; freeRwops: Bool): ptr Surface +saveSurface sdl2_gpu.html#saveSurface,ptr.Surface,cstring,FileFormatEnum sdl2_gpu: saveSurface(surface: ptr Surface; filename: cstring; format: FileFormatEnum): Bool +saveSurface_RW sdl2_gpu.html#saveSurface_RW,ptr.Surface,ptr.RWops,Bool,FileFormatEnum sdl2_gpu: saveSurface_RW(surface: ptr Surface; rwops: ptr RWops; freeRwops: Bool;\n format: FileFormatEnum): Bool +createImage sdl2_gpu.html#createImage,Uint16,Uint16,FormatEnum sdl2_gpu: createImage(w: Uint16; h: Uint16; format: FormatEnum): ptr Image +createImageUsingTexture sdl2_gpu.html#createImageUsingTexture,TextureHandle,Bool sdl2_gpu: createImageUsingTexture(handle: TextureHandle; takeOwnership: Bool): ptr Image +loadImage sdl2_gpu.html#loadImage,cstring sdl2_gpu: loadImage(filename: cstring): ptr Image +loadImage_RW sdl2_gpu.html#loadImage_RW,ptr.RWops,Bool sdl2_gpu: loadImage_RW(rwops: ptr RWops; freeRwops: Bool): ptr Image +createAliasImage sdl2_gpu.html#createAliasImage,ptr.Image sdl2_gpu: createAliasImage(image: ptr Image): ptr Image +copyImage sdl2_gpu.html#copyImage,ptr.Image sdl2_gpu: copyImage(image: ptr Image): ptr Image +freeImage sdl2_gpu.html#freeImage,ptr.Image sdl2_gpu: freeImage(image: ptr Image) +setImageVirtualResolution sdl2_gpu.html#setImageVirtualResolution,ptr.Image,Uint16,Uint16 sdl2_gpu: setImageVirtualResolution(image: ptr Image; w: Uint16; h: Uint16) +unsetImageVirtualResolution sdl2_gpu.html#unsetImageVirtualResolution,ptr.Image sdl2_gpu: unsetImageVirtualResolution(image: ptr Image) +updateImage sdl2_gpu.html#updateImage,ptr.Image,ptr.Rect,ptr.Surface,ptr.Rect sdl2_gpu: updateImage(image: ptr Image; imageRect: ptr Rect; surface: ptr Surface;\n surfaceRect: ptr Rect) +updateImageBytes sdl2_gpu.html#updateImageBytes,ptr.Image,ptr.Rect,ptr.cuchar,cint sdl2_gpu: updateImageBytes(image: ptr Image; imageRect: ptr Rect; bytes: ptr cuchar;\n bytesPerRow: cint) +replaceImage sdl2_gpu.html#replaceImage,ptr.Image,ptr.Surface,ptr.Rect sdl2_gpu: replaceImage(image: ptr Image; surface: ptr Surface; surfaceRect: ptr Rect): Bool +saveImage sdl2_gpu.html#saveImage,ptr.Image,cstring,FileFormatEnum sdl2_gpu: saveImage(image: ptr Image; filename: cstring; format: FileFormatEnum): Bool +saveImage_RW sdl2_gpu.html#saveImage_RW,ptr.Image,ptr.RWops,Bool,FileFormatEnum sdl2_gpu: saveImage_RW(image: ptr Image; rwops: ptr RWops; freeRwops: Bool; format: FileFormatEnum): Bool +generateMipmaps sdl2_gpu.html#generateMipmaps,ptr.Image sdl2_gpu: generateMipmaps(image: ptr Image) +setColor sdl2_gpu.html#setColor,ptr.Image,Color sdl2_gpu: setColor(image: ptr Image; color: Color) +setRGB sdl2_gpu.html#setRGB,ptr.Image,Uint8,Uint8,Uint8 sdl2_gpu: setRGB(image: ptr Image; r: Uint8; g: Uint8; b: Uint8) +setRGBA sdl2_gpu.html#setRGBA,ptr.Image,Uint8,Uint8,Uint8,Uint8 sdl2_gpu: setRGBA(image: ptr Image; r: Uint8; g: Uint8; b: Uint8; a: Uint8) +unsetColor sdl2_gpu.html#unsetColor,ptr.Image sdl2_gpu: unsetColor(image: ptr Image) +getBlending sdl2_gpu.html#getBlending,ptr.Image sdl2_gpu: getBlending(image: ptr Image): Bool +setBlending sdl2_gpu.html#setBlending,ptr.Image,Bool sdl2_gpu: setBlending(image: ptr Image; enable: Bool) +setBlendFunction sdl2_gpu.html#setBlendFunction,ptr.Image,BlendFuncEnum,BlendFuncEnum,BlendFuncEnum,BlendFuncEnum sdl2_gpu: setBlendFunction(image: ptr Image; sourceColor: BlendFuncEnum;\n destColor: BlendFuncEnum; sourceAlpha: BlendFuncEnum;\n destAlpha: BlendFuncEnum) +setBlendEquation sdl2_gpu.html#setBlendEquation,ptr.Image,BlendEqEnum,BlendEqEnum sdl2_gpu: setBlendEquation(image: ptr Image; colorEquation: BlendEqEnum;\n alphaEquation: BlendEqEnum) +setBlendMode sdl2_gpu.html#setBlendMode,ptr.Image,BlendPresetEnum sdl2_gpu: setBlendMode(image: ptr Image; mode: BlendPresetEnum) +setImageFilter sdl2_gpu.html#setImageFilter,ptr.Image,FilterEnum sdl2_gpu: setImageFilter(image: ptr Image; filter: FilterEnum) +setAnchor sdl2_gpu.html#setAnchor,ptr.Image,cfloat,cfloat sdl2_gpu: setAnchor(image: ptr Image; anchorX: cfloat; anchorY: cfloat) +getAnchor sdl2_gpu.html#getAnchor,ptr.Image,ptr.cfloat,ptr.cfloat sdl2_gpu: getAnchor(image: ptr Image; anchorX: ptr cfloat; anchorY: ptr cfloat) +getSnapMode sdl2_gpu.html#getSnapMode,ptr.Image sdl2_gpu: getSnapMode(image: ptr Image): SnapEnum +setSnapMode sdl2_gpu.html#setSnapMode,ptr.Image,SnapEnum sdl2_gpu: setSnapMode(image: ptr Image; mode: SnapEnum) +setWrapMode sdl2_gpu.html#setWrapMode,ptr.Image,WrapEnum,WrapEnum sdl2_gpu: setWrapMode(image: ptr Image; wrapModeX: WrapEnum; wrapModeY: WrapEnum) +getTextureHandle sdl2_gpu.html#getTextureHandle,ptr.Image sdl2_gpu: getTextureHandle(image: ptr Image): TextureHandle +copyImageFromSurface sdl2_gpu.html#copyImageFromSurface,ptr.Surface sdl2_gpu: copyImageFromSurface(surface: ptr Surface): ptr Image +copyImageFromTarget sdl2_gpu.html#copyImageFromTarget,ptr.Target sdl2_gpu: copyImageFromTarget(target: ptr Target): ptr Image +copySurfaceFromTarget sdl2_gpu.html#copySurfaceFromTarget,ptr.Target sdl2_gpu: copySurfaceFromTarget(target: ptr Target): ptr Surface +copySurfaceFromImage sdl2_gpu.html#copySurfaceFromImage,ptr.Image sdl2_gpu: copySurfaceFromImage(image: ptr Image): ptr Surface +vectorLength sdl2_gpu.html#vectorLength,ptr.cfloat sdl2_gpu: vectorLength(vec3: ptr cfloat): cfloat +vectorNormalize sdl2_gpu.html#vectorNormalize,ptr.cfloat sdl2_gpu: vectorNormalize(vec3: ptr cfloat) +vectorDot sdl2_gpu.html#vectorDot,ptr.cfloat,ptr.cfloat sdl2_gpu: vectorDot(A: ptr cfloat; B: ptr cfloat): cfloat +vectorCross sdl2_gpu.html#vectorCross,ptr.cfloat,ptr.cfloat,ptr.cfloat sdl2_gpu: vectorCross(result: ptr cfloat; A: ptr cfloat; B: ptr cfloat) +vectorCopy sdl2_gpu.html#vectorCopy,ptr.cfloat,ptr.cfloat sdl2_gpu: vectorCopy(result: ptr cfloat; A: ptr cfloat) +vectorApplyMatrix sdl2_gpu.html#vectorApplyMatrix,ptr.cfloat,ptr.cfloat sdl2_gpu: vectorApplyMatrix(vec3: ptr cfloat; matrix4x4: ptr cfloat) +vector4ApplyMatrix sdl2_gpu.html#vector4ApplyMatrix,ptr.cfloat,ptr.cfloat sdl2_gpu: vector4ApplyMatrix(vec4: ptr cfloat; matrix4x4: ptr cfloat) +matrixCopy sdl2_gpu.html#matrixCopy,ptr.cfloat,ptr.cfloat sdl2_gpu: matrixCopy(result: ptr cfloat; A: ptr cfloat) +matrixIdentity sdl2_gpu.html#matrixIdentity,ptr.cfloat sdl2_gpu: matrixIdentity(result: ptr cfloat) +matrixOrtho sdl2_gpu.html#matrixOrtho,ptr.cfloat,cfloat,cfloat,cfloat,cfloat,cfloat,cfloat sdl2_gpu: matrixOrtho(result: ptr cfloat; left: cfloat; right: cfloat; bottom: cfloat; top: cfloat;\n zNear: cfloat; zFar: cfloat) +matrixFrustum sdl2_gpu.html#matrixFrustum,ptr.cfloat,cfloat,cfloat,cfloat,cfloat,cfloat,cfloat sdl2_gpu: matrixFrustum(result: ptr cfloat; left: cfloat; right: cfloat; bottom: cfloat;\n top: cfloat; zNear: cfloat; zFar: cfloat) +matrixPerspective sdl2_gpu.html#matrixPerspective,ptr.cfloat,cfloat,cfloat,cfloat,cfloat sdl2_gpu: matrixPerspective(result: ptr cfloat; fovy: cfloat; aspect: cfloat; zNear: cfloat;\n zFar: cfloat) +matrixLookAt sdl2_gpu.html#matrixLookAt,ptr.cfloat,cfloat,cfloat,cfloat,cfloat,cfloat,cfloat,cfloat,cfloat,cfloat sdl2_gpu: matrixLookAt(matrix: ptr cfloat; eyeX: cfloat; eyeY: cfloat; eyeZ: cfloat;\n targetX: cfloat; targetY: cfloat; targetZ: cfloat; upX: cfloat;\n upY: cfloat; upZ: cfloat) +matrixTranslate sdl2_gpu.html#matrixTranslate,ptr.cfloat,cfloat,cfloat,cfloat sdl2_gpu: matrixTranslate(result: ptr cfloat; x: cfloat; y: cfloat; z: cfloat) +matrixScale sdl2_gpu.html#matrixScale,ptr.cfloat,cfloat,cfloat,cfloat sdl2_gpu: matrixScale(result: ptr cfloat; sx: cfloat; sy: cfloat; sz: cfloat) +matrixRotate sdl2_gpu.html#matrixRotate,ptr.cfloat,cfloat,cfloat,cfloat,cfloat sdl2_gpu: matrixRotate(result: ptr cfloat; degrees: cfloat; x: cfloat; y: cfloat; z: cfloat) +matrixMultiply sdl2_gpu.html#matrixMultiply,ptr.cfloat,ptr.cfloat,ptr.cfloat sdl2_gpu: matrixMultiply(result: ptr cfloat; A: ptr cfloat; B: ptr cfloat) +multiplyAndAssign sdl2_gpu.html#multiplyAndAssign,ptr.cfloat,ptr.cfloat sdl2_gpu: multiplyAndAssign(result: ptr cfloat; B: ptr cfloat) +getMatrixString sdl2_gpu.html#getMatrixString,ptr.cfloat sdl2_gpu: getMatrixString(A: ptr cfloat): cstring +getCurrentMatrix sdl2_gpu.html#getCurrentMatrix sdl2_gpu: getCurrentMatrix(): ptr cfloat +getTopMatrix sdl2_gpu.html#getTopMatrix,ptr.MatrixStack sdl2_gpu: getTopMatrix(stack: ptr MatrixStack): ptr cfloat +getModel sdl2_gpu.html#getModel sdl2_gpu: getModel(): ptr cfloat +getView sdl2_gpu.html#getView sdl2_gpu: getView(): ptr cfloat +getProjection sdl2_gpu.html#getProjection sdl2_gpu: getProjection(): ptr cfloat +getModelViewProjection sdl2_gpu.html#getModelViewProjection,ptr.cfloat sdl2_gpu: getModelViewProjection(result: ptr cfloat) +createMatrixStack sdl2_gpu.html#createMatrixStack sdl2_gpu: createMatrixStack(): ptr MatrixStack +freeMatrixStack sdl2_gpu.html#freeMatrixStack,ptr.MatrixStack sdl2_gpu: freeMatrixStack(stack: ptr MatrixStack) +initMatrixStack sdl2_gpu.html#initMatrixStack,ptr.MatrixStack sdl2_gpu: initMatrixStack(stack: ptr MatrixStack) +copyMatrixStack sdl2_gpu.html#copyMatrixStack,ptr.MatrixStack,ptr.MatrixStack sdl2_gpu: copyMatrixStack(source: ptr MatrixStack; dest: ptr MatrixStack) +clearMatrixStack sdl2_gpu.html#clearMatrixStack,ptr.MatrixStack sdl2_gpu: clearMatrixStack(stack: ptr MatrixStack) +resetProjection sdl2_gpu.html#resetProjection,ptr.Target sdl2_gpu: resetProjection(target: ptr Target) +matrixMode sdl2_gpu.html#matrixMode,ptr.Target,cint sdl2_gpu: matrixMode(target: ptr Target; matrixMode: cint) +setProjection sdl2_gpu.html#setProjection,ptr.cfloat sdl2_gpu: setProjection(A: ptr cfloat) +setView sdl2_gpu.html#setView,ptr.cfloat sdl2_gpu: setView(A: ptr cfloat) +setModel sdl2_gpu.html#setModel,ptr.cfloat sdl2_gpu: setModel(A: ptr cfloat) +setProjectionFromStack sdl2_gpu.html#setProjectionFromStack,ptr.MatrixStack sdl2_gpu: setProjectionFromStack(stack: ptr MatrixStack) +setViewFromStack sdl2_gpu.html#setViewFromStack,ptr.MatrixStack sdl2_gpu: setViewFromStack(stack: ptr MatrixStack) +setModelFromStack sdl2_gpu.html#setModelFromStack,ptr.MatrixStack sdl2_gpu: setModelFromStack(stack: ptr MatrixStack) +pushMatrix sdl2_gpu.html#pushMatrix sdl2_gpu: pushMatrix() +popMatrix sdl2_gpu.html#popMatrix sdl2_gpu: popMatrix() +loadIdentity sdl2_gpu.html#loadIdentity sdl2_gpu: loadIdentity() +loadMatrix sdl2_gpu.html#loadMatrix,ptr.cfloat sdl2_gpu: loadMatrix(matrix4x4: ptr cfloat) +ortho sdl2_gpu.html#ortho,cfloat,cfloat,cfloat,cfloat,cfloat,cfloat sdl2_gpu: ortho(left: cfloat; right: cfloat; bottom: cfloat; top: cfloat; zNear: cfloat;\n zFar: cfloat) +frustum sdl2_gpu.html#frustum,cfloat,cfloat,cfloat,cfloat,cfloat,cfloat sdl2_gpu: frustum(left: cfloat; right: cfloat; bottom: cfloat; top: cfloat; zNear: cfloat;\n zFar: cfloat) +perspective sdl2_gpu.html#perspective,cfloat,cfloat,cfloat,cfloat sdl2_gpu: perspective(fovy: cfloat; aspect: cfloat; zNear: cfloat; zFar: cfloat) +lookAt sdl2_gpu.html#lookAt,cfloat,cfloat,cfloat,cfloat,cfloat,cfloat,cfloat,cfloat,cfloat sdl2_gpu: lookAt(eyeX: cfloat; eyeY: cfloat; eyeZ: cfloat; targetX: cfloat; targetY: cfloat;\n targetZ: cfloat; upX: cfloat; upY: cfloat; upZ: cfloat) +translate sdl2_gpu.html#translate,cfloat,cfloat,cfloat sdl2_gpu: translate(x: cfloat; y: cfloat; z: cfloat) +scale sdl2_gpu.html#scale,cfloat,cfloat,cfloat sdl2_gpu: scale(sx: cfloat; sy: cfloat; sz: cfloat) +rotate sdl2_gpu.html#rotate,cfloat,cfloat,cfloat,cfloat sdl2_gpu: rotate(degrees: cfloat; x: cfloat; y: cfloat; z: cfloat) +multMatrix sdl2_gpu.html#multMatrix,ptr.cfloat sdl2_gpu: multMatrix(matrix4x4: ptr cfloat) +clear sdl2_gpu.html#clear,ptr.Target sdl2_gpu: clear(target: ptr Target) +clearColor sdl2_gpu.html#clearColor,ptr.Target,Color sdl2_gpu: clearColor(target: ptr Target; color: Color) +clearRGB sdl2_gpu.html#clearRGB,ptr.Target,Uint8,Uint8,Uint8 sdl2_gpu: clearRGB(target: ptr Target; r: Uint8; g: Uint8; b: Uint8) +clearRGBA sdl2_gpu.html#clearRGBA,ptr.Target,Uint8,Uint8,Uint8,Uint8 sdl2_gpu: clearRGBA(target: ptr Target; r: Uint8; g: Uint8; b: Uint8; a: Uint8) +blit sdl2_gpu.html#blit,ptr.Image,ptr.Rect,ptr.Target,cfloat,cfloat sdl2_gpu: blit(image: ptr Image; srcRect: ptr Rect; target: ptr Target; x: cfloat; y: cfloat) +blitRotate sdl2_gpu.html#blitRotate,ptr.Image,ptr.Rect,ptr.Target,cfloat,cfloat,cfloat sdl2_gpu: blitRotate(image: ptr Image; srcRect: ptr Rect; target: ptr Target; x: cfloat; y: cfloat;\n degrees: cfloat) +blitScale sdl2_gpu.html#blitScale,ptr.Image,ptr.Rect,ptr.Target,cfloat,cfloat,cfloat,cfloat sdl2_gpu: blitScale(image: ptr Image; srcRect: ptr Rect; target: ptr Target; x: cfloat; y: cfloat;\n scaleX: cfloat; scaleY: cfloat) +blitTransform sdl2_gpu.html#blitTransform,ptr.Image,ptr.Rect,ptr.Target,cfloat,cfloat,cfloat,cfloat,cfloat sdl2_gpu: blitTransform(image: ptr Image; srcRect: ptr Rect; target: ptr Target; x: cfloat;\n y: cfloat; degrees: cfloat; scaleX: cfloat; scaleY: cfloat) +blitTransformX sdl2_gpu.html#blitTransformX,ptr.Image,ptr.Rect,ptr.Target,cfloat,cfloat,cfloat,cfloat,cfloat,cfloat,cfloat sdl2_gpu: blitTransformX(image: ptr Image; srcRect: ptr Rect; target: ptr Target; x: cfloat;\n y: cfloat; pivotX: cfloat; pivotY: cfloat; degrees: cfloat;\n scaleX: cfloat; scaleY: cfloat) +blitRect sdl2_gpu.html#blitRect,ptr.Image,ptr.Rect,ptr.Target,ptr.Rect sdl2_gpu: blitRect(image: ptr Image; srcRect: ptr Rect; target: ptr Target; destRect: ptr Rect) +blitRectX sdl2_gpu.html#blitRectX,ptr.Image,ptr.Rect,ptr.Target,ptr.Rect,cfloat,cfloat,cfloat,FlipEnum sdl2_gpu: blitRectX(image: ptr Image; srcRect: ptr Rect; target: ptr Target; destRect: ptr Rect;\n degrees: cfloat; pivotX: cfloat; pivotY: cfloat; flipDirection: FlipEnum) +triangleBatch sdl2_gpu.html#triangleBatch,ptr.Image,ptr.Target,cushort,ptr.cfloat,cuint,ptr.cushort,BatchFlagEnum sdl2_gpu: triangleBatch(image: ptr Image; target: ptr Target; numVertices: cushort;\n values: ptr cfloat; numIndices: cuint; indices: ptr cushort;\n flags: BatchFlagEnum) +triangleBatchX sdl2_gpu.html#triangleBatchX,ptr.Image,ptr.Target,cushort,pointer,cuint,ptr.cushort,BatchFlagEnum sdl2_gpu: triangleBatchX(image: ptr Image; target: ptr Target; numVertices: cushort;\n values: pointer; numIndices: cuint; indices: ptr cushort;\n flags: BatchFlagEnum) +primitiveBatch sdl2_gpu.html#primitiveBatch,ptr.Image,ptr.Target,PrimitiveEnum,cushort,ptr.cfloat,cuint,ptr.cushort,BatchFlagEnum sdl2_gpu: primitiveBatch(image: ptr Image; target: ptr Target; primitiveType: PrimitiveEnum;\n numVertices: cushort; values: ptr cfloat; numIndices: cuint;\n indices: ptr cushort; flags: BatchFlagEnum) +primitiveBatchV sdl2_gpu.html#primitiveBatchV,ptr.Image,ptr.Target,PrimitiveEnum,cushort,pointer,cuint,ptr.cushort,BatchFlagEnum sdl2_gpu: primitiveBatchV(image: ptr Image; target: ptr Target; primitiveType: PrimitiveEnum;\n numVertices: cushort; values: pointer; numIndices: cuint;\n indices: ptr cushort; flags: BatchFlagEnum) +flushBlitBuffer sdl2_gpu.html#flushBlitBuffer sdl2_gpu: flushBlitBuffer() +flip sdl2_gpu.html#flip,ptr.Target sdl2_gpu: flip(target: ptr Target) +pixel sdl2_gpu.html#pixel,ptr.Target,cfloat,cfloat,Color sdl2_gpu: pixel(target: ptr Target; x: cfloat; y: cfloat; color: Color) +line sdl2_gpu.html#line,ptr.Target,cfloat,cfloat,cfloat,cfloat,Color sdl2_gpu: line(target: ptr Target; x1: cfloat; y1: cfloat; x2: cfloat; y2: cfloat; color: Color) +arc sdl2_gpu.html#arc,ptr.Target,cfloat,cfloat,cfloat,cfloat,cfloat,Color sdl2_gpu: arc(target: ptr Target; x: cfloat; y: cfloat; radius: cfloat; startAngle: cfloat;\n endAngle: cfloat; color: Color) +arcFilled sdl2_gpu.html#arcFilled,ptr.Target,cfloat,cfloat,cfloat,cfloat,cfloat,Color sdl2_gpu: arcFilled(target: ptr Target; x: cfloat; y: cfloat; radius: cfloat; startAngle: cfloat;\n endAngle: cfloat; color: Color) +circle sdl2_gpu.html#circle,ptr.Target,cfloat,cfloat,cfloat,Color sdl2_gpu: circle(target: ptr Target; x: cfloat; y: cfloat; radius: cfloat; color: Color) +circleFilled sdl2_gpu.html#circleFilled,ptr.Target,cfloat,cfloat,cfloat,Color sdl2_gpu: circleFilled(target: ptr Target; x: cfloat; y: cfloat; radius: cfloat; color: Color) +ellipse sdl2_gpu.html#ellipse,ptr.Target,cfloat,cfloat,cfloat,cfloat,cfloat,Color sdl2_gpu: ellipse(target: ptr Target; x: cfloat; y: cfloat; rx: cfloat; ry: cfloat; degrees: cfloat;\n color: Color) +ellipseFilled sdl2_gpu.html#ellipseFilled,ptr.Target,cfloat,cfloat,cfloat,cfloat,cfloat,Color sdl2_gpu: ellipseFilled(target: ptr Target; x: cfloat; y: cfloat; rx: cfloat; ry: cfloat;\n degrees: cfloat; color: Color) +sector sdl2_gpu.html#sector,ptr.Target,cfloat,cfloat,cfloat,cfloat,cfloat,cfloat,Color sdl2_gpu: sector(target: ptr Target; x: cfloat; y: cfloat; innerRadius: cfloat;\n outerRadius: cfloat; startAngle: cfloat; endAngle: cfloat; color: Color) +sectorFilled sdl2_gpu.html#sectorFilled,ptr.Target,cfloat,cfloat,cfloat,cfloat,cfloat,cfloat,Color sdl2_gpu: sectorFilled(target: ptr Target; x: cfloat; y: cfloat; innerRadius: cfloat;\n outerRadius: cfloat; startAngle: cfloat; endAngle: cfloat; color: Color) +tri sdl2_gpu.html#tri,ptr.Target,cfloat,cfloat,cfloat,cfloat,cfloat,cfloat,Color sdl2_gpu: tri(target: ptr Target; x1: cfloat; y1: cfloat; x2: cfloat; y2: cfloat; x3: cfloat;\n y3: cfloat; color: Color) +triFilled sdl2_gpu.html#triFilled,ptr.Target,cfloat,cfloat,cfloat,cfloat,cfloat,cfloat,Color sdl2_gpu: triFilled(target: ptr Target; x1: cfloat; y1: cfloat; x2: cfloat; y2: cfloat; x3: cfloat;\n y3: cfloat; color: Color) +rectangle sdl2_gpu.html#rectangle,ptr.Target,cfloat,cfloat,cfloat,cfloat,Color sdl2_gpu: rectangle(target: ptr Target; x1: cfloat; y1: cfloat; x2: cfloat; y2: cfloat; color: Color) +rectangle2 sdl2_gpu.html#rectangle2,ptr.Target,Rect,Color sdl2_gpu: rectangle2(target: ptr Target; rect: Rect; color: Color) +rectangleFilled sdl2_gpu.html#rectangleFilled,ptr.Target,cfloat,cfloat,cfloat,cfloat,Color sdl2_gpu: rectangleFilled(target: ptr Target; x1: cfloat; y1: cfloat; x2: cfloat; y2: cfloat;\n color: Color) +rectangleFilled2 sdl2_gpu.html#rectangleFilled2,ptr.Target,Rect,Color sdl2_gpu: rectangleFilled2(target: ptr Target; rect: Rect; color: Color) +rectangleRound sdl2_gpu.html#rectangleRound,ptr.Target,cfloat,cfloat,cfloat,cfloat,cfloat,Color sdl2_gpu: rectangleRound(target: ptr Target; x1: cfloat; y1: cfloat; x2: cfloat; y2: cfloat;\n radius: cfloat; color: Color) +rectangleRound2 sdl2_gpu.html#rectangleRound2,ptr.Target,Rect,cfloat,Color sdl2_gpu: rectangleRound2(target: ptr Target; rect: Rect; radius: cfloat; color: Color) +rectangleRoundFilled sdl2_gpu.html#rectangleRoundFilled,ptr.Target,cfloat,cfloat,cfloat,cfloat,cfloat,Color sdl2_gpu: rectangleRoundFilled(target: ptr Target; x1: cfloat; y1: cfloat; x2: cfloat; y2: cfloat;\n radius: cfloat; color: Color) +rectangleRoundFilled2 sdl2_gpu.html#rectangleRoundFilled2,ptr.Target,Rect,cfloat,Color sdl2_gpu: rectangleRoundFilled2(target: ptr Target; rect: Rect; radius: cfloat; color: Color) +polygon sdl2_gpu.html#polygon,ptr.Target,cuint,ptr.cfloat,Color sdl2_gpu: polygon(target: ptr Target; numVertices: cuint; vertices: ptr cfloat; color: Color) +polyline sdl2_gpu.html#polyline,ptr.Target,cuint,ptr.cfloat,Color,Bool sdl2_gpu: polyline(target: ptr Target; numVertices: cuint; vertices: ptr cfloat; color: Color;\n closeLoop: Bool) +polygonFilled sdl2_gpu.html#polygonFilled,ptr.Target,cuint,ptr.cfloat,Color sdl2_gpu: polygonFilled(target: ptr Target; numVertices: cuint; vertices: ptr cfloat; color: Color) +createShaderProgram sdl2_gpu.html#createShaderProgram sdl2_gpu: createShaderProgram(): Uint32 +freeShaderProgram sdl2_gpu.html#freeShaderProgram,Uint32 sdl2_gpu: freeShaderProgram(programObject: Uint32) +compileShader_RW sdl2_gpu.html#compileShader_RW,ShaderEnum,ptr.RWops,Bool sdl2_gpu: compileShader_RW(shaderType: ShaderEnum; shaderSource: ptr RWops; freeRwops: Bool): Uint32 +compileShader sdl2_gpu.html#compileShader,ShaderEnum,cstring sdl2_gpu: compileShader(shaderType: ShaderEnum; shaderSource: cstring): Uint32 +loadShader sdl2_gpu.html#loadShader,ShaderEnum,cstring sdl2_gpu: loadShader(shaderType: ShaderEnum; filename: cstring): Uint32 +linkShaders sdl2_gpu.html#linkShaders,Uint32,Uint32 sdl2_gpu: linkShaders(shaderObject1: Uint32; shaderObject2: Uint32): Uint32 +linkManyShaders sdl2_gpu.html#linkManyShaders,ptr.Uint32,cint sdl2_gpu: linkManyShaders(shaderObjects: ptr Uint32; count: cint): Uint32 +freeShader sdl2_gpu.html#freeShader,Uint32 sdl2_gpu: freeShader(shaderObject: Uint32) +attachShader sdl2_gpu.html#attachShader,Uint32,Uint32 sdl2_gpu: attachShader(programObject: Uint32; shaderObject: Uint32) +detachShader sdl2_gpu.html#detachShader,Uint32,Uint32 sdl2_gpu: detachShader(programObject: Uint32; shaderObject: Uint32) +linkShaderProgram sdl2_gpu.html#linkShaderProgram,Uint32 sdl2_gpu: linkShaderProgram(programObject: Uint32): Bool +getCurrentShaderProgram sdl2_gpu.html#getCurrentShaderProgram sdl2_gpu: getCurrentShaderProgram(): Uint32 +isDefaultShaderProgram sdl2_gpu.html#isDefaultShaderProgram,Uint32 sdl2_gpu: isDefaultShaderProgram(programObject: Uint32): Bool +activateShaderProgram sdl2_gpu.html#activateShaderProgram,Uint32,ptr.ShaderBlock sdl2_gpu: activateShaderProgram(programObject: Uint32; `block`: ptr ShaderBlock) +deactivateShaderProgram sdl2_gpu.html#deactivateShaderProgram sdl2_gpu: deactivateShaderProgram() +getShaderMessage sdl2_gpu.html#getShaderMessage sdl2_gpu: getShaderMessage(): cstring +getAttributeLocation sdl2_gpu.html#getAttributeLocation,Uint32,cstring sdl2_gpu: getAttributeLocation(programObject: Uint32; attribName: cstring): cint +makeAttributeFormat sdl2_gpu.html#makeAttributeFormat,cint,TypeEnum,Bool,cint,cint sdl2_gpu: makeAttributeFormat(numElemsPerVertex: cint; kind: TypeEnum; normalize: Bool;\n strideBytes: cint; offsetBytes: cint): AttributeFormat +makeAttribute sdl2_gpu.html#makeAttribute,cint,pointer,AttributeFormat sdl2_gpu: makeAttribute(location: cint; values: pointer; format: AttributeFormat): Attribute +getUniformLocation sdl2_gpu.html#getUniformLocation,Uint32,cstring sdl2_gpu: getUniformLocation(programObject: Uint32; uniformName: cstring): cint +loadShaderBlock sdl2_gpu.html#loadShaderBlock,Uint32,cstring,cstring,cstring,cstring sdl2_gpu: loadShaderBlock(programObject: Uint32; positionName: cstring; texcoordName: cstring;\n colorName: cstring; modelViewMatrixName: cstring): ShaderBlock +setShaderBlock sdl2_gpu.html#setShaderBlock,ShaderBlock sdl2_gpu: setShaderBlock(`block`: ShaderBlock) +getShaderBlock sdl2_gpu.html#getShaderBlock sdl2_gpu: getShaderBlock(): ShaderBlock +setShaderImage sdl2_gpu.html#setShaderImage,ptr.Image,cint,cint sdl2_gpu: setShaderImage(image: ptr Image; location: cint; imageUnit: cint) +getUniformiv sdl2_gpu.html#getUniformiv,Uint32,cint,ptr.cint sdl2_gpu: getUniformiv(programObject: Uint32; location: cint; values: ptr cint) +setUniformi sdl2_gpu.html#setUniformi,cint,cint sdl2_gpu: setUniformi(location: cint; value: cint) +setUniformiv sdl2_gpu.html#setUniformiv,cint,cint,cint,ptr.cint sdl2_gpu: setUniformiv(location: cint; numElementsPerValue: cint; numValues: cint;\n values: ptr cint) +getUniformuiv sdl2_gpu.html#getUniformuiv,Uint32,cint,ptr.cuint sdl2_gpu: getUniformuiv(programObject: Uint32; location: cint; values: ptr cuint) +setUniformui sdl2_gpu.html#setUniformui,cint,cuint sdl2_gpu: setUniformui(location: cint; value: cuint) +setUniformuiv sdl2_gpu.html#setUniformuiv,cint,cint,cint,ptr.cuint sdl2_gpu: setUniformuiv(location: cint; numElementsPerValue: cint; numValues: cint;\n values: ptr cuint) +getUniformfv sdl2_gpu.html#getUniformfv,Uint32,cint,ptr.cfloat sdl2_gpu: getUniformfv(programObject: Uint32; location: cint; values: ptr cfloat) +setUniformf sdl2_gpu.html#setUniformf,cint,cfloat sdl2_gpu: setUniformf(location: cint; value: cfloat) +setUniformfv sdl2_gpu.html#setUniformfv,cint,cint,cint,ptr.cfloat sdl2_gpu: setUniformfv(location: cint; numElementsPerValue: cint; numValues: cint;\n values: ptr cfloat) +getUniformMatrixfv sdl2_gpu.html#getUniformMatrixfv,Uint32,cint,ptr.cfloat sdl2_gpu: getUniformMatrixfv(programObject: Uint32; location: cint; values: ptr cfloat) +setUniformMatrixfv sdl2_gpu.html#setUniformMatrixfv,cint,cint,cint,cint,Bool,ptr.cfloat sdl2_gpu: setUniformMatrixfv(location: cint; numMatrices: cint; numRows: cint; numColumns: cint;\n transpose: Bool; values: ptr cfloat) +setAttributef sdl2_gpu.html#setAttributef,cint,cfloat sdl2_gpu: setAttributef(location: cint; value: cfloat) +setAttributei sdl2_gpu.html#setAttributei,cint,cint sdl2_gpu: setAttributei(location: cint; value: cint) +setAttributeui sdl2_gpu.html#setAttributeui,cint,cuint sdl2_gpu: setAttributeui(location: cint; value: cuint) +setAttributefv sdl2_gpu.html#setAttributefv,cint,cint,ptr.cfloat sdl2_gpu: setAttributefv(location: cint; numElements: cint; value: ptr cfloat) +setAttributeiv sdl2_gpu.html#setAttributeiv,cint,cint,ptr.cint sdl2_gpu: setAttributeiv(location: cint; numElements: cint; value: ptr cint) +setAttributeuiv sdl2_gpu.html#setAttributeuiv,cint,cint,ptr.cuint sdl2_gpu: setAttributeuiv(location: cint; numElements: cint; value: ptr cuint) +setAttributeSource sdl2_gpu.html#setAttributeSource,cint,Attribute sdl2_gpu: setAttributeSource(numValues: cint; source: Attribute)