Exercises
Welcome to the Arcan Developer Exercises!
These are a series of exercises that intend to help you get perspective as to what Arcan can be used for and how to interpret documentation and debugging tools, how visualization problems can be broken down and approached, and as a means of incrementally get an idea of how the engine works internally.
The exercises have been grouped into three categories, based on their perceived difficulty (i.e. beginner, intermediate, advanced), with an additional 'low level' category for those that already are proficient but want to build more advanced systems or interoperate with the engine on lower levels.
Most exercises can be approached from two perspectives:
-
'Curious', developer that has a graphical application in mind.
-
'Engine Internals', developer that is interested in how the engine works.
For the curious developer, all you need is a working Arcan installation and a text-editor. For engine internals, being comfortable with C and associated developer tools is necessary. It might also be useful to have access to a minimalistic tracer, e.g. APITrace.
Each exercise has a section that is marked based on the intended perspective, and will hint at which calls are relevant, how to navigate the documentation and code and the surrounding tools.
Note that the exercises marked Low Level only target those interested in engine internals and lower system level work (e.g. how to interact with the engine by writing custom frameservers etc).
The sets are still woefully incomplete so a lot of pages are missing, as they are written during short downtime periods. Check the tests/exercises for cheating on solving the problems and for seeing how far the writing has come.
The first exercise set introduces you to loading and displaying images, text and single- coloured regions, along with first level debugging tools.
The second exercise set introduces you to transformation chains: scaling, rotation, blending and how they interact with interpolation.
Exercise 3: Getting Control and keeping Time
The third exercise set takes care of the necessary evil behind getting access to input devices and the timing sources available.
The fourth exercise set works through how video objects can be connected to each-other and which rules and caveats that apply.
The fifth exercise set goes into how objects can share backing store with each other as a means for saving memory and making drawing more cache friendly.
Exercise 6: Frame, Set and Match
The sixth exercise set extends on the sharing part with the idea of framesets, a way for extending a video object to contain other objects inside of it.
The seventh exercise set goes into some of the text rendering features.
Exercise 8: Who, What, Where and When
The eight exercise set goes into the art of object picking.
The ninth exercise set takes a first glance at GPU based post-processing via the use of shaders.
Exercise 1: Target for rendering
Now the gloves are coming off as the basics are in place. The first intermediate exercise set is that of rendertargets.
Exercise 2: 50 Shaders of Grey
The second exercise set extends the topic on shaders by looking at some engine built-in uniforms and how to define your own.
The third exercise is the first of several that looks into the important concept of frameservers.
Exercise 4: Sampling and Filtering
The fourth exercise set dives into image quality controls.
Exercise 5: Stacked, Know your Limits
The fifth exercise set is about the context stack, and how it relates to resource management.
Exercise 6: The third Dimensions
The sixth exercise set looks at the basic set of engine features that can be used for rendering 3D scenes.
Exercise 7: A record for future generations
The seventh exercise set returns to the frameserver concept and shows how recordtargets are used for reading back.
Exercise 8: Debugging tools and Crash Recovery
The eight exercise set digs into built-in scripts, engine features etc. useful to discover problems.
The first advanced exercise set looks into how frameserver connections are made, special controls and the difference between authoritative and non-authoritative connections.
The second exercise set looks how an odd but potent combination of engine features can be used to compare frameserver data against older iterations of itself.
The third exercise set expands on the frameserver idea, and covers how additional segments can be requested and (rejected or pushed) to an existing frameserver, and what this is used for.
The fourth exercise set covers frameserver state-management, what events to look out for and how state can be explicitly pushed between frameservers.
The fifth exercise set covers the special LWA (lightweight-) Arcan build where Arcan can be used as an application engine and as a display server.
The sixth exercise set digs into other special forms of rendertargets, such as calctargets and nulltargets.
Exercise 7: Display Management
The seventh exercise set covers low level display management controls.