forked from alex-eg/sex
alex-eg
a221e0f8ea
<OpenGL/gl3.h> does not exist there and -framework is not a gcc flag, so the documented build line failed with no hint why. #+macosx picks the header now, and both build lines are in the file -- pkg-config carries the flags on either platform, apart from Apple's GL framework, which has no pkg-config file to carry.
263 lines
8.8 KiB
Scheme
263 lines
8.8 KiB
Scheme
;;; A triangle that follows the mouse pointer, spins while the left
|
|
;;; mouse button is held down, and quits on Escape (or on closing the
|
|
;;; window).
|
|
;;;
|
|
;;; SDL3 supplies the window, the GL context and the events. Everything
|
|
;;; drawn goes through an OpenGL 3.3 core-profile pipeline: a vertex and
|
|
;;; fragment shader, and one VAO/VBO holding a unit triangle. Where the
|
|
;;; triangle is and how far it has spun are passed in as uniforms, so
|
|
;;; the geometry itself is uploaded once and never touched again.
|
|
;;;
|
|
;;; Build, macOS:
|
|
;;; ./sexc example/sdl3-triangle.sex -o sdl3-triangle -- `pkg-config --cflags --libs sdl3` -framework OpenGL
|
|
;;;
|
|
;;; Build, Linux:
|
|
;;; ./sexc example/sdl3-triangle.sex -o sdl3-triangle -- `pkg-config --cflags --libs sdl3 gl`
|
|
;;;
|
|
;;; The GL header is the one platform difference, and #+ / #- picks it.
|
|
;;; Apple keeps the core-profile entry points in <OpenGL/gl3.h> and
|
|
;;; links them through -framework OpenGL, which no pkg-config file
|
|
;;; describes; everywhere else the prototypes come from <GL/glext.h>
|
|
;;; with GL_GLEXT_PROTOTYPES defined, and -lGL -- `pkg-config --libs
|
|
;;; gl' -- resolves them. SDL3/SDL_opengl.h is not the shortcut it
|
|
;;; looks like: on Apple it resolves to the 2.1 header, which has no
|
|
;;; glGenVertexArrays and so cannot bind the VAO this program needs.
|
|
|
|
#+macosx (define GL-SILENCE-DEPRECATION 1) ; OpenGL is deprecated on macOS
|
|
|
|
(include SDL3/SDL.h)
|
|
|
|
#+macosx (include OpenGL/gl3.h)
|
|
#-macosx (define GL-GLEXT-PROTOTYPES 1)
|
|
#-macosx (include GL/gl.h)
|
|
#-macosx (include GL/glext.h)
|
|
|
|
(define WINDOW-WIDTH 800)
|
|
(define WINDOW-HEIGHT 600)
|
|
|
|
(define TRIANGLE-RADIUS 70.0) ; in window units
|
|
(define SPIN-SPEED 3.0) ; radians per second
|
|
|
|
;;; The vertex shader does the whole transform: spin the unit triangle
|
|
;;; by u_angle, scale it to u_radius, move it to u_center, then convert
|
|
;;; from window coordinates to clip space. That way a frame only has to
|
|
;;; push four uniforms rather than rebuild any geometry.
|
|
(var vertex-shader-src (* const char) "
|
|
#version 330 core
|
|
|
|
layout (location = 0) in vec2 a_pos;
|
|
layout (location = 1) in vec3 a_color;
|
|
|
|
uniform vec2 u_center; // triangle centre, in window units
|
|
uniform vec2 u_viewport; // window size, same units as u_center
|
|
uniform float u_angle; // current spin, in radians
|
|
uniform float u_radius; // triangle size, in window units
|
|
|
|
out vec3 v_color;
|
|
|
|
void main()
|
|
{
|
|
float s = sin(u_angle);
|
|
float c = cos(u_angle);
|
|
vec2 spun = vec2(a_pos.x * c - a_pos.y * s,
|
|
a_pos.x * s + a_pos.y * c);
|
|
vec2 p = spun * u_radius + u_center;
|
|
|
|
// Window coordinates have their origin top-left with y growing
|
|
// downwards; clip space is centred with y growing upwards.
|
|
gl_Position = vec4(p.x / u_viewport.x * 2.0 - 1.0,
|
|
1.0 - p.y / u_viewport.y * 2.0,
|
|
0.0,
|
|
1.0);
|
|
v_color = a_color;
|
|
}
|
|
")
|
|
|
|
(var fragment-shader-src (* const char) "
|
|
#version 330 core
|
|
|
|
in vec3 v_color;
|
|
out vec4 frag_color;
|
|
|
|
void main()
|
|
{
|
|
frag_color = vec4(v_color, 1.0);
|
|
}
|
|
")
|
|
|
|
(fn compile-shader ((kind GLenum) (src (* const char))) GLuint
|
|
(var shader GLuint (glCreateShader kind))
|
|
(glShaderSource shader 1 (& src) NULL)
|
|
(glCompileShader shader)
|
|
|
|
(var ok GLint 0)
|
|
(glGetShaderiv shader GL-COMPILE-STATUS (& ok))
|
|
(if (== ok 0)
|
|
(do
|
|
(var info [char 1024])
|
|
(glGetShaderInfoLog shader 1024 NULL info)
|
|
(SDL-Log "shader compilation failed: %s" info)
|
|
(glDeleteShader shader)
|
|
(return 0)))
|
|
(return shader))
|
|
|
|
(fn make-program () GLuint
|
|
(var vertex-shader GLuint (compile-shader GL-VERTEX-SHADER vertex-shader-src))
|
|
(var fragment-shader GLuint (compile-shader GL-FRAGMENT-SHADER fragment-shader-src))
|
|
(if (c-or (== vertex-shader 0) (== fragment-shader 0))
|
|
(do
|
|
(glDeleteShader vertex-shader)
|
|
(glDeleteShader fragment-shader)
|
|
(return 0)))
|
|
|
|
(var program GLuint (glCreateProgram))
|
|
(glAttachShader program vertex-shader)
|
|
(glAttachShader program fragment-shader)
|
|
(glLinkProgram program)
|
|
|
|
;; The shaders are only needed until the program is linked; the
|
|
;; program holds its own reference until then.
|
|
(glDeleteShader vertex-shader)
|
|
(glDeleteShader fragment-shader)
|
|
|
|
(var ok GLint 0)
|
|
(glGetProgramiv program GL-LINK-STATUS (& ok))
|
|
(if (== ok 0)
|
|
(do
|
|
(var info [char 1024])
|
|
(glGetProgramInfoLog program 1024 NULL info)
|
|
(SDL-Log "program linking failed: %s" info)
|
|
(glDeleteProgram program)
|
|
(return 0)))
|
|
(return program))
|
|
|
|
(pub fn main () int
|
|
(if (! (SDL-Init SDL-INIT-VIDEO))
|
|
(do
|
|
(SDL-Log "SDL_Init failed: %s" (SDL-GetError))
|
|
(return 1)))
|
|
|
|
;; Ask for core profile 3.3 before the window exists: these attributes
|
|
;; are read when the context is created.
|
|
(SDL-GL-SetAttribute SDL-GL-CONTEXT-MAJOR-VERSION 3)
|
|
(SDL-GL-SetAttribute SDL-GL-CONTEXT-MINOR-VERSION 3)
|
|
(SDL-GL-SetAttribute SDL-GL-CONTEXT-PROFILE-MASK SDL-GL-CONTEXT-PROFILE-CORE)
|
|
(SDL-GL-SetAttribute SDL-GL-DOUBLEBUFFER 1)
|
|
|
|
(var window (* SDL-Window)
|
|
(SDL-CreateWindow "Sex + SDL3 + OpenGL"
|
|
WINDOW-WIDTH WINDOW-HEIGHT
|
|
SDL-WINDOW-OPENGL))
|
|
(if (== window NULL)
|
|
(do
|
|
(SDL-Log "SDL_CreateWindow failed: %s" (SDL-GetError))
|
|
(SDL-Quit)
|
|
(return 1)))
|
|
|
|
(var gl-context SDL-GLContext (SDL-GL-CreateContext window))
|
|
(if (== gl-context NULL)
|
|
(do
|
|
(SDL-Log "SDL_GL_CreateContext failed: %s" (SDL-GetError))
|
|
(SDL-DestroyWindow window)
|
|
(SDL-Quit)
|
|
(return 1)))
|
|
|
|
(SDL-GL-MakeCurrent window gl-context)
|
|
(SDL-GL-SetSwapInterval 1)
|
|
|
|
(var program GLuint (make-program))
|
|
(if (== program 0)
|
|
(do
|
|
(SDL-GL-DestroyContext gl-context)
|
|
(SDL-DestroyWindow window)
|
|
(SDL-Quit)
|
|
(return 1)))
|
|
|
|
;; A unit triangle, two position components then three colour
|
|
;; components per vertex. The vertices sit on the unit circle at 90,
|
|
;; 210 and 330 degrees; the shader spins, scales and moves it.
|
|
(var verts [GLfloat 15]
|
|
#( 0.000 1.000 1.00 0.35 0.35
|
|
-0.866 -0.500 0.35 1.00 0.45
|
|
0.866 -0.500 0.40 0.50 1.00))
|
|
|
|
(var vao GLuint 0)
|
|
(var vbo GLuint 0)
|
|
(glGenVertexArrays 1 (& vao))
|
|
(glBindVertexArray vao)
|
|
(glGenBuffers 1 (& vbo))
|
|
(glBindBuffer GL-ARRAY-BUFFER vbo)
|
|
(glBufferData GL-ARRAY-BUFFER (sizeof verts) verts GL-STATIC-DRAW)
|
|
|
|
(var stride GLsizei (cast (* 5 (sizeof GLfloat)) GLsizei))
|
|
(glVertexAttribPointer 0 2 GL-FLOAT GL-FALSE stride (cast 0 (* void)))
|
|
(glEnableVertexAttribArray 0)
|
|
(glVertexAttribPointer 1 3 GL-FLOAT GL-FALSE stride
|
|
(cast (* 2 (sizeof GLfloat)) (* void)))
|
|
(glEnableVertexAttribArray 1)
|
|
|
|
(var u-center GLint (glGetUniformLocation program "u_center"))
|
|
(var u-viewport GLint (glGetUniformLocation program "u_viewport"))
|
|
(var u-angle GLint (glGetUniformLocation program "u_angle"))
|
|
(var u-radius GLint (glGetUniformLocation program "u_radius"))
|
|
|
|
(var running bool true)
|
|
(var angle float 0.0)
|
|
(var last-ticks Uint64 (SDL-GetTicks))
|
|
(var event SDL-Event)
|
|
|
|
(while running
|
|
(while (SDL-PollEvent (& event))
|
|
(switch (. event type)
|
|
(case SDL-EVENT-QUIT
|
|
(= running false))
|
|
(case SDL-EVENT-KEY-DOWN
|
|
(if (== (. event key key) SDLK-ESCAPE)
|
|
(= running false)))))
|
|
|
|
;; Seconds since the previous frame, so the spin rate does not
|
|
;; depend on how fast we happen to be rendering.
|
|
(var now Uint64 (SDL-GetTicks))
|
|
(var dt float (/ (cast (- now last-ticks) float) 1000.0))
|
|
(= last-ticks now)
|
|
|
|
(var mouse-x float 0.0)
|
|
(var mouse-y float 0.0)
|
|
(var buttons SDL-MouseButtonFlags (SDL-GetMouseState (& mouse-x) (& mouse-y)))
|
|
(if (!= 0 (& buttons SDL-BUTTON-LMASK))
|
|
(= angle (+ angle (* SPIN-SPEED dt))))
|
|
|
|
;; The viewport is in pixels, which is not the same as window units
|
|
;; on a HiDPI display; the mouse position is in window units, so the
|
|
;; shader needs that size rather than the pixel one.
|
|
(var pixel-width int 0)
|
|
(var pixel-height int 0)
|
|
(SDL-GetWindowSizeInPixels window (& pixel-width) (& pixel-height))
|
|
(glViewport 0 0 pixel-width pixel-height)
|
|
|
|
(var window-width int 0)
|
|
(var window-height int 0)
|
|
(SDL-GetWindowSize window (& window-width) (& window-height))
|
|
|
|
(glClearColor 0.06 0.06 0.09 1.0)
|
|
(glClear GL-COLOR-BUFFER-BIT)
|
|
|
|
(glUseProgram program)
|
|
(glUniform2f u-center mouse-x mouse-y)
|
|
(glUniform2f u-viewport (cast window-width float) (cast window-height float))
|
|
(glUniform1f u-angle angle)
|
|
(glUniform1f u-radius TRIANGLE-RADIUS)
|
|
|
|
(glBindVertexArray vao)
|
|
(glDrawArrays GL-TRIANGLES 0 3)
|
|
|
|
(SDL-GL-SwapWindow window))
|
|
|
|
(glDeleteVertexArrays 1 (& vao))
|
|
(glDeleteBuffers 1 (& vbo))
|
|
(glDeleteProgram program)
|
|
(SDL-GL-DestroyContext gl-context)
|
|
(SDL-DestroyWindow window)
|
|
(SDL-Quit)
|
|
(return 0))
|