home *** CD-ROM | disk | FTP | other *** search
/ Fujiology Archive / fujiology_archive_v1_0.iso / !FALCON / LINEOUT / OUT.ZIP / SOURCE.ZIP / FAQ.TXT < prev    next >
Text File  |  2002-04-02  |  8KB  |  206 lines
  1. Human Fly (UFly) 2.1 - questions and answers
  2.  
  3. ============================================================================
  4.  
  5. What is it?
  6.  
  7. A 3d rendering pipeline for modern atari tos computers.
  8.  
  9.  
  10. Where can I get it?
  11.  
  12. Well you got this file, so you got Human Fly too, right? =:P
  13.  
  14.  
  15. What are it's features?
  16.  
  17. - open source and interface for whatever special implementations you like
  18. - handles multi-transformations with matrices
  19. - dynamic viewport dimensions (outer and inner), focal-length, aspect ratio
  20. - spline based keyframer
  21. - primitive types:
  22.   - sprite (rle)
  23.   - line: flat, gouraud, phong
  24.   - polygon: flat, gouraud, phong, texturemap, envmap, alphatexture, bump
  25. - directly accessible primitive paint routs!
  26. - flexible object format:
  27.   - normal vectors
  28.   - texture vertices
  29.   - free choice of primitivetype and palette/texture/image per primitive
  30. - dynamic paintmodes:
  31.   - move, or, add, saturated add logic operations
  32.   - pixels can be bytes or words
  33.   - bytes to skip after each pixel
  34. - full clipping on all primitives
  35. - painters algo sorting
  36. - linear morphing
  37. - bounding boxes for efficient culling and background restoring
  38.  
  39.  
  40. What if I wanna use all this shit and I dunno about matrices or vector or..?
  41.  
  42. Oh boy! Well, you can always try one of the fine docs out there on the net
  43. about 3d basics. I know Denthor of Asphyxia (pc dude) made a good tutorial
  44. about these things. If you want a book, you can buy somekind of bible:
  45. 'Computer Graphics - principles and practice' by Foley and van Dam. You can
  46. come back after you glanced at this a few times.
  47.  
  48.  
  49. How does it work?
  50.  
  51. It is basicly an 68K assembler library. You include it in your favourite
  52. asm sourcecode and make some 3d animations with it. The Human Fly library
  53. is supplied as source and not as a binary.
  54. The way to work with Human Fly is not unlike OpenGL, but less flexible and
  55. less complicated. There are no windowing libs, no floating point routs, no
  56. nurbs shit, multi lights or teapots, no bullshit.
  57.  
  58.  
  59. What systems are currently supported?
  60.  
  61. Only the ataris with 020 or better I'm afraid. The current Human Fly
  62. implementations are video hardware independent. You can make them render
  63. bytes, words, etc to a block of memory of your choice. So it runs on Falcon,
  64. but also on TT (with c2p) or clones(!).
  65.  
  66.  
  67. What's this open source and interface stuff?
  68.  
  69. The hflycore.s file is basicly a header file or interface if you like for
  70. the whole pipeline. It has information on the functioning of all the routs.
  71. It contains equates and stuff every implementation of Human Fly should use.
  72. Everybody can make their own Human Fly implementation using this header
  73. file. If you want to make a VDI or a 3d accelerator specific version: please
  74. be my most honoured guest!
  75. At this moment version 2.1 knows two implementations:
  76.  - dsp falcon (fast, limited amount of objects)
  77.  - general cpu version (slow on standard falc, but can handle more objects!)
  78.  
  79.  
  80. Where to start?
  81.  
  82. It's best to start with some of the example source supplied with this
  83. package. Check out those fancy Human Fly calls and then take a hike over to
  84. hflycore.s to check out what they do.
  85.  
  86.  
  87. Yeah, and now in detail please!
  88.  
  89. The pipeline is alot like OpenGL and basicly you should work like this:
  90. 1) initialize viewport, initialize primitive painters, register objects
  91.    This is done only once.
  92. 2) set up transformation matrices and use them on objects to transform
  93. 3) tell the pipeline to do depthsorting, complete and then paint
  94.  
  95. 1)
  96. For a full complex scene you need alot of initialisation. A better idea is
  97. to start with the most simple situation like a only one flatshaded cube or
  98. pyramid. Even for this you to call the obligatory init calls. Registering
  99. palettes and objects, setting up your viewport and even setting the
  100. texturetable to a null are necessary. 
  101. Calls are as follows:
  102. - HumanFly.init
  103. - Viewport.update
  104. - Polygon.init
  105. - ObjectRegistry.clear
  106. - ObjectRegistry.set
  107.  
  108. 2)
  109. Also the most transformation calls are needed. Even if you only wanna
  110. display 1 stupid object in front of you. You need first to set up a rotation
  111. matrix by passing x,y,z rotation angles, all 0 in this case. Then you need
  112. to translate it a bit along the z axis, say (0,0,500). Then you need to
  113. call the transform rout with object handle and transformmode.
  114. - Matrix.generate
  115. - Matrix.translate
  116. - Matrix.push
  117. - TransformObject.transform
  118. - Matrix.pop
  119.  
  120. 3)
  121. For painting on screen you need to register the viewport buffer. Now you
  122. can restore the background and so on with some Human Fly calls as well.
  123. After that you can (if needed) depthsort the primitives. For one convex
  124. object like cubes, spheres or pyramids this is shit, but for everything else
  125. you should really use depthsort! Finally you can tell the pipeline to
  126. complete and paint.
  127. - Primitive.setScreenbuffer
  128. - PrimitiveMesh.new
  129. - PrimitiveMesh.sortZ
  130. - PrimitiveMesh.complete
  131. - (Viewport.paintRectangle)
  132. - PrimitiveMesh.paint
  133.  
  134.  
  135. How are the functions didived?
  136.  
  137. Human Fly is somewhat inspired by thinking in terms of objects. This means
  138. that the pipeline has a range of objects. Each of these objects has it's
  139. responsibilities. For instance: the Viewport object has control over the
  140. dimensions of the screenbuffer, the Matrix object has the responsibility to
  141. contain consecutive rotations and translations and so forth...
  142. In a rendering pipeline you can roughly divide functions up in two parts:
  143. - transformation (3d)
  144. - rendering (2d)
  145. And ofcourse you have the usual more global utility engine stuff.
  146. In Human Fly transformation covers the following objects: 
  147. - ObjectRegistry
  148. - Matrix
  149. - TransformObject
  150. And for rendering the following objects are used:
  151. - Primitive
  152. - Sprite
  153. - Line
  154. - Polygon
  155. - PrimitiveMesh
  156. - Viewport
  157. The more global objects are:
  158. - HumanFly
  159. - Keyframer
  160. - WorldTree
  161.  
  162.  
  163. How to build objects with moving parts?
  164.  
  165. Ah! This is where matrices come in. HumanFly handles a stack of these. This
  166. is needed for multi rotation/translation. For instance: you've got a world.
  167. In this world you got a car. A car has got wheels, doors, etc. All of these
  168. have their own rotation and possible translation. To transform a wheel you
  169. need need one rotation/translation. On top of that you need the car's
  170. rotation/translation. Finally you need the world rotation/translation.
  171. Multiply/add all these matrices toghether and you got yourself the final
  172. transformation matrix of the wheel.
  173. Human Fly handles this paradigm simple. These multiplies are implicit and
  174. handled within a stack structure. To handle the transformation of the wheel
  175. for instance you first calc and push the world matrix. Then you calc and
  176. push the car matrix. Finally you calc and push the wheel matrix. Now you
  177. perform a call to the transformobject.
  178. Inside the car you can easily transform other parts very easily. Now you
  179. just pop off one entry of the matrix stack, calc and push the door matrix,
  180. push it and then call transform.
  181. This is the most efficient and easy way to implement flexible world
  182. construction. Ofcourse this idea was ripped from OpenGL, what else?
  183.  
  184.  
  185. Can I just use HumanFly only to paint some 2d primitives?
  186.  
  187. The answer is yes. You can directly call any primitive routine by supplying
  188. it with a table of vertices. This way you can make your own 2d or 3d
  189. pipeline only using HumanFly's painting routines.
  190. There are both clipping as well as unclipping flavours. The first catagory
  191. is perfectly safe, but beware when using the second!!
  192.  
  193.  
  194. How to get alphablending?
  195.  
  196. Setting the paintmode is the answer. You need to divide your rendering in
  197. two stages. One is the foreground and the other is the alphalayer. For each
  198. stage you you set the paintmode anew.
  199. A (relatively) cheap way of getting alpha is to set both stages to bytes and
  200. 1 byte pixelskip. Stage 1 should have a byteoffset=0, stage 2 should have
  201. byteoffet=1. This way, when you have finished both you can read out pairs
  202. of bytes (words) and use them to index a big 256*256 word alphablending
  203. table!
  204.  
  205.  
  206.