OpenGL: Difference between revisions

 

opengl.adb:

with Lumen.Events;

with Lumen.Events.Animate;

when Program_Exit =>

null; -- normal termination

 

=={{header|AutoHotkey}}==

Gui, +LastFound +Resize

hDC := DllCall("GetDC", "uInt", WinExist())

DllCall("ReleaseDC", "uInt", hDC)

DllCall("FreeLibrary", "uInt", hOpenGL32)

 

=={{header|BaCon}}==

BaCon allows embedding C code. This is an example with GLUT.

PRAGMA LDFLAGS GL glut

 

 

glutDisplayFunc(Triangle)

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

SYS "LoadLibrary", "OPENGL32.DLL" TO opengl%

ghRC% += 0 : IF ghRC% SYS `wglDeleteContext`, ghRC% : ghRC% = 0

ghDC% += 0 : IF ghDC% SYS "ReleaseDC", @hwnd%, ghDC% : ghDC% = 0

 

=={{header|C}}==

In this example, we use [[:Category:GLUT|GLUT]] to create a window and handle the main loop in a portable way. Windowing systems like MS Windows and X11 have their own platform-specific ways of handling these things.

 

#include <GL/gl.h>

#include <GL/glut.h>

 

return EXIT_SUCCESS;

 

=={{header|C sharp|C#}}==

C# example using the [http://www.opentk.com/ OpenTK] library, which is multiplatform and provides C# OpenGL bindings for .Net and Mono. This code creates its own window and draws the triangle into it.

 

using OpenTK.Graphics;

namespace OpenGLTest

}

}

 

=={{header|Clojure}}==

 

In this example, we use [http://github.com/ztellman/penumbra Penumbra], which is an idiomatic wrapper for OpenGL.

(require '[penumbra.app :as app])

 

(color 0 0 1) (vertex 0 30)))

 

 

=={{header|Common Lisp}}==

{{libheader|Lispbuilder-SDL}}

 

(case type

(right

(setup-gl w h)

(setf (sdl:frame-rate) 2)

 

=={{header|D}}==

{{libheader|dglut}}

opengl_sample.d:

import dglut.core, dglut.window, dglut.opengl;

 

}

loop;

=={{header|Delphi}}==

{{libheader| System.Classes}}

{{libheader| System.UITypes}}

Thanks Neslib for libraries FastMath [https://github.com/neslib/FastMath], DelphiStb [https://github.com/neslib/DelphiStb] and Samples codes [https://github.com/neslib/DelphiLearnOpenGL] to abstract openGl functions and window creation.

program OpenGLTriangle;

 

begin

RunApp(TTriangleApp, 640, 480, 'OpenGL Triangle');

 

=={{header|eC}}==

{{libheader|Ecere}}

 

import "ecere"

 

}

 

 

=={{header|Euphoria}}==

{{works with|OpenEuphoria < 4.0}}

Adapted from NeHe tutorial #3 nehe.gamedev.net

include get.e

include dll.e

 

WinMain()

 

=={{header|Factor}}==

Translated from C

ui.gadgets ui.render ;

IN: rosettacode.opengl

[ triangle-gadget new "Triangle" open-window ] with-ui ;

MAIN: triangle-window

 

=={{header|Forth}}==

{{libheader|Theseus}}

triangle.fs:

 

triangle.m:

\ automatic generated code

\ do not edit

$1 0 ?DO stop LOOP bye ;

script? [IF] main [THEN]

 

=={{header|FreeBASIC}}==

This is adapted from example OpenGL code that's included with FreeBASIC distributions.

 

#include once "GL/gl.bi"

#include once "GL/glu.bi"

flip

 

 

=={{header|Go}}==

<br>

This program was also tested on Windows 10 but ''may'' only work if you comment out the marked line. This is because gl.Init() may produce an initialization error which is non-critical as far as this program is concerned. The reason for this error is unknown (see [[https://rosettacode.org/wiki/Talk:OpenGL Talk page]]).

 

import (

 

gl.Flush()

 

=={{header|Haskell}}==

import Graphics.UI.GLUT

 

corner r g b x y = do color (Color3 r g b :: Color3 GLfloat)

 

=={{header|J}}==

Additionally, if you are using 64 bit windows, to get opengl working on J602 you will need to copy jzopengl_win.ijs to jzopengl_win_64.ijs in system/classes/opengl/.

 

(coinsert[require) 'jzopengl'

 

)

 

 

Note: OpenGL's initial state is well defined by the OpenGL standard.

=={{header|Java}}==

This example uses [http://lwjgl.org/ LWJGL], a game library which has an OpenGL binding for Java

import org.lwjgl.opengl.Display;

import org.lwjgl.opengl.DisplayMode;

}

 

 

 

Unfortunately for comparison with the other examples on this page, WebGL provides only OpenGL ES, which removes the classic “fixed-function pipeline” and glVertex() in favor of requiring you to write ''vertex shaders'' and ''fragment shaders'', and use vertex arrays. It is not hard to write shader programs to emulate as much of the fixed-function pipeline as you need, but it does mean more verbosity as you have to explicitly define all of the data you're going to communicate to your shader.

In the interest of brevity and not depending on an external matrix library, this example ''omits matrix operations entirely'', as OpenGL ES requires you to add those features yourself if you want them. Examples which show how to implement the classic OpenGL matrix stack are available at [http://learningwebgl.com/blog/?page_id=1217 Learning WebGL] (which this code was derived from).

 

<head>

<title>Minimal WebGL Example</title>

</script>

</body>

 

=={{header|Julia}}==

Julia's Makie plotting package uses OpenGL as its backend. This example is from the Makie documentation.

 

mesh([(0.0, 0.0), (0.5, 1.0), (1.0, 0.0)], color = [:red, :green, :blue], shading = false)

 

=={{header|Kotlin}}==

{{libheader|GLUT}}

{{Works with|Ubuntu 14.04}}

 

import kotlinx.cinterop.*

glutMainLoop()

 

{{output}}

 

=={{header|Liberty BASIC}}==

struct rect, x as long, y as long, x2 as long, y2 as long

struct PFD, Size as word, Version as word, Flags as long,_

close #glu

close #gl

 

=={{header|Lingo}}==

{{libheader|RavOpenGL xtra}}

global GL -- OpenGL constants

 

-- Show the window

_movie.stage.visible = TRUE

 

=={{header|Lua}}==

Note that GL functions that take constants in LuaGL can take either the numbers representing those flags (ie. gl.XXX + gl.YYY) or a comma-separated string of those flags (ie. "XXX,YYY"). This example uses strings.

 

local iup = require "iuplua"

require "iupluagl"

 

iup.MainLoop()

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Non-Windows only:

VertexColors -> {Red, Green, Blue}]}, Boxed -> False],

 

=={{header|MAXScript}}==

The choice of OpenGL or D3D in MAX is a user configuration setting. All MAXScript code is platform independent.

setMesh newMesh vertices:#([-100, -100, 0], [100, -100, 0], [-100, 100, 0]) faces:#([1, 2, 3])

defaultVCFaces newMesh

viewport.setType #view_top

max tool maximize

 

=={{header|Mercury}}==

{{libheader|mercury_opengl}}

Translated from C.

:- interface.

 

mogl.load_identity(!IO),

mogl.ortho(-30.0, 30.0, -30.0, 30.0, -30.0, 30.0, !IO),

 

=={{header|Nim}}==

{{libheader|OpenGL}}

{{libheader|Nim bindings for OpenGL}}

 

proc paint() {.cdecl.} =

glutReshapeFunc(reshape)

 

 

=={{header|OCaml}}==

{{libheader|glMLite}}

open Glut

 

 

glutMainLoop();

 

=={{header|Ol}}==

OpenGL window works in background (as coroutine) and allow user to call any functions, including OpenGL, in REPL simultaneously with window rendering process.

 

(import (lib gl))

(gl:set-window-title "Rosettacode OpenGL example")

(glEnd)

))

 

=={{header|OxygenBasic}}==

title="Rotating Triangle"

include "OpenglSceneFrame.inc"

end sub

 

 

=={{header|Pascal}}==

{{libheader|GLUT}}

Ported from the C example.

 

uses

end.

 

 

=={{header|Perl}}==

 

sub triangle {

glpFlush;

 

 

==={{libheader|Perl/SDL}}===

use SDL::Event;

use SDL::OpenGL;

$app->loop ({

SDL_QUIT() => sub { exit; },

 

=={{header|Phix}}==

{{trans|JavaScript}}

This can be run online [http://phix.x10.mx/p2js/OpenGL.htm here], also works on desktop/Phix.<br>

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\OpenGL.exw

<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

 

=={{header|PicoLisp}}==

This is for the 64-bit version.

 

(glutInit)

(mouseFunc '((Btn State X Y) (bye)))

 

 

=={{header|Pike}}==

Uses GLUE to create the window. Rendering code is based on the C example.

GLUE.init(([

"fullscreen": 0,

sleep(0.01);

}

 

=={{header|PureBasic}}==

 

 

XIncludeFile "OpenGL.pbi"

pfd.PIXELFORMATDESCRIPTOR

Wend

 

 

=={{header|Python}}==

#-*- coding: utf-8 -*-

 

glutReshapeFunc(reshape)

 

=={{header|QB64}}==

'Task

'Display a smooth shaded triangle with OpenGL.

_glEnd

End Sub

=={{header|R}}==

{{libheader|rgl}}

x <- c(-1, -1, 1)

y <- c(0, -1, -1)

M <- cbind(x,y,z)

rgl.bg(color="gray15")

 

=={{header|Racket}}==

If OpenGL context creation fails please consult Racket [http://docs.racket-lang.org/gui/libs.html documentation]

 

#lang racket/gui

(require sgl/gl)

 

(send win show #t)

 

=={{header|Raku}}==

It's a little verbose since it is doing all of the setup and loading manually.

 

 

class Window is repr('CPointer') {}

 

glfwTerminate();

 

See screen cap: [https://github.com/thundergnat/rc/blob/master/img/OpenGL-Triangle-perl6.png OpenGL-Triangle-perl6.png] (Offsite PNG image.)

 

=={{header|Ring}}==

# Project: OpenGL

 

glEnd()

glutSwapBuffers()

Outputimage:

 

{{libheader|ruby-opengl}}

 

require 'gl'

require 'glut'

glutReshapeFunc(reshape)

 

=={{header|Rust}}==

using glutin for window creation and glow for opengl/opengles functions. as such, the fixed function pipeline is not supported

use glutin::event::*;

use glutin::event_loop::{ControlFlow, EventLoop};

_ => {}

});

=={{header|Scala}}==

{{libheader|Light Weight Java Game Library}}

import org.lwjgl.opengl.GL11._

 

Thread.sleep(1000)

}

 

=={{header|Tcl}}==

{{libheader|Tk}}

{{libheader|tcl3d}}

package require tcl3d

 

togl .surface -width 640 -height 480 -double true -depth true \

-displayproc paintShape -reshapeproc resizedWin

 

=={{header|Wren}}==

 

Notice that we can't pass Wren methods directly to the glutDisplayFunc and glutReshapeFunc functions for callback registration purposes because of re-entrancy problems so, instead, we pass sufficient information from Wren to enable the callbacks to be constructed from the C side.

 

var GL_COLOR_BUFFER_BIT = 0x4000

Glut.displayFunc("GLCallbacks", "paint()")

Glut.reshapeFunc("GLCallbacks", "reshape(_,_)")

<br>

We now embed this Wren script in the following C program, compile and run it.

#include <stdio.h>

#include <string.h>

vm = wrenNewVM(&config);

const char* module = "main";

char *script = readFile(fileName);

WrenInterpretResult result = wrenInterpret(vm, module, script);

free(script);

return 0;

 

{{out}}