Blitz Hardwired -> PureBasic, [α] Опции

[Guevara-chan]

...Пришло время запилить новый wrapper. Wrapper сам себя не запилит.
Собственно, на этот раз все в рамках стандарта. Открыв очередную тему очередной попытки воскресить величие B3D под современные графические API, я задумалась, что не помешала бы возможность оценить какие из результатов. Подумав еще немного, я напилила следующее:

Код

; *=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*
; Hardwired's low-level declarations.
; Converted in 2014 by Guevara-chan.
; *=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*
Define *Library_ = OpenLibrary(#PB_Any, "Hardwired.dll")

Prototype.L _dxCountGfxDrivers()
Global dxCountGfxDrivers._dxCountGfxDrivers = GetFunction(*Library_, "dCountGfxDrivers")
Prototype.L _dxGraphics3D(width.L, height.L, depth.L, mode.L)
Global dxGraphics3D._dxGraphics3D = GetFunction(*Library_, "dGraphics3D")
Prototype.L _dxEndGraphics()
Global dxEndGraphics._dxEndGraphics = GetFunction(*Library_, "dEndGraphics")
Prototype.L _dxShowMouse()
Global dxShowMouse._dxShowMouse = GetFunction(*Library_, "dShowMouse")
Prototype.L _dxHideMouse()
Global dxHideMouse._dxHideMouse = GetFunction(*Library_, "dHideMouse")
Prototype.L _dxKeyDown(key.L)
Global dxKeyDown._dxKeyDown = GetFunction(*Library_, "dKeyDown")
Prototype.L _dxMouseDown(button.L)
Global dxMouseDown._dxMouseDown = GetFunction(*Library_, "dMouseDown")
Prototype.L _dxGetMouse()
Global dxGetMouse._dxGetMouse = GetFunction(*Library_, "dGetMouse")
Prototype.L _dxMouseHit(button.L)
Global dxMouseHit._dxMouseHit = GetFunction(*Library_, "dMouseHit")
Prototype.L _dxWaitMouse()
Global dxWaitMouse._dxWaitMouse = GetFunction(*Library_, "dWaitMouse")
Prototype.L _dxMouseX()
Global dxMouseX._dxMouseX = GetFunction(*Library_, "dMouseX")
Prototype.L _dxMouseY()
Global dxMouseY._dxMouseY = GetFunction(*Library_, "dMouseY")
Prototype.L _dxMouseZ()
Global dxMouseZ._dxMouseZ = GetFunction(*Library_, "dMouseZ")
Prototype.L _dxMoveMouse(x.L, y.L)
Global dxMoveMouse._dxMoveMouse = GetFunction(*Library_, "dMoveMouse")
Prototype.L _dxFlushMouse()
Global dxFlushMouse._dxFlushMouse = GetFunction(*Library_, "dFlushMouse")
Prototype.L _dxMouseXSpeed()
Global dxMouseXSpeed._dxMouseXSpeed = GetFunction(*Library_, "dMouseXSpeed")
Prototype.L _dxMouseYSpeed()
Global dxMouseYSpeed._dxMouseYSpeed = GetFunction(*Library_, "dMouseYSpeed")
Prototype.L _dxMouseZSpeed()
Global dxMouseZSpeed._dxMouseZSpeed = GetFunction(*Library_, "dMouseZSpeed")
Prototype.L _dxKeyHit(key.L)
Global dxKeyHit._dxKeyHit = GetFunction(*Library_, "dKeyHit")
Prototype.L _dxFlushKeys()
Global dxFlushKeys._dxFlushKeys = GetFunction(*Library_, "dFlushKeys")
Prototype.L _dxWaitKey()
Global dxWaitKey._dxWaitKey = GetFunction(*Library_, "dWaitKey")
Prototype.L _dxLoadFont(filename.p-ascii, height, bold, italic, underline)
Global dxLoadFont._dxLoadFont = GetFunction(*Library_, "dLoadFont")
Prototype.L _dxCls()
Global dxCls._dxCls = GetFunction(*Library_, "dCls")
Prototype.L _dxClsColor(red.F, green.F, blue.F)
Global dxClsColor._dxClsColor = GetFunction(*Library_, "dClsColor")
Prototype.L _dxFlip(vsync.L)
Global dxFlip._dxFlip = GetFunction(*Library_, "dFlip")
Prototype.L _dxFrontBuffer()
Global dxFrontBuffer._dxFrontBuffer = GetFunction(*Library_, "dFrontBuffer")
Prototype.L _dxBackBuffer()
Global dxBackBuffer._dxBackBuffer = GetFunction(*Library_, "dBackBuffer")
Prototype.L _dxColor(red.L, green.L, blue.L)
Global dxColor._dxColor = GetFunction(*Library_, "dColor")
Prototype.L _dxPlot(x.L, y.L)
Global dxPlot._dxPlot = GetFunction(*Library_, "dPlot")
Prototype.L _dxCreateMesh(parent.L)
Global dxCreateMesh._dxCreateMesh = GetFunction(*Library_, "dCreateMesh")
Prototype.L _dxCreateCamera(parent.L)
Global dxCreateCamera._dxCreateCamera = GetFunction(*Library_, "dCreateCamera")
Prototype.L _dxPositionEntity(entity.L, x.F, y.F, z.F, Global_.L)
Global dxPositionEntity._dxPositionEntity = GetFunction(*Library_, "dPositionEntity")
Prototype.L _dxCreateTeapot(parent.L)
Global dxCreateTeapot._dxCreateTeapot = GetFunction(*Library_, "dCreateTeapot")
Prototype.L _dxRenderWorld(tween.L)
Global dxRenderWorld._dxRenderWorld = GetFunction(*Library_, "dRenderWorld")
Prototype.L _dxAddVertex(surface.L, x.F, y.F, z.F, u.F, v.F, w.F)
Global dxAddVertex._dxAddVertex = GetFunction(*Library_, "dAddVertex")
Prototype.L _dxCreateSurface(mesh)
Global dxCreateSurface._dxCreateSurface = GetFunction(*Library_, "dCreateSurface")
Prototype.L _dxCountVertices(surface.L)
Global dxCountVertices._dxCountVertices = GetFunction(*Library_, "dCountVertices")
Prototype.L _dxVertexColor(surface, index, red.F, green.F, blue.F, alpha.F)
Global dxVertexColor._dxVertexColor = GetFunction(*Library_, "dVertexColor")
Prototype.L _dxVertexRed(surface, index)
Global dxVertexRed._dxVertexRed = GetFunction(*Library_, "dVertexRed")
Prototype.L _dxVertexGreen(surface, index)
Global dxVertexGreen._dxVertexGreen = GetFunction(*Library_, "dVertexGreen")
Prototype.L _dxVertexBlue(surface, index)
Global dxVertexBlue._dxVertexBlue = GetFunction(*Library_, "dVertexBlue")
Prototype.F _dxVertexAlpha(surface, index)
Global dxVertexAlpha._dxVertexAlpha = GetFunction(*Library_, "dVertexAlpha")
Prototype.L _dxVertexTexCoords(surface, index, texture_u.F, texture_v.F, texture_w.F, coord_set)
Global dxVertexTexCoords._dxVertexTexCoords = GetFunction(*Library_, "dVertexTexCoords")
Prototype.L _dxVertexNormal(surface, index, x_normal.F, y_normal.F, z_normal.F)
Global dxVertexNormal._dxVertexNormal = GetFunction(*Library_, "dVertexNormal")
Prototype.F _dxVertexX(surface, index)
Global dxVertexX._dxVertexX = GetFunction(*Library_, "dVertexX")
Prototype.F _dxVertexY(surface, index)
Global dxVertexY._dxVertexY = GetFunction(*Library_, "dVertexY")
Prototype.F _dxVertexZ(surface, index)
Global dxVertexZ._dxVertexZ = GetFunction(*Library_, "dVertexZ")
Prototype.F _dxVertexNX(surface, index)
Global dxVertexNX._dxVertexNX = GetFunction(*Library_, "dVertexNX")
Prototype.F _dxVertexNY(surface, index)
Global dxVertexNY._dxVertexNY = GetFunction(*Library_, "dVertexNY")
Prototype.F _dxVertexNZ(surface, index)
Global dxVertexNZ._dxVertexNZ = GetFunction(*Library_, "dVertexNZ")
Prototype.F _dxVertexU(surface, index)
Global dxVertexU._dxVertexU = GetFunction(*Library_, "dVertexU")
Prototype.F _dxVertexV(surface, index)
Global dxVertexV._dxVertexV = GetFunction(*Library_, "dVertexV")
Prototype.F _dxVertexW(surface, index)
Global dxVertexW._dxVertexW = GetFunction(*Library_, "dVertexW")
Prototype.L _dxCountSurfaces(mesh)
Global dxCountSurfaces._dxCountSurfaces = GetFunction(*Library_, "dCountSurfaces")
Prototype.L _dxClearSurface(surface, vertices, triangles)
Global dxClearSurface._dxClearSurface = GetFunction(*Library_, "dClearSurface")
Prototype.L _dxAddTriangle(surface, vertex_1, vertex_2, vertex_3)
Global dxAddTriangle._dxAddTriangle = GetFunction(*Library_, "dAddTriangle")
Prototype.L _dxCountTriangles(surface)
Global dxCountTriangles._dxCountTriangles = GetFunction(*Library_, "dCountTriangles")
Prototype.L _dxTriangleVertex(surface, triangle_index, corner)
Global dxTriangleVertex._dxTriangleVertex = GetFunction(*Library_, "dTriangleVertex")
Prototype.L _dxAmbientLight(red.L, green.L, blue.L)
Global dxAmbientLight._dxAmbientLight = GetFunction(*Library_, "dAmbientLight")
Prototype.L _dxCameraViewport(camera, x, y, width, height)
Global dxCameraViewport._dxCameraViewport = GetFunction(*Library_, "dCameraViewport")
Prototype.L _dxCameraClsColor(camera, red, green, blue)
Global dxCameraClsColor._dxCameraClsColor = GetFunction(*Library_, "dCameraClsColor")
Prototype.L _dxCameraProjMode(camera, projection_mode)
Global dxCameraProjMode._dxCameraProjMode = GetFunction(*Library_, "dCameraProjMode")
Prototype.L _dxCameraRange(camera, near.F, far.F)
Global dxCameraRange._dxCameraRange = GetFunction(*Library_, "dCameraRange")
Prototype.L _dxCameraClsMode(camera, cls_color, z_buffer)
Global dxCameraClsMode._dxCameraClsMode = GetFunction(*Library_, "dCameraClsMode")
Prototype.L _dxCameraAspect(camera, aspect_ratio.F)
Global dxCameraAspect._dxCameraAspect = GetFunction(*Library_, "dCameraAspect")
Prototype.L _dxAutoCameraAspect(camera)
Global dxAutoCameraAspect._dxAutoCameraAspect = GetFunction(*Library_, "dAutoCameraAspect")
Prototype.L _dxCameraFOV(camera, focus.F)
Global dxCameraFOV._dxCameraFOV = GetFunction(*Library_, "dCameraFOV")
Prototype.F _dxGetCameraFOV(camera)
Global dxGetCameraFOV._dxGetCameraFOV = GetFunction(*Library_, "dGetCameraFOV")
Prototype.F _dxGetCameraAspect(camera)
Global dxGetCameraAspect._dxGetCameraAspect = GetFunction(*Library_, "dGetCameraAspect")
Prototype.L _dxCreateTorus(inner_radius.F, outer_radius.F, sides, rings)
Global dxCreateTorus._dxCreateTorus = GetFunction(*Library_, "dCreateTorus")
Prototype.L _dxCreateCube(parent.L)
Global dxCreateCube._dxCreateCube = GetFunction(*Library_, "dCreateCube")
Prototype.L _dxCreateCylinder(radius1.F, radius2.F, length.F, slices, stacks)
Global dxCreateCylinder._dxCreateCylinder = GetFunction(*Library_, "dCreateCylinder")
Prototype.L _dxCreateSphere(segments.L, parent.L)
Global dxCreateSphere._dxCreateSphere = GetFunction(*Library_, "dCreateSphere")
Prototype.L _dxFreeEntity(entity.L)
Global dxFreeEntity._dxFreeEntity = GetFunction(*Library_, "dFreeEntity")
Prototype.L _dxEntityParent(entity.L, parent.L)
Global dxEntityParent._dxEntityParent = GetFunction(*Library_, "dEntityParent")
Prototype.L _dxCountChildren(entity.L)
Global dxCountChildren._dxCountChildren = GetFunction(*Library_, "dCountChildren")
Prototype.L _dxGetChild(entity.L, index.L)
Global dxGetChild._dxGetChild = GetFunction(*Library_, "dGetChild")
Prototype.I _dxEntityClass(entity.L)
Global dxEntityClass_._dxEntityClass = GetFunction(*Library_, "dEntityClass")
Macro dxEntityClass(entity) : PeekS(dxEntityClass_(entity), -1, #PB_Ascii) : EndMacro
Prototype.L _dxGetParent(entity.L)
Global dxGetParent._dxGetParent = GetFunction(*Library_, "dGetParent")
Prototype.L _dxNameEntity(entity.L, name.p-ascii)
Global dxNameEntity._dxNameEntity = GetFunction(*Library_, "dNameEntity")
Prototype.I _dxEntityName(entity.L)
Global dxEntityName_._dxEntityName = GetFunction(*Library_, "dEntityName")
Macro dxEntityName(entity) : PeekS(dxEntityName_(entity), -1, #PB_Ascii) : EndMacro
Prototype.F _dxEntityX(entity.L, Global_.L)
Global dxEntityX._dxEntityX = GetFunction(*Library_, "dEntityX")
Prototype.F _dxEntityY(entity.L, Global_.L)
Global dxEntityY._dxEntityY = GetFunction(*Library_, "dEntityY")
Prototype.F _dxEntityZ(entity.L, Global_.L)
Global dxEntityZ._dxEntityZ = GetFunction(*Library_, "dEntityZ")
Prototype.L _dxRotateEntity(entity.L, pitch.F, yaw.F, roll.F, Global_.L)
Global dxRotateEntity._dxRotateEntity = GetFunction(*Library_, "dRotateEntity")
Prototype.F _dxGetMatElement(entity.L, row.L, column.L)
Global dxGetMatElement._dxGetMatElement = GetFunction(*Library_, "dGetMatElement")
Prototype.L _dxUpdateNormals(mesh.L)
Global dxUpdateNormals._dxUpdateNormals = GetFunction(*Library_, "dUpdateNormals")
Prototype.L _dxCreateTexture(width.L, height.L, flags.L, frames.L)
Global dxCreateTexture._dxCreateTexture = GetFunction(*Library_, "dCreateTexture")
Prototype.L _dxTurnEntity(entity.L, pitch.F, yaw.F, roll.F, Global_.L)
Global dxTurnEntity._dxTurnEntity = GetFunction(*Library_, "dTurnEntity")
Prototype.L _dxMoveEntity(entity.L, x.F, y.F, z.F)
Global dxMoveEntity._dxMoveEntity = GetFunction(*Library_, "dMoveEntity")
Prototype.L _dxTranslateEntity(entity, x.F, y.F, z.F, Global_)
Global dxTranslateEntity._dxTranslateEntity = GetFunction(*Library_, "dTranslateEntity")
Prototype.L _dxEntityRed(entity.L)
Global dxEntityRed._dxEntityRed = GetFunction(*Library_, "dEntityRed")
Prototype.L _dxEntityGreen(entity.L)
Global dxEntityGreen._dxEntityGreen = GetFunction(*Library_, "dEntityGreen")
Prototype.L _dxEntityBlue(entity.L)
Global dxEntityBlue._dxEntityBlue = GetFunction(*Library_, "dEntityBlue")
Prototype.L _dxEntityColor(entity.L, red.L, green.L, blue.L)
Global dxEntityColor._dxEntityColor = GetFunction(*Library_, "dEntityColor")
Prototype.L _dxEntityFX(entity.L, fx.L)
Global dxEntityFX._dxEntityFX = GetFunction(*Library_, "dEntityFX")
Prototype.L _dxGetEntityFX(entity.L)
Global dxGetEntityFX._dxGetEntityFX = GetFunction(*Library_, "dGetEntityFX")
Prototype.L _dxDither(state.L)
Global dxDither._dxDither = GetFunction(*Library_, "dDither")
Prototype.L _dxCameraFogMode(camera.L, state.L)
Global dxCameraFogMode._dxCameraFogMode = GetFunction(*Library_, "dCameraFogMode")
Prototype.L _dxCameraFogColor(camera.L, red.L, green.L, blue.L)
Global dxCameraFogColor._dxCameraFogColor = GetFunction(*Library_, "dCameraFogColor")
Prototype.L _dxCameraFogRange(camera.L, near.F, far.F)
Global dxCameraFogRange._dxCameraFogRange = GetFunction(*Library_, "dCameraFogRange")
Prototype.L _dxLoadTexture(file.p-ascii, flags.L)
Global dxLoadTexture._dxLoadTexture = GetFunction(*Library_, "dLoadTexture")
Prototype.L _dxEntityTexture(entity.L, texture.L, frame.L, index.L)
Global dxEntityTexture._dxEntityTexture = GetFunction(*Library_, "dEntityTexture")
Prototype.L _dxCountGfxModes3D()
Global dxCountGfxModes3D._dxCountGfxModes3D = GetFunction(*Library_, "dCountGfxModes3D")
Prototype.L _dxGfxModeWidth(adapter.L)
Global dxGfxModeWidth._dxGfxModeWidth = GetFunction(*Library_, "dGfxModeWidth")
Prototype.L _dxGfxModeHeight(adapter.L)
Global dxGfxModeHeight._dxGfxModeHeight = GetFunction(*Library_, "dGfxModeHeight")
Prototype.L _dxGfxModeDepth(adapter.L)
Global dxGfxModeDepth._dxGfxModeDepth = GetFunction(*Library_, "dGfxModeDepth")
Prototype.L _dxGfxModeRefreshRate(adapter.L)
Global dxGfxModeRefreshRate._dxGfxModeRefreshRate = GetFunction(*Library_, "dGfxModeRefreshRate")
Prototype.L _dxWireframe(enable.L)
Global dxWireframe._dxWireframe = GetFunction(*Library_, "dWireframe")
Prototype.L _dxEntityWireframe(entity.L, enable.L)
Global dxEntityWireframe._dxEntityWireframe = GetFunction(*Library_, "dEntityWireframe")
Prototype.L _dxPointframe(enable.L)
Global dxPointframe._dxPointframe = GetFunction(*Library_, "dPointframe")
Prototype.L _dxEntityPointframe(entity.L, enable.L)
Global dxEntityPointframe._dxEntityPointframe = GetFunction(*Library_, "dEntityPointframe")
Prototype.L _dxScaleEntity(entity.L, scale_x.F, scale_y.F, scale_z.F, Global_)
Global dxScaleEntity._dxScaleEntity = GetFunction(*Library_, "dScaleEntity")
Prototype.F _dxEntityScaleX(entity.L)
Global dxEntityScaleX._dxEntityScaleX = GetFunction(*Library_, "dEntityScaleX")
Prototype.F _dxEntityScaleY(entity.L)
Global dxEntityScaleY._dxEntityScaleY = GetFunction(*Library_, "dEntityScaleY")
Prototype.F _dxEntityScaleZ(entity.L)
Global dxEntityScaleZ._dxEntityScaleZ = GetFunction(*Library_, "dEntityScaleZ")
Prototype.L _dxCreateLight(type.L, parent.L)
Global dxCreateLight._dxCreateLight = GetFunction(*Library_, "dCreateLight")
Prototype.L _dxColorRed()
Global dxColorRed._dxColorRed = GetFunction(*Library_, "dColorRed")
Prototype.L _dxColorGreen()
Global dxColorGreen._dxColorGreen = GetFunction(*Library_, "dColorGreen")
Prototype.L _dxColorBlue()
Global dxColorBlue._dxColorBlue = GetFunction(*Library_, "dColorBlue")
Prototype.L _dxGraphicsBuffer()
Global dxGraphicsBuffer._dxGraphicsBuffer = GetFunction(*Library_, "dGraphicsBuffer")
Prototype.L _dxSetBuffer(buffer.L)
Global dxSetBuffer._dxSetBuffer = GetFunction(*Library_, "dSetBuffer")
Prototype.L _dxCreateText(text.p-ascii, extrusion.F)
Global dxCreateText._dxCreateText = GetFunction(*Library_, "dCreateText")
Prototype.L _dx3DFont(font.p-ascii, bold.L, italic.L, underline.L, strikeout.L)
Global dx3DFont._dx3DFont = GetFunction(*Library_, "d3DFont")
Prototype.L _dxRect(x.L, y.L, width.L, height.L, solid.L)
Global dxRect._dxRect = GetFunction(*Library_, "dRect")
Prototype.L _dxTextureBuffer(texture)
Global dxTextureBuffer._dxTextureBuffer = GetFunction(*Library_, "dTextureBuffer")
Prototype.L _dxGraphicsWidth()
Global dxGraphicsWidth._dxGraphicsWidth = GetFunction(*Library_, "dGraphicsWidth")
Prototype.L _dxGraphicsHeight()
Global dxGraphicsHeight._dxGraphicsHeight = GetFunction(*Library_, "dGraphicsHeight")
Prototype.L _dxGraphicsDepth()
Global dxGraphicsDepth._dxGraphicsDepth = GetFunction(*Library_, "dGraphicsDepth")
Prototype.L _dxGetColor(x.L, y.L)
Global dxGetColor._dxGetColor = GetFunction(*Library_, "dGetColor")
Prototype.L _dxReadPixel(x.L, y.L, buffer)
Global dxReadPixel._dxReadPixel = GetFunction(*Library_, "dReadPixel")
Prototype.L _dxLightColor(light.L, red.L, green.L, blue.L)
Global dxLightColor._dxLightColor = GetFunction(*Library_, "dLightColor")
Prototype.L _dxLightRange(light.L, range.F)
Global dxLightRange._dxLightRange = GetFunction(*Library_, "dLightRange")
Prototype.L _dxLightConeAngles(light.L, inner_angle.F, outer_angle.F)
Global dxLightConeAngles._dxLightConeAngles = GetFunction(*Library_, "dLightConeAngles")
Prototype.L _dxHideEntity(entity.L)
Global dxHideEntity._dxHideEntity = GetFunction(*Library_, "dHideEntity")
Prototype.L _dxShowEntity(entity.L)
Global dxShowEntity._dxShowEntity = GetFunction(*Library_, "dShowEntity")
Prototype.L _dxEntityOrder(entity.L, order.L)
Global dxEntityOrder._dxEntityOrder = GetFunction(*Library_, "dEntityOrder")
Prototype.L _dxOval(x.L, y.L, width.L, height.L, solid.L)
Global dxOval._dxOval = GetFunction(*Library_, "dOval")
Prototype.L _dxLine(x1.L, y1.L, x2.L, y2.L)
Global dxLine._dxLine = GetFunction(*Library_, "dLine")
Prototype.L _dxText(x.L, y.L, text.p-ascii, center_x.L, center_y.L)
Global dxText._dxText = GetFunction(*Library_, "dText")
Prototype.L _dxSetFont(font.L)
Global dxSetFont._dxSetFont = GetFunction(*Library_, "dSetFont")
Prototype.L _dxFreeFont(font.L)
Global dxFreeFont._dxFreeFont = GetFunction(*Library_, "dFreeFont")
Prototype.L _dxUpdateSurfaceNormals(surface.L)
Global dxUpdateSurfaceNormals._dxUpdateSurfaceNormals = GetFunction(*Library_, "dUpdateSurfaceNormals")
Prototype.L _dxWBuffer(enable.L)
Global dxWBuffer._dxWBuffer = GetFunction(*Library_, "dWBuffer")
Prototype.L _dxPixelShaderVersion()
Global dxPixelShaderVersion._dxPixelShaderVersion = GetFunction(*Library_, "dxPixelShaderVersion")
Prototype.L _dxVertexShaderVersion()
Global dxVertexShaderVersion._dxVertexShaderVersion = GetFunction(*Library_, "dxVertexShaderVersion")
Prototype.L _dxCreatePixelShader(operation.p-ascii, file.p-ascii, entry_point.p-ascii, version.p-ascii)
Global dxCreatePixelShader._dxCreatePixelShader = GetFunction(*Library_, "dCreatePixelShader")
Prototype.L _dxFreePixelShader(pixel_shader.L)
Global dxFreePixelShader._dxFreePixelShader = GetFunction(*Library_, "dFreePixelShader")
Prototype.L _dxCreateVertexShader(operation.p-ascii, file.p-ascii, entry_point.p-ascii, version.p-ascii)
Global dxCreateVertexShader._dxCreateVertexShader = GetFunction(*Library_, "dCreateVertexShader")
Prototype.L _dxFreeVertexShader(vertex_shader.L)
Global dxFreeVertexShader._dxFreeVertexShader = GetFunction(*Library_, "dFreeVertexShader")
Prototype.L _dxEntityPixelShader(entity.L, pixel_shader.L)
Global dxEntityPixelShader._dxEntityPixelShader = GetFunction(*Library_, "dEntityPixelShader")
Prototype.L _dxEntityVertexShader(entity.L, vertex_shader.L)
Global dxEntityVertexShader._dxEntityVertexShader = GetFunction(*Library_, "dEntityVertexShader")
Prototype.I _dxGetLastShaderError()
Global dxGetLastShaderError_._dxGetLastShaderError = GetFunction(*Library_, "dGetLastShaderError")
Macro dxGetLastShaderError() : PeekS(dxGetLastShaderError_(), -1, #PB_Ascii) : EndMacro
Prototype.L _dxVertexCoords(surface.L, vertex.L, x.F, y.F, z.F)
Global dxVertexCoords._dxVertexCoords = GetFunction(*Library_, "dVertexCoords")
Prototype.L _dxFlipMesh(mesh.L)
Global dxFlipMesh._dxFlipMesh = GetFunction(*Library_, "dFlipMesh")
Prototype.L _dxApptitle(title.p-ascii)
Global dxApptitle._dxApptitle = GetFunction(*Library_, "dApptitle")
Prototype.L _dxCountEntities()
Global dxCountEntities._dxCountEntities = GetFunction(*Library_, "dCountEntities")
Prototype.L _dxGetSurface(mesh.L, surface.L)
Global dxGetSurface._dxGetSurface = GetFunction(*Library_, "dGetSurface")
Prototype.L _dxFirstEntity()
Global dxFirstEntity._dxFirstEntity = GetFunction(*Library_, "dFirstEntity")
Prototype.L _dxNextEntity(present_entity.L)
Global dxNextEntity._dxNextEntity = GetFunction(*Library_, "dNextEntity")
Prototype.L _dxPreviousEntity(present_entity.L)
Global dxPreviousEntity._dxPreviousEntity = GetFunction(*Library_, "dPreviousEntity")
Prototype.L _dxEntityBlend(entity, blend.L)
Global dxEntityBlend._dxEntityBlend = GetFunction(*Library_, "dEntityBlend")
Prototype.L _dxCopyEntity(entity, parent)
Global dxCopyEntity._dxCopyEntity = GetFunction(*Library_, "dCopyEntity")
Prototype.L _dxFreeSurface(surface.L)
Global dxFreeSurface._dxFreeSurface = GetFunction(*Library_, "dFreeSurface")
Prototype.L _dxTextureBlend(texture.L, blend.L)
Global dxTextureBlend._dxTextureBlend = GetFunction(*Library_, "dTextureBlend")
Prototype.F _dxGetVersion()
Global dxGetVersion._dxGetVersion = GetFunction(*Library_, "dGetVersion")
Prototype.L _dxStringWidth(string.p-ascii)
Global dxStringWidth._dxStringWidth = GetFunction(*Library_, "dStringWidth")
Prototype.L _dxStringHeight(string.p-ascii)
Global dxStringHeight._dxStringHeight = GetFunction(*Library_, "dStringHeight")
Prototype.L _dxCreateBrush(red.F, green.F, blue.F)
Global dxCreateBrush._dxCreateBrush = GetFunction(*Library_, "dCreateBrush")
Prototype.L _dxFreeBrush(brush.L)
Global dxFreeBrush._dxFreeBrush = GetFunction(*Library_, "dFreeBrush")
Prototype.L _dxBrushColor(brush.L, red.F, green.F, blue.F)
Global dxBrushColor._dxBrushColor = GetFunction(*Library_, "dBrushColor")
Prototype.L _dxBrushAlpha(brush.L, alpha.F)
Global dxBrushAlpha._dxBrushAlpha = GetFunction(*Library_, "dBrushAlpha")
Prototype.L _dxBrushShininess(brush.L, shininess.F)
Global dxBrushShininess._dxBrushShininess = GetFunction(*Library_, "dBrushShininess")
Prototype.L _dxBrushFX(brush.L, fx.L)
Global dxBrushFX._dxBrushFX = GetFunction(*Library_, "dBrushFX")
Prototype.L _dxBrushTexture(brush.L, texture.L, frame.L, index.L)
Global dxBrushTexture._dxBrushTexture = GetFunction(*Library_, "dBrushTexture")
Prototype.L _dxBrushBlend(brush.L, blend.L)
Global dxBrushBlend._dxBrushBlend = GetFunction(*Library_, "dBrushBlend")
Prototype.L _dxGetEntityBrush(entity.L)
Global dxGetEntityBrush._dxGetEntityBrush = GetFunction(*Library_, "dGetEntityBrush")
Prototype.L _dxNameTexture(texture.L, name.p-ascii)
Global dxNameTexture._dxNameTexture = GetFunction(*Library_, "dNameTexture")
Prototype.I _dxTextureName(texture.L)
Global dxTextureName_._dxTextureName = GetFunction(*Library_, "dTextureName")
Macro dxTextureName(texture) : PeekS(dxTextureName_(texture), -1, #PB_Ascii) : EndMacro
Prototype.L _dxTextureCoords(texture.L, coord_set.L)
Global dxTextureCoords._dxTextureCoords = GetFunction(*Library_, "dTextureCoords")
Prototype.L _dxTextureWidth(texture.L)
Global dxTextureWidth._dxTextureWidth = GetFunction(*Library_, "dTextureWidth")
Prototype.L _dxTextureHeight(texture.L)
Global dxTextureHeight._dxTextureHeight = GetFunction(*Library_, "dTextureHeight")
Prototype.F _dxGetDebugFloat()
Global dxGetDebugFloat._dxGetDebugFloat = GetFunction(*Library_, "dGetDebugFloat")
Prototype.L _dxScaleTexture(texture.L, u_scale.F, v_scale.F)
Global dxScaleTexture._dxScaleTexture = GetFunction(*Library_, "dScaleTexture")
Prototype.L _dxPositionTexture(texture.L, u_position.F, v_position.F)
Global dxPositionTexture._dxPositionTexture = GetFunction(*Library_, "dPositionTexture")
Prototype.L _dxRotateTexture(texture.L, angle.F)
Global dxRotateTexture._dxRotateTexture = GetFunction(*Library_, "dRotateTexture")
Prototype.L _dxEntityAlpha(entity.L, alpha.F)
Global dxEntityAlpha._dxEntityAlpha = GetFunction(*Library_, "dEntityAlpha")
Prototype.F _dxGetEntityAlpha(entity.L)
Global dxGetEntityAlpha._dxGetEntityAlpha = GetFunction(*Library_, "dGetEntityAlpha")
Prototype.L _dxPositionMesh(mesh.L, x.F, y.F, z.F)
Global dxPositionMesh._dxPositionMesh = GetFunction(*Library_, "dPositionMesh")
Prototype.F _dxMeshWidth(mesh.L)
Global dxMeshWidth._dxMeshWidth = GetFunction(*Library_, "dMeshWidth")
Prototype.F _dxMeshHeight(mesh.L)
Global dxMeshHeight._dxMeshHeight = GetFunction(*Library_, "dMeshHeight")
Prototype.F _dxMeshDepth(mesh.L)
Global dxMeshDepth._dxMeshDepth = GetFunction(*Library_, "dMeshDepth")
Prototype.F _dxEntityPitch(entity.L, Global_.L)
Global dxEntityPitch._dxEntityPitch = GetFunction(*Library_, "dEntityPitch")
Prototype.F _dxEntityYaw(entity.L, Global_.L)
Global dxEntityYaw._dxEntityYaw = GetFunction(*Library_, "dEntityYaw")
Prototype.F _dxEntityRoll(entity.L, Global_.L)
Global dxEntityRoll._dxEntityRoll = GetFunction(*Library_, "dEntityRoll")
Prototype.L _dxFreeSurfaceAttribs(surface.L)
Global dxFreeSurfaceAttribs._dxFreeSurfaceAttribs = GetFunction(*Library_, "dFreeSurfaceAttribs")
Prototype.L _dxSurfaceFx(surface.L, fx.L)
Global dxSurfaceFx._dxSurfaceFx = GetFunction(*Library_, "dSurfaceFx")
Prototype.L _dxSurfaceBlend(surface.L, blend.L)
Global dxSurfaceBlend._dxSurfaceBlend = GetFunction(*Library_, "dSurfaceBlend")
Prototype.L _dxSurfaceAlpha(surface.L, alpha.F)
Global dxSurfaceAlpha._dxSurfaceAlpha = GetFunction(*Library_, "dSurfaceAlpha")
Prototype.L _dxSurfaceWireframe(surface.L, enable.L)
Global dxSurfaceWireframe._dxSurfaceWireframe = GetFunction(*Library_, "dSurfaceWireframe")
Prototype.L _dxSurfacePointframe(surface.L, enable.L)
Global dxSurfacePointframe._dxSurfacePointframe = GetFunction(*Library_, "dSurfacePointframe")
Prototype.L _dxSurfacePixelShader(surface.L, pixel_shader.L)
Global dxSurfacePixelShader._dxSurfacePixelShader = GetFunction(*Library_, "dSurfacePixelShader")
Prototype.L _dxSurfaceVertexShader(surface.L, vertex_shader.L)
Global dxSurfaceVertexShader._dxSurfaceVertexShader = GetFunction(*Library_, "dSurfaceVertexShader")
Prototype.L _dxSurfaceColor(surface.L, red.L, green.L, blue.L)
Global dxSurfaceColor._dxSurfaceColor = GetFunction(*Library_, "dSurfaceColor")
Prototype.L _dxGetSurfaceBrush(surface.L)
Global dxGetSurfaceBrush._dxGetSurfaceBrush = GetFunction(*Library_, "dGetSurfaceBrush")
Prototype.L _dxPaintEntity(entity.L, brush.L)
Global dxPaintEntity._dxPaintEntity = GetFunction(*Library_, "dPaintEntity")
Prototype.L _dxPaintSurface(surface.L, brush.L)
Global dxPaintSurface._dxPaintSurface = GetFunction(*Library_, "dPaintSurface")
Prototype.L _dxSurfaceTexture(surf.L, texture.L, frame.L, index.L)
Global dxSurfaceTexture._dxSurfaceTexture = GetFunction(*Library_, "dSurfaceTexture")
Prototype.L _dxWritePixel(x.L, y.L, argb.L, buffer.L)
Global dxWritePixel._dxWritePixel = GetFunction(*Library_, "dWritePixel")
Prototype.L _dxLockBuffer(buffer.L)
Global dxLockBuffer._dxLockBuffer = GetFunction(*Library_, "dLockBuffer")
Prototype.L _dxUnLockBuffer(buffer.L)
Global dxUnLockBuffer._dxUnLockBuffer = GetFunction(*Library_, "dUnLockBuffer")
Prototype.L _dxWritePixelFast(x.L, y.L, argb.L, buffer.L)
Global dxWritePixelFast._dxWritePixelFast = GetFunction(*Library_, "dWritePixelFast")
Prototype.L _dxReadPixelFast(x.L, y.L, buffer.L)
Global dxReadPixelFast._dxReadPixelFast = GetFunction(*Library_, "dReadPixelFast")
Prototype.L _dxTextureSave(texture.L, filename.p-ascii, type)
Global dxTextureSave._dxTextureSave = GetFunction(*Library_, "dTextureSave")
Prototype.L _dxCopySurface(surface.L, parent_entity.L)
Global dxCopySurface._dxCopySurface = GetFunction(*Library_, "dCopySurface")
Prototype.L _dxCopyMesh(entity.L, parent.L)
Global dxCopyMesh._dxCopyMesh = GetFunction(*Library_, "dCopyMesh")
Prototype.L _dxCreateImage(width.L, height.L, frames.L)
Global dxCreateImage._dxCreateImage = GetFunction(*Library_, "dCreateImage")
Prototype.L _dxFreeImage(image.L)
Global dxFreeImage._dxFreeImage = GetFunction(*Library_, "dFreeImage")
Prototype.L _dxImageWidth(image.L)
Global dxImageWidth._dxImageWidth = GetFunction(*Library_, "dImageWidth")
Prototype.L _dxImageHeight(image.L)
Global dxImageHeight._dxImageHeight = GetFunction(*Library_, "dImageHeight")
Prototype.L _dxImageBuffer(image.L)
Global dxImageBuffer._dxImageBuffer = GetFunction(*Library_, "dImageBuffer")
Prototype.L _dxCopyImage(image.L)
Global dxCopyImage._dxCopyImage = GetFunction(*Library_, "dCopyImage")
Prototype.L _dxCopyRect(src_x.L, src_y.L, src_width.L, src_height.L, dest_x.L, dest_y.L, src_buffer.L, dest_buffer.L)
Global dxCopyRect._dxCopyRect = GetFunction(*Library_, "dCopyRect")
Prototype.L _dxSetFilters(max.L, min.L, mip.L)
Global dxSetFilters._dxSetFilters = GetFunction(*Library_, "dSetFilters")
Prototype.L _dxRenderToTexture(texture.L)
Global dxRenderToTexture._dxRenderToTexture = GetFunction(*Library_, "dRenderToTexture")
Prototype.L _dxRenderToScreen()
Global dxRenderToScreen._dxRenderToScreen = GetFunction(*Library_, "dRenderToScreen")
Prototype.L _dxCreateSprite(parent.L)
Global dxCreateSprite._dxCreateSprite = GetFunction(*Library_, "dCreateSprite")
Prototype.L _dxSpriteViewMode(sprite.L, view_mode.L)
Global dxSpriteViewMode._dxSpriteViewMode = GetFunction(*Library_, "dSpriteViewMode")
Prototype.L _dxScaleSprite(sprite.L, x_scale.F, y_scale.F)
Global dxScaleSprite._dxScaleSprite = GetFunction(*Library_, "dScaleSprite")
Prototype.L _dxHandleSprite(sprite.L, x.F, y.F)
Global dxHandleSprite._dxHandleSprite = GetFunction(*Library_, "dHandleSprite")
Prototype.L _dxUseDirectX11(enable.L)
Global dxUseDirectX11._dxUseDirectX11 = GetFunction(*Library_, "dUseDirectX11")
Prototype.L _dxDirectX11Used()
Global dxDirectX11Used._dxDirectX11Used = GetFunction(*Library_, "dDirectX11Used")
Prototype.L _dxSeedRnd(seed.L)
Global dxSeedRnd._dxSeedRnd = GetFunction(*Library_, "dSeedRnd")
Prototype.F _dxRnd(low.F, high.F)
Global dxRnd._dxRnd = GetFunction(*Library_, "dRnd")
Prototype.L _dxRand(low.L, high.L)
Global dxRand._dxRand = GetFunction(*Library_, "dRand")
Prototype.L _dxCreatePivot(parent.L)
Global dxCreatePivot._dxCreatePivot = GetFunction(*Library_, "dCreatePivot")
Prototype.L _dxBufferNoise(buffer, x, y, w, h, red_filter.F, green_filter.F, blue_filter.F, alpha_filter.F)
Global dxBufferNoise._dxBufferNoise = GetFunction(*Library_, "dBufferNoise")
Prototype.L _dxBufferInvert(buffer, x, y, w, h)
Global dxBufferInvert._dxBufferInvert = GetFunction(*Library_, "dBufferInvert")
Prototype.L _dxSetCubeFace(texture.L, face.L)
Global dxSetCubeFace._dxSetCubeFace = GetFunction(*Library_, "dSetCubeFace")
Prototype.F _dxGetSurfaceBoundingRadius(surface.L)
Global dxGetSurfaceBoundingRadius._dxGetSurfaceBoundingRadius = GetFunction(*Library_, "dGetSurfaceBoundingRadius")
Prototype.L _dxTrisRendered()
Global dxTrisRendered._dxTrisRendered = GetFunction(*Library_, "dTrisRendered")
Prototype.L _dxEntityInView(entity.L, camera.L)
Global dxEntityInView._dxEntityInView = GetFunction(*Library_, "dEntityInView")
Prototype.L _dxMaxLights()
Global dxMaxLights._dxMaxLights = GetFunction(*Library_, "dMaxLights")
Prototype.L _dxCreateTerrain(grid_size.L, parent.L)
Global dxCreateTerrain._dxCreateTerrain = GetFunction(*Library_, "dCreateTerrain")
Prototype.L _dxModifyTerrain(terrain.L, grid_x.L, grid_z.L, height.F, realtime)
Global dxModifyTerrain._dxModifyTerrain = GetFunction(*Library_, "dModifyTerrain")
Prototype.L _dxTerrainSize(terrain.L)
Global dxTerrainSize._dxTerrainSize = GetFunction(*Library_, "dTerrainSize")
Prototype.L _dxLoadTerrain(file.p-ascii, parent.L)
Global dxLoadTerrain._dxLoadTerrain = GetFunction(*Library_, "dLoadTerrain")
Prototype.F _dxTerrainHeight(terrain.L, grid_x.F, grid_z.F)
Global dxTerrainHeight._dxTerrainHeight = GetFunction(*Library_, "dTerrainHeight")
Prototype.L _dxFitMesh(mesh.L, x.F, y.F, z.F, w.F, h.F, d.F, uniform)
Global dxFitMesh._dxFitMesh = GetFunction(*Library_, "dFitMesh")
Prototype.L _dxScaleMesh(mesh.L, width.F, height.F, depth.F)
Global dxScaleMesh._dxScaleMesh = GetFunction(*Library_, "dScaleMesh")
Prototype.L _dxGetConstantTableSize(shader.L)
Global dxGetConstantTableSize._dxGetConstantTableSize = GetFunction(*Library_, "dGetConstantTableSize")
Prototype.L _dxConstantCount(shader.L)
Global dxConstantCount._dxConstantCount = GetFunction(*Library_, "dConstantCount")
Prototype.L _dxDeclareVertexShaderWorldConstant(shader.L, constant_name.p-ascii)
Global dxDeclareVertexShaderWorldConstant._dxDeclareVertexShaderWorldConstant = GetFunction(*Library_, "dDeclareVertexShaderWorldConstant")
Prototype.L _dxDeclareVertexShaderViewConstant(shader.L, constant_name.p-ascii)
Global dxDeclareVertexShaderViewConstant._dxDeclareVertexShaderViewConstant = GetFunction(*Library_, "dDeclareVertexShaderViewConstant")
Prototype.L _dxDeclareVertexShaderProjConstant(shader.L, constant_name.p-ascii)
Global dxDeclareVertexShaderProjConstant._dxDeclareVertexShaderProjConstant = GetFunction(*Library_, "dDeclareVertexShaderProjConstant")
Prototype.L _dxDeclareVertexShaderWorldViewProjConstant(shader.L, constant_name.p-ascii)
Global dxDeclareVertexShaderWorldViewProjConstant._dxDeclareVertexShaderWorldViewProjCo
nstant = GetFunction(*Library_, "dDeclareVertexShaderWorldViewProjConstant")
Prototype.L _dxEntityRadius(entity.L, radius_x.F, radius_y.F)
Global dxEntityRadius._dxEntityRadius = GetFunction(*Library_, "dEntityRadius")
Prototype.L _dxEntityBox(entity.L, x.F, y.F, z.F, width.F, height.F, depth.F)
Global dxEntityBox._dxEntityBox = GetFunction(*Library_, "dEntityBox")
Prototype.L _dxEntityType(entity.L, collision_type.L, recursive.L)
Global dxEntityType._dxEntityType = GetFunction(*Library_, "dEntityType")
Prototype.L _dxEntityPickMode(entity.L, pick_geometry.L, obscurer.L)
Global dxEntityPickMode._dxEntityPickMode = GetFunction(*Library_, "dEntityPickMode")
Prototype.L _dxGetEntityType(entity.L)
Global dxGetEntityType._dxGetEntityType = GetFunction(*Library_, "dGetEntityType")
Prototype.L _dxGetFPS()
Global dxGetFPS._dxGetFPS = GetFunction(*Library_, "dGetFPS")
Prototype.L _dxPointEntity(entity.L, target.L, roll.F)
Global dxPointEntity._dxPointEntity = GetFunction(*Library_, "dPointEntity")
Prototype.L _dxAlignToVector(entity.L, vector_x.F, vector_y.F, vector_z.F, axis.L, rate.F)
Global dxAlignToVector._dxAlignToVector = GetFunction(*Library_, "dAlignToVector")
Prototype.L _dxFramesRendered()
Global dxFramesRendered._dxFramesRendered = GetFunction(*Library_, "dFramesRendered")
Prototype.L _dxTFormPoint(x.F, y.F, z.F, source_entity, dest_entity)
Global dxTFormPoint._dxTFormPoint = GetFunction(*Library_, "dTFormPoint")
Prototype.F _dxTFormedX()
Global dxTFormedX._dxTFormedX = GetFunction(*Library_, "dTFormedX")
Prototype.F _dxTFormedY()
Global dxTFormedY._dxTFormedY = GetFunction(*Library_, "dTFormedY")
Prototype.F _dxTFormedZ()
Global dxTFormedZ._dxTFormedZ = GetFunction(*Library_, "dTFormedZ")
Prototype.F _dxEntityDistance(src_entity.L, dest_entity.L)
Global dxEntityDistance._dxEntityDistance = GetFunction(*Library_, "dEntityDistance")
Prototype.F _dxVectorYaw(x.F, y.F, z.F)
Global dxVectorYaw._dxVectorYaw = GetFunction(*Library_, "dVectorYaw")
Prototype.F _dxVectorPitch(x.F, y.F, z.F)
Global dxVectorPitch._dxVectorPitch = GetFunction(*Library_, "dVectorPitch")
Prototype.L _dxCameraProject(camera.L, x.F, y.F, z.F)
Global dxCameraProject._dxCameraProject = GetFunction(*Library_, "dCameraProject")
Prototype.F _dxProjectedX()
Global dxProjectedX._dxProjectedX = GetFunction(*Library_, "dProjectedX")
Prototype.F _dxProjectedY()
Global dxProjectedY._dxProjectedY = GetFunction(*Library_, "dProjectedY")
Prototype.F _dxProjectedZ()
Global dxProjectedZ._dxProjectedZ = GetFunction(*Library_, "dProjectedZ")
Prototype.F _dxDeltaPitch(src_entity, dest_entity)
Global dxDeltaPitch._dxDeltaPitch = GetFunction(*Library_, "dDeltaPitch")
Prototype.F _dxDeltaYaw(src_entity, dest_entity)
Global dxDeltaYaw._dxDeltaYaw = GetFunction(*Library_, "dDeltaYaw")
Prototype.L _dxCameraPick(camera.L, viewport_x, viewport_y)
Global dxCameraPick._dxCameraPick = GetFunction(*Library_, "dCameraPick")
Prototype.F _dxPickedX()
Global dxPickedX._dxPickedX = GetFunction(*Library_, "dPickedX")
Prototype.F _dxPickedY()
Global dxPickedY._dxPickedY = GetFunction(*Library_, "dPickedY")
Prototype.F _dxPickedZ()
Global dxPickedZ._dxPickedZ = GetFunction(*Library_, "dPickedZ")
Prototype.F _dxPickedNX()
Global dxPickedNX._dxPickedNX = GetFunction(*Library_, "dPickedNX")
Prototype.F _dxPickedNY()
Global dxPickedNY._dxPickedNY = GetFunction(*Library_, "dPickedNY")
Prototype.F _dxPickedNZ()
Global dxPickedNZ._dxPickedNZ = GetFunction(*Library_, "dPickedNZ")
Prototype.L _dxPickedTime()
Global dxPickedTime._dxPickedTime = GetFunction(*Library_, "dPickedTime")
Prototype.L _dxPickedEntity()
Global dxPickedEntity._dxPickedEntity = GetFunction(*Library_, "dPickedEntity")
Prototype.L _dxPickedSurface()
Global dxPickedSurface._dxPickedSurface = GetFunction(*Library_, "dPickedSurface")
Prototype.L _dxPickedTriangle()
Global dxPickedTriangle._dxPickedTriangle = GetFunction(*Library_, "dPickedTriangle")
Prototype.L _dxEntityPick(entity, range.F)
Global dxEntityPick._dxEntityPick = GetFunction(*Library_, "dEntityPick")
Prototype.L _dxLinePick(x.F, y.F, z.F, dx.F, dy.F, dz.F, radius.F)
Global dxLinePick._dxLinePick = GetFunction(*Library_, "dLinePick")
Prototype.L _dxHideWindow(enable)
Global dxHideWindow._dxHideWindow = GetFunction(*Library_, "dHideWindow")
Prototype.L _dxIsWindowMinimized()
Global dxIsWindowMinimized._dxIsWindowMinimized = GetFunction(*Library_, "dIsWindowMinimized")
Prototype.L _dxRotateMesh(entity.L, pitch.F, yaw.F, roll.F)
Global dxRotateMesh._dxRotateMesh = GetFunction(*Library_, "dRotateMesh")
Prototype.L _dxCreateEmitter(elements.L, base_entity.L, parent.L)
Global dxCreateEmitter._dxCreateEmitter = GetFunction(*Library_, "dCreateEmitter")
Prototype.L _dxEmitterCountElements(emitter.L)
Global dxEmitterCountElements._dxEmitterCountElements = GetFunction(*Library_, "dEmitterCountElements")
Prototype.L _dxEmitterSetElementCount(emitter.L, count.L)
Global dxEmitterSetElementCount._dxEmitterSetElementCount = GetFunction(*Library_, "dEmitterSetElementCount")
Prototype.L _dxEmitterDeleteElement(emitter.L, element.L)
Global dxEmitterDeleteElement._dxEmitterDeleteElement = GetFunction(*Library_, "dEmitterDeleteElement")
Prototype.I _dxGetWinVersion()
Global dxGetWinVersion_._dxGetWinVersion = GetFunction(*Library_, "dGetWinVersion")
Macro dxGetWinVersion() : PeekS(dxGetWinVersion_(), -1, #PB_Ascii) : EndMacro
Prototype.L _dxCameraZoom(camera.L, zoom.F)
Global dxCameraZoom._dxCameraZoom = GetFunction(*Library_, "dCameraZoom")
Prototype.L _dxSurfaceShininess(surface.L, shininess.F)
Global dxSurfaceShininess._dxSurfaceShininess = GetFunction(*Library_, "dSurfaceShininess")
Prototype.L _dxEntityShininess(entity.L, shininess.F)
Global dxEntityShininess._dxEntityShininess = GetFunction(*Library_, "dEntityShininess")
Prototype.L _dxCreateMaze(width.L, height.L, halls.L)
Global dxCreateMaze._dxCreateMaze = GetFunction(*Library_, "dCreateMaze")
Prototype.L _dxFreeMaze(maze.L)
Global dxFreeMaze._dxFreeMaze = GetFunction(*Library_, "dFreeMaze")
Prototype.L _dxReadMaze(maze.L, x.L, z.L)
Global dxReadMaze._dxReadMaze = GetFunction(*Library_, "dReadMaze")
Prototype.L _dxLoadMesh(file.p-ascii, parent.L)
Global dxLoadMesh._dxLoadMesh = GetFunction(*Library_, "dLoadMesh")
Prototype.L _dxSaveMesh(file.p-ascii, entity)
Global dxSaveMesh._dxSaveMesh = GetFunction(*Library_, "dSaveMesh")
Prototype.L _dxLoadMeshXFromBank(bank.L, parent.L)
Global dxLoadMeshXFromBank._dxLoadMeshXFromBank = GetFunction(*Library_, "dLoadMeshXFromBank")
Prototype.L _dxLoadTextureFromBank(bank.L, flags.L)
Global dxLoadTextureFromBank._dxLoadTextureFromBank = GetFunction(*Library_, "dLoadTextureFromBank")
Prototype.L _dxBoneAddNode(entity.L)
Global dxBoneAddNode._dxBoneAddNode = GetFunction(*Library_, "dBoneAddNode")
Prototype.L _dxBoneNodeCount(entity.L)
Global dxBoneNodeCount._dxBoneNodeCount = GetFunction(*Library_, "dBoneNodeCount")
Prototype.L _dxBoneParentNode(child_node.L, parent_node.L)
Global dxBoneParentNode._dxBoneParentNode = GetFunction(*Library_, "dBoneParentNode")
Prototype.L _dxFreeBoneNode(node.L)
Global dxFreeBoneNode._dxFreeBoneNode = GetFunction(*Library_, "dFreeBoneNode")
Prototype.L _dxBoneCountNodeSiblings(node.L)
Global dxBoneCountNodeSiblings._dxBoneCountNodeSiblings = GetFunction(*Library_, "dBoneCountNodeSiblings")
Prototype.L _dxBonePositionNode(node, x.F, y.F, z.F)
Global dxBonePositionNode._dxBonePositionNode = GetFunction(*Library_, "dBonePositionNode")
Prototype.F _dxBoneNodeX(node.L)
Global dxBoneNodeX._dxBoneNodeX = GetFunction(*Library_, "dBoneNodeX")
Prototype.F _dxBoneNodeY(node.L)
Global dxBoneNodeY._dxBoneNodeY = GetFunction(*Library_, "dBoneNodeY")
Prototype.F _dxBoneNodeZ(node.L)
Global dxBoneNodeZ._dxBoneNodeZ = GetFunction(*Library_, "dBoneNodeZ")
Prototype.L _dxBoneRotateNode(node.L, pitch.F, yaw.F, roll.F)
Global dxBoneRotateNode._dxBoneRotateNode = GetFunction(*Library_, "dBoneRotateNode")
Prototype.F _dxBoneNodePitch(node.L)
Global dxBoneNodePitch._dxBoneNodePitch = GetFunction(*Library_, "dBoneNodePitch")
Prototype.F _dxBoneNodeYaw(node.L)
Global dxBoneNodeYaw._dxBoneNodeYaw = GetFunction(*Library_, "dBoneNodeYaw")
Prototype.F _dxBoneNodeRoll(node.L)
Global dxBoneNodeRoll._dxBoneNodeRoll = GetFunction(*Library_, "dBoneNodeRoll")
Prototype.L _dxBoneGetParentNode(node.L)
Global dxBoneGetParentNode._dxBoneGetParentNode = GetFunction(*Library_, "dBoneGetParentNode")
Prototype.L _dxBoneCountChildren(node.L)
Global dxBoneCountChildren._dxBoneCountChildren = GetFunction(*Library_, "dBoneCountChildren")
Prototype.L _dxBoneGetChild(node.L, child_no.L)
Global dxBoneGetChild._dxBoneGetChild = GetFunction(*Library_, "dBoneGetChild")
Prototype.L _dxBankSize(bank.L)
Global dxBankSize._dxBankSize = GetFunction(*Library_, "dBankSize")
Prototype.L _dxPeekMemInt(address.L)
Global dxPeekMemInt._dxPeekMemInt = GetFunction(*Library_, "dPeekMemInt")
Prototype.L _dxPokeMemInt(address.L, value.L)
Global dxPokeMemInt._dxPokeMemInt = GetFunction(*Library_, "dPokeMemInt")
Prototype.L _dxLocate(x.L, y.L)
Global dxLocate._dxLocate = GetFunction(*Library_, "dLocate")
Prototype.L _dxPrint(string.p-ascii)
Global dxPrint._dxPrint = GetFunction(*Library_, "dPrint")
Prototype.L _dxLoadAnimTexture(file.p-ascii, flags.L, frame_width.L, frame_height.L, first_frame.L, frame_count.L)
Global dxLoadAnimTexture._dxLoadAnimTexture = GetFunction(*Library_, "dLoadAnimTexture")
Prototype.L _dxLoadAnimTextureFromBank(bank.L, flags.L, frame_width.L, frame_height.L, first_frame.L, frame_count.L)
Global dxLoadAnimTextureFromBank._dxLoadAnimTextureFromBank = GetFunction(*Library_, "dLoadAnimTextureFromBank")
Prototype.L _dxMeshesIntersect(mesh_a.L, mesh_b.L)
Global dxMeshesIntersect._dxMeshesIntersect = GetFunction(*Library_, "dMeshesIntersect")
Prototype.L _dxRotateSprite(sprite.L, angle.F)
Global dxRotateSprite._dxRotateSprite = GetFunction(*Library_, "dRotateSprite")
Prototype.L _dxUpdateWorld(anim_speed.F)
Global dxUpdateWorld._dxUpdateWorld = GetFunction(*Library_, "dUpdateWorld")
Prototype.L _dxCreateCone(segments.L, solid.L, parent.L)
Global dxCreateCone._dxCreateCone = GetFunction(*Library_, "dCreateCone")
Prototype.L _dxLightCaster(light, enable)
Global dxLightCaster._dxLightCaster = GetFunction(*Library_, "dLightCaster")
Prototype.L _dxEntityCaster(entity, enable)
Global dxEntityCaster._dxEntityCaster = GetFunction(*Library_, "dEntityCaster")
Prototype.L _dxEnityShadowDetail(entity.L, triangles.L, detail_percent.F)
Global dxEnityShadowDetail._dxEnityShadowDetail = GetFunction(*Library_, "dEnityShadowDetail")
Prototype.L _dxEnityShadowColor(entity.L, red.L, green.L, blue.L)
Global dxEnityShadowColor._dxEnityShadowColor = GetFunction(*Library_, "dEnityShadowColor")
Prototype.L _dxEnityShadowIntensity(entity.L, intensity_percent.F)
Global dxEnityShadowIntensity._dxEnityShadowIntensity = GetFunction(*Library_, "dEnityShadowIntensity")
Prototype.L _dxEnableShadows(enable.L)
Global dxEnableShadows._dxEnableShadows = GetFunction(*Library_, "dEnableShadows")
Prototype.L _dxEnityShadowCutoff(entity.L, minimum.F, maximum.F, fadein.F)
Global dxEnityShadowCutoff._dxEnityShadowCutoff = GetFunction(*Library_, "dEnityShadowCutoff")
Prototype.L _dxSetVSync(enable.L)
Global dxSetVSync._dxSetVSync = GetFunction(*Library_, "dSetVSync")
Prototype.L _dxSetWindowDefaults(borderless.L, minimize_button.L, maximize_button.L, close_button.L, autoclose.L)
Global dxSetWindowDefaults._dxSetWindowDefaults = GetFunction(*Library_, "dSetWindowDefaults")
Prototype.L _dxWinClose()
Global dxWinClose._dxWinClose = GetFunction(*Library_, "dWinClose")
Prototype.L _dxClearWorld(entities.L, brushes.L, textures.L)
Global dxClearWorld._dxClearWorld = GetFunction(*Library_, "dClearWorld")
Prototype.L _dxClearCollisions()
Global dxClearCollisions._dxClearCollisions = GetFunction(*Library_, "dClearCollisions")
Prototype.L _dxCollisions(src_type.L, dest_type.L, method.L, response.L)
Global dxCollisions._dxCollisions = GetFunction(*Library_, "dCollisions")
Prototype.L _dxTextureFilter(match_text.p-ascii, flags.L)
Global dxTextureFilter._dxTextureFilter = GetFunction(*Library_, "dTextureFilter")
Prototype.L _dxClearTextureFilters()
Global dxClearTextureFilters._dxClearTextureFilters = GetFunction(*Library_, "dClearTextureFilters")
Prototype.L _dxScreenWidth()
Global dxScreenWidth._dxScreenWidth = GetFunction(*Library_, "dScreenWidth")
Prototype.L _dxScreenHeight()
Global dxScreenHeight._dxScreenHeight = GetFunction(*Library_, "dScreenHeight")
Prototype.L _dxWindowWidth()
Global dxWindowWidth._dxWindowWidth = GetFunction(*Library_, "dWindowWidth")
Prototype.L _dxWindowHeight()
Global dxWindowHeight._dxWindowHeight = GetFunction(*Library_, "dxWindowHeight")
Prototype.L _dxWindowX()
Global dxWindowX._dxWindowX = GetFunction(*Library_, "dWindowX")
Prototype.L _dxWindowY()
Global dxWindowY._dxWindowY = GetFunction(*Library_, "dWindowY")
Prototype.L _dxWindowResized()
Global dxWindowResized._dxWindowResized = GetFunction(*Library_, "dWindowResized")
Prototype.L _dxWindowMoved()
Global dxWindowMoved._dxWindowMoved = GetFunction(*Library_, "dWindowMoved")
Prototype.L _dxMeshSimplify(mesh.L, vertex_count.L, triangle_count.L, vertex_percent.F, triangle_percent.F)
Global dxMeshSimplify._dxMeshSimplify = GetFunction(*Library_, "dMeshSimplify")
Prototype.L _dxVlcPresent()
Global dxVlcPresent._dxVlcPresent = GetFunction(*Library_, "dVlcPresent")
Prototype.L _dxFreeVid(video.L)
Global dxFreeVid._dxFreeVid = GetFunction(*Library_, "dFreeVid")
Prototype.L _dxVidLoad(file.p-ascii)
Global dxVidLoad._dxVidLoad = GetFunction(*Library_, "dVidLoad")
Prototype.L _dxVidDownload(path.L)
Global dxVidDownload._dxVidDownload = GetFunction(*Library_, "dVidDownload")
Prototype.L _dxVidTrackCount(video.L)
Global dxVidTrackCount._dxVidTrackCount = GetFunction(*Library_, "dVidTrackCount")
Prototype.L _dxVidTrackType(video.L, track.L)
Global dxVidTrackType._dxVidTrackType = GetFunction(*Library_, "dVidTrackType")
Prototype.L _dxVidWidth(video.L)
Global dxVidWidth._dxVidWidth = GetFunction(*Library_, "dVidWidth")
Prototype.L _dxVidHeight(video.L)
Global dxVidHeight._dxVidHeight = GetFunction(*Library_, "dVidHeight")
Prototype.L _dxVidDuration(video.L)
Global dxVidDuration._dxVidDuration = GetFunction(*Library_, "dVidDuration")
Prototype.L _dxVidTexture(video.L, texture.L)
Global dxVidTexture._dxVidTexture = GetFunction(*Library_, "dVidTexture")
Prototype.L _dxGetVidTexture(video.L)
Global dxGetVidTexture._dxGetVidTexture = GetFunction(*Library_, "dGetVidTexture")
Prototype.L _dxVidPlay(video.L)
Global dxVidPlay._dxVidPlay = GetFunction(*Library_, "dVidPlay")
Prototype.L _dxVidPlaying(video.L)
Global dxVidPlaying._dxVidPlaying = GetFunction(*Library_, "dVidPlaying")
Prototype.L _dxVidStop(video.L)
Global dxVidStop._dxVidStop = GetFunction(*Library_, "dVidStop")
Prototype.L _dxVidPause(video.L)
Global dxVidPause._dxVidPause = GetFunction(*Library_, "dVidPause")
Prototype.L _dxVidGetPosition(video.L)
Global dxVidGetPosition._dxVidGetPosition = GetFunction(*Library_, "dVidGetPosition")
Prototype.L _dxVidSetPosition(video.L, millisecs.L)
Global dxVidSetPosition._dxVidSetPosition = GetFunction(*Library_, "dVidSetPosition")
Prototype.L _dxVidMuted(video.L)
Global dxVidMuted._dxVidMuted = GetFunction(*Library_, "dVidMuted")
Prototype.L _dxVidMute(video.L)
Global dxVidMute._dxVidMute = GetFunction(*Library_, "dVidMute")
Prototype.L _dxVidUnMute(video.L)
Global dxVidUnMute._dxVidUnMute = GetFunction(*Library_, "dVidUnMute")
Prototype.L _dxVidGetVolume(video.L)
Global dxVidGetVolume._dxVidGetVolume = GetFunction(*Library_, "dVidGetVolume")
Prototype.L _dxVidSetVolume(video.L)
Global dxVidSetVolume._dxVidSetVolume = GetFunction(*Library_, "dVidSetVolume")
Prototype.L _dxVidGetSubtitleCount(video.L)
Global dxVidGetSubtitleCount._dxVidGetSubtitleCount = GetFunction(*Library_, "dVidGetSubtitleCount")
Prototype.L _dxVidGetAudioTrackCount(video.L)
Global dxVidGetAudioTrackCount._dxVidGetAudioTrackCount = GetFunction(*Library_, "dVidGetAudioTrackCount")
Prototype.I _dxVidGetAudioTrackDescription(video.L, track.L)
Global dxVidGetAudioTrackDescription_._dxVidGetAudioTrackDescription = GetFunction(*Library_, "dVidGetAudioTrackDescription")
Macro dxVidGetAudioTrackDescription(video,track) : PeekS(dxVidGetAudioTrackDescription_(video,track), -1, #PB_Ascii) : EndMacro
Prototype.L _dxSetAudioTrack(video.L, track.L)
Global dxSetAudioTrack._dxSetAudioTrack = GetFunction(*Library_, "dSetAudioTrack")
Prototype.I _dxGetSubtitleDescription(video.L, track.L)
Global dxGetSubtitleDescription_._dxGetSubtitleDescription = GetFunction(*Library_, "dGetSubtitleDescription")
Macro dxGetSubtitleDescription(video,track) : PeekS(dxGetSubtitleDescription_(video,track), -1, #PB_Ascii) : EndMacro
Prototype.L _dxSetSubtitle(video.L, track.L)
Global dxSetSubtitle._dxSetSubtitle = GetFunction(*Library_, "dSetSubtitle")
Prototype.I _dxRequestFile(title.p-ascii, default_folder.p-ascii, filter.p-ascii)
Global dxRequestFile_._dxRequestFile = GetFunction(*Library_, "dRequestFile")
Macro dxRequestFile(title,default_folder,filter) : PeekS(dxRequestFile_(title,default_folder,filter), -1, #PB_Ascii) : EndMacro
Prototype.F _dxGetPlayRate(video.L)
Global dxGetPlayRate._dxGetPlayRate = GetFunction(*Library_, "dGetPlayRate")
Prototype.L _dxSetPlayRate(video.L, rate.F)
Global dxSetPlayRate._dxSetPlayRate = GetFunction(*Library_, "dSetPlayRate")
Prototype.L _dxDx11Present()
Global dxDx11Present._dxDx11Present = GetFunction(*Library_, "dDx11Present")
Prototype.L _dxBeginScene()
Global dxBeginScene._dxBeginScene = GetFunction(*Library_, "dBeginScene")
Prototype.L _dxEndScene()
Global dxEndScene._dxEndScene = GetFunction(*Library_, "dEndScene")
Prototype.L _dxRenderEntity(entity.L, camera.L)
Global dxRenderEntity._dxRenderEntity = GetFunction(*Library_, "dRenderEntity")
Prototype.L _dxRenderCls(camera.L)
Global dxRenderCls._dxRenderCls = GetFunction(*Library_, "dRenderCls")
Prototype.I _dx11GetMaxFeatureLevel()
Global dx11GetMaxFeatureLevel_._dx11GetMaxFeatureLevel = GetFunction(*Library_, "d11GetMaxFeatureLevel")
Macro dx11GetMaxFeatureLevel() : PeekS(dx11GetMaxFeatureLevel_(), -1, #PB_Ascii) : EndMacro
Prototype.L _dx11SoftwareEmulation()
Global dx11SoftwareEmulation._dx11SoftwareEmulation = GetFunction(*Library_, "d11SoftwareEmulation")
Prototype.L _dx11NoSoftwareEmulation()
Global dx11NoSoftwareEmulation._dx11NoSoftwareEmulation = GetFunction(*Library_, "d11NoSoftwareEmulation")
Prototype.L _dxDebugSilent()
Global dxDebugSilent._dxDebugSilent = GetFunction(*Library_, "dDebugSilent")
Prototype.L _dxDebugLoud()
Global dxDebugLoud._dxDebugLoud = GetFunction(*Library_, "dDebugLoud")
Prototype.L _dxDebugHarsh()
Global dxDebugHarsh._dxDebugHarsh = GetFunction(*Library_, "dDebugHarsh")
Prototype.L _dxDebugLoudAndHarsh()
Global dxDebugLoudAndHarsh._dxDebugLoudAndHarsh = GetFunction(*Library_, "dDebugLoudAndHarsh")

...Потом еще, коли уж взялась, перевела пару примеров из комплекта поставки...

Код

; // Converted in 2014 by Guevara-chan.
;******** DX9 Simple Planetary test *********
Declare Control()

;init gfx mode
XIncludeFile "Hardwired_decls.pbi"
dxGraphics3D(1024,768,32,2)
dxApptitle("DirectX9 Planetary Test")
; Setup fonts to be used
; 2Dfonts
;font=dxLoadFont("courier new",16,0,0,0)
;font2=dxLoadFont("times",18,#True,#True,0)
;dxSetFont font

dxSetBuffer (dxBackBuffer()); set the current drawing buffer
Global speed=10
Global mode$="Side"

; Setup Camera  
Global campivot= dxCreatePivot(0)
Global camera=dxCreateCamera(campivot);create a standard camera
dxMoveEntity(camera, 0, 0, -15);Move cam away from sun(so we can see something)
;dxCameraZoom(camera, 1.6); fixes the warped planets look(happens under certain conditions)
;Setup Light
light=dxCreateLight(2,0)
dxAmbientLight(255,255,255); 0,0,0
;Setup Pivots.
pivot1  = dxCreatePivot(0); for moving entire solarsystem or sun?
pivot4  = dxCreatePivot(0); for Earth
;Setup Bodies.
;SUN
sun=dxCreateSphere(32,0)
dxScaleEntity(sun,2.5,2.5,2.5,#True)

suntexture=dxLoadTexture("images\suncyl1.jpg",9); use texture or just color entity.
dxEntityTexture(sun,suntexture,0,0)
dxEntityColor(sun,255,255,0)
dxEntityFX(sun,1)
;dxEntityShininess(sun,1)
dxEntityAlpha(sun,1)

;EARTH
earth=dxCreateSphere(32,pivot4)
dxScaleEntity(earth,0.35,0.35,0.35,#True)

earthtexture=dxLoadTexture("images\earth.jpg",9); use texture or just color entity.
dxEntityTexture(earth,earthtexture,0,0)
;EntityColor(earth,0,0,200)
;dxEntityShininess(earth,1)
dxEntityFX(earth,1)
dxEntityAlpha(earth,1)

dxMoveEntity(earth, 9, 0, 0)


Mainloop:
While Not dxKeyHit(1);Esc =exit

;move bodies
    dxTurnEntity(sun,0,1,0,#True); spin sun
    dxTurnEntity(pivot4,0,0.15,0,#True); speed; move earth trajectory
    dxTurnEntity(earth,0,1,0,#True); spin earth

;control functions
    Control()

;UpdateWorld(); update coords
    dxRenderWorld(0); display the scene into our double buffer
    dxText(400,600,"DDirectX9 Planetary Test",0,0)
    dxText(440,620,"ViewMode: "+mode$,0,0)
    
    dxFlip(0); flip buffer into sight

Wend
dxEndGraphics()
End

Procedure Control()
;-------- camcontrol -------
    If dxKeyDown(57)
        dxWaitKey()
    EndIf    

    If dxKeyDown(200);Up= Cam Closer
        dxMoveEntity(camera,0,0,0.1)
    EndIf

    If dxKeyDown(208); Down= Cam Further
        dxMoveEntity(camera,0,0,-0.1)
    EndIf

    If dxKeyDown(205);  Left = move cam left
        dxMoveEntity(camera,0.1,0,0)
    EndIf

    If dxKeyDown(203);  Right = turn cam right
        dxMoveEntity(camera,-0.1,0,0)
    EndIf
;--------- View ---------
    If dxKeyDown(2); 1=SideView
        dxRotateEntity(campivot, 0,0,0,0)
        mode$="Side"
    EndIf
    If dxKeyDown(3); 2=TopView    
        dxRotateEntity(campivot, 90,0,0,0)
        mode$="Top"
    EndIf
EndProcedure

Код

; // Converted in 2014 by Guevara-chan.
XIncludeFile "Hardwired_decls.pbi"
dxGraphics3D(640,480,32,2)

dxSetBuffer(dxBackBuffer())


; create camera
camera=dxCreateCamera(0)
dxCameraClsColor(camera,160,160,160)
dxPositionEntity(camera,0,0,-30,#True)
middle=dxCreatePivot(0)
dxEntityParent(camera,middle)

; create add texture - white cirlce on a black background
For n=0 To 50
dxColor(0,0,0)
dxRect(n*32,n*32,32,32,1)

dxColor(5+(n*5),5+(n*5),5+(n*5))
dxOval(10+n,10+n,236-(n*2),236-(n*2),1)
Next

blob_tex=dxCreateTexture(256,256,9,0)
blob=dxCreateImage(256,256,0)
dxCopyRect(0,0,256,256,0,0,dxBackBuffer(),dxTextureBuffer(blob_tex))
dxFreeImage(blob)

max_blobs=100

; create blobs using add blend mode
Dim blobs(max_blobs); blob sprites
Dim xyblobs.f(max_blobs,2); blob vector

For n=0 To max_blobs
    blobs(n)=dxCreateSprite(0)
    dxEntityFX(blobs(n),1)
    dxEntityBlend(blobs(n),3);set blend mode to add
    dxEntityTexture(blobs(n),blob_tex,0,0)
    xyblobs(n,0)=Random(200) / 100.0 - 1
    xyblobs(n,1)=Random(200) / 100.0 - 1
    xyblobs(n,2)=Random(200) / 100.0 - 1
    dxEntityColor(blobs(n),Random(255),Random(255),Random(255));give it a colour
    Next

; create cube texture

dxColor(255,255,255)
dxRect(0,0,256,256,1)
For n=0 To 7
    If n=0  :  dxColor(0,0,0) : EndIf
    If n=1  :  dxColor(0,0,255) : EndIf
    If n=2  :  dxColor(0,255,0) : EndIf
    If n=3  :  dxColor(0,255,255) : EndIf
    If n=4  :  dxColor(255,0,0) : EndIf
    If n=5  :  dxColor(255,0,255) : EndIf
    If n=6  :  dxColor(255,255,0) : EndIf
    If n=7  :  dxColor(255,255,255) : EndIf
    dxRect(n*32,n*32,32,32,1)
    Next

dxColor(0,0,0)
For n=0 To 255 Step 32
dxLine(0,n,255,n)
dxLine(n,0,n,255)
Next

cube_tex=dxCreateTexture(256,256,9,0)
cube=dxCreateImage(256,256,0)
dxCopyRect(0,0,256,256,0,0,dxBackBuffer(),dxTextureBuffer(cube_tex))
dxFreeImage(cube)

; create cube
cube=dxCreateCube(0)
dxScaleEntity(cube,11,11,11,#True)
dxEntityTexture(cube,cube_tex,0,0)
dxEntityFX(cube,17);set fullbright and 2 sided textures
dxEntityBlend(cube,2);set multiply blend

Repeat

; move the blobs around
For n=0 To max_blobs
    dxMoveEntity(blobs(n),xyblobs(n,0),xyblobs(n,1),xyblobs(n,2))
;bounce off sides
lmt=10
    If dxEntityX(blobs(n),False)<-lmt Or dxEntityX(blobs(n),False)>lmt : xyblobs(n,0)=-xyblobs(n,0) : EndIf
    If dxEntityY(blobs(n),False)<-lmt Or dxEntityY(blobs(n),False)>lmt : xyblobs(n,1)=-xyblobs(n,1) : EndIf
    If dxEntityZ(blobs(n),False)<-lmt Or dxEntityZ(blobs(n),False)>lmt : xyblobs(n,2)=-xyblobs(n,2) : EndIf
    Next

; turn camera
dxTurnEntity(middle,0.1,0.2,0.3,#True)


;dxUpdateWorld
dxRenderWorld(0)
dxFlip(0)


Until dxKeyHit(1)
End

...Впечатления смешанные, ибо уже на банальном повороте pivot’а на 0, 0, 0, прикрепленная к нему камера улетела в никуда. Но все же.