#video of #graphics #algorithms “SIGGRAPH 2026 Papers Fast Forward” #toread (2½ hours)
on 02026-08-25#video of #graphics #algorithms “SIGGRAPH Thesis Fast Forward 2025” #toread (20’)
on 02026-08-25A report from 02013 about printing #ESC-P #graphics on receipt #printers
on 02026-04-22#Epson’s #PDF #reference #documentation for #ESC-P 2; this section describes how to send bit-image or raster #graphics to #printers.
on 02026-04-22new Val Kilmer #movie “As Deep As The Grave” was shot entirely after his death with #AI #graphics.
on 02026-04-16#SIGGRAPH ’24 “thesis fast forward” half-hour #video covering 9 different #graphics dissertations.
Ruben Wiersma talks about applying 2-D neural networks on 3-D meshes in a few different ways, including three that you can pip install: deltaconv pcdiff gravomg.
Chenxi Liu talks about her #algorithms for analyzing vector sketches that artists can use to communicate visual ideas, so far apparently used only for sketch simplification and flood fill.
Rohan Sawhney talks about Monte Carlo geometry processing, specifically to solve PDEs on complex geometry without the volumetric meshing #FEM needs, using “Muller 1956”’s “Walk on Spheres” to interpolate boundary conditions into the interior of a region, using something that sounds similar to an SDF, though he doesn’t call it that; like a “ray tracer” for physics (versus FEM’s “triangle rendering”).
Silvia Sellán talks about faster computation of swept volumes, as well as some other 3-D problems like surface reconstruction; I don’t really understand the common thread between these, though she says it’s “uncertainty quantification”.
Xilong Zhou talks about how to acquire “materials” such as bricks, marble, or ceramic tile, from photos, to use their BRDFs or SVBRDFs in rendering, with some kind of #Bayesian approach.
“Hi, my name is Dr. Zachary Ferguson” talks about a new numerical method for #simulation that don’t experience numerical instability (explosion) when simulated surfaces come into contact and the time step isn’t short enough; it’s called "incremental potential contact", with a new smooth barrier function (with a singularity!) enabling Newton’s method with line search to solve the contact correctly, using continuous collison detection (“CCD”). He claims that his work has “sparked a revolution in physical simulation”, although if that’s true, I don’t know why he feels the need to introduce himself as "Dr. Zachary Ferguson", as if he were used to being ignored and dismissed.
Pascal Guehl [geɪł] talks about texture/material synthesis, what he calls “semi-procedural”, combining the advantages of “by-example” texture synthesis (trying to make things look like a photo) with procedural (adding up noise functions and frequency components). It works by finding the “closest procedural model” to a given example image. Looks really cool.
S. Mazdak “Maz” Abdulnaga talks about volumetric mapping for medical imaging, in particular by minimizing the distortion energy of a volumetric map (ℝ³ → ℝ³) between two target volumes; the energy is defined in a symmetric way, so it doesn’t change when you swap the volumes. For example, you can use this to analyze placental health during pregnancy by mapping 3-D MRI scans taken over time to one another. Other applications include improving texture transfer for surfaces.
Yiwei Hu talks about “efficient material authoring by inverse material modeling”, tackling the same problem as Pascal Guehl in more or less the same way, but using CNN #neural-networks and gradient-based #optimization; his approach seems to handle some cases like checkerboard patterns better than Guehl’s.
on 02026-01-14#video. He says he “evaluates the [#SDF] function once for all points on a [sparse] grid once, and then reuse those cached values when rendering” to get fast enough #performance for fully dynamic #videogames, using bilinear interpolation between the SDF at lattice points to approximate the SDF at intermediate positions. This produces the usual chamfered corner artifacts you see in SDF fonts, as he points out. He uses “brick maps” to reduce storage and, for #LoD, “geometry clipmaps” and the #Jolt-physics engine. However, it seems like he’s having trouble with objects “melting” onto his terrain. #toread #graphics #shaders
on 02026-01-1282-minute #SDF #video which I think ismostly about #sphere-tracing #graphics in #Unreal-Engine for #videogames. #toread
on 02026-01-12#Detheroc (Viktor Chlumský) did their #dissertation on #SDF #fonts using a median-of-three approach to get sharp corners. #graphics
on 02026-01-12“#LambdaCube #3D is a domain specific language and library that makes it possible to program GPUs in a purely functional style.” Abandoned ten years ago. #Haskell #GPGPU #graphics
on 02026-01-12Multichannel #SDF #fonts with sharp corners in the #LambdaCube Font Engine (#Lafonten) using four channels rather than two. #graphics
on 02026-01-12#Qt’s QML Scene Graph renders text using #SDF #fonts with even subpixel #antialiasing, by the simple expedient of “extruding” outline fonts (I think they mean inset/outset). #graphics
on 02026-01-12how #Mapbox uses #SDF #fonts for #maps, including “text halos”, with images of the SDF texture atlases, using 192–255 for “inside” negative SDF values. #graphics
on 02026-01-12the 02007 #SIGGRAPH #PDF #paper by Chris Green at #Valve about #SDF #fonts. Cites a SIGGRAPH ’00 paper by Frisken, Perry, Rockwood, and Jones on adaptively sampled SDFs. #graphics
on 02026-01-12“Making my 1970’s-style renderer multi-threaded” by Filip Hraček. #3D #graphics #concurrency
on 02025-11-28#explorable-explanations of Bézier curves for #graphics
on 02025-11-26#fractals in #PostScript. #small-is-beautiful #graphics
on 02025-11-26#dithering transparency in Super Mario Odyssey #videogames avoids #graphics overdraw “by creating the illusion of transparency through stippling.” I guess you just run your shader program on the background pixels that peek through the dither mask.
on 02025-11-13The ZX Spectrum had 1 bit for each of its 256×192 pixels, then 768 attribute bytes for 8×8 “character cells” which defined a 3-bit paper color, a 3-bit ink color, and bright and flashing attributes. #graphics #retrocomputing
on 02025-11-1341' #CodingAdventure #video on simulating smoke #graphics #toread
on 02025-10-14Xiaolin Wu’s line-drawing algorithm, with purportedly correct code, but using Win32 DrawPixel. #graphics #algorithms
on 02025-08-06#reverse-engineering of Tim J. Clarke’s MARS.COM #demo which did heightfield #3D #graphics, similar to the #VoxelSpace algorithm used in Comanche in 01992
on 02025-07-20Tabatha Hickman’s explanation of how she did #procedural generation of a suburb using shape grammars. #graphics
on 02025-02-21Rishabh Shah’s #demo of #procedural generation of a city using shape grammars using WebGL and JS. You have to click the “iterate” button a few times #3D #graphics
on 02025-02-21half-hour #video lecture on generation of buildings with grammars (including shape grammars like CityEngine’s CGA) by Rachel Hwang. I think she was teaching the class “CIS 700 - Special Topics in #Procedural #Graphics” at the University of Pennsylvania in spring 02016.
on 02025-02-21a pretty three.js shader making firework #graphics #shaders #JS
on 02024-11-13#akkartik wrote a #multitouch Mandelbrot #fractals zoomer #graphics
on 02024-09-16explains, “Every time you set the scissor state with glScissor, you set the scissor state. It does not nest, and it does not stack, so you cannot “subscissor” with nested calls to #glScissor. You’ll have to manually compute the rectangular intersection of your ListView and your Window bounding rects, and then scissor to that when drawing ListView.” #OpenGL #graphics
on 02024-09-11#retrocomputing #history #video of #Symbolics #Lisp #3D #graphics. Probably from about 01987. Maybe a digitization of a 30' VHS tape made by Symbolics at the time with shitty elevator music. He’s interactively modeling of a little airplane.
To orient the 3-D axes, their negative sides are “marked with gaps”, and the Z-X plane is “marked with a triangle” (the Y axis being the normally vertical one, as in Minetest).
The original might have been higher resolution, because all the user interface text is illegible except in occasional zoom shots.
It takes about 4 frames at 30fps for each popup menu to fully draw, making the #UX a bit sluggish, and larger menus can take as long as 8 frames. Similarly, the little airplane model (with about 30 polygons) can only redraw about once every 4 frames, making interactive rotation clumsy.
Interesting choice called out at 6'28": the popup menu pops up with the mouse on top of the last choice, easing the task of repeating it. As IIRC is usual with Genera, the menus have black shadows, and the active menu item is highlighted by drawing a box around its text.
Object edges and points are highlighted by making them thicker; object faces are highlighted by filling them with black. Presumably at this point they didn’t have color.
It can import data from “Cattom [?], CATIA, and IGES formats”!
At 11'55” he’s enthusiastically explaining how Genera supports multitasking, as he demonstrates a somewhat Flash-like animation program called “S-Dynamics”.
At 14'44” he shows “a look at [the bird animation] on the color screen”, which implies that indeed the screen he's been looking at is monochrome.
At 18'28” he starts doing a UI demo on the color screen itself, which is even slower, probably because it uses 32-bit RGBA. There’s a sort of ribbon-like thing across the bottom with a hierarchical menu tree structure inside of it. Drawing a translucent gradient circle is demonstrated at 21'25” and takes over two seconds of computation!
At the end, he mentions being able to export to “any video format”: “PAL, NTSC, or HDTV”, and the first (satellite) HDTV broadcasts were in 01989, so this might have been at the very tail end of Symbolics, around 01990.
Oh, yes, at the very end it says it's “Copywrite [sic] 1989 Symbolics Inc.”.
on 02024-08-07#graphics #algorithms for median filtering and percentile filtering (rank filters): the histogram algorithm, binary-tree algorithm, Perreault and Hérbert’s constant-time algorithm, etc.
on 02024-07-27discussion of #graphics #algorithms for median filtering
on 02024-07-27a more manual way to add lines to a 3-D display for #graphics debugging in #Godot is to add a CanvasLayer with a Control and override the Control’s _draw method to use $Camera3D.unproject_position; I suspect you can still do this in Godot 4
a simple library to add lines to a 3-D display for #graphics debugging in #Godot, which works in Godot 4
on 02024-06-24#video #toread about raytracing #graphics from two-minute papers
on 02024-06-23#CodingAdventure #video #toread #tutorial on raymarching #graphics
on 02024-06-23a new #Gaussian-Splatting #paper analyzing it as Markov chain Monte Carlo #MCMC #graphics
on 02024-06-18#graphics with spherical harmonics for Lambertian lighting with light probes #math
on 02024-06-18#Perspective corrected #texture-mapping interpolation in #graphics, and the alternative affine-mapping approximation used by the PS1 hardware
on 02024-06-16#CodingAdventure #video about #raytracing #graphics with BVH in #Unity. He’s using AABBs split spatially in half along the long axis, with triangles assigned according to their centers and the AABBs grown to fit. He’s using the Stanford Dragon as his test mesh. Apparently Unity’s shader language doesn’t support recursion, nested lists, or dynamic allocations, but syntactically looks very much like C#, except for out or inout on some parameters. while-loops are fine. You communicate with the shader by SetBuffering a “material” (RayTracingMaterial, I guess is what he called his shader), but the buffer names aren’t checked. Also he crashed the GPU by overrunning a buffer. Aha, and Unity wraps your mouse around the left and right edges of the screen when you’re dragging left or right on a number to adjust it. By building a 27-level deep BVH over an 81000-triangle reduced version of the model and using early ray termination tests, he was able to get that model to display at 325+ fps instead of being slow and janky. Further optimizations (maintaining integers rather than structs on the BVH stack, splitting nodes using the “surface area heuristic”, and reducing the size of his node struct) got to 600+. This version could handle the whole 870k triangle model at almost 500 fps. Finally he adds reflection and renders the model in the Sponza Palace.
#video on how to set up 2-D glow #graphics in #Godot (this was the one that got me over the hump to actually getting it working)
on 02024-05-28#video about #graphics for 2-D #games in #Godot. Super awesome tips: the highest-impact visual tweaks to add. Specifically, 2-D glow, ACES or filmic tonemapping, using a color palette from Lospec or something, set up your camera well (maybe focusing on what the player is pointing at), adding lights, adding particles, and easing (“animating”) transitions with lerp or Tweens.
on 02024-05-26#video of #shaders for simulating fire #graphics in #Godot with noise and a fire texture made in Krita, sampled twice and multiplied, then mapped through a fire colormap
on 02024-05-26#video #tutorial on #particle-systems, including #graphics of fire, explosions, retro video game explosions, implosions, and shattering sprites. Also covers #Godot’s AnimationPlayer node a bit.
on 02024-05-26100% #CC CC0 public-domain HDRI environments, PBR material textures, and “hyperreal” #3D models, for #games and #graphics. Hundreds of each. The latest 3-D model is a 3-D scanned milk can in 6000 polygons (“Metal Jug”). The texture images are all at least 8000 pixels square, and they have normal maps. Supports .blend, glTF, .zip, .usd (Universal Scene Description), .fbx, and for HDRIs, Open EXR and Radiance RGBE (.hdr). Supported by ads, several hundred patrons on Patreon (who get early access to new files that are otherwise shown only as teasers for weeks), and a Blender addon. One of the top downloads is a 27k triangle model of a Leica camera uploaded four years ago with 27000 triangles and 89000 downloads. #pasivos
on 02024-05-21#video on making #shaders in #Godot for fake water #graphics or fire, etc. He maps a sum of two noise textures (fed in as uniform sampler2Ds) to the water depth, uses that as a displacement to sample from another texture, then smoothsteps the depth to get some white highlights on the waves.
on 02024-05-20#video on #graphics performance of sunbeams in a forest in #games
on 02024-05-19#graphics in #games look cool when your #shaders posterize the V channel of HSV, or all three. #video
on 02024-05-19#video on #Godot #mapgen #graphics #toread
on 02024-05-19“giving personality to procedural animations (for #games) using math” illustrated using Manim. Reparameterizes a second-order ODE with natural frequency f, damping coefficient ζ, and response speed r, to get a conveniently controllable system, then integrates it with the semi-implicit Euler method, then analyzes the eigenvalues of the state transition matrix to ensure stability. #video #graphics
on 02024-05-18#raytracing #graphics including #algorithms like resampled importance sampling, reservoir sampling, temporal reuse, spatial reuse, and #ReSTIR. Another very nice pure-CGI #video
on 02024-05-18terrain #mapgen for mountain #graphics with fractal Perlin noise and iq’s “gradient trick”, where you attenuate higher-frequency layers wherever the gradient of the lower-frequency layers is large; also, with diffusion-limited aggregation with a gradually increasing level of detail, and with “dual-filter blurring” #image-processing, where you alternate downsampling an image with blurring it, then alternate upsampling the result with blurring it, much like multiscale low-pass filtering with Hogenauer filters. Very nice pure-CGI #video.
on 02024-05-18A lost #video of the 128-byte #3D #graphics #raytracer called #Spongy. #small-is-beautiful
on 02024-04-15TBC’s "Spongy" by mentor, a #3D #graphics #raytracer of a Menger sponge (#fractals) in a 128-byte (#small-is-beautiful) MS-DOS executable (b013 cd10 6800 a007 bac8 03ee 42ee eeee 4075 f5f7 e340 01f8 f774 15b9 7f00 29ca 60b1 04be f8ff df44 fade 74f8 d9fb de08 80f3 02d9 c9de 0875 04d9 e089 04de c1ad 8b00 df18 e2dd b101 31ed bef8 ffad f7e3 0344 f5f7 e105 ab2a 3d55 5583 dd00 7b0e 83fe fe7c e86b c903 84c9 79dc eb05 fec3 75d4 4b93 c1e8 02aa 6147 7597 452f eb93) winning 1st place in the PC 256-byte division at Function 2009
on 02024-04-15discussion of the BBC #BASIC #3D #raytracer #small-is-beautiful #graphics
on 02024-04-15Explanation and movie of the #3D #graphics #raytracer in 10 lines of #BASIC (in the family of the BBC BASIC one, but for an Atari). #small-is-beautiful
on 02024-04-15Oscar Toledo G. just released a boot sector real-time animated ray tracer, based on the BBC BASIC one, which can be run from a floppy disc boot sector with no OS #small-is-beautiful #3D #graphics #raytracer #asm
on 02024-04-15#Bresenham #graphics #algorithms modified to draw thick lines
on 02024-02-21#color in physically-based rendering of 3-D #graphics
on 02024-01-31#Graphics Gems book series home page, with all the code
on 02024-01-28#PDF scan of Phil Koopman’s article (01986? #FORTH Dimensions Volume VIII, No. 6) giving #Bresenham’s line-drawing algorithm in Forth. 23 lines of code provide a driver for 4-color CGA with comments explaining how to patch it for EGA or 2-color CGA. He got the algorithm from p. 435 of “Foley and Van Dam, Fundamentals of ICAD”, maybe actually “Fundamentals of Interactive Computer Graphics”, where p. 435 gives an implementation in Pascal. 2D #graphics #retrocomputing
on 02024-01-28#PDF #paper from 02013 about the language #Halide for #GPGPU #graphics
on 02024-01-28#PDF #paper from #Bresenham in 01965 giving Bresenham’s line-drawing algorithm: “Algorithm for computer control of a digital plotter”. Says the original paper was “An incremental algorithm for digital plotting” in 01963. Also incidentally says Iverson “introduced” the floor/ceiling notation, though as they were both IBMers, possibly we should take that “seriously but not literally”. 2-D #graphics #algorithms
on 02024-01-28why #Wayland is a better option for the future of driving your #graphics hardware than trying to keep #XFree86 alive, by the guy who got sick of doing it #X-Windows
on 02024-01-25Nelson Beebe’s PLOT79 #PDP-10 software had 29 installations worldwide in 01981, according to his example pie chart here. The following page explains, “Plot facilities on the College of Science DECSYSTEM-20 currently consist of the following: ... Apple LaserWriter laser printer ... Imlac PDS-1D refresh-type CRT” #history #vector #graphics
on 02024-01-17BBC #BASIC #graphics #raytracer in 8 lines of code, 448 bytes, with #emulation. 10 REMĀĘĆĞ$Č*Ēĉ!ăě-ĕ'ď 20 MODE1:VDU5 30 FORN=8TO247:FORM=0TO319 40 X=0:Y=-.1:Z=3:U=(M-159.5)/160:V=(N-127.5)/160:W=1/SQR(U*U+V*V+1):U=U*W:V=V*W:I=SGNU:G=1 50 E=X-I:F=Y-I:P=U*E+V*F-W*Z:D=P*P-E*E-F*F-Z*Z+1:IFD>0T=-P-SQRD:IFT>0X=X+T*U:Y=Y+T*V:Z=Z-T*W:E=X-I:F=Y-I:G=Z:P=2*(U*E+V*F-W*G):U=U-P*E:V=V-P*F:W=W+P*G:I=-I:GOTO50 60 IFV<0P=(Y+2)/V:V=-V*((INT(X-U*P)+INT(Z-W*P)AND1)/2+.3)+.2 70 GCOL0,3-(48*SQRV+?(PAGE+5+M MOD4+N MOD4*4)/3)DIV16 80 PLOT69,4*M,4*N:NEXT,
BBC #BASIC #graphics #raytracer in half a kilobyte, though I think the line numbers are maybe missing #small-is-beautiful
on 02024-01-172-D #graphics #algorithms for simplifying Bézier paths, describing an algorithm implemented in his Rust library for 2-D shapes, "kurbo".
on 02024-01-142-D #graphics #algorithms for outlining Bézier strokes. “This post presents a significantly better solution to the parallel curve problem than the current state of the art.” Includes #explorable-explanations.
on 02024-01-14the #Slug 2-D #graphics #algorithms #paper, “GPU-Centered #Font Rendering Directly from Glyph Outlines”, by Lengyel, #CC BY-ND, 02017
on 02024-01-14"Slug" library for 2-D #graphics for rendering a #font or similar vector graphics on the GPU
on 02024-01-14#PDF #paper on 2-D #graphics for rendering a #font on the GPU, by Loop and Blinn, 02005
on 02024-01-14#PostScript #tutorial and reference for 2D #graphics.
on 02024-01-14Curl noise #3D #graphics #shaders
on 02024-01-12#proce55ing supports 2-D #graphics blend modes other than just alpha compositing: BLEND (B := A·factor + B), ADD (B := A·factor + B ∧ 255), SUBTRACT (B := B - A·factor ∨ 0), DARKEST (B := A·factor ∧ B), LIGHTEST (B := A·factor ∨ B), DIFFERENCE, EXCLUSION, MULTIPLY (as values from 0–1 I guess), SCREEN (“opposite multiply”??), and REPLACE (ignoring alpha). The older blend() function also supports HARD_LIGHT, SOFT_LIGHT, OVERLAY, DODGE, and BURN.
The #Gaussian-splatting #graphics #paper came out on 02023-05-02.
on 02023-12-08#SDF #raytracer in #Haskell #3D #graphics #small-is-beautiful
on 02023-10-08My very first #raytracer (in four pages of C) #3D #graphics #small-is-beautiful
on 02023-10-08#pointcloud #3D #graphics #algorithms with a tiny #ASCII-art implementation in a few lines of C. #small-is-beautiful
on 02023-09-19Bresenham’s #graphics #algorithms for lines, circles, axis-aligned #ellipses, and Bézier curves.
on 02022-05-27“The High Precision DDA for Ellipse-Generation”, by Hong Tao, Aircraft Manufacturing Engineering Dept., Northwestern Polytechnical University, Xi’an, The People’s Republic of China, #graphics #algorithms for #ellipses from 01988
on 02022-05-27more about the #scanline-rendering #graphics #algorithm
on 02022-05-21the #scanline-rendering #graphics #algorithm generates the pixels of a scene in order, published by Wylie, Romney, Evans, and Erdahl in 01967 and independently in 01969 and 01972, and used by Evans and Sutherland “ESIG” image generators to rasterize on the fly; the Nintendo DS does too, and so does Quake.
on 02022-05-21SIGGRAPH ’21 #PDF presentation explaining how Unreal Engine 5’s "Nanite" “virtual geometry system” does automatic level-of-detail #graphics on triangle meshes, as an alternative to voxelization, displacement maps, point clouds, or subdivision surfaces; it doesn’t handle skeletal animation yet. It groups triangles into clusters of up to 128 triangles, which are sort of grouped into higher-level clusters, and culls invisible clusters.
on 02021-11-03"Nanite" “virtual geometry system” in Unreal Engine 5. #graphics
on 02021-11-02“DEODR (for Discontinuity-Edge-Overdraw based Differentiable Renderer) is a #differentiable #3D mesh renderer written in C with Python and Matlab bindings.” for “efficient analysis-by-synthesis computer vision” from 02008! #graphics #optimization #software #rendering
on 02021-02-09#software of #SDFDiff #differentiable #signed-distance-fields #3D #optimization #graphics #rendering. Proprietary by default tho
on 02021-02-09#video of "SDFDiff" #Differentiable #Rendering of #Signed-Distance-Fields for #3D Shape #Optimization (CVPR2020 Oral), using a multiresolution strategy. #graphics
on 02021-02-09#Video of the #DIST #differentiable #graphics #rendering software #3D scanning a couple of chairs with #optimization
on 02021-02-09#3D reconstruction with #differentiable #optimization using sphere tracing of a #signed-distance-field with the "DIST" #graphics #rendering software
on 02021-02-09#notty is a new #graphics protocol for #terminals, similar to MGR or (somewhat less) to X11 or #stdg
on 02021-01-24Michael #Abrash’s #Graphics Programming Black Book from 01997. #performance #ebook
on 02021-01-24apparently xterm is acquiring #SIXEL support and with libsixel and osmesa you can do real-time #3D #graphics that way in #terminals
on 02021-01-24AcidWarp, free eyecandy #graphics software from 1993 for MS-DOS
on 02021-01-20discussion of (MIT) Li et al.'s #graphics rasterizer that’s differentiable (because it uses a sigmoid where normal rasterizers would use a step function) for #optimization
on 02021-01-15discussion of #graphics #dithering #algorithms including output-dependent feedback
on 02021-01-13a fairly comprehensive summary of #graphics #dithering #algorithms
on 02021-01-13the good-looking textured light-sourced bouncy fun smart and stretchy page, on #graphics #algorithms
on 02021-01-13how Inigo Quilez #iq did the moss and grass #graphics for the movie Brave
on 02021-01-13"stdg" provides #graphics from shell scripts (or anything else that can do text on stdin and stdout) with a simplified PostScript-like command language — but supporting interactivity! Just 1kloc of #Rust. #smallisbeautiful
on 02020-12-01Bresenham’s #algorithms for plotting lines, ellipses, antialiased quadratic Bézier curves, etc. #graphics
on 02020-12-01#algorithms for rotating raster #graphics (with three shears)
on 02020-12-01Gabriel Gambetta, who wrote the 1-kilobyte JS #raytracing code, is releasing an awesome #ebook on computer #graphics under CC BY-NC-SA; it includes a relatively full-featured rasterizer and a relatively full-featured raytracer.
on 02020-12-01#Raytracing in one weekend, #CC0 #public-domain #ebook #graphics
on 02020-10-10behind the scenes of #demoscene demo Guberniya by Macau Exports #graphics
on 02019-02-09#Gray-Scott #reaction-diffusion #graphics with tourism notes on the whole phase space
on 02019-02-01A summary of Minskys and Trinskys. #math #minsky-circle-algorithm #graphics #fractals
on 02018-11-23#PDF of the "Porter–Duff" #paper defining an algebra of #graphics image-compositing operators
on 02018-10-23on GL compute #shaders and their relative advantages and disadvantages compared to fragment shaders (and vertex shaders? not sure) #graphics
on 02018-10-13recommendations for #graphics #rendering books
on 02018-10-13photorealistic pathtracing #rendering in #Shadertoy #WebGL fragment #shaders using a texture buffer for progressive improvement (?) #graphics
on 02018-10-13dissections of #Shadertoy #WebGL fragment #shaders, including a photorealistic cloud simulation in 10 lines of code and real-time raytracing #rendering #graphics
on 02018-10-13doing liquid simulation using #WebGL fragment #shaders #graphics
on 02018-10-13doing #cellular-automata (the Game of Life in this case) using #WebGL fragment #shaders #graphics
on 02018-10-13using #WebGL #shaders on #Shadertoy to solve the wave equation and thus simulate waves #graphics
on 02018-10-13how to use fragment #shaders with texture buffers from #Shadertoy in #OpenFrameworks #graphics
on 02018-10-13generating a city from noise in #WebGL fragment #shaders #shadertoy #graphics
on 02018-10-13how to use fragment #shaders in #WebGL in three.js #JS #Shadertoy #graphics
on 02018-10-13#rendering to textures in #WebGL #shaders #graphics
on 02018-10-13#rendering to texture buffers in #WebGL #shaders in order to get state #graphics
on 02018-10-13#rendering real-time #caustics in #WebGL, with a link to a demo. #graphics
on 02018-08-30a global illumination method, including #caustics, using “photon maps” #rendering #graphics
on 02018-08-30HP-PCL documentation from 1993, explaining how to compose HP-PCL files including HPGL commands for vector #graphics in MS-DOS EDIT.
on 02018-01-01#3D terrain rendering #algorithms from Novalogic’s 01992 game “Comanche” in 20 lines of #graphics code, using ray-casting in voxel space (?) — a pretty standard #heightfields rendering thing really #smallisbeautiful #voxelspace
on 02017-11-25#Ryg recommends papers #toread. He’s limited it to 10 and they’re mostly focused on #graphics. I haven’t read a single one of them.
on 02017-11-25Mason Change explains how the new #graphics system in #Firefox works. #toread
on 02017-08-22‘“But Vulkan is the hardz” I hear you saying. “Shouldn’t I start with something easy like OpenGL?” Emphatically I say NO. The point is that #Vulkan removes the mystery. It spells things out, plain as day. And for a programmer, this is awesome! It’s intellectually honest about what it needs, and what it’s doing. It will teach you what it really means to program a GPU.’ #graphics #tutorial
on 02017-08-06#Ray-tracing with global illumination “using unbiased Monte Carlo path tracing” in 99 lines of C++. #smallisbeautiful #rendering #graphics
on 02017-08-06"Butteraugli" #graphics #compression #psychovisual assessment algorithm.
on 02017-08-06#DSSIM #graphics #compression #psychovisual image quality assessment algorithm #source-code.
on 02017-08-06"DSSIM" is a #graphics #compression #psychovisual image quality assessment algorithm.
on 02017-08-06#SSIMULACRA #graphics #compression #psychovisual image quality assessment algorithm #source-code. It’s based on DSSIM.
on 02017-08-06"SSIMULACRA" is a #graphics #compression assessment algorithm; it does #psychovisual image quality assessment.
on 02017-08-06#Graphics #performance #algorithms: running console graphics pipeline #emulation (of the Nintendo GameCube, specifically, in the Dolphin emulator) in a pseudo-GPGPU "Ubershader"
on 02017-07-30how to use #Ditaa for #graphics #diagrams
on 02017-06-16"Ditaa" is “diagrams through ASCII art” — the thing used for the diagrams in the ZeroMQ book. You draw ASCII-art box-and-line #diagrams (with Emacs artist-mode or whatever) and it converts them to colored images with drop-shadows and whatnot. Org-mode bundles it. #graphics
on 02017-06-16#ebook with #Proce55ing #explorable-explanations of how to do different kinds of #graphics and physics effects in code
on 02017-05-30#PDF of a Henry Baker #paper about complex #math #algorithms and CORDIC and whatnot. #geometry #graphics
on 02017-05-27Ken Perlin presents a live-editable explanation of #ray-tracing, using #WebGL GLSL. #explorable-explanations #graphics #rendering
on 02017-05-19#pdf #paper #toread “Sampling Procedural Shaders Using #Affine-Arithmetic” #interval-arithmetic #graphics “an average value of the shader together with accurate error bounds over a finite area” from 1998!!
on 02017-05-19#paper “Fast #Ray-Tracing of Arbitrary Implicit Surfaces with Interval and #Affine-Arithmetic” #interval-arithmetic #graphics #toread with reduced affine arithmetic and #GPGPU goodness from 2008.
on 02017-05-19#pdf #paper “Ray Casting Implicit Fractal Surfaces with Reduced #Affine-Arithmetic” #graphics #ray-tracing #interval-arithmetic #toread This looks fricking awesome. From 2010.
on 02017-05-19more about #ambient-occlusion #graphics, here in 3ds Max
on 02017-03-11in #graphics, you can get a “very crude approximation to full global illumination” with an "ambient occlusion" map on your image
on 02017-03-11syllabus for a course in the #3D #graphics program #Blender by Neal Hirsig
on 02017-01-14Ken Perlin’s simplex-noise software patent. :( #graphics #algorithms #patents
on 02016-11-21Ken Perlin won an Oscar for the Perlin noise, which he invented for Tron and later improved with “simplex noise”, which I think goes off-patent in 2022. #graphics #algorithms
on 02016-11-21"Rhodium liquid carbon", a truly amazing little #graphics demo in #WebGL, or really in GLSL, doing real-time volumetric #ray-tracing of a particle system with depth of field, refraction, and glow all in a couple hundred lines of code. By demoscene artist Virgill. #smallisbeautiful #rendering
on 02016-10-23the chapter from the #OpenGL Red Book that covers the stencil buffer XOR polygon filling hack. #graphics
on 02016-09-29#graphics #algorithms #performance #sse #toread by #ryg
on 02016-09-29#graphics #algorithms rasterizing triangles with #barycentric coordinates without worrying about performance #toread by #ryg
on 02016-09-29improving #graphics #algorithms #performance with #barycentric coordinates. #toread by #ryg
on 02016-09-29“an algorithm and associated sample code [using #SSE] for software occlusion culling which is available for download” #algorithms #performance #toread this is what ryg was commenting on in his 2013 #graphics thread
on 02016-09-29Write combining can cause #performance problems in #graphics #algorithms or can speed them up. #toread by #ryg
on 02016-09-29ryg explains how to do #graphics programming
on 02016-09-23Simulating water ripples efficiently with integer #DSP time-space filtering: d[i] = ((s[i-1]+s[i+1]+s[i-320]+s[i+320]) >> 1) - d[i]; d[i] -= d[i] >> 5;. #graphics
comments on #Raph-Levien’s #font renderer #font-rs. Raph is raphlinus. #graphics
on 02016-08-03Sean Barrett explains how his #font rasterizer does #antialiasing #graphics with paraxial trapezoids and precise signed-area calculations.
on 02016-08-03#Raph-Levien lucidly explains how his new #font rasterizer "font-rs" in #Rust is the fastest (≈6× faster than FreeType). Among other things, he uses #SSE #prefix-sum to do the filling, and structures the parser as an iterator to avoid allocation. #graphics #performance
on 02016-08-03#source-code by #Detheroc for "msdfgen", which renders #fonts using a multi-channel #SDF to get sharp corners. #graphics
on 02016-08-03Chris Green’s #pdf #graphics #paper on magnified rendering of line-art textures using #shaders to bilinear-filter a low-resolution "signed distance field" (#SDF) texture and then threshold it (“alpha testing”). Seems like it could be applicable to raster-to-vector conversion (e.g. potrace). (The file is rather heavy for viewing in xpdf; recommend evince or a similar prefetching PDF viewer.)
on 02016-08-03Darius wrote a new interpreter for Chris Van Wyk’s #constraint #graphics language “IDEAL” in Python
on 02016-08-02SwiftShader is a new #graphics library, this time for GPUless 3D rendering.
on 02016-06-29#pdf #paper describing the Reyes #graphics #rendering architecture, from 1987, by Cook, Carpenter, and Catmull.
on 02016-05-24Chris Van Wyk’s IDEAL programming language for #constraint #graphics.
on 02015-11-16#pdf #paper on #convolution-surfaces in #3D #graphics, made computationally tractable by the choice of an especially well-behaved convolution kernel.
on 02015-11-16#Bret-Victor’s #constraint #graphics program Substroke, based on #programming-by-example.
on 02015-11-16“Seaborn is a library for making attractive and informative #statistics #graphics in #Python. It is built on top of matplotlib and tightly integrated with the PyData stack, including support for #numpy and #pandas data structures and statistical routines from scipy and statsmodels.”
on 02015-11-16#rasterization of #graphics with #wavelets does #antialiasing of polygons and Béziers without error.
on 02015-09-17#video on how “oldschool” #hardware #graphics worked, like the Commodore 64 and the Nintendo NES. Doesn’t really cover character-generator displays.
on 02015-08-19Doing gaussian (and other) #blur filters on a #GPU for #graphics.
on 02015-08-05