Graphics

From Things and Stuff Wiki
Jump to navigation Jump to search


General

See also 3D / CAD, Photography, JS scripts#Graphics, WYSIWYG


Hardware


VBIOS

  • https://en.wikipedia.org/wiki/Video_BIOS - the BIOS of a graphics card in a (usually IBM PC-derived) computer. Much the way the system BIOS provides a set of functions that are used by software programs to access the system hardware, the video BIOS provides a set of video-related functions that are used by programs to access the video hardware. The video BIOS interfaces software to the video chipset in the same way that the system BIOS does for the system chipset. The ROM also contained a basic font set to upload to the video adapter font RAM, if the video card did not contain a font ROM with this font set instead.


  • https://en.wikipedia.org/wiki/VESA_BIOS_Extensions - a VESA standard, currently at version 3, that defines the interface that can be used by software to access compliant video boards at high resolutions and bit depths. This is opposed to the "traditional" int 10h BIOS calls, which are limited to resolutions of 640×480 pixels with 16 color (4-bit) depth or less. VBE is made available through the video card's BIOS, which installs during boot up some interrupt vectors that point to itself.

Most newer cards implement the more capable VBE 3.0 standard. Older versions of VBE provide only a real mode interface, which cannot be used without a significant performance penalty from within protected mode operating systems. Consequently, the VBE standard has almost never been used for writing a video card's drivers; each vendor has thus had to invent a proprietary protocol for communicating with its own video card. Despite this, it is common that a driver thunk out to the real mode interrupt in order to initialize screen modes and gain direct access to a card's linear frame buffer, because these tasks would otherwise require handling many hundreds of proprietary variations that exist from card to card.

Display standards


  • https://en.wikipedia.org/wiki/Color_Graphics_Adapter - originally also called the Color/Graphics Adapter or IBM Color/Graphics Monitor Adapter, introduced in 1981, was IBM's first graphics card and first color display card for the IBM PC. For this reason, it also became that computer's first color computer display standard.The standard IBM CGA graphics card was equipped with 16 kilobytes of video memory and could be connected either to a dedicated direct-drive CRT monitor using a 4-bit digital (TTL) RGBI interface, such as the IBM 5153 color display, or to an NTSC-compatible television or composite video monitor via an RCA connector. The RCA connector provided only baseband video, so to connect the CGA card to a standard television set required a separate RF modulator unless the TV had an RCA jack, although doing so with the former combined with an amplifier was sometimes more practical, since one could then hook up an antenna to the amplifier and get wireless video.



  • https://en.wikipedia.org/wiki/VGA-compatible_text_mode - introduced in 1987 by IBM as part of the VGA standard for its IBM PS/2 computers. Its use on IBM PC compatibles was widespread through the 1990s and persists today for some applications on modern desktop computers. The main features of VGA text mode are colored (programmable 16 color palette) characters and their background, blinking, various shapes of the cursor (block/underline/hidden static/blinking), and loadable fonts (with various glyph sizes). The Linux console traditionally uses hardware VGA-compatible text modes, and the Win32 console environment has an ability to switch the screen to text mode for some text window sizes.


  • https://en.wikipedia.org/wiki/Super_VGA - or Ultra VGA, or just SVGA or UVGA, short for Super Video Graphics Array and Ultra Video Graphics Array is a broad term that covers a wide range of computer display standards. The SVGA standard was developed in 1988, when NEC Home Electronics announced its creation of the Video Electronics Standards Association (VESA). The development of SVGA was led by NEC, along with other VESA members including ATI Technologies and Western Digital. SVGA enabled graphics display resolutions up to 800×600 pixels, 56% more pixels than VGA's maximum resolution of 640×480.

Framebuffer

  • https://en.wikipedia.org/wiki/Framebuffer - frame buffer, or sometimes framestore, is a portion of RAM containing a bitmap that drives a video display. It is a memory buffer containing a complete frame of data. Modern video cards contain framebuffer circuitry in their cores. This circuitry converts an in-memory bitmap into a video signal that can be displayed on a computer monitor.

In computing, a screen buffer is a part of computer memory used by a computer application for the representation of the content to be shown on the computer display. The screen buffer may also be called the video buffer, the regeneration buffer, or regen buffer for short. Screen buffers should be distinguished from video memory. To this end, the term off-screen buffer is also used.

The information in the buffer typically consists of color values for every pixel to be shown on the display. Color values are commonly stored in 1-bit binary (monochrome), 4-bit palettized, 8-bit palettized, 16-bit high color and 24-bit true color formats. An additional alpha channel is sometimes used to retain information about pixel transparency. The total amount of memory required for the framebuffer depends on the resolution of the output signal, and on the color depth or palette size.


  • https://en.wikipedia.org/wiki/Linux_framebuffer - fbdev is a graphic hardware-independent abstraction layer to show graphics on a computer monitor, typically on the console. The word framebuffer means a part of video memory containing a current video frame, and the Linux framebuffer means “access method to the framebuffer under the Linux kernel”, without relying on system-specific libraries such as SVGALib or another user space software.




Startup

  • fbsplash - formerly gensplash, is a userspace implementation of a splash screen for Linux systems. It provides a graphical environment during system boot using the Linux framebuffer layer.
Q: "I get a tty1 login before KDM pops up."
A: "You could disable tty1. Comment out this line in /etc/inittab: 
  c1:2345:respawn:/sbin/agetty -8 38400 tty1 linux"


DirectFB

  • directfb.net - a thin library that provides hardware graphics acceleration, input device handling and abstraction, integrated windowing system with support for translucent windows and multiple display layers, not only on top of the Linux Framebuffer Device. It is a complete hardware abstraction layer with software fallbacks for every graphics operation that is not supported by the underlying hardware. DirectFB adds graphical power to embedded systems and sets a new standard for graphics under Linux. [3]


  • fbv - a very simple graphic file viewer for the framebuffer console, capable of displaying GIF, JPEG, PNG and BMP files using libungif, libjpeg, and libpng. The image can be shown either in fit-to-screen or panning mode in 8, 15/16, and 32bpp.




SVGAlib

  • SVGAlib Tutorials - provides an easy way to create graphical applications and eliminates the rigmarole of the X Window System. If you have even the most rudimentary grasp of programming in C, then you can use SVGAlib.


GTK


Xvfb

  • Xvfb - or X virtual framebuffer is a display server implementing the X11 display server protocol. In contrast to other display servers Xvfb performs all graphical operations in memory without showing any screen output. From the point of view of the client, it acts exactly like any other X display server, serving requests and sending events and errors as appropriate. However, no output is shown. This virtual server does not require the computer it is running on to even have a screen or any input device. Only a network layer is necessary. Unlike a real display server, Xvfb does not support modern X11 extensions like compositing, Randr or GLX. Xdummy is a newer alternative which supports these extensions as well as providing the same functionality as Xvfb. Xvfb is primarily used for testing.


fbturbo

  • fbturbo - an Xorg driver for Allwinner and other ARM-based devices, derived from fbdev driver. With regard to 2D graphics, it provides a number of software optimizations on all platforms, while letting the SIMD (ARM NEON) accelerated code from the pixman library run at full speed without any unnecessary overhead. 2D hardware acceleration using G2D is supported on sunxi platforms. The recommended framebuffer color depths are 16 (RGB565) and 24 (XRGB8888), the other color depths may be supported too. Multi-head configurations are supported.


minifb


uvesafb


  • https://wiki.archlinux.org/index.php/AMD_Catalyst - AMD's Linux driver package catalyst was previously named fglrx (FireGL and Radeon X). Only the package name has changed, while the kernel module retains its original fglrx.ko filename. Therefore, any mention of fglrx below is specifically in reference to the kernel module, not the package.


fbtft


Display server

  • https://en.wikipedia.org/wiki/Display_server - or window server is a program whose primary task is to coordinate the input and output of its clients to and from the rest of the operating system, the hardware, and each other. The display server communicates with its clients over the display server protocol, a communications protocol, which can be network-transparent or simply network-capable. The display server is a key component in any graphical user interface, specifically the windowing system.

X Window System


Xwindows drives the underlying graphical interface of most if not all Unix/Linux computers providing a GUI. It was developed in 1984 at MIT. After around 35 years of development, tweaking and adding of new hardware and ideas, it is generally acknowledged to be a bit of a beast. It should be remembered that the common configuration at time of development was a single mini running X providing individual views to Xterminals in a timesharing system. Nowadays the norm is X providing a single screen on a desktop or laptop.

All of this means that there are many ways of achieving the same thing and many slightly different things that can meet the same purpose. In modern X versions sometimes you can get away with limited or no configuration. In the last few years the boast is that X is self configuring. Certainly the best practice rule of thumb is less configuration is better - that is only configure what is wrong.

Xorg

  • X.Org project provides an open source implementation of the X Window System. The development work is being done in conjunction with the freedesktop.org community. The X.Org Foundation is the educational non-profit corporation whose Board serves this effort, and whose Members lead this work. 


X11: /usr/lib/X11 /etc/X11 /usr/include/X11 /usr/share/X11





  • A Testament to X11 Backwards Compatibility - I recently scored a Hewlett Packard 1670A Deep Memory Logic Analyzer and I finally had a chance to fire it up. This unit dates back to 1992 and is packed with all sorts of interesting options for connecting peripherals to it. One particular feature that caught my eye was the option to connect to an X Server.

History

Legacy X servers

  • https://en.wikipedia.org/wiki/XFree86 - was an implementation of the X Window System. For most of the 1990s and early 2000s, the project was the source of most innovation in X and was the de facto steward of X development. Until early 2004, it was almost universal on Linux and the BSDs. In February 2004, with version 4.4.0, The XFree86 Project adopted a license change that the Free Software Foundation considered GPL incompatible. Most open source operating systems using XFree86 found this unacceptable and moved to a fork from before the license change. The first fork was the abortive Xouvert, but X.Org Server soon became dominant. Most XFree86 developers also moved to X.Org.

Startup

/etc/X11/xinit/xinitrc

if [ -d /etc/X11/xinit/xinitrc.d ]; then
       for f in /etc/X11/xinit/xinitrc.d/*; do
               [ -x "$f" ] && . "$f"
       done
       unset f
fi


Config

You can create a basic xorg.conf using the X executable itself. As root run: 

Xorg :1 -configure

This will create the file /root/xorg.conf.new, which you can then copy to /etc/X11/xorg.conf: 

cp /root/xorg.conf.new /etc/X11/xorg.conf



xrdb

xset



In case monitors don't report EDID information, modeline settings might required. 

cvt 1280 1024 75


randr

  • http://en.wikipedia.org/wiki/RandR - a communications protocol written as an extension to the X11[2] protocol. XRandR provides the ability to resize, rotate and reflect the root window of a screen. RandR is also responsible for setting the screen refresh rate.


xrandr -q
  show possible and current screen resolutions

xdpyinfo | grep 'dimensions:'
  show just current screen resolution in px and mm



xrandrr='xrandr --output DVI-I-1 --mode 1280x1024 --pos 0x0 --panning 0x0+0+0 --output DVI-I-0 --mode 1280x1024 --pos 1280x0'

xrandrc='xrandr --output DVI-I-1 --same-as DVI-I-0'

xrandr --output DVI-I-1 --off

xrandr --output TV-0 --mode 1024x768 --pos 0x0 --panning 0x0+0+0 --output DVI-I-0 --mode 1280x1024 --pos 1024x0


  • ARandR is designed to provide a simple visual front end for XRandR. Relative monitor positions are shown graphically and can be changed in a drag-and-drop way.
  • autorandr - Auto-detect the connect display hardware and load the appropiate X11 setup using xrandr or disper


  • randrctl - Minimalistic JSON profile based screen manager for X. It allows to store current screen setup in a declarative configuration file (a profile) and apply stored settigns later with a simple command.

Multihead

faulty EDID;

  • DMX (Distributed Multihead X Project) - Typical X servers provide multi-head support for multiple displays attached to the same machine. When Xinerama is in use, these multiple displays are presented to the user as a single unified screen. Xdmx is proxy X server that provides multi-head support for multiple displays attached to different machines (each of which is running a typical X server). When Xinerama is used with Xdmx, the multiple displays on multiple machines are presented to the user as a single unified screen. A simple application for Xdmx would be to provide multi-head support using two desktop machines, each of which has a single display device attached to it.


Switching



  • Disper is an on-the-fly display switch utility. It is intended to be used just before giving a presentation with a laptop, when all one wants is that the beamer, which has just been connected, is able to show whatever you prepared. Disper gives you the option to either clone all detected displays, or extend the desktop to them. Resolutions are automatically detected. For cloning, the highest common resolution supported by all displays is chosen; for extending every display device gets its highest supported resolution. For special setups requiring more detailed control, one can still use the standard display configuration utilites.








Remote

X's network transparency was not designed as 'it will run xterm well'; originally it was to be something that should let you run almost everything remotely, providing a full environment. ... You cannot operate with X over the network in the same way that you do locally. Trying to do so is painful and involves many things that either don't work at all or perform so badly that you don't want to use them.

X Forwarding

Requires xorg-xauth and xorg-xhost packages on the remote machine.

Remote /etc/ssh/sshd_config: 

AllowTcpForwarding yes
X11UseLocalhost yes

X11DisplayOffset 10

X11Forwarding yes

Remote /etc/ssh/ssh_config: 

Compression yes

Local /etc/ssh/ssh_config (optional, flag is -X) 

ForwardX11 yes

ssh -XC user@host
  # X forwarding, compression

xclock
  # remote xclock should appear locally

xhost +192.168.1.64
  # add address to x access control list

mcookie
  # generate magic cookie on remote, i.e., bc85bb773ae8897d9569ddbe69684411

xauth add node10/unix:3 . bc85bb773ae8897d9569ddbe69684411
  # add remote to local xauth list

xauth list
  # list X magic cookies
  • https://wiki.archlinux.org/index.php/Xhost - used to add and delete host names or user names to the list allowed to make connections to the X server. In the case of hosts, this provides a rudimentary form of privacy control and security. It is only sufficient for a workstation (single user) environment, although it does limit the worst abuses.

Xnest

  • Xnest is both an X client and an X server. Xnest is a client of the real server which manages windows and graphics requests on its behalf. Xnest is a server to its own clients. Xnest manages windows and graphics requests on their behalf. To these clients, Xnest appears to be a conventional server.
    • http://en.wikipedia.org/wiki/Xnest - a display server implementing the X11 display server protocol that shows its output in a window. In other words, Xnest opens a window that works like another screen in which the user can open windows, etc.

Xephyr

  • Xephyr is a kdrive based X Server which targets a window on a host X Server as its framebuffer. Unlike Xnest it supports modern X extensions (even if host server doesn't) such as Composite, Damage, randr etc (no GLX support now). It uses SHM Images and shadow framebuffer updates to provide good performance. It also has a visual debugging mode for observing screen updates. 
Xephyr -br -ac -noreset -screen 800x600 :1 &

DISPLAY=:1 xterm

startx -- /usr/bin/Xephyr :1

Xpra

  • Xpra - X Persistent Remote Applications, is 'screen for X', and more: it allows you to run X programs, usually on a remote host and direct their display to your local machine. It also allows you to display existing desktop sessions remotely. Xpra is "rootless" or "seamless", and sessions can be accessed over SSH, or password protected and encrypted over plain TCP sockets. Xpra adapts to bandwidth constraints and is fully open-source. [10]

The main problem with ssh -X is all your apps close when your connection drops. 

xpra shadow ssh:milk@silver.local:0 --ssh="/usr/bin/ssh p=231"
  # shadow the display on a remote machine


  • Xdummy was originally developed by Karl Runge as a ​script to allow a standard X11 server to be used by non-root users with the dummy video driver

x2x

x2vnc

  • x2vnc - A dual-screen hack. will let you use two screens on two different computers as if they were connected to the same computer. Even if one of the computers runs Windows 95/98/NT and the other one runs X-windows. The program will open a small (one pixel wide) window on the edge of your screen. Moving the pointer into this window will trigger the program to take over your mouse and send mouse movements and keystrokes though the RFB protocol to a VNC server running on another machine. When the pointer is moved back towards the opposite edge on the other screen, the mouse is then released again. The operation itself is almost identical to x2x, but most of the code was actually borrowed from the program vncviewer.

x11vnc

  • x11vnc allows one to view remotely and interact with real X displays (i.e. a display corresponding to a physical monitor, keyboard, and mouse) with any VNC viewer. In this way it plays the role for Unix/X11 that WinVNC plays for Windows.

xrdp

  • xrdp - An open source remote desktop protocol(rdp) server. Based on the work of FreeRDP and rdesktop, xrdp uses the remote desktop protocol to present a GUI to the user. The goal of this project is to provide a fully functional Linux terminal server, capable of accepting connections from rdesktop, freerdp, and Microsoft's own terminal server / remote desktop clients. Unlike Windows NT/2000/2003/2008/2012 server, xrdp will not display a Windows desktop but an X window desktop to the user. Xrdp uses Xvnc or X11rdp to manage the X session.

xmove

  • xmove - a computer program that allows the movement of X Window System applications between different displays and the persistence of X applications across X server restarts. It solves a problem in the design of X, where an X client (an X application) is tied to the X server (X display) it was started on for its lifetime. Also, if the X server is shut down, the client application is forced to stop running. xmove lets the client disconnect from its current X server, and connect to a new one, at any time. The transition is completely transparent to the client. xmove works by acting as a proxy between the client and server. It is a "pseudoserver" which stores enough server state so that clients can connect to a new server without being disrupted.

Guievict

  • guievict is a computer program which enables the GUI of any application for XFree86 implementation of X Window to be transparently migrated to or replicated on another display. Unlike some program providing similar functionalities, it requires neither prearranging steps such as re-linking the application program binary nor re-directing the application process's window system communication through a proxy like xmove does.

DXPC

Mir


Arcan

  • Arcan - Arcan is a powerful development framework for creating virtually anything between user interfaces for specialised embedded applications all the way to full-blown standalone desktop environments. Boot splash screen? no problem. SCADA HMI for your home? easy peasy. Xorg backend? got you covered. Wayland compositor? sure thing. At its heart lies a robust and portable multimedia engine, with a well-tested and well-documented interface, programmable using Lua. At every step of the way, the underlying development emphasises security, performance and debugability guided by a principle of least surprise in terms of API design. [11]


  • Durden - a desktop environment for the Arcan Display Server. It serves both as a reference showcase on how to take advantage of some of the features in Arcan, and as a very competent entry to the advanced-user side of the desktop environment spectrum. The basic premise is to absorb most, if not all, features from current desktop environments in a modular and configurable way - then let user selected profiles actually cherry- pick the configuration, visuals and tunning that reflects the desktop the user wants or is familiar with. Internally, it is based around a file-system like structure ("the menu") and everything else is references to paths within this structure. Development is discussed on IRC @ irc.freenode.net, #arcan - while issues are tracked at the github page for now.



Graphics APIs


  • Mesa - began as an open-source implementation of the OpenGL specification - a system for rendering interactive 3D graphics.Over the years the project has grown to implement more graphics APIs, including OpenGL ES (versions 1, 2, 3), OpenCL, OpenMAX, VDPAU, VA API, XvMC and Vulkan.A variety of device drivers allows the Mesa libraries to be used in many different environments ranging from software emulation to complete hardware acceleration for modern GPUs.Mesa ties into several other open-source projects: the Direct Rendering Infrastructure and X.org to provide OpenGL support on Linux, FreeBSD and other operating systems.



DirectX

OpenGL

Tutorials

  • Learn OpenGL - "Welcome to my humble attempt to facilitate a well-developed teaching platform for the graphics API called OpenGL. Whether you are trying to learn OpenGL for academic purposes, to pursue a career or simply looking for a hobby, this site will teach you the basics, the intermediate and all the advanced knowledge using modern (core-profile) OpenGL. The aim of LearnOpenGL is to show you all there is to modern OpenGL in an easy-to-understand fashion with clear examples, while also providing a useful reference for later studies."

to sort

  • https://en.wikipedia.org/wiki/EGL_(API) - an interface between Khronos rendering APIs (such as OpenGL, OpenGL ES or OpenVG) and the underlying native platform windowing system. EGL handles graphics context management, surface/buffer binding, rendering synchronization, and enables "high-performance, accelerated, mixed-mode 2D and 3D rendering using other Khronos APIs." EGL is managed by the non-profit technology consortium Khronos Group.


  • https://en.wikipedia.org/wiki/OpenGL_Utility_Library - 'GLU, a computer graphics library for OpenGL.It consists of a number of functions that use the base OpenGL library to provide higher-level drawing routines from the more primitive routines that OpenGL provides. It is usually distributed with the base OpenGL package. GLU is not implemented in the embedded version of the OpenGL package, OpenGL ES. Among these features are mapping between screen- and world-coordinates, generation of texture mipmaps, drawing of quadric surfaces, NURBS, tessellation of polygonal primitives, interpretation of OpenGL error codes, an extended range of transformation routines for setting up viewing volumes and simple positioning of the camera, generally in more human-friendly terms than the routines presented by OpenGL. It also provides additional primitives for use in OpenGL applications, including spheres, cylinders and disks.
  • GLM - a header only C++ mathematics library for graphics software based on the OpenGL Shading Language (GLSL) specifications. GLM provides classes and functions designed and implemented with the same naming conventions and functionalities than GLSL so that anyone who knows GLSL, can use GLM as well in C++. This project isn't limited to GLSL features. An extension system, based on the GLSL extension conventions, provides extended capabilities: matrix transformations, quaternions, data packing, random numbers, noise, etc... This library works perfectly with OpenGL but it also ensures interoperability with other third party libraries and SDK. It is a good candidate for software rendering (raytracing / rasterisation), image processing, physic simulations and any development context that requires a simple and convenient mathematics library.


  • OpenGL Extension - a means for OpenGL implementations to provide new or expanded functionality that the core of OpenGL does not provide. Using extensions should not be looked on as something to be avoided; it should be accepted as standard practice for the OpenGL user.Some extensions expose features that only one particular hardware vendor exposes, but many extensions are implemented by multiple implementations. There is a mechanism for determining which extensions are available from a particular implementation.


  • GLEW - a cross-platform open-source C/C++ extension loading library. GLEW provides efficient run-time mechanisms for determining which OpenGL extensions are supported on the target platform. OpenGL core and extension functionality is exposed in a single header file. GLEW has been tested on a variety of operating systems, including Windows, Linux, Mac OS X, FreeBSD, Irix, and Solaris.



  • OpenGL Extensions Viewer - A reliable software which displays useful information about the current OpenGL 3D accelerator and new Vulkan 3D API. This program displays the vendor name, the version implemented, the renderer name and the extensions of the current OpenGL 3D accelerator.


  • https://github.com/cginternals/glbinding - leverages C++11 features like enum classes, lambdas, and variadic templates, instead of relying on macros; all OpenGL symbols are real functions and variables. It provides type-safe parameters, per feature API header, lazy function resolution, multi-context and multi-thread support, global and local function callbacks, meta information about the generated OpenGL binding and the OpenGL runtime, as well as tools and examples for quick-starting your projects. Based on the OpenGL API specification (gl.xml) glbinding is generated using python scripts and templates that can be easily adapted to fit custom needs.



  • freeglut - a free-software/open-source alternative to the OpenGL Utility Toolkit (GLUT) library. GLUT was originally written by Mark Kilgard to support the sample programs in the second edition OpenGL 'RedBook'. Since then, GLUT has been used in a wide variety of practical applications because it is simple, widely available and highly portable.GLUT (and hence FreeGLUT) takes care of all the system-specific chores required for creating windows, initializing OpenGL contexts, and handling input events, to allow for trully portable OpenGL programs.FreeGLUT is released under the X-Consortium license.


  • GLFW - an Open Source, multi-platform library for OpenGL, OpenGL ES and Vulkan development on the desktop. It provides a simple API for creating windows, contexts and surfaces, receiving input and events. GLFW is written in C and has native support for Windows, macOS and many Unix-like systems using the X Window System, such as Linux and FreeBSD.GLFW is licensed under the zlib/libpng license.


  • Pugl - a minimal portable API for GUIs which supports embedding and is suitable for use in plugins. It works on X11, Mac OS X, and Windows. GUIs can be drawn with OpenGL or Cairo. Pugl is vaguely similar to GLUT, but with some significant distinctions: Minimal in scope, providing only what is necessary to draw and receive keyboard and mouse input. No reliance on static data whatsoever, so the API can be used in plugins or multiple independent parts of a program. Single implementation, which is small, liberally licensed Free / Open Source Software, and suitable for direct inclusion in programs if avoiding a library dependency is desired. Support for embedding in other windows, so Pugl code can draw to a widget inside a larger GUI. More complete support for keyboard input, including additional "special" keys, modifiers, and support for detecting individual modifier key presses.


  • CmdlineGL - a simple binary that reads a stream of OpenGL commands as text, renders them to an X11 window, and then writes any user input from the window to standard out. It enables any language capable of reading and writing text to then be able to build interactive graphical applications. This is an old project I wrote in college. It was my 6th entry in a series of "Abuse of Technology" projects where I would do something absurd that was also sort of cool or intriguing or surprising that it could even work. In this case, I was writing animated OpenGL demos in Bash, though it can be used in conjunction with any language.
  • OpenGL bindings for Bash - A project that started as a joke can be useful to people wanting to learn the concepts of OpenGL.


  • https://en.wikipedia.org/wiki/VirtualGL - an open source program that redirects the 3D rendering commands from Unix and Linux OpenGL applications to 3D accelerator hardware in a dedicated server and displays the rendered output interactively to a thin client located elsewhere on the network.

Testing

  • Piglit - an open-source test suite for OpenGL implementations.

Images


  • lonesock.net: SOIL - a tiny C library used primarily for uploading textures into OpenGL. It is based on stb_image version 1.16, the public domain code from Sean Barrett (found here). I have extended it to load TGA and DDS files, and to perform common functions needed in loading OpenGL textures. SOIL can also be used to save and load images in a variety of formats (useful for loading height maps, non-OpenGL applications, etc.)


OpenVG

  • https://en.wikipedia.org/wiki/OpenVG - an API designed for hardware-accelerated 2D vector graphics. Its primary platforms are mobile phones, gaming & media consoles and consumer electronic devices. It was designed to help manufacturers create more attractive user interfaces by offloading computationally intensive graphics processing from the CPU onto a GPU to save energy. OpenVG is well suited[citation needed] to accelerating Flash and mobile profile of SVG sequences. The OpenGL ES library provides similar functionality for 3D graphics. OpenVG is managed by the non-profit technology consortium Khronos Group.

OpenGL ES

  • https://en.wikipedia.org/wiki/OpenGL_ES - or GLES is a subset of the OpenGL computer graphics rendering application programming interface (API) for rendering 2D and 3D computer graphics such as those used by video games, typically hardware-accelerated using a graphics processing unit (GPU). It is designed for embedded systems like smartphones, tablet computers, video game consoles and PDAs. OpenGL ES is the "most widely deployed 3D graphics API in history". The API is cross-language and multi-platform. The libraries GLUT and GLU are not available for OpenGL ES. OpenGL ES is managed by the non-profit technology consortium Khronos Group. Vulkan, a next-generation API from Khronos, is made for simpler high performance drivers for mobile and desktop devices.


  • https://github.com/brackeen/glfm - Write OpenGL ES code in C/C++ without writing platform-specific code.GLFM is an OpenGL ES layer for mobile devices and the web. GLFM supplies an OpenGL ES context and input events. It is largely inspired by GLFW.GLFM is written in C and runs on iOS 8, tvOS 9, Android 2.3.3 (API 10), and WebGL 1.0 (via Emscripten).




  • GL4ES - a library provide OpenGL 2.x functionality for GLES2.0 accelerated Hardware (and support OpenGL 1.5 function, sometimes better then when using GLES 1.1 backend) There is also support for GLES 1.1 Hardware, emulating OpenGL 1.5, and some OpenGL 2.x+ extensions.GL4ES is known to work on many platform: OpenPandora, ODroid, RaspberryPI (2 and 3 at least), PocketCHIP, “otherfruit”PI (like the OrangePI), Android, x86 and x86_64 Linux (tested using mesa-egl). There is also some WIP support for AmigaOS4, using experimental GLES2 driver for Warp3D. The focus is on compatibility and speed with a wide selection of game and software.It has been tested successfully of a large selection of games and software, including: Minecraft, OpenMW, SeriousSam (both First and Second Encounters), RVGL (ReVolt GL), TSMC (The Secret Maryo Chronicles), TORCS, SpeedDreams, GL-117, Foobillard(plus), Blender 2.68 to name just a few.

Vulkan

  • Vulkan - a new generation graphics and compute API that provides high-efficiency, cross-platform access to modern GPUs used in a wide variety of devices from PCs and consoles to mobile phones and embedded platforms.





EGL

  • https://en.wikipedia.org/wiki/EGL_(API) - an interface between Khronos rendering APIs (such as OpenGL, OpenGL ES or OpenVG) and the underlying native platform windowing system. EGL handles graphics context management, surface/buffer binding, rendering synchronization, and enables "high-performance, accelerated, mixed-mode 2D and 3D rendering using other Khronos APIs." EGL is managed by the non-profit technology consortium Khronos Group.The acronym EGL is an initialism, which starting from EGL version 1.2 refers to Khronos Native Platform Graphics Interface. Prior to version 1.2, the name of the EGL specification was OpenGL ES Native Platform Graphics Interface. X.Org development documentation glossary defines EGL as "Embedded-System Graphics Library"


Engine

See also Creative / live coding, 3D / CAD


to sort





Aliasing


Noise

  • The importance of good noise - There are many articles to read about noise functions in computer graphics, especially now that a lot of people recently got interested in ray tracing, but it took me a long time to fully understood why noise characteristics are so important and I didn’t find a good resource on the Internet explaining it, so I’ll give it a shot.

Glitch

  • r/unixporn: [i3lock - Glitched Screenlock with imagemagick and sox]

Synthesis

Evolutionary

  • Picbreeder - a collaborative art application based on an idea called evolutionary art, which is a technique that allows pictures to be bred almost like animals. For example, you can evolve a butterfly into a bat by selecting parents that look like bats.


Maching learning

  • Ganbreeder - a collaborative art tool for discovering images. Images are 'bred' by having children, mixing with other images and being shared via their URL. This is an experiment in using breeding + sharing as methods of exploring high complexity spaces. GAN's are simply the engine enabling this. Ganbreeder is very similar to, and named after, Picbreeder. It is also inspired by an earlier project of mine Facebook Graffiti which demonstrated the creative capacity of crowds.

Graphic designers

Graffiti

  • #000000book - An open database for Graffiti Markup Language (GML) files

Testing


Retrieved from "https://wiki.thingsandstuff.org/index.php?title=Graphics&oldid=53530"