home *** CD-ROM | disk | FTP | other *** search
/ Point Programming 1 / PPROG1.ISO / c / wgt35 / intro.doc < prev    next >
Encoding:
Text File  |  1993-01-28  |  7.8 KB  |  160 lines
  1.             WordUp Graphics Toolkit V3.5
  2.                 for Turbo C++ v.1.0 
  3.                Copyright 1993 Chris Egerter
  4.                    
  5.  
  6. The WordUp Graphics Toolkit is a large collection of functions for use
  7. in Turbo C++ programs which control many aspects of graphics programming.
  8. This library was created since there weren't any other libraries which
  9. suited our needs.  WGT provides enough graphics capabilities to satisfy
  10. the professional programmer, yet is easy enough for beginners.
  11. Because the library is quite large and contains many functions, we don't
  12. expect you to learn everything at once. If you get stuck, look through
  13. the example files for help, and don't give up! Anything is possible once
  14. you know how to use the WGT system.
  15.  
  16. WGT includes most of the usual functions found in the common graphics
  17. programming library such as lines, circles, bars, etc. However, many
  18. functions are much more complex, such as drop down menus, multidirectional
  19. scrolling, custom fonts, sprite movement and animation control, palette
  20. manipulation, special FX, a graphical file selector, and much more...
  21.  
  22.  
  23. Suggested Order of Learning Topics
  24. ----------------------------------
  25. Several example files (number WGTxx.c) should be compiled and studied
  26. in numerical order. This will help you understand many of the commands
  27. available.
  28.  
  29. Please try out each example program, and most importantly, EXPERIMENT!
  30. The best way to learn is to try things for yourself. If you just load in
  31. the example files and run them, you will not gain anything. If you
  32. happen to run into a problem, check the WGT documentation on the functions
  33. you are using, read the troubleshooting document, and if all else fails,
  34. mail WordUp Software Productions at the address on the order form.
  35. All of the libraries have been tested well, and the problem is most likely
  36. the way your compiler or linker is set up. However there may be a few bugs,
  37. and we'd like to hear about them.
  38.  
  39.  
  40. Graphics Programming: An Introduction
  41. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  42.     When programming in graphics mode, the screen is made up of
  43. many small dots. The WGT library uses a mode which has 320 dots across
  44. the screen, and 200 down. Each dot can change colours. There are 256
  45. different colours possible for each dot. When placed side by side
  46. in a rectanglar lattice pattern, the dots form more complex shapes.
  47. Each of these dots are called pixels. The 256 colours you can select
  48. from is called the palette.
  49.     Since the screen 320 by 200 pixels, there is a total of 64000
  50. (320 times 200) pixels on the screen at all times. Since there are 256
  51. possible colours, each pixel requires 1 byte of information
  52. (which ranges 0-255). Therefore a full screen to be saved requires 64000
  53. bytes of memory.
  54.     The palette is made of 256 containers ranging in number 0-255.
  55. Each of the 256 colours is made up of red, green, and blue values.
  56. For short, RGB means red,green, and blue. Imagine mixing colours of
  57. paint together using only the primary colours. From the RGB colours,
  58. you can make many other colours and shades. Each RGB value ranges 0-63.
  59. This is the standard for VGA cards. With 64 possible combinations for
  60. each of the RGB values, you have a possible 262144 (64*64*64)
  61. colour combinations!
  62.     So now you know that the screen is made of pixels which can be
  63. one of 256 colours. Obviously setting each one of these pixels to different
  64. colours to make a picture would be an enormous task if you had to set every
  65. pixel one at a time. The WGT library helps you out by giving you control
  66. of many commands which manipulate the pixels for you. For example, to draw
  67. a line, just call the line command, and tell it where the endpoints are.
  68. WGT will do all the calculations for you, and draw the line. When you
  69. call the line command, you need to tell where the line is on the screen.
  70. This is done by giving some coordinates. Each coordinate is made of two
  71. values: X and Y. X means how many pixels across the screen and Y is how
  72. many pixels down the screen, with 0 being the top left corner.
  73. Here is a simple diagram with a few coordinates to help you out:
  74.  
  75.      This is your monitor!
  76. ------------------------------------------
  77. |(0,0)                            (319,0)|
  78. |                                        | A line drawn a line from (100,40)
  79. |                  |                     | to (110,150), it would look like
  80. |                  |                     | this:
  81. |         .(50,50)  |                    |   |
  82. |                   | <-----------------------
  83. |                   |                    |
  84. |                    |                   |
  85. |                    |                   |
  86. |                                        |
  87. |(0,199)                        (319,199)|
  88. ------------------------------------------
  89.  
  90. The WGT library gets much more complex depending on which functions you
  91. use. It can control the palette, by fading in or out, or rotating it
  92. (color cycling). It also handles areas of the screen called blocks, which
  93. hold many pixels together and rectangular arrays. Blocks can be flipped,
  94. stretched, warped, resized, pasted on the screen, and many other operations.
  95.  
  96. This should be enough to get you started. Have fun and explore the
  97. possibilities of the WordUp Graphics Toolkit!
  98.  
  99.  
  100. How to link the example programs:
  101. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  102. WGT v3.5 contains many example programs which you can examine or
  103. change as you like.  To link an example program with the libraries
  104. needed, run the Turbo IDE. Change to the directory where all of
  105. the example C programs are. Next, open a project file. There should
  106. be some listed in the dialog. Click on the appropriate project file,
  107. and run the program. This is necessary because the Turbo C++ linker
  108. doesn't know what the WGT commands are, until you link in the WGT
  109. libraries. Take a look at the project window, as it will list the
  110. libraries and files you are currently linking together.
  111. The examples named WGTnn.c should be used with the wgtdemo project
  112. file.
  113.  
  114. Not all examples will work with the current setup in wgtdemo.prj.
  115. If the linker reports an undefined symbol, pick out which library is needed
  116. out of the list below, and add it to the list in the project window.
  117.  
  118. WGT35.LIB.......Main library (always link this)
  119. WSPR.LIB........Static background sprite library
  120. WGT4SCR.LIB.....Multidirectional scrolling library
  121. WGTMENU.LIB.....Custom drop down menu library
  122. WGTFLI.LIB......FLI library
  123. WGTJOY.LIB......Joystick routine library
  124. WGTSB.LIB.......SoundBlaster routine library
  125. FILESEL.LIB.....File selector routine
  126.  
  127.  
  128. Many of the example programs are not complete. They aren't meant as 
  129. games to play around with, but show how to use WGT. You may have more
  130. fun completing yourself, as you get to know the WGT system.
  131.  
  132.  
  133. Sprites: Why and When to use them:
  134. ----------------------------------
  135. The WordUp Graphics Toolkit contains a special sprite library.
  136. Sprites are basically animated moving objects on the screen. Sprites
  137. can be drawn with the WGT Sprite Creator, and loaded into your program
  138. with a few commands. Each sprite file created can hold up to 1000 sprites
  139. along with one palette. A block is an area of screen memory which can
  140. be stored and changed using different commands. When a sprite file is
  141. loaded, it simply places the sprites into an array of blocks.
  142. The array is always called 'sprites[1001]' and single sprites can be
  143. accessed by the array.
  144. WGT includes a library just for sprites which controls all animation and
  145. movement. This requires very little knowledge of the sprite array, however
  146. you can use the array yourself if you want to.
  147.  
  148. The library for sprites requires the background to remain relatively the
  149. same. Scrolling backgrounds involve the usage of a completely different
  150. system of moving images. Please read scroll.doc for more information regarding
  151. scrolling backgrounds. You must plan ahead, and use the appropriate system
  152. for your task.
  153.  
  154.  
  155.  
  156.  
  157.  
  158.  
  159.  
  160.