jyapayne/Nim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

tests: Trim .nim files trailing whitespace

Browse source 
via OSX: find . -name '*.nim' -exec sed -i '' -E 's/[[:space:]]+$//' {} +
This commit is contained in:
Adam Strzelecki 2015-09-04 23:04:32 +02:00
commit e80465dacf
372 changed files with 4486 additions and 4486 deletions
Download patch file Download diff file Expand all files Collapse all files

10
tests/manyloc/keineschweine/lib/client_helpers.nim
View file

@ -1,4 +1,4 @@
import
import
tables, sg_packets, enet, estreams, sg_gui, sfml,
zlib_helpers, md5, sg_assets, os
type
@ -17,7 +17,7 @@ type
pos: int32
data: string
readyToSave: bool
var
var
currentFileTransfer: TFileTransfer
downloadProgress* = newButton(nil, "", vec2f(0,0), nil)
currentFileTransfer.data = ""
@ -73,7 +73,7 @@ proc handleFilePartRecv*(serv: PServer; buffer: PBuffer) {.procvar.} =
var
f = readScFileTransfer(buffer)
updateFileProgress()
if not(f.pos == currentFileTransfer.pos):
if not(f.pos == currentFileTransfer.pos):
echo "returning early from filepartrecv"
return ##issues, probably
if currentFileTransfer.data.len == 0:
@ -100,7 +100,7 @@ proc handleFilePartRecv*(serv: PServer; buffer: PBuffer) {.procvar.} =
proc saveCurrentFile() =
if not currentFileTransfer.readyToSave: return
let
let
path = expandPath(currentFileTransfer.assetType, currentFileTransfer.fileName)
parent = parentDir(path)
if not existsDir(parent):
@ -123,7 +123,7 @@ proc handleFileChallengeResult*(serv: PServer; buffer: PBuffer) {.procvar.} =
## HFileCHallenge
proc handleFileChallenge*(serv: PServer; buffer: PBuffer) {.procvar.} =
var
var
challenge = readScFileChallenge(buffer)
path = expandPath(challenge)
resp: CsFileChallenge

8
tests/manyloc/keineschweine/lib/estreams.nim
View file

@ -1,6 +1,6 @@
import endians
proc swapEndian16*(outp, inp: pointer) =
proc swapEndian16*(outp, inp: pointer) =
## copies `inp` to `outp` swapping bytes. Both buffers are supposed to
## contain at least 2 bytes.
var i = cast[cstring](inp)
@ -113,10 +113,10 @@ when isMainModule:
echo(repr(b))
b.pos = 0
echo(repr(b.readStr()))
b.flush()
echo "flushed"
b.writeC([1,2,3])
echo(repr(b))

346
tests/manyloc/keineschweine/lib/gl.nim
View file

@ -5,24 +5,24 @@
# These units are free to use
#
#******************************************************************************
# Converted to Delphi by Tom Nuydens (tom@delphi3d.net)
# For the latest updates, visit Delphi3D: http://www.delphi3d.net
# Converted to Delphi by Tom Nuydens (tom@delphi3d.net)
# For the latest updates, visit Delphi3D: http://www.delphi3d.net
#******************************************************************************
when defined(windows):
when defined(windows):
{.push, callconv: stdcall.}
else:
else:
{.push, callconv: cdecl.}
when defined(windows):
const
when defined(windows):
const
dllname* = "opengl32.dll"
elif defined(macosx):
const
elif defined(macosx):
const
dllname* = "/System/Library/Frameworks/OpenGL.framework/Libraries/libGL.dylib"
else:
const
else:
const
dllname* = "libGL.so.1"
type
type
PGLenum* = ptr TGLenum
PGLboolean* = ptr TGLboolean
PGLbitfield* = ptr TGLbitfield
@ -983,128 +983,128 @@ const # Version
GL_TEXTURE_COMPONENTS* = GL_TEXTURE_INTERNAL_FORMAT
proc glAccum*(op: TGLenum, value: TGLfloat){.dynlib: dllname, importc: "glAccum".}
proc glAlphaFunc*(fun: TGLenum, theref: TGLclampf){.dynlib: dllname,
proc glAlphaFunc*(fun: TGLenum, theref: TGLclampf){.dynlib: dllname,
importc: "glAlphaFunc".}
proc glAreTexturesResident*(n: TGLsizei, textures: PGLuint,
proc glAreTexturesResident*(n: TGLsizei, textures: PGLuint,
residences: PGLboolean): TGLboolean{.
dynlib: dllname, importc: "glAreTexturesResident".}
proc glArrayElement*(i: TGLint){.dynlib: dllname, importc: "glArrayElement".}
proc glBegin*(mode: TGLenum){.dynlib: dllname, importc: "glBegin".}
proc glBindTexture*(target: TGLenum, texture: TGLuint){.dynlib: dllname,
proc glBindTexture*(target: TGLenum, texture: TGLuint){.dynlib: dllname,
importc: "glBindTexture".}
proc glBitmap*(width, height: TGLsizei, xorig, yorig: TGLfloat,
xmove, ymove: TGLfloat, bitmap: PGLubyte){.dynlib: dllname,
proc glBitmap*(width, height: TGLsizei, xorig, yorig: TGLfloat,
xmove, ymove: TGLfloat, bitmap: PGLubyte){.dynlib: dllname,
importc: "glBitmap".}
proc glBlendFunc*(sfactor, dfactor: TGLenum){.dynlib: dllname,
proc glBlendFunc*(sfactor, dfactor: TGLenum){.dynlib: dllname,
importc: "glBlendFunc".}
proc glCallList*(list: TGLuint){.dynlib: dllname, importc: "glCallList".}
proc glCallLists*(n: TGLsizei, atype: TGLenum, lists: pointer){.dynlib: dllname,
proc glCallLists*(n: TGLsizei, atype: TGLenum, lists: pointer){.dynlib: dllname,
importc: "glCallLists".}
proc glClear*(mask: TGLbitfield){.dynlib: dllname, importc: "glClear".}
proc glClearAccum*(red, green, blue, alpha: TGLfloat){.dynlib: dllname,
proc glClearAccum*(red, green, blue, alpha: TGLfloat){.dynlib: dllname,
importc: "glClearAccum".}
proc glClearColor*(red, green, blue, alpha: TGLclampf){.dynlib: dllname,
proc glClearColor*(red, green, blue, alpha: TGLclampf){.dynlib: dllname,
importc: "glClearColor".}
proc glClearDepth*(depth: TGLclampd){.dynlib: dllname, importc: "glClearDepth".}
proc glClearIndex*(c: TGLfloat){.dynlib: dllname, importc: "glClearIndex".}
proc glClearStencil*(s: TGLint){.dynlib: dllname, importc: "glClearStencil".}
proc glClipPlane*(plane: TGLenum, equation: PGLdouble){.dynlib: dllname,
proc glClipPlane*(plane: TGLenum, equation: PGLdouble){.dynlib: dllname,
importc: "glClipPlane".}
proc glColor3b*(red, green, blue: TGlbyte){.dynlib: dllname,
proc glColor3b*(red, green, blue: TGlbyte){.dynlib: dllname,
importc: "glColor3b".}
proc glColor3bv*(v: PGLbyte){.dynlib: dllname, importc: "glColor3bv".}
proc glColor3d*(red, green, blue: TGLdouble){.dynlib: dllname,
proc glColor3d*(red, green, blue: TGLdouble){.dynlib: dllname,
importc: "glColor3d".}
proc glColor3dv*(v: PGLdouble){.dynlib: dllname, importc: "glColor3dv".}
proc glColor3f*(red, green, blue: TGLfloat){.dynlib: dllname,
proc glColor3f*(red, green, blue: TGLfloat){.dynlib: dllname,
importc: "glColor3f".}
proc glColor3fv*(v: PGLfloat){.dynlib: dllname, importc: "glColor3fv".}
proc glColor3i*(red, green, blue: TGLint){.dynlib: dllname, importc: "glColor3i".}
proc glColor3iv*(v: PGLint){.dynlib: dllname, importc: "glColor3iv".}
proc glColor3s*(red, green, blue: TGLshort){.dynlib: dllname,
proc glColor3s*(red, green, blue: TGLshort){.dynlib: dllname,
importc: "glColor3s".}
proc glColor3sv*(v: PGLshort){.dynlib: dllname, importc: "glColor3sv".}
proc glColor3ub*(red, green, blue: TGLubyte){.dynlib: dllname,
proc glColor3ub*(red, green, blue: TGLubyte){.dynlib: dllname,
importc: "glColor3ub".}
proc glColor3ubv*(v: PGLubyte){.dynlib: dllname, importc: "glColor3ubv".}
proc glColor3ui*(red, green, blue: TGLuint){.dynlib: dllname,
proc glColor3ui*(red, green, blue: TGLuint){.dynlib: dllname,
importc: "glColor3ui".}
proc glColor3uiv*(v: PGLuint){.dynlib: dllname, importc: "glColor3uiv".}
proc glColor3us*(red, green, blue: TGLushort){.dynlib: dllname,
proc glColor3us*(red, green, blue: TGLushort){.dynlib: dllname,
importc: "glColor3us".}
proc glColor3usv*(v: PGLushort){.dynlib: dllname, importc: "glColor3usv".}
proc glColor4b*(red, green, blue, alpha: TGlbyte){.dynlib: dllname,
proc glColor4b*(red, green, blue, alpha: TGlbyte){.dynlib: dllname,
importc: "glColor4b".}
proc glColor4bv*(v: PGLbyte){.dynlib: dllname, importc: "glColor4bv".}
proc glColor4d*(red, green, blue, alpha: TGLdouble){.dynlib: dllname,
proc glColor4d*(red, green, blue, alpha: TGLdouble){.dynlib: dllname,
importc: "glColor4d".}
proc glColor4dv*(v: PGLdouble){.dynlib: dllname, importc: "glColor4dv".}
proc glColor4f*(red, green, blue, alpha: TGLfloat){.dynlib: dllname,
proc glColor4f*(red, green, blue, alpha: TGLfloat){.dynlib: dllname,
importc: "glColor4f".}
proc glColor4fv*(v: PGLfloat){.dynlib: dllname, importc: "glColor4fv".}
proc glColor4i*(red, green, blue, alpha: TGLint){.dynlib: dllname,
proc glColor4i*(red, green, blue, alpha: TGLint){.dynlib: dllname,
importc: "glColor4i".}
proc glColor4iv*(v: PGLint){.dynlib: dllname, importc: "glColor4iv".}
proc glColor4s*(red, green, blue, alpha: TGLshort){.dynlib: dllname,
proc glColor4s*(red, green, blue, alpha: TGLshort){.dynlib: dllname,
importc: "glColor4s".}
proc glColor4sv*(v: PGLshort){.dynlib: dllname, importc: "glColor4sv".}
proc glColor4ub*(red, green, blue, alpha: TGLubyte){.dynlib: dllname,
proc glColor4ub*(red, green, blue, alpha: TGLubyte){.dynlib: dllname,
importc: "glColor4ub".}
proc glColor4ubv*(v: PGLubyte){.dynlib: dllname, importc: "glColor4ubv".}
proc glColor4ui*(red, green, blue, alpha: TGLuint){.dynlib: dllname,
proc glColor4ui*(red, green, blue, alpha: TGLuint){.dynlib: dllname,
importc: "glColor4ui".}
proc glColor4uiv*(v: PGLuint){.dynlib: dllname, importc: "glColor4uiv".}
proc glColor4us*(red, green, blue, alpha: TGLushort){.dynlib: dllname,
proc glColor4us*(red, green, blue, alpha: TGLushort){.dynlib: dllname,
importc: "glColor4us".}
proc glColor4usv*(v: PGLushort){.dynlib: dllname, importc: "glColor4usv".}
proc glColorMask*(red, green, blue, alpha: TGLboolean){.dynlib: dllname,
proc glColorMask*(red, green, blue, alpha: TGLboolean){.dynlib: dllname,
importc: "glColorMask".}
proc glColorMaterial*(face, mode: TGLenum){.dynlib: dllname,
proc glColorMaterial*(face, mode: TGLenum){.dynlib: dllname,
importc: "glColorMaterial".}
proc glColorPointer*(size: TGLint, atype: TGLenum, stride: TGLsizei,
p: pointer){.dynlib: dllname,
proc glColorPointer*(size: TGLint, atype: TGLenum, stride: TGLsizei,
p: pointer){.dynlib: dllname,
importc: "glColorPointer".}
proc glCopyPixels*(x, y: TGLint, width, height: TGLsizei, atype: TGLenum){.
dynlib: dllname, importc: "glCopyPixels".}
proc glCopyTexImage1D*(target: TGLenum, level: TGLint, internalFormat: TGLenum,
proc glCopyTexImage1D*(target: TGLenum, level: TGLint, internalFormat: TGLenum,
x, y: TGLint, width: TGLsizei, border: TGLint){.
dynlib: dllname, importc: "glCopyTexImage1D".}
proc glCopyTexImage2D*(target: TGLenum, level: TGLint, internalFormat: TGLenum,
proc glCopyTexImage2D*(target: TGLenum, level: TGLint, internalFormat: TGLenum,
x, y: TGLint, width, height: TGLsizei, border: TGLint){.
dynlib: dllname, importc: "glCopyTexImage2D".}
proc glCopyTexSubImage1D*(target: TGLenum, level, xoffset, x, y: TGLint,
width: TGLsizei){.dynlib: dllname,
proc glCopyTexSubImage1D*(target: TGLenum, level, xoffset, x, y: TGLint,
width: TGLsizei){.dynlib: dllname,
importc: "glCopyTexSubImage1D".}
proc glCopyTexSubImage2D*(target: TGLenum,
level, xoffset, yoffset, x, y: TGLint,
width, height: TGLsizei){.dynlib: dllname,
proc glCopyTexSubImage2D*(target: TGLenum,
level, xoffset, yoffset, x, y: TGLint,
width, height: TGLsizei){.dynlib: dllname,
importc: "glCopyTexSubImage2D".}
proc glCullFace*(mode: TGLenum){.dynlib: dllname, importc: "glCullFace".}
proc glDeleteLists*(list: TGLuint, range: TGLsizei){.dynlib: dllname,
proc glDeleteLists*(list: TGLuint, range: TGLsizei){.dynlib: dllname,
importc: "glDeleteLists".}
proc glDeleteTextures*(n: TGLsizei, textures: PGLuint){.dynlib: dllname,
proc glDeleteTextures*(n: TGLsizei, textures: PGLuint){.dynlib: dllname,
importc: "glDeleteTextures".}
proc glDepthFunc*(fun: TGLenum){.dynlib: dllname, importc: "glDepthFunc".}
proc glDepthMask*(flag: TGLboolean){.dynlib: dllname, importc: "glDepthMask".}
proc glDepthRange*(zNear, zFar: TGLclampd){.dynlib: dllname,
proc glDepthRange*(zNear, zFar: TGLclampd){.dynlib: dllname,
importc: "glDepthRange".}
proc glDisable*(cap: TGLenum){.dynlib: dllname, importc: "glDisable".}
proc glDisableClientState*(aarray: TGLenum){.dynlib: dllname,
proc glDisableClientState*(aarray: TGLenum){.dynlib: dllname,
importc: "glDisableClientState".}
proc glDrawArrays*(mode: TGLenum, first: TGLint, count: TGLsizei){.
dynlib: dllname, importc: "glDrawArrays".}
proc glDrawBuffer*(mode: TGLenum){.dynlib: dllname, importc: "glDrawBuffer".}
proc glDrawElements*(mode: TGLenum, count: TGLsizei, atype: TGLenum,
indices: pointer){.dynlib: dllname,
proc glDrawElements*(mode: TGLenum, count: TGLsizei, atype: TGLenum,
indices: pointer){.dynlib: dllname,
importc: "glDrawElements".}
proc glDrawPixels*(width, height: TGLsizei, format, atype: TGLenum,
proc glDrawPixels*(width, height: TGLsizei, format, atype: TGLenum,
pixels: pointer){.dynlib: dllname, importc: "glDrawPixels".}
proc glEdgeFlag*(flag: TGLboolean){.dynlib: dllname, importc: "glEdgeFlag".}
proc glEdgeFlagPointer*(stride: TGLsizei, p: pointer){.dynlib: dllname,
proc glEdgeFlagPointer*(stride: TGLsizei, p: pointer){.dynlib: dllname,
importc: "glEdgeFlagPointer".}
proc glEdgeFlagv*(flag: PGLboolean){.dynlib: dllname, importc: "glEdgeFlagv".}
proc glEnable*(cap: TGLenum){.dynlib: dllname, importc: "glEnable".}
proc glEnableClientState*(aarray: TGLenum){.dynlib: dllname,
proc glEnableClientState*(aarray: TGLenum){.dynlib: dllname,
importc: "glEnableClientState".}
proc glEnd*(){.dynlib: dllname, importc: "glEnd".}
proc glEndList*(){.dynlib: dllname, importc: "glEndList".}
@ -1116,9 +1116,9 @@ proc glEvalCoord2d*(u, v: TGLdouble){.dynlib: dllname, importc: "glEvalCoord2d".
proc glEvalCoord2dv*(u: PGLdouble){.dynlib: dllname, importc: "glEvalCoord2dv".}
proc glEvalCoord2f*(u, v: TGLfloat){.dynlib: dllname, importc: "glEvalCoord2f".}
proc glEvalCoord2fv*(u: PGLfloat){.dynlib: dllname, importc: "glEvalCoord2fv".}
proc glEvalMesh1*(mode: TGLenum, i1, i2: TGLint){.dynlib: dllname,
proc glEvalMesh1*(mode: TGLenum, i1, i2: TGLint){.dynlib: dllname,
importc: "glEvalMesh1".}
proc glEvalMesh2*(mode: TGLenum, i1, i2, j1, j2: TGLint){.dynlib: dllname,
proc glEvalMesh2*(mode: TGLenum, i1, i2, j1, j2: TGLint){.dynlib: dllname,
importc: "glEvalMesh2".}
proc glEvalPoint1*(i: TGLint){.dynlib: dllname, importc: "glEvalPoint1".}
proc glEvalPoint2*(i, j: TGLint){.dynlib: dllname, importc: "glEvalPoint2".}
@ -1126,75 +1126,75 @@ proc glFeedbackBuffer*(size: TGLsizei, atype: TGLenum, buffer: PGLfloat){.
dynlib: dllname, importc: "glFeedbackBuffer".}
proc glFinish*(){.dynlib: dllname, importc: "glFinish".}
proc glFlush*(){.dynlib: dllname, importc: "glFlush".}
proc glFogf*(pname: TGLenum, param: TGLfloat){.dynlib: dllname,
proc glFogf*(pname: TGLenum, param: TGLfloat){.dynlib: dllname,
importc: "glFogf".}
proc glFogfv*(pname: TGLenum, params: PGLfloat){.dynlib: dllname,
proc glFogfv*(pname: TGLenum, params: PGLfloat){.dynlib: dllname,
importc: "glFogfv".}
proc glFogi*(pname: TGLenum, param: TGLint){.dynlib: dllname, importc: "glFogi".}
proc glFogiv*(pname: TGLenum, params: PGLint){.dynlib: dllname,
proc glFogiv*(pname: TGLenum, params: PGLint){.dynlib: dllname,
importc: "glFogiv".}
proc glFrontFace*(mode: TGLenum){.dynlib: dllname, importc: "glFrontFace".}
proc glFrustum*(left, right, bottom, top, zNear, zFar: TGLdouble){.
dynlib: dllname, importc: "glFrustum".}
proc glGenLists*(range: TGLsizei): TGLuint{.dynlib: dllname,
proc glGenLists*(range: TGLsizei): TGLuint{.dynlib: dllname,
importc: "glGenLists".}
proc glGenTextures*(n: TGLsizei, textures: PGLuint){.dynlib: dllname,
proc glGenTextures*(n: TGLsizei, textures: PGLuint){.dynlib: dllname,
importc: "glGenTextures".}
proc glGetBooleanv*(pname: TGLenum, params: PGLboolean){.dynlib: dllname,
proc glGetBooleanv*(pname: TGLenum, params: PGLboolean){.dynlib: dllname,
importc: "glGetBooleanv".}
proc glGetClipPlane*(plane: TGLenum, equation: PGLdouble){.dynlib: dllname,
proc glGetClipPlane*(plane: TGLenum, equation: PGLdouble){.dynlib: dllname,
importc: "glGetClipPlane".}
proc glGetDoublev*(pname: TGLenum, params: PGLdouble){.dynlib: dllname,
proc glGetDoublev*(pname: TGLenum, params: PGLdouble){.dynlib: dllname,
importc: "glGetDoublev".}
proc glGetError*(): TGLenum{.dynlib: dllname, importc: "glGetError".}
proc glGetFloatv*(pname: TGLenum, params: PGLfloat){.dynlib: dllname,
proc glGetFloatv*(pname: TGLenum, params: PGLfloat){.dynlib: dllname,
importc: "glGetFloatv".}
proc glGetIntegerv*(pname: TGLenum, params: PGLint){.dynlib: dllname,
proc glGetIntegerv*(pname: TGLenum, params: PGLint){.dynlib: dllname,
importc: "glGetIntegerv".}
proc glGetLightfv*(light, pname: TGLenum, params: PGLfloat){.dynlib: dllname,
proc glGetLightfv*(light, pname: TGLenum, params: PGLfloat){.dynlib: dllname,
importc: "glGetLightfv".}
proc glGetLightiv*(light, pname: TGLenum, params: PGLint){.dynlib: dllname,
proc glGetLightiv*(light, pname: TGLenum, params: PGLint){.dynlib: dllname,
importc: "glGetLightiv".}
proc glGetMapdv*(target, query: TGLenum, v: PGLdouble){.dynlib: dllname,
proc glGetMapdv*(target, query: TGLenum, v: PGLdouble){.dynlib: dllname,
importc: "glGetMapdv".}
proc glGetMapfv*(target, query: TGLenum, v: PGLfloat){.dynlib: dllname,
proc glGetMapfv*(target, query: TGLenum, v: PGLfloat){.dynlib: dllname,
importc: "glGetMapfv".}
proc glGetMapiv*(target, query: TGLenum, v: PGLint){.dynlib: dllname,
proc glGetMapiv*(target, query: TGLenum, v: PGLint){.dynlib: dllname,
importc: "glGetMapiv".}
proc glGetMaterialfv*(face, pname: TGLenum, params: PGLfloat){.dynlib: dllname,
proc glGetMaterialfv*(face, pname: TGLenum, params: PGLfloat){.dynlib: dllname,
importc: "glGetMaterialfv".}
proc glGetMaterialiv*(face, pname: TGLenum, params: PGLint){.dynlib: dllname,
proc glGetMaterialiv*(face, pname: TGLenum, params: PGLint){.dynlib: dllname,
importc: "glGetMaterialiv".}
proc glGetPixelMapfv*(map: TGLenum, values: PGLfloat){.dynlib: dllname,
proc glGetPixelMapfv*(map: TGLenum, values: PGLfloat){.dynlib: dllname,
importc: "glGetPixelMapfv".}
proc glGetPixelMapuiv*(map: TGLenum, values: PGLuint){.dynlib: dllname,
proc glGetPixelMapuiv*(map: TGLenum, values: PGLuint){.dynlib: dllname,
importc: "glGetPixelMapuiv".}
proc glGetPixelMapusv*(map: TGLenum, values: PGLushort){.dynlib: dllname,
proc glGetPixelMapusv*(map: TGLenum, values: PGLushort){.dynlib: dllname,
importc: "glGetPixelMapusv".}
proc glGetPointerv*(pname: TGLenum, params: pointer){.dynlib: dllname,
proc glGetPointerv*(pname: TGLenum, params: pointer){.dynlib: dllname,
importc: "glGetPointerv".}
proc glGetPolygonStipple*(mask: PGLubyte){.dynlib: dllname,
proc glGetPolygonStipple*(mask: PGLubyte){.dynlib: dllname,
importc: "glGetPolygonStipple".}
proc glGetString*(name: TGLenum): cstring{.dynlib: dllname,
proc glGetString*(name: TGLenum): cstring{.dynlib: dllname,
importc: "glGetString".}
proc glGetTexEnvfv*(target, pname: TGLenum, params: PGLfloat){.dynlib: dllname,
proc glGetTexEnvfv*(target, pname: TGLenum, params: PGLfloat){.dynlib: dllname,
importc: "glGetTexEnvfv".}
proc glGetTexEnviv*(target, pname: TGLenum, params: PGLint){.dynlib: dllname,
proc glGetTexEnviv*(target, pname: TGLenum, params: PGLint){.dynlib: dllname,
importc: "glGetTexEnviv".}
proc glGetTexGendv*(coord, pname: TGLenum, params: PGLdouble){.dynlib: dllname,
proc glGetTexGendv*(coord, pname: TGLenum, params: PGLdouble){.dynlib: dllname,
importc: "glGetTexGendv".}
proc glGetTexGenfv*(coord, pname: TGLenum, params: PGLfloat){.dynlib: dllname,
proc glGetTexGenfv*(coord, pname: TGLenum, params: PGLfloat){.dynlib: dllname,
importc: "glGetTexGenfv".}
proc glGetTexGeniv*(coord, pname: TGLenum, params: PGLint){.dynlib: dllname,
proc glGetTexGeniv*(coord, pname: TGLenum, params: PGLint){.dynlib: dllname,
importc: "glGetTexGeniv".}
proc glGetTexImage*(target: TGLenum, level: TGLint, format: TGLenum,
atype: TGLenum, pixels: pointer){.dynlib: dllname,
proc glGetTexImage*(target: TGLenum, level: TGLint, format: TGLenum,
atype: TGLenum, pixels: pointer){.dynlib: dllname,
importc: "glGetTexImage".}
proc glGetTexLevelParameterfv*(target: TGLenum, level: TGLint, pname: TGLenum,
params: pointer){.dynlib: dllname,
proc glGetTexLevelParameterfv*(target: TGLenum, level: TGLint, pname: TGLenum,
params: pointer){.dynlib: dllname,
importc: "glGetTexLevelParameterfv".}
proc glGetTexLevelParameteriv*(target: TGLenum, level: TGLint, pname: TGLenum,
params: PGLint){.dynlib: dllname,
proc glGetTexLevelParameteriv*(target: TGLenum, level: TGLint, pname: TGLenum,
params: PGLint){.dynlib: dllname,
importc: "glGetTexLevelParameteriv".}
proc glGetTexParameterfv*(target, pname: TGLenum, params: PGLfloat){.
dynlib: dllname, importc: "glGetTexParameterfv".}
@ -1217,28 +1217,28 @@ proc glIndexubv*(c: PGLubyte){.dynlib: dllname, importc: "glIndexubv".}
proc glInitNames*(){.dynlib: dllname, importc: "glInitNames".}
proc glInterleavedArrays*(format: TGLenum, stride: TGLsizei, p: pointer){.
dynlib: dllname, importc: "glInterleavedArrays".}
proc glIsEnabled*(cap: TGLenum): TGLboolean{.dynlib: dllname,
proc glIsEnabled*(cap: TGLenum): TGLboolean{.dynlib: dllname,
importc: "glIsEnabled".}
proc glIsList*(list: TGLuint): TGLboolean{.dynlib: dllname, importc: "glIsList".}
proc glIsTexture*(texture: TGLuint): TGLboolean{.dynlib: dllname,
proc glIsTexture*(texture: TGLuint): TGLboolean{.dynlib: dllname,
importc: "glIsTexture".}
proc glLightModelf*(pname: TGLenum, param: TGLfloat){.dynlib: dllname,
proc glLightModelf*(pname: TGLenum, param: TGLfloat){.dynlib: dllname,
importc: "glLightModelf".}
proc glLightModelfv*(pname: TGLenum, params: PGLfloat){.dynlib: dllname,
proc glLightModelfv*(pname: TGLenum, params: PGLfloat){.dynlib: dllname,
importc: "glLightModelfv".}
proc glLightModeli*(pname: TGLenum, param: TGLint){.dynlib: dllname,
proc glLightModeli*(pname: TGLenum, param: TGLint){.dynlib: dllname,
importc: "glLightModeli".}
proc glLightModeliv*(pname: TGLenum, params: PGLint){.dynlib: dllname,
proc glLightModeliv*(pname: TGLenum, params: PGLint){.dynlib: dllname,
importc: "glLightModeliv".}
proc glLightf*(light, pname: TGLenum, param: TGLfloat){.dynlib: dllname,
proc glLightf*(light, pname: TGLenum, param: TGLfloat){.dynlib: dllname,
importc: "glLightf".}
proc glLightfv*(light, pname: TGLenum, params: PGLfloat){.dynlib: dllname,
proc glLightfv*(light, pname: TGLenum, params: PGLfloat){.dynlib: dllname,
importc: "glLightfv".}
proc glLighti*(light, pname: TGLenum, param: TGLint){.dynlib: dllname,
proc glLighti*(light, pname: TGLenum, param: TGLint){.dynlib: dllname,
importc: "glLighti".}
proc glLightiv*(light, pname: TGLenum, params: PGLint){.dynlib: dllname,
proc glLightiv*(light, pname: TGLenum, params: PGLint){.dynlib: dllname,
importc: "glLightiv".}
proc glLineStipple*(factor: TGLint, pattern: TGLushort){.dynlib: dllname,
proc glLineStipple*(factor: TGLint, pattern: TGLushort){.dynlib: dllname,
importc: "glLineStipple".}
proc glLineWidth*(width: TGLfloat){.dynlib: dllname, importc: "glLineWidth".}
proc glListBase*(base: TGLuint){.dynlib: dllname, importc: "glListBase".}
@ -1247,36 +1247,36 @@ proc glLoadMatrixd*(m: PGLdouble){.dynlib: dllname, importc: "glLoadMatrixd".}
proc glLoadMatrixf*(m: PGLfloat){.dynlib: dllname, importc: "glLoadMatrixf".}
proc glLoadName*(name: TGLuint){.dynlib: dllname, importc: "glLoadName".}
proc glLogicOp*(opcode: TGLenum){.dynlib: dllname, importc: "glLogicOp".}
proc glMap1d*(target: TGLenum, u1, u2: TGLdouble, stride, order: TGLint,
proc glMap1d*(target: TGLenum, u1, u2: TGLdouble, stride, order: TGLint,
points: PGLdouble){.dynlib: dllname, importc: "glMap1d".}
proc glMap1f*(target: TGLenum, u1, u2: TGLfloat, stride, order: TGLint,
proc glMap1f*(target: TGLenum, u1, u2: TGLfloat, stride, order: TGLint,
points: PGLfloat){.dynlib: dllname, importc: "glMap1f".}
proc glMap2d*(target: TGLenum, u1, u2: TGLdouble, ustride, uorder: TGLint,
proc glMap2d*(target: TGLenum, u1, u2: TGLdouble, ustride, uorder: TGLint,
v1, v2: TGLdouble, vstride, vorder: TGLint, points: PGLdouble){.
dynlib: dllname, importc: "glMap2d".}
proc glMap2f*(target: TGLenum, u1, u2: TGLfloat, ustride, uorder: TGLint,
proc glMap2f*(target: TGLenum, u1, u2: TGLfloat, ustride, uorder: TGLint,
v1, v2: TGLfloat, vstride, vorder: TGLint, points: PGLfloat){.
dynlib: dllname, importc: "glMap2f".}
proc glMapGrid1d*(un: TGLint, u1, u2: TGLdouble){.dynlib: dllname,
proc glMapGrid1d*(un: TGLint, u1, u2: TGLdouble){.dynlib: dllname,
importc: "glMapGrid1d".}
proc glMapGrid1f*(un: TGLint, u1, u2: TGLfloat){.dynlib: dllname,
proc glMapGrid1f*(un: TGLint, u1, u2: TGLfloat){.dynlib: dllname,
importc: "glMapGrid1f".}
proc glMapGrid2d*(un: TGLint, u1, u2: TGLdouble, vn: TGLint, v1, v2: TGLdouble){.
dynlib: dllname, importc: "glMapGrid2d".}
proc glMapGrid2f*(un: TGLint, u1, u2: TGLfloat, vn: TGLint, v1, v2: TGLfloat){.
dynlib: dllname, importc: "glMapGrid2f".}
proc glMaterialf*(face, pname: TGLenum, param: TGLfloat){.dynlib: dllname,
proc glMaterialf*(face, pname: TGLenum, param: TGLfloat){.dynlib: dllname,
importc: "glMaterialf".}
proc glMaterialfv*(face, pname: TGLenum, params: PGLfloat){.dynlib: dllname,
proc glMaterialfv*(face, pname: TGLenum, params: PGLfloat){.dynlib: dllname,
importc: "glMaterialfv".}
proc glMateriali*(face, pname: TGLenum, param: TGLint){.dynlib: dllname,
proc glMateriali*(face, pname: TGLenum, param: TGLint){.dynlib: dllname,
importc: "glMateriali".}
proc glMaterialiv*(face, pname: TGLenum, params: PGLint){.dynlib: dllname,
proc glMaterialiv*(face, pname: TGLenum, params: PGLint){.dynlib: dllname,
importc: "glMaterialiv".}
proc glMatrixMode*(mode: TGLenum){.dynlib: dllname, importc: "glMatrixMode".}
proc glMultMatrixd*(m: PGLdouble){.dynlib: dllname, importc: "glMultMatrixd".}
proc glMultMatrixf*(m: PGLfloat){.dynlib: dllname, importc: "glMultMatrixf".}
proc glNewList*(list: TGLuint, mode: TGLenum){.dynlib: dllname,
proc glNewList*(list: TGLuint, mode: TGLenum){.dynlib: dllname,
importc: "glNewList".}
proc glNormal3b*(nx, ny, nz: TGlbyte){.dynlib: dllname, importc: "glNormal3b".}
proc glNormal3bv*(v: PGLbyte){.dynlib: dllname, importc: "glNormal3bv".}
@ -1299,22 +1299,22 @@ proc glPixelMapuiv*(map: TGLenum, mapsize: TGLsizei, values: PGLuint){.
dynlib: dllname, importc: "glPixelMapuiv".}
proc glPixelMapusv*(map: TGLenum, mapsize: TGLsizei, values: PGLushort){.
dynlib: dllname, importc: "glPixelMapusv".}
proc glPixelStoref*(pname: TGLenum, param: TGLfloat){.dynlib: dllname,
proc glPixelStoref*(pname: TGLenum, param: TGLfloat){.dynlib: dllname,
importc: "glPixelStoref".}
proc glPixelStorei*(pname: TGLenum, param: TGLint){.dynlib: dllname,
proc glPixelStorei*(pname: TGLenum, param: TGLint){.dynlib: dllname,
importc: "glPixelStorei".}
proc glPixelTransferf*(pname: TGLenum, param: TGLfloat){.dynlib: dllname,
proc glPixelTransferf*(pname: TGLenum, param: TGLfloat){.dynlib: dllname,
importc: "glPixelTransferf".}
proc glPixelTransferi*(pname: TGLenum, param: TGLint){.dynlib: dllname,
proc glPixelTransferi*(pname: TGLenum, param: TGLint){.dynlib: dllname,
importc: "glPixelTransferi".}
proc glPixelZoom*(xfactor, yfactor: TGLfloat){.dynlib: dllname,
proc glPixelZoom*(xfactor, yfactor: TGLfloat){.dynlib: dllname,
importc: "glPixelZoom".}
proc glPointSize*(size: TGLfloat){.dynlib: dllname, importc: "glPointSize".}
proc glPolygonMode*(face, mode: TGLenum){.dynlib: dllname,
proc glPolygonMode*(face, mode: TGLenum){.dynlib: dllname,
importc: "glPolygonMode".}
proc glPolygonOffset*(factor, units: TGLfloat){.dynlib: dllname,
proc glPolygonOffset*(factor, units: TGLfloat){.dynlib: dllname,
importc: "glPolygonOffset".}
proc glPolygonStipple*(mask: PGLubyte){.dynlib: dllname,
proc glPolygonStipple*(mask: PGLubyte){.dynlib: dllname,
importc: "glPolygonStipple".}
proc glPopAttrib*(){.dynlib: dllname, importc: "glPopAttrib".}
proc glPopClientAttrib*(){.dynlib: dllname, importc: "glPopClientAttrib".}
@ -1323,7 +1323,7 @@ proc glPopName*(){.dynlib: dllname, importc: "glPopName".}
proc glPrioritizeTextures*(n: TGLsizei, textures: PGLuint, priorities: PGLclampf){.
dynlib: dllname, importc: "glPrioritizeTextures".}
proc glPushAttrib*(mask: TGLbitfield){.dynlib: dllname, importc: "glPushAttrib".}
proc glPushClientAttrib*(mask: TGLbitfield){.dynlib: dllname,
proc glPushClientAttrib*(mask: TGLbitfield){.dynlib: dllname,
importc: "glPushClientAttrib".}
proc glPushMatrix*(){.dynlib: dllname, importc: "glPushMatrix".}
proc glPushName*(name: TGLuint){.dynlib: dllname, importc: "glPushName".}
@ -1335,35 +1335,35 @@ proc glRasterPos2i*(x, y: TGLint){.dynlib: dllname, importc: "glRasterPos2i".}
proc glRasterPos2iv*(v: PGLint){.dynlib: dllname, importc: "glRasterPos2iv".}
proc glRasterPos2s*(x, y: TGLshort){.dynlib: dllname, importc: "glRasterPos2s".}
proc glRasterPos2sv*(v: PGLshort){.dynlib: dllname, importc: "glRasterPos2sv".}
proc glRasterPos3d*(x, y, z: TGLdouble){.dynlib: dllname,
proc glRasterPos3d*(x, y, z: TGLdouble){.dynlib: dllname,
importc: "glRasterPos3d".}
proc glRasterPos3dv*(v: PGLdouble){.dynlib: dllname, importc: "glRasterPos3dv".}
proc glRasterPos3f*(x, y, z: TGLfloat){.dynlib: dllname,
proc glRasterPos3f*(x, y, z: TGLfloat){.dynlib: dllname,
importc: "glRasterPos3f".}
proc glRasterPos3fv*(v: PGLfloat){.dynlib: dllname, importc: "glRasterPos3fv".}
proc glRasterPos3i*(x, y, z: TGLint){.dynlib: dllname, importc: "glRasterPos3i".}
proc glRasterPos3iv*(v: PGLint){.dynlib: dllname, importc: "glRasterPos3iv".}
proc glRasterPos3s*(x, y, z: TGLshort){.dynlib: dllname,
proc glRasterPos3s*(x, y, z: TGLshort){.dynlib: dllname,
importc: "glRasterPos3s".}
proc glRasterPos3sv*(v: PGLshort){.dynlib: dllname, importc: "glRasterPos3sv".}
proc glRasterPos4d*(x, y, z, w: TGLdouble){.dynlib: dllname,
proc glRasterPos4d*(x, y, z, w: TGLdouble){.dynlib: dllname,
importc: "glRasterPos4d".}
proc glRasterPos4dv*(v: PGLdouble){.dynlib: dllname, importc: "glRasterPos4dv".}
proc glRasterPos4f*(x, y, z, w: TGLfloat){.dynlib: dllname,
proc glRasterPos4f*(x, y, z, w: TGLfloat){.dynlib: dllname,
importc: "glRasterPos4f".}
proc glRasterPos4fv*(v: PGLfloat){.dynlib: dllname, importc: "glRasterPos4fv".}
proc glRasterPos4i*(x, y, z, w: TGLint){.dynlib: dllname,
proc glRasterPos4i*(x, y, z, w: TGLint){.dynlib: dllname,
importc: "glRasterPos4i".}
proc glRasterPos4iv*(v: PGLint){.dynlib: dllname, importc: "glRasterPos4iv".}
proc glRasterPos4s*(x, y, z, w: TGLshort){.dynlib: dllname,
proc glRasterPos4s*(x, y, z, w: TGLshort){.dynlib: dllname,
importc: "glRasterPos4s".}
proc glRasterPos4sv*(v: PGLshort){.dynlib: dllname, importc: "glRasterPos4sv".}
proc glReadBuffer*(mode: TGLenum){.dynlib: dllname, importc: "glReadBuffer".}
proc glReadPixels*(x, y: TGLint, width, height: TGLsizei,
format, atype: TGLenum, pixels: pointer){.dynlib: dllname,
proc glReadPixels*(x, y: TGLint, width, height: TGLsizei,
format, atype: TGLenum, pixels: pointer){.dynlib: dllname,
importc: "glReadPixels".}
proc glRectd*(x1, y1, x2, y2: TGLdouble){.dynlib: dllname, importc: "glRectd".}
proc glRectdv*(v1: PGLdouble, v2: PGLdouble){.dynlib: dllname,
proc glRectdv*(v1: PGLdouble, v2: PGLdouble){.dynlib: dllname,
importc: "glRectdv".}
proc glRectf*(x1, y1, x2, y2: TGLfloat){.dynlib: dllname, importc: "glRectf".}
proc glRectfv*(v1: PGLfloat, v2: PGLfloat){.dynlib: dllname, importc: "glRectfv".}
@ -1371,22 +1371,22 @@ proc glRecti*(x1, y1, x2, y2: TGLint){.dynlib: dllname, importc: "glRecti".}
proc glRectiv*(v1: PGLint, v2: PGLint){.dynlib: dllname, importc: "glRectiv".}
proc glRects*(x1, y1, x2, y2: TGLshort){.dynlib: dllname, importc: "glRects".}
proc glRectsv*(v1: PGLshort, v2: PGLshort){.dynlib: dllname, importc: "glRectsv".}
proc glRenderMode*(mode: TGLint): TGLint{.dynlib: dllname,
proc glRenderMode*(mode: TGLint): TGLint{.dynlib: dllname,
importc: "glRenderMode".}
proc glRotated*(angle, x, y, z: TGLdouble){.dynlib: dllname,
proc glRotated*(angle, x, y, z: TGLdouble){.dynlib: dllname,
importc: "glRotated".}
proc glRotatef*(angle, x, y, z: TGLfloat){.dynlib: dllname, importc: "glRotatef".}
proc glScaled*(x, y, z: TGLdouble){.dynlib: dllname, importc: "glScaled".}
proc glScalef*(x, y, z: TGLfloat){.dynlib: dllname, importc: "glScalef".}
proc glScissor*(x, y: TGLint, width, height: TGLsizei){.dynlib: dllname,
proc glScissor*(x, y: TGLint, width, height: TGLsizei){.dynlib: dllname,
importc: "glScissor".}
proc glSelectBuffer*(size: TGLsizei, buffer: PGLuint){.dynlib: dllname,
proc glSelectBuffer*(size: TGLsizei, buffer: PGLuint){.dynlib: dllname,
importc: "glSelectBuffer".}
proc glShadeModel*(mode: TGLenum){.dynlib: dllname, importc: "glShadeModel".}
proc glStencilFunc*(fun: TGLenum, theref: TGLint, mask: TGLuint){.
dynlib: dllname, importc: "glStencilFunc".}
proc glStencilMask*(mask: TGLuint){.dynlib: dllname, importc: "glStencilMask".}
proc glStencilOp*(fail, zfail, zpass: TGLenum){.dynlib: dllname,
proc glStencilOp*(fail, zfail, zpass: TGLenum){.dynlib: dllname,
importc: "glStencilOp".}
proc glTexCoord1d*(s: TGLdouble){.dynlib: dllname, importc: "glTexCoord1d".}
proc glTexCoord1dv*(v: PGLdouble){.dynlib: dllname, importc: "glTexCoord1dv".}
@ -1412,19 +1412,19 @@ proc glTexCoord3i*(s, t, r: TGLint){.dynlib: dllname, importc: "glTexCoord3i".}
proc glTexCoord3iv*(v: PGLint){.dynlib: dllname, importc: "glTexCoord3iv".}
proc glTexCoord3s*(s, t, r: TGLshort){.dynlib: dllname, importc: "glTexCoord3s".}
proc glTexCoord3sv*(v: PGLshort){.dynlib: dllname, importc: "glTexCoord3sv".}
proc glTexCoord4d*(s, t, r, q: TGLdouble){.dynlib: dllname,
proc glTexCoord4d*(s, t, r, q: TGLdouble){.dynlib: dllname,
importc: "glTexCoord4d".}
proc glTexCoord4dv*(v: PGLdouble){.dynlib: dllname, importc: "glTexCoord4dv".}
proc glTexCoord4f*(s, t, r, q: TGLfloat){.dynlib: dllname,
proc glTexCoord4f*(s, t, r, q: TGLfloat){.dynlib: dllname,
importc: "glTexCoord4f".}
proc glTexCoord4fv*(v: PGLfloat){.dynlib: dllname, importc: "glTexCoord4fv".}
proc glTexCoord4i*(s, t, r, q: TGLint){.dynlib: dllname, importc: "glTexCoord4i".}
proc glTexCoord4iv*(v: PGLint){.dynlib: dllname, importc: "glTexCoord4iv".}
proc glTexCoord4s*(s, t, r, q: TGLshort){.dynlib: dllname,
proc glTexCoord4s*(s, t, r, q: TGLshort){.dynlib: dllname,
importc: "glTexCoord4s".}
proc glTexCoord4sv*(v: PGLshort){.dynlib: dllname, importc: "glTexCoord4sv".}
proc glTexCoordPointer*(size: TGLint, atype: TGLenum, stride: TGLsizei,
p: pointer){.dynlib: dllname,
proc glTexCoordPointer*(size: TGLint, atype: TGLenum, stride: TGLsizei,
p: pointer){.dynlib: dllname,
importc: "glTexCoordPointer".}
proc glTexEnvf*(target: TGLenum, pname: TGLenum, param: TGLfloat){.
dynlib: dllname, importc: "glTexEnvf".}
@ -1442,16 +1442,16 @@ proc glTexGenf*(coord: TGLenum, pname: TGLenum, param: TGLfloat){.
dynlib: dllname, importc: "glTexGenf".}
proc glTexGenfv*(coord: TGLenum, pname: TGLenum, params: PGLfloat){.
dynlib: dllname, importc: "glTexGenfv".}
proc glTexGeni*(coord: TGLenum, pname: TGLenum, param: TGLint){.dynlib: dllname,
proc glTexGeni*(coord: TGLenum, pname: TGLenum, param: TGLint){.dynlib: dllname,
importc: "glTexGeni".}
proc glTexGeniv*(coord: TGLenum, pname: TGLenum, params: PGLint){.
dynlib: dllname, importc: "glTexGeniv".}
proc glTexImage1D*(target: TGLenum, level, internalformat: TGLint,
width: TGLsizei, border: TGLint, format, atype: TGLenum,
proc glTexImage1D*(target: TGLenum, level, internalformat: TGLint,
width: TGLsizei, border: TGLint, format, atype: TGLenum,
pixels: pointer){.dynlib: dllname, importc: "glTexImage1D".}
proc glTexImage2D*(target: TGLenum, level, internalformat: TGLint,
width, height: TGLsizei, border: TGLint,
format, atype: TGLenum, pixels: pointer){.dynlib: dllname,
proc glTexImage2D*(target: TGLenum, level, internalformat: TGLint,
width, height: TGLsizei, border: TGLint,
format, atype: TGLenum, pixels: pointer){.dynlib: dllname,
importc: "glTexImage2D".}
proc glTexParameterf*(target: TGLenum, pname: TGLenum, param: TGLfloat){.
dynlib: dllname, importc: "glTexParameterf".}
@ -1461,12 +1461,12 @@ proc glTexParameteri*(target: TGLenum, pname: TGLenum, param: TGLint){.
dynlib: dllname, importc: "glTexParameteri".}
proc glTexParameteriv*(target: TGLenum, pname: TGLenum, params: PGLint){.
dynlib: dllname, importc: "glTexParameteriv".}
proc glTexSubImage1D*(target: TGLenum, level, xoffset: TGLint, width: TGLsizei,
format, atype: TGLenum, pixels: pointer){.dynlib: dllname,
proc glTexSubImage1D*(target: TGLenum, level, xoffset: TGLint, width: TGLsizei,
format, atype: TGLenum, pixels: pointer){.dynlib: dllname,
importc: "glTexSubImage1D".}
proc glTexSubImage2D*(target: TGLenum, level, xoffset, yoffset: TGLint,
width, height: TGLsizei, format, atype: TGLenum,
pixels: pointer){.dynlib: dllname,
proc glTexSubImage2D*(target: TGLenum, level, xoffset, yoffset: TGLint,
width, height: TGLsizei, format, atype: TGLenum,
pixels: pointer){.dynlib: dllname,
importc: "glTexSubImage2D".}
proc glTranslated*(x, y, z: TGLdouble){.dynlib: dllname, importc: "glTranslated".}
proc glTranslatef*(x, y, z: TGLfloat){.dynlib: dllname, importc: "glTranslatef".}
@ -1494,42 +1494,42 @@ proc glVertex4i*(x, y, z, w: TGLint){.dynlib: dllname, importc: "glVertex4i".}
proc glVertex4iv*(v: PGLint){.dynlib: dllname, importc: "glVertex4iv".}
proc glVertex4s*(x, y, z, w: TGLshort){.dynlib: dllname, importc: "glVertex4s".}
proc glVertex4sv*(v: PGLshort){.dynlib: dllname, importc: "glVertex4sv".}
proc glVertexPointer*(size: TGLint, atype: TGLenum, stride: TGLsizei,
p: pointer){.dynlib: dllname,
proc glVertexPointer*(size: TGLint, atype: TGLenum, stride: TGLsizei,
p: pointer){.dynlib: dllname,
importc: "glVertexPointer".}
proc glViewport*(x, y: TGLint, width, height: TGLsizei){.dynlib: dllname,
proc glViewport*(x, y: TGLint, width, height: TGLsizei){.dynlib: dllname,
importc: "glViewport".}
type
type
PFN_GLARRAY_ELEMENT_EXTPROC* = proc (i: TGLint)
PFN_GLDRAW_ARRAYS_EXTPROC* = proc (mode: TGLenum, first: TGLint,
PFN_GLDRAW_ARRAYS_EXTPROC* = proc (mode: TGLenum, first: TGLint,
count: TGLsizei)
PFN_GLVERTEX_POINTER_EXTPROC* = proc (size: TGLint, atype: TGLenum,
stride, count: TGLsizei,
PFN_GLVERTEX_POINTER_EXTPROC* = proc (size: TGLint, atype: TGLenum,
stride, count: TGLsizei,
p: pointer)
PFN_GLNORMAL_POINTER_EXTPROC* = proc (atype: TGLenum, stride, count: TGLsizei,
PFN_GLNORMAL_POINTER_EXTPROC* = proc (atype: TGLenum, stride, count: TGLsizei,
p: pointer)
PFN_GLCOLOR_POINTER_EXTPROC* = proc (size: TGLint, atype: TGLenum,
PFN_GLCOLOR_POINTER_EXTPROC* = proc (size: TGLint, atype: TGLenum,
stride, count: TGLsizei, p: pointer)
PFN_GLINDEX_POINTER_EXTPROC* = proc (atype: TGLenum, stride, count: TGLsizei,
PFN_GLINDEX_POINTER_EXTPROC* = proc (atype: TGLenum, stride, count: TGLsizei,
p: pointer)
PFN_GLTEXCOORD_POINTER_EXTPROC* = proc (size: TGLint, atype: TGLenum,
PFN_GLTEXCOORD_POINTER_EXTPROC* = proc (size: TGLint, atype: TGLenum,
stride, count: TGLsizei, p: pointer)
PFN_GLEDGEFLAG_POINTER_EXTPROC* = proc (stride, count: TGLsizei,
PFN_GLEDGEFLAG_POINTER_EXTPROC* = proc (stride, count: TGLsizei,
pointer: PGLboolean)
PFN_GLGET_POINTER_VEXT_PROC* = proc (pname: TGLenum, params: pointer)
PFN_GLARRAY_ELEMENT_ARRAY_EXTPROC* = proc (mode: TGLenum, count: TGLsizei,
PFN_GLARRAY_ELEMENT_ARRAY_EXTPROC* = proc (mode: TGLenum, count: TGLsizei,
pi: pointer) # WIN_swap_hint
PFN_GLADDSWAPHINT_RECT_WINPROC* = proc (x, y: TGLint, width, height: TGLsizei)
PFN_GLCOLOR_TABLE_EXTPROC* = proc (target, internalFormat: TGLenum,
width: TGLsizei, format, atype: TGLenum,
PFN_GLCOLOR_TABLE_EXTPROC* = proc (target, internalFormat: TGLenum,
width: TGLsizei, format, atype: TGLenum,
data: pointer)
PFN_GLCOLOR_SUBTABLE_EXTPROC* = proc (target: TGLenum, start, count: TGLsizei,
PFN_GLCOLOR_SUBTABLE_EXTPROC* = proc (target: TGLenum, start, count: TGLsizei,
format, atype: TGLenum, data: pointer)
PFN_GLGETCOLOR_TABLE_EXTPROC* = proc (target, format, atype: TGLenum,
PFN_GLGETCOLOR_TABLE_EXTPROC* = proc (target, format, atype: TGLenum,
data: pointer)
PFN_GLGETCOLOR_TABLE_PARAMETER_IVEXTPROC* = proc (target, pname: TGLenum,
PFN_GLGETCOLOR_TABLE_PARAMETER_IVEXTPROC* = proc (target, pname: TGLenum,
params: PGLint)
PFN_GLGETCOLOR_TABLE_PARAMETER_FVEXTPROC* = proc (target, pname: TGLenum,
PFN_GLGETCOLOR_TABLE_PARAMETER_FVEXTPROC* = proc (target, pname: TGLenum,
params: PGLfloat)
{.pop.}

2334
tests/manyloc/keineschweine/lib/glext.nim
View file

File diff suppressed because it is too large Load diff

134
tests/manyloc/keineschweine/lib/glu.nim
View file

@ -4,28 +4,28 @@
# Sebastian Guenther (sg@freepascal.org) in 2002
# These units are free to use
#******************************************************************************
# Converted to Delphi by Tom Nuydens (tom@delphi3d.net)
# For the latest updates, visit Delphi3D: http://www.delphi3d.net
# Converted to Delphi by Tom Nuydens (tom@delphi3d.net)
# For the latest updates, visit Delphi3D: http://www.delphi3d.net
#******************************************************************************
import
import
GL
when defined(windows):
when defined(windows):
{.push, callconv: stdcall.}
else:
else:
{.push, callconv: cdecl.}
when defined(windows):
const
when defined(windows):
const
dllname = "glu32.dll"
elif defined(macosx):
const
elif defined(macosx):
const
dllname = "/System/Library/Frameworks/OpenGL.framework/Libraries/libGLU.dylib"
else:
const
else:
const
dllname = "libGLU.so.1"
type
type
TViewPortArray* = array[0..3, TGLint]
T16dArray* = array[0..15, TGLdouble]
TCallBack* = proc ()
@ -34,12 +34,12 @@ type
T4fArray* = array[0..3, TGLfloat]
PPointer* = ptr Pointer
type
GLUnurbs*{.final.} = object
type
GLUnurbs*{.final.} = object
PGLUnurbs* = ptr GLUnurbs
GLUquadric*{.final.} = object
GLUquadric*{.final.} = object
PGLUquadric* = ptr GLUquadric
GLUtesselator*{.final.} = object
GLUtesselator*{.final.} = object
PGLUtesselator* = ptr GLUtesselator # backwards compatibility:
GLUnurbsObj* = GLUnurbs
PGLUnurbsObj* = PGLUnurbs
@ -57,40 +57,40 @@ type
TGLUtesselatorObj* = GLUtesselatorObj
TGLUtriangulatorObj* = GLUtriangulatorObj
proc gluErrorString*(errCode: TGLenum): cstring{.dynlib: dllname,
proc gluErrorString*(errCode: TGLenum): cstring{.dynlib: dllname,
importc: "gluErrorString".}
proc gluErrorUnicodeStringEXT*(errCode: TGLenum): ptr int16{.dynlib: dllname,
proc gluErrorUnicodeStringEXT*(errCode: TGLenum): ptr int16{.dynlib: dllname,
importc: "gluErrorUnicodeStringEXT".}
proc gluGetString*(name: TGLenum): cstring{.dynlib: dllname,
proc gluGetString*(name: TGLenum): cstring{.dynlib: dllname,
importc: "gluGetString".}
proc gluOrtho2D*(left, right, bottom, top: TGLdouble){.dynlib: dllname,
proc gluOrtho2D*(left, right, bottom, top: TGLdouble){.dynlib: dllname,
importc: "gluOrtho2D".}
proc gluPerspective*(fovy, aspect, zNear, zFar: TGLdouble){.dynlib: dllname,
proc gluPerspective*(fovy, aspect, zNear, zFar: TGLdouble){.dynlib: dllname,
importc: "gluPerspective".}
proc gluPickMatrix*(x, y, width, height: TGLdouble, viewport: var TViewPortArray){.
dynlib: dllname, importc: "gluPickMatrix".}
proc gluLookAt*(eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz: TGLdouble){.
dynlib: dllname, importc: "gluLookAt".}
proc gluProject*(objx, objy, objz: TGLdouble,
modelMatrix, projMatrix: var T16dArray,
proc gluProject*(objx, objy, objz: TGLdouble,
modelMatrix, projMatrix: var T16dArray,
viewport: var TViewPortArray, winx, winy, winz: PGLdouble): int{.
dynlib: dllname, importc: "gluProject".}
proc gluUnProject*(winx, winy, winz: TGLdouble,
modelMatrix, projMatrix: var T16dArray,
proc gluUnProject*(winx, winy, winz: TGLdouble,
modelMatrix, projMatrix: var T16dArray,
viewport: var TViewPortArray, objx, objy, objz: PGLdouble): int{.
dynlib: dllname, importc: "gluUnProject".}
proc gluScaleImage*(format: TGLenum, widthin, heightin: TGLint, typein: TGLenum,
datain: Pointer, widthout, heightout: TGLint,
typeout: TGLenum, dataout: Pointer): int{.dynlib: dllname,
proc gluScaleImage*(format: TGLenum, widthin, heightin: TGLint, typein: TGLenum,
datain: Pointer, widthout, heightout: TGLint,
typeout: TGLenum, dataout: Pointer): int{.dynlib: dllname,
importc: "gluScaleImage".}
proc gluBuild1DMipmaps*(target: TGLenum, components, width: TGLint,
proc gluBuild1DMipmaps*(target: TGLenum, components, width: TGLint,
format, atype: TGLenum, data: Pointer): int{.
dynlib: dllname, importc: "gluBuild1DMipmaps".}
proc gluBuild2DMipmaps*(target: TGLenum, components, width, height: TGLint,
proc gluBuild2DMipmaps*(target: TGLenum, components, width, height: TGLint,
format, atype: TGLenum, data: Pointer): int{.
dynlib: dllname, importc: "gluBuild2DMipmaps".}
proc gluNewQuadric*(): PGLUquadric{.dynlib: dllname, importc: "gluNewQuadric".}
proc gluDeleteQuadric*(state: PGLUquadric){.dynlib: dllname,
proc gluDeleteQuadric*(state: PGLUquadric){.dynlib: dllname,
importc: "gluDeleteQuadric".}
proc gluQuadricNormals*(quadObject: PGLUquadric, normals: TGLenum){.
dynlib: dllname, importc: "gluQuadricNormals".}
@ -100,12 +100,12 @@ proc gluQuadricOrientation*(quadObject: PGLUquadric, orientation: TGLenum){.
dynlib: dllname, importc: "gluQuadricOrientation".}
proc gluQuadricDrawStyle*(quadObject: PGLUquadric, drawStyle: TGLenum){.
dynlib: dllname, importc: "gluQuadricDrawStyle".}
proc gluCylinder*(qobj: PGLUquadric, baseRadius, topRadius, height: TGLdouble,
slices, stacks: TGLint){.dynlib: dllname,
proc gluCylinder*(qobj: PGLUquadric, baseRadius, topRadius, height: TGLdouble,
slices, stacks: TGLint){.dynlib: dllname,
importc: "gluCylinder".}
proc gluDisk*(qobj: PGLUquadric, innerRadius, outerRadius: TGLdouble,
proc gluDisk*(qobj: PGLUquadric, innerRadius, outerRadius: TGLdouble,
slices, loops: TGLint){.dynlib: dllname, importc: "gluDisk".}
proc gluPartialDisk*(qobj: PGLUquadric, innerRadius, outerRadius: TGLdouble,
proc gluPartialDisk*(qobj: PGLUquadric, innerRadius, outerRadius: TGLdouble,
slices, loops: TGLint, startAngle, sweepAngle: TGLdouble){.
dynlib: dllname, importc: "gluPartialDisk".}
proc gluSphere*(qobj: PGLuquadric, radius: TGLdouble, slices, stacks: TGLint){.
@ -113,51 +113,51 @@ proc gluSphere*(qobj: PGLuquadric, radius: TGLdouble, slices, stacks: TGLint){.
proc gluQuadricCallback*(qobj: PGLUquadric, which: TGLenum, fn: TCallBack){.
dynlib: dllname, importc: "gluQuadricCallback".}
proc gluNewTess*(): PGLUtesselator{.dynlib: dllname, importc: "gluNewTess".}
proc gluDeleteTess*(tess: PGLUtesselator){.dynlib: dllname,
proc gluDeleteTess*(tess: PGLUtesselator){.dynlib: dllname,
importc: "gluDeleteTess".}
proc gluTessBeginPolygon*(tess: PGLUtesselator, polygon_data: Pointer){.
dynlib: dllname, importc: "gluTessBeginPolygon".}
proc gluTessBeginContour*(tess: PGLUtesselator){.dynlib: dllname,
proc gluTessBeginContour*(tess: PGLUtesselator){.dynlib: dllname,
importc: "gluTessBeginContour".}
proc gluTessVertex*(tess: PGLUtesselator, coords: var T3dArray, data: Pointer){.
dynlib: dllname, importc: "gluTessVertex".}
proc gluTessEndContour*(tess: PGLUtesselator){.dynlib: dllname,
proc gluTessEndContour*(tess: PGLUtesselator){.dynlib: dllname,
importc: "gluTessEndContour".}
proc gluTessEndPolygon*(tess: PGLUtesselator){.dynlib: dllname,
proc gluTessEndPolygon*(tess: PGLUtesselator){.dynlib: dllname,
importc: "gluTessEndPolygon".}
proc gluTessProperty*(tess: PGLUtesselator, which: TGLenum, value: TGLdouble){.
dynlib: dllname, importc: "gluTessProperty".}
proc gluTessNormal*(tess: PGLUtesselator, x, y, z: TGLdouble){.dynlib: dllname,
proc gluTessNormal*(tess: PGLUtesselator, x, y, z: TGLdouble){.dynlib: dllname,
importc: "gluTessNormal".}
proc gluTessCallback*(tess: PGLUtesselator, which: TGLenum, fn: TCallBack){.
dynlib: dllname, importc: "gluTessCallback".}
proc gluGetTessProperty*(tess: PGLUtesselator, which: TGLenum, value: PGLdouble){.
dynlib: dllname, importc: "gluGetTessProperty".}
proc gluNewNurbsRenderer*(): PGLUnurbs{.dynlib: dllname,
proc gluNewNurbsRenderer*(): PGLUnurbs{.dynlib: dllname,
importc: "gluNewNurbsRenderer".}
proc gluDeleteNurbsRenderer*(nobj: PGLUnurbs){.dynlib: dllname,
proc gluDeleteNurbsRenderer*(nobj: PGLUnurbs){.dynlib: dllname,
importc: "gluDeleteNurbsRenderer".}
proc gluBeginSurface*(nobj: PGLUnurbs){.dynlib: dllname,
proc gluBeginSurface*(nobj: PGLUnurbs){.dynlib: dllname,
importc: "gluBeginSurface".}
proc gluBeginCurve*(nobj: PGLUnurbs){.dynlib: dllname, importc: "gluBeginCurve".}
proc gluEndCurve*(nobj: PGLUnurbs){.dynlib: dllname, importc: "gluEndCurve".}
proc gluEndSurface*(nobj: PGLUnurbs){.dynlib: dllname, importc: "gluEndSurface".}
proc gluBeginTrim*(nobj: PGLUnurbs){.dynlib: dllname, importc: "gluBeginTrim".}
proc gluEndTrim*(nobj: PGLUnurbs){.dynlib: dllname, importc: "gluEndTrim".}
proc gluPwlCurve*(nobj: PGLUnurbs, count: TGLint, aarray: PGLfloat,
stride: TGLint, atype: TGLenum){.dynlib: dllname,
proc gluPwlCurve*(nobj: PGLUnurbs, count: TGLint, aarray: PGLfloat,
stride: TGLint, atype: TGLenum){.dynlib: dllname,
importc: "gluPwlCurve".}
proc gluNurbsCurve*(nobj: PGLUnurbs, nknots: TGLint, knot: PGLfloat,
stride: TGLint, ctlarray: PGLfloat, order: TGLint,
proc gluNurbsCurve*(nobj: PGLUnurbs, nknots: TGLint, knot: PGLfloat,
stride: TGLint, ctlarray: PGLfloat, order: TGLint,
atype: TGLenum){.dynlib: dllname, importc: "gluNurbsCurve".}
proc gluNurbsSurface*(nobj: PGLUnurbs, sknot_count: TGLint, sknot: PGLfloat,
tknot_count: TGLint, tknot: PGLfloat,
s_stride, t_stride: TGLint, ctlarray: PGLfloat,
sorder, torder: TGLint, atype: TGLenum){.dynlib: dllname,
proc gluNurbsSurface*(nobj: PGLUnurbs, sknot_count: TGLint, sknot: PGLfloat,
tknot_count: TGLint, tknot: PGLfloat,
s_stride, t_stride: TGLint, ctlarray: PGLfloat,
sorder, torder: TGLint, atype: TGLenum){.dynlib: dllname,
importc: "gluNurbsSurface".}
proc gluLoadSamplingMatrices*(nobj: PGLUnurbs,
modelMatrix, projMatrix: var T16dArray,
viewport: var TViewPortArray){.dynlib: dllname,
proc gluLoadSamplingMatrices*(nobj: PGLUnurbs,
modelMatrix, projMatrix: var T16dArray,
viewport: var TViewPortArray){.dynlib: dllname,
importc: "gluLoadSamplingMatrices".}
proc gluNurbsProperty*(nobj: PGLUnurbs, aproperty: TGLenum, value: TGLfloat){.
dynlib: dllname, importc: "gluNurbsProperty".}
@ -173,16 +173,16 @@ type # gluQuadricCallback
GLUtessVertexProc* = proc (p: Pointer)
GLUtessEndProc* = proc ()
GLUtessErrorProc* = proc (p: TGLenum)
GLUtessCombineProc* = proc (p1: var T3dArray, p2: T4pArray, p3: T4fArray,
GLUtessCombineProc* = proc (p1: var T3dArray, p2: T4pArray, p3: T4fArray,
p4: PPointer)
GLUtessBeginDataProc* = proc (p1: TGLenum, p2: Pointer)
GLUtessEdgeFlagDataProc* = proc (p1: TGLboolean, p2: Pointer)
GLUtessVertexDataProc* = proc (p1, p2: Pointer)
GLUtessEndDataProc* = proc (p: Pointer)
GLUtessErrorDataProc* = proc (p1: TGLenum, p2: Pointer)
GLUtessCombineDataProc* = proc (p1: var T3dArray, p2: var T4pArray,
p3: var T4fArray, p4: PPointer, p5: Pointer) #
#
GLUtessCombineDataProc* = proc (p1: var T3dArray, p2: var T4pArray,
p3: var T4fArray, p4: PPointer, p5: Pointer) #
#
# gluNurbsCallback
GLUnurbsErrorProc* = proc (p: TGLenum) #*** Generic constants ****/
@ -226,21 +226,21 @@ const # Version
GLU_TESS_COMBINE* = 100105 # void (CALLBACK*)(TGLdouble coords[3],
# void *data[4],
# TGLfloat weight[4],
# void **dataOut)
# void **dataOut)
GLU_TESS_BEGIN_DATA* = 100106 # void (CALLBACK*)(TGLenum type,
# void *polygon_data)
# void *polygon_data)
GLU_TESS_VERTEX_DATA* = 100107 # void (CALLBACK*)(void *data,
# void *polygon_data)
# void *polygon_data)
GLU_TESS_END_DATA* = 100108 # void (CALLBACK*)(void *polygon_data)
GLU_TESS_ERROR_DATA* = 100109 # void (CALLBACK*)(TGLenum errno,
# void *polygon_data)
# void *polygon_data)
GLU_TESS_EDGE_FLAG_DATA* = 100110 # void (CALLBACK*)(TGLboolean boundaryEdge,
# void *polygon_data)
# void *polygon_data)
GLU_TESS_COMBINE_DATA* = 100111 # void (CALLBACK*)(TGLdouble coords[3],
# void *data[4],
# TGLfloat weight[4],
# void **dataOut,
# void *polygon_data)
# void *polygon_data)
# TessError
GLU_TESS_ERROR1* = 100151
GLU_TESS_ERROR2* = 100152
@ -313,11 +313,11 @@ const # Version
GLU_NURBS_ERROR36* = 100286
GLU_NURBS_ERROR37* = 100287 #*** Backwards compatibility for old tesselator ****/
proc gluBeginPolygon*(tess: PGLUtesselator){.dynlib: dllname,
proc gluBeginPolygon*(tess: PGLUtesselator){.dynlib: dllname,
importc: "gluBeginPolygon".}
proc gluNextContour*(tess: PGLUtesselator, atype: TGLenum){.dynlib: dllname,
proc gluNextContour*(tess: PGLUtesselator, atype: TGLenum){.dynlib: dllname,
importc: "gluNextContour".}
proc gluEndPolygon*(tess: PGLUtesselator){.dynlib: dllname,
proc gluEndPolygon*(tess: PGLUtesselator){.dynlib: dllname,
importc: "gluEndPolygon".}
const # Contours types -- obsolete!
GLU_CW* = 100120

140
tests/manyloc/keineschweine/lib/glut.nim
View file

@ -15,17 +15,17 @@
# For the latest updates, visit Delphi3D: http://www.delphi3d.net
#******************************************************************************
import
import
GL
when defined(windows):
const
when defined(windows):
const
dllname = "glut32.dll"
elif defined(macosx):
const
elif defined(macosx):
const
dllname = "/System/Library/Frameworks/GLUT.framework/GLUT"
else:
const
else:
const
dllname = "libglut.so.3"
type
TGlutVoidCallback* = proc (){.cdecl.}
@ -36,7 +36,7 @@ type
TGlut1Char2IntCallback* = proc (c: int8, v1, v2: cint){.cdecl.}
TGlut1UInt3IntCallback* = proc (u, v1, v2, v3: cint){.cdecl.}
const
const
GLUT_API_VERSION* = 3
GLUT_XLIB_IMPLEMENTATION* = 12 # Display mode bit masks.
GLUT_RGB* = 0
@ -93,7 +93,7 @@ const
GLUT_NORMAL* = 0
GLUT_OVERLAY* = 1
when defined(Windows):
when defined(Windows):
const # Stroke font constants (use these in GLUT program).
GLUT_STROKE_ROMAN* = cast[Pointer](0)
GLUT_STROKE_MONO_ROMAN* = cast[Pointer](1) # Bitmap font constants (use these in GLUT program).
@ -104,7 +104,7 @@ when defined(Windows):
GLUT_BITMAP_HELVETICA_10* = cast[Pointer](6)
GLUT_BITMAP_HELVETICA_12* = cast[Pointer](7)
GLUT_BITMAP_HELVETICA_18* = cast[Pointer](8)
else:
else:
var # Stroke font constants (use these in GLUT program).
GLUT_STROKE_ROMAN*: Pointer
GLUT_STROKE_MONO_ROMAN*: Pointer # Bitmap font constants (use these in GLUT program).
@ -229,7 +229,7 @@ const # glutGet parameters.
GLUT_GAME_MODE_REFRESH_RATE* = 5
GLUT_GAME_MODE_DISPLAY_CHANGED* = 6 # GLUT initialization sub-API.
proc glutInit*(argcp: ptr cint, argv: pointer){.dynlib: dllname,
proc glutInit*(argcp: ptr cint, argv: pointer){.dynlib: dllname,
importc: "glutInit".}
proc glutInit*() =
@ -239,34 +239,34 @@ proc glutInit*() =
cmdCount {.importc: "cmdCount".}: cint
glutInit(addr(cmdCount), addr(cmdLine))
proc glutInitDisplayMode*(mode: int16){.dynlib: dllname,
proc glutInitDisplayMode*(mode: int16){.dynlib: dllname,
importc: "glutInitDisplayMode".}
proc glutInitDisplayString*(str: cstring){.dynlib: dllname,
proc glutInitDisplayString*(str: cstring){.dynlib: dllname,
importc: "glutInitDisplayString".}
proc glutInitWindowPosition*(x, y: int){.dynlib: dllname,
proc glutInitWindowPosition*(x, y: int){.dynlib: dllname,
importc: "glutInitWindowPosition".}
proc glutInitWindowSize*(width, height: int){.dynlib: dllname,
proc glutInitWindowSize*(width, height: int){.dynlib: dllname,
importc: "glutInitWindowSize".}
proc glutMainLoop*(){.dynlib: dllname, importc: "glutMainLoop".}
# GLUT window sub-API.
proc glutCreateWindow*(title: cstring): int{.dynlib: dllname,
proc glutCreateWindow*(title: cstring): int{.dynlib: dllname,
importc: "glutCreateWindow".}
proc glutCreateSubWindow*(win, x, y, width, height: int): int{.dynlib: dllname,
proc glutCreateSubWindow*(win, x, y, width, height: int): int{.dynlib: dllname,
importc: "glutCreateSubWindow".}
proc glutDestroyWindow*(win: int){.dynlib: dllname, importc: "glutDestroyWindow".}
proc glutPostRedisplay*(){.dynlib: dllname, importc: "glutPostRedisplay".}
proc glutPostWindowRedisplay*(win: int){.dynlib: dllname,
proc glutPostWindowRedisplay*(win: int){.dynlib: dllname,
importc: "glutPostWindowRedisplay".}
proc glutSwapBuffers*(){.dynlib: dllname, importc: "glutSwapBuffers".}
proc glutGetWindow*(): int{.dynlib: dllname, importc: "glutGetWindow".}
proc glutSetWindow*(win: int){.dynlib: dllname, importc: "glutSetWindow".}
proc glutSetWindowTitle*(title: cstring){.dynlib: dllname,
proc glutSetWindowTitle*(title: cstring){.dynlib: dllname,
importc: "glutSetWindowTitle".}
proc glutSetIconTitle*(title: cstring){.dynlib: dllname,
proc glutSetIconTitle*(title: cstring){.dynlib: dllname,
importc: "glutSetIconTitle".}
proc glutPositionWindow*(x, y: int){.dynlib: dllname,
proc glutPositionWindow*(x, y: int){.dynlib: dllname,
importc: "glutPositionWindow".}
proc glutReshapeWindow*(width, height: int){.dynlib: dllname,
proc glutReshapeWindow*(width, height: int){.dynlib: dllname,
importc: "glutReshapeWindow".}
proc glutPopWindow*(){.dynlib: dllname, importc: "glutPopWindow".}
proc glutPushWindow*(){.dynlib: dllname, importc: "glutPushWindow".}
@ -280,107 +280,107 @@ proc glutWarpPointer*(x, y: int){.dynlib: dllname, importc: "glutWarpPointer".}
proc glutEstablishOverlay*(){.dynlib: dllname, importc: "glutEstablishOverlay".}
proc glutRemoveOverlay*(){.dynlib: dllname, importc: "glutRemoveOverlay".}
proc glutUseLayer*(layer: TGLenum){.dynlib: dllname, importc: "glutUseLayer".}
proc glutPostOverlayRedisplay*(){.dynlib: dllname,
proc glutPostOverlayRedisplay*(){.dynlib: dllname,
importc: "glutPostOverlayRedisplay".}
proc glutPostWindowOverlayRedisplay*(win: int){.dynlib: dllname,
proc glutPostWindowOverlayRedisplay*(win: int){.dynlib: dllname,
importc: "glutPostWindowOverlayRedisplay".}
proc glutShowOverlay*(){.dynlib: dllname, importc: "glutShowOverlay".}
proc glutHideOverlay*(){.dynlib: dllname, importc: "glutHideOverlay".}
# GLUT menu sub-API.
proc glutCreateMenu*(callback: TGlut1IntCallback): int{.dynlib: dllname,
proc glutCreateMenu*(callback: TGlut1IntCallback): int{.dynlib: dllname,
importc: "glutCreateMenu".}
proc glutDestroyMenu*(menu: int){.dynlib: dllname, importc: "glutDestroyMenu".}
proc glutGetMenu*(): int{.dynlib: dllname, importc: "glutGetMenu".}
proc glutSetMenu*(menu: int){.dynlib: dllname, importc: "glutSetMenu".}
proc glutAddMenuEntry*(caption: cstring, value: int){.dynlib: dllname,
proc glutAddMenuEntry*(caption: cstring, value: int){.dynlib: dllname,
importc: "glutAddMenuEntry".}
proc glutAddSubMenu*(caption: cstring, submenu: int){.dynlib: dllname,
proc glutAddSubMenu*(caption: cstring, submenu: int){.dynlib: dllname,
importc: "glutAddSubMenu".}
proc glutChangeToMenuEntry*(item: int, caption: cstring, value: int){.
dynlib: dllname, importc: "glutChangeToMenuEntry".}
proc glutChangeToSubMenu*(item: int, caption: cstring, submenu: int){.
dynlib: dllname, importc: "glutChangeToSubMenu".}
proc glutRemoveMenuItem*(item: int){.dynlib: dllname,
proc glutRemoveMenuItem*(item: int){.dynlib: dllname,
importc: "glutRemoveMenuItem".}
proc glutAttachMenu*(button: int){.dynlib: dllname, importc: "glutAttachMenu".}
proc glutDetachMenu*(button: int){.dynlib: dllname, importc: "glutDetachMenu".}
# GLUT window callback sub-API.
proc glutDisplayFunc*(f: TGlutVoidCallback){.dynlib: dllname,
proc glutDisplayFunc*(f: TGlutVoidCallback){.dynlib: dllname,
importc: "glutDisplayFunc".}
proc glutReshapeFunc*(f: TGlut2IntCallback){.dynlib: dllname,
proc glutReshapeFunc*(f: TGlut2IntCallback){.dynlib: dllname,
importc: "glutReshapeFunc".}
proc glutKeyboardFunc*(f: TGlut1Char2IntCallback){.dynlib: dllname,
proc glutKeyboardFunc*(f: TGlut1Char2IntCallback){.dynlib: dllname,
importc: "glutKeyboardFunc".}
proc glutMouseFunc*(f: TGlut4IntCallback){.dynlib: dllname,
proc glutMouseFunc*(f: TGlut4IntCallback){.dynlib: dllname,
importc: "glutMouseFunc".}
proc glutMotionFunc*(f: TGlut2IntCallback){.dynlib: dllname,
proc glutMotionFunc*(f: TGlut2IntCallback){.dynlib: dllname,
importc: "glutMotionFunc".}
proc glutPassiveMotionFunc*(f: TGlut2IntCallback){.dynlib: dllname,
proc glutPassiveMotionFunc*(f: TGlut2IntCallback){.dynlib: dllname,
importc: "glutPassiveMotionFunc".}
proc glutEntryFunc*(f: TGlut1IntCallback){.dynlib: dllname,
proc glutEntryFunc*(f: TGlut1IntCallback){.dynlib: dllname,
importc: "glutEntryFunc".}
proc glutVisibilityFunc*(f: TGlut1IntCallback){.dynlib: dllname,
proc glutVisibilityFunc*(f: TGlut1IntCallback){.dynlib: dllname,
importc: "glutVisibilityFunc".}
proc glutIdleFunc*(f: TGlutVoidCallback){.dynlib: dllname,
proc glutIdleFunc*(f: TGlutVoidCallback){.dynlib: dllname,
importc: "glutIdleFunc".}
proc glutTimerFunc*(millis: int16, f: TGlut1IntCallback, value: int){.
dynlib: dllname, importc: "glutTimerFunc".}
proc glutMenuStateFunc*(f: TGlut1IntCallback){.dynlib: dllname,
proc glutMenuStateFunc*(f: TGlut1IntCallback){.dynlib: dllname,
importc: "glutMenuStateFunc".}
proc glutSpecialFunc*(f: TGlut3IntCallback){.dynlib: dllname,
proc glutSpecialFunc*(f: TGlut3IntCallback){.dynlib: dllname,
importc: "glutSpecialFunc".}
proc glutSpaceballMotionFunc*(f: TGlut3IntCallback){.dynlib: dllname,
proc glutSpaceballMotionFunc*(f: TGlut3IntCallback){.dynlib: dllname,
importc: "glutSpaceballMotionFunc".}
proc glutSpaceballRotateFunc*(f: TGlut3IntCallback){.dynlib: dllname,
proc glutSpaceballRotateFunc*(f: TGlut3IntCallback){.dynlib: dllname,
importc: "glutSpaceballRotateFunc".}
proc glutSpaceballButtonFunc*(f: TGlut2IntCallback){.dynlib: dllname,
proc glutSpaceballButtonFunc*(f: TGlut2IntCallback){.dynlib: dllname,
importc: "glutSpaceballButtonFunc".}
proc glutButtonBoxFunc*(f: TGlut2IntCallback){.dynlib: dllname,
proc glutButtonBoxFunc*(f: TGlut2IntCallback){.dynlib: dllname,
importc: "glutButtonBoxFunc".}
proc glutDialsFunc*(f: TGlut2IntCallback){.dynlib: dllname,
proc glutDialsFunc*(f: TGlut2IntCallback){.dynlib: dllname,
importc: "glutDialsFunc".}
proc glutTabletMotionFunc*(f: TGlut2IntCallback){.dynlib: dllname,
proc glutTabletMotionFunc*(f: TGlut2IntCallback){.dynlib: dllname,
importc: "glutTabletMotionFunc".}
proc glutTabletButtonFunc*(f: TGlut4IntCallback){.dynlib: dllname,
proc glutTabletButtonFunc*(f: TGlut4IntCallback){.dynlib: dllname,
importc: "glutTabletButtonFunc".}
proc glutMenuStatusFunc*(f: TGlut3IntCallback){.dynlib: dllname,
proc glutMenuStatusFunc*(f: TGlut3IntCallback){.dynlib: dllname,
importc: "glutMenuStatusFunc".}
proc glutOverlayDisplayFunc*(f: TGlutVoidCallback){.dynlib: dllname,
proc glutOverlayDisplayFunc*(f: TGlutVoidCallback){.dynlib: dllname,
importc: "glutOverlayDisplayFunc".}
proc glutWindowStatusFunc*(f: TGlut1IntCallback){.dynlib: dllname,
proc glutWindowStatusFunc*(f: TGlut1IntCallback){.dynlib: dllname,
importc: "glutWindowStatusFunc".}
proc glutKeyboardUpFunc*(f: TGlut1Char2IntCallback){.dynlib: dllname,
proc glutKeyboardUpFunc*(f: TGlut1Char2IntCallback){.dynlib: dllname,
importc: "glutKeyboardUpFunc".}
proc glutSpecialUpFunc*(f: TGlut3IntCallback){.dynlib: dllname,
proc glutSpecialUpFunc*(f: TGlut3IntCallback){.dynlib: dllname,
importc: "glutSpecialUpFunc".}
proc glutJoystickFunc*(f: TGlut1UInt3IntCallback, pollInterval: int){.
dynlib: dllname, importc: "glutJoystickFunc".}
# GLUT color index sub-API.
proc glutSetColor*(cell: int, red, green, blue: TGLfloat){.dynlib: dllname,
proc glutSetColor*(cell: int, red, green, blue: TGLfloat){.dynlib: dllname,
importc: "glutSetColor".}
proc glutGetColor*(ndx, component: int): TGLfloat{.dynlib: dllname,
proc glutGetColor*(ndx, component: int): TGLfloat{.dynlib: dllname,
importc: "glutGetColor".}
proc glutCopyColormap*(win: int){.dynlib: dllname, importc: "glutCopyColormap".}
# GLUT state retrieval sub-API.
proc glutGet*(t: TGLenum): int{.dynlib: dllname, importc: "glutGet".}
proc glutDeviceGet*(t: TGLenum): int{.dynlib: dllname, importc: "glutDeviceGet".}
# GLUT extension support sub-API
proc glutExtensionSupported*(name: cstring): int{.dynlib: dllname,
proc glutExtensionSupported*(name: cstring): int{.dynlib: dllname,
importc: "glutExtensionSupported".}
proc glutGetModifiers*(): int{.dynlib: dllname, importc: "glutGetModifiers".}
proc glutLayerGet*(t: TGLenum): int{.dynlib: dllname, importc: "glutLayerGet".}
# GLUT font sub-API
proc glutBitmapCharacter*(font: pointer, character: int){.dynlib: dllname,
proc glutBitmapCharacter*(font: pointer, character: int){.dynlib: dllname,
importc: "glutBitmapCharacter".}
proc glutBitmapWidth*(font: pointer, character: int): int{.dynlib: dllname,
proc glutBitmapWidth*(font: pointer, character: int): int{.dynlib: dllname,
importc: "glutBitmapWidth".}
proc glutStrokeCharacter*(font: pointer, character: int){.dynlib: dllname,
proc glutStrokeCharacter*(font: pointer, character: int){.dynlib: dllname,
importc: "glutStrokeCharacter".}
proc glutStrokeWidth*(font: pointer, character: int): int{.dynlib: dllname,
proc glutStrokeWidth*(font: pointer, character: int): int{.dynlib: dllname,
importc: "glutStrokeWidth".}
proc glutBitmapLength*(font: pointer, str: cstring): int{.dynlib: dllname,
proc glutBitmapLength*(font: pointer, str: cstring): int{.dynlib: dllname,
importc: "glutBitmapLength".}
proc glutStrokeLength*(font: pointer, str: cstring): int{.dynlib: dllname,
proc glutStrokeLength*(font: pointer, str: cstring): int{.dynlib: dllname,
importc: "glutStrokeLength".}
# GLUT pre-built models sub-API
proc glutWireSphere*(radius: TGLdouble, slices, stacks: TGLint){.
@ -399,9 +399,9 @@ proc glutSolidTorus*(innerRadius, outerRadius: TGLdouble, sides, rings: TGLint){
dynlib: dllname, importc: "glutSolidTorus".}
proc glutWireDodecahedron*(){.dynlib: dllname, importc: "glutWireDodecahedron".}
proc glutSolidDodecahedron*(){.dynlib: dllname, importc: "glutSolidDodecahedron".}
proc glutWireTeapot*(size: TGLdouble){.dynlib: dllname,
proc glutWireTeapot*(size: TGLdouble){.dynlib: dllname,
importc: "glutWireTeapot".}
proc glutSolidTeapot*(size: TGLdouble){.dynlib: dllname,
proc glutSolidTeapot*(size: TGLdouble){.dynlib: dllname,
importc: "glutSolidTeapot".}
proc glutWireOctahedron*(){.dynlib: dllname, importc: "glutWireOctahedron".}
proc glutSolidOctahedron*(){.dynlib: dllname, importc: "glutSolidOctahedron".}
@ -410,29 +410,29 @@ proc glutSolidTetrahedron*(){.dynlib: dllname, importc: "glutSolidTetrahedron".}
proc glutWireIcosahedron*(){.dynlib: dllname, importc: "glutWireIcosahedron".}
proc glutSolidIcosahedron*(){.dynlib: dllname, importc: "glutSolidIcosahedron".}
# GLUT video resize sub-API.
proc glutVideoResizeGet*(param: TGLenum): int{.dynlib: dllname,
proc glutVideoResizeGet*(param: TGLenum): int{.dynlib: dllname,
importc: "glutVideoResizeGet".}
proc glutSetupVideoResizing*(){.dynlib: dllname,
proc glutSetupVideoResizing*(){.dynlib: dllname,
importc: "glutSetupVideoResizing".}
proc glutStopVideoResizing*(){.dynlib: dllname, importc: "glutStopVideoResizing".}
proc glutVideoResize*(x, y, width, height: int){.dynlib: dllname,
proc glutVideoResize*(x, y, width, height: int){.dynlib: dllname,
importc: "glutVideoResize".}
proc glutVideoPan*(x, y, width, height: int){.dynlib: dllname,
proc glutVideoPan*(x, y, width, height: int){.dynlib: dllname,
importc: "glutVideoPan".}
# GLUT debugging sub-API.
proc glutReportErrors*(){.dynlib: dllname, importc: "glutReportErrors".}
# GLUT device control sub-API.
proc glutIgnoreKeyRepeat*(ignore: int){.dynlib: dllname,
proc glutIgnoreKeyRepeat*(ignore: int){.dynlib: dllname,
importc: "glutIgnoreKeyRepeat".}
proc glutSetKeyRepeat*(repeatMode: int){.dynlib: dllname,
proc glutSetKeyRepeat*(repeatMode: int){.dynlib: dllname,
importc: "glutSetKeyRepeat".}
proc glutForceJoystickFunc*(){.dynlib: dllname, importc: "glutForceJoystickFunc".}
# GLUT game mode sub-API.
#example glutGameModeString('1280x1024:32@75');
proc glutGameModeString*(AString: cstring){.dynlib: dllname,
proc glutGameModeString*(AString: cstring){.dynlib: dllname,
importc: "glutGameModeString".}
proc glutEnterGameMode*(): int{.dynlib: dllname, importc: "glutEnterGameMode".}
proc glutLeaveGameMode*(){.dynlib: dllname, importc: "glutLeaveGameMode".}
proc glutGameModeGet*(mode: TGLenum): int{.dynlib: dllname,
proc glutGameModeGet*(mode: TGLenum): int{.dynlib: dllname,
importc: "glutGameModeGet".}
# implementation

60
tests/manyloc/keineschweine/lib/glx.nim
View file

@ -23,19 +23,19 @@
# Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
#
import
import
X, XLib, XUtil, gl
when defined(windows):
const
when defined(windows):
const
dllname = "GL.dll"
elif defined(macosx):
const
elif defined(macosx):
const
dllname = "/usr/X11R6/lib/libGL.dylib"
else:
const
else:
const
dllname = "libGL.so"
const
const
GLX_USE_GL* = 1
GLX_BUFFER_SIZE* = 2
GLX_LEVEL* = 3
@ -98,55 +98,55 @@ type # From XLib:
proc glXChooseVisual*(dpy: PDisplay, screen: int, attribList: ptr int32): PXVisualInfo{.
cdecl, dynlib: dllname, importc: "glXChooseVisual".}
proc glXCreateContext*(dpy: PDisplay, vis: PXVisualInfo, shareList: GLXContext,
direct: bool): GLXContext{.cdecl, dynlib: dllname,
proc glXCreateContext*(dpy: PDisplay, vis: PXVisualInfo, shareList: GLXContext,
direct: bool): GLXContext{.cdecl, dynlib: dllname,
importc: "glXCreateContext".}
proc glXDestroyContext*(dpy: PDisplay, ctx: GLXContext){.cdecl, dynlib: dllname,
proc glXDestroyContext*(dpy: PDisplay, ctx: GLXContext){.cdecl, dynlib: dllname,
importc: "glXDestroyContext".}
proc glXMakeCurrent*(dpy: PDisplay, drawable: GLXDrawable, ctx: GLXContext): bool{.
cdecl, dynlib: dllname, importc: "glXMakeCurrent".}
proc glXCopyContext*(dpy: PDisplay, src, dst: GLXContext, mask: int32){.cdecl,
proc glXCopyContext*(dpy: PDisplay, src, dst: GLXContext, mask: int32){.cdecl,
dynlib: dllname, importc: "glXCopyContext".}
proc glXSwapBuffers*(dpy: PDisplay, drawable: GLXDrawable){.cdecl,
proc glXSwapBuffers*(dpy: PDisplay, drawable: GLXDrawable){.cdecl,
dynlib: dllname, importc: "glXSwapBuffers".}
proc glXCreateGLXPixmap*(dpy: PDisplay, visual: PXVisualInfo, pixmap: XPixmap): GLXPixmap{.
cdecl, dynlib: dllname, importc: "glXCreateGLXPixmap".}
proc glXDestroyGLXPixmap*(dpy: PDisplay, pixmap: GLXPixmap){.cdecl,
proc glXDestroyGLXPixmap*(dpy: PDisplay, pixmap: GLXPixmap){.cdecl,
dynlib: dllname, importc: "glXDestroyGLXPixmap".}
proc glXQueryExtension*(dpy: PDisplay, errorb, event: var int): bool{.cdecl,
proc glXQueryExtension*(dpy: PDisplay, errorb, event: var int): bool{.cdecl,
dynlib: dllname, importc: "glXQueryExtension".}
proc glXQueryVersion*(dpy: PDisplay, maj, min: var int): bool{.cdecl,
proc glXQueryVersion*(dpy: PDisplay, maj, min: var int): bool{.cdecl,
dynlib: dllname, importc: "glXQueryVersion".}
proc glXIsDirect*(dpy: PDisplay, ctx: GLXContext): bool{.cdecl, dynlib: dllname,
proc glXIsDirect*(dpy: PDisplay, ctx: GLXContext): bool{.cdecl, dynlib: dllname,
importc: "glXIsDirect".}
proc glXGetConfig*(dpy: PDisplay, visual: PXVisualInfo, attrib: int,
value: var int): int{.cdecl, dynlib: dllname,
proc glXGetConfig*(dpy: PDisplay, visual: PXVisualInfo, attrib: int,
value: var int): int{.cdecl, dynlib: dllname,
importc: "glXGetConfig".}
proc glXGetCurrentContext*(): GLXContext{.cdecl, dynlib: dllname,
proc glXGetCurrentContext*(): GLXContext{.cdecl, dynlib: dllname,
importc: "glXGetCurrentContext".}
proc glXGetCurrentDrawable*(): GLXDrawable{.cdecl, dynlib: dllname,
proc glXGetCurrentDrawable*(): GLXDrawable{.cdecl, dynlib: dllname,
importc: "glXGetCurrentDrawable".}
proc glXWaitGL*(){.cdecl, dynlib: dllname, importc: "glXWaitGL".}
proc glXWaitX*(){.cdecl, dynlib: dllname, importc: "glXWaitX".}
proc glXUseXFont*(font: XFont, first, count, list: int){.cdecl, dynlib: dllname,
proc glXUseXFont*(font: XFont, first, count, list: int){.cdecl, dynlib: dllname,
importc: "glXUseXFont".}
# GLX 1.1 and later
proc glXQueryExtensionsString*(dpy: PDisplay, screen: int): cstring{.cdecl,
proc glXQueryExtensionsString*(dpy: PDisplay, screen: int): cstring{.cdecl,
dynlib: dllname, importc: "glXQueryExtensionsString".}
proc glXQueryServerString*(dpy: PDisplay, screen, name: int): cstring{.cdecl,
proc glXQueryServerString*(dpy: PDisplay, screen, name: int): cstring{.cdecl,
dynlib: dllname, importc: "glXQueryServerString".}
proc glXGetClientString*(dpy: PDisplay, name: int): cstring{.cdecl,
proc glXGetClientString*(dpy: PDisplay, name: int): cstring{.cdecl,
dynlib: dllname, importc: "glXGetClientString".}
# Mesa GLX Extensions
proc glXCreateGLXPixmapMESA*(dpy: PDisplay, visual: PXVisualInfo,
proc glXCreateGLXPixmapMESA*(dpy: PDisplay, visual: PXVisualInfo,
pixmap: XPixmap, cmap: XColormap): GLXPixmap{.
cdecl, dynlib: dllname, importc: "glXCreateGLXPixmapMESA".}
proc glXReleaseBufferMESA*(dpy: PDisplay, d: GLXDrawable): bool{.cdecl,
proc glXReleaseBufferMESA*(dpy: PDisplay, d: GLXDrawable): bool{.cdecl,
dynlib: dllname, importc: "glXReleaseBufferMESA".}
proc glXCopySubBufferMESA*(dpy: PDisplay, drawbale: GLXDrawable,
x, y, width, height: int){.cdecl, dynlib: dllname,
proc glXCopySubBufferMESA*(dpy: PDisplay, drawbale: GLXDrawable,
x, y, width, height: int){.cdecl, dynlib: dllname,
importc: "glXCopySubBufferMESA".}
proc glXGetVideoSyncSGI*(counter: var int32): int{.cdecl, dynlib: dllname,
proc glXGetVideoSyncSGI*(counter: var int32): int{.cdecl, dynlib: dllname,
importc: "glXGetVideoSyncSGI".}
proc glXWaitVideoSyncSGI*(divisor, remainder: int, count: var int32): int{.
cdecl, dynlib: dllname, importc: "glXWaitVideoSyncSGI".}

2
tests/manyloc/keineschweine/lib/idgen.nim
View file

@ -5,7 +5,7 @@ type
freeIDs: seq[T]
EOutOfIDs* = object of EInvalidKey
#proc free[T](idg: PIDgen[T]) =
#proc free[T](idg: PIDgen[T]) =
# result.freeIDs = nil
proc newIDGen*[T: Ordinal](): PIDGen[T] =
new(result)#, free)

24
tests/manyloc/keineschweine/lib/input_helpers.nim
View file

@ -2,7 +2,7 @@ import
sfml, tables, hashes
type
TKeyEventKind* = enum down, up
TInputFinishedProc* = proc()
TInputFinishedProc* = proc()
TKeyCallback = proc()
PKeyClient* = ref object
onKeyDown: TTable[int32, TKeyCallback]
@ -18,7 +18,7 @@ var
activeClient: PKeyClient = nil
activeInput: PTextInput = nil
proc setActive*(client: PKeyClient) =
proc setActive*(client: PKeyClient) =
activeClient = client
echo("** set active client ", client.name)
proc newKeyClient*(name: string = "unnamed", setactive = false): PKeyClient =
@ -43,28 +43,28 @@ proc addKeyEvent*(key: TKeyCode, ev: TKeyEventKind) {.inline.} =
if activeClient.isNil: return
let k = key.int32
case ev
of down:
of down:
keyState[k] = true
if activeClient.onKeyDown.hasKey(k):
activeClient.onKeyDown[k]()
else:
else:
keyState[k] = false
if activeClient.onKeyUp.hasKey(k):
activeClient.onKeyUp[k]()
proc addButtonEvent*(btn: TMouseButton, ev: TKeyEventKind) {.inline.} =
if activeClient.isNil: return
if activeClient.isNil: return
let b = -btn.int32
case ev
of down:
keyState[b] = true
of down:
keyState[b] = true
if activeClient.onKeyDown.hasKey(b):
activeClient.onKeyDown[b]()
else:
else:
keyState[b] = false
if activeClient.onKeyUp.hasKey(b):
activeClient.onKeyUp[b]()
proc registerHandler*(client: PKeyClient; key: TKeyCode;
ev: TKeyEventKind; fn: TKeyCallback) =
ev: TKeyEventKind; fn: TKeyCallback) =
case ev
of down: client.onKeyDown[key.int32] = fn
of up: client.onKeyUp[key.int32] = fn
@ -90,7 +90,7 @@ proc recordText*(i: PTextInput; c: cint) =
if c > 127 or i.isNil: return
if c in 32..126: ##printable
if i.cursor == i.text.len: i.text.add(c.int.chr)
else:
else:
let rem = i.text.substr(i.cursor)
i.text.setLen(i.cursor)
i.text.add(chr(c.int))
@ -104,7 +104,7 @@ proc recordText*(i: PTextInput; c: cint) =
i.text.add(rem)
elif c == 10 or c == 13:## \n, \r enter
if not i.onEnter.isNil: i.onEnter()
proc recordText*(i: PTextInput; e: TTextEvent) {.inline.} =
proc recordText*(i: PTextInput; e: TTextEvent) {.inline.} =
recordText(i, e.unicode)
proc setMousePos*(x, y: cint) {.inline.} =
@ -135,4 +135,4 @@ iterator pollEvents*(window: PRenderWindow): PEvent =
of EvtTextEntered: recordText(activeInput, event.text)
of EvtMouseMoved: setMousePos(event.mouseMove.x, event.mouseMove.y)
else: nil
yield(addr event)
yield(addr event)

6
tests/manyloc/keineschweine/lib/map_filter.nim
View file

@ -19,7 +19,7 @@ template unless*(condition: expr; body: stmt): stmt {.dirty.} =
when isMainModule:
proc dumpSeq[T](x: seq[T]) =
for index, item in x.pairs:
for index, item in x.pairs:
echo index, " ", item
echo "-------"
@ -28,13 +28,13 @@ when isMainModule:
dumpSeq res
from strutils import toHex
var foocakes = t.map(proc(z: int): string =
var foocakes = t.map(proc(z: int): string =
result = toHex((z * 23).BiggestInt, 4))
dumpSeq foocakes
t.mapInPlace(proc(z: int): int = result = z * 30)
dumpSeq t
var someSeq = @[9,8,7,6,5,4,3,2,1] ## numbers < 6 or even
filterIt2 someSeq, it < 6 or (it and 1) == 0:
echo(it)

2
tests/manyloc/keineschweine/lib/math_helpers.nim
View file

@ -6,5 +6,5 @@ proc radians*(deg: float): float =
return deg * PI / 180.0
## V not math, sue me
proc ff*(f: float, precision = 2): string {.inline.} =
proc ff*(f: float, precision = 2): string {.inline.} =
return formatFloat(f, ffDecimal, precision)

2
tests/manyloc/keineschweine/lib/sfml_stuff.nim
View file

@ -1,4 +1,4 @@
import
import
math, strutils,
sfml, input_helpers
when not defined(NoChipmunk):

70
tests/manyloc/keineschweine/lib/sg_assets.nim
View file

@ -1,5 +1,5 @@
import
re, json, strutils, tables, math, os, math_helpers,
re, json, strutils, tables, math, os, math_helpers,
sg_packets, md5, zlib_helpers
when defined(NoSFML):
@ -56,9 +56,9 @@ type
energyCost*: float
useSound*: PSoundRecord
case kind*: TItemKind
of Projectile:
of Projectile:
bullet*: PBulletRecord
else:
else:
nil
PBulletRecord* = ref TBulletRecord
TBulletRecord* = object
@ -84,7 +84,7 @@ type
health*: int
TExplosionRecord* = object
anim*: PAnimationRecord
sound*: PSoundRecord
sound*: PSoundRecord
PAnimationRecord* = ref TAnimationRecord
TAnimationRecord* = object
spriteSheet*: PSpriteSheet
@ -96,9 +96,9 @@ type
when defined(NoSFML):
contents*: TChecksumFile
else:
soundBuf*: PSoundBuffer
soundBuf*: PSoundBuffer
PSpriteSheet* = ref TSpriteSheet
TSpriteSheet* = object
TSpriteSheet* = object
file*: string
framew*,frameh*: int
rows*, cols*: int
@ -112,7 +112,7 @@ type
const
TAU* = PI * 2.0
MomentMult* = 0.62 ## global moment of inertia multiplier
var
var
cfg: PZoneSettings
SpriteSheets* = initTable[string, PSpriteSheet](64)
SoundCache * = initTable[string, PSoundRecord](64)
@ -151,7 +151,7 @@ proc importSound*(data: PJsonNode; errors: var seq[string]; fieldName: string =
## this is the only pipe between lobby and main.nim
proc getActiveState*(): TGameState =
result = activeState
proc transition*() =
proc transition*() =
assert activeState == Lobby, "Transition() called from a state other than lobby!"
activeState = Transitioning
proc doneWithSaidTransition*() =
@ -179,7 +179,7 @@ proc free*(obj: PSoundRecord) =
echo "Free'd ", obj.file
proc loadAllAssets*() =
var
var
loaded = 0
failed = 0
for name, ss in SpriteSheets.pairs():
@ -205,7 +205,7 @@ iterator playableVehicles*(): PVehicleRecord =
yield v
template allAssets*(body: stmt) {.dirty.}=
block:
block:
var assetType = FGraphics
for file, asset in pairs(SpriteSheets):
body
@ -230,7 +230,7 @@ cacheImpl newSprite, SpriteSheets, PSpriteSheet:
if filename =~ re"\S+_(\d+)x(\d+)\.\S\S\S":
result.framew = strutils.parseInt(matches[0])
result.frameh = strutils.parseInt(matches[1])
checkFile("data/gfx"/result.file)
checkFile("data/gfx"/result.file)
else:
errors.add "Bad file: "&filename&" must be in format name_WxH.png"
return
@ -260,7 +260,7 @@ when defined(NoSFML):
result = true
else:
proc load*(ss: PSpriteSheet): bool =
if not ss.sprite.isNil:
if not ss.sprite.isNil:
return
var image = sfml.newImage("data/gfx/"/ss.file)
if image == nil:
@ -335,7 +335,7 @@ proc loadSettings*(rawJson: string, errors: var seq[string]): bool =
except EJsonParsingError:
errors.add("JSON parsing error: "& getCurrentExceptionMsg())
return
except:
except:
errors.add("Unknown exception: "& getCurrentExceptionMsg())
return
if not validateSettings(settings, errors):
@ -354,7 +354,7 @@ proc loadSettings*(rawJson: string, errors: var seq[string]): bool =
nameToItemID = initTable[string, int](32)
nameToObjID = initTable[string, int](32)
nameToBulletID = initTable[string, int](32)
var
var
vID = 0'i16
bID = 0'i16
for vehicle in settings["vehicles"].items:
@ -382,7 +382,7 @@ proc loadSettings*(rawJson: string, errors: var seq[string]): bool =
errors.add("Projectile #$1 has no bullet!"% $vID)
elif itm.bullet.id == -1:
## this item has an anonymous bullet, fix the ID and name
itm.bullet.id = bID
itm.bullet.id = bID
itm.bullet.name = itm.name
cfg.bullets.add itm.bullet
nameToBulletID[itm.bullet.name] = itm.bullet.id
@ -448,7 +448,7 @@ proc importLevel(data: PJsonNode; errors: var seq[string]): PLevelSettings =
new(result)
result.size = vec2i(5000, 5000)
result.starfield = @[]
checkKey(data, "level")
var level = data["level"]
if level.hasKey("size") and level["size"].kind == JArray and level["size"].len == 2:
@ -460,7 +460,7 @@ proc importLevel(data: PJsonNode; errors: var seq[string]): PLevelSettings =
proc importPhys(data: PJsonNode): TPhysicsRecord =
result.radius = 20.0
result.mass = 10.0
if data.hasKey("physics") and data["physics"].kind == JObject:
let phys = data["physics"]
phys.getField("radius", result.radius)
@ -473,11 +473,11 @@ proc importHandling(data: PJsonNode): THandlingRecord =
result.reverse = 30.0
result.strafe = 30.0
result.rotation = 2200.0
checkKey(data, "handling")
if data["handling"].kind != JObject:
return
let hand = data["handling"]
hand.getField("thrust", result.thrust)
hand.getField("top_speed", result.topSpeed)
@ -489,19 +489,19 @@ proc importAnim(data: PJsonNode, errors: var seq[string]): PAnimationRecord =
result.angle = 0.0
result.delay = 1000.0
result.spriteSheet = nil
if data.hasKey("anim"):
let anim = data["anim"]
if anim.kind == JObject:
if anim.hasKey("file"):
result.spriteSheet = newSprite(anim["file"].str, errors)
anim.getField "angle", result.angle
anim.getField "delay", result.delay
elif data["anim"].kind == JString:
result.spriteSheet = newSprite(anim.str, errors)
result.angle = radians(result.angle) ## comes in as degrees
result.angle = radians(result.angle) ## comes in as degrees
result.delay /= 1000 ## delay comes in as milliseconds
proc importSoul(data: PJsonNode): TSoulRecord =
result.energy = 10000
@ -525,8 +525,8 @@ proc importSound*(data: PJsonNode; errors: var seq[string]; fieldName: string =
proc importVeh(data: PJsonNode; errors: var seq[string]): PVehicleRecord =
new(result)
result.playable = false
if data.kind != JArray or data.len != 2 or
(data.kind == JArray and
if data.kind != JArray or data.len != 2 or
(data.kind == JArray and
(data[0].kind != JString or data[1].kind != JObject)):
result.name = "(broken)"
errors.add "Vehicle record is malformed"
@ -556,13 +556,13 @@ proc importItem(data: PJsonNode; errors: var seq[string]): PItemRecord =
result.name = data[0].str
result.anim = importAnim(data[2], errors)
result.physics = importPhys(data[2])
result.cooldown = 100.0
result.cooldown = 100.0
data[2].getField("cooldown", result.cooldown)
result.cooldown /= 1000.0 ##cooldown is stored in ms
result.cooldown /= 1000.0 ##cooldown is stored in ms
result.useSound = importSound(data[2], errors, "useSound")
case data[1].str.toLower
of "projectile":
result.kind = Projectile
@ -570,7 +570,7 @@ proc importItem(data: PJsonNode; errors: var seq[string]): PItemRecord =
result.bullet = fetchBullet(data[2]["bullet"].str)
elif data[2]["bullet"].kind == JInt:
result.bullet = cfg.bullets[data[2]["bullet"].num.int]
elif data[2]["bullet"].kind == JObject:
elif data[2]["bullet"].kind == JObject:
result.bullet = importBullet(data[2]["bullet"], errors)
else:
errors.add "UNKNOWN BULLET TYPE for item "& result.name
@ -584,20 +584,20 @@ proc importItem(data: PJsonNode; errors: var seq[string]): PItemRecord =
proc importBullet(data: PJsonNode; errors: var seq[string]): PBulletRecord =
new(result)
result.id = -1
var bdata: PJsonNode
if data.kind == JArray:
result.name = data[0].str
bdata = data[1]
elif data.kind == JObject:
bdata = data
else:
else:
errors.add "Malformed bullet record"
return
result.anim = importAnim(bdata, errors)
result.physics = importPhys(bdata)
result.lifetime = 2000.0
result.inheritVelocity = 1000.0
result.baseVelocity = 30.0

34
tests/manyloc/keineschweine/lib/sg_gui.nim
View file

@ -1,5 +1,5 @@
import
sfml, sfml_colors,
sfml, sfml_colors,
input_helpers, sg_packets
from strutils import countlines
{.deadCodeElim: on.}
@ -63,7 +63,7 @@ proc click*(b: PButton; p: TVector2f)
proc setPosition*(b: PButton; p: TVector2f)
proc setString*(b: PButton; s: string) {.inline.}
proc newButton*(container: PGuiContainer; text: string; position: TVector2f;
proc newButton*(container: PGuiContainer; text: string; position: TVector2f;
onClick: TButtonClicked; startEnabled: bool = true): PButton {.discardable.}
proc init(b: PButton; text: string; position: TVector2f; onClick: TButtonClicked)
proc setEnabled*(b: PButton; enabled: bool)
@ -91,7 +91,7 @@ proc newGuiContainer*(): PGuiContainer =
proc newGuiContainer*(pos: TVector2f): PGuiContainer =
result = newGuiContainer()
result.setPosition pos
proc free*(container: PGuiContainer) =
proc free*(container: PGuiContainer) =
container.widgets = nil
container.buttons = nil
proc add*(container: PGuiContainer; widget: PGuiObject) =
@ -128,9 +128,9 @@ proc newButton*(container: PGuiContainer; text: string;
position: TVector2f; onClick: TButtonClicked;
startEnabled: bool = true): PButton =
new(result, free)
init(result,
text,
if not container.isNil: position + container.position else: position,
init(result,
text,
if not container.isNil: position + container.position else: position,
onClick)
container.add result
if not startEnabled: disable(result)
@ -168,13 +168,13 @@ proc setPosition*(b: PButton, p: TVector2f) =
b.bounds = b.text.getGlobalBounds()
proc setString*(b: PButton; s: string) =
b.text.setString(s)
proc click*(b: PButton, p: TVector2f) =
if b.enabled and (addr b.bounds).contains(p.x, p.y):
proc click*(b: PButton, p: TVector2f) =
if b.enabled and (addr b.bounds).contains(p.x, p.y):
b.onClick(b)
proc free(obj: PTextEntry) =
free(PButton(obj))
proc newTextEntry*(container: PGuiContainer; text: string;
proc newTextEntry*(container: PGuiContainer; text: string;
position: TVector2F; onEnter: TInputFinishedProc = nil): PTextEntry =
new(result, free)
init(PButton(result), text, position + container.position, proc(b: PButton) =
@ -210,7 +210,7 @@ proc add*(m: PMessageArea, text: string): PText =
pos.y -= 16.0
proc draw*(window: PRenderWindow; m: PMessageArea) =
let nmsgs = len(m.messages)
let nmsgs = len(m.messages)
if nmsgs == 0: return
for i in countdown(nmsgs - 1, max(nmsgs - 30, 0)):
window.draw(m.messages[i])
@ -224,11 +224,11 @@ proc newMessageArea*(container: PGuiContainer; position: TVector2f): PMessageAre
result.scrollBack = 0
result.direction = -1 ## to push old messages up
container.add(result)
proc add*(m: PMessageArea, msg: ScChat) =
const prependName = {CPub, CPriv}
var mmm: TMessage
if msg.kind in prependName:
if msg.kind in prependName:
mmm.text = "<"
mmm.text.add msg.fromPlayer
mmm.text.add "> "
@ -239,9 +239,9 @@ proc add*(m: PMessageArea, msg: ScChat) =
of CPub: mmm.color = RoyalBlue
of CPriv, CSystem: mmm.color = Green
of CError: mmm.color = Red
mmm.lines = countLines(mmm.text)+1
m.messages.add mmm
update m
proc add*(m: PMessageArea, msg: string) {.inline.} =
@ -249,7 +249,7 @@ proc add*(m: PMessageArea, msg: string) {.inline.} =
add(m, chat)
proc proctor*(m: PText; msg: ptr TMessage; pos: ptr TVector2f) =
m.setString msg.text
m.setString msg.text
m.setColor msg.color
m.setPosition pos[]
proc update*(m: PMessageArea) =
@ -263,7 +263,7 @@ proc update*(m: PMessageArea) =
for i in m.sizeVisible.. < m.texts.len:
m.texts.pop().destroy()
let nmsgs = m.messages.len()
if m.sizeVisible == 0 or nmsgs == 0:
if m.sizeVisible == 0 or nmsgs == 0:
echo "no messages? ", m.sizeVisible, ", ", nmsgs
return
var pos = vec2f(m.pos.x, m.pos.y)
@ -271,7 +271,7 @@ proc update*(m: PMessageArea) =
##echo nmsgs - i - 1 - m.scrollBack
let msg = addr m.messages[nmsgs - i - 1 - m.scrollBack]
proctor(m.texts[i], msg, addr pos)
pos.y += (16 * m.direction * msg.lines).cfloat
pos.y += (16 * m.direction * msg.lines).cfloat
proc draw*(window: PRenderWindow; m: PMessageArea) =
let nmsgs = len(m.texts)

10
tests/manyloc/keineschweine/lib/sg_packets.nim
View file

@ -33,7 +33,7 @@ defPacket(Poing, tuple[id: int32, time: float32])
type ChatType* = enum
CPub = 0'i8, CPriv, CSystem, CError
forwardPacketT(ChatType, int8)
idPacket(Chat, 'C',
idPacket(Chat, 'C',
tuple[kind: ChatType = CPub; fromPlayer: string = ""; text: string = ""],
tuple[target: string = ""; text: string = ""])
@ -65,8 +65,8 @@ defPacket(ScSpawn, tuple[
type TAssetType* = enum
FDummy,
FZoneCfg, FGraphics, FSound
FDummy,
FZoneCfg, FGraphics, FSound
forwardPacketT(TAssetType, int8)
forwardPacket(MD5Digest, array[0..15, int8])
@ -93,7 +93,7 @@ let HVerifyClient* = 'v'
defPacket(SdVerifyClient, tuple[session: ScLogin])
when isMainModule:
var buf = newBuffer(100)
var m = toMd5("hello there")
echo(repr(m))
@ -101,7 +101,7 @@ when isMainModule:
echo(repr(buf.data))
echo(len(buf.data))
buf.reset()
var x = buf.readMD5Digest()

2
tests/manyloc/keineschweine/lib/vehicles.nim
View file

@ -1,5 +1,5 @@
import
sfml, chipmunk,
sfml, chipmunk,
sg_assets, sfml_stuff, keineschweine

148
tests/manyloc/keineschweine/lib/wingl.nim
View file

@ -1,9 +1,9 @@
import
import
gl, windows
proc wglGetExtensionsStringARB*(hdc: HDC): cstring{.dynlib: dllname,
proc wglGetExtensionsStringARB*(hdc: HDC): cstring{.dynlib: dllname,
importc: "wglGetExtensionsStringARB".}
const
const
WGL_FRONT_COLOR_BUFFER_BIT_ARB* = 0x00000001
WGL_BACK_COLOR_BUFFER_BIT_ARB* = 0x00000002
WGL_DEPTH_BUFFER_BIT_ARB* = 0x00000004
@ -13,21 +13,21 @@ proc WinChoosePixelFormat*(DC: HDC, p2: PPixelFormatDescriptor): int{.
dynlib: "gdi32", importc: "ChoosePixelFormat".}
proc wglCreateBufferRegionARB*(hDC: HDC, iLayerPlane: TGLint, uType: TGLuint): THandle{.
dynlib: dllname, importc: "wglCreateBufferRegionARB".}
proc wglDeleteBufferRegionARB*(hRegion: THandle){.dynlib: dllname,
proc wglDeleteBufferRegionARB*(hRegion: THandle){.dynlib: dllname,
importc: "wglDeleteBufferRegionARB".}
proc wglSaveBufferRegionARB*(hRegion: THandle, x: TGLint, y: TGLint,
proc wglSaveBufferRegionARB*(hRegion: THandle, x: TGLint, y: TGLint,
width: TGLint, height: TGLint): BOOL{.
dynlib: dllname, importc: "wglSaveBufferRegionARB".}
proc wglRestoreBufferRegionARB*(hRegion: THandle, x: TGLint, y: TGLint,
width: TGLint, height: TGLint, xSrc: TGLint,
ySrc: TGLint): BOOL{.dynlib: dllname,
proc wglRestoreBufferRegionARB*(hRegion: THandle, x: TGLint, y: TGLint,
width: TGLint, height: TGLint, xSrc: TGLint,
ySrc: TGLint): BOOL{.dynlib: dllname,
importc: "wglRestoreBufferRegionARB".}
proc wglAllocateMemoryNV*(size: TGLsizei, readFrequency: TGLfloat,
proc wglAllocateMemoryNV*(size: TGLsizei, readFrequency: TGLfloat,
writeFrequency: TGLfloat, priority: TGLfloat): PGLvoid{.
dynlib: dllname, importc: "wglAllocateMemoryNV".}
proc wglFreeMemoryNV*(pointer: PGLvoid){.dynlib: dllname,
proc wglFreeMemoryNV*(pointer: PGLvoid){.dynlib: dllname,
importc: "wglFreeMemoryNV".}
const
const
WGL_IMAGE_BUFFER_MIN_ACCESS_I3D* = 0x00000001
WGL_IMAGE_BUFFER_LOCK_I3D* = 0x00000002
@ -35,30 +35,30 @@ proc wglCreateImageBufferI3D*(hDC: HDC, dwSize: DWORD, uFlags: UINT): PGLvoid{.
dynlib: dllname, importc: "wglCreateImageBufferI3D".}
proc wglDestroyImageBufferI3D*(hDC: HDC, pAddress: PGLvoid): BOOL{.
dynlib: dllname, importc: "wglDestroyImageBufferI3D".}
proc wglAssociateImageBufferEventsI3D*(hdc: HDC, pEvent: PHandle,
pAddress: PGLvoid, pSize: PDWORD,
count: UINT): BOOL{.dynlib: dllname,
proc wglAssociateImageBufferEventsI3D*(hdc: HDC, pEvent: PHandle,
pAddress: PGLvoid, pSize: PDWORD,
count: UINT): BOOL{.dynlib: dllname,
importc: "wglAssociateImageBufferEventsI3D".}
proc wglReleaseImageBufferEventsI3D*(hdc: HDC, pAddress: PGLvoid, count: UINT): BOOL{.
dynlib: dllname, importc: "wglReleaseImageBufferEventsI3D".}
proc wglEnableFrameLockI3D*(): BOOL{.dynlib: dllname,
proc wglEnableFrameLockI3D*(): BOOL{.dynlib: dllname,
importc: "wglEnableFrameLockI3D".}
proc wglDisableFrameLockI3D*(): BOOL{.dynlib: dllname,
proc wglDisableFrameLockI3D*(): BOOL{.dynlib: dllname,
importc: "wglDisableFrameLockI3D".}
proc wglIsEnabledFrameLockI3D*(pFlag: PBOOL): BOOL{.dynlib: dllname,
proc wglIsEnabledFrameLockI3D*(pFlag: PBOOL): BOOL{.dynlib: dllname,
importc: "wglIsEnabledFrameLockI3D".}
proc wglQueryFrameLockMasterI3D*(pFlag: PBOOL): BOOL{.dynlib: dllname,
proc wglQueryFrameLockMasterI3D*(pFlag: PBOOL): BOOL{.dynlib: dllname,
importc: "wglQueryFrameLockMasterI3D".}
proc wglGetFrameUsageI3D*(pUsage: PGLfloat): BOOL{.dynlib: dllname,
proc wglGetFrameUsageI3D*(pUsage: PGLfloat): BOOL{.dynlib: dllname,
importc: "wglGetFrameUsageI3D".}
proc wglBeginFrameTrackingI3D*(): BOOL{.dynlib: dllname,
proc wglBeginFrameTrackingI3D*(): BOOL{.dynlib: dllname,
importc: "wglBeginFrameTrackingI3D".}
proc wglEndFrameTrackingI3D*(): BOOL{.dynlib: dllname,
proc wglEndFrameTrackingI3D*(): BOOL{.dynlib: dllname,
importc: "wglEndFrameTrackingI3D".}
proc wglQueryFrameTrackingI3D*(pFrameCount: PDWORD, pMissedFrames: PDWORD,
proc wglQueryFrameTrackingI3D*(pFrameCount: PDWORD, pMissedFrames: PDWORD,
pLastMissedUsage: PGLfloat): BOOL{.
dynlib: dllname, importc: "wglQueryFrameTrackingI3D".}
const
const
WGL_NUMBER_PIXEL_FORMATS_ARB* = 0x00002000
WGL_DRAW_TO_WINDOW_ARB* = 0x00002001
WGL_DRAW_TO_BITMAP_ARB* = 0x00002002
@ -109,27 +109,27 @@ const
WGL_TYPE_RGBA_ARB* = 0x0000202B
WGL_TYPE_COLORINDEX_ARB* = 0x0000202C
proc wglGetPixelFormatAttribivARB*(hdc: HDC, iPixelFormat: TGLint,
iLayerPlane: TGLint, nAttributes: TGLuint,
proc wglGetPixelFormatAttribivARB*(hdc: HDC, iPixelFormat: TGLint,
iLayerPlane: TGLint, nAttributes: TGLuint,
piAttributes: PGLint, piValues: PGLint): BOOL{.
dynlib: dllname, importc: "wglGetPixelFormatAttribivARB".}
proc wglGetPixelFormatAttribfvARB*(hdc: HDC, iPixelFormat: TGLint,
iLayerPlane: TGLint, nAttributes: TGLuint,
proc wglGetPixelFormatAttribfvARB*(hdc: HDC, iPixelFormat: TGLint,
iLayerPlane: TGLint, nAttributes: TGLuint,
piAttributes: PGLint, pfValues: PGLfloat): BOOL{.
dynlib: dllname, importc: "wglGetPixelFormatAttribfvARB".}
proc wglChoosePixelFormatARB*(hdc: HDC, piAttribIList: PGLint,
pfAttribFList: PGLfloat, nMaxFormats: TGLuint,
proc wglChoosePixelFormatARB*(hdc: HDC, piAttribIList: PGLint,
pfAttribFList: PGLfloat, nMaxFormats: TGLuint,
piFormats: PGLint, nNumFormats: PGLuint): BOOL{.
dynlib: dllname, importc: "wglChoosePixelFormatARB".}
const
const
WGL_ERROR_INVALID_PIXEL_TYPE_ARB* = 0x00002043
WGL_ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB* = 0x00002054
proc wglMakeContextCurrentARB*(hDrawDC: HDC, hReadDC: HDC, hglrc: HGLRC): BOOL{.
dynlib: dllname, importc: "wglMakeContextCurrentARB".}
proc wglGetCurrentReadDCARB*(): HDC{.dynlib: dllname,
proc wglGetCurrentReadDCARB*(): HDC{.dynlib: dllname,
importc: "wglGetCurrentReadDCARB".}
const
const
WGL_DRAW_TO_PBUFFER_ARB* = 0x0000202D # WGL_DRAW_TO_PBUFFER_ARB { already defined }
WGL_MAX_PBUFFER_PIXELS_ARB* = 0x0000202E
WGL_MAX_PBUFFER_WIDTH_ARB* = 0x0000202F
@ -139,22 +139,22 @@ const
WGL_PBUFFER_HEIGHT_ARB* = 0x00002035
WGL_PBUFFER_LOST_ARB* = 0x00002036
proc wglCreatePbufferARB*(hDC: HDC, iPixelFormat: TGLint, iWidth: TGLint,
proc wglCreatePbufferARB*(hDC: HDC, iPixelFormat: TGLint, iWidth: TGLint,
iHeight: TGLint, piAttribList: PGLint): THandle{.
dynlib: dllname, importc: "wglCreatePbufferARB".}
proc wglGetPbufferDCARB*(hPbuffer: THandle): HDC{.dynlib: dllname,
proc wglGetPbufferDCARB*(hPbuffer: THandle): HDC{.dynlib: dllname,
importc: "wglGetPbufferDCARB".}
proc wglReleasePbufferDCARB*(hPbuffer: THandle, hDC: HDC): TGLint{.
dynlib: dllname, importc: "wglReleasePbufferDCARB".}
proc wglDestroyPbufferARB*(hPbuffer: THandle): BOOL{.dynlib: dllname,
proc wglDestroyPbufferARB*(hPbuffer: THandle): BOOL{.dynlib: dllname,
importc: "wglDestroyPbufferARB".}
proc wglQueryPbufferARB*(hPbuffer: THandle, iAttribute: TGLint, piValue: PGLint): BOOL{.
dynlib: dllname, importc: "wglQueryPbufferARB".}
proc wglSwapIntervalEXT*(interval: TGLint): BOOL{.dynlib: dllname,
proc wglSwapIntervalEXT*(interval: TGLint): BOOL{.dynlib: dllname,
importc: "wglSwapIntervalEXT".}
proc wglGetSwapIntervalEXT*(): TGLint{.dynlib: dllname,
proc wglGetSwapIntervalEXT*(): TGLint{.dynlib: dllname,
importc: "wglGetSwapIntervalEXT".}
const
const
WGL_BIND_TO_TEXTURE_RGB_ARB* = 0x00002070
WGL_BIND_TO_TEXTURE_RGBA_ARB* = 0x00002071
WGL_TEXTURE_FORMAT_ARB* = 0x00002072
@ -195,13 +195,13 @@ proc wglReleaseTexImageARB*(hPbuffer: THandle, iBuffer: TGLint): BOOL{.
dynlib: dllname, importc: "wglReleaseTexImageARB".}
proc wglSetPbufferAttribARB*(hPbuffer: THandle, piAttribList: PGLint): BOOL{.
dynlib: dllname, importc: "wglSetPbufferAttribARB".}
proc wglGetExtensionsStringEXT*(): cstring{.dynlib: dllname,
proc wglGetExtensionsStringEXT*(): cstring{.dynlib: dllname,
importc: "wglGetExtensionsStringEXT".}
proc wglMakeContextCurrentEXT*(hDrawDC: HDC, hReadDC: HDC, hglrc: HGLRC): BOOL{.
dynlib: dllname, importc: "wglMakeContextCurrentEXT".}
proc wglGetCurrentReadDCEXT*(): HDC{.dynlib: dllname,
proc wglGetCurrentReadDCEXT*(): HDC{.dynlib: dllname,
importc: "wglGetCurrentReadDCEXT".}
const
const
WGL_DRAW_TO_PBUFFER_EXT* = 0x0000202D
WGL_MAX_PBUFFER_PIXELS_EXT* = 0x0000202E
WGL_MAX_PBUFFER_WIDTH_EXT* = 0x0000202F
@ -212,18 +212,18 @@ const
WGL_PBUFFER_WIDTH_EXT* = 0x00002034
WGL_PBUFFER_HEIGHT_EXT* = 0x00002035
proc wglCreatePbufferEXT*(hDC: HDC, iPixelFormat: TGLint, iWidth: TGLint,
proc wglCreatePbufferEXT*(hDC: HDC, iPixelFormat: TGLint, iWidth: TGLint,
iHeight: TGLint, piAttribList: PGLint): THandle{.
dynlib: dllname, importc: "wglCreatePbufferEXT".}
proc wglGetPbufferDCEXT*(hPbuffer: THandle): HDC{.dynlib: dllname,
proc wglGetPbufferDCEXT*(hPbuffer: THandle): HDC{.dynlib: dllname,
importc: "wglGetPbufferDCEXT".}
proc wglReleasePbufferDCEXT*(hPbuffer: THandle, hDC: HDC): TGLint{.
dynlib: dllname, importc: "wglReleasePbufferDCEXT".}
proc wglDestroyPbufferEXT*(hPbuffer: THandle): BOOL{.dynlib: dllname,
proc wglDestroyPbufferEXT*(hPbuffer: THandle): BOOL{.dynlib: dllname,
importc: "wglDestroyPbufferEXT".}
proc wglQueryPbufferEXT*(hPbuffer: THandle, iAttribute: TGLint, piValue: PGLint): BOOL{.
dynlib: dllname, importc: "wglQueryPbufferEXT".}
const
const
WGL_NUMBER_PIXEL_FORMATS_EXT* = 0x00002000
WGL_DRAW_TO_WINDOW_EXT* = 0x00002001
WGL_DRAW_TO_BITMAP_EXT* = 0x00002002
@ -270,47 +270,47 @@ const
WGL_TYPE_RGBA_EXT* = 0x0000202B
WGL_TYPE_COLORINDEX_EXT* = 0x0000202C
proc wglGetPixelFormatAttribivEXT*(hdc: HDC, iPixelFormat: TGLint,
iLayerPlane: TGLint, nAttributes: TGLuint,
proc wglGetPixelFormatAttribivEXT*(hdc: HDC, iPixelFormat: TGLint,
iLayerPlane: TGLint, nAttributes: TGLuint,
piAttributes: PGLint, piValues: PGLint): BOOL{.
dynlib: dllname, importc: "wglGetPixelFormatAttribivEXT".}
proc wglGetPixelFormatAttribfvEXT*(hdc: HDC, iPixelFormat: TGLint,
iLayerPlane: TGLint, nAttributes: TGLuint,
proc wglGetPixelFormatAttribfvEXT*(hdc: HDC, iPixelFormat: TGLint,
iLayerPlane: TGLint, nAttributes: TGLuint,
piAttributes: PGLint, pfValues: PGLfloat): BOOL{.
dynlib: dllname, importc: "wglGetPixelFormatAttribfvEXT".}
proc wglChoosePixelFormatEXT*(hdc: HDC, piAttribIList: PGLint,
pfAttribFList: PGLfloat, nMaxFormats: TGLuint,
proc wglChoosePixelFormatEXT*(hdc: HDC, piAttribIList: PGLint,
pfAttribFList: PGLfloat, nMaxFormats: TGLuint,
piFormats: PGLint, nNumFormats: PGLuint): BOOL{.
dynlib: dllname, importc: "wglChoosePixelFormatEXT".}
const
const
WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D* = 0x00002050
WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D* = 0x00002051
WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D* = 0x00002052
WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D* = 0x00002053
proc wglGetDigitalVideoParametersI3D*(hDC: HDC, iAttribute: TGLint,
piValue: PGLint): BOOL{.dynlib: dllname,
proc wglGetDigitalVideoParametersI3D*(hDC: HDC, iAttribute: TGLint,
piValue: PGLint): BOOL{.dynlib: dllname,
importc: "wglGetDigitalVideoParametersI3D".}
proc wglSetDigitalVideoParametersI3D*(hDC: HDC, iAttribute: TGLint,
piValue: PGLint): BOOL{.dynlib: dllname,
proc wglSetDigitalVideoParametersI3D*(hDC: HDC, iAttribute: TGLint,
piValue: PGLint): BOOL{.dynlib: dllname,
importc: "wglSetDigitalVideoParametersI3D".}
const
const
WGL_GAMMA_TABLE_SIZE_I3D* = 0x0000204E
WGL_GAMMA_EXCLUDE_DESKTOP_I3D* = 0x0000204F
proc wglGetGammaTableParametersI3D*(hDC: HDC, iAttribute: TGLint,
piValue: PGLint): BOOL{.dynlib: dllname,
proc wglGetGammaTableParametersI3D*(hDC: HDC, iAttribute: TGLint,
piValue: PGLint): BOOL{.dynlib: dllname,
importc: "wglGetGammaTableParametersI3D".}
proc wglSetGammaTableParametersI3D*(hDC: HDC, iAttribute: TGLint,
piValue: PGLint): BOOL{.dynlib: dllname,
proc wglSetGammaTableParametersI3D*(hDC: HDC, iAttribute: TGLint,
piValue: PGLint): BOOL{.dynlib: dllname,
importc: "wglSetGammaTableParametersI3D".}
proc wglGetGammaTableI3D*(hDC: HDC, iEntries: TGLint, puRed: PGLUSHORT,
proc wglGetGammaTableI3D*(hDC: HDC, iEntries: TGLint, puRed: PGLUSHORT,
puGreen: PGLUSHORT, puBlue: PGLUSHORT): BOOL{.
dynlib: dllname, importc: "wglGetGammaTableI3D".}
proc wglSetGammaTableI3D*(hDC: HDC, iEntries: TGLint, puRed: PGLUSHORT,
proc wglSetGammaTableI3D*(hDC: HDC, iEntries: TGLint, puRed: PGLUSHORT,
puGreen: PGLUSHORT, puBlue: PGLUSHORT): BOOL{.
dynlib: dllname, importc: "wglSetGammaTableI3D".}
const
const
WGL_GENLOCK_SOURCE_MULTIVIEW_I3D* = 0x00002044
WGL_GENLOCK_SOURCE_EXTERNAL_SYNC_I3D* = 0x00002045
WGL_GENLOCK_SOURCE_EXTERNAL_FIELD_I3D* = 0x00002046
@ -330,21 +330,21 @@ const
WGL_TEXTURE_FLOAT_RGB_NV* = 0x000020B7
WGL_TEXTURE_FLOAT_RGBA_NV* = 0x000020B8
proc wglEnableGenlockI3D*(hDC: HDC): BOOL{.dynlib: dllname,
proc wglEnableGenlockI3D*(hDC: HDC): BOOL{.dynlib: dllname,
importc: "wglEnableGenlockI3D".}
proc wglDisableGenlockI3D*(hDC: HDC): BOOL{.dynlib: dllname,
proc wglDisableGenlockI3D*(hDC: HDC): BOOL{.dynlib: dllname,
importc: "wglDisableGenlockI3D".}
proc wglIsEnabledGenlockI3D*(hDC: HDC, pFlag: PBOOL): BOOL{.dynlib: dllname,
proc wglIsEnabledGenlockI3D*(hDC: HDC, pFlag: PBOOL): BOOL{.dynlib: dllname,
importc: "wglIsEnabledGenlockI3D".}
proc wglGenlockSourceI3D*(hDC: HDC, uSource: TGLuint): BOOL{.dynlib: dllname,
proc wglGenlockSourceI3D*(hDC: HDC, uSource: TGLuint): BOOL{.dynlib: dllname,
importc: "wglGenlockSourceI3D".}
proc wglGetGenlockSourceI3D*(hDC: HDC, uSource: PGLUINT): BOOL{.dynlib: dllname,
proc wglGetGenlockSourceI3D*(hDC: HDC, uSource: PGLUINT): BOOL{.dynlib: dllname,
importc: "wglGetGenlockSourceI3D".}
proc wglGenlockSourceEdgeI3D*(hDC: HDC, uEdge: TGLuint): BOOL{.dynlib: dllname,
proc wglGenlockSourceEdgeI3D*(hDC: HDC, uEdge: TGLuint): BOOL{.dynlib: dllname,
importc: "wglGenlockSourceEdgeI3D".}
proc wglGetGenlockSourceEdgeI3D*(hDC: HDC, uEdge: PGLUINT): BOOL{.
dynlib: dllname, importc: "wglGetGenlockSourceEdgeI3D".}
proc wglGenlockSampleRateI3D*(hDC: HDC, uRate: TGLuint): BOOL{.dynlib: dllname,
proc wglGenlockSampleRateI3D*(hDC: HDC, uRate: TGLuint): BOOL{.dynlib: dllname,
importc: "wglGenlockSampleRateI3D".}
proc wglGetGenlockSampleRateI3D*(hDC: HDC, uRate: PGLUINT): BOOL{.
dynlib: dllname, importc: "wglGetGenlockSampleRateI3D".}
@ -352,15 +352,15 @@ proc wglGenlockSourceDelayI3D*(hDC: HDC, uDelay: TGLuint): BOOL{.
dynlib: dllname, importc: "wglGenlockSourceDelayI3D".}
proc wglGetGenlockSourceDelayI3D*(hDC: HDC, uDelay: PGLUINT): BOOL{.
dynlib: dllname, importc: "wglGetGenlockSourceDelayI3D".}
proc wglQueryGenlockMaxSourceDelayI3D*(hDC: HDC, uMaxLineDelay: PGLUINT,
proc wglQueryGenlockMaxSourceDelayI3D*(hDC: HDC, uMaxLineDelay: PGLUINT,
uMaxPixelDelay: PGLUINT): BOOL{.
dynlib: dllname, importc: "wglQueryGenlockMaxSourceDelayI3D".}
const
const
WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV* = 0x000020A0
WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV* = 0x000020A1
WGL_TEXTURE_RECTANGLE_NV* = 0x000020A2
const
const
WGL_RGBA_FLOAT_MODE_ATI* = 0x00008820
WGL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI* = 0x00008835
WGL_TYPE_RGBA_FLOAT_ATI* = 0x000021A0

4
tests/manyloc/keineschweine/lib/zlib_helpers.nim
View file

@ -18,7 +18,7 @@ proc uncompress*(source: string, destLen: var int): string =
var res = zlib.uncompress(cstring(result), addr destLen, cstring(source), source.len)
if res != Z_OK:
echo "Error occurred: ", res
when isMainModule:
import strutils
@ -37,4 +37,4 @@ when isMainModule:
ln = s.len
rr = uncompress(r, ln)
echo r.len, " -> ", rr.len
assert rr == s
assert rr == s