1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
|
/* Copyright (C) 1994-2003 Revolution Software Ltd
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* $Header$
*/
//=============================================================================
//
// Filename : driver96.h
// Created : 6th August 1996
// By : P.R.Porter
//
// Summary : This include file defines all interfaces to the Revolution
// driver96 system. All game code which requires driver
// functions should simlply include this file.
//
// Version Date By Description
// ------- --------- --- -----------------------------------------------
// 1.0 12-Sep-96 PRP Initial drivers include file - with utypes.h!
//
// 1.1 17-Sep-96 PRP screenWide and screenDeep made available to the
// game engine.
//
// 1.2 18-Sep-96 PRP Mouse functions added. The _mouseEvent struct
// is made visible to the game engine, and the
// function prototype for getting a mouse event
// from the queue has been added. Also, filename
// in macro for driver error reporting is fixed.
//
// 1.3 19-Sep-96 PRP Interface to keyboard functions added. Also,
// removed references to bool which is not
// allowed by the cpp compiler.
//
// 1.4 19-Sep-96 PRP Fix definition of MouseEvent() and make the
// rderror variable static.
//
// 1.5 20-Sep-96 PRP Added interface to console functions.
//
// 1.6 23-Sep-96 PRP Removed console functions from drivers!
//
// 1.7 25-Sep-96 PRP Added interface to sprite drawing functions.
// RenderScreen changed so that the drawing offset
// is not passed in. This is now calculated from
// SetScrollTarget, and the number of frames we
// are going to render in the next game cycle.
//
// 1.8 26-Sep-96 PRP Moved the screen drawing and scrolling code
// to render.c for clarity. Changed the mouse
// coordinates to be relative to the top left
// corner of the game screen and removed the mouse
// position from the log.
//
// 1.9 09-Oct-96 PRP Defined SOFTWARE_SCREEN_BUFFER in here so that
// all of the drivers can use it, and the game
// engine will know what's going on!
//
// 1.10 28-Oct-96 PRP DrawSprite has changed. There are now flags to
// describe whether the sprite is compressed,
// transparent or displayed from the top left
// corner of the screen as opposed to the top left
// corner of the background.
//
// 1.11 29-Oct-96 PRP Naming of RDSPR_DISPLAYALIGN fixed in header!
//
// 1.12 01-Nov-96 PRP Added compression type, RDSPR_SPRITECOMPRESSION,
// and increased the size of the parameter passed
// to DrawSprite so up to eight compression types
// can be defined.
// Added functions to mouse.c for animating mouse
// pointers. Interface to functions put in here..
//
// 1.13 07-Nov-96 PRP Added RDERR_GOFULLSCREEN as a return error for
// creating the primary surface on a screen
// which is not in 8bpp mode. Also, made it so
// sprite drawing is passed a structure with
// all of the sprite parameters in, rather than
// the individual values passed.
// When setting up the screen display/resolution
// you should now specify whether you want the
// game to run in full screen mode or in a window.
//
// 1.14 15-Nov-96 PRP Added menubar code into drivers.
//
// 1.15 21-Nov-96 PRP Changed the interface to the DrawLine function.
//
// 1.16 25-Nov-96 PRP Added a function to set the Luggage animation.
//
// 1.17 25-Nov-96 PRP Added functions to palette.c which create
// match tables, and match rgb values to palette
// indeces - and new error messages
//
// 1.18 26-Nov-96 PRP Added error - RDERR_INVALIDSCALING which will
// be used when sprites are drawn with a scaling
// value outside of the range 0 .. s .. 512
//
// 1.19 29-Nov-96 PRP Added timing information to be referenced by
// the game engine. Also implemented palette
// fading with new functions added!
//
// 1.20 03-Dec-96 PRP Sound driver functions added. It is now
// possible to play speech.
//
// 1.21 05-Dec-96 PRP BS2_SetPalette changed so that the palette can
// be realized immediately or later when fading
// is called.
//
// 1.22 05-Dec-96 PRP Added sound driver functions for dealing with
// sound fx.
//
// 1.23 09-Dec-96 PRP Changed the UpdatePaletteMatchTable to take
// a pointer rather than a filename.
//
// 1.24 19-Dec-96 PRP Changed the sound system functions to add
// volume and pan position. Also, added a flag
// to the fx player for looping.
//
// 1.25 27-Jan-97 PRP Changed the call to render parallax, to define
// which layer is to be rendered. Also, added
// the RDBLTFX_ equates for how the rendering
// engine works. There are new functions to
// initialise and close the background layers
// which need to be called at the start and end
// of a room.
//
// 1.26 10-Feb-97 PRP Changed the direct draw error reporting calls,
// and added new return error codes.
//
// 1.27 11-Feb-97 PRP Added the blending value into the spriteInfo
// structure.
//
// 1.28 12-Feb-97 PRP Added set and clear blt effects functions.
//
// 1.29 06-Mar-97 PRP Added error return code RDERR_LOCKFAILED for
// failing to lock the front buffer when trying
// to write a screen shot. Also, added definition
// of _pcxHeader.
//
// 1.30 17-Mar-97 PRP Added RDFADE_BLACK as a return value for the
// GetPaletteStatus() function.
//
// 1.31 18-Mar-97 PRP Added InitialiseRenderCycle() to be called
// before the rendering loop is entered. This
// resets the timers.
//
// 1.32 20-Mar-97 PRP Added reference to ResetRenderEngine() to be
// called upon entry to the control panel.
//
// 1.33 24-Mar-97 PRP Added sprite drawing functions for hardware
// utilisation.
//
// 1.34 24-Mar-97 PRP Added return code RDERR_SURFACELOST
//
// 1.35 01-Apr-97 PRP Added new sprite type RDSPR_RLE256FAST
//
// 1.36 04-Apr-97 PRP Changed the prototype for InitialiseWindow.
//
// 1.37 07-Apr-97 PRP Added function prototypes and error values
// for the switching between the hardware and
// software renderers.
//
// 1.38 07-Apr-97 PRP Added function prototypes and error values
// for the shadow masking engine.
//
// 1.39 08-Apr-97 PRP Added reference to PlaySmacker()
//
// 1.40 09-Apr-97 PRP Added references to the functions which play music
// streaming it from the CD.
//
// 1.41 10-Apr-97 PRP Added defines for mouse flashing or not. Also
// changed function call to SetMouseAnim to
// include this parameter.
//
// 1.42 11-Apr-97 PRP EraseSoftwareScreenBuffer added.
//
// 1.43 11-Apr-97 JEL In render.c changed EraseSoftwareRenderBuffer to EraseSoftwareScreenBuffer
//
// 1.44 11-Apr-97 CJR Added palCopy definition for use in game engine.
//
// 1.45 22-Apr-97 PRP Added decompression error return value.
//
// 1.46 28-Apr-97 PSJ Added members to _wavHeader structure.
//
// 1.47 21-May-97 PRP Added the _movieTextObject data structure. This will
// be used in the call to PlaySmacker to define if there is any
// text to be displayed and when.
//
// 1.48 21-May-97 PRP Fixed the pointer to the text sprite within the movie
// text object structure.
//
// 1.49 22-May-97 JEL Fixed PlaySmacker for a movieTextObject parameter of NULL
//
// 1.50 29-May-97 PSJ Added the _drvStatus data structure. This will allow the
// state of all the drivers globals to be passed between dlls,
// exectuables and threads.
//
// 1.51 29-May-97 PSJ Added the _drvSoundStatus data structure and move _drvStatus to _drvDrawStatus.
// This will allow the state of the drivers drawing globals and audio globals to
// be passed between dlls, exectuables and threads.
// Also included ddraw.h dsound.h and mmsystem.h in this file.
//
// 1.52 29-May-97 PRP Added reference to the DisableQuitKey function,
// which removes the ability to press control-Q to quit
// the game.
//
// 1.53 04-Jun-97 PRP Changed the funtion call to PlaySmacker. Now includes
// a wav to lead out at the end of the smack file.
//
// 1.55 06-Jun-97 PSJ Added GetFxVolume and SetFxVolume for fx master volume control.
// Added GetSpeechVolume and SetSpeechVolume for speech master volume.
//
// 1.56 09-Jun-97 PSJ Added GetMusicVolume and SetMusicVolume.
//
// 1.57 10-Jun-97 PSJ Added MuteMusic, MuteFx, MuteSpeech, IsMusicMute, IsFxMute and Is SpeechMute
//
// 1.58 12-Jun-97 PSJ Added PlayCompSpeech to load and play a compressed wave.
//
// 1.59 12-Jun-97 PSJ Added GetRenderType to return the type of rendering
// currently being used.
//
// 1.60 13-Jun-97 PRP Added functions to set and clear shadow mask status.
//
// 1.61 26-Jun-97 PSJ Added AmISpeaking to check for lip syncing spots in the speech.
// Also added RDSE_QUIET and RDSE_SPEAKING as return values.
//
// 1.62 26-Jun-97 PSJ Added PauseSpeech and UnpauseSpeech.
//
// 1.63 26-Jun-97 PRP Added DimPalette.
//
// 1.64 27-Jun-97 PRP Moved definition of GrabScreenShot in from
// d_draw.h
//
// 1.65 15-Jul-97 PRP Added functions to pause and unpause speech.
//
// 1.66 16-Jul-97 PRP Added a speech pointer to the movieTextObject structure.
//
// 1.67 16-Jul-97 PSJ Added GetCompSpeechSize and PreFetchSpeech
//
// 1.68 21-Jul-97 PRP Added new FX type for sequence lead in and new function
// to pause sound effects apart from the lead in music.
//
// 1.73 22-Jul-97 PRP Added define to ensure DirectX 3.0 functionality used
// under DirectX 5.0 drivers :)
//
// 1.74 23-Jul-97 JEL Added CheckForMouseEvents() to return no. of events outstanding
//
// 1.75 30-Jul-97 PSJ Added MusicTimeRemaining() to return time left for current tune.
//
// 1.77 06-Aug-97 PSJ Updated Get and Set scroll SoundStatus.
//
// 1.78 07-Aug-97 PSJ Added SetWindowName to set the name of the window.
//
// 1.79 12-Aug-97 PSJ Added ReverseStereo.
//
// 1.80 13-Aug-97 PRP Added CloseMenuImmediately.
//
// 1.81 13-Aug-97 PSJ Added GetKeyStatus
//
// 1.82 13-Aug-97 PRP Added IsFxOpen.
//
// 1.83 15-Aug-97 PRP SetFxVolumePan added to update a sample on the fly.
//
// 1.84 15-Aug-97 PRP SetFxIdVolume added.
//
// 1.85 22-Aug-97 PSJ Added type RDSE_LEADOUT
//
// Functions
// ---------
//
// ---------------------------------------------------------------------------
// ------------------------------- d_draw.c ----------------------------------
// ---------------------------------------------------------------------------
//
// int32 InitialiseDisplay(int32 width, int32 height, int32 colourDepth, int32 windowType)
//
// Initialises the directDraw display with the sizes and colour depths passed
// in. The windowType is either RD_FULLSCREEN or RD_WINDOWED depending upon
// whether the app is to run in a window or not. If RD_WINDOWED is selected,
// the runction may returnRDERR_GOFULLSCREEN which implies that the window
// size and colour depth requested is not compatible with the current
// settings.
// If the required display cannot be set up, then an error code is
// returned, otherwise zero.
//
// ---------------------------------------------------------------------------
//
// int32 ResetDisplay(void)
//
// Closes down the directDraw sub-system and resets the display back to it's
// original size. Returns an RD code.
//
// ---------------------------------------------------------------------------
//
// int32 EraseBackBuffer(void)
//
// Fills the back buffer with palette colour zero. Returns an RD code.
//
// ---------------------------------------------------------------------------
//
// int32 WaitForVbl(void)
//
// This function returns when the video hardware is in vertical retrace.
//
// ---------------------------------------------------------------------------
//
// void InterpretDirectDrawError(int32 error)
//
// This function is passed the pointer to a direct draw error code, and
// translates this into a revolution driver error code. It also reports the
// error.
//
// ---------------------------------------------------------------------------
//
// int32 SetBltFx(void)
//
// Sets the edge blend and arithmetic stretching effects.
//
// ---------------------------------------------------------------------------
//
// int32 ClearBltFx(void)
//
// Clears the edge blend and arithmetic stretching effects.
//
// ---------------------------------------------------------------------------
//
// int32 RenderHard(void);
//
// Turns on the hardware renderer. Returns an error if the
// hardware is not capable of rendering.
//
// ---------------------------------------------------------------------------
//
// int32 RenderSoft(void);
//
// Turns on the software renderer. Returns an error if it
// is already on.
//
// ---------------------------------------------------------------------------
//
// int32 GetRenderType(void)
//
// Returns the type of rendering currently being used.
// 0 = H/W rendering, 1 = S/W Rendering + BltFxOFF, 2 = S/W Rendering + BltFxON
//
// ---------------------------------------------------------------------------
//
// int32 PlaySmacker(char *filename)
//
// Plays the smacker file, filename.
//
// ---------------------------------------------------------------------------
//
// void GetDrawStatus(_drvStatus *s)
//
// Retrieves the value of the driver's drawing globals and stores them in s.
//
// ---------------------------------------------------------------------------
//
// void SetDrawStatus(_drvStatus *s)
//
// Set the value of the driver's drawing globals from s.
//
// --------------------------- rdwin.c ---------------------------------------
// ---------------------------------------------------------------------------
//
// int32 InitialiseWindow(HWND hWnd)
//
// Creates a window! This must be the first operation in creating the
// Windows 95 version.
//
// ---------------------------------------------------------------------------
//
// int32 ServiceWindows(void)
//
// This function should be called at a high rate ( > 20 per second) to service
// windows and the interfaces it provides.
//
// ---------------------------------------------------------------------------
//
// int32 CloseAppWindow(void)
//
// Removes all windows hooks from the application.
//
// ---------------------------------------------------------------------------
//
// int32 ReportDriverError(int32 error)
//
// Creates a message box and displays the error code passed to it, as well as
// the filename and line that the function was called from
//
// ---------------------------------------------------------------------------
//
// int32 ReportFatalError(const uint8 *error)
//
// Creates a message box and displays the error string passed in, as well as
// the filename and line that the function was called from
//
// ---------------------------------------------------------------------------
//
// void SetWindowName(const char *windowName)
//
// Set the window name to windowName and stores this name in gameName for future
// use.
//
// ---------------------------------------------------------------------------
// --------------------------------- language.c ------------------------------
// ---------------------------------------------------------------------------
//
// int32 GetLanguageVersion(uint8 *version)
//
// This function modifies the 'version' passed in to be the current language.
// The first time this function is called, it gets the language from the
// version.inf file distributed on the game CD. It returns an RD error code
// if this file cannot be opened, or the version cannot be obtained from it.
//
// ---------------------------------------------------------------------------
//
// int32 SetLanguageVersion(uint8 version)
//
// This function is useful for debugging. It sets the version to the one
// passed in.
//
// ---------------------------------------------------------------------------
//
// int32 GetGameName(uint8 *name);
//
// Fills the string pointed to by name with the title of the game, depending
// upon what the current language version is.
//
// --------------------------------------------------------------------------
// ------------------------------- palette.c --------------------------------
// --------------------------------------------------------------------------
//
// void BS2_SetPalette(int32 startEntry, int32 noEntries, uint8 *colourTable, uint8 setNow)
//
// Sets the palette from position startEntry for noEntries, to the data
// pointed to by colourTable. To set the palette immediately pass
// RDPAL_INSTANT. If you want to fade later, pass RDPAL_FADE.
//
// --------------------------------------------------------------------------
//
// int32 UpdatePaletteMatchTable(uint8 *data)
//
// Uses the current palCopy to create a table of palette indeces which will
// be searched later for a quick palette match - only if NULL is passed in
// as the data. If a pointer to valid data is passed in, the palette match
// table is copied from that data.
//
// --------------------------------------------------------------------------
//
// uint8 QuickMatch(uint8 r, uint8 g, uint8 b)
//
// Returns the palette index of the closest matching colour in the palette
// to these RGB values.
//
// --------------------------------------------------------------------------
//
// int32 FadeUp(float time)
//
// Fades the palette up from black to the current palette in time.
//
// --------------------------------------------------------------------------
//
// int32 FadeDown(float time)
//
// Fades the palette down to black from the current palette in time.
//
// --------------------------------------------------------------------------
//
// uint8 GetFadeStatus(void)
//
// Returns the fade status which can be one of RDFADE_UP, RDFADE_DOWN or
// RDFADE_NONE.
//
//
// --------------------------------------------------------------------------
// -------------------------------- mouse.c ---------------------------------
// --------------------------------------------------------------------------
//
// _mouseEvent *MouseEvent(void)
//
// If there is a mouse event in the queue, a valid pointer is returned.
// Otherwise, NULL.
//
// --------------------------------------------------------------------------
//
// int32 SetMouseAnim(uint8 *ma, int32 size, int32 mouseFlash)
//
// A pointer to a valid mouse animation is passed in, along with the size of
// the header plus sprite data. Remember to check that the function has
// successfully completed, as memory allocation is required. When the mouse
// animation has been set, the mouse sprite does not need to be kept in the
// memory manager.
// Pass NULL in to clear the mouse sprite.
// mouseFlash should be either RDMOUSE_FLASH or RDMOUSE_NOFLASH
// defining whether to pulse the mouse or not.
//
// --------------------------------------------------------------------------
//
// int32 SetLuggageAnim(uint8 *la, int32 size)
//
// A pointer to a valid luggage animation is passed in, along with the size of
// the header plus sprite data. Remember to check that the function has
// successfully completed, as memory allocation is required.
// Pass NULL in to clear the luggage sprite. Luggage sprites are of the same
// format as mouse sprites.
//
// --------------------------------------------------------------------------
//
// int32 AnimateMouse(void)
//
// This function animates the current mouse pointer. If no pointer is
// currently defined, an error code is returned.
//
//
// --------------------------------------------------------------------------
// ------------------------------ keyboard.c --------------------------------
// --------------------------------------------------------------------------
//
// BOOL KeyWaiting(void)
//
// This function returns TRUE if there is an unprocessed key waiting in the
// queue, FALSE otherwise.
//
// --------------------------------------------------------------------------
//
// int32 ReadKey(char *key)
//
// Sets the value of key passed in to the current waiting key. If there is
// no key waiting, an error code is returned.
//
//
// --------------------------------------------------------------------------
//
// void GetKeyStatus(_drvKeyStatus *)
//
// Retrieves the address of the keyboard buffer bits.
//
// --------------------------------------------------------------------------
// ------------------------------- sprite.c ---------------------------------
// --------------------------------------------------------------------------
//
// int32 DrawSprite(_spriteInfo *s)
//
// Draws a sprite onto the screen of the type defined in the _spriteInfo
// structure. The _spriteInfo structure consists of the following elements:
//
// int16 x; // coords for top-left of sprite
// int16 y;
// uint16 w; // dimensions of sprite (before scaling)
// uint16 h;
// uint16 scale; // scale at which to draw, given in 256ths
// ['0' or '256' MEANS DON'T SCALE]
// uint16 scaledWidth; // new dimensions
// uint16 scaledHeight; //
// uint16 blend // blending value.
// uint16 type; // combination of the bits below
// uint8 *data; // pointer to the sprite data
// uint8 *colourTable; // pointer to 16-byte colour table - only
// applicable to 16-col compression type
//
// WARNING: Sprites will only be drawn onto the background. Sprites will not
// appear over the menubar areas. The mouse and menu drawing is treated
// as a special case.
//
// The type of the sprite can be any of the following:
//
// if (RDSPR_TRANS)
// The sprite has a transparent colour zero
// if (RDSPR_NOCOMPRESSION)
// The sprite data must not be compressed (slow to draw)
// The RDSPR_DISPLAYALIGN bit may be set to draw the sprite
// at coordinates relative to the top left corner of the
// monitor.
// else
// Compression must be set as one of the following:
// RDSPR_RLE16
// RDSPR_RLE256
// RDSPR_LAYERCOMPRESSION
// else
// The sprite has an opaque colour zero
// RDSPR_NOCOMPRESSION must be set!
// RDSPR_DISPLAYALIGN may be set to align the coordinates of the sprite
// to the top left corner of the monitor.
//
// ---------------------------------------------------------------------------
//
// int32 CreateSurface(_spriteInfo *s, uint32 *surface)
//
// Creates a sprite surface in video memory (if possible) and returns it's
// handle in surface.
//
// ---------------------------------------------------------------------------
//
// int32 DrawSurface(_spriteInfo *s, uint32 surface)
//
// Draws the sprite surface created earlier. If the surface has been lost,
// it is recreated.
//
// ---------------------------------------------------------------------------
//
// int32 DeleteSurface(uint32 surface)
//
// Deletes a surface from video memory.
//
// ---------------------------------------------------------------------------
//
// int32 OpenLightMask(_spriteInfo *s)
//
// Opens the light masking sprite for a room.
//
// ---------------------------------------------------------------------------
//
// int32 CloseLightMask(void)
//
// Closes the light masking sprite for a room.
//
// --------------------------------------------------------------------------
// ------------------------------- render.c ---------------------------------
// --------------------------------------------------------------------------
//
// int32 RenderParallax(_parallax *p)
//
// Draws a parallax layer at the current position determined by the scroll.
// A parallax can be either foreground, background or the main screen.
//
// ---------------------------------------------------------------------------
//
// int32 CopyScreenBuffer(void)
//
// Copies the screen buffer to screen memory. This function should be called
// when the drawing should be done to the back buffer. It only does this
// when we are using a software screen buffer.
//
// ---------------------------------------------------------------------------
//
// int32 SetScrollTarget(int16 sx, int16 sy)
//
// Sets the scroll target position for the end of the game cycle. The drivers
// will then automatically scroll as many times as it can to reach this
// position in the allotted time.
//
// --------------------------------------------------------------------------
//
// int32 InitialiseRenderCycle(void)
//
// Initialises the timers before the render loop is entered.
//
// --------------------------------------------------------------------------
//
// int32 StartRenderCycle(void)
//
// This function should be called when the game engine is ready to start
// the render cycle.
//
// --------------------------------------------------------------------------
//
// int32 EndRenderCycle(BOOL *end)
//
// This function should be called at the end of the render cycle. If the
// render cycle is to be terminated, the function sets *end to 1. Otherwise,
// the render cycle should continue.
//
// --------------------------------------------------------------------------
//
// int32 SetLocationMetrics(uint16 w, uint16 h)
//
// This function tells the drivers the size of the background screen for the
// current location.
//
// --------------------------------------------------------------------------
//
// int32 PlotPoint(uint16 x, uint16 y, uint8 colour)
//
// Plots the point x,y in relation to the top left corner of the background.
//
// --------------------------------------------------------------------------
//
// int32 DrawLine(int16 x1, int16 y1, int16 x2, int16 y2, uint8 colour)
//
// Draws a line from the point x1,y1 to x2,y2 of the specified colour.
//
// --------------------------------------------------------------------------
//
// int32 InitialiseBackgroundLayer(_parallax *p)
//
// This function should be called five times with either the parallax layer
// or a NULL pointer in order of background parallax to foreground parallax.
//
// --------------------------------------------------------------------------
//
// int32 CloseBackgroundLayer(void)
//
// Should be called once after leaving a room to free up video memory.
//
// --------------------------------------------------------------------------
//
// int32 PlotDots(int16 x, int16 y, int16 count)
//
// Plots 'count' dots at the position x,y.
//
// --------------------------------------------------------------------------
//
// int32 EraseSoftwareScreenBuffer(void)
//
// Clears the memory used for the software screen buffer. This should
// not be called every cycle because it takes time and is not necessary.
// However, it should be called between levels and such.
//
// --------------------------------------------------------------------------
// ---------------------------- menu.c --------------------------------------
// --------------------------------------------------------------------------
//
// int32 ProcessMenu(void)
//
// This function should be called regularly to process the menuber system.
// The rate at which this function is called will dictate how smooth the menu
// system is. The menu cannot be drawn at a higher rate than the system
// vbl rate.
//
// --------------------------------------------------------------------------
//
// int32 ShowMenu(uint8 menu)
//
// This function brings the menu in to view. The choice of top or bottom menu
// is defined by the parameter menu being either RDMENU_TOP or RDMENU_BOTTOM.
// An error code is returned if the menu is already shown.
//
// --------------------------------------------------------------------------
//
// int32 HideMenu(uint8 menu)
//
// This function hides the menu defined by the parameter menu. If the menu is
// already hidden, an error code is returned.
//
// --------------------------------------------------------------------------
//
// int32 SetMenuIcon(uint8 menu, uint8 pocket, uint8 *icon)
//
// This function sets a menubar icon to that passed in. If icon is NULL, the
// pocket is cleared, otherwise, that icon is placed into pocket. The menu is
// either RDMENU_TOP or RDMENU_BOTTOM. Valid error codes include
// RDERR_INVALIDPOCKET if the pocket number does not exist. Initially, there
// are 15 pockets.
//
// --------------------------------------------------------------------------
//
// uint8 GetMenuStatus(uint8 menu)
//
// This function returns the status of the menu passed in menu. Return values
// are RDMENU_OPENING, RDMENU_CLOSING, RDMENU_HIDDEN and RDMENU_SHOWN.
//
//
//
// --------------------------------------------------------------------------
// --------------------------- d_sound.c ------------------------------------
// --------------------------------------------------------------------------
//
// int32 InitialiseSound(uint16 freq, uint16 channels, uint16 bitDepth)
//
// This function initialises DirectSound by specifying the parameters of the
// primary buffer.
//
// Freq is the sample rate - 44100, 22050 or 11025
// Channels should be 1 for mono, 2 for stereo
// BitDepth should be either 8 or 16 bits per sample.
//
// --------------------------------------------------------------------------
//
// int32 PlaySpeech(uint8 *data, uint8 vol, int8 pan)
//
// This function plays the wav file passed into it as speech. An error occurs
// if speech is already playing, or directSound comes accross problems.
// volume can be from 0 to 16.
// pan can be from -16 (full left) to 16 (full right).
//
// --------------------------------------------------------------------------
//
// int32 PreFetchCompSpeech(const char *filename, uint32 speechid, uint8 *wave)
//
// This function loads and decompresses speech sample 'speechid' from the
// cluster 'filename' into 'wave'. 'wave' should contain the address of
// preallocated memory large enough for speech to fit into
// (see GetCompSpeechSize).
//
// --------------------------------------------------------------------------
//
// int32 GetCompSpeechSize(const char *filename, uint32 speechid);
//
// This function returns the size that speech sample 'speechid' from cluster
// 'filename' will be after it has been decompressed and had a wav header
// added. Returns 0 for any error.
//
// --------------------------------------------------------------------------
//
// int32 PlayCompSpeech(const char *filename, uint32 id, uint8 vol, int8 pan)
//
// This function loads, decompresses and plays the wav 'id' from the cluster
// 'filename'. An error occurs if speech is already playing, or directSound
// comes accross problems. 'volume' can be from 0 to 16. 'pan' can be from
// -16 (full left) to 16 (full right).
// id is the text line id used to reference the speech within the speech
// cluster.
//
// --------------------------------------------------------------------------
//
// int32 StopSpeechSword2(void)
//
// Stops the speech from playing.
//
// --------------------------------------------------------------------------
//
// int32 GetSpeechStatus(void)
//
// Returns either RDSE_SAMPLEPLAYING or RDSE_SAMPLEFINISHED
//
// --------------------------------------------------------------------------
//
// int32 AmISpeaking(void)
//
// Returns either RDSE_QUIET or RDSE_SPEAKING
//
// --------------------------------------------------------------------------
//
// int32 PauseSpeech(void)
//
// Stops the speech dead in it's tracks.
//
// --------------------------------------------------------------------------
//
// int32 UnpauseSpeech(void)
//
// Re-starts the speech from where it was stopped.
//
// --------------------------------------------------------------------------
//
// int32 OpenFx(int32 id, uint8 *data)
//
// This function opens a sound effect ready for playing. A unique id should
// be passed in so that each effect can be referenced individually.
//
// WARNING: Zero is not a valid ID.
//
// --------------------------------------------------------------------------
//
// int32 PlayFx(int32 id, uint8 *data, uint8 vol, int8 pan, uint8 type)
//
// This function plays a sound effect. If the effect has already been opened
// then *data should be NULL, and the sound effect will simply be obtained
// from the id passed in. If the effect has not been opened, then the wav
// data should be passed in data. The sound effect will be closed when it
// has finished playing.
// volume can be from 0 to 16.
// pan can be from -16 (full left) to 16 (full right).
// type is either RDSE_FXSPOT or RDSE_FXLOOP
//
// WARNING: Zero is not a valid ID
//
// --------------------------------------------------------------------------
//
// int32 CloseFx(int32 id)
//
// This function closes a sound effect which has been previously opened for
// playing. Sound effects must be closed when they are finished with,
// otherwise you will run out of sound effect buffers.
//
// --------------------------------------------------------------------------
//
// int32 ClearAllFx(void)
//
// This function clears all of the sound effects which are currently open or
// playing, irrespective of type.
//
// --------------------------------------------------------------------------
//
// int32 StreamMusic(uint8 *filename, int32 loopFlag)
//
// Streams music from the file defined by filename. The loopFlag should
// be set to RDSE_FXLOOP if the music is to loop back to the start.
// Otherwise, it should be RDSE_FXSPOT.
// The return value must be checked for any problems.
//
// --------------------------------------------------------------------------
//
// int32 StreamCompMusic(uint8 *filename, uint32 id, int32 loopFlag)
//
// Streams music 'id' from the cluster file 'filename'. The loopFlag should
// be set to RDSE_FXLOOP if the music is to loop back to the start.
// Otherwise, it should be RDSE_FXSPOT.
// The return value must be checked for any problems.
//
// StreamCompMusic should not be used inconjunction with StreamMusic.
//
// --------------------------------------------------------------------------
//
// void StopMusic(void)
//
// Fades out and stops the music.
//
// --------------------------------------------------------------------------
//
// int32 PauseMusic(void)
//
// Stops the music dead in it's tracks.
//
// --------------------------------------------------------------------------
//
// int32 UnpauseMusic(void)
//
// Re-starts the music from where it was stopped.
//
// ---------------------------------------------------------------------------
//
// void GetSoundStatus(_drvStatus *s)
//
// Retrieves the value of the driver's audio globals and stores them in s.
//
// ---------------------------------------------------------------------------
//
// void SetSoundStatus(_drvStatus *s)
//
// Set the value of the driver's audio globals from s.
//
// ---------------------------------------------------------------------------
//
// void SetMusicVolume(uint8 vol)
//
// Set the volume of any future as well as playing (but not fading) music to
// vol. vol is in the range of 0 to 16 with 0 being silent.
//
// ---------------------------------------------------------------------------
//
// uint8 GetMusicVolume(void)
//
// Returns the volume setting for music.
//
// ---------------------------------------------------------------------------
//
// void SetFxVolume(uint8 vol)
//
// Set the master volume of all fx' to vol. The fx' still have there own
// volume setting as well as the master volume. vol is in the range 0 to 14
// with 0 being silent.
//
// ---------------------------------------------------------------------------
//
// uint8 GetFxVolume(void)
//
// Returns the master volume setting for fx'.
//
// ---------------------------------------------------------------------------
//
// void SetSpeechVolume(uint8 vol)
//
// Set the volume of any future as well as playing speech samples to vol.
// vol is in the range of 0 to 14 with 0 being silent.
//
// ---------------------------------------------------------------------------
//
// uint8 GetSpeechVolume(void)
//
// Returns the volume setting for speech.
//
// ---------------------------------------------------------------------------
//
// void MuteMusic(uint8 mute)
//
// If mute is 0, the music volume is restored to the last set master level.
// otherwise the music is muted (volume 0).
//
// ---------------------------------------------------------------------------
//
// void MuteFx(uint8 mute)
//
// See MuteMusic(uint8).
//
// ---------------------------------------------------------------------------
//
// void MuteSpeech(uint8 mute)
//
// See MuteMusic(uint8).
//
// ---------------------------------------------------------------------------
//
// uint8 IsMusicMute(void)
//
// Returns the music's mute state, 1 if mute, 0 if not mute.
//
// ---------------------------------------------------------------------------
//
// uint8 IsFxMute(void)
//
// See IsMusicMute().
//
// ---------------------------------------------------------------------------
//
// uint8 IsMusicMute(void)
//
// See IsMusicMute().
//
// ---------------------------------------------------------------------------
//
// int32 MusicTimeRemaining(void)
//
// Returns the time left for the current tune.
//
// ---------------------------------------------------------------------------
//
// int32 ReverseStereo(void)
//
// Returns the time left for the current tune.
//
// ---------------------------------------------------------------------------
//
// int32 SetFxVolumePan(int32 id, uint8 vol, uint8 pan)
//
// Sets the volume and pan of the sample which is currently playing (id)
//
//=============================================================================
#ifndef DRIVER96_H
#define DRIVER96_H
//#define DIRECTDRAW_VERSION 0x0300
//#include <windows.h>
//#include <windowsx.h>
#include <limits.h>
//#include <mmsystem.h>
#include <stdio.h>
#include <string.h>
#include "common/scummsys.h"
#include "common/engine.h" // for warning()
#include "common/system.h"
#include "common/rect.h"
//#include "ddraw.h"
//#include "dsound.h"
#ifdef __cplusplus
extern "C" {
#endif
//
// Defines
// -------
//
// defines specific to windows headers...
#ifndef WIN32
#define SEM_FAILCRITICALERRORS 1
#define FILE_ATTRIBUTE_NORMAL 0x80
#define _MAX_PATH 260
#endif
//Generic error codes
#define RD_OK 0x00000000
#define RDERR_UNKNOWN 0x00000001
#define RDERR_INVALIDPOINTER 0x00000002
#define RDERR_OUTOFMEMORY 0x00000003
#define RDERR_INVALIDFILENAME 0x00000004
#define RDERR_READERROR 0x00000005
#define RDERR_WRITEERROR 0x00000006
#define RDERR_NOEMULATION 0x00000007
#define RDERR_LOCKFAILED 0x00000008
//Drawing error codes
#define RDERR_VIDEOMODE 0x00010000
#define RDERR_COLOURDEPTH 0x00010001
#define RDERR_CANNOTFLIP 0x00010002
#define RDERR_RESTORELAYERS 0x00010003
#define RDERR_DDRAWNOEMULATION 0X00010004
#define RDERR_NOHARDWARE 0x00010005
#define RDERR_ALREADYON 0x00010006
#define RDERR_DECOMPRESSION 0x00010007
//Operating system error codes
#define RDERR_CREATEWINDOW 0x00020000
#define RDERR_APPCLOSED 0x00020001
#define RDERR_GOFULLSCREEN 0x00020002
//Language and version error codes
#define RDERR_OPENVERSIONFILE 0x00030000
#define RDERR_INVALIDVERSION 0x00030001
//Keyboard error codes
#define RDERR_NOKEYWAITING 0x00040000
//Sprite drawing error codes
#define RDERR_NOCLIPPING 0x00050000
#define RDERR_NOTIMPLEMENTED 0x00050001
#define RDERR_UNKNOWNTYPE 0x00050002
#define RDERR_INVALIDSCALING 0x00050003
#define RDERR_SURFACELOST 0x00050004
#define RDERR_NOTCLOSED 0x00050005
#define RDERR_NOTOPEN 0x00050006
#define RDERR_ALREADYCLOSED 0x00050007 // added for _console.cpp by khalek
//Menubar error codes
#define RDERR_INVALIDMENU 0x00060000
#define RDERR_INVALIDPOCKET 0x00060001
#define RDERR_INVALIDCOMMAND 0x00060002
//Palette fading error codes
#define RDERR_FADEINCOMPLETE 0x00070000
//Sound engine error codes
#define RDERR_DSOUNDCREATE 0x00080000
#define RDERR_DSOUNDCOOPERATE 0x00080001
#define RDERR_DSOUNDPBUFFER 0x00080002
#define RDERR_PRIMARYFORMAT 0x00080003
#define RDERR_SPEECHPLAYING 0x00080004
#define RDERR_SPEECHNOTPLAYING 0x00080005
#define RDERR_INVALIDWAV 0x00080006
#define RDERR_CREATESOUNDBUFFER 0x00080007
#define RDERR_LOCKSPEECHBUFFER 0x00080008
#define RDERR_FXALREADYOPEN 0x00080009
#define RDERR_NOFREEBUFFERS 0x0008000A
#define RDERR_FXNOTOPEN 0x0008000B
#define RDERR_FXFUCKED 0x0008000C
#define RDERR_INVALIDID 0x0008000D
// Language codes
#define ENGLISH 0x00
#define AMERICAN 0x01
#define GERMAN 0x02
#define FRENCH 0x03
#define SPANISH 0x04
#define ITIALIAN 0x05
#define JAPANESE 0x06
#define SLOVAK 0x07
// Key codes
#define RDKEY_ESCAPE 27
// Mouse button defines
#define RD_LEFTBUTTONDOWN 0x01
#define RD_LEFTBUTTONUP 0x02
#define RD_RIGHTBUTTONDOWN 0x04
#define RD_RIGHTBUTTONUP 0x08
//Sprite defines
#define RDSPR_TRANS 0x0001
#define RDSPR_BLEND 0x0004
#define RDSPR_FLIP 0x0008
#define RDSPR_SHADOW 0x0010
#define RDSPR_DISPLAYALIGN 0x0020
#define RDSPR_NOCOMPRESSION 0x0040
#define RDSPR_EDGEBLEND 0x0080
//This is the high byte part of the sprite type which defines what type of
// compression is used, as long as RDSPR_NOCOMPRESSION is not defined.
#define RDSPR_RLE16 0x0000
#define RDSPR_RLE256 0x0100
#define RDSPR_RLE256FAST 0x0200
//Rendering defines
#define RD_SOFTWARESCREENBUFFER 0x01
//Windows defines
#define RD_FULLSCREEN 0x01000000
#define RD_WINDOWED 0x01000001
//Fading defines
#define RDFADE_NONE 0x00
#define RDFADE_UP 0x01
#define RDFADE_DOWN 0x02
#define RDFADE_BLACK 0x03
//Mouse defines
#define RDMOUSE_NOFLASH 0x00
#define RDMOUSE_FLASH 0x01
//Menubar defines.
#define RDMENU_TOP 0x00
#define RDMENU_BOTTOM 0x01
#define RDMENU_HIDDEN 0x00
#define RDMENU_SHOWN 0x01
#define RDMENU_OPENING 0x02
#define RDMENU_CLOSING 0x03
#define RDMENU_ICONWIDE 35
#define RDMENU_ICONDEEP 30
#define RDMENU_ICONSTART 24
#define RDMENU_ICONSPACING 5
#define RDMENU_MAXPOCKETS 15
#define RDMENU_MENUDEEP 40
#define RDSE_SAMPLEFINISHED 0
#define RDSE_SAMPLEPLAYING 1
#define RDSE_FXTOCLEAR 0
#define RDSE_FXCACHED 1
#define RDSE_FXSPOT 0
#define RDSE_FXLOOP 1
#define RDSE_FXLEADIN 2
#define RDSE_FXLEADOUT 3
#define RDSE_QUIET 1
#define RDSE_SPEAKING 0
#define RDPAL_FADE 0
#define RDPAL_INSTANT 1
//Blitting FX defines
#define RDBLTFX_MOUSEBLT 0x01
#define RDBLTFX_FGPARALLAX 0x02
#define RDBLTFX_ARITHMETICSTRETCH 0x04
#define RDBLTFX_EDGEBLEND 0x08
#define RDBLTFX_SHADOWBLEND 0x10
#define RDBLTFX_FLATALPHA 0x20
#define RDBLTFX_GRADEDALPHA 0x40
#define RDBLTFX_ALLHARDWARE 0x80
// Max number of sound fx
#define MAXFX 16
#define MAXMUS 2
// Key buffer size
#define MAX_KEY_BUFFER 32
typedef int BOOL;
#define TRUE 1
#define FALSE 0
// Surface class to help replace LPDIRECTDRAWSURFACE.
//
// This class should be used as little as possible since it introduces an
// extra layer of data copying. It should only be used where we decode
// something once and draw it many times, such as the parallax layers.
//
// Even then it's only necessary if we also need to keep track of the
// surface's dimensions.
//
// Since the building blocks of the parallax layers have constant size,
// expect this class to go away.
class Surface {
public:
uint16 _width, _height;
uint16 _pitch;
byte *_pixels;
Surface(uint width, uint height) {
_width = width;
_height = height;
_pixels = (byte *) calloc(_width, _height);
}
void clear();
void blit(Surface *s, ScummVM::Rect *r);
void blit(Surface *s, ScummVM::Rect *r, ScummVM::Rect *clip_rect);
~Surface() {
free(_pixels);
}
};
//
// Structure definitions
// ---------------------
//
typedef struct
{
uint16 buttons;
} _mouseEvent;
typedef struct
{
uint16 w;
uint16 h;
uint32 offset[2]; // 2 is arbitrary
} _parallax;
// The _spriteInfo structure is used to tell the driver96 code what attributes
// are linked to a sprite for drawing. These include position, scaling and
// compression.
typedef struct
{
int16 x; // coords for top-left of sprite
int16 y;
uint16 w; // dimensions of sprite (before scaling)
uint16 h;
uint16 scale; // scale at which to draw, given in 256ths ['0' or '256' MEANS DON'T SCALE]
uint16 scaledWidth; // new dimensions (we calc these for the mouse area, so may as well pass to you to save time)
uint16 scaledHeight; //
uint16 type; // mask containing 'RDSPR_' bits specifying compression type, flip, transparency, etc
uint16 blend; // holds the blending values.
uint8 *data; // pointer to the sprite data
uint8 *colourTable; // pointer to 16-byte colour table, only applicable to 16-col compression type
} _spriteInfo;
// This is the format of a .WAV file. Somewhere after this header is the string
// 'DATA' followed by an int32 size which is the size of the data. Following
// the size of the data is the data itself.
typedef struct
{
char riff[4];
uint32 fileLength;
char wavID[4];
char format[4];
uint32 formatLen;
uint16 formatTag;
uint16 channels;
uint16 samplesPerSec;
uint16 avgBytesPerSec;
uint16 blockAlign;
uint16 unknown1;
uint16 unknown2;
uint16 bitsPerSample;
} _wavHeader;
// This is the structure which is passed to the sequence player.
// It includes the smack to play, and any text lines which are
// to be displayed over the top of the sequence.
typedef struct
{
uint16 startFrame;
uint16 endFrame;
_spriteInfo *textSprite;
_wavHeader *speech;
} _movieTextObject;
typedef struct
{ uint8 manufacturer;
uint8 version;
uint8 encoding;
uint8 bitsPerPixel;
int16 xmin,ymin;
int16 xmax,ymax;
int16 hres;
int16 vres;
char palette[48];
char reserved;
uint8 colourPlanes;
int16 bytesPerLine;
int16 paletteType;
char filler[58];
} _pcxHeader;
// This is the structure which is used to set and
// retrieve the direct draw drivers global variables.
typedef struct
{
// HWND hwnd;
// LPDIRECTDRAW lpDraw;
// LPDIRECTDRAW2 lpDD2;
// Surface *lpPrimarySurface;
Surface *lpBackBuffer;
// LPDIRECTDRAWPALETTE lpPalette;
int16 screenDeep;
int16 screenWide;
int16 scrollx;
int16 scrolly;
int16 scrollxTarget;
int16 scrollyTarget;
int16 scrollxOld;
int16 scrollyOld;
int16 failCount;
int32 renderCaps;
int32 dxHalCaps;
int32 dxHelCaps;
BOOL noVbl;
BOOL bFullScreen;
// DDCAPS driverCaps;
// DDCOLORKEY blackColorKey;
} _drvDrawStatus;
// This is the structure which is used to set and
// retrieve the direct sound drivers global variables.
typedef struct
{
// HWND hwnd;
// LPDIRECTSOUND lpDS;
// LPDIRECTSOUNDBUFFER dsbPrimary;
// LPDIRECTSOUNDBUFFER dsbSpeech;
// LPDIRECTSOUNDBUFFER dsbFx[MAXFX];
int32 fxId[MAXFX];
uint8 fxCached[MAXFX];
uint8 soundOn;
uint8 speechStatus;
uint8 fxPaused;
char musFilename[MAXMUS][256];
uint8 speechPaused;
uint8 speechVol;
uint8 fxVol;
uint8 speechMuted;
uint8 fxMuted;
uint8 musicMuted;
uint8 compressedMusic;
uint8 fxiPaused[MAXFX];
uint8 fxLooped[MAXFX];
int16 musStreaming[MAXMUS];
int16 musicPaused[MAXMUS];
int16 musCounter[MAXMUS];
int16 musFading[MAXMUS];
int16 musLooping[MAXMUS];
int16 musLastSample[MAXMUS];
int32 streamCursor[MAXMUS];
int32 musFilePos[MAXMUS];
int32 musEnd[MAXMUS];
uint32 musId[MAXMUS];
// DSBUFFERDESC dsbdMus[MAXMUS];
// LPDIRECTSOUNDBUFFER lpDsbMus[MAXMUS];
FILE *fpMus[MAXMUS];
// PCMWAVEFORMAT wfMus[MAXMUS];
uint32 volMusic[2];
} _drvSoundStatus;
// This is the structure which is used to retrieve
// the keyboard driver bits.
typedef struct
{
uint8 *pBacklog;
uint8 *pPointer;
char *pBuffer;
} _drvKeyStatus;
// should probably remove this struct as it just replaces a windows struct...
typedef struct {
uint32 dwLength;
uint32 dwMemoryLoad;
uint32 dwTotalPhys;
uint32 dwAvailPhys;
uint32 dwTotalPageFile;
uint32 dwAvailPageFile;
uint32 dwTotalVirtual;
uint32 dwAvailVirtual;
} GCC_PACK SVM_MEMORYSTATUS;
//
// Function Prototypes
// -------------------
//
//-----------------------------------------------------------------------------
// Display functions - from d_draw.c
//-----------------------------------------------------------------------------
extern int32 InitialiseDisplay(int16 width, int16 height, int16 colourDepth, int32 windowType);
extern int32 WaitForVbl(void);
extern int32 EraseBackBuffer(void);
extern void SetTransFx(void);
extern void ClearTransFx(void);
extern void SetBltFx(void);
extern void ClearBltFx(void);
extern void ClearShadowFx(void);
extern void SetShadowFx(void);
extern int32 GetRenderType(void);
extern int32 PlaySmacker(char *filename, _movieTextObject *textObjects[], uint8 *musicOut);
extern void GetDrawStatus(_drvDrawStatus *s);
extern void SetDrawStatus(_drvDrawStatus *s);
extern int32 GrabScreenShot(void);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Windows OS functions - from rdwin.c
//-----------------------------------------------------------------------------
//extern int32 InitialiseWindow(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow, char *gameName);
extern int32 CloseAppWindow(void);
extern int32 ServiceWindows(void);
extern int32 _ReportDriverError(int32 error, const uint8 *filename, uint32 line);
extern int32 _ReportFatalError(const uint8 *error, const uint8 *filename, uint32 line);
extern int32 DisableQuitKey(void);
extern void SetWindowName(const char *windowName);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Language functions - from language.c
//-----------------------------------------------------------------------------
extern int32 GetLanguageVersion(uint8 *version);
extern int32 SetLanguageVersion(uint8 version);
extern int32 GetGameName(uint8 *name);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Palette functions - from palette.c
//-----------------------------------------------------------------------------
extern int32 BS2_SetPalette(int16 startEntry, int16 noEntries, uint8 *palette, uint8 setNow);
extern int32 UpdatePaletteMatchTable(uint8 *data);
extern uint8 QuickMatch(uint8 r, uint8 g, uint8 b);
extern int32 FadeUp(float time);
extern int32 FadeDown(float time);
extern uint8 GetFadeStatus(void);
extern int32 DimPalette(void);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Mouse functions - from mouse.c
//-----------------------------------------------------------------------------
extern _mouseEvent *MouseEvent(void);
extern int32 SetMouseAnim(uint8 *ma, int32 size, int32 mouseFlash);
extern int32 SetLuggageAnim(uint8 *la, int32 size);
extern int32 AnimateMouse(void);
uint8 CheckForMouseEvents(void); // (James23july97)
extern void ResetRenderEngine(void);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Keyboard functions - from keyboard.c
//-----------------------------------------------------------------------------
extern BOOL KeyWaiting(void);
extern int32 ReadKey(char *key);
extern void GetKeyStatus(_drvKeyStatus *s);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Sprite functions - from sprite.c
//-----------------------------------------------------------------------------
extern int32 DrawSprite(_spriteInfo *s);
extern int32 CreateSurface(_spriteInfo *s, uint8 **surface);
extern int32 DrawSurface(_spriteInfo *s, uint8 *surface);
extern int32 DeleteSurface(uint8 *surface);
extern int32 OpenLightMask(_spriteInfo *s);
extern int32 CloseLightMask(void);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Screen drawing and scrolling function - from render.c
//-----------------------------------------------------------------------------
extern int32 SetScrollTarget(int16 sx, int16 sy);
extern int32 InitialiseRenderCycle(void);
extern int32 StartRenderCycle(void);
extern int32 EndRenderCycle(BOOL *end);
extern int32 RenderParallax(_parallax *p, int16 layer);
extern int32 SetLocationMetrics(uint16 w, uint16 h);
extern int32 CopyScreenBuffer(void);
extern int32 PlotPoint(uint16 x, uint16 y, uint8 colour);
extern int32 DrawLine(int16 x1, int16 y1, int16 x2, int16 y2, uint8 colour);
extern int32 InitialiseBackgroundLayer(_parallax *p);
extern int32 CloseBackgroundLayer(void);
extern int32 PlotDots(int16 x, int16 y, int16 count);
extern int32 EraseSoftwareScreenBuffer(void);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Menubar control and drawing functions - from menu.c
//-----------------------------------------------------------------------------
extern int32 ProcessMenu(void);
extern int32 ShowMenu(uint8 menu);
extern int32 HideMenu(uint8 menu);
extern int32 SetMenuIcon(uint8 menu, uint8 pocket, uint8 *icon);
extern uint8 GetMenuStatus(uint8 menu);
extern int32 CloseMenuImmediately(void);
//-----------------------------------------------------------------------------
// Misc functions - from misc.cpp
//-----------------------------------------------------------------------------
extern uint32 SVM_timeGetTime(void);
extern void SVM_VirtualUnlock(uint8 *free_memman, uint32 total_free_memory);
extern void SVM_GlobalMemoryStatus(SVM_MEMORYSTATUS *memo);
extern void SVM_SetFileAttributes(char *file, uint32 atrib);
extern void SVM_DeleteFile(char *file);
extern void SVM_GetCurrentDirectory(uint32 max, char* path);
extern int32 SVM_GetVolumeInformation(char *cdPath, char *sCDName, uint32 maxPath, uint8 *, uint32 *dwMaxCompLength, uint32 *dwFSFlags, uint8 *, uint32 a);
extern void scumm_mkdir(const char *pathname);
extern void SVM_GetModuleFileName(void *module, char *destStr, uint32 maxLen);
//-----------------------------------------------------------------------------
//Macro for calling error handler with source filename and line.
//-----------------------------------------------------------------------------
#define ReportDriverError(f) _ReportDriverError(f, (const uint8 *) __FILE__, (uint32) __LINE__)
#define ReportFatalError(f) _ReportFatalError(f, (const uint8 *) __FILE__, (uint32) __LINE__)
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Macro for reporting a non-fatal driver error
//-----------------------------------------------------------------------------
#ifdef _SWORD2_DEBUG
static int32 rderror;
#define Driver(f) \
if (rderror = f) \
ReportDriverError(rderror)
#else
#define Driver(f) f
#endif
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
extern BOOL gotTheFocus; // set if the game is currently displayed
extern int16 screenWide; // Width of the screen display
extern int16 screenDeep; // Height of the screen display
extern int16 mousex; // Mouse screen x coordinate
extern int16 mousey; // Mouse screen y coordinate
extern int32 renderCaps; // Flags which determine how to render the scene.
extern uint8 palCopy[256][4]; // Current palette.
//-----------------------------------------------------------------------------
extern long int myTimers[10][2];
#ifdef __cplusplus
}
#endif
#endif
|