// // Interface to all the OS functions. // #ifndef _OS_ #define _OS_ // ======================================================== // // WINDOWS AND MISCELLANEOUS STUFF // // ======================================================== // // The command line passed to the program. // extern CBYTE *OS_command_line; // // Outputs a debug string. // Returns the number of milliseconds since MAIN_main was called. It is very accurate. // Resets OS_ticks() // Returns the Mhz of the current processor. // void OS_string (CBYTE *fmt, ...); void OS_reset_ticks (void); SLONG OS_ticks (void); void OS_ticks_reset (void); SLONG OS_processor_mhz(void); // // In windowed mode it puts up an error message. In release build or // fullscreen mode, it return and does nothing. // void OS_error(CBYTE *fmt, ...); // // Returns TRUE if the given file has its archive bit set. Returns // FALSE if the file is not found. // SLONG OS_is_archive_bit_set(CBYTE *fname); void OS_clear_archive_bit (CBYTE *fname); // ======================================================== // // TEXTURE STUFF // // ======================================================== typedef struct os_texture OS_Texture; // // You can create a texture either from a TGA file or just by // specifying a size and format. If the file could not be loaded // then a blank texture is used instead. If you try and create // a texture from the same TGA file twice, the same pointer will // be returned both times. // // It looks for the file in the "Textures\" directory and then // in any directory its find in it's texture path. It loads // additional texture paths from the "data\texurepaths.txt" file // #define OS_TEXTURE_FORMAT_RGB 0 // RGB #define OS_TEXTURE_FORMAT_1555 1 // ARGB #define OS_TEXTURE_FORMAT_4444 2 // ARGB #define OS_TEXTURE_FORMAT_8 3 // Grayscale #define OS_TEXTURE_FORMAT_SCREEN 4 // The same format that the back buffer is in. #define OS_TEXTURE_FORMAT_NUMBER 5 #define OS_TEXTURE_MAX_SIZE 512 OS_Texture *OS_texture_create(CBYTE *fname, SLONG invert = FALSE); OS_Texture *OS_texture_create(SLONG width, SLONG height, SLONG format); // // Call this function once you have loaded all textures. It ensures that // as many of the textures as possible start off on the card instead of // only in the texture cache in system memory. // void OS_texture_finished_creating(void); // // Returns the size of the texture. // SLONG OS_texture_width (OS_Texture *ot); SLONG OS_texture_height(OS_Texture *ot); // // To updating a texture yourself, lock the texture and write // into the bitmap. When you unlock it, the new texture will // be blitted to the hardware. // // You're not allowed to READ from the texture! Only write. // // On success one of OS_bitmap_uword_screen or OS_bitmap_ubyte_screen will // point to the screen memory. // void OS_texture_lock (OS_Texture *ot); // OS_bitmap_screen == NULL => lock failed. void OS_texture_unlock(OS_Texture *ot); // // The bitmap returned by OS_texture_lock. To create a pixel, use the masks and // shifts like this: // // pixel = (r >> mask_r) << shift_r; // pixel |= (g >> mask_g) << shift_g; // pixel |= (b >> mask_b) << shift_b; // // Include alpha only if the original texture had alpha. // extern SLONG OS_bitmap_format; // OS_TEXTURE_FORMAT_* extern UWORD *OS_bitmap_uword_screen; // For 16-bit formats. extern SLONG OS_bitmap_uword_pitch; // Pitch in UWORDS extern UBYTE *OS_bitmap_ubyte_screen; // For the grayscale format. extern SLONG OS_bitmap_ubyte_pitch; // Pitch in UBYTES extern SLONG OS_bitmap_width; extern SLONG OS_bitmap_height; extern SLONG OS_bitmap_mask_r; extern SLONG OS_bitmap_mask_g; extern SLONG OS_bitmap_mask_b; extern SLONG OS_bitmap_mask_a; extern SLONG OS_bitmap_shift_r; extern SLONG OS_bitmap_shift_g; extern SLONG OS_bitmap_shift_b; extern SLONG OS_bitmap_shift_a; // // Writes a pixel to a 16-bit bitmap. // #define OS_BITMAP_UWORD_PIXEL(x,y) (OS_bitmap_uword_screen + (x) + (y) * OS_bitmap_uword_pitch) #define OS_BITMAP_UWORD_COLOUR(r,g,b) ((((r) >> OS_bitmap_mask_r) << OS_bitmap_shift_r) | (((g) >> OS_bitmap_mask_g) << OS_bitmap_shift_g) | (((b) >> OS_bitmap_mask_b) << OS_bitmap_shift_b)) #define OS_BITMAP_UWORD_PLOT(x,y,r,g,b) {*OS_BITMAP_UWORD_PIXEL(x,y) = OS_BITMAP_UWORD_COLOUR(r,g,b);} // // Write a pixel to an 8-bit bitmap // #define OS_BITMAP_UBYTE_PIXEL(x,y) (OS_bitmap_ubyte_screen + (x) + (y) * OS_bitmap_ubyte_pitch) #define OS_BITMAP_UBYTE_PLOT(x,y,c) {*OS_BITMAP_UBYTE_PIXEL(x,y) = (c);} // // Blitting a portion of the backbuffer onto the texture. // This will fail if the backbuffer and the texture are in // different formats. Returns TRUE on success. // // The (x,y) is the upper left hand corner of the texture and // the size of the region is given by the size of the texture. // // The texture can't be locked! // SLONG OS_texture_blit_from_backbuffer(OS_Texture *ot, SLONG x, SLONG y); // // Searches the "Textures\\" directory for the given file and returns // the fullpath name. Returns the address from inside the same static // array each time it is called. Returns NULL if it can't find the // file inside the "Textures\\" directory. // CBYTE *OS_texture_full_path(CBYTE *fname); // ======================================================== // // THE CAMERA // // ======================================================== // // Sets up the camera used to transform points added to the OS_Buffers. // void OS_camera_set( float world_x, float world_y, float world_z, float view_dist, float yaw, float pitch, float roll, float lens, float screen_x1 = 0.0F, float screen_y1 = 0.0F, float screen_x2 = 1.0F, float screen_y2 = 1.0F); void OS_camera_set( float world_x, float world_y, float world_z, float view_dist, float matrix[9], float lens, float screen_x1 = 0.0F, float screen_y1 = 0.0F, float screen_x2 = 1.0F, float screen_y2 = 1.0F); extern float OS_cam_x; // For reference only! Use the function above to set the camera extern float OS_cam_y; extern float OS_cam_z; extern float OS_cam_lens; extern float OS_cam_view_matrix [9]; extern float OS_cam_view_matrix_plus_local_rot[9]; // For when using OS_transform_local() // // The clipping flags. // #define OS_CLIP_TOP (1 << 0) #define OS_CLIP_BOTTOM (1 << 1) #define OS_CLIP_LEFT (1 << 2) #define OS_CLIP_RIGHT (1 << 3) #define OS_CLIP_FAR (1 << 4) #define OS_CLIP_NEAR (1 << 5) #define OS_CLIP_ROTATED (1 << 6) #define OS_CLIP_TRANSFORMED (1 << 7) #define OS_CLIP_OFFSCREEN (OS_CLIP_TOP|OS_CLIP_BOTTOM|OS_CLIP_LEFT|OS_CLIP_RIGHT) #define OS_ZCLIP_PLANE (128.0F / 65536.0F) // // Transformed points. // typedef struct { float x; float y; float z; float X; float Y; float Z; ULONG clip; } OS_Trans; #define OS_MAX_TRANS 16384 extern OS_Trans OS_trans[OS_MAX_TRANS]; extern SLONG OS_trans_upto; // // Transforming points. // void OS_transform( float world_x, float world_y, float world_z, OS_Trans *os); // // Sets the local position and orientation for OS_transform_local(). // void OS_local_position_and_rotation( float world_x, float world_y, float world_z, float local_rotation_matrix[9]); // // Transforms a point, but first puts it through the local rotation // and position given by OS_local_position_and_rotation(). // void OS_transform_local( float local_x, float local_y, float local_z, OS_Trans *os); // ======================================================== // // BUFFERS FOR COLLECTING TOGETHER POINTS AND TRIANGLES // // ======================================================== typedef struct os_buffer OS_Buffer; typedef struct { UWORD trans; // Index into the OS_trans array for the transformed point. UWORD index; // Before you add any OS_Verts to a buffer make sure they all have this field set to NULL float u1; float v1; float u2; // For multitexturing. float v2; ULONG colour; ULONG specular; } OS_Vert; // // The number of poly's drawn last frame. // extern SLONG OS_poly_count_transformed; extern SLONG OS_poly_count_drawn; // // Returns a new buffer to which you can add triangles. // OS_Buffer *OS_buffer_new(void); // // Adds a triangle to the buffer. The triangle is given by three vertices // into an OS_Vert array whose tlvert field is all set to zero. // void OS_buffer_add_triangle( OS_Buffer *ob, OS_Vert *ov1, OS_Vert *ov2, OS_Vert *ov3); // // Adds a 2D sprite to the buffer. // #define OS_FADE_TOP (1 << 0) #define OS_FADE_BOTTOM (1 << 1) #define OS_FADE_LEFT (1 << 2) #define OS_FADE_RIGHT (1 << 3) void OS_buffer_add_sprite( OS_Buffer *ob, float x1, // Normalised to 0.0F - 1.0F float y1, // Normalised to 0.0F - 1.0F float x2, // Normalised to 0.0F - 1.0F float y2, // Normalised to 0.0F - 1.0F float u1 = 0.0F, float v1 = 0.0F, float u2 = 1.0F, float v2 = 1.0F, float z = 0.0F, ULONG colour = 0xffffffff, ULONG specular = 0x00000000, ULONG fade = 0); void OS_buffer_add_multitex_sprite( OS_Buffer *ob, float x1, // Normalised to 0.0F - 1.0F float y1, // Normalised to 0.0F - 1.0F float x2, // Normalised to 0.0F - 1.0F float y2, // Normalised to 0.0F - 1.0F float u11 = 0.0F, float v11 = 0.0F, float u12 = 1.0F, float v12 = 1.0F, float u21 = 0.0F, float v21 = 0.0F, float u22 = 1.0F, float v22 = 1.0F, float z = 0.0F, ULONG colour = 0xffffffff, ULONG specular = 0x00000000, ULONG fade = 0); // // Adds a rotated 2D sprite to the buffer. // void OS_buffer_add_sprite_rot( OS_Buffer *ob, float x_mid, float y_mid, float radius, // As a percentage of the width of the screen. float angle, float u1 = 0.0F, float v1 = 0.0F, float u2 = 1.0F, float v2 = 1.0F, float z = 0.0F, ULONG colour = 0xffffffff, ULONG specular = 0x00000000, float tu1 = 0.0F, float tv1 = 0.0F, // For the second pass... float tu2 = 1.0F, float tv2 = 1.0F); // // Adds an arbitrary-shaped sprite to the buffer. The points are // given in this order. // // 0-------1 // / \ // 2-----------3 void OS_buffer_add_sprite_arbitrary( OS_Buffer *ob, float x1, // Normalised to 0.0F - 1.0F float y1, // Normalised to 0.0F - 1.0F float x2, // Normalised to 0.0F - 1.0F float y2, // Normalised to 0.0F - 1.0F float x3, // Normalised to 0.0F - 1.0F float y3, // Normalised to 0.0F - 1.0F float x4, // Normalised to 0.0F - 1.0F float y4, // Normalised to 0.0F - 1.0F float u1 = 0.0F, float v0 = 0.0F, float u2 = 1.0F, float v2 = 0.0F, float u3 = 0.0F, float v3 = 1.0F, float u4 = 1.0F, float v4 = 1.0F, float z = 0.0F, ULONG colour = 0xffffffff, ULONG specular = 0x00000000); void OS_buffer_add_sprite_arbitrary( OS_Buffer *ob, float x1, // Normalised to 0.0F - 1.0F float y1, // Normalised to 0.0F - 1.0F float x2, // Normalised to 0.0F - 1.0F float y2, // Normalised to 0.0F - 1.0F float x3, // Normalised to 0.0F - 1.0F float y3, // Normalised to 0.0F - 1.0F float x4, // Normalised to 0.0F - 1.0F float y4, // Normalised to 0.0F - 1.0F float u1 = 0.0F, float v0 = 0.0F, float u2 = 1.0F, float v2 = 0.0F, float u3 = 0.0F, float v3 = 1.0F, float u4 = 1.0F, float v4 = 1.0F, float z1 = 0.0F, float z2 = 0.0F, float z3 = 0.0F, float z4 = 0.0F, ULONG colour = 0xffffffff, ULONG specular = 0x00000000); // // Adds a line. // void OS_buffer_add_line_2d( OS_Buffer *ob, float x1, // Normalised to 0.0F - 1.0F float y1, // Normalised to 0.0F - 1.0F float x2, // Normalised to 0.0F - 1.0F float y2, // Normalised to 0.0F - 1.0F float width = 0.01F, // As a percentage of the width of the screen. float u1 = 0.0F, float v1 = 0.0F, float u2 = 1.0F, float v2 = 1.0F, float z = 0.0F, ULONG colour = 0xffffffff, ULONG specular = 0x00000000); void OS_buffer_add_line_3d( OS_Buffer *ob, float X1, // These are in REAL SCREEN COORDINATES! float Y1, // These are in REAL SCREEN COORDINATES! float X2, // These are in REAL SCREEN COORDINATES! float Y2, // These are in REAL SCREEN COORDINATES! float width = 0.01F, // As a percentage of the width of the screen. float u1 = 0.0F, float v1 = 0.0F, float u2 = 1.0F, float v2 = 1.0F, float z1 = 0.0F, float z2 = 0.0F, ULONG colour = 0xffffffff, ULONG specular = 0x00000000); // // Draws the buffer in the way defined by the OS_DRAW_* flags and the texture. After // drawing a buffer it becomes invalid. You can't add triangles to it anymore. // #define OS_DRAW_NORMAL 0 // Normal zbuffered gouraud textured triangle #define OS_DRAW_ADD (1 << 0) // Pixel = source + dest #define OS_DRAW_MULTIPLY (1 << 1) // Pixel = source * dest * 2 #define OS_DRAW_CLAMP (1 << 2) // No texture wrapping #define OS_DRAW_DECAL (1 << 3) // No gouraud #define OS_DRAW_TRANSPARENT (1 << 4) // Just the zbuffer written to (Pixel = dest) #define OS_DRAW_DOUBLESIDED (1 << 5) // Don't backface cull #define OS_DRAW_NOZWRITE (1 << 6) // Don't write to the zbuffer #define OS_DRAW_ALPHAREF (1 << 7) // Don't draw if alpha channel is zero #define OS_DRAW_ZREVERSE (1 << 8) // Reverses the order or the zbuffer #define OS_DRAW_ZALWAYS (1 << 9) // Never z-reject. #define OS_DRAW_CULLREVERSE (1 << 10) // Flip the direction of backface culling #define OS_DRAW_NODITHER (1 << 11) // Turn of gouraud-shade dithering #define OS_DRAW_ALPHABLEND (1 << 12) // Alphablending #define OS_DRAW_TEX_NONE (1 << 13) // No texture mapping #define OS_DRAW_TEX_MUL (1 << 14) // Two textures multiplied together #define OS_DRAW_NOFILTER (1 << 15) // No filtering #define OS_DRAW_MULBYONE (1 << 16) // Pixel = source * dest * 1 void OS_buffer_draw( OS_Buffer *ob, OS_Texture *ot1, // NULL => No texture mapping OS_Texture *ot2 = NULL, ULONG draw = OS_DRAW_NORMAL); // ======================================================== // // RENDER LOOP STUFF // // ======================================================== // // A couple of BOOLs to tell you how the screen is setup. // extern UBYTE OS_frame_is_fullscreen; extern UBYTE OS_frame_is_hardware; extern float OS_screen_width; extern float OS_screen_height; // // Clears the screen. // void OS_clear_screen( UBYTE r = 0, UBYTE g = 0, UBYTE b = 0, float z = 1.0F); // // Draws the FPS onto the screen. Call ONCE a frame! // void OS_fps_draw(void); SLONG OS_fps_get (void); // // Flips the screen. // void OS_show(void); // // Saves out a screenshot. If the filename is NULL then // it saves out shot.tga where n is the lowest available // number. // void OS_screenshot(CBYTE *fname = NULL); // ======================================================== // // MOUSE STUFF // // ======================================================== void OS_mouse_get(SLONG *x, SLONG *y); void OS_mouse_set(SLONG x, SLONG y); // ======================================================== // // SOUND STUFF // // ======================================================== // // A sound identifier, so you can change a sounds attributes. // typedef struct os_sound OS_Sound; // // Creates a new sound. // #define OS_SOUND_TYPE_UNUSED 0 #define OS_SOUND_TYPE_2D 1 #define OS_SOUND_TYPE_3D 2 OS_Sound *OS_sound_create(CBYTE *fname, SLONG type); // // Assumes the sound to be mono at 22050 samples per second. // OS_Sound *OS_sound_create(UWORD *data, SLONG num_samples, SLONG type); // // Plays a sound. If OS_SOUND_FLAG_LOOP then the sound will play until // it is stopped with OS_sound_stop(). // #define OS_SOUND_FLAG_INTERRUPT (1 << 0) // If this sample is already playing- it will start again. #define OS_SOUND_FLAG_LOOP (1 << 1) // Continue playing until OS_sound_stop() is called. void OS_sound_play(OS_Sound *sound, SLONG flag = 0); void OS_sound_stop(OS_Sound *sound); // // For 2D sounds. // void OS_sound_2d_set_volume(OS_Sound *sound, float volume); // volume is between 0.0F and 1.0F // // For 3D sounds. The new setting take effect from the next // time you call OS_process_messages(). // void OS_sound_3d_set_range (OS_Sound *sound, float min, float max); void OS_sound_3d_set_position( OS_Sound *sound, float x, float y, float z, float dx = 0.0F, float dy = 0.0F, float dz = 0.0F); // // Setup the listener for 3D sounds. // void OS_sound_listener_set( float x, float y, float z, float dx = 0.0F, float dy = 0.0F, float dz = 0.0F, float yaw = 0.0F, float pitch = 0.0F, float roll = 0.0F); // ======================================================== // // JOYSTICK INPUT // // ======================================================== // // These values are updated after each call to OS_process_messages() // extern float OS_joy_x; // -1.0F to +1.0F extern float OS_joy_y; // -1.0F to +1.0F extern ULONG OS_joy_button; // The buttons that are currently down extern ULONG OS_joy_button_down; // The buttons that have just been pressed extern ULONG OS_joy_button_up; // The buttons that have just been released #endif