Added SDL API docs.

docs/api/sdl/sdl.sdl/tsdlstream.md

@@ -0,0 +1,11 @@
+---
+id: tsdlstream
+title: TSDLStream
+sidebar_label: TSDLStream
+---
+
+
+[TSDLStream](../../../sdl/sdl.sdl/tsdlstream) extends [TStream](../../../brl/brl.stream/tstream) to provide methods for reading and writing various types of values
+to and from an SDL-based Read/Write stream.
+
+

docs/api/sdl/sdl.sdlhaptic/tsdlhaptic.md

@@ -0,0 +1,239 @@
+---
+id: tsdlhaptic
+title: TSDLHaptic
+sidebar_label: TSDLHaptic
+---
+
+
+## Methods
+
+### `Method Query:UInt()`
+
+Gets the haptic device's supported features in bitwise manner.
+
+#### Returns
+A list of supported haptic features in bitwise manner (OR'd), or 0 on failure.
+
+
+
+### `Method Index:Int()`
+
+Gets the index of the haptic device.
+
+
+### `Method Pause:Int()`
+
+Pauses the haptic device.
+
+#### Returns
+0 on success or a negative error code on failure.
+
+
+
+### `Method Unpause:Int()`
+
+Unpauses the haptic device.
+
+0 on success or a negative error code on failure.
+
+
+
+### `Method StopAll:Int()`
+
+Stops all the currently playing effects on the haptic device.
+
+#### Returns
+0 on success or a negative error code on failure.
+
+
+
+### `Method NumAxes:Int()`
+
+Gets the number of haptic axes the device has.
+
+The number of haptic axes might be useful if working with the [Direction](../../../sdl/sdl.sdlhaptic/#method-direction-tsdlhapticdirection) effect.
+
+
+
+### `Method EffectSupported:Int(effect:TSDLHapticEffect)`
+
+Checks to see if an effect is supported by a haptic device.
+
+True if effect is supported, False if it isn't, or a negative error code on failure.
+
+
+
+### `Method NumEffects:Int()`
+
+Gets 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 [NumEffects](../../../sdl/sdl.sdlhaptic/#method-numeffects-int)().
+
+
+
+### `Method NumEffectsPlaying:Int()`
+
+Gets 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.
+
+
+
+### `Method NewEffect:Int(effect:TSDLHapticEffect)`
+
+Creates a new haptic effect on the device.
+
+#### Returns
+The ID of the effect on success or a negative error code on failure.
+
+
+
+### `Method RunEffect:Int(effect:Int, iterations:UInt)`
+
+Runs the effect on the 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.
+
+
+#### Returns
+0 on success or a negative error code on failure.
+
+
+
+### `Method StopEffect:Int(effect:Int)`
+
+Stops the haptic effect on the device.
+
+#### Returns
+0 on success or a negative error code on failure.
+
+
+
+### `Method EffectStatus:Int(effect:Int)`
+
+Gets the status of the current effect on the haptic device.
+
+Device must support the [SDL_HAPTIC_STATUS](../../../sdl/sdl.sdlhaptic/#const-sdl-haptic-status-int-1-shl-14) feature.
+
+
+#### Returns
+0 if it isn't playing, 1 if it is playing, or a negative error code on failure.
+
+
+
+### `Method DestroyEffect(effect:Int)`
+
+Destroys the haptic effect on the device.
+
+This will stop the effect if it's running. Effects are automatically destroyed when the device is closed.
+
+
+
+### `Method RumbleInit:Int()`
+
+Initializes the haptic device for simple rumble playback.
+
+#### Returns
+0 on success or a negative error code on failure.
+
+
+
+### `Method RumblePlay:Int(strength:Float, length:UInt)`
+
+Runs a simple rumble effect on a haptic device.
+
+
+### `Method RumbleStop:Int()`
+
+Stops the simple rumble on the haptic device.
+
+#### Returns
+0 on success or a negative error code on failure.
+
+
+
+### `Method RumbleSupported:Int()`
+
+Checks whether rumble is supported on the haptic device.
+
+
+### `Method SetAutocenter:Int(value:Int)`
+
+Sets the global autocenter of the haptic device.
+
+#### Returns
+0 on success or a negative error code on failure.
+
+
+
+### `Method SetGain:Int(value:Int)`
+
+Sets the global gain of the haptic device.
+
+
+### `Method Close()`
+
+Closes the haptic device.
+
+
+## Functions
+
+### `Function Open:TSDLHaptic(device:Int)`
+
+Opens a haptic device for use.
+
+The device 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 SetGain() and SetAutocenter().
+
+
+
+### `Function OpenFromJoystick:TSDLHaptic(joystick:TSDLJoystick)`
+
+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 opened 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.
+
+
+#### Returns
+Aa valid haptic device on success or NULL on failure.
+
+
+
+### `Function MouseIsHaptic:Int()`
+
+Gets whether or not the current mouse has haptic capabilities.
+
+
+### `Function OpenFromMouse:TSDLHaptic()`
+
+Opens a haptic device from the current mouse.
+
+#### Returns
+The haptic device or NULL on failure.
+
+
+
+### `Function NumHaptics:Int()`
+
+Counts the number of haptic devices attached to the system.
+
+
+### `Function Name:String(device:Int)`
+
+Gets the implementation dependent name of the haptic device.
+
+
+### `Function Opened:Int(device:Int)`
+
+Checks if the haptic device at the designated index has been opened.
+
+#### Returns
+Returns True if it has been opened, False if it hasn't or on failure.
+
+
+

docs/api/sdl/sdl.sdlhaptic/tsdlhapticcondition.md

@@ -0,0 +1,107 @@
+---
+id: tsdlhapticcondition
+title: TSDLHapticCondition
+sidebar_label: TSDLHapticCondition
+---
+
+
+## Methods
+
+### `Method New(effectType:Int)`
+
+Creates a new instance of the effect.
+
+<b>effectType</b> one of [SDL_HAPTIC_SPRING](../../../sdl/sdl.sdlhaptic/#const-sdl-haptic-spring-int-1-shl-7), [SDL_HAPTIC_DAMPER](../../../sdl/sdl.sdlhaptic/#const-sdl-haptic-damper-int-1-shl-8), [SDL_HAPTIC_INERTIA](../../../sdl/sdl.sdlhaptic/#const-sdl-haptic-inertia-int-1-shl-9), [SDL_HAPTIC_FRICTION](../../../sdl/sdl.sdlhaptic/#const-sdl-haptic-friction-int-1-shl-10)
+
+
+
+### `Method GetLength:UInt()`
+
+Returns the duration of effect (ms).
+
+
+### `Method GetDelay:Short()`
+
+Returns the delay before starting effect.
+
+
+### `Method GetButton:Short()`
+
+Returns the button that triggers effect.
+
+
+### `Method GetInterval:Short()`
+
+Returns how soon before effect can be triggered again.
+
+
+### `Method Direction:TSDLHapticDirection()`
+
+Returns the effect direction.
+
+This instance is owned by the effect, and any changes will apply only to this effect.
+
+
+
+### `Method SetLength(value:UInt)`
+
+Sets the duration of the effect.
+
+You can pass SDL_HAPTIC_INFINITY to length instead of a 0-32767 value.
+
+
+
+### `Method SetDelay(value:Short)`
+
+Sets the delay before starting the effect.
+
+
+### `Method SetButton(value:Short)`
+
+Sets the button that triggers the effect.
+
+
+### `Method SetInterval(value:Short)`
+
+Sets how soon it can be triggered again after button.
+
+
+### `Method SetRightSat(x:Short, y:Short = 0, z:Short = 0)`
+
+Sets level when joystick is to the positive side.
+
+max = $FFFF
+
+
+
+### `Method SetLeftSat(x:Short, y:Short = 0, z:Short = 0)`
+
+Sets level when joystick is to the negative side.
+
+max = $FFFF
+
+
+
+### `Method SetRightCoeff(x:Int, y:Int = 0, z:Int = 0)`
+
+Sets how fast to increase the force towards the positive side.
+
+
+### `Method SetLeftCoeff(x:Int, y:Int = 0, z:Int = 0)`
+
+Sets how fast to increase the force towards the negative side.
+
+
+### `Method SetDeadband(x:Short, y:Short = 0, z:Short = 0)`
+
+Sets the size of the dead zone.
+
+max = $FFFF: whole axis-range when 0-centered
+
+
+
+### `Method SetCenter(x:Int, y:Int = 0, z:Int = 0)`
+
+Sets the position of the dead zone.
+
+

docs/api/sdl/sdl.sdlhaptic/tsdlhapticconstant.md

@@ -0,0 +1,110 @@
+---
+id: tsdlhapticconstant
+title: TSDLHapticConstant
+sidebar_label: TSDLHapticConstant
+---
+
+
+## Methods
+
+### `Method New()`
+
+Creates a new instance of the effect.
+
+
+### `Method GetLength:UInt()`
+
+Returns the duration of effect (ms).
+
+
+### `Method GetDelay:Short()`
+
+Returns the delay before starting effect.
+
+
+### `Method GetButton:Short()`
+
+Returns the button that triggers effect.
+
+
+### `Method GetInterval:Short()`
+
+Returns how soon before effect can be triggered again.
+
+
+### `Method GetAttackLength:Short()`
+
+Returns the duration of the attack (ms).
+
+
+### `Method GetAttackLevel:Short()`
+
+Returns the level at the start of the attack.
+
+
+### `Method GetFadeLength:Short()`
+
+Returns the duration of the fade out (ms).
+
+
+### `Method GetFadeLevel:Short()`
+
+Returns the level at the end of the fade.
+
+
+### `Method Direction:TSDLHapticDirection()`
+
+Returns the effect direction.
+
+This instance is owned by the effect, and any changes will apply only to this effect.
+
+
+
+### `Method SetLength(value:UInt)`
+
+Sets the duration of the effect.
+
+You can pass SDL_HAPTIC_INFINITY to length instead of a 0-32767 value.
+
+
+
+### `Method SetDelay(value:Short)`
+
+Sets the delay before starting the effect.
+
+
+### `Method SetButton(value:Short)`
+
+Sets the button that triggers the effect.
+
+
+### `Method SetInterval(value:Short)`
+
+Sets how soon it can be triggered again after button.
+
+
+### `Method SetLevel(value:Int)`
+
+Sets the strength of the constant effect.
+
+
+### `Method SetAttackLength(value:Short)`
+
+Sets the duration of the attack.
+
+
+### `Method SetAttackLevel(value:Short)`
+
+Sets the level at the start of the attack.
+
+
+### `Method SetFadeLength(value:Short)`
+
+Sets the duration of the fade.
+
+
+### `Method SetFadeLevel(value:Short)`
+
+Sets the level at the end of the fade.
+
+

docs/api/sdl/sdl.sdlhaptic/tsdlhapticcustom.md

@@ -0,0 +1,128 @@
+---
+id: tsdlhapticcustom
+title: TSDLHapticCustom
+sidebar_label: TSDLHapticCustom
+---
+
+
+The 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 Short samples.
+If channels is 1, the effect is rotated using the defined direction. Otherwise it uses the samples in data for the different axes.
+
+
+## Methods
+
+### `Method New()`
+
+Creates a new instance of the effect.
+
+
+### `Method GetLength:UInt()`
+
+Returns the duration of effect (ms).
+
+
+### `Method GetDelay:Short()`
+
+Returns the delay before starting effect.
+
+
+### `Method GetButton:Short()`
+
+Returns the button that triggers effect.
+
+
+### `Method GetInterval:Short()`
+
+Returns how soon before effect can be triggered again.
+
+
+### `Method GetAttackLength:Short()`
+
+Returns the duration of the attack (ms).
+
+
+### `Method GetAttackLevel:Short()`
+
+Returns the level at the start of the attack.
+
+
+### `Method GetFadeLength:Short()`
+
+Returns the duration of the fade out (ms).
+
+
+### `Method GetFadeLevel:Short()`
+
+Returns the level at the end of the fade.
+
+
+### `Method Direction:TSDLHapticDirection()`
+
+Returns the effect direction.
+
+This instance is owned by the effect, and any changes will apply only to this effect.
+
+
+
+### `Method SetLength(value:UInt)`
+
+Sets the duration of the effect.
+
+You can pass SDL_HAPTIC_INFINITY to length instead of a 0-32767 value.
+
+
+
+### `Method SetDelay(value:Short)`
+
+Sets the delay before starting the effect.
+
+
+### `Method SetButton(value:Short)`
+
+Sets the button that triggers the effect.
+
+
+### `Method SetInterval(value:Short)`
+
+Sets how soon it can be triggered again after button.
+
+
+### `Method SetChannels(value:Byte)`
+
+Sets the axes to use, minimum of 1.
+
+If channels is 1, the effect is rotated using the defined direction. Otherwise it uses the samples in data for the different axes.
+
+
+
+### `Method SetPeriod(value:Byte)`
+
+Sets the sample periods.
+
+
+### `Method SetData(data:Short[])`
+
+Sets the samples data.
+
+
+### `Method SetAttackLength(value:Short)`
+
+Sets the duration of the attack.
+
+
+### `Method SetAttackLevel(value:Short)`
+
+Sets the level at the start of the attack.
+
+
+### `Method SetFadeLength(value:Short)`
+
+Sets the duration of the fade.
+
+
+### `Method SetFadeLevel(value:Short)`
+
+Sets the level at the end of the fade.
+
+

docs/api/sdl/sdl.sdlhaptic/tsdlhapticdirection.md

@@ -0,0 +1,21 @@
+---
+id: tsdlhapticdirection
+title: TSDLHapticDirection
+sidebar_label: TSDLHapticDirection
+---
+
+
+Cardinal directions of the haptic device are relative to the positioning of the device. North is
+considered to be away from the user. South is toward the user, east is right, and west is left of the user.
+
+
+## Methods
+
+### `Method SetType(value:Int)`
+
+Sets the type of encoding.
+
+One of [SDL_HAPTIC_POLAR](../../../sdl/sdl.sdlhaptic/#const-sdl-haptic-polar-int-0), [SDL_HAPTIC_CARTESIAN](../../../sdl/sdl.sdlhaptic/#const-sdl-haptic-cartesian-int-1) or [SDL_HAPTIC_SPHERICAL](../../../sdl/sdl.sdlhaptic/#const-sdl-haptic-spherical-int-2).
+
+
+

docs/api/sdl/sdl.sdlhaptic/tsdlhapticeffect.md

@@ -0,0 +1,14 @@
+---
+id: tsdlhapticeffect
+title: TSDLHapticEffect
+sidebar_label: TSDLHapticEffect
+---
+
+
+## Methods
+
+### `Method Free()`
+
+Frees the effect.
+
+

docs/api/sdl/sdl.sdlhaptic/tsdlhapticleftright.md

@@ -0,0 +1,32 @@
+---
+id: tsdlhapticleftright
+title: TSDLHapticLeftRight
+sidebar_label: TSDLHapticLeftRight
+---
+
+
+One motor is high frequency, the other is low frequency.
+
+
+## Methods
+
+### `Method New()`
+
+Creates a new instance of the effect.
+
+
+### `Method SetLength(value:UInt)`
+
+Sets the duration of the effect.
+
+
+### `Method SetLargeMagnitude(value:Short)`
+
+Sets the control of the large controller motor.
+
+
+### `Method SetSmallMagnitude(value:Short)`
+
+Sets the control of the small controller motor.
+
+

docs/api/sdl/sdl.sdlhaptic/tsdlhapticperiodic.md

@@ -0,0 +1,143 @@
+---
+id: tsdlhapticperiodic
+title: TSDLHapticPeriodic
+sidebar_label: TSDLHapticPeriodic
+---
+
+
+The type determines the shape of the wave and the other parameters determine the dimensions of the wave.
+
+
+## Methods
+
+### `Method New(waveType:Int)`
+
+Creates a new instance of the effect.
+
+<b>waveType</b> one of [SDL_HAPTIC_SINE](../../../sdl/sdl.sdlhaptic/#const-sdl-haptic-sine-int-1-shl-1), [SDL_HAPTIC_LEFTRIGHT](../../../sdl/sdl.sdlhaptic/#const-sdl-haptic-leftright-int-1-shl-2), [SDL_HAPTIC_TRIANGLE](../../../sdl/sdl.sdlhaptic/#const-sdl-haptic-triangle-int-1-shl-3), [SDL_HAPTIC_SAWTOOTHUP](../../../sdl/sdl.sdlhaptic/#const-sdl-haptic-sawtoothup-int-1-shl-4) or [SDL_HAPTIC_SAWTOOTHDOWN](../../../sdl/sdl.sdlhaptic/#const-sdl-haptic-sawtoothdown-int-1-shl-5).
+
+
+
+### `Method GetLength:UInt()`
+
+Returns the duration of effect (ms).
+
+
+### `Method GetDelay:Short()`
+
+Returns the delay before starting effect.
+
+
+### `Method GetButton:Short()`
+
+Returns the button that triggers effect.
+
+
+### `Method GetInterval:Short()`
+
+Returns how soon before effect can be triggered again.
+
+
+### `Method GetAttackLength:Short()`
+
+Returns the duration of the attack (ms).
+
+
+### `Method GetAttackLevel:Short()`
+
+Returns the level at the start of the attack.
+
+
+### `Method GetFadeLength:Short()`
+
+Returns the duration of the fade out (ms).
+
+
+### `Method GetFadeLevel:Short()`
+
+Returns the level at the end of the fade.
+
+
+### `Method Direction:TSDLHapticDirection()`
+
+Returns the effect direction.
+
+This instance is owned by the effect, and any changes will apply only to this effect.
+
+
+
+### `Method SetLength(value:UInt)`
+
+Sets the duration of the effect.
+
+You can pass SDL_HAPTIC_INFINITY to length instead of a 0-32767 value.
+
+
+
+### `Method SetDelay(value:Short)`
+
+Sets the delay before starting the effect.
+
+
+### `Method SetButton(value:Short)`
+
+Sets the button that triggers the effect.
+
+
+### `Method SetInterval(value:Short)`
+
+Sets how soon it can be triggered again after button.
+
+
+### `Method SetPeriod(value:Short)`
+
+Sets the period of the wave.
+
+
+### `Method SetMagnitude(value:Int)`
+
+Sets the peak value
+
+Ff negative, equivalent to 180 degrees extra phase shift
+
+
+
+### `Method SetOffset(value:Int)`
+
+Sets the mean value of the wave.
+
+
+### `Method SetPhase(value:Short)`
+
+Sets the positive phase shift given by hundredth of a degree.
+
+Phase is given by hundredths of a degree, meaning that giving the phase a value of 9000
+will displace it 25% of its period. Here are sample values:
+<p>0 - No phase displacement</p>
+<p>9000 - Displaced 25% of its period</p>
+<p>18000 - Displaced 50% of its period</p>
+<p>27000 - Displaced 75% of its period</p>
+<p>36000 - Displaced 100% of its period, same as 0, but 0 is preferred</p>
+
+
+
+### `Method SetAttackLength(value:Short)`
+
+Sets the duration of the attack.
+
+
+### `Method SetAttackLevel(value:Short)`
+
+Sets the level at the start of the attack.
+
+
+### `Method SetFadeLength(value:Short)`
+
+Sets the duration of the fade.
+
+
+### `Method SetFadeLevel(value:Short)`
+
+Sets the level at the end of the fade.
+
+

docs/api/sdl/sdl.sdlhaptic/tsdlhapticramp.md

@@ -0,0 +1,120 @@
+---
+id: tsdlhapticramp
+title: TSDLHapticRamp
+sidebar_label: TSDLHapticRamp
+---
+
+
+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.
+
+
+## Methods
+
+### `Method New()`
+
+Creates a new instance of the effect.
+
+
+### `Method GetLength:UInt()`
+
+Returns the duration of effect (ms).
+
+
+### `Method GetDelay:Short()`
+
+Returns the delay before starting effect.
+
+
+### `Method GetButton:Short()`
+
+Returns the button that triggers effect.
+
+
+### `Method GetInterval:Short()`
+
+Returns how soon before effect can be triggered again.
+
+
+### `Method GetAttackLength:Short()`
+
+Returns the duration of the attack (ms).
+
+
+### `Method GetAttackLevel:Short()`
+
+Returns the level at the start of the attack.
+
+
+### `Method GetFadeLength:Short()`
+
+Returns the duration of the fade out (ms).
+
+
+### `Method GetFadeLevel:Short()`
+
+Returns the level at the end of the fade.
+
+
+### `Method Direction:TSDLHapticDirection()`
+
+Returns the effect direction.
+
+This instance is owned by the effect, and any changes will apply only to this effect.
+
+
+
+### `Method SetLength(value:UInt)`
+
+Sets the duration of the effect.
+
+This effect does not support a duration of SDL_HAPTIC_INFINITY.
+
+
+
+### `Method SetDelay(value:Short)`
+
+Sets the delay before starting the effect.
+
+
+### `Method SetButton(value:Short)`
+
+Sets the button that triggers the effect.
+
+
+### `Method SetInterval(value:Short)`
+
+Sets how soon it can be triggered again after button.
+
+
+### `Method SetStart(value:Int)`
+
+Sets the beginning strength level.
+
+
+### `Method SetEnd(value:Int)`
+
+Sets the ending strength level.
+
+
+### `Method SetAttackLength(value:Short)`
+
+Sets the duration of the attack.
+
+
+### `Method SetAttackLevel(value:Short)`
+
+Sets the level at the start of the attack.
+
+
+### `Method SetFadeLength(value:Short)`
+
+Sets the duration of the fade.
+
+
+### `Method SetFadeLevel(value:Short)`
+
+Sets the level at the end of the fade.
+
+

docs/api/sdl/sdl.sdlrender/tsdlrenderer.md

@@ -0,0 +1,197 @@
+---
+id: tsdlrenderer
+title: TSDLRenderer
+sidebar_label: TSDLRenderer
+---
+
+
+## Methods
+
+### `Method CreateTexture:TSDLTexture(format:UInt, access:Int, width:Int, height:Int)`
+
+Creates a texture for a rendering context.
+
+
+### `Method CreateTextureFromSurface:TSDLTexture(surface:TSDLSurface)`
+
+Creates a texture from an existing surface.
+
+
+### `Method GetDrawBlendMode:Int(blendMode:Int Var)`
+
+Gets the blend mode used for drawing operations.
+
+
+### `Method GetDrawColor:Int(r:Byte Var, g:Byte Var, b:Byte Var, a:Byte Var)`
+
+Gets the color used for drawing operations (Rect, Line and Clear).
+
+
+### `Method GetTarget:TSDLSurface()`
+
+Getsthe current render target.
+
+
+### `Method GetOutputSize:Int(w:Int Var, h:Int Var)`
+
+Gets the output size in pixels of a rendering context.
+
+
+### `Method Clear:Int()`
+
+Clears the current rendering target with the drawing color.
+
+
+### `Method Copy:Int(texture:TSDLTexture, sx:Int = -1, sy:Int = -1, sw:Int = -1, sh:Int = -1, dx:Int = -1, dy:Int = -1, dw:Int = -1, dh:Int = -1)`
+
+Copies a portion of the texture to the current rendering target.
+
+
+### `Method CopyEx:Int(texture:TSDLTexture, sx:Int = -1, sy:Int = -1, sw:Int = -1, sh:Int = -1, dx:Int = -1, dy:Int = -1, dw:Int = -1, dh:Int = -1, angle:Double = 0, cx:Int = -1, cy:Int = -1, flipMode:Int = SDL_FLIP_NONE)`
+
+Copies a portion of the texture to the current rendering target, optionally rotating it by angle around the given center and also flipping it top-bottom and/or left-right.
+
+
+### `Method DrawLine:Int(x1:Int, y1:Int, x2:Int, y2:Int)`
+
+Draws a line on the current rendering target.
+
+
+### `Method DrawLines:Int(points:Int Ptr, count:Int)`
+
+Draws a series of connected lines on the current rendering target.
+
+A point consists of a pair of Ints (x, y), where <b>count</b> is the count of pairs.
+
+
+
+### `Method DrawPoint:Int(x:Int, y:Int)`
+
+Draws a point on the current rendering target.
+
+
+### `Method DrawPoints:Int(points:Int Ptr, count:Int)`
+
+Draws multiple points on the current rendering target.
+
+
+### `Method DrawRect:Int(x:Int = -1, y:Int = -1, w:Int = -1, h:Int = -1)`
+
+Draws a rectangle on the current rendering target.
+
+
+### `Method DrawRects:Int(rects:Int Ptr, count:Int)`
+
+Draws some number of rectangles on the current rendering target.
+
+
+### `Method FillRect:Int(x:Int = -1, y:Int = -1, w:Int = -1, h:Int = -1)`
+
+Fills a rectangle on the current rendering target with the drawing color.
+
+
+### `Method GetIntegerScale:Int()`
+
+Gets whether integer scales are forced for resolution-independent rendering.
+
+
+### `Method GetLogicalSize(w:Int Var, h:Int Var)`
+
+Gets device independent resolution for rendering.
+
+
+### `Method GetScale(x:Float Var, y:Float Var)`
+
+Gets the drawing scale for the current target.
+
+
+### `Method GetViewport(x:Int Var, y:Int Var, w:Int Var, h:Int Var)`
+
+Gets the drawing area for the current target.
+
+
+### `Method IsClipEnabled:Int()`
+
+Gets whether clipping is enabled on the given renderer.
+
+
+### `Method Present()`
+
+Updates the screen with any rendering performed since the previous call.
+
+
+### `Method ReadPixels:Int(format:UInt, pixels:Byte Ptr, pitch:Int, x:Int = -1, y:Int = -1, w:Int = -1, h:Int = -1)`
+
+Reads pixels from the current rendering target.
+
+
+### `Method SetClipRect:Int(x:Int = -1, y:Int = -1, w:Int = -1, h:Int = -1)`
+
+Sets the clip rectangle for rendering on the specified target.
+
+
+### `Method SetIntegerScale:Int(enable:Int)`
+
+Sets whether to force integer scales for resolution-independent rendering.
+
+
+### `Method SetLogicalSize:Int(w:Int, h:Int)`
+
+Sets a device independent resolution for rendering.
+
+
+### `Method SetScale:Int(scaleX:Float, scaleY:Float)`
+
+Sets the drawing scale for rendering on the current target.
+
+
+### `Method SetViewport:Int(x:Int = -1, y:Int = -1, w:Int = -1, h:Int = -1)`
+
+Sets the drawing area for rendering on the current target.
+
+
+### `Method TargetSupported:Int()`
+
+Determines whether a window supports the use of render targets.
+
+
+### `Method SetDrawBlendMode:Int(blendMode:Int)`
+
+Sets the blend mode used for drawing operations (Fill and Line).
+
+
+### `Method SetDrawColor:Int(r:Byte, g:Byte, b:Byte, a:Byte)`
+
+Sets the color used for drawing operations (Rect, Line and Clear).
+
+
+### `Method SetTarget:Int(texture:TSDLTexture)`
+
+Sets a texture as the current rendering target.
+
+
+### `Method Destroy()`
+
+Destroys the rendering context for a window and free associated textures.
+
+
+## Functions
+
+### `Function Create:TSDLRenderer(window:TSDLWindow, index:Int = -1, flags:UInt = 0)`
+
+Creates a 2D rendering context for a window.
+
+Note that providing no flags gives priority to available [SDL_RENDERER_ACCELERATED](../../../sdl/sdl.sdlrender/#const-sdl-renderer-accelerated-int-02) renderers
+
+
+
+### `Function CreateSoftwareRenderer:TSDLRenderer(surface:TSDLSurface)`
+
+Creates a 2D software rendering context for a surface.
+
+
+### `Function GetRenderer:TSDLRenderer(window:TSDLWindow)`
+
+Gets the renderer associated with a window.
+
+

docs/api/sdl/sdl.sdlrender/tsdltexture.md

@@ -0,0 +1,69 @@
+---
+id: tsdltexture
+title: TSDLTexture
+sidebar_label: TSDLTexture
+---
+
+
+## Methods
+
+### `Method GetAlphaMod:Int(alpha:Byte Var)`
+
+Gets the additional alpha value multiplied into render copy operations.
+
+
+### `Method GetBlendMode:Int(blendMode:Int Var)`
+
+Gets the blend mode used for texture copy operations.
+
+
+### `Method GetColorMod:Int(r:Byte Var, g:Byte Var, b:Byte Var)`
+
+Gets the additional color value multiplied into render copy operations.
+
+
+### `Method Lock:Int(pixels:Byte Ptr Ptr, pitch:Int Var, x:Int = -1, y:Int = -1, w:Int = -1, h:Int = -1)`
+
+Locks a portion of the texture for write-only pixel access.
+
+
+### `Method Query:Int(format:UInt Var, access:Int Var, w:Int Var, h:Int Var)`
+
+Queries the attributes of a texture.
+
+
+### `Method SetAlphaMod:Int(alpha:Byte)`
+
+Sets an additional alpha value multiplied into render copy operations.
+
+
+### `Method SetBlendMode:Int(blendMode:Int)`
+
+Sets the blend mode for a texture, used by TSDLRenderer.Copy().
+
+
+### `Method SetColorMod:Int(r:Byte, g:Byte, b:Byte)`
+
+Sets an additional color value multiplied into render copy operations.
+
+
+### `Method Unlock()`
+
+Unlocks a texture, uploading the changes to video memory, if needed.
+
+
+### `Method Update:Int(pixels:Byte Ptr, pitch:Int, x:Int = -1, y:Int = -1, w:Int = -1, h:Int = -1)`
+
+Updates the given texture rectangle with new pixel data.
+
+
+### `Method UpdateYUV:Int(yPlane:Byte Ptr, yPitch:Int, uPlane:Byte Ptr, uPitch:Int, vPlane:Byte Ptr, vPitch:Int, x:Int = -1, y:Int = -1, w:Int = -1, h:Int = -1)`
+
+Updates a rectangle within a planar YV12 or IYUV texture with new pixel data.
+
+
+### `Method Destroy()`
+
+Destroys the texture.
+
+

docs/api/sdl/sdl.sdlsensor/tsdlsensor.md

@@ -0,0 +1,112 @@
+---
+id: tsdlsensor
+title: TSDLSensor
+sidebar_label: TSDLSensor
+---
+
+
+## Methods
+
+### `Method GetName:String()`
+
+Gets the implementation dependent name of a sensor.
+
+
+### `Method GetType:Int()`
+
+Gets the type of a sensor.
+
+This can be called before any sensors are opened.
+
+
+
+### `Method GetNonPortableType:Int()`
+
+Gets the platform dependent type of a sensor.
+
+This can be called before any sensors are opened.
+
+
+
+### `Method GetInstanceID:Int()`
+
+Gets the instance ID of a sensor.
+
+This can be called before any sensors are opened.
+
+
+
+### `Method GetData:Int(data:Float Ptr, numValues:Int)`
+
+Gets the current state of an opened sensor.
+
+The number of values and interpretation of the data is sensor dependent.
+
+
+
+### `Method Close()`
+
+Closes the sensor.
+
+
+## Functions
+
+### `Function NumSensors:Int()`
+
+Counts the number of sensors attached to the system right now.
+
+
+### `Function GetDeviceName:String(deviceIndex:Int)`
+
+Gets the implementation dependent name of a sensor.
+
+This can be called before any sensors are opened.
+
+
+
+### `Function GetDeviceType:Int(deviceIndex:Int)`
+
+Gets the type of a sensor.
+
+This can be called before any sensors are opened.
+
+
+
+### `Function GetDeviceNonPortableType:Int(deviceIndex:Int)`
+
+Gets the platform dependent type of a sensor.
+
+This can be called before any sensors are opened.
+
+
+
+### `Function GetDeviceInstanceID:Int(deviceIndex:Int)`
+
+Gets the instance ID of a sensor.
+
+This can be called before any sensors are opened.
+
+
+
+### `Function FromInstanceID:TSDLSensor(instanceID:Int)`
+
+Returns the TSDLSensor associated with an instance id.
+
+
+### `Function Open:TSDLSensor(deviceIndex:Int)`
+
+Opens a sensor for use.
+
+The index passed as an argument refers to the N'th sensor on the system.
+
+
+
+### `Function Update()`
+
+Updates 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.
+
+
+

docs/api/sdl/sdl.sdlsystem/tsdlmultigesture.md

@@ -0,0 +1,39 @@
+---
+id: tsdlmultigesture
+title: TSDLMultiGesture
+sidebar_label: TSDLMultiGesture
+---
+
+
+## Fields
+
+### `Field touchId:Long`
+
+The touch device id.
+
+
+### `Field x:Int`
+
+The center of the gesture.
+
+
+### `Field y:Int`
+
+The center of the gesture.
+
+
+### `Field dTheta:Float`
+
+The amount that the fingers rotated during this motion.
+
+
+### `Field dDist:Float`
+
+The amount that the fingers pinched during this motion.
+
+
+### `Field numFingers:Int`
+
+The number of fingers used in the gesture.
+
+

docs/api/sdl/sdl.sdlvideo/tsdldisplay.md

@@ -0,0 +1,71 @@
+---
+id: tsdldisplay
+title: TSDLDisplay
+sidebar_label: TSDLDisplay
+---
+
+
+## Methods
+
+### `Method GetName:String()`
+
+Gets the name of the display.
+
+
+### `Method GetBounds:Int(w:Int Var, h:Int Var)`
+
+Gets the desktop area represented by the display, with the primary display located at 0,0.
+
+
+### `Method GetDPI:Int(ddpi:Float Var, hdpi:Float Var, vdpi:Float Var)`
+
+Gets the diagonal, horizontal and vertical dots/pixels-per-inch for the display.
+
+#### Returns
+0 on success, or -1 if no DPI information is available.
+
+
+
+### `Method GetUsableBounds:Int(w:Int Var, h:Int Var)`
+
+Gets 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.
+
+
+
+### `Method GetNumDisplayModes:Int()`
+
+Returns the number of available display modes.
+
+
+### `Method GetDisplayMode:TSDLDisplayMode(modeIndex:Int)`
+
+Gets information about a specific display mode.
+
+#### Returns
+A display mode or Null on failure.
+
+
+
+### `Method GetDesktopDisplayMode:TSDLDisplayMode()`
+
+Gets information about the desktop display mode.
+
+#### Returns
+A display mode or Null on failure.
+
+
+
+### `Method GetCurrentDisplayMode:TSDLDisplayMode()`
+
+Gets information about the current display mode.
+
+#### Returns
+A display mode or Null on failure.
+
+
+

docs/api/sdl/sdl.sdlvideo/tsdldisplaymode.md

@@ -0,0 +1,56 @@
+---
+id: tsdldisplaymode
+title: TSDLDisplayMode
+sidebar_label: TSDLDisplayMode
+---
+
+
+## Methods
+
+### `Method Format:UInt()`
+
+One of the SDL pixel formats.
+
+
+### `Method Width:Int()`
+
+The width, in screen coordinates.
+
+
+### `Method Height:Int()`
+
+The height, in screen coordinates.
+
+
+### `Method RefreshRate:Int()`
+
+The refresh rate (in Hz), or 0 for unspecified.
+
+
+### `Method DriverData:Byte Ptr()`
+
+Driver-specific data.
+
+
+### `Method GetClosestDisplayMode:TSDLDisplayMode(display:TSDLDisplay)`
+
+Gets the closest match to this display mode.
+
+The available display modes are scanned and the closest mode matching the requested mode and returned.
+The mode format and refresh rate default to the desktop mode if they are set to 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.
+
+
+#### Returns
+The closest mode or Null if no matching display mode was available.
+
+
+
+## Functions
+
+### `Function Create:TSDLDisplayMode(format:UInt, width:Int, height:Int, refreshRate:Int)`
+
+Creates a new custom display mode, useful for calling [GetClosestDisplayMode](../../../sdl/sdl.sdlvideo/#method-getclosestdisplaymode-tsdldisplaymode-display-tsdldisplay).
+
+

docs/api/sdl/sdl.sdlvideo/tsdlglcontext.md

@@ -0,0 +1,138 @@
+---
+id: tsdlglcontext
+title: TSDLGLContext
+sidebar_label: TSDLGLContext
+---
+
+
+## Methods
+
+### `Method Free()`
+
+Frees the GL Context.
+
+
+## Functions
+
+### `Function ExtensionSupported:Int(extension:String)`
+
+Checks if an OpenGL extension is supported for the current context.
+
+This method operates on the current GL context; you must have created a context and it must be current before calling this method.
+Do not assume that all contexts you create will have the same set of extensions available, or that recreating an existing context
+will offer the same extensions again.
+While it's probably not a massive overhead, this method is not an O(1) operation. Check the extensions you care about after creating
+the GL context and save that information somewhere instead of calling the method every time you need to know.
+
+
+#### Returns
+True if the extension is supported, False otherwise.
+
+
+
+### `Function GetAttribute:Int(attr:Int, value:Int Var)`
+
+Gets the actual value for an attribute from the current context.
+
+#### Returns
+0 on success or a negative error code on failure.
+
+
+
+### `Function GetCurrentContext:TSDLGLContext()`
+
+Gets the currently active OpenGL context.
+
+#### Returns
+The currently active OpenGL context or Null on failure.
+
+
+
+### `Function GetCurrentWindow:TSDLWindow()`
+
+Gets the currently active OpenGL window.
+
+#### Returns
+The currently active OpenGL window on success or Null on failure.
+
+
+
+### `Function GetProcAddress:Byte Ptr(proc:String)`
+
+Gets an OpenGL function by name.
+
+If the GL library is loaded at runtime with GLLoadLibrary(), then all GL functions must be retrieved this way.
+Usually this is used to retrieve function pointers to OpenGL extensions.
+
+
+#### Returns
+A pointer to the named OpenGL function. The returned pointer should be cast to the appropriate function signature.
+
+
+
+### `Function LoadLibrary:Int(path:String)`
+
+Dynamically loads an OpenGL library.
+
+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.
+If you do this, you need to retrieve all of the GL functions used in your program from the dynamic library using GLGetProcAddress().
+
+
+#### Returns
+0 on success or a negative error code on failure.
+
+
+
+### `Function GetSwapInterval:Int()`
+
+Gets the swap interval for the current OpenGL context.
+
+If the system can't determine the swap interval, or there isn't a valid current context, this method will return 0 as a safe default.
+
+
+#### Returns
+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.
+
+
+
+### `Function SetSwapInterval:Int(value:Int)`
+
+Sets the swap interval for the current OpenGL context.
+
+Some systems allow specifying -1 for the interval, to enable late swap tearing. Late swap tearing works the same as vsync,
+but if you've already missed the vertical retrace for a given frame, it swaps buffers immediately, which might be less jarring for
+the user during occasional framerate drops. If application requests late swap tearing and the system does not support it, this
+method will fail and return -1. In such a case, you should probably retry the call with 1 for the interval.
+Late swap tearing is implemented for some glX drivers with GLX_EXT_swap_control_tear and for some Windows drivers with WGL_EXT_swap_control_tear.
+
+
+#### Returns
+0 on success or -1 if setting the swap interval is not supported.
+
+
+
+### `Function ResetAttributes()`
+
+Resets all previously set OpenGL context attributes to their default values.
+
+
+### `Function SetAttribute:Int(attr:Int, value:Int)`
+
+Sets an OpenGL window attribute before window creation.
+
+Sets the OpenGL attribute <b>attr</b> to <b>value</b>. The requested attributes should be set before creating an OpenGL window.
+You should use [GetAttribute](../../../sdl/sdl.sdlvideo/TSDLGLContext/#function-getattribute-int-attr-int-value-int-var)() to check the values after creating the OpenGL context, since the values obtained can differ from
+the requested ones.
+
+
+#### Returns
+0 on success or a negative error code on failure.
+
+
+
+### `Function UnloadLibrary()`
+
+Unloads the OpenGL library previously loaded by [LoadLibrary](../../../sdl/sdl.sdlvideo/TSDLGLContext/#function-loadlibrary-int-path-string)()
+
+

docs/api/sdl/sdl.sdlvideo/tsdlwindow.md

@@ -0,0 +1,410 @@
+---
+id: tsdlwindow
+title: TSDLWindow
+sidebar_label: TSDLWindow
+---
+
+
+## Methods
+
+### `Method GetDisplay:TSDLDisplay()`
+
+Gets the display associated with the window.
+
+#### Returns
+Returns the display containing the center of the window on success or Null on failure.
+
+
+
+### `Method SetDisplayMode:Int(Mode:TSDLDisplayMode)`
+
+Sets the display mode to use when the window is visible at fullscreen.
+
+This only affects the display mode used when the window is fullscreen. To change the window size when the window is not fullscreen,
+use [SetSize](../../../sdl/sdl.sdlvideo/#method-setsize-w-int-h-int)().
+
+
+#### Returns
+0 on success or a negative error code on failure.
+
+
+
+### `Method GetDisplayMode:TSDLDisplayMode()`
+
+Gets information about the display mode to use when a window is visible at fullscreen.
+
+#### Returns
+The display mode on success or Null on failure.
+
+
+
+### `Method GetPixelFormat:UInt()`
+
+Gets the pixel format associated with the window.
+
+#### Returns
+The pixel format of the window on success or SDL_PIXELFORMAT_UNKNOWN on failure.
+
+
+
+### `Method GetID:UInt()`
+
+Gets the numeric ID of the window, for logging purposes.
+
+#### Returns
+The ID of the window on success or 0 on failure.
+
+
+
+### `Method GetTitle:String()`
+
+Gets the title of the window.
+
+
+### `Method SetTitle(title:String)`
+
+Sets the title of the window.
+
+
+### `Method SetPosition(x:Int, y:Int)`
+
+Sets the position of the window.
+
+The window coordinate origin is the upper left of the display.
+
+
+
+### `Method GetPosition(x:Int Var, y:Int Var)`
+
+Gets the position of the window.
+
+
+### `Method SetSize(w:Int, h:Int)`
+
+Sets the size of the window's client area.
+
+The window size in screen coordinates may differ from the size in pixels, if the window was created with
+[SDL_WINDOW_ALLOW_HIGHDPI](../../../sdl/sdl.sdlvideo/#const-sdl-window-allow-highdpi-uint-00002000) on a platform with high-dpi support (e.g. iOS or OS X).
+Use [GLGetDrawableSize](../../../sdl/sdl.sdlvideo/#method-glgetdrawablesize-w-int-var-h-int-var)() or SDLGetRendererOutputSize() to get the real client area size in pixels.
+Fullscreen windows automatically match the size of the display mode, and you should use SetWindowDisplayMode() to change their size.
+
+
+
+### `Method GetSize(w:Int Var, h:Int Var)`
+
+Gets the size of the window's client area.
+
+The window size in screen coordinates may differ from the size in pixels, if the window was created with
+[SDL_WINDOW_ALLOW_HIGHDPI](../../../sdl/sdl.sdlvideo/#const-sdl-window-allow-highdpi-uint-00002000) on a platform with high-dpi support (e.g. iOS or OS X).
+Use [GLGetDrawableSize](../../../sdl/sdl.sdlvideo/#method-glgetdrawablesize-w-int-var-h-int-var)() or SDLGetRendererOutputSize() to get the real client area size in pixels.
+
+
+
+### `Method GetBorderSize:Int(wTop:Int Var, wLeft:Int Var, wBottom:Int Var, wRight:Int Var)`
+
+Gets the size of the window's borders (decorations) around the client area.
+
+Note: If this method fails (returns -1), the size values will be initialized to 0, 0, 0, 0, as if the window in question was borderless.
+This method also returns -1 if getting the information is not supported.
+This method is only supported on X11.
+
+
+
+### `Method SetMinimumSize(w:Int, h:Int)`
+
+Sets the minimum size of the window's client area.
+
+
+### `Method GetMinimumSize(w:Int Var, h:Int Var)`
+
+Gets the minimum size of a window's client area.
+
+
+### `Method SetMaximumSize(w:Int, h:Int)`
+
+Sets the maximum size of the window's client area.
+
+
+### `Method GetMaximumSize(w:Int Var, h:Int Var)`
+
+Gets the maximum size of the window's client area.
+
+
+### `Method SetBordered(bordered:Int)`
+
+Sets the border state of the 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.
+You can't change the border state of a fullscreen window.
+
+
+
+### `Method SetResizable(resizable:Int)`
+
+Sets the user-resizable state of the 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.
+You can't change the resizable state of a fullscreen window.
+
+
+
+### `Method Show()`
+
+Shows the window.
+
+
+### `Method Hide()`
+
+Hides the window.
+
+
+### `Method Raise()`
+
+Raises the window above other windows and sets the input focus.
+
+
+### `Method Maximize()`
+
+Makes the window as large as possible.
+
+
+### `Method Minimize()`
+
+Minimizes the window to an iconic representation.
+
+
+### `Method Restore()`
+
+Restores the size and position of a minimized or maximized window.
+
+
+### `Method SetFullScreen:Int(flags:UInt)`
+
+Sets the window's fullscreen state.
+
+<b>flags</b> may be SDL_WINDOW_FULLSCREEN, for "real" fullscreen with a videomode change; SDL_WINDOW_FULLSCREEN_DESKTOP
+for "fake" fullscreen that takes the size of the desktop; and 0 for windowed mode.
+
+
+#### Returns
+0 on success or a negative error code on failure.
+
+
+
+### `Method GetSurface:TSDLSurface()`
+
+Gets the SDL surface associated with the window.
+
+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. Do not free this surface.
+This surface will be invalidated if the window is resized. After resizing a window this method must be called again to return a valid surface.
+You may not combine this with 3D or the rendering API on this window.
+
+
+#### Returns
+The surface associated with the window, or Null on failure.
+
+
+
+### `Method UpdateSurface:Int()`
+
+Copies the window surface to the screen.
+
+This is the method you use to reflect any changes to the surface on the screen.
+
+
+#### Returns
+0 on success or a negative error code on failure.
+
+
+
+### `Method SetGrab(grabbed:Int)`
+
+Sets the window's input grab mode.
+
+When input is grabbed the mouse is confined to the window.
+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.
+
+
+
+### `Method GetGrab:Int()`
+
+Gets a window's input grab mode.
+
+#### Returns
+True if input is grabbed, False otherwise.
+
+
+
+### `Method SetBrightness:Int(brightness:Float)`
+
+Sets the brightness (gamma multiplier) for the display that owns the window.
+
+Despite the name and signature, this method sets the brightness of the entire display, not an individual window.
+A window is considered to be owned by the display that contains the window's center pixel. (The index of this display can be
+retrieved using [GetDisplay](../../../sdl/sdl.sdlvideo/#method-getdisplay-tsdldisplay)().) The brightness set will not follow the window if it is moved to another display
+
+
+#### Returns
+0 on success or a negative error code on failure.
+
+
+
+### `Method GetBrightness:Float()`
+
+Gets the brightness (gamma multiplier) for the display that owns the window.
+
+Despite the name and signature, this method sets the brightness of the entire display, not an individual window.
+A window is considered to be owned by the display that contains the window's center pixel. (The index of this display can be
+retrieved using [GetDisplay](../../../sdl/sdl.sdlvideo/#method-getdisplay-tsdldisplay)().) The brightness set will not follow the window if it is moved to another display
+
+
+#### Returns
+The brightness for the display where 0.0 is completely dark and 1.0 is normal brightness.
+
+
+
+### `Method SetOpacity:Int(opacity:Float)`
+
+Sets the opacity for the window.
+
+The parameter <b>opacity</b> will be clamped internally between 0.0f (transparent) and 1.0f (opaque).
+This method also returns -1 if setting the opacity isn't supported.
+This method is only supported on DirectFB, X11, Cocoa (Apple Mac OS X) and Microsoft Windows.
+
+
+#### Returns
+0 on success or a negative error code on failure.
+
+
+
+### `Method GetOpacity:Int(opacity:Float Var)`
+
+Gets the opacity of the window.
+
+If transparency isn't supported on this platform, opacity will be reported as 1.0f without error.
+This method also returns -1 if the window is invalid.
+This method is only supported on DirectFB, X11, Cocoa (Apple Mac OS X) and Microsoft Windows.
+
+
+#### Returns
+0 on success or a negative error code on failure.
+
+
+
+### `Method SetModalFor:Int(parent:TSDLWindow)`
+
+Sets the window as a modal for another window.
+
+This function is only supported on X11.
+
+
+#### Returns
+0 on success or a negative error code on failure.
+
+
+
+### `Method SetInputFocus:Int()`
+
+Explicitly sets input focus to the window.
+
+You almost certainly want [Raise](../../../sdl/sdl.sdlvideo/#method-raise)() instead of this function. Use this with caution, as you might give
+focus to a window that is completely obscured by other windows.
+This method is only supported on X11.
+
+
+#### Returns
+0 on success or a negative error code on failure.
+
+
+
+### `Method SetGammaRamp:Int(red:Short Ptr, green:Short Ptr, blue:Short Ptr)`
+
+Sets the gamma ramp for the display that owns a given window.
+
+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.
+Despite the name and signature, this method sets the gamma ramp of the entire display, not an individual window.
+A window is considered to be owned by the display that contains the window's center pixel. (The index of this display
+can be retrieved using [GetDisplay](../../../sdl/sdl.sdlvideo/#method-getdisplay-tsdldisplay)().) The gamma ramp set will not follow the window if it is moved to another display.
+
+
+#### Returns
+0 on success or a negative error code on failure.
+
+
+
+### `Method GetGammaRamp:Int(red:Short Ptr, green:Short Ptr, blue:Short Ptr)`
+
+Gets the gamma ramp for the display that owns the window.
+
+Despite the name and signature, this method sets the gamma ramp of the entire display, not an individual window.
+A window is considered to be owned by the display that contains the window's center pixel. (The index of this display
+can be retrieved using [GetDisplay](../../../sdl/sdl.sdlvideo/#method-getdisplay-tsdldisplay)().) The gamma ramp set will not follow the window if it is moved to another display.
+
+
+#### Returns
+0 on success or a negative error code on failure.
+
+
+
+### `Method Destroy()`
+
+Destroys the window.
+
+
+### `Method GLCreateContext:TSDLGLContext()`
+
+Creates an OpenGL context for use with an OpenGL window, and makes it current.
+
+Windows users new to OpenGL should note that, for historical reasons, GL functions added after OpenGL version 1.1 are
+not available by default. Those functions must be loaded at run-time, either with an OpenGL extension-handling
+library or with GLGetProcAddress() and its related functions.
+
+
+#### Returns
+The OpenGL context associated with window or Null on error.
+
+
+
+### `Method GLGetDrawableSize(w:Int Var, h:Int Var)`
+
+Gets the size of a window's underlying drawable in pixels (for use with glViewport).
+
+This may differ from [GetSize](../../../sdl/sdl.sdlvideo/#method-getsize-w-int-var-h-int-var)() if we're rendering to a high-DPI drawable, i.e. the window was created with
+[SDL_WINDOW_ALLOW_HIGHDPI](../../../sdl/sdl.sdlvideo/#const-sdl-window-allow-highdpi-uint-00002000) on a platform with high-DPI support (Apple calls this "Retina"), and not disabled by
+the SDL_HINT_VIDEO_HIGHDPI_DISABLED hint.
+
+
+
+### `Method GLMakeCurrent:Int(context:TSDLGLContext)`
+
+Sets up an OpenGL context for rendering into an OpenGL window.
+
+#### Returns
+0 on success or a negative error code on failure.
+
+
+
+### `Method GLSwap()`
+
+Updates a window with OpenGL rendering.
+
+This is used with double-buffered OpenGL contexts, which are the default.
+
+
+
+## Functions
+
+### `Function Create:TSDLWindow(title:String, x:Int, y:Int, w:Int, h:Int, flags:UInt)`
+
+Creates a window with the specified position, dimensions, and flags.
+
+#### Returns
+The window that was created or Null on failure.
+
+
+

docs/api/sdl/sdl.virtualjoystick/tvirtualjoystick.md

@@ -0,0 +1,17 @@
+---
+id: tvirtualjoystick
+title: TVirtualJoystick
+sidebar_label: TVirtualJoystick
+---
+
+
+Can be extended to implement your own rendering of it.
+
+
+## Methods
+
+### `Method AddButton:Int(x:Int, y:Int, radius:Int)`
+
+Adds a button at the specified location.
+
+

docs/api/sdl/sdl_d3d9sdlmax2d.md

@@ -0,0 +1,22 @@
+---
+id: sdl.d3d9sdlmax2d
+title: SDL.D3D9SDLMax2D
+sidebar_label: SDL.D3D9SDLMax2D
+---
+
+
+
+The Direct3D9 Max2D module provides a Direct3D9 driver for Max2D.
+
+
+## Functions
+
+### `Function D3D9SDLMax2DDriver:TD3D9SDLMax2DDriver()`
+
+Get Direct3D9 SDL Max2D Driver
+
+
+The returned driver can be used with [SetGraphicsDriver](../../brl/brl.graphics/#function-setgraphicsdriver-driver-tgraphicsdriver-defaultflags-graphics-backbuffer) to enable Direct3D9 Max2D rendering.
+
+
+

docs/api/sdl/sdl_gl2sdlmax2d.md

@@ -0,0 +1,23 @@
+---
+id: sdl.gl2sdlmax2d
+title: SDL.GL2SDLMax2D
+sidebar_label: SDL.GL2SDLMax2D
+---
+
+
+
+The OpenGL Max2D module provides an OpenGL 2+ driver for Max2D with shader support.
+Legacy fixed functionality is included for testing purposes if GLMAX2D_USE_LEGACY = True.
+
+
+## Functions
+
+### `Function GL2Max2DDriver:TGL2Max2DDriver()`
+
+Get OpenGL Max2D Driver
+
+
+The returned driver can be used with [SetGraphicsDriver](../../brl/brl.graphics/#function-setgraphicsdriver-driver-tgraphicsdriver-defaultflags-graphics-backbuffer) to enable OpenGL Max2D rendering.
+
+
+

docs/api/sdl/sdl_glsdlmax2d.md

@@ -0,0 +1,23 @@
+---
+id: sdl.glsdlmax2d
+title: SDL.GLSDLMax2D
+sidebar_label: SDL.GLSDLMax2D
+---
+
+
+
+The OpenGL Max2D module provides an SDL-backend OpenGL driver for Max2D.
+
+
+## Functions
+
+### `Function GLMax2DDriver:TGLMax2DDriver()`
+
+Get OpenGL Max2D Driver
+
+
+The returned driver can be used with [SetGraphicsDriver](../../brl/brl.graphics/#function-setgraphicsdriver-driver-tgraphicsdriver-defaultflags-graphics-backbuffer) to enable OpenGL Max2D
+rendering.
+
+
+

docs/api/sdl/sdl_sdl.md

@@ -0,0 +1,397 @@
+---
+id: sdl.sdl
+title: SDL.SDL
+sidebar_label: SDL.SDL
+---
+
+
+Simple DirectMedia Layer is a cross-platform development library designed to provide low level access to audio,
+keyboard, mouse, joystick, and graphics hardware via OpenGL and Direct3D.
+
+SDL is a wrapper around operating-system-specific functions that a game needs to access.
+
+It provides a common framework for accessing these functions for multiple operating systems (cross-platform).  SDL provides support for 2D pixel operations,
+sound, file access, event handling, timing and threading. It is often used to complement OpenGL by setting up the graphical output an
+providing mouse and keyboard input, since OpenGL comprises only rendering.
+
+
+
+## Types
+| Type | Description |
+|---|---|
+| [TSDLStream](../../sdl/sdl.sdl/tsdlstream) | An SDL-based data stream type. |
+
+## Functions
+
+### `Function OpenSDLStream:TSDLStream( file:String, readable:Int, writeable:Int )`
+
+Opens an SDL stream for reading/writing.
+
+#### Returns
+A stream object.
+
+
+
+### `Function SDLGetBasePath:String()`
+
+Get the directory where the application was run from.
+
+This is where the application data directory is.
+This is not necessarily a fast call, though, so you should call this once near startup and save the string if you need it.<br/>
+Mac OS X and iOS Specific Functionality: If the application is in a ".app" bundle, this function returns the Resource directory
+(e.g. MyApp.app/Contents/Resources/). This behaviour can be overridden by adding a property to the Info.plist file. Adding a string key with
+the name SDL_FILESYSTEM_BASE_DIR_TYPE with a supported value will change the behaviour.
+
+
+
+### `Function SDLGetPrefPath:String(org:String, app:String)`
+
+Returns the preferences dir.
+
+This is meant to be where the application can write personal files (Preferences and save games, etc.) that are specific to the application.
+This directory is unique per user and per application. The path will be Null if there is a problem (creating directory failed, etc.)<br/>
+The return path will be guaranteed to end with a path separator ('\' on Windows, '/' on most other platforms).
+You should assume the path returned by this function is the only safe place to write files (and that GetBasePath(), while it might be writable, or even
+the parent of the returned path, aren't where you should be writing things).<br/>
+Both the org and app strings may become part of a directory name, so please follow these rules:<br/>
+* Try to use the same org string (including case-sensitivity) for all your applications that use this function.<br/>
+* Always use a unique app string for each one, and make sure it never changes for an app once you've decided on it.<br/>
+* Only use letters, numbers, and spaces. Avoid punctuation like "Game Name 2: Bad Guy's Revenge!" ... "Game Name 2" is sufficient.
+
+
+
+### `Function SDLAndroidGetExternalStoragePath:String()`
+
+Gets the path used for external storage for this application.
+
+This path is unique to your application, but is public and can be written to by other applications.
+Your external storage path is typically: /storage/sdcard0/Android/data/your.app.package/files.
+
+
+#### Returns
+The path used for external storage for this application on success or NULL on failure; call [SDLGetError](../../sdl/sdl.sdl/#function-sdlgeterror-string)() for more information.
+
+
+
+### `Function SDLAndroidGetExternalStorageState:Int()`
+
+Gets the current state of external storage.
+
+The current state of external storage, a bitmask of these values: SDL_ANDROID_EXTERNAL_STORAGE_READ, SDL_ANDROID_EXTERNAL_STORAGE_WRITE.
+If external storage is currently unavailable, this will return 0.
+
+
+
+### `Function SDLAndroidGetInternalStoragePath:String()`
+
+Gets the path used for internal storage for this application.
+
+This path is unique to your application and cannot be written to by other applications.
+Your internal storage path is typically: /data/data/your.app.package/files.
+
+
+#### Returns
+The path used for internal storage or NULL on failure; call [SDLGetError](../../sdl/sdl.sdl/#function-sdlgeterror-string)() for more information.
+
+
+
+### `Function SDLHasClipboardText:Int()`
+
+Return a flag indicating whether the clipboard exists and contains a text string that is non-empty.
+
+
+### `Function SDLGetClipboardText:String()`
+
+Returns the clipboard text.
+
+
+### `Function SDLSetClipboardText:Int(Text:String)`
+
+Puts text into the clipboard.
+
+#### Returns
+0 on success or a negative error code on failure.
+
+
+
+### `Function SDLLogAppInfo(Text:String)`
+
+Logs a message with [SDL_LOG_CATEGORY_APPLICATION](../../sdl/sdl.sdl/#const-sdl-log-category-application-int-0) and [SDL_LOG_PRIORITY_INFO](../../sdl/sdl.sdl/#const-sdl-log-priority-info-int-3).
+
+
+### `Function SDLLogDebug(category:Int, Text:String)`
+
+Logs a message with [SDL_LOG_PRIORITY_DEBUG](../../sdl/sdl.sdl/#const-sdl-log-priority-debug-int-2).
+
+
+### `Function SDLLogError(category:Int, Text:String)`
+
+Logs a message with [SDL_LOG_PRIORITY_ERROR](../../sdl/sdl.sdl/#const-sdl-log-priority-error-int-5).
+
+
+### `Function SDLLogCritical(category:Int, Text:String)`
+
+Logs a message with [SDL_LOG_PRIORITY_CRITICAL](../../sdl/sdl.sdl/#const-sdl-log-priority-critical-int-6).
+
+
+### `Function SDLLogInfo(category:Int, Text:String)`
+
+Logs a message with [SDL_LOG_PRIORITY_INFO](../../sdl/sdl.sdl/#const-sdl-log-priority-info-int-3).
+
+
+### `Function SDLLogVerbose(category:Int, Text:String)`
+
+Logs a message with [SDL_LOG_PRIORITY_VERBOSE](../../sdl/sdl.sdl/#const-sdl-log-priority-verbose-int-1).
+
+
+### `Function SDLLogWarn(category:Int, Text:String)`
+
+Logs a message with [SDL_LOG_PRIORITY_WARN](../../sdl/sdl.sdl/#const-sdl-log-priority-warn-int-4).
+
+
+### `Function SDLLogSetAllPriority(priority:Int)`
+
+Sets the priority of all log categories.
+
+If you are debugging SDL, you might want to call this with [SDL_LOG_PRIORITY_WARN](../../sdl/sdl.sdl/#const-sdl-log-priority-warn-int-4).
+
+
+
+### `Function SDLGetPowerInfo:Int(seconds:Int Var, percent:Int Var)`
+
+Gets the current power supply details.
+
+You should never take a battery status as absolute truth. Batteries (especially failing batteries) are delicate hardware,
+and the values reported here are best estimates based on what that hardware reports. It's not uncommon for older batteries to lose
+stored power much faster than it reports, or completely drain when reporting it has 20 percent left, etc.
+Battery status can change at any time; if you are concerned with power state, you should call this function frequently,
+and perhaps ignore changes until they seem to be stable for a few seconds.
+
+
+#### Returns
+One of [SDL_POWERSTATE_UNKNOWN](../../sdl/sdl.sdl/#const-sdl-powerstate-unknown-int-0), [SDL_POWERSTATE_ON_BATTERY](../../sdl/sdl.sdl/#const-sdl-powerstate-on-battery-int-1), [SDL_POWERSTATE_NO_BATTERY](../../sdl/sdl.sdl/#const-sdl-powerstate-no-battery-int-2), [SDL_POWERSTATE_CHARGING](../../sdl/sdl.sdl/#const-sdl-powerstate-charging-int-3), or [SDL_POWERSTATE_CHARGED](../../sdl/sdl.sdl/#const-sdl-powerstate-charged-int-4).
+
+
+
+### `Function SDLGetPixelFormatName:String(format:UInt)`
+
+Gets the human readable name of a pixel format
+
+
+### `Function SDLGetTicks:UInt()`
+
+Gets the number of milliseconds since the SDL library initialization.
+
+This value wraps if the program runs for more than 49 days.
+
+
+#### Returns
+A value representing the number of milliseconds since the SDL library initialized.
+
+
+
+### `Function SDLGetError:String()`
+
+Retrieves a message about the last error that occurred.
+
+#### Returns
+A message with information about the specific error that occurred, or an empty string if there hasn't been an error message set since the last call to [SDLClearError](../../sdl/sdl.sdl/#function-sdlclearerror)(). The message is only applicable when an SDL function has signaled an error. You must check the return values of SDL function calls to determine when to appropriately call [SDLGetError](../../sdl/sdl.sdl/#function-sdlgeterror-string)().
+
+
+
+### `Function SDLClearError()`
+
+Clears any previous error message.
+
+
+## Consts
+
+### `Const SDL_APP_TERMINATING:Int         = $101`
+
+The application is being terminated by the OS.
+
+Called on iOS in applicationWillTerminate().
+Called on Android in onDestroy()
+
+
+
+### `Const SDL_APP_LOWMEMORY:Int           = $102`
+
+The application is low on memory, free memory if possible.
+
+Called on iOS in applicationDidReceiveMemoryWarning().
+Called on Android in onLowMemory()
+
+
+
+### `Const SDL_APP_WILLENTERBACKGROUND:Int = $103`
+
+The application is about to enter the background.
+
+Called on iOS in applicationWillResignActive().
+Called on Android in onPause()
+
+
+
+### `Const SDL_APP_DIDENTERBACKGROUND:Int  = $104`
+
+The application did enter the background and may not get CPU for some time.
+
+Called on iOS in applicationDidEnterBackground().
+Called on Android in onPause()
+
+
+
+### `Const SDL_APP_WILLENTERFOREGROUND:Int = $105`
+
+The application is about to enter the foreground.
+
+Called on iOS in applicationWillEnterForeground().
+Called on Android in onResume()
+
+
+
+### `Const SDL_APP_DIDENTERFOREGROUND:Int  = $106`
+
+The application is now interactive.
+
+Called on iOS in applicationDidBecomeActive().
+Called on Android in onResume()
+
+
+
+### `Const SDL_LOG_CATEGORY_APPLICATION:Int = 0`
+
+Application log category.
+
+Has a default log priority of SDL_LOG_PRIORITY_INFO.
+
+
+
+### `Const SDL_LOG_CATEGORY_ERROR:Int = 1`
+
+Error log category.
+
+Has a default log priority of SDL_LOG_PRIORITY_CRITICAL.
+
+
+
+### `Const SDL_LOG_CATEGORY_ASSERT:Int = 2`
+
+Assertion log category.
+
+Has a default log priority of SDL_LOG_PRIORITY_WARN.
+
+
+
+### `Const SDL_LOG_CATEGORY_SYSTEM:Int = 3`
+
+System log category.
+
+Has a default log priority of SDL_LOG_PRIORITY_CRITICAL.
+
+
+
+### `Const SDL_LOG_CATEGORY_AUDIO:Int = 4`
+
+Audio log category.
+
+Has a default log priority of SDL_LOG_PRIORITY_CRITICAL.
+
+
+
+### `Const SDL_LOG_CATEGORY_VIDEO:Int = 5`
+
+Video log category.
+
+Has a default log priority of SDL_LOG_PRIORITY_CRITICAL.
+
+
+
+### `Const SDL_LOG_CATEGORY_RENDER:Int = 6`
+
+Render log category.
+
+Has a default log priority of SDL_LOG_PRIORITY_CRITICAL.
+
+
+
+### `Const SDL_LOG_CATEGORY_INPUT:Int = 7`
+
+Input log category.
+
+Has a default log priority of SDL_LOG_PRIORITY_CRITICAL.
+
+
+
+### `Const SDL_LOG_CATEGORY_TEST:Int = 8`
+
+Test log category.
+
+Has a default log priority of SDL_LOG_PRIORITY_VERBOSE.
+
+
+
+### `Const SDL_LOG_CATEGORY_CUSTOM:Int = 19`
+
+Application defined starting category.
+
+An application can use subsequent category numbers as required, e.g. SDL_LOG_CATEGORY_CUSTOM + 1, etc.
+
+
+
+### `Const SDL_LOG_PRIORITY_VERBOSE:Int = 1`
+
+Verbose log priority.
+
+
+### `Const SDL_LOG_PRIORITY_DEBUG:Int = 2`
+
+Debug log priority.
+
+
+### `Const SDL_LOG_PRIORITY_INFO:Int = 3`
+
+Info log priority.
+
+
+### `Const SDL_LOG_PRIORITY_WARN:Int = 4`
+
+Warn log priority.
+
+
+### `Const SDL_LOG_PRIORITY_ERROR:Int = 5`
+
+Error log priority.
+
+
+### `Const SDL_LOG_PRIORITY_CRITICAL:Int = 6`
+
+Critical log priority.
+
+
+### `Const SDL_POWERSTATE_UNKNOWN:Int = 0`
+
+Cannot determine power status
+
+
+### `Const SDL_POWERSTATE_ON_BATTERY:Int = 1`
+
+Not plugged in, running on the battery
+
+
+### `Const SDL_POWERSTATE_NO_BATTERY:Int = 2`
+
+Plugged in, no battery available
+
+
+### `Const SDL_POWERSTATE_CHARGING:Int = 3`
+
+Plugged in, charging battery
+
+
+### `Const SDL_POWERSTATE_CHARGED:Int = 4`
+
+Plugged in, battery charged
+
+

docs/api/sdl/sdl_sdlfreeaudio.md

@@ -0,0 +1,7 @@
+---
+id: sdl.sdlfreeaudio
+title: SDL.SDLFreeAudio
+sidebar_label: SDL.SDLFreeAudio
+---
+
+

docs/api/sdl/sdl_sdlhaptic.md

@@ -0,0 +1,158 @@
+---
+id: sdl.sdlhaptic
+title: SDL.SDLHaptic
+sidebar_label: SDL.SDLHaptic
+---
+
+
+## Types
+| Type | Description |
+|---|---|
+| [TSDLHaptic](../../sdl/sdl.sdlhaptic/tsdlhaptic) | A haptic device. |
+| [TSDLHapticDirection](../../sdl/sdl.sdlhaptic/tsdlhapticdirection) | The direction where the force comes from, instead of the direction in which the force is exerted. |
+| [TSDLHapticEffect](../../sdl/sdl.sdlhaptic/tsdlhapticeffect) | A generic template for any haptic effect. |
+| [TSDLHapticConstant](../../sdl/sdl.sdlhaptic/tsdlhapticconstant) | A constant effect applies a constant force to the joystick in the specified direction. |
+| [TSDLHapticPeriodic](../../sdl/sdl.sdlhaptic/tsdlhapticperiodic) | A wave-shaped effect that repeats itself over time. |
+| [TSDLHapticCondition](../../sdl/sdl.sdlhaptic/tsdlhapticcondition) | A template for a condition effect. |
+| [TSDLHapticRamp](../../sdl/sdl.sdlhaptic/tsdlhapticramp) | A template for a ramp effect. |
+| [TSDLHapticLeftRight](../../sdl/sdl.sdlhaptic/tsdlhapticleftright) | Controls the large and small motors, commonly found in modern game controllers. |
+| [TSDLHapticCustom](../../sdl/sdl.sdlhaptic/tsdlhapticcustom) | A custom force feedback effect. |
+
+## Consts
+
+### `Const SDL_HAPTIC_INFINITY:UInt = 4294967295:UInt`
+
+Used to play a device an infinite number of times.
+
+
+### `Const SDL_HAPTIC_POLAR:Int = 0`
+
+Uses polar coordinates for the direction.
+
+
+### `Const SDL_HAPTIC_CARTESIAN:Int = 1`
+
+Uses cartesian coordinates for the direction.
+
+
+### `Const SDL_HAPTIC_SPHERICAL:Int = 2`
+
+Uses spherical coordinates for the direction.
+
+
+### `Const SDL_HAPTIC_CONSTANT:Int = 1 Shl 0`
+
+Constant effect supported.
+
+Constant haptic effect.
+
+
+
+### `Const SDL_HAPTIC_SINE:Int = 1 Shl 1`
+
+Sine wave effect supported.
+
+Periodic haptic effect that simulates sine waves.
+
+
+
+### `Const SDL_HAPTIC_LEFTRIGHT:Int = 1 Shl 2`
+
+Left/Right effect supported.
+
+Haptic effect for direct control over high/low frequency motors.
+
+
+
+### `Const SDL_HAPTIC_TRIANGLE:Int = 1 Shl 3`
+
+Triangle wave effect supported.
+
+Periodic haptic effect that simulates triangular waves.
+
+
+
+### `Const SDL_HAPTIC_SAWTOOTHUP:Int = 1 Shl 4`
+
+Sawtoothup wave effect supported.
+
+Periodic haptic effect that simulates saw tooth up waves.
+
+
+
+### `Const SDL_HAPTIC_SAWTOOTHDOWN:Int = 1 Shl 5`
+
+Sawtoothdown wave effect supported.
+
+Periodic haptic effect that simulates saw tooth down waves.
+
+
+
+### `Const SDL_HAPTIC_RAMP:Int = 1 Shl 6`
+
+Ramp effect supported.
+
+Ramp haptic effect.
+
+
+
+### `Const SDL_HAPTIC_SPRING:Int = 1 Shl 7`
+
+Spring effect supported - uses axes position.
+
+Condition haptic effect that simulates a spring. Effect is based on the axes position.
+
+
+
+### `Const SDL_HAPTIC_DAMPER:Int = 1 Shl 8`
+
+Damper effect supported - uses axes velocity.
+
+Condition haptic effect that simulates dampening. Effect is based on the axes velocity.
+
+
+
+### `Const SDL_HAPTIC_INERTIA:Int = 1 Shl 9`
+
+Inertia effect supported - uses axes acceleration.
+
+Condition haptic effect that simulates inertia. Effect is based on the axes acceleration.
+
+
+
+### `Const SDL_HAPTIC_FRICTION:Int = 1 Shl 10`
+
+Friction effect supported - uses axes movement.
+
+Condition haptic effect that simulates friction. Effect is based on the axes movement.
+
+
+
+### `Const SDL_HAPTIC_CUSTOM:Int = 1 Shl 11`
+
+Custom effect is supported.
+
+User defined custom haptic effect.
+
+
+
+### `Const SDL_HAPTIC_GAIN:Int = 1 Shl 12`
+
+Device supports setting the global gain.
+
+
+### `Const SDL_HAPTIC_AUTOCENTER:Int = 1 Shl 13`
+
+Device supports setting autocenter.
+
+
+### `Const SDL_HAPTIC_STATUS:Int = 1 Shl 14`
+
+Device supports querying effect status.
+
+
+### `Const SDL_HAPTIC_PAUSE:Int = 1 Shl 15`
+
+Devices supports being paused.
+
+

docs/api/sdl/sdl_sdlrender.md

@@ -0,0 +1,90 @@
+---
+id: sdl.sdlrender
+title: SDL.SDLRender
+sidebar_label: SDL.SDLRender
+---
+
+
+SDLRender contains functions for 2D accelerated rendering.
+
+This API supports the following features:
+
+* single pixel points
+* single pixel lines
+* filled rectangles
+* texture images
+All of these may be drawn in opaque, blended, or additive modes.
+
+The texture images can have an additional color tint or alpha modulation applied to them, and may also be stretched with linear interpolation, rotated or flipped/mirrored.
+
+For advanced functionality like particle effects or actual 3D you should use SDL's OpenGL/Direct3D support or one of the many available 3D engines.
+
+> This API is not designed to be used from multiple threads.
+
+
+
+## Types
+| Type | Description |
+|---|---|
+| [TSDLRenderer](../../sdl/sdl.sdlrender/tsdlrenderer) | A 2D rendering context. |
+| [TSDLTexture](../../sdl/sdl.sdlrender/tsdltexture) | An efficient driver-specific representation of pixel data. |
+
+## Functions
+
+### `Function SDLGetNumRenderDrivers:Int()`
+
+Gets the number of 2D rendering drivers available for the current display.
+
+
+## Consts
+
+### `Const SDL_TEXTUREACCESS_STATIC:Int = 0`
+
+changes rarely, not lockable
+
+
+### `Const SDL_TEXTUREACCESS_STREAMING:Int = 1`
+
+changes frequently, lockable
+
+
+### `Const SDL_TEXTUREACCESS_TARGET:Int = 2`
+
+can be used as a render target
+
+
+### `Const SDL_FLIP_NONE:Int = 0`
+
+do not flip
+
+
+### `Const SDL_FLIP_HORIZONTAL:Int = 1`
+
+flip horizontally
+
+
+### `Const SDL_FLIP_VERTICAL:Int = 2`
+
+flip vertically
+
+
+### `Const SDL_RENDERER_SOFTWARE:Int = $01`
+
+the renderer is a software fallback
+
+
+### `Const SDL_RENDERER_ACCELERATED:Int = $02`
+
+the renderer uses hardware acceleration
+
+
+### `Const SDL_RENDERER_PRESENTVSYNC:Int = $04`
+
+present is synchronized with the refresh rate
+
+
+### `Const SDL_RENDERER_TARGETTEXTURE:Int = $08`
+
+the renderer supports rendering to texture
+
+

docs/api/sdl/sdl_sdlsensor.md

@@ -0,0 +1,12 @@
+---
+id: sdl.sdlsensor
+title: SDL.SDLSensor
+sidebar_label: SDL.SDLSensor
+---
+
+
+## Types
+| Type | Description |
+|---|---|
+| [TSDLSensor](../../sdl/sdl.sdlsensor/tsdlsensor) | A Sensor |
+

docs/api/sdl/sdl_sdlsystem.md

@@ -0,0 +1,12 @@
+---
+id: sdl.sdlsystem
+title: SDL.SDLSystem
+sidebar_label: SDL.SDLSystem
+---
+
+
+## Types
+| Type | Description |
+|---|---|
+| [TSDLMultiGesture](../../sdl/sdl.sdlsystem/tsdlmultigesture) | Information about multiple finger gestures. |
+

docs/api/sdl/sdl_sdltimer.md

@@ -0,0 +1,7 @@
+---
+id: sdl.sdltimer
+title: SDL.SDLTimer
+sidebar_label: SDL.SDLTimer
+---
+
+

docs/api/sdl/sdl_sdlvideo.md

@@ -0,0 +1,317 @@
+---
+id: sdl.sdlvideo
+title: SDL.SDLVideo
+sidebar_label: SDL.SDLVideo
+---
+
+
+## Types
+| Type | Description |
+|---|---|
+| [TSDLWindow](../../sdl/sdl.sdlvideo/tsdlwindow) | An SDL Window. |
+| [TSDLGLContext](../../sdl/sdl.sdlvideo/tsdlglcontext) | An Open GL context. |
+| [TSDLDisplay](../../sdl/sdl.sdlvideo/tsdldisplay) | Represents an indexed video display. |
+| [TSDLDisplayMode](../../sdl/sdl.sdlvideo/tsdldisplaymode) | The description of a display mode. |
+
+## Functions
+
+### `Function SDLGetVideoDrivers:String[]()`
+
+Returns the list of built-in video drivers.
+
+The video drivers are presented in the order in which they are normally checked during initialization.
+
+
+
+### `Function SDLVideoInit:Int(driver:String)`
+
+Initializes the video subsystem, optionally specifying a video driver.
+
+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.
+
+
+
+### `Function SDLVideoQuit()`
+
+Shuts down the video subsystem.
+
+Closes all windows, and restores the original video mode.
+
+
+
+### `Function SDLGetCurrentVideoDriver:String()`
+
+Gets the name of the currently initialized video driver.
+
+#### Returns
+The name of the current video driver or NULL if no driver has been initialized.
+
+
+
+### `Function SDLGetNumVideoDisplays:Int()`
+
+Gets the number of available video displays.
+
+#### Returns
+A number >= 1 or a negative error code on failure. Call [SDLGetError](../../sdl/sdl.sdl/#function-sdlgeterror-string)() for more information.
+
+
+
+### `Function SDLGetGrabbedWindow:TSDLWindow()`
+
+Gets the window that currently has an input grab enabled.
+
+#### Returns
+The window if input is grabbed, and Null otherwise.
+
+
+
+### `Function SDLIsScreenSaverEnabled:Int()`
+
+Returns whether the screensaver is currently enabled (Default off).
+
+The screensaver is disabled by default since SDL 2.0.2. Before SDL 2.0.2 the screensaver was enabled by default.
+
+
+
+### `Function SDLEnableScreenSaver()`
+
+Allows the screen to be blanked by a screensaver.
+
+
+### `Function SDLDisableScreenSaver()`
+
+Prevents the screen from being blanked by a screensaver.
+
+If you disable the screensaver, it is automatically re-enabled when SDL quits.
+
+
+
+## Consts
+
+### `Const SDL_WINDOW_FULLSCREEN:UInt = $00000001`
+
+fullscreen window
+
+
+### `Const SDL_WINDOW_OPENGL:UInt = $00000002`
+
+window usable with OpenGL context
+
+
+### `Const SDL_WINDOW_SHOWN:UInt = $00000004`
+
+window is visible
+
+
+### `Const SDL_WINDOW_HIDDEN:UInt = $00000008`
+
+window is not visible
+
+
+### `Const SDL_WINDOW_BORDERLESS:UInt = $00000010`
+
+no window decoration
+
+
+### `Const SDL_WINDOW_RESIZABLE:UInt = $00000020`
+
+window can be resized
+
+
+### `Const SDL_WINDOW_MINIMIZED:UInt = $00000040`
+
+window is minimized
+
+
+### `Const SDL_WINDOW_MAXIMIZED:UInt = $00000080`
+
+window is maximized
+
+
+### `Const SDL_WINDOW_INPUT_GRABBED:UInt = $00000100`
+
+window has grabbed input focus
+
+
+### `Const SDL_WINDOW_INPUT_FOCUS:UInt = $00000200`
+
+window has input focus
+
+
+### `Const SDL_WINDOW_MOUSE_FOCUS:UInt = $00000400`
+
+window has mouse focus
+
+
+### `Const SDL_WINDOW_FULLSCREEN_DESKTOP:UInt = SDL_WINDOW_FULLSCREEN | $00001000`
+
+full screen desktop
+
+
+### `Const SDL_WINDOW_FOREIGN:UInt = $00000800`
+
+window not created by SDL
+
+
+### `Const SDL_WINDOW_ALLOW_HIGHDPI:UInt = $00002000`
+
+window should be created in high-DPI mode if supported
+
+
+### `Const SDL_WINDOW_MOUSE_CAPTURE:UInt = $00004000`
+
+window has mouse captured (unrelated to INPUT_GRABBED)
+
+
+### `Const SDL_WINDOW_ALWAYS_ON_TOP:UInt = $00008000`
+
+window should always be above others
+
+
+### `Const SDL_WINDOW_SKIP_TASKBAR:UInt = $00010000`
+
+window should not be added to the taskbar
+
+
+### `Const SDL_WINDOW_UTILITY:UInt = $00020000`
+
+window should be treated as a utility window
+
+
+### `Const SDL_WINDOW_TOOLTIP:UInt = $00040000`
+
+window should be treated as a tooltip
+
+
+### `Const SDL_WINDOW_POPUP_MENU:UInt = $00080000`
+
+window should be treated as a popup menu
+
+
+### `Const SDL_WINDOW_VULKAN:UInt = $10000000`
+
+window usable for Vulkan surface
+
+
+### `Const SDL_GL_RED_SIZE:Int = 0`
+
+the minimum number of bits for the red channel of the color buffer; defaults to 3
+
+
+### `Const SDL_GL_GREEN_SIZE:Int = 1`
+
+the minimum number of bits for the green channel of the color buffer; defaults to 3
+
+
+### `Const SDL_GL_BLUE_SIZE:Int = 2`
+
+the minimum number of bits for the blue channel of the color buffer; defaults to 2
+
+
+### `Const SDL_GL_ALPHA_SIZE:Int = 3`
+
+the minimum number of bits for the alpha channel of the color buffer; defaults to 0
+
+
+### `Const SDL_GL_BUFFER_SIZE:Int = 4`
+
+the minimum number of bits for frame buffer size; defaults to 0
+
+
+### `Const SDL_GL_DOUBLEBUFFER:Int = 5`
+
+whether the output is single or double buffered; defaults to double buffering on
+
+
+### `Const SDL_GL_DEPTH_SIZE:Int = 6`
+
+the minimum number of bits in the depth buffer; defaults to 16
+
+
+### `Const SDL_GL_STENCIL_SIZE:Int = 7`
+
+the minimum number of bits in the stencil buffer; defaults to 0
+
+
+### `Const SDL_GL_ACCUM_RED_SIZE:Int = 8`
+
+the minimum number of bits for the red channel of the accumulation buffer; defaults to 0
+
+
+### `Const SDL_GL_ACCUM_GREEN_SIZE:Int = 9`
+
+the minimum number of bits for the green channel of the accumulation buffer; defaults to 0
+
+
+### `Const SDL_GL_ACCUM_BLUE_SIZE:Int = 10`
+
+the minimum number of bits for the blue channel of the accumulation buffer; defaults to 0
+
+
+### `Const SDL_GL_ACCUM_ALPHA_SIZE:Int = 11`
+
+the minimum number of bits for the alpha channel of the accumulation buffer; defaults to 0
+
+
+### `Const SDL_GL_STEREO:Int = 12`
+
+whether the output is stereo 3D; defaults to off
+
+
+### `Const SDL_GL_MULTISAMPLEBUFFERS:Int = 13`
+
+the number of buffers used for multisample anti-aliasing; defaults to 0; see Remarks for details
+
+
+### `Const SDL_GL_MULTISAMPLESAMPLES:Int = 14`
+
+the number of samples used around the current pixel used for multisample anti-aliasing; defaults to 0; see Remarks for details
+
+
+### `Const SDL_GL_ACCELERATED_VISUAL:Int = 15`
+
+set to 1 to require hardware acceleration, set to 0 to force software rendering; defaults to allow either
+
+
+### `Const SDL_GL_RETAINED_BACKING:Int = 16`
+
+not used (deprecated)
+
+
+### `Const SDL_GL_CONTEXT_MAJOR_VERSION:Int = 17`
+
+OpenGL context major version; see Remarks for details
+
+
+### `Const SDL_GL_CONTEXT_MINOR_VERSION:Int = 18`
+
+OpenGL context minor version; see Remarks for details
+
+
+### `Const SDL_GL_CONTEXT_FLAGS:Int = 19`
+
+some combination of 0 or more of elements of the SDL_GLcontextFlag enumeration; defaults to 0
+
+
+### `Const SDL_GL_CONTEXT_PROFILE_MASK:Int = 20`
+
+type of GL context (Core, Compatibility, ES). See SDL_GLprofile; default value depends on platform
+
+
+### `Const SDL_GL_SHARE_WITH_CURRENT_CONTEXT:Int = 21`
+
+OpenGL context sharing; defaults to 0
+
+
+### `Const SDL_GL_FRAMEBUFFER_SRGB_CAPABLE:Int = 22`
+
+requests sRGB capable visual; defaults to 0
+
+
+### `Const SDL_GL_CONTEXT_RELEASE_BEHAVIOR:Int = 23`
+
+sets context the release behavior; defaults to 1
+
+

docs/api/sdl/sdl_virtualjoystick.md

@@ -0,0 +1,12 @@
+---
+id: sdl.virtualjoystick
+title: SDL.VirtualJoystick
+sidebar_label: SDL.VirtualJoystick
+---
+
+
+## Types
+| Type | Description |
+|---|---|
+| [TVirtualJoystick](../../sdl/sdl.virtualjoystick/tvirtualjoystick) | A virtual touch joystick. |
+

website/sidebars.json

@@ -158,6 +158,20 @@
       "api/pub/pub.opengles",
       "api/pub/pub.xmmintrin",
       "api/pub/pub.zlib"
+    ],
+    "SDL": [
+      "api/sdl/sdl.sdl",
+      "api/sdl/sdl.sdlsystem",
+      "api/sdl/sdl.sdlvideo",
+      "api/sdl/sdl.sdlrender",
+      "api/sdl/sdl.sdltimer",
+      "api/sdl/sdl.sdlhaptic",
+      "api/sdl/sdl.sdlsensor",
+      "api/sdl/sdl.sdlfreeaudio",
+      "api/sdl/sdl.sdlglsdlmax2d",
+      "api/sdl/sdl.sdlgl2sdlmax2d",
+      "api/sdl/sdl.sdld3d9sdlmax2d",
+      "api/sdl/sdl.sdlvirtualjoystick"
     ]
   },
   "brl_audio": {
@@ -165,5 +179,41 @@
       "api/brl/brl.audio/tchannel",
       "api/brl/brl.audio/tsound"
     ]
+  },
+  "brl_stream": {
+    "BRL.Stream": [
+      "api/brl/brl.stream/tcstream",
+      "api/brl/brl.stream/tio",
+      "api/brl/brl.stream/tstream",
+      "api/brl/brl.stream/tstreamexception",
+      "api/brl/brl.stream/tstreamfactory",
+      "api/brl/brl.stream/tstreamreadexception",
+      "api/brl/brl.stream/tstreamwrapper",
+      "api/brl/brl.stream/tstreamwriteexception"
+    ]
+  },
+  "sdl_sdl": {
+    "SDL.SDL": [
+      "api/sdl/sdl.sdl/tsdlstream"
+    ]
+  },
+  "sdl_sdlhaptic": {
+    "SDL.SDLHaptic": [
+      "api/sdl/sdl.sdlhaptic/tsdlhaptic",
+      "api/sdl/sdl.sdlhaptic/tsdlhapticcondition",
+      "api/sdl/sdl.sdlhaptic/tsdlhapticconstant",
+      "api/sdl/sdl.sdlhaptic/tsdlhapticcustom",
+      "api/sdl/sdl.sdlhaptic/tsdlhapticdirection",
+      "api/sdl/sdl.sdlhaptic/tsdlhapticreflect",
+      "api/sdl/sdl.sdlhaptic/tsdlhapticleftright",
+      "api/sdl/sdl.sdlhaptic/tsdlhapticperiodic",
+      "api/sdl/sdl.sdlhaptic/tsdlhapticramp"
+    ]
+  },
+  "sdl_sdlrender": {
+    "SDL.SDLRender": [
+      "api/sdl/sdl.sdlrender/tsdlrenderer",
+      "api/sdl/sdl.sdlrender/tsdltexture"
+    ]
   }
 }