jetomit/avp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Initial revision

Browse source
This commit is contained in:
Steven Fuller 2001-07-01 00:55:22 +00:00 • committed by Patryk Obara
parent 218ca90543
commit 2186d5f3f9
572 changed files with 2 additions and 29666 deletions
Download patch file Download diff file Expand all files Collapse all files

262
3dc/AvP_Alien_Readme.txt
View file

@ -1,262 +0,0 @@
***********************************************************************
ALIENS VERSUS PREDATOR
Alien Demo
Version 1.2
Readme File
Jan 20th 1999
***********************************************************************
CONTENTS
***********************************************************************
1. MINIMUM REQUIREMENTS
2. DEMO OBJECTIVES
3. INSTALLATION
4. GAME CONTROLS
5. ALIEN ABILITIES
6. ALIEN WEAPONS
7. CONTACT & LEGAL INFORMATION
***********************************************************************
1. MINIMUM REQUIREMENTS
***********************************************************************
Intel Pentium 200 MMX PC (or 100% compatible CPU)
DirectX supported 3D Accelerator Card
DirectX v.6 (Included on Installation CD)
32Mb RAM (64Mb recommended)
64Mb free Hard Drive
Windows 95
The ALIENS VERSUS PREDATOR Demo is a work in-progress. Thus it is not
fully optimized and configured for lower spec machines. These issues
will be corrected for the full retail version, giving the end user
control over engine and special effect variables ensuring smooth
gameplay over a wide variety of CPUs, accelerator cards and RAM.
Due to the complexity of the ALIENS VERSUS PREDATOR models, users with
32Mb of RAM may experience some memory paging, especially when exiting
the game and returning to Windows. These problems will be fixed for the
release version of the game.
KNOWN ISSUE WITH SOUNDBLASTER LIVE! CARDS:
Currently with SoundBlaster Live! cards, the EAX environmental
extensions are applied to all the audio being played from the CD.
While this does not necessarily interfere with the game; to stop
it from happening, follow these steps:
1. Access your Creative AudioHQ, usually found in
Start Menu --> Programs --> Creative--> Soundblaster Live! --> AudioHQ
2. Access the 'Environmental Audio' control applet
3. Click on the 'Options' tab within the Environmental Audio window.
4. Check the 'Always Save Changes Automatically' preference box.
5. Click the 'Source' tab.
6. Select the CD Digital source and set the Reverb & Chorus amounts
to 0%. Leave the Original Sound source at 100%.
7. Do the same with the CD Audio source. (Reverb & Chorus at 0%)
8. Click on 'Close' and you will be prompted to input a name for your
new settings. We suggest 'No CD effects' or similar.
9. You are now ready to play ALIENS VERSUS PREDATOR with normal CD
music. This issue should be resolved for the full release of the game.
***********************************************************************
2. DEMO OBJECTIVES
***********************************************************************
Playing as an Alien, you start in an Atmosphere Processor secured
by Colonial Marines. You must escape to the planet's surface to alert
the Hive. You must proceed with speed and stealth, and use guile to
disable and destroy those forces which you cannot attack head-on.
***********************************************************************
3. INSTALLATION
***********************************************************************
ALIENS VERSUS PREDATOR requires DirectX 6. This can be found within the
game's installation directory and you will be prompted to install it if
it is not on your system when you install the Demo.
To install the ALIENS VERSUS PREDATOR Demo, double click on Setup.exe
Follow the onscreen instructions.
ALIENS VERSUS PREDATOR dynamically streams FMV from your machine's
local hard-drive. This playback is greatly enhanced if the FMV files
are installed on a defragmented directory. We STRONGLY recommend
de-fragging your hard drive before installing ALIENS VERSUS PREDATOR.
To de-fragment your drive, either use the Windows95 accessory
'Disk Defragmenter' or any other 3rd party defragmentation utility.
Although the ALIENS VERSUS PREDATOR Demo will work with other
applications running in the background, for the best results it is
recommended that you run the game as a stand-alone application
(with no other applications running).
As well as avoiding possible conflicts from other applications, this
will also help prevent Windows from accessing the hard drive Virtual
Memory swap file, and affecting the speed and sound effects of the
game.
***********************************************************************
4. GAME CONTROLS
***********************************************************************
ALIENS VERSUS PREDATOR supports all DirectX compatible controllers. You
must install and set up these controllers before entering the game.
Other keys and mouse configurations can be defined either from the main
menu screen or from the in-game menus.
The default keys are:
UPARROW Forward
DOWNARROW Backward
LEFTARROW Strafe Left
RIGHTARROW Strafe Right
NUMPAD 4 Turn Left
NUMPAD 6 Turn Right
RIGHT_ALT Strafe
A Look Up
Z Look Down
S Centre View
LEFTSHIFT Walk
RIGHTCTRL Crouch/Climb
RIGHTSHIFT Jump
SPACE Operate
I Toggle between HUNT and NAVIGATION vision modes
The default mouse settings are full MouseLook.
The default mouse buttons are "Claw Attack" and "Tail Attack".
F8 Take screenshot (currently only 16bit video modes)
***********************************************************************
5. ALIEN ABILITIES
***********************************************************************
HEALTH
Health is displayed as the numerals in the top right of your screen.
When you are damaged, your screen will flash yellow from the sides.
Your health can be replenished by feeding on other lifeforms - see
JAW ATTACK in the ALIEN WEAPONS section.
ARMOR
The strength of the Alien's exoskeleton is displayed as the numerals
directly under HEALTH. As with HEALTH, damage to the exoskeleton can
be repaired by feeding on other lifeforms.
VISION MODES
The Alien has the ability to 'see' the world through two modes:
HUNTING and NAVIGATION. In HUNTING mode the Alien's senses are
attuned to searching for prey, whereas in NAVIGATION mode the
senses are concentrated on defining the surrounding environment.
MOVEMENT & CLIMBING
The Alien has the ability to move on any surface. Simply hold down
the 'Crouch/Climb' key whilst moving. When climbing, releasing the
key will release the Alien's grip and drop it to the floor. Using
the 'Jump' key while climbing will cause the Alien to pounce in the
direction it is looking.
***********************************************************************
6. ALIEN WEAPONS
***********************************************************************
CLAWS
Tapping or holding the 'Claw Attack' button triggers a flurry of
swipes and slashes. In the right circumstances the 'Claw Attack'
button can also trigger the secondary jaws.
JAW
The secondary jaws can be used to feed on other lifeforms, thus
replenishing HEALTH and ARMOR. Jaw attacks require a certain amount
of skill to achieve. When a target's head is close enough and in the
centre of the screen (the 'sweet-spot') the Alien's inner jaws will
become visible to indicate that a jaw attack is possible. Pressing
the 'Claw Attack' key will then launch the jaw attack.
N.B. Jaw attacking corpses provides less of a health/armor bonus than
live prey - assuming that the corpse still has a head. Try practicing
on unarmed personnel!
TAIL
Tapping 'Tail Attack' causes a quick, low power, jab, whereas holding
down the 'Tail Attack' button readies the tail for a more powerful
strike. The tail will automatically target any prey in front of the
Alien.
***********************************************************************
7. CONTACT & LEGAL INFORMATION
***********************************************************************
CONTACT INFORMATION
For more information, or to communicate with us with regards to this or
any Fox Interactive product, please consult our Worldwide Web site at:
http://www.foxinteractive.com
...or for questions/technical issues send us an email at:
avp@fox.com
LEGAL INFORMATION
ALIENS VERSUS PREDATOR is published by Fox Interactive and developed
by Rebellion Developments, Ltd.
ALIENS TM & (c) 1986, 1998 Twentieth Century Fox Film Corporation.
PREDATOR TM & (c) 1987, 1998 Twentieth Century Fox Film Corporation.
ALIENS VERSUS PREDATOR TM & (c) 1998 Twentieth Century Fox Film
Corporation. All Rights Reserved. "Aliens," "Predator," "Fox," and
"Fox Interactive" and their associated logos are the property of
Twentieth Century Fox Film Corporation. All Rights Reserved.
***********************************************************************

284
3dc/AvP_Marine_Readme.txt
View file

@ -1,284 +0,0 @@
***********************************************************************
ALIENS VERSUS PREDATOR
Marine Demo
Version 1.0
Readme File
Nov 23rd 1998
***********************************************************************
CONTENTS
***********************************************************************
1. MINIMUM REQUIREMENTS
2. DEMO OBJECTIVES
3. INSTALLATION
4. GAME CONTROLS
5. MARINE EQUIPMENT
6. MARINE WEAPONRY
7. CONTACT & LEGAL INFORMATION
***********************************************************************
1. MINIMUM REQUIREMENTS
***********************************************************************
Intel Pentium 200 MMX PC (or 100% compatible CPU)
DirectX supported 3D Accelerator Card
DirectX v.6 (Included on Installation CD)
32Mb RAM (64Mb recommended)
64Mb free Hard Drive
Windows 95
The ALIENS VERSUS PREDATOR Demo is a work in-progress. Thus it is not
fully optimised and configured for lower spec machines. These issues
will be corrected for the full retail version, giving the end user
control over engine and special effect variables ensuring smooth
gameplay over a wide variety of CPUs, accelerator cards and RAM.
Due to the complexity of the ALIENS VERSUS PREDATOR models, users with
32Mb of RAM may experience some memory paging, especially when exiting
the game and returning to Windows. These problems will be fixed for the
release version of the game.
KNOWN ISSUE WITH SOUNDBLASTER LIVE! CARDS:
Currently with SoundBlaster Live! cards, the EAX environmental
extensions are applied to all the audio being played from the CD.
While this does not necessarily interfere with the game; to stop
it from happening, follow these steps:
1. Access your Creative AudioHQ, usually found in
Start Menu --> Programs --> Creative--> Soundblaster Live! --> AudioHQ
2. Access the 'Environmental Audio' control applet
3. Click on the 'Options' tab within the Environmental Audio window.
4. Check the 'Always Save Changes Automatically' preference box.
5. Click the 'Source' tab.
6. Select the CD Digital source and set the Reverb & Chorus amounts
to 0%. Leave the Original Sound source at 100%.
7. Do the same with the CD Audio source. (Reverb & Chorus at 0%)
8. Click on 'Close' and you will be prompted to input a name for your
new settings. We suggest 'No CD effects' or similar.
9. You are now ready to play ALIENS VERSUS PREDATOR with normal CD
music. This issue should be resolved for the full release of the game.
***********************************************************************
2. DEMO OBJECTIVES
***********************************************************************
As the Marine, you are the last surviving member of your squad. Your
mission was to explore and investigate the Atmosphere Processor, then
destroy it. You were to remain as guard inside the APC... until your
squad were brutally massacred by forces unknown. Your mission is now
to survive and follow the instructions beamed down to you from your
mission commander from his support ship in low orbit.
***********************************************************************
3. INSTALLATION
***********************************************************************
ALIENS VERSUS PREDATOR requires DirectX 6. This can be found within the
game's installation directory and you will be prompted to install it if
it is not on your system when you install the Demo.
To install the ALIENS VERSUS PREDATOR Demo, double click on Setup.exe
Follow the onscreen instructions.
ALIENS VERSUS PREDATOR dynamically streams FMV from your machine's
local hard-drive. This playback is greatly enhanced if the FMV files
are installed on a defragmented directory. We STRONGLY recommend
de-fragging your hard drive before installing ALIENS VERSUS PREDATOR.
To de-fragment your drive, either use the Windows95 accessory
'Disk Defragmenter' or any other 3rd party defragmentation utility.
Although the ALIENS VERSUS PREDATOR Demo will work with other
applications running in the background, for the best results it is
recommended that you run the game as a stand-alone application
(with no other applications running).
As well as avoiding possible conflicts from other applications, this
will also help prevent Windows from accessing the hard drive Virtual
Memory swap file, and affecting the speed and sound effects of the
game.
***********************************************************************
4. GAME CONTROLS
***********************************************************************
ALIENS VERSUS PREDATOR supports all DirectX compatible controllers. You
must install and set up these controllers before entering the game.
Other keys and mouse configurations can be defined either from the main
menu screen or from the in-game menus.
The default keys are:
UPARROW Forward
DOWNARROW Backward
LEFTARROW Strafe Left
RIGHTARROW Strafe Right
NUMPAD 4 Turn Left
NUMPAD 6 Turn Right
RIGHT_ALT Strafe
A Look Up
Z Look Down
S Centre View
LEFTSHIFT Walk
RIGHTSHIFT Jump
SPACE Operate
I Toggle Image Intensifier
Q Next Weapon
W Previous Weapon
L Throw Flare
BACKSPACE Flashback weapon (switches to previous held)
The default mouse settings are full MouseLook.
The default mouse buttons are fire primary and fire secondary.
***********************************************************************
5. MARINE EQUIPMENT
***********************************************************************
HEALTH
Health is displayed as green numerals in the top right of your screen.
When you are damaged, your screen will flash red from the sides. Your
health can be replenished from healthpacks your comrades have dropped
in various levels of the Atmosphere Processor.
ARMOR
Armor protects you from both acid blood and other forms of damage. It
is displayed beneath the health numerals as a percentage. You may don
extra armor if you find it.
IMAGE INTENSIFIER
All Colonial Marines are equipped with image intensification optics.
Once activated your vision is augmented for low light conditions, thus
allowing you to see even in pitch darkness. You may use the Intensifier
at will, although it does temporarily burn-out if you are near a strong
light source (such as your weapon firing).
FLARES
You come equipped with small phosphorus flares that you may throw to
light your way. These will stick to any surface and provide a strong
yet temporary light, as well as a deal of smoke. Flares and your
Image Intensifier naturally do not mix well.
***********************************************************************
6. MARINE WEAPONS
***********************************************************************
PULSERIFLE (slot 1)
A Colonial Marine's standard weapon, combining a powerful assault rifle
with an under and over grenade launcher. It carries 99 rounds in the
magazine - watch for reloads! The number of grenades it can carry are
limited - look for your companion's old pulserifles for reloads.
The PulseRifle is less accurate if you are moving whilst firing.
SMARTGUN (slot 2)
A mobile Colonial Marine's most powerful weapon, the SmartGun is a
masterpiece of technology. Mounted on a gyroscopic harness, it literally
aims itself, targeting the centre of mass. It is linked to the marine's
Head Up Display - once it has acquired a target the recticle turns red
and begins to track. To fully use a SmartGun, the operator must watch
where the gun wishes to move and lead it manually - this drastically
decreases aiming time. Smartguns are less useful against smaller, more
agile targets. The smartgun is belt-fed from a large magazine mounted
on the harness, so rarely runs out of ammunition. Care should be taken
as the armour piercing bullets from the SmartGun will deal with most
targets in an explosive manner - short bursts will be sufficient to
deal with almost any foe.
FLAMETHROWER (Slot 3)
The Flamethrower is specifically designed as a close-combat weapon for
the clearing of areas. It is somewhat inaccurate, but the jet of napalm
will eventually kill anything it ignites. Keep the jet trained on a
target to inflict more direct damage.
The flamethrower runs out of fuel in a very short space of time - short
controlled bursts are the most economical method of firing.
WARNING! The napalm fired from the flamethrower is dangerous - do NOT
run forwards whilst firing (walking is OK) else you will set yourself
on fire. Additionally, it is possible that the napalm will 'bounce' off
a surface and back onto the user. However, nothing is more effective
than the flamethrower when exterminating vermin.
***********************************************************************
7. CONTACT & LEGAL INFORMATION
***********************************************************************
CONTACT INFORMATION
For more information, or to communicate with us with regards to this or
any Fox Interactive product, please consult our Worldwide Web site at:
http://www.foxinteractive.com
...or for questions/technical issues send us an email at:
avp@fox.com
LEGAL INFORMATION
ALIENS VERSUS PREDATOR is published by Fox Interactive and developed
by Rebellion Developments, Ltd.
ALIENS TM & (c) 1986, 1998 Twentieth Century Fox Film Corporation.
PREDATOR TM & (c) 1987, 1998 Twentieth Century Fox Film Corporation.
ALIENS VERSUS PREDATOR TM & (c) 1998 Twentieth Century Fox Film
Corporation. All Rights Reserved. "Aliens," "Predator," "Fox," and
"Fox Interactive" and their associated logos are the property of
Twentieth Century Fox Film Corporation. All Rights Reserved.
***********************************************************************

264
3dc/AvP_Predator_Readme.txt
View file

@ -1,264 +0,0 @@
***********************************************************************
ALIENS VERSUS PREDATOR
Predator Demo
Version 1.3
Readme File
Oct 22nd 1998
***********************************************************************
CONTENTS
***********************************************************************
1. MINIMUM REQUIREMENTS
2. DEMO OBJECTIVES
3. INSTALLATION
4. GAME CONTROLS
5. PREDATOR EQUIPMENT
6. PREDATOR WEAPONRY
7. CONTACT & LEGAL INFORMATION
***********************************************************************
1. MINIMUM REQUIREMENTS
***********************************************************************
Intel Pentium 200 MMX PC (or 100% compatible CPU)
DirectX supported 3D Accelerator Card
DirectX v.6 (Included on Installation CD)
32Mb RAM (64Mb reccommended)
64Mb free Hard Drive
Windows 95
The ALIENS VERSUS PREDATOR Demo is a work in-progress. Thus it is not
fully optimised and configured for lower spec machines. These issues
will be corrected for the full retail version, giving the end user
control over engine and special effect variables ensuring smooth
gameplay over a wide variety of CPUs, accelerator cards and RAM.
Due to the complexity of the ALIENS VERSUS PREDATOR models, users with
32Mb of RAM may experience some memory paging, especially when exiting
the game and returning to Windows. These problems will be fixed for the
release version of the game.
***********************************************************************
2. DEMO OBJECTIVES
***********************************************************************
As the Predator, you must descend through an Alien-infested Atmosphere
Processor to eliminate the Marines who are defending an APC at the base
of the structure. Your weapons are Wrist-blades, Speargun and shoulder
mounted Plasmacaster. You also possess an emergency medical kit.
***********************************************************************
3. INSTALLATION
***********************************************************************
ALIENS VERSUS PREDATOR requires DirectX 6. This can be found within the
game's installation directory and you will be prompted to install it if
it is not on your system when you install the Demo.
To install the ALIENS VERSUS PREDATOR Demo, double click on Setup.exe
Follow the onscreen instructions.
ALIENS VERSUS PREDATOR dynamically streams FMV from your machine's
local hard-drive. This playback is greatly enhanced if the FMV files
are installed on a defragmented directory. We STRONGLY recommend
de-fragging your hard drive before installing ALIENS VERSUS PREDATOR.
To de-fragment your drive, either use the Windows95 accessory
'Disk Defragmenter' or any other 3rd party defragmentation utility.
Although the ALIENS VERSUS PREDATOR Demo will work with other
Applications running in the background, for the best results it is
recommended that you run the game as a stand-alone application
(with no other applications running).
As well as avoiding possible conflicts from other applications, this
will also help prevent Windows from accessing the hard drive Virtual
Memory swap file, and affecting the speed and sound effects of the
game.
***********************************************************************
4. GAME CONTROLS
***********************************************************************
ALIENS VERSUS PREDATOR supports all DirectX compatible controllers. You
must install and set up these controllers before entering the game.
Other keys and mouse configurations can be defined either from the main
menu screen or from the in-game menus.
The default keys are:
UPARROW Forward
DOWNARROW Backward
LEFTARROW Strafe Left
RIGHTARROW Strafe Right
NUMPAD 4 Turn Left
NUMPAD 6 Turn Right
RIGHT_ALT Strafe
A Look Up
Z Look Down
S Centre View
LEFTSHIFT Walk
RIGHTSHIFT Jump
SPACE Operate
I Toggle Cloaking
Q Next Weapon
W Previous Weapon
PAGEUP Zoom In
PAGEDOWN Zoom Out
L Cycle Vision Modes
The default mouse settings are full MouseLook.
The default mouse buttons are fire primary and fire secondary.
***********************************************************************
5. PREDATOR EQUIPMENT
***********************************************************************
HEALTH
Health is displayed as a vertical red bar on the left hand side of the
screen. As the Predator is wounded, these digits are removed from the
bottom up. When health is low, the Predator should use the MediComp.
The Predator has no Health pick-ups in ALIENS VERSUS PREDATOR.
FIELD CHARGE
All of the Predator's weapons and equipment run off the Predator's
Field Charge, a general measure of power. This is displayed as a
vertical blue bar on the right hand side of the screen. The Predator
can find extremely limited amounts of Field Charge in the Demo.
Field Charge is drained by a number of the Predator's abilities,
which are listed below:
Healing. The MediComp (q.v.) is expensive to run.
Plasmacaster. This can drain however much is required.
Cloaking. Both a chunk to enter cloak and a small permanent drain.
CLOAKING
The Predator has the ability to 'bend light' around itself. This can
render it almost invisible under most lighting conditions unless it
gives it's position away. Unfortunately, the Xenomorph species does
not use light to detect it's prey, so cloaking is not effective.
Whilst in cloak, the Predator sees the world differently as the
light is processed for his vision.
Entering cloak is costly for Field Charge.
VISION MODES
There are two vision modes available in this demo - Thermal and
Electro-magnetic. Thermal vision shows up Humans as bright red and
yellow heat sources, while the rest of the world is cold and blue.
Electro-magnetic vision displays the Aliens clearly, whilst failing
to pick up on the human targets. Some of the Predator's abilities
depend on picking the correct vision modes.
***********************************************************************
6. PREDATOR WEAPONS
***********************************************************************
WRISTBLADES (slot 1)
A set of lethal razor-sharp blades mounted on the Predator's right
wrist. Use Primary Fire to perform a quick jab. Use Secondary Fire to
pull back and charge up a high-powered swipe. The Predator may use the
wristblades while cloaked.
SPEARGUN (slot 3)
A high-velocity harpoon-style weapon, this fires a jagged bolt of metal
capable of ripping parts off the Predator's enemies. The extreme power
is tempered by the slow rate-of-fire and the fact that Aliens can easily
survive traumatic injuries. Ammunition is limited and the use of this
weapon de-activates the Predator's cloaking.
PLASMACASTER (slot 4)
The Predator's most effective weapon is computer-controlled from the
wrist console. It has it's own charge meter (found on the Wrist Console
as a small red bar) which displays how much power is contained within
the blast. This can be charged either by Primary Fire and upon release
the bolt is fired, or can have charge stored within it via the use of
Secondary Fire.
The Plasmacaster is fully auto-tracking, locking onto a target in
seconds as long as it remains within view. The Plasmacaster can only
target enemies if fired from the Predator's correct vision mode for
that species.
MEDICOMP (Slot 6)
Not really a weapon, the MediComp is the Predator's only hope of
regaining health while in combat. It is extremely expensive of
Field Charge and takes some time to use, during which the Predator
is effectively defenseless. It is therefore important to use it during
lulls in combat.
Primary fire begins the healing sequence.
Secondary fire activates the Predator's fire-damping abilities should
it unfortunately be caught by a flamethrower or incendiary. This is
far less expensive than a full heal.
***********************************************************************
7. CONTACT & LEGAL INFORMATION
***********************************************************************
CONTACT INFORMATION
For more information, or to communicate with us with regards to this or
any Fox Interactive product, please consult our Worldwide Web site at:
http://www.foxinteractive.com
LEGAL INFORMATION
ALIENS T & c 1986, 1998 Twentieth Century Fox Film Corporation.
PREDATOR T & c 1987, 1998 Twentieth Century Fox Film Corporation.
ALIENS VERSUS PREDATOR T & c 1998 Twentieth Century Fox Film
Corporation. All Rights Reserved. "Aliens," "Predator," "Fox," and
"Fox Interactive" and their associated logos are the property of
Twentieth Century Fox Film Corporation. All Rights Reserved.
***********************************************************************

278
3dc/AvP_Readme+Credits.txt
View file

@ -1,278 +0,0 @@
***********************************************************************
Fox Interactive presents
A Rebellion Game
***********************************************************************
Aliens Versus Predator
Predator Demo
Version 1.0
Readme File
10/16/98
***********************************************************************
CONTENTS
***********************************************************************
1. MINIMUM REQUIREMENTS
2. DEMO OBJECTIVES
3. INSTALLATION
4. GAME CONTROLS
5. PREDATOR EQUIPMENT
6. PREDATOR WEAPONRY
7. CREDITS
***********************************************************************
1. MINIMUM REQUIREMENTS
***********************************************************************
P200 MMX PC
Intel or 100% compatible CPU
DirectX supported 3D Accelerator Card
DirectX v.6 (Included on Installation CD)
32Mb RAM
Windows 95
The Aliens Versus Predator Demo is a work in-progress. Thus it is not
fully optimised and configured for lower spec machines. These issues
will be corrected for the full retail version, giving the end user
control over engine and special effect variables ensuring smooth
gameplay over a wide variety of CPUs, accelerator cards and RAM.
***********************************************************************
2. DEMO OBJECTIVES
***********************************************************************
As the Predator, you must descend through an Alien-infested Atmosphere
Processor to eliminate the Marines who are defending an APC at the base
of the structure. Your weapons are Wrist-blades, Speargun and shoulder
mounted Plasmacaster. You also possess an emergency medical kit.
***********************************************************************
3. INSTALLATION
***********************************************************************
To install the Aliens Versus Predator Demo, double click on Setup.exe
Follow the onscreen instructions.
Aliens Versus Predator dynamically streams FMV from your machine's
local hard-drive. This playback is greatly enhanced if the FMV files
are installed on a defragmented directory. We STRONGLY reccomend
de-fragging your hard drive before installing Aliens Versus Predator.
To de-fragment your drive, either use the Windows95 accessory
'Disk Defragmenter' or any other 3rd party defragmentation utility.
***********************************************************************
4. GAME CONTROLS
***********************************************************************
Aliens Versus Predator supports all DirectX compatible controllers. You
must install and set up these controllers before entering the game.
Other keys and mouse configurations can be defined either from the main
menu screen or from the in-game menus.
The default keys are:
UPARROW Forward
DOWNARROW Backward
LEFTARROW Strafe Left
RIGHTARROW Strafe Right
NUMPAD 4 Turn Reft
NUMPAD 6 Turn Right
RIGHT_ALT Strafe
A Look Up
Z Look Down
S Centre View
LEFTSHIFT Walk
RIGHTSHIFT Jump
SPACE Operate
I Toggle Cloaking
Q Next Weapon
W Previous Weapon
PAGEUP Zoom In
PAGEDOWN Zoon Out
L Cycle Vision Modes
The default mouse settings are full mouselook.
The default mouse buttons are fire primary and fire secondary.
***********************************************************************
5. PREDATOR EQUIPMENT
***********************************************************************
HEALTH
Health is displayed as a vertical red bar on the left hand side of the
screen. As the Predator is wounded, these digits are removed from the
bottom up. When health is low, the Predator should use the Medicomp.
The Predator has no Health pick-ups in Aliens Versus Predator.
FIELD CHARGE
All of the Predator's weapons and equipment run off the predator's
Field Charge, a general measure of power. This is displayed as a
vertical blue bar on the right hand side of the screen. The Predator
can find extremely limited amounts of Field Charge in the Demo.
Field Charge is drained by a number of the Predator's abilities,
which are listed below:
Healing. The Medicomp (qv) is expensive to run.
Plasmacaster. This can drain however much is required.
Cloaking. Both a chunk to enter cloak and a small permanent drain.
CLOAKING
The Predator has the ability to 'bend light' around itself. This can
render it almost invisible under most lighting conditions unless it
gives it's position away. Unfortunately, the Xenomorph species does
not use light to detect it's prey, so cloaking is not effective.
Whilst in cloak, the Predator sees the world differently as the
light is processed for his vision.
Entering cloak is costly for Field Charge.
VISION MODES
There are two vision modes available in this demo - Thermal and
Electro-magnetic. Thermal vision shows up Humans as bright red and
yellow heat sources, while the rest of the world is cold and blue.
Electro-magnetic vision displays the Aliens clearly, whilst failing
to pick up on the human targets. Some of the Predator's abilities
depend on picking the correct vision modes.
***********************************************************************
6. PREDATOR WEAPONS
***********************************************************************
WRISTBLADES (slot 1)
A set of lethal razor-sharp blades mounted on the Predator's right
wrist. Use Primary Fire to perform a quick jab. Use Secondary Fire to
pull back and charge up a high-powered swipe. The Predator may use the
wristblades while cloaked.
SPEARGUN (slot 3)
A high-velocity harpoon-style weapon, this fires a jagged bolt of metal
capable of ripping parts off the Predator's enemies. The extreme power
is tempered by the slow rate-of-fire and the fact that Aliens can easily
survive traumatic injuries. Ammunition is limited and the use of this
weapon de-activates the Predator's cloaking.
PLASMACASTER (slot 4)
The Predator's most effective weapon is computer-controlled from the
wrist console. It has it's own charge meter (found on the Wrist Console
as a small red bar) which displays how much power is contained within
the blast. This can be charged either by Primary Fire and upon release
the bolt is fired, or can have charge stored within it via the use of
Secondary Fire.
The Plasmacaster is fully auto-tracking, locking onto a target in
seconds as long as it remains within view. The Plasmacaster can only
target enemies if fired from the Predator's correct vision mode for
that species.
MEDICOMP (Slot 6)
Not really a weapon, the Medicomp is the Predator's only hope of
regaining health while in combat. It is extremely expensive of
Field Charge and takes some time to use, during which the Predator
is effectively defenseless. It is therefore important to use it during
lulls in combat.
Primary fire begins the healing sequence.
Secondary fire activates the Predator's fire-damping abilities should
it unfortunately be caught by a flamethrower or incendiary. This is
far less expensive than a full heal.
***********************************************************************
7. CREDITS
***********************************************************************
REBELLION CREDITS
Creative Director Jason Kingsley
Technical Director Chris Kingsley
Lead Programmer Kevin Lea
AI Programmer Chris Fox
Tools Programmer Richard Rice
Additional Programming Jake Hotson
Dave Wall
Producer Alastair Halsby
Level Design Julian Breddy
Ed Cookson
Adam Comiskey
Joe Gelder
Alastair Halsby
Tim Jones
Level Texturemaps Julian Breddy
Ed Cookson
Adam Comiskey
Joe Gelder
Alastair Halsby
Tim Jones
Matthew Riordan
Character Models
& Animation Ken Turner
Adam Comiskey
Character Texturemaps Alastair Halsby
Tim Jones
Ken Turner
Adam Comiskey
Sound Ed Cookson
Tim Jones
Alastair Halsby
Thanks To:
Patrick Dickinson, George Launchbury, Jake Hempson, John Bryden,
Andy Nixon, Will Davis, Shelagh Lewins, Luke Harman, Dan Mitchell,
Lee Brimmicombe-Wood, Sophie Mobbs, Bernard H. Wood and Paul Topping.
FOX INTERACTIVE CREDITS

226
3dc/AvP_Readme.txt
View file

@ -1,226 +0,0 @@
***********************************************************************
Fox Interactive presents
A Rebellion Game
***********************************************************************
Aliens Versus Predator
Predator Demo
Version 1.0
Readme File
10/16/98
***********************************************************************
CONTENTS
***********************************************************************
1. MINIMUM REQUIREMENTS
2. DEMO OBJECTIVES
3. INSTALLATION
4. GAME CONTROLS
5. PREDATOR EQUIPMENT
6. PREDATOR WEAPONRY
***********************************************************************
1. MINIMUM REQUIREMENTS
***********************************************************************
P200 MMX PC
Intel or 100% compatible CPU
DirectX supported 3D Accelerator Card
DirectX v.6 (Included on Installation CD)
32Mb RAM
Windows 95
The Aliens Versus Predator Demo is a work in-progress. Thus it is not
fully optimised and configured for lower spec machines. These issues
will be corrected for the full retail version, giving the end user
control over engine and special effect variables ensuring smooth
gameplay over a wide variety of CPUs, accelerator cards and RAM.
***********************************************************************
2. DEMO OBJECTIVES
***********************************************************************
As the Predator, you must descend through an Alien-infested Atmosphere
Processor to eliminate the Marines who are defending an APC at the base
of the structure. Your weapons are Wrist-blades, Speargun and shoulder
mounted Plasmacaster. You also possess an emergency medical kit.
***********************************************************************
3. INSTALLATION
***********************************************************************
To install the Aliens Versus Predator Demo, double click on Setup.exe
Follow the onscreen instructions.
Aliens Versus Predator dynamically streams FMV from your machine's
local hard-drive. This playback is greatly enhanced if the FMV files
are installed on a defragmented directory. We STRONGLY reccomend
de-fragging your hard drive before installing Aliens Versus Predator.
To de-fragment your drive, either use the Windows95 accessory
'Disk Defragmenter' or any other 3rd party defragmentation utility.
***********************************************************************
4. GAME CONTROLS
***********************************************************************
Aliens Versus Predator supports all DirectX compatible controllers. You
must install and set up these controllers before entering the game.
Other keys and mouse configurations can be defined either from the main
menu screen or from the in-game menus.
The default keys are:
UPARROW Forward
DOWNARROW Backward
LEFTARROW Strafe Left
RIGHTARROW Strafe Right
NUMPAD 4 Turn Reft
NUMPAD 6 Turn Right
RIGHT_ALT Strafe
A Look Up
Z Look Down
S Centre View
LEFTSHIFT Walk
RIGHTSHIFT Jump
SPACE Operate
I Toggle Cloaking
Q Next Weapon
W Previous Weapon
PAGEUP Zoom In
PAGEDOWN Zoon Out
L Cycle Vision Modes
The default mouse settings are full mouselook.
The default mouse buttons are fire primary and fire secondary.
***********************************************************************
5. PREDATOR EQUIPMENT
***********************************************************************
HEALTH
Health is displayed as a vertical red bar on the left hand side of the
screen. As the Predator is wounded, these digits are removed from the
bottom up. When health is low, the Predator should use the Medicomp.
The Predator has no Health pick-ups in Aliens Versus Predator.
FIELD CHARGE
All of the Predator's weapons and equipment run off the predator's
Field Charge, a general measure of power. This is displayed as a
vertical blue bar on the right hand side of the screen. The Predator
can find extremely limited amounts of Field Charge in the Demo.
Field Charge is drained by a number of the Predator's abilities,
which are listed below:
Healing. The Medicomp (qv) is expensive to run.
Plasmacaster. This can drain however much is required.
Cloaking. Both a chunk to enter cloak and a small permanent drain.
CLOAKING
The Predator has the ability to 'bend light' around itself. This can
render it almost invisible under most lighting conditions unless it
gives it's position away. Unfortunately, the Xenomorph species does
not use light to detect it's prey, so cloaking is not effective.
Whilst in cloak, the Predator sees the world differently as the
light is processed for his vision.
Entering cloak is costly for Field Charge.
VISION MODES
There are two vision modes available in this demo - Thermal and
Electro-magnetic. Thermal vision shows up Humans as bright red and
yellow heat sources, while the rest of the world is cold and blue.
Electro-magnetic vision displays the Aliens clearly, whilst failing
to pick up on the human targets. Some of the Predator's abilities
depend on picking the correct vision modes.
***********************************************************************
6. PREDATOR WEAPONS
***********************************************************************
WRISTBLADES (slot 1)
A set of lethal razor-sharp blades mounted on the Predator's right
wrist. Use Primary Fire to perform a quick jab. Use Secondary Fire to
pull back and charge up a high-powered swipe. The Predator may use the
wristblades while cloaked.
SPEARGUN (slot 3)
A high-velocity harpoon-style weapon, this fires a jagged bolt of metal
capable of ripping parts off the Predator's enemies. The extreme power
is tempered by the slow rate-of-fire and the fact that Aliens can easily
survive traumatic injuries. Ammunition is limited and the use of this
weapon de-activates the Predator's cloaking.
PLASMACASTER (slot 4)
The Predator's most effective weapon is computer-controlled from the
wrist console. It has it's own charge meter (found on the Wrist Console
as a small red bar) which displays how much power is contained within
the blast. This can be charged either by Primary Fire and upon release
the bolt is fired, or can have charge stored within it via the use of
Secondary Fire.
The Plasmacaster is fully auto-tracking, locking onto a target in
seconds as long as it remains within view. The Plasmacaster can only
target enemies if fired from the Predator's correct vision mode for
that species.
MEDICOMP (Slot 6)
Not really a weapon, the Medicomp is the Predator's only hope of
regaining health while in combat. It is extremely expensive of
Field Charge and takes some time to use, during which the Predator
is effectively defenseless. It is therefore important to use it during
lulls in combat.
Primary fire begins the healing sequence.
Secondary fire activates the Predator's fire-damping abilities should
it unfortunately be caught by a flamethrower or incendiary. This is
far less expensive than a full heal.
***********************************************************************

340
3dc/CREDITS.txt
View file

@ -1,340 +0,0 @@
}Fox Interactive Presents
}Aliens Versus Predator
}Gold Edition
}Fox Interactive
}-------------
Producer|David Stalker
Senior Associate Producer|Chris Miller
Associate Producer|Aaron Blean
}Fox QA Department
QA Manager|David Ortiz
QA Lead|Igor Krinitsky
QA Co-Lead|Chris Wilson
Testers|Arabian
|Aron Ahles
|Ken Anderson
|Eric Asevo
|Sweet Billy
|Ben Borth
|Pete Cesario
|Francis Choi
|Kristian Davila
|Matt Dell
|Ryan Dowling
|Michael Dunn
|Tim Hall
|Tim Harrison
|Judd Hollander
|Kevin Huynh
|Cris Lee
|Jeremy Luyties
|Red Magpantay
|Kerry Marshall
|Young Park
|Kyle Peschel
|Harish Rao
|Don Sexton
|Gabe Slater
|Jeff Tatman
|Luke Thai
|Tim Tran
|Daan Wisehart
|Sung Yoo
|Brian Zenns
}Rebellion
}-------
Creative Director|Jason Kingsley
Technical Director|Chris Kingsley
Senior Producer|Mark Eyles
Production Manager|Graeme Williams
Technology Manager|Kevin Lea
Producer & Lead Artist|Tim Jones
Network Code & Tools Programmer|Richard Rice
Art|Julian Breddy
|Ed Cookson
|Dominic Jeffery
|Tim Jones
|Ken Turner
Sound|Ed Cookson
Additional Sound|Julian Breddy
|Dominic Jeffery
|Tim Jones
Thanks to|Al Halsby
|Chris Fox
|Jessica Sharp
|Nadia Cocklin
|Harry Harris
|April Chung
|Anna Floyer
|Siobhan Boughton
|Helen Szirtes
|Christian Russell
|Phil Moss
|Matt Black
|The Special K Massive (Big up stylee!)
}Gold Edition FMVs
Cast|Ed Cookson
|Aeron Guy
|Mike Healey
|Ben Jones
|Tim Jones
|Chris Kingsley
|Ed Niblett
|Ken Turner
Creative Director and Lighting|Jason Kingsley
Direction|Ed Cookson
|Tim Jones
|Ken Turner
Editing and Sound Effects|Ed Cookson
|Ken Turner
Special Effects|Ken, Ben, Ed C and Tim
Thanks to|Everyone at Rebellion who gave up their weekend
}Aliens Versus Predator
}Fox Interactive
}-------------
Producer|David Stalker
Associate Producer|Chris Miller
Music Composition|Rich Ragsdale
Sound Effects|Jered C. Miller
}Fox QA Department
QA Manager|Mike Schneider
QA Lead|Aaron Blean
Testers|Seth Roth
|Ken Anderson
|Eric Asevo
|Pete Cesario
|Ryan Dowling
|Michael Dunn
|Tim Hall
|Igor Krinitsky
|Red Magpantay
|Sweet Billy
|Paul Pawlicki
|Harish Rao
|Tim Ramage
|Nick Stecher
|Jeff Tatman
|Tim Tran
|Sung Yoo
|Kristian Davila
}Big Shouts out to:
The unsung folks at Fox|Paul Provenzano
|Mark Dawson
|Dave Shaw
|Alan Alder
|Brian Thomas
|Melissa Totten
|Ellen Gameral
|Jamie Samson
|Michele Birkner
|Priscilla Bourbonnais
|Mike Arkin
|Andrea Griffiths
|Simon Etchells
The folks who made the movies|Ridley Scott
|H.R. Giger
|James Cameron
|John McTiernan
|James Horner
|Jerry Goldsmith
|Elliot Goldenthal
|Stan Winston
|and many other talented individuals
}Rebellion
}-------
Creative Director|Jason Kingsley
Technical Director|Chris Kingsley
Producer & Lead Artist|Alastair Halsby
Engine Code & Lead Programmer|Kevin Lea
Network Code & Tools Programmer|Richard Rice
AI Programmer|Chris Fox
}Additional Programming
Sound|Dave Wall
Tools|Jake Hotson
AI|Alex Thomson
Art|Julian Breddy
|Ed Cookson
|Al Halsby
|Tim Jones
Additional Art|Ken Turner
|Matthew Riordan
|Adam Comiskey
|Kevin Lea
Lead Animator & Character Design|Ken Turner
Additional Animation|Adam Comiskey
Character Art|Al Halsby
|Tim Jones
|Julian Breddy
Sound|Ed Cookson
Additional Sound|Tim Jones
|Will Davies
|Al Halsby
Male Voice Talent|Julian Breddy
|Ken Turner
|Dominic Jeffrey
Female Voice Talent|Becky Kneubuhl
|April Chung
|Nadia Cocklin
Rebellion Thanks:|Jessica Sharp
|Patrick Dickinson
|George Launchbury
|Roxby Hartley
|Jake Hempson
|John Bryden
|Andy Nixon
|Shelagh Lewins
|Luke Harman
|Dan Mitchell
|Lee Brimmicombe-Wood
|Sophie Mobbs
|Bernard H. Wood
|Paul Topping
}Mondo Media
}-----------
Art Director|Marco Bertoldo
Producer|Liz Stuart
Senior Producer|Vivian Barad
3D Artists|Brittnal Anderson
|Robert Jeffery
|Kelley Lamsens
|Jeanne Littooy
|Manuel Marquez
|Art Matsuura
Storyboard Artist|Rhode Montijo
#

8501
3dc/Kshape.bak
View file

File diff suppressed because it is too large Load diff

BIN
3dc/SMACKW32.DLL
View file

Binary file not shown.

BIN
3dc/SMACKW32.LIB
View file

Binary file not shown.

BIN
3dc/avp.ico
View file

Binary file not shown.
Side by side

Before

Width:  |  Height:  |  Size: 2.2 KiB

1
3dc/avp.rc
View file

@ -1 +0,0 @@
AVPICON ICON AvP.ICO

BIN
3dc/avp/shapes/vssver.scc
View file

Binary file not shown.

BIN
3dc/avp/support/vssver.scc
View file

Binary file not shown.

BIN
3dc/avp/vssver.scc
View file

Binary file not shown.

BIN
3dc/avp/win95/Frontend/vssver.scc
View file

Binary file not shown.

353
3dc/avp/win95/System.bak
View file

@ -1,353 +0,0 @@
#ifndef SYSTEM_INCLUDED
/* AVP - WIN95
Project Specific System Equates etc.
*/
#ifdef __cplusplus
extern "C" {
#endif
/********************* SYSTEM, PLATFORM AND GAME************/
#define Yes 1
#define No 0
#ifdef _DEBUG /* standard compiler command line debugging-ON switch */
#define debug Yes
#elif defined(NDEBUG) /* standard compiler command line debugging-OFF switch */
#define debug No
#else /* default switch */
#define debug Yes
#endif
#define SuppressWarnings Yes
#define SupportWindows95 Yes
#define Saturn No
#define PSX No
#define platform_pc Yes
#define InterfaceEngine No
#define Term -1
/******************** General *****************************/
#define SupportFPMathsFunctions Yes
#define SupportFPSquareRoot Yes
#define GlobalScale 1
#define one14 16383
#define ONE_FIXED 65536
#define ONE_FIXED_SHIFT 16
#define Analogue Yes
#define Digital No
/* Offsets from *** int pointer *** for vectors and vertices */
typedef enum {
ix,
iy,
iz
} PTARRAYINDICES;
#define StopCompilationOnMultipleInclusions No
#define UseProjPlatAssert Yes /* assert fired functions are in dxlog.c */
/*************** CAMERA AND VIEW VOL********************/
#define NearZ 1024
#define FarZ ONE_FIXED
#define SupportMultiCamModules Yes
/************* Timer and Frame Rate Independence *************/
#define TimerFrame 1000
#define TimerFrame10 10000
#define NormalFrame ONE_FIXED
#define NormalFrameShift ONE_FIXED_SHIFT
#define UseAlarmTimer No
/******************** Clip Outcodes *****************/
#define ClipTerm 0x1fffffff
#define oc_left 0x00000001
#define oc_right 0x00000002
#define oc_up 0x00000004
#define oc_down 0x00000008
#define oc_z 0x00000010
#define oc_pntrot 0x00000020
#define oc_xrot 0x00000040
#define oc_yrot 0x00000080
#define oc_zrot 0x00000100
#define oc_z_lt_h1 0x00000200
#define oc_z_gte_h2 0x00000400
#define oc_z_haze 0x00000800
#define oc_clampz 0x00001000
/* Outcodes can be cast to this struct */
typedef struct oc_entry {
int OC_Flags1;
int OC_Flags2;
int OC_HazeAlpha;
} OC_ENTRY;
/* now defunct - see next four defines*/
#define Hardware2dTextureClipping No
#define Texture3dClamping No
#define Texture2dClamping No
#define Texture3dSubdivide No
#define SaturnHazing No
/***************** Angles and VALUES ******************/
#define deg10 114
#define deg22pt5 256
#define deg45 512
#define deg90 1024
#define deg180 2048
#define deg270 3072
#define deg315 3584
#define deg337pt5 3840
#define deg350 3980
#define deg360 4096
#define wrap360 4095
#define Cosine45 46341 /* 46340.95001 cosine(45deg)*/
#define DefaultSlope 46341
#define bigint 1<<30 /* max int size*/
#define smallint -(bigint) /* smallest int size*/
#define BigLowY 100000 /* Must be bigger than any Screen Y */
/****************** BUFFER SIZES **********************/
#define maxvdbs 1
#define maxobjects 750
extern int maxshapes;
#define maxstblocks 1000
#define maxrotpts 10000
//tuning for morph sizes
#define maxmorphPts 1024
#define maxmorphNormals 1024
#define maxmorphVNormals 1024
#define maxpolys 4000
#define maxpolyptrs maxpolys
#define maxpolypts 9 /* Translates as number of vectors */
#define maxvsize 6 /* 3d Phong is x,y,z,nx,ny,nz */
#define pointsarraysize maxpolypts*maxvsize
#define avgpolysize (1 + 1 + 1 + 1 + (6 * 4) + 1) /* 3d guard poly*/
#define maxscansize 8 /* e.g. Tx, U1, V1, U2, V2, X1, X2, Y */
#define vsize 3 /* Scale for polygon vertex indices */
#define numfreebspblocks 1
#define maxbspnodeitems 1
#if 0
#define MaxImages 80 /* Was 400, but now we only have one NPC in each image group */
#define MaxImageGroups 15 /* Right: One for the ENV one for the CHARACTER, one for each NPC (max 4, though only MPS4 ever has as many as 3 at present) */
#else
#define MaxImages 400
#define MaxImageGroups 1
#endif
#define oversample_8bitg_threshold 256
/************** Some Shell and Loading Platform Compiler Options ******************/
#define binary_loading No
#undef RIFF_SYSTEM
#define RIFF_SYSTEM
#define TestRiffLoaders Yes
#define SupportFarStrategyModel No
#define LoadingMapsShapesAndTexturesEtc No
#define pc_backdrops No
#define flic_player Yes
#define SaturnCDQueueSystem No
#define DynamicAdaptationToFrameRate No
/***************** DRAW SORT *******************/
#define SupportTrackOptimisation No
#define SupportBSP No
#define SupportZBuffering Yes
#define ZBufferTest No
/***************** SHAPE DATA DEFINES************/
#define StandardShapeLanguage Yes
#define CalcShapeExtents No
#define SupportModules Yes
#define IncludeModuleFunctionPrototypes Yes
#define SupportDynamicModuleObjects Yes
#define SupportMorphing Yes
#define LazyEvaluationForMorphing No
/* Default Scale for Shape Vertices */
#define pscale 1
/***************** COLLISION DEFINES*************/
#define StandardStrategyAndCollisions No
#define IntermediateSSACM No /* User preference */
/************** TEXTURE DEFINES*******************/
#define LoadPGMPalettesFromAnywhere Yes
#define maxTxAnimblocks 100
/* Texture usage of the colour int */
#define TxDefn 16 /* Shift up for texture definition index */
#define TxLocal 0x8000 /* Set bit 15 to signify a local index */
#define ClrTxIndex 0xffff0000 /* AND with this to clear the low 16-bits */
#define ClrTxDefn 0x0000ffff /* AND with this to clear the high 16-bits */
#define draw_palette No
#define AssumeTextures256Wide Yes
#define remap_table_rgb_bits 4 /* Gives 4,096 entries */
#define Remap24BitBMPFilesInRaw256Mode No
#define Remap8BitBMPFilesInRaw256Mode No
#define SupportMIPMapping No
#define UseMIPMax No
#define UseMIPMin No
#define UseMIPAvg Yes
/* Jake's addition to mip-mapping */
/* improves resolution of mip images chosen for the scandraws */
/* 0 is the worstt resoloution, best anti-aliasing 6 the best*/
#define MIP_INDEX_SUBTRACT 1
/* What to do if the images are not the most suitable size for mip mapping ... */
/* Set this if you have inappropriately sized images and you want */
/* the mip maps' sizes to be rounded up eg. 161x82 -> 81x41 -> 21x11 -> 11x6 -> 6x3 -> 3x2 -> 2x1 */
#define MIP_ROUNDUP Yes
#if 0
#define num_shadetable_entries 256
#define shadetable_shift 8 /* 65,535 -> 255 */
#endif
#if 1
#define num_shadetable_entries 1024
#define shadetable_shift 6
#endif
/*
3d textures
This defines the amount by which we can scale up U/Z, V/Z & 1/Z
It is defined in terms of the maximum UV size and the size of an int
A value of 10 gives a scale of 31 - 10 = 21
1/Z, the critical value, reaches 0 at 2^21 = 2km
Since we know that z STARTS at no less than 2^8, we can increase this value
by 8, giving 2^29
1/Z now reaches 0 at 2^29 = 537km
*/
#define support3dtextures Yes
#define int3dtextures No /* there is no D3D Zbuffer support for int 3d textures */
#define SupportGouraud3dTextures Yes
/*************************** WINDOWS 95 *********************/
#define SUPPORT_MMX 0
#define MaxD3DInstructions 1000 // includes state change instructions!!!
#define MaxD3DVertices 256
#define optimiseflip No /* unstable at present */
#define optimiseblit Yes /* unstable at present */
/******************** PLAYSTATION ********************/
#ifdef __cplusplus
};
#endif
#define SYSTEM_INCLUDED
#endif

206
3dc/avp/win95/gadgets/gadget.bak
View file

@ -1,206 +0,0 @@
/*
gadget.h
Base header file for Dave Malcolm's user interface "gadget" code.
Note to "C" programmers: look at the bottom of this file
*/
#ifndef _gadget
#define _gadget 1
#ifdef __cplusplus
extern "C" {
#endif
/* Version settings *****************************************************/
#define UseGadgets Yes
/* If this is set to No all gadget code collapses to void macros */
#define EnableStatusPanels No
/* Constants ***********************************************************/
#define HUD_SPACING 20
/* Macros ***************************************************************/
/* Type definitions *****************************************************/
#if UseGadgets
#ifndef _projtext
#include "projtext.h"
#endif
#ifdef __cplusplus
#ifndef _r2base
#include "r2base.h"
#endif
class Gadget
{
public:
// Pure virtual render method:
virtual void Render
(
const struct r2pos& R2Pos,
const struct r2rect& R2Rect_Clip,
int FixP_Alpha
) = 0;
// Render yourself at the coordinates given, clipped by the clipping rectangle
// Note that the position need not be at all related to the clipping rectangle;
// it's up to the implementation to behave for these cases.
// Both the coordinate and the clipping rectangle are in absolute screen coordinates
// The alpha value to use is "absolute"
virtual ~Gadget();
// ensure virtual destructor
#if debug
char* GetDebugName(void);
void Render_Report
(
const struct r2pos& R2Pos,
const struct r2rect& R2Rect_Clip,
int FixP_Alpha
);
// use to textprint useful information about a call to "Render"
#endif
protected:
// Protected constructor since abstract base class
#if debug
Gadget
(
char* DebugName_New
) : DebugName( DebugName_New )
{
// empty
}
#else
Gadget(){}
#endif
private:
#if debug
char* DebugName;
#endif
}; // end of class Gadget
// Inline methods:
#if debug
inline char* Gadget::GetDebugName(void)
{
return DebugName;
}
#endif
#if 0
class GadgetWithSize : public Gadget
{
// Friends
// Protected data:
protected:
r2size R2Size_Val;
// Public methods:
public:
r2size GetSize(void) const;
void SetSize(r2size R2Size);
virtual void SetSize_PostProcessing(void) {}
// Protected methods:
protected:
// Protected constructor since abstract class
// (It's abstract since Render() remains pure virtual )
GadgetWithSize
(
#if debug
char* DebugName_New,
#endif
r2size R2Size_New
) : Gadget
(
#if debug
DebugName_New
#endif
),
R2Size_Val( R2Size_New ) {}
// Private methods:
private:
// Private data:
private:
// Inline methods:
public:
r2size GetSize(void) const
{
return R2Size_Val;
}
void SetSize( r2size R2Size_New )
{
R2Size_Val = R2Size_New;
SetSize_PostProcessing();
}
protected:
private:
}; // end of class GadgetWithSize
#endif
#endif /* __cplusplus */
#endif /* UseGadgets */
/* Exported globals *****************************************************/
/* Function prototypes **************************************************/
#if UseGadgets
extern void GADGET_Init(void);
/* expects to be called at program boot-up time */
extern void GADGET_UnInit(void);
/* expects to be called at program shutdown time */
extern void GADGET_Render(void);
/* expects to be called within the rendering part of the main loop */
extern void GADGET_ScreenModeChange_Setup(void);
/* expects to be called immediately before anything happens to the screen
mode */
extern void GADGET_ScreenModeChange_Cleanup(void);
/* expects to be called immediately after anything happens to the screen
mode */
extern void GADGET_NewOnScreenMessage( ProjChar* messagePtr );
extern void RemoveTheConsolePlease(void);
#else /* UseGadgets */
#define GADGET_Init() ((void) 0)
#define GADGET_UnInit() ((void) 0)
#define GADGET_Render() ((void) 0)
#define GADGET_ScreenModeChange_Setup() ((void) 0)
#define GADGET_ScreenModeChange_Cleanup() ((void) 0)
#define GADGET_NewOnScreenMessage(x) ((void) 0)
#endif /* UseGadgets */
/* End of the header ****************************************************/
#ifdef __cplusplus
};
#endif
#endif

BIN
3dc/avp/win95/gadgets/vssver.scc
View file

Binary file not shown.

BIN
3dc/avp/win95/vssver.scc
View file

Binary file not shown.

834
3dc/avp/win95/winmain.bak
View file

@ -1,834 +0,0 @@
/* Main designed spec for use with windows95*/
#include "3dc.h"
#include "module.h"
#include "inline.h"
#include "stratdef.h"
#include "gamedef.h"
#include "gameplat.h"
#include "bh_types.h"
#include "usr_io.h"
#include "font.h"
/* JH 27/1/97 */
#include "comp_shp.h"
#include "chnkload.hpp"
#include "npcsetup.h" /* JH 30/4/97 */
#include "krender.h"
#include "pldnet.h"
#include "avpview.h"
#include "scrshot.hpp"
#include "language.h"
#include "huddefs.h"
#include "vision.h"
#include "pcmenus.h"
#include "multmenu.h"
#include "menudefs.h"
#include "database.h"
#include "avp_menus.h"
#include "kshape.h"
#define UseLocalAssert Yes
#include "ourasert.h"
#include "ffstdio.h" // fast file stdio
#include "davehook.h"
#include "rebmenus.hpp"
#include "intro.hpp"
#include "showcmds.h"
#include "consbind.hpp"
#include "AvpReg.hpp"
#include "mempool.h"
#include "GammaControl.h"
#include "CDTrackSelection.h"
/*------------Patrick 1/6/97---------------
New sound system
-------------------------------------------*/
#include "psndplat.h"
#define FRAMEAV 100
#include "AvP_UserProfile.h"
#define PROFILING_ON 0
#if PROFILING_ON
#include "pentime.h"
#endif
#if 0
#undef PrintDebuggingText
extern int PrintDebuggingText(const char* t, ...);
#endif
/*
externs for commonly used global variables and arrays
*/
extern int VideoMode;
extern void (*UpdateScreen[]) (void);
extern DISPLAYBLOCK* ActiveBlockList[];
extern SCREENDESCRIPTORBLOCK ScreenDescriptorBlock;
extern void (*SetVideoMode[]) (void);
extern int FrameRate;
extern int WindowRequestMode;
extern int NumActiveBlocks;
int HWAccel = 0;
#if debug
#define MainTextPrint 1
extern int alloc_cnt, deall_cnt;
extern int ItemCount;
int DebugFontLoaded = 0;
extern BOOL ForceLoad_Alien;
extern BOOL ForceLoad_Marine;
extern BOOL ForceLoad_Predator;
extern BOOL ForceLoad_Hugger;
extern BOOL ForceLoad_Queen;
extern BOOL ForceLoad_Civvie;
extern BOOL ForceLoad_PredAlien;
extern BOOL ForceLoad_Xenoborg;
extern BOOL ForceLoad_Pretorian;
extern BOOL ForceLoad_SentryGun;
BOOL UseMouseCentreing = FALSE;
#else
#define MainTextPrint 0
#endif
BOOL KeepMainRifFile=FALSE;
extern void LoadKeyConfiguration();
extern void DeInitialisePlayer();
extern int AvP_MainMenus(void);
extern int AvP_InGameMenus(void);
extern IngameKeyboardInput_ClearBuffer(void);
HINSTANCE AVP_HInstance, hInst;
int AVP_NCmd;
extern unsigned long TotalMemAllocated;
char LevelName[] = {"predbit6\0QuiteALongNameActually"};
static ELO ELOLevelToLoad = {&LevelName};
int QuickStartMultiplayer=1;
int VideoModeNotAvailable=0;
extern int DebuggingCommandsActive;
extern int WindowMode;
void exit_break_point_fucntion ()
{
#if debug
if (WindowMode == WindowModeSubWindow)
{
__asm int 3;
}
#endif
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow)
{
char * instr;
#if debug
int level_to_load = I_Num_Environments;
char * command_line = lpCmdLine;
#endif
AVP_HInstance = hInst = hInstance;
AVP_NCmd = nCmdShow;
AutorunOff();
EnumerateCardsAndVideoModes();
LoadCDTrackList(); //load list of cd tracks assigned to levels , from a text file
// CDDA_Start();
// CDDA_Play(1);
SetFastRandom();
/**** init game now ONLY sets up varibles for the whole
game. If you want to put something in it it must
be something that only needs to be called once
****/
#if debug && 1//!PREDATOR_DEMO
{
#if OverrideOldMenus
{
HWAccel = 1;
}
#else
if(strstr(command_line, "-h"))
{
HWAccel = 1;
}
#endif
//see if any extra npc rif files should be loaded
{
char* strpos=strstr(command_line, "-l");
if(strpos)
{
while(strpos)
{
strpos+=2;
if(*strpos>='a' && *strpos<='z')
{
while(*strpos>='a' && *strpos<='z')
{
switch (*strpos)
{
case 'a':
ForceLoad_Alien = TRUE;
break;
case 'm':
ForceLoad_Marine = TRUE;
break;
case 'p':
ForceLoad_Predator = TRUE;
break;
case 'h':
ForceLoad_Hugger = TRUE;
break;
case 'q':
ForceLoad_Queen = TRUE;
break;
case 'c':
ForceLoad_Civvie = TRUE;
break;
case 'x':
ForceLoad_Xenoborg = TRUE;
break;
case 't':
ForceLoad_Pretorian = TRUE;
break;
case 'r':
ForceLoad_PredAlien = TRUE;
break;
case 's':
ForceLoad_SentryGun = TRUE;
break;
}
strpos++;
}
}
else
{
ForceLoad_Alien = TRUE;
}
strpos=strstr(strpos,"-l");
}
}
}
#ifdef AVP_DEBUG_VERSION
if (strstr(command_line, "-i")) WeWantAnIntro();
if (strstr(command_line, "-qm"))
{
QuickStartMultiplayer = 1;
}
else if (strstr(command_line, "-qa"))
{
QuickStartMultiplayer = 2;
}
else if (strstr(command_line, "-qp"))
{
QuickStartMultiplayer = 3;
}
else
{
QuickStartMultiplayer = 0;
}
if(strstr(command_line,"-keeprif"))
{
KeepMainRifFile=TRUE;
}
if (strstr(command_line, "-m"))
{
UseMouseCentreing = 1;
}
#endif //AVP_DEBUG_VERSION
}
#else
{
#if OverrideOldMenus
{
HWAccel = 1;
}
#endif
}
#endif
if(strstr(command_line,"-server"))
{
extern int DirectPlay_InitLobbiedGame();
//game has been launched by mplayer , we best humour it
LobbiedGame=LobbiedGame_Server;
if(!DirectPlay_InitLobbiedGame())
{
exit(0x6364);
}
}
else if(strstr(command_line,"-client"))
{
extern int DirectPlay_InitLobbiedGame();
//ditto
LobbiedGame=LobbiedGame_Client;
if(!DirectPlay_InitLobbiedGame())
{
exit(0x6364);
}
}
else if (strstr(command_line, "-debug"))
{
DebuggingCommandsActive = 1;
}
// Modified by Edmond for mplayer demo
#if MPLAYER_DEMO
if (!LobbiedGame)
{
MessageBox(NULL, "This demo can only be launched from Mplayer.", "Oh no!", MB_OK);
exit(33445);
}
#endif
#if PLAY_INTRO//(MARINE_DEMO||ALIEN_DEMO||PREDATOR_DEMO)
if (!LobbiedGame) // Edmond
WeWantAnIntro();
#endif
GetPathFromRegistry();
/* JH 28/5/97 */
/* Initialise 'fast' file system */
#if MARINE_DEMO
ffInit("fastfile\\mffinfo.txt","fastfile\\");
#elif ALIEN_DEMO
ffInit("alienfastfile\\ffinfo.txt","alienfastfile\\");
#else
ffInit("fastfile\\ffinfo.txt","fastfile\\");
#endif
InitGame();
/*** Define video mode for windows initialisation ***/
InitialVideoMode();
/****** Put in by John to sort out easy sub window mode ******/
/****** REMOVE FOR GAME!!!!! ******/
#if debug && 1//!PREDATOR_DEMO
if(strstr(command_line, "-w"))
{
WindowRequestMode = WindowModeSubWindow;
if (!HWAccel)
RasterisationRequestMode = RequestSoftwareRasterisation;
}
if(instr = strstr(command_line, "-s"))
sscanf(instr, "-s%d", &level_to_load);
#endif
Env_List[0] = &(ELOLevelToLoad);
level_to_load = 0;
/******* System initialisation **********/
InitialiseSystem(hInstance, nCmdShow);
InitialiseRenderer();
InitOptionsMenu(); /* by this time we know all about the video card, etc */
LoadKeyConfiguration();
/********** Grab The Video mode **********/
/* JH - nope, not yet; not until we start the menus
(or if debugging, start the game), do we need to
set the initial video mode */
/*-------------------Patrick 2/6/97-----------------------
Start the sound system
----------------------------------------------------------*/
SoundSys_Start();
CDDA_Start();
/* kill mouse cursor */
SetCursor(NULL);
/* load language file and setup text string access */
InitTextStrings();
ChangeDirectDrawObject();
AvP.LevelCompleted = 0;
LoadSounds("PLAYER");
#if PREDATOR_DEMO||MARINE_DEMO||ALIEN_DEMO
if(AvP_MainMenus())
#else
while(AvP_MainMenus())
#endif
{
int menusActive=0;
int thisLevelHasBeenCompleted=0;
#if !(PREDATOR_DEMO||MARINE_DEMO||ALIEN_DEMO)
if(instr = strstr(command_line, "-n"))
{
sscanf(instr, "-n %s", &LevelName);
}
#endif
#if debug
if(UseMouseCentreing)
{
//Start thread that recentres mouse , making it easier to play
//in subwindow mode
InitCentreMouseThread();
}
#endif
// Env_List[0] = &(ELOLevelToLoad);
// level_to_load = 0;
// AvP.PlayerType = I_Marine;
/* turn off any special effects */
d3d_light_ctrl.ctrl = LCCM_NORMAL;
d3d_overlay_ctrl.ctrl = OCCM_NORMAL;
/* JH 20/5/97
The video mode is no longer set when exiting the menus
(not necessary if user selects EXIT)
So it is set here */
/********** Grab The Video mode **********/
GetCorrectDirectDrawObject();
if(!SetGameVideoMode())
{
VideoModeNotAvailable=1;
continue;
}
/* Dubious restart hack for DirectDraw problems */
/* JH - I'm not sure this is really necessary
- it only comes into play if you try and set
a video mode which is not supported
BUT we are never going to try and do that
- or are we? */
HandleVideoModeRestarts(hInstance, nCmdShow);
/* Check Gamma Settings are correct after video mode change */
InitialiseGammaSettings(RequestedGammaSetting);
/**** init the chunk loaders ***************/
// no longer required here
// Load precompiled shapes
start_of_loaded_shapes = load_precompiled_shapes();
/*********** Load up the character stuff *******/
InitCharacter();
/* KJL 17:56:14 26/02/98 - load a font required for Dave's HUD */
// LoadPFFont(DATABASE_MESSAGE_FONT);
/*********** Read in the env Map **************/
#if debug
if(level_to_load != I_Num_Environments)
{
if((level_to_load < 0) || (level_to_load > I_Num_Environments))
#ifdef MPLAYER_DEMO
level_to_load = I_Dml1;
#else
level_to_load = I_Sp1;
#endif
AvP.CurrentEnv = AvP.StartingEnv = level_to_load;
}
#endif
LoadRifFile(); /* sets up a map*/
#if debug
DebugFontLoaded = 1;
#endif
/*********** Process the data ************/
AssignAllSBNames();
StartGame();
// UnloadRifFile();//deletes environment File_Chunk since it is no longer needed
/* Patrick 26/6/97
Load the game sounds here: should be done after loading everthing
else, incase sounds take up system memory */
// LoadSounds("PLAYER");
/* JH 28/5/97 */
/* remove resident loaded 'fast' files */
ffcloseall();
/*********** Play the game ***************/
/* KJL 15:43:25 03/11/97 - run until this boolean is set to 0 */
AvP.MainLoopRunning = 1;
ScanImagesForFMVs();
ResetFrameCounter();
Game_Has_Loaded();
ResetFrameCounter();
if(AvP.Network!=I_No_Network)
{
/*Need to choose a starting position for the player , but first we must look
through the network messages to find out which generator spots are currently clear*/
netGameData.myGameState = NGS_Playing;
MinimalNetCollectMessages();
TeleportNetPlayerToAStartingPosition(Player->ObStrategyBlock,1);
}
IngameKeyboardInput_ClearBuffer();
while(AvP.MainLoopRunning)
{
#if debug
#if 0
DumpBoundsCheckInfo(DUMPTOSCREEN);
#endif
#endif
CheckForWindowsMessages();
CursorHome();
#if debug
if (memoryInitialisationFailure)
{
textprint("Initialisation not completed - out of memory!\n");
GLOBALASSERT(1 == 0);
}
#endif
switch(AvP.GameMode)
{
case I_GM_Playing:
{
if ((!menusActive || (AvP.Network!=I_No_Network && !netGameData.skirmishMode)) && !AvP.LevelCompleted)
{
#if MainTextPrint /* debugging stuff */
{
if (ShowDebuggingText.FPS) ReleasePrintDebuggingText("FrameRate = %d fps\n",FrameRate);
if (ShowDebuggingText.Environment) ReleasePrintDebuggingText("Environment %s\n", Env_List[AvP.CurrentEnv]->main);
if (ShowDebuggingText.Coords) ReleasePrintDebuggingText("Player World Coords: %d,%d,%d\n",Player->ObWorld.vx,Player->ObWorld.vy,Player->ObWorld.vz);
{
PLAYER_STATUS *playerStatusPtr= (PLAYER_STATUS *) (Player->ObStrategyBlock->SBdataptr);
PLAYER_WEAPON_DATA *weaponPtr = &(playerStatusPtr->WeaponSlot[playerStatusPtr->SelectedWeaponSlot]);
TEMPLATE_WEAPON_DATA *twPtr = &TemplateWeapon[weaponPtr->WeaponIDNumber];
if (ShowDebuggingText.GunPos)
{
PrintDebuggingText("Gun Position x:%d,y:%d,z:%d\n",twPtr->RestPosition.vx,twPtr->RestPosition.vy,twPtr->RestPosition.vz);
}
}
}
#endif /* MainTextPrint */
DoAllShapeAnimations();
UpdateGame();
#if 1
#if PROFILING_ON
ProfileStart();
#endif
AvpShowViews();
#if PROFILING_ON
ProfileStop("SHOW VIEW");
#endif
//Do screen shot here so that text and hud graphics aren't shown
#if PROFILING_ON
ProfileStart();
#endif
MaintainHUD();
#if PROFILING_ON
ProfileStop("RENDER HUD");
#endif
#if debug
FlushTextprintBuffer();
#endif
//check cd status
CheckCDAndChooseTrackIfNeeded();
// check to see if we're pausing the game;
// if so kill off any sound effects
if(InGameMenusAreRunning() && ( (AvP.Network!=I_No_Network && netGameData.skirmishMode) || (AvP.Network==I_No_Network)) )
SoundSys_StopAll();
}
else
{
ReadUserInput();
// UpdateAllFMVTextures();
SoundSys_Management();
#if SOFTWARE_RENDERER
FlushSoftwareZBuffer();
#else
FlushD3DZBuffer();
#endifÿ
{
extern void ThisFramesRenderingHasBegun(void);
ThisFramesRenderingHasBegun();
}
}
{
menusActive = AvP_InGameMenus();
if(AvP.RestartLevel) menusActive=0;
}
if (AvP.LevelCompleted)
{
SoundSys_FadeOutFast();
DoCompletedLevelStatisticsScreen();
thisLevelHasBeenCompleted = 1;
}
{
/* after this call, no more graphics can be drawn until the next frame */
extern void ThisFramesRenderingHasFinished(void);
ThisFramesRenderingHasFinished();
}
/* JH 5/6/97 - this function may draw translucent polygons to the whole screen */
//HandleD3DScreenFading();
#else
{
ColourFillBackBuffer(0);
}
#endif
InGameFlipBuffers();
FrameCounterHandler();
{
PLAYER_STATUS *playerStatusPtr= (PLAYER_STATUS *) (Player->ObStrategyBlock->SBdataptr);
if (!menusActive && playerStatusPtr->IsAlive && !AvP.LevelCompleted)
{
DealWithElapsedTime();
}
}
break;
}
case I_GM_Menus:
{
AvP.GameMode = I_GM_Playing;
//StartGameMenus();
LOCALASSERT(AvP.Network == I_No_Network);
//AccessDatabase(0);
break;
}
#if 0
case I_GM_Paused:
{
{
extern void DoPcPause(void);
DoPcPause();
}
break;
}
#endif
default:
{
GLOBALASSERT(2<1);
break;
}
}
if(AvP.RestartLevel)
{
AvP.RestartLevel=0;
AvP.LevelCompleted = 0;
FixCheatModesInUserProfile(UserProfilePtr);
RestartLevel();
}
}// end of main game loop
{
AvP.LevelCompleted = thisLevelHasBeenCompleted;
}
FixCheatModesInUserProfile(UserProfilePtr);
#if !(PREDATOR_DEMO||MARINE_DEMO||ALIEN_DEMO)
TimeStampedMessage("We're out of the main loop");
/* KJL 17:56:14 26/02/98 - unload a font required for Dave's HUD */
// UnloadFont(&AvpFonts[DATABASE_MESSAGE_FONT]);
#if 1
{
extern void CloseFMV(void);
CloseFMV();
ReleaseAllFMVTextures();
}
#endif
/* DHM 23/3/98 */
// REBMENUS_ProjectSpecific_EndOfMainLoopHook();
/* DHM 8/4/98 */
CONSBIND_WriteKeyBindingsToConfigFile();
TimeStampedMessage("After key bindings writen");
/* CDF 2/10/97 */
DeInitialisePlayer();
TimeStampedMessage("After DeInitialisePlayer");
DeallocatePlayersMirrorImage();
TimeStampedMessage("After DeallocatePlayersMirrorImage");
/* KJL 15:26:43 03/12/97 - clear data */
KillHUD();
TimeStampedMessage("After KillHUD");
Destroy_CurrentEnvironment();
TimeStampedMessage("After Destroy_CurrentEnvironment");
DeallocateAllImages();
TimeStampedMessage("After DeallocateAllImages");
EndNPCs(); /* JH 30/4/97 - unload npc rifs */
TimeStampedMessage("After EndNPCs");
ExitGame();
#endif
/* Patrick 26/6/97
Stop and remove all game sounds here, since we are returning to the menus */
SoundSys_StopAll();
ResetEaxEnvironment();
//make sure the volume gets reset for the menus
SoundSys_ResetFadeLevel();
TimeStampedMessage("After SoundSys_StopAll");
// SoundSys_RemoveAll();
TimeStampedMessage("After SoundSys_RemoveAll");
CDDA_Stop();
TimeStampedMessage("After CDDA_Stop");
/* netgame support */
#if SupportWindows95 /* call me paranoid */
if(AvP.Network != I_No_Network)
{
/* we cleanup and reset our game mode here, at the end of the game loop, as other
clean-up functions need to know if we've just exited a netgame */
EndAVPNetGame();
//EndOfNetworkGameScreen();
}
#endif
//need to get rid of the player rifs before we can clear the memory pool
ClearMemoryPool();
#if debug
if(UseMouseCentreing)
{
//Stop thread that recentres mouse , making it easier to play
//in subwindow mode
FinishCentreMouseThread();
}
#endif
if(LobbiedGame)
{
/*
We have been playing a lobbied game , and have now diconnected.
Since we can't start a new multiplayer game , exit to avoid confusion
*/
break;
}
}
#if !(PREDATOR_DEMO||MARINE_DEMO||ALIEN_DEMO)
TimeStampedMessage("After Menus");
/* Added 28/1/98 by DHM: hook for my code on program shutdown */
{
DAVEHOOK_UnInit();
}
TimeStampedMessage("After DAVEHOOK_UnInit");
/*-------------------Patrick 2/6/97-----------------------
End the sound system
----------------------------------------------------------*/
SoundSys_StopAll();
SoundSys_RemoveAll();
#else
QuickSplashScreens();
#endif
#if !(PREDATOR_DEMO||MARINE_DEMO||ALIEN_DEMO)
TimeStampedMessage("After SoundSys_End");
TimeStampedMessage("After CDDA_End");
/* unload language file */
// KillTextStrings();
// TimeStampedMessage("After KillTextStrings");
ExitSystem();
TimeStampedMessage("After ExitSystem");
// ffKill(); /* to avoid misreported memory leaks */
TimeStampedMessage("After ffKill");
#else
SoundSys_End();
ReleaseDirect3D();
//TimeStampedMessage("after ReleaseDirect3D");
/* Kill windows procedures */
ExitWindowsSystem();
//TimeStampedMessage("after ExitWindowsSystem");
#endif
CDDA_End();
ClearMemoryPool();
AutorunOn();
return(0);
}

BIN
3dc/binkw32.dll
View file

Binary file not shown.

BIN
3dc/binkw32.lib
View file

Binary file not shown.

BIN
3dc/dialog.dll
View file

Binary file not shown.

BIN
3dc/dialog.lib
View file

Binary file not shown.

BIN
3dc/ia3d.lib
View file

Binary file not shown.

BIN
3dc/include/vssver.scc
View file

Binary file not shown.

BIN
3dc/plddpvc.dll
View file

Binary file not shown.

1
3dc/plddpvc.lnk
View file

@ -1 +0,0 @@
import '_InvokeDavesDirectPlayDLL@4' plddpvc.InvokeDavesDirectPlayDLL

147
3dc/readme.txt
View file

@ -1,147 +0,0 @@
***********************************************************************
ALIENS VERSUS PREDATOR GOLD
***********************************************************************
About This Document:
This document contains last-minute information about Aliens versus Predator, if you have any questions, check to see if it is addressed here first.
************************************************************************
I. MINIMUM REQUIREMENTS
II. GENERAL TECHNICAL ISSUES
III. TROUBLE SHOOTING GENERAL GAME ISSUES
IV. MULTI-PLAYER
V. CONTACTING FOX INTERACTIVE
I: MINIMUM REQUIREMENTS
The following information is the minimum hardware requirement needed to run Aliens vs. Predator.
Pentium 200 MMX, 32 MB RAM
Windows 95/98
300MB Hard Disk space
4x CD ROM
Direct3D Supported 3D Graphics Card, at least 4MB video memory.
DirectSound compatible sound card.
Mouse, Keyboard and any DirectX supported controllers
Internet access (only required for multi-player games), TCP/IP, IPX LAN Card or minimum 33.6 kbps modem.
Aliens versus Predator requires DirectX 6 or higher to run properly. If you already have DirectX 6 choose no when prompted during the installation. Should you decide to install it at a later time you can run the DXSETUP program located in the DirectX folder on Aliens versus Predator, Disc 1.
II: GENERAL TECHNICAL ISSUES
Here is a list of some of the known technical problems you might encounter.
Graphics Cards:
Aliens versus Predator detects multiple Graphics cards and the resolution settings they are capable of. Although the user can select the highest resolution setting possible, the game may not be able to run due to memory limitations on the video card. For example: users with only one Voodoo2 card will be see the option to select 1024 x 768, but will not be able to play the game in this resolution. In order to run at that resolution two Voodoo2 cards are needed. To fix this simply select the next resolution down until you find one which will work.
ATI RAGE128 chipsets:
With the drivers that shipped with some cards, there may be graphical corruption such as in the Main Menu. The game may also crash when the user tries to enter the game. ATI Technologies is aware of this problem and there are drivers that correct it. Go to http://www.atitech.ca/ca_us/betadrv to obtain the latest drivers.
Nvidia Riva128 chipsets:
Aliens versus Predator makes use of blend modes that are not simultaneously supported by the Riva chipset. Nvidia is aware of this problem and are looking into providing support with new drivers. Go to http://www.nvidia.com to obtain the latest drivers.
Voodoo 1 in combination with SR 9 (Savage 4):
Texture corruption is sometimes observed in game when the Voodoo 1 card is selected. We recommend using the SR 9 card instead as this does not exhibit the same problems in this situation.
Sound Cards:
Creative Labs SoundBlaster Live:
Currently when exiting the game, windows 95/98 will sometimes crash with a blue screen error message. This problem has been corrected and Creative Labs have released a new driver that corrects this problem. Go to http://www.sblive.com
Peripherals:
Logitech Mouse with 3rd button mouse wheel - when trying to assign a key to the middle mouse button, it may assign this function to "Mouse1" or "Mouse2". To function as a third mouse button "Mouse3" make sure that you have the latest drivers from Logitech (http://www.logitech.com). Also access the Windows Control Panel and double-click Mouse (Click Start, Settings, Control Panel, Mouse) to access Logitech Mouse Properties and click on the buttons tab. Go into the "Button Assignment 2" menu and select "Middle Button". This will enable the 3rd mouse button within Aliens versus Predator.
Microsoft Sidewinder Force Feedback Controllers:
Although these controllers function without any known problems, Force Feedback is not currently supported in Aliens versus Predator.
NOTE: Make sure you have installed the most recent drivers for all your hardware before playing Aliens Versus Predator, this will help avoid most issues.
Windows 95/98 Issues:
When pressing ALT+TAB and/or the Windows Key on keyboards Aliens versus Predator will minimize. Problems may occur when minimizing Single and Multiplayer games so this is NOT recommended.
Because Alien Vs Predator is using Red Book audio (CD music) there is an occasional pause when ever the CD seeks to a new track. This is a general Windows problem, there is no work around for this.
III: TROUBLE SHOOTING GENERAL GAME ISSUES
Question: I'm getting low frame rate when playing Aliens vs. Predator what's wrong?
a) Did you try defragging your hard drive before installing Aliens versus Predator?
b) Do you have multiple applications running in the background on WIN 95/98? Check your taskbar and see if applications can be closed or disabled like Virus Scanners and other utilities in Windows. Programs running in your task bar use system resources, to check your system resources, right click your mouse over the My Computer icon, select properties, Performance, if it's less than 80% you may encounter some problems.
c) Select a lower screen resolution setting in the game.
d) Did you set all the Details Settings to Very Low or Off?
Question: I put in the Music CD but I'm not hearing any background music.
a) Is autoplay enabled for your CD-ROM? If so, chances are that Windows Music Player or other Audio player was initiated. This frequently occurs when the Music CD is inserted before executing Aliens versus Predator. Simply exit out of the audio player before starting Aliens vs. Predator.
b) Check and make sure that the CD Volume Slider in Aliens versus Predator is all the way to the right. If you still don't hear any music while your in the game, exit out to Windows and go into the Control Panel (Start, Setting, Control Panel). Now double click the Multimedia Icon and select the "CD Music" tab. Make sure that the volume slider is all the way to the right.
c)If your machine has multiple CD-ROM drives (CD-Writers, DVD-ROMS) they are sometimes selected as the main audio source. Even though systems may play music CD's just fine when not playing the game, make sure you assign the correct Drive letter to be your source drive to hear in-game music. You can do this by going to the Start Menu, Settings, Control Panel, Multimedia. Now select the CD-Music tab and change the drive letter accordingly to where you placed your music CD.
Question: My game keeps pausing for a second, what's going on?
a)Because Alien versus Predator uses Red Book audio (CD music), there is an occasional pause whenever the CD seeks to a new track. This is a general Windows problem, there is no known work around for this.
Question: What can I do if the game is too dark?.
a) By nature the Alien versus Predator environments are meant to be dark and scary. Certain sections of the game are designed to be so dark that you are forced to use different vision modes to compensate. If you are having trouble seeing things generally you will find a gamma correction utility in the Video Options menu in the game. Try different settings until you find one you like.
IV. MULTI-PLAYER
Aliens Versus Predator has an eight player maximum limit. Because of the amount of information being transferred some lower end machines might experience lag and very choppy game play. Some things can be done to help this, however, the basis of a fast game is still dependant on the host's machine speed. The faster the machine the better the play.
To compensate for laggy network play the host can designate several resource-saving options. When you get ready to host a multi-player game, there is a large list of options for tweaking, every machine is different and responds better or worse to specific changes. Things like locking out the use of the flamethrower will help reduce slow down on all machines. We recommend trying out different settings until you find the one that best fits you machine.
V. CONTACTING FOX INTERACTIVE
In the rare case that you should receive a defective disc or discs, you should first attempt to return it to the store from which you bought it, taking with you your receipt. If, however, you fail in your quest, you can write to us, call us or email us at the following locations.
Fox Interactive
P.O. Box 900
Beverly Hills, Ca 90213-0900
Or call 970-522-5369
For more information visit our web site.
www.foxinteractive.com
Fox Interactive would like to thank you for purchasing this title.

BIN
3dc/vssver.scc
View file

Binary file not shown.

433
3dc/win95/SMACK.H
View file

@ -1,433 +0,0 @@
#ifndef SMACKH
#define SMACKH
#define SMACKVERSION "3.1s"
#ifndef __RADRES__
#include "rad.h"
RADDEFSTART
typedef struct SmackTag {
u32 Version; // SMK2 only right now
u32 Width; // Width (1 based, 640 for example)
u32 Height; // Height (1 based, 480 for example)
u32 Frames; // Number of frames (1 based, 100 = 100 frames)
u32 MSPerFrame; // Frame Rate
u32 SmackerType; // bit 0 set=ring frame
u32 LargestInTrack[7]; // Largest single size for each track
u32 tablesize; // Size of the init tables
u32 codesize; // Compression info
u32 absize; // ditto
u32 detailsize; // ditto
u32 typesize; // ditto
u32 TrackType[7]; // high byte=0x80-Comp,0x40-PCM data,0x20-16 bit,0x10-stereo
u32 extra; // extra value (should be zero)
u32 NewPalette; // set to one if the palette changed
u8 Palette[772]; // palette data
u32 PalType; // type of palette
u32 FrameNum; // Frame Number to be displayed
u32 FrameSize; // The current frame's size in bytes
u32 SndSize; // The current frame sound tracks' size in bytes
s32 LastRectx; // Rect set in from SmackToBufferRect (X coord)
s32 LastRecty; // Rect set in from SmackToBufferRect (Y coord)
s32 LastRectw; // Rect set in from SmackToBufferRect (Width)
s32 LastRecth; // Rect set in from SmackToBufferRect (Height)
u32 OpenFlags; // flags used on open
u32 LeftOfs; // Left Offset used in SmackTo
u32 TopOfs; // Top Offset used in SmackTo
u32 LargestFrameSize; // Largest frame size
u32 Highest1SecRate; // Highest 1 sec data rate
u32 Highest1SecFrame; // Highest 1 sec data rate starting frame
u32 ReadError; // Set to non-zero if a read error has ocurred
u32 addr32; // translated address for 16 bit interface
} Smack;
#define SmackHeaderSize(smk) ((((u8*)&((smk)->extra))-((u8*)(smk)))+4)
typedef struct SmackSumTag {
u32 TotalTime; // total time
u32 MS100PerFrame; // MS*100 per frame (100000/MS100PerFrame=Frames/Sec)
u32 TotalOpenTime; // Time to open and prepare for decompression
u32 TotalFrames; // Total Frames displayed
u32 SkippedFrames; // Total number of skipped frames
u32 SoundSkips; // Total number of sound skips
u32 TotalBlitTime; // Total time spent blitting
u32 TotalReadTime; // Total time spent reading
u32 TotalDecompTime; // Total time spent decompressing
u32 TotalBackReadTime; // Total time spent reading in background
u32 TotalReadSpeed; // Total io speed (bytes/second)
u32 SlowestFrameTime; // Slowest single frame time
u32 Slowest2FrameTime; // Second slowest single frame time
u32 SlowestFrameNum; // Slowest single frame number
u32 Slowest2FrameNum; // Second slowest single frame number
u32 AverageFrameSize; // Average size of the frame
u32 HighestMemAmount; // Highest amount of memory allocated
u32 TotalExtraMemory; // Total extra memory allocated
u32 HighestExtraUsed; // Highest extra memory actually used
} SmackSum;
//=======================================================================
#define SMACKNEEDPAN 0x00020L // Will be setting the pan
#define SMACKNEEDVOLUME 0x00040L // Will be setting the volume
#define SMACKFRAMERATE 0x00080L // Override fr (call SmackFrameRate first)
#define SMACKLOADEXTRA 0x00100L // Load the extra buffer during SmackOpen
#define SMACKPRELOADALL 0x00200L // Preload the entire animation
#define SMACKNOSKIP 0x00400L // Don't skip frames if falling behind
#define SMACKSIMULATE 0x00800L // Simulate the speed (call SmackSim first)
#define SMACKFILEHANDLE 0x01000L // Use when passing in a file handle
#define SMACKTRACK1 0x02000L // Play audio track 1
#define SMACKTRACK2 0x04000L // Play audio track 2
#define SMACKTRACK3 0x08000L // Play audio track 3
#define SMACKTRACK4 0x10000L // Play audio track 4
#define SMACKTRACK5 0x20000L // Play audio track 5
#define SMACKTRACK6 0x40000L // Play audio track 6
#define SMACKTRACK7 0x80000L // Play audio track 7
#define SMACKTRACKS (SMACKTRACK1|SMACKTRACK2|SMACKTRACK3|SMACKTRACK4|SMACKTRACK5|SMACKTRACK6|SMACKTRACK7)
#define SMACKBUFFERREVERSED 0x00000001
#define SMACKBUFFER555 0x80000000
#define SMACKBUFFER565 0xc0000000
#define SMACKBUFFER16 (SMACKBUFFER555|SMACKBUFFER565)
#define SMACKYINTERLACE 0x100000L // Force interleaving Y scaling
#define SMACKYDOUBLE 0x200000L // Force doubling Y scaling
#define SMACKYNONE (SMACKYINTERLACE|SMACKYDOUBLE) // Force normal Y scaling
#define SMACKFILEISSMK 0x2000000L // Internal flag for 16 to 32 bit thunking
#define SMACKAUTOEXTRA 0xffffffffL // NOT A FLAG! - Use as extrabuf param
//=======================================================================
#define SMACKSURFACEFAST 0
#define SMACKSURFACESLOW 1
#define SMACKSURFACEDIRECT 2
RADEXPFUNC Smack PTR4* RADEXPLINK SmackOpen(const char PTR4* name,u32 flags,u32 extrabuf);
#ifdef __RADMAC__
#include <files.h>
RADEXPFUNC Smack PTR4* RADEXPLINK SmackMacOpen(FSSpec* fsp,u32 flags,u32 extrabuf);
#endif
RADEXPFUNC u32 RADEXPLINK SmackDoFrame(Smack PTR4* smk);
RADEXPFUNC void RADEXPLINK SmackNextFrame(Smack PTR4* smk);
RADEXPFUNC u32 RADEXPLINK SmackWait(Smack PTR4* smk);
RADEXPFUNC void RADEXPLINK SmackClose(Smack PTR4* smk);
RADEXPFUNC void RADEXPLINK SmackVolumePan(Smack PTR4* smk, u32 trackflag,u32 volume,u32 pan);
RADEXPFUNC void RADEXPLINK SmackSummary(Smack PTR4* smk,SmackSum PTR4* sum);
RADEXPFUNC u32 RADEXPLINK SmackSoundInTrack(Smack PTR4* smk,u32 trackflags);
RADEXPFUNC u32 RADEXPLINK SmackSoundOnOff(Smack PTR4* smk,u32 on);
#ifndef __RADMAC__
RADEXPFUNC void RADEXPLINK SmackToScreen(Smack PTR4* smk,u32 left,u32 top,u32 BytePS,const u16 PTR4* WinTbl,void* SetBank,u32 Flags);
#endif
RADEXPFUNC void RADEXPLINK SmackToBuffer(Smack PTR4* smk,u32 left,u32 top,u32 Pitch,u32 destheight,const void PTR4* buf,u32 Flags);
RADEXPFUNC u32 RADEXPLINK SmackToBufferRect(Smack PTR4* smk, u32 SmackSurface);
RADEXPFUNC void RADEXPLINK SmackGoto(Smack PTR4* smk,u32 frame);
RADEXPFUNC void RADEXPLINK SmackColorRemap(Smack PTR4* smk,const void PTR4* remappal,u32 numcolors,u32 paltype);
RADEXPFUNC void RADEXPLINK SmackColorTrans(Smack PTR4* smk,const void PTR4* trans);
RADEXPFUNC void RADEXPLINK SmackFrameRate(u32 forcerate);
RADEXPFUNC void RADEXPLINK SmackSimulate(u32 sim);
RADEXPFUNC u32 RADEXPLINK SmackGetTrackData(Smack PTR4* smk,void PTR4* dest,u32 trackflag);
RADEXPFUNC void RADEXPLINK SmackSoundCheck(void);
//======================================================================
// the functions for the new SmackBlit API
typedef struct _SMACKBLIT PTR4* HSMACKBLIT;
typedef struct _SMACKBLIT {
u32 Flags;
u8 PTR4* Palette;
u32 PalType;
u16 PTR4* SmoothTable;
u16 PTR4* Conv8to16Table;
u32 whichmode;
u32 palindex;
u32 t16index;
u32 smoothindex;
u32 smoothtype;
u32 firstpalette;
} SMACKBLIT;
#define SMACKBLIT1X 1
#define SMACKBLIT2X 2
#define SMACKBLIT2XSMOOTHING 4
#define SMACKBLIT2XINTERLACE 8
RADEXPFUNC HSMACKBLIT RADEXPLINK SmackBlitOpen(u32 flags);
RADEXPFUNC void RADEXPLINK SmackBlitSetPalette(HSMACKBLIT sblit, void PTR4* Palette,u32 PalType);
RADEXPFUNC u32 RADEXPLINK SmackBlitSetFlags(HSMACKBLIT sblit,u32 flags);
RADEXPFUNC void RADEXPLINK SmackBlit(HSMACKBLIT sblit,void PTR4* dest, u32 destpitch, u32 destx, u32 desty, void PTR4* src, u32 srcpitch, u32 srcx, u32 srcy, u32 srcw, u32 srch);
RADEXPFUNC void RADEXPLINK SmackBlitClear(HSMACKBLIT sblit,void PTR4* dest, u32 destpitch, u32 destx, u32 desty, u32 destw, u32 desth, s32 color);
RADEXPFUNC void RADEXPLINK SmackBlitClose(HSMACKBLIT sblit);
RADEXPFUNC void RADEXPLINK SmackBlitTrans(HSMACKBLIT sblit,void PTR4* dest, u32 destpitch, u32 destx, u32 desty, void PTR4* src, u32 srcpitch, u32 srcx, u32 srcy, u32 srcw, u32 srch, u32 trans);
RADEXPFUNC void RADEXPLINK SmackBlitMask(HSMACKBLIT sblit,void PTR4* dest, u32 destpitch, u32 destx, u32 desty, void PTR4* src, u32 srcpitch, u32 srcx, u32 srcy, u32 srcw, u32 srch, u32 trans,void PTR4* mask);
RADEXPFUNC void RADEXPLINK SmackBlitMerge(HSMACKBLIT sblit,void PTR4* dest, u32 destpitch, u32 destx, u32 desty, void PTR4* src, u32 srcpitch, u32 srcx, u32 srcy, u32 srcw, u32 srch, u32 trans,void PTR4* back);
RADEXPFUNC char PTR4* RADEXPLINK SmackBlitString(HSMACKBLIT sblit,char PTR4* dest);
#ifndef __RADMAC__
RADEXPFUNC u32 RADEXPLINK SmackUseMMX(u32 flag); //0=off, 1=on, 2=query current
#endif
//======================================================================
#ifdef __RADDOS__
#define SMACKSOUNDNONE -1
extern void* SmackTimerSetupAddr;
extern void* SmackTimerReadAddr;
extern void* SmackTimerDoneAddr;
typedef void RADEXPLINK (*SmackTimerSetupType)(void);
typedef u32 RADEXPLINK (*SmackTimerReadType)(void);
typedef void RADEXPLINK (*SmackTimerDoneType)(void);
#define SmackTimerSetup() ((SmackTimerSetupType)(SmackTimerSetupAddr))()
#define SmackTimerRead() ((SmackTimerReadType)(SmackTimerReadAddr))()
#define SmackTimerDone() ((SmackTimerDoneType)(SmackTimerDoneAddr))()
RADEXPFUNC u8 RADEXPLINK SmackSoundUseMSS(void* DigDriver);
#ifndef AIL_startup
#ifdef __SW_3R
extern s32 cdecl AIL_startup_reg(void);
#define AIL_startup AIL_startup_reg
#else
extern s32 cdecl AIL_startup_stack(void);
#define AIL_startup AIL_startup_stack
#endif
#endif
#define SmackSoundMSSLiteInit() SmackSoundMSSLiteInitWithStart(&AIL_startup);
RADEXPFUNC void RADEXPLINK SmackSoundMSSLiteInitWithStart(void* start);
RADEXPFUNC void RADEXPLINK SmackSoundMSSLiteDone(void);
RADEXPFUNC u8 RADEXPLINK SmackSoundUseSOS3r(u32 SOSDriver,u32 MaxTimerSpeed);
RADEXPFUNC u8 RADEXPLINK SmackSoundUseSOS3s(u32 SOSDriver,u32 MaxTimerSpeed);
RADEXPFUNC u8 RADEXPLINK SmackSoundUseSOS4r(u32 SOSDriver,u32 MaxTimerSpeed);
RADEXPFUNC u8 RADEXPLINK SmackSoundUseSOS4s(u32 SOSDriver,u32 MaxTimerSpeed);
#ifdef __SW_3R
#define SmackSoundUseSOS3 SmackSoundUseSOS3r
#define SmackSoundUseSOS4 SmackSoundUseSOS4r
#else
#define SmackSoundUseSOS3 SmackSoundUseSOS3s
#define SmackSoundUseSOS4 SmackSoundUseSOS4s
#endif
#else
#define SMACKRESRESET 0
#define SMACKRES640X400 1
#define SMACKRES640X480 2
#define SMACKRES800X600 3
#define SMACKRES1024X768 4
RADEXPFUNC u32 RADEXPLINK SmackSetSystemRes(u32 mode); // use SMACKRES* values
#define SMACKNOCUSTOMBLIT 128
#define SMACKSMOOTHBLIT 256
#define SMACKINTERLACEBLIT 512
#ifdef __RADMAC__
#include <windows.h>
#include <palettes.h>
#include <qdoffscreen.h>
#define SmackTimerSetup()
#define SmackTimerDone()
RADEXPFUNC u32 RADEXPLINK SmackTimerRead(void);
RADEXPFUNC s32 RADEXPLINK SmackGDSurfaceType( GDHandle gd );
#define SMACKAUTOBLIT 0
#define SMACKDIRECTBLIT 1
#define SMACKGWORLDBLIT 2
typedef struct SmackBufTag {
u32 Reversed;
u32 SurfaceType; // SMACKSURFACExxxxxx
u32 BlitType; // SMACKxxxxxBLIT
u32 Width;
u32 Height;
u32 Pitch;
u32 Zoomed;
u32 ZWidth;
u32 ZHeight;
u32 DispColors; // colors on screen
u32 MaxPalColors;
u32 PalColorsInUse;
u32 StartPalColor;
u32 EndPalColor;
void* Buffer;
void* Palette;
u32 PalType;
u32 SoftwareCursor;
WindowPtr wp;
GWorldPtr gwp;
CTabHandle cth;
PaletteHandle palh;
GDHandle gd;
u32 gdSurfaceType;
HSMACKBLIT sblit;
void * ScreenAddr;
u32 ScreenPitch;
s32 manyblits;
s32 PTR4* blitrects;
s32 PTR4* rectsptr;
s32 maxrects;
s32 numrects;
} SmackBuf;
#else
#ifdef __RADWIN__
#define INCLUDE_MMSYSTEM_H
#include "windows.h"
#include "windowsx.h"
#ifdef __RADNT__ // to combat WIN32_LEAN_AND_MEAN
#include "mmsystem.h"
RADEXPFUNC s32 RADEXPLINK SmackDDSurfaceType(void* lpDDS);
#endif
#define SMACKAUTOBLIT 0
#define SMACKFULL320X240BLIT 1
#define SMACKFULL320X200BLIT 2
#define SMACKFULL320X200DIRECTBLIT 3
#define SMACKSTANDARDBLIT 4
#define SMACKWINGBLIT 5
#define SMACKDIBSECTIONBLIT 5
#define WM_SMACKACTIVATE WM_USER+0x5678
typedef struct SmackBufTag {
u32 Reversed; // 1 if the buffer is upside down
u32 SurfaceType; // SMACKSURFACExxxx defines
u32 BlitType; // SMACKxxxxBLIT defines
u32 FullScreen; // 1 if full-screen
u32 Width;
u32 Height;
u32 Pitch;
u32 Zoomed;
u32 ZWidth;
u32 ZHeight;
u32 DispColors; // colors on the screen
u32 MaxPalColors; // total possible colors in palette (usually 256)
u32 PalColorsInUse; // Used colors in palette (usually 236)
u32 StartPalColor; // first usable color index (usually 10)
u32 EndPalColor; // last usable color index (usually 246)
RGBQUAD Palette[256];
u32 PalType;
u32 forceredraw; // force a complete redraw on next blit (for >8bit)
u32 didapalette; // force an invalidate on the next palette change
void PTR4* Buffer;
void PTR4* DIBRestore;
u32 OurBitmap;
u32 OrigBitmap;
u32 OurPalette;
u32 WinGDC;
u32 FullFocused;
u32 ParentHwnd;
u32 OldParWndProc;
u32 OldDispWndProc;
u32 DispHwnd;
u32 WinGBufHandle;
void PTR4* lpDD;
void PTR4* lpDDSP;
u32 DDSurfaceType;
HSMACKBLIT DDblit;
s32 ddSoftwarecur;
s32 didaddblit;
s32 lastwasdd;
RECT ddscreen;
s32 manyblits;
s32 PTR4* blitrects;
s32 PTR4* rectsptr;
s32 maxrects;
s32 numrects;
HDC lastdc;
} SmackBuf;
RADEXPFUNC void RADEXPLINK SmackGet(Smack PTR4* smk,void PTR4* dest);
RADEXPFUNC void RADEXPLINK SmackBufferGet( SmackBuf PTR4* sbuf, void PTR4* dest);
RADEXPFUNC u8 RADEXPLINK SmackSoundUseMSS(void PTR4* dd);
RADEXPFUNC u8 RADEXPLINK SmackSoundUseDirectSound(void PTR4* dd); // NULL=Create
RADEXPFUNC void RADEXPLINK SmackSoundSetDirectSoundHWND(HWND hw);
RADEXPFUNC u8 RADEXPLINK SmackSoundUseDW(u32 openfreq, u32 openbits, u32 openchans);
#define SmackTimerSetup()
#define SmackTimerDone()
#define SmackTimerRead timeGetTime
#endif
#endif
#ifdef __RADMAC__
RADEXPFUNC SmackBuf PTR4* RADEXPLINK SmackBufferOpen( WindowPtr wp, u32 BlitType, u32 width, u32 height, u32 ZoomW, u32 ZoomH );
RADEXPFUNC u32 RADEXPLINK SmackBufferBlit( SmackBuf PTR4* sbuf, s32 hwndx, s32 hwndy, s32 subx, s32 suby, s32 subw, s32 subh );
RADEXPFUNC void RADEXPLINK SmackBufferFromScreen( SmackBuf PTR4* destbuf, s32 x, s32 y);
RADEXPFUNC s32 RADEXPLINK SmackIsSoftwareCursor(GDHandle gd);
RADEXPFUNC s32 RADEXPLINK SmackCheckCursor(WindowPtr wp,s32 x,s32 y,s32 w,s32 h);
RADEXPFUNC void RADEXPLINK SmackRestoreCursor(s32 checkcount);
#else
RADEXPFUNC SmackBuf PTR4* RADEXPLINK SmackBufferOpen( HWND wnd, u32 BlitType, u32 width, u32 height, u32 ZoomW, u32 ZoomH );
RADEXPFUNC u32 RADEXPLINK SmackBufferBlit( SmackBuf PTR4* sbuf, HDC dc, s32 hwndx, s32 hwndy, s32 subx, s32 suby, s32 subw, s32 subh );
RADEXPFUNC void RADEXPLINK SmackBufferFromScreen( SmackBuf PTR4* destbuf, HWND hw, s32 x, s32 y);
RADEXPFUNC s32 RADEXPLINK SmackIsSoftwareCursor(void* lpDDSP,HCURSOR cur);
RADEXPFUNC s32 RADEXPLINK SmackCheckCursor(HWND wnd,s32 x,s32 y,s32 w,s32 h);
RADEXPFUNC void RADEXPLINK SmackRestoreCursor(s32 checkcount);
#endif
RADEXPFUNC void RADEXPLINK SmackBufferStartMultipleBlits( SmackBuf PTR4* sbuf );
RADEXPFUNC void RADEXPLINK SmackBufferEndMultipleBlits( SmackBuf PTR4* sbuf );
RADEXPFUNC char PTR4* RADEXPLINK SmackBufferString(SmackBuf PTR4* sb,char PTR4* dest);
RADEXPFUNC void RADEXPLINK SmackBufferNewPalette( SmackBuf PTR4* sbuf, const void PTR4* pal, u32 paltype );
RADEXPFUNC u32 RADEXPLINK SmackBufferSetPalette( SmackBuf PTR4* sbuf );
RADEXPFUNC void RADEXPLINK SmackBufferClose( SmackBuf PTR4* sbuf );
RADEXPFUNC void RADEXPLINK SmackBufferClear( SmackBuf PTR4* destbuf, u32 color);
RADEXPFUNC void RADEXPLINK SmackBufferToBuffer( SmackBuf PTR4* destbuf, s32 destx, s32 desty, const SmackBuf PTR4* sourcebuf,s32 sourcex,s32 sourcey,s32 sourcew,s32 sourceh);
RADEXPFUNC void RADEXPLINK SmackBufferToBufferTrans( SmackBuf PTR4* destbuf, s32 destx, s32 desty, const SmackBuf PTR4* sourcebuf,s32 sourcex,s32 sourcey,s32 sourcew,s32 sourceh,u32 TransColor);
RADEXPFUNC void RADEXPLINK SmackBufferToBufferMask( SmackBuf PTR4* destbuf, s32 destx, s32 desty, const SmackBuf PTR4* sourcebuf,s32 sourcex,s32 sourcey,s32 sourcew,s32 sourceh,u32 TransColor,const SmackBuf PTR4* maskbuf);
RADEXPFUNC void RADEXPLINK SmackBufferToBufferMerge( SmackBuf PTR4* destbuf, s32 destx, s32 desty, const SmackBuf PTR4* sourcebuf,s32 sourcex,s32 sourcey,s32 sourcew,s32 sourceh,u32 TransColor,const SmackBuf PTR4* mergebuf);
RADEXPFUNC void RADEXPLINK SmackBufferCopyPalette( SmackBuf PTR4* destbuf, SmackBuf PTR4* sourcebuf, u32 remap);
RADEXPFUNC u32 RADEXPLINK SmackBufferFocused( SmackBuf PTR4* sbuf);
#endif
RADDEFEND
#endif
#endif

208
3dc/win95/bink.c
View file

@ -1,208 +0,0 @@
/* Bink! player, KJL 99/4/30 */
#include "bink.h"
#include "3dc.h"
#include "d3_func.h"
#define UseLocalAssert 1
#include "ourasert.h"
extern char *ScreenBuffer;
extern LPDIRECTSOUND DSObject;
extern int GotAnyKey;
extern int IntroOutroMoviesAreActive;
extern DDPIXELFORMAT DisplayPixelFormat;
extern void DirectReadKeyboard(void);
static int BinkSurfaceType;
void PlayBinkedFMV(char *filenamePtr)
{
BINK* binkHandle;
int playing = 1;
if (!IntroOutroMoviesAreActive) return;
// if (!IntroOutroMoviesAreActive) return;
BinkSurfaceType = GetBinkPixelFormat();
/* skip FMV if surface type not supported */
if (BinkSurfaceType == -1) return;
/* use Direct sound */
BinkSoundUseDirectSound(DSObject);
/* open smacker file */
binkHandle = BinkOpen(filenamePtr,0);
if (!binkHandle)
{
char message[100];
sprintf(message,"Unable to access file: %s\n",filenamePtr);
MessageBox(NULL,message,"AvP Error",MB_OK+MB_SYSTEMMODAL);
exit(0x111);
return;
}
while(playing)
{
CheckForWindowsMessages();
if (!BinkWait(binkHandle))
playing = NextBinkFrame(binkHandle);
FlipBuffers();
DirectReadKeyboard();
if (GotAnyKey) playing = 0;
}
/* close file */
BinkClose(binkHandle);
}
static int NextBinkFrame(BINK *binkHandle)
{
/* unpack frame */
BinkDoFrame(binkHandle);
BinkCopyToBuffer(binkHandle,(void*)ScreenBuffer,640*2,480,(640-binkHandle->Width)/2,(480-binkHandle->Height)/2,BinkSurfaceType);
//BinkToBuffer(binkHandle,(640-binkHandle->Width)/2,(480-binkHandle->Height)/2,640*2,480,(void*)ScreenBuffer,GetBinkPixelFormat(&DisplayPixelFormat));
/* are we at the last frame yet? */
if ((binkHandle->FrameNum==(binkHandle->Frames-1))) return 0;
/* next frame, please */
BinkNextFrame(binkHandle);
return 1;
}
static int GetBinkPixelFormat(void)
{
if( (DisplayPixelFormat.dwFlags & DDPF_RGB) && !(DisplayPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) )
{
int m;
int redShift=0;
int greenShift=0;
int blueShift=0;
m = DisplayPixelFormat.dwRBitMask;
LOCALASSERT(m);
while(!(m&1)) m>>=1;
while(m&1)
{
m>>=1;
redShift++;
}
m = DisplayPixelFormat.dwGBitMask;
LOCALASSERT(m);
while(!(m&1)) m>>=1;
while(m&1)
{
m>>=1;
greenShift++;
}
m = DisplayPixelFormat.dwBBitMask;
LOCALASSERT(m);
while(!(m&1)) m>>=1;
while(m&1)
{
m>>=1;
blueShift++;
}
if(redShift == 5)
{
if (greenShift == 5)
{
if (blueShift == 5)
{
return BINKSURFACE555;
}
else // not supported
{
return -1;
}
}
else if (greenShift == 6)
{
if (blueShift == 5)
{
return BINKSURFACE565;
}
else // not supported
{
return -1;
}
}
}
else if (redShift == 6)
{
if (greenShift == 5)
{
if (blueShift == 5)
{
return BINKSURFACE655;
}
else // not supported
{
return -1;
}
}
else if (greenShift == 6)
{
if (blueShift == 4)
{
return BINKSURFACE664;
}
else // not supported
{
return -1;
}
}
}
else
{
return -1;
}
}
return -1;
}
BINK *MenuBackground = 0;
extern void StartMenuBackgroundBink(void)
{
char *filenamePtr = "fmvs/menubackground.bik";//newer.bik";
/* open smacker file */
MenuBackground = BinkOpen(filenamePtr,0);
BinkSurfaceType = GetBinkPixelFormat();
BinkDoFrame(MenuBackground);
}
extern int PlayMenuBackgroundBink(void)
{
int newframe = 0;
if(!MenuBackground) return 0;
if (!BinkWait(MenuBackground)&&IntroOutroMoviesAreActive) newframe=1;
if(newframe) BinkDoFrame(MenuBackground);
BinkCopyToBuffer(MenuBackground,(void*)ScreenBuffer,640*2,480,(640-MenuBackground->Width)/2,(480-MenuBackground->Height)/2,BinkSurfaceType|BINKSURFACECOPYALL);
/* next frame, please */
if(newframe)BinkNextFrame(MenuBackground);
return 1;
}
extern void EndMenuBackgroundBink(void)
{
if(!MenuBackground) return;
BinkClose(MenuBackground);
MenuBackground = 0;
}

488
3dc/win95/bink.h
View file

@ -1,488 +0,0 @@
#ifndef BINKH
#define BINKH
#define BINKVERSION "0.8e"
#ifndef __RADRES__
#include "bink_rad.h"
RADDEFSTART
typedef struct BINK PTR4* HBINK;
typedef s32 (RADLINK PTR4* BINKIOOPEN) (struct BINKIO PTR4* Bnkio, const char PTR4 *name, u32 flags);
typedef u32 (RADLINK PTR4* BINKIOREADHEADER) (struct BINKIO PTR4* Bnkio, s32 Offset, void PTR4* Dest,u32 Size);
typedef u32 (RADLINK PTR4* BINKIOREADFRAME) (struct BINKIO PTR4* Bnkio, u32 Framenum,s32 origofs,void PTR4* dest,u32 size);
typedef u32 (RADLINK PTR4* BINKIOGETBUFFERSIZE)(struct BINKIO PTR4* Bnkio, u32 Size);
typedef void (RADLINK PTR4* BINKIOSETINFO) (struct BINKIO PTR4* Bnkio, void PTR4* Buf,u32 Size,u32 FileSize,u32 simulate);
typedef u32 (RADLINK PTR4* BINKIOIDLE) (struct BINKIO PTR4* Bnkio);
typedef void (RADLINK PTR4* BINKIOCLOSE) (struct BINKIO PTR4* Bnkio);
typedef struct BINKIO {
BINKIOREADHEADER ReadHeader;
BINKIOREADFRAME ReadFrame;
BINKIOGETBUFFERSIZE GetBufferSize;
BINKIOSETINFO SetInfo;
BINKIOIDLE Idle;
BINKIOCLOSE Close;
HBINK bink;
volatile u32 DoingARead;
volatile u32 BytesRead;
volatile u32 TotalTime;
volatile u32 ForegroundTime;
volatile u32 BufSize;
volatile u32 BufHighUsed;
volatile u32 CurBufSize;
volatile u32 CurBufUsed;
volatile u8 iodata[128];
} BINKIO;
typedef s32 (RADLINK PTR4* BINKSNDOPEN) (struct BINKSND PTR4* BnkSnd, u32 freq, s32 bits, s32 chans, u32 flags, HBINK bink);
typedef void (RADLINK PTR4* BINKSNDRESET) (struct BINKSND PTR4* BnkSnd);
typedef s32 (RADLINK PTR4* BINKSNDREADY) (struct BINKSND PTR4* BnkSnd);
typedef s32 (RADLINK PTR4* BINKSNDLOCK) (struct BINKSND PTR4* BnkSnd, u8 PTR4* PTR4* addr, u32 PTR4* len);
typedef s32 (RADLINK PTR4* BINKSNDUNLOCK) (struct BINKSND PTR4* BnkSnd, u32 filled);
typedef void (RADLINK PTR4* BINKSNDVOLUME) (struct BINKSND PTR4* BnkSnd, s32 volume);
typedef void (RADLINK PTR4* BINKSNDPAN) (struct BINKSND PTR4* BnkSnd, s32 pan);
typedef s32 (RADLINK PTR4* BINKSNDOFF) (struct BINKSND PTR4* BnkSnd, s32 status);
typedef s32 (RADLINK PTR4* BINKSNDPAUSE) (struct BINKSND PTR4* BnkSnd, s32 status);
typedef void (RADLINK PTR4* BINKSNDCLOSE) (struct BINKSND PTR4* BnkSnd);
typedef BINKSNDOPEN (RADLINK PTR4* BINKSNDSYSOPEN) (u32 param);
typedef struct BINKSND {
BINKSNDRESET SetParam;
BINKSNDRESET Reset;
BINKSNDREADY Ready;
BINKSNDLOCK Lock;
BINKSNDUNLOCK Unlock;
BINKSNDVOLUME Volume;
BINKSNDPAN Pan;
BINKSNDPAUSE Pause;
BINKSNDOFF Off;
BINKSNDCLOSE Close;
u32 BestSizeIn16;
u32 SoundDroppedOut;
u32 freq;
s32 bits,chans;
u8 snddata[128];
} BINKSND;
typedef struct BINKRECT {
s32 Left,Top,Width,Height;
} BINKRECT;
#define BINKMAXDIRTYRECTS 8
typedef struct BUNDLEPOINTERS {
void* typeptr;
void* type16ptr;
void* colorptr;
void* bits2ptr;
void* motionXptr;
void* motionYptr;
void* dctptr;
void* mdctptr;
void* patptr;
} BUNDLEPOINTERS;
typedef struct BINK {
u32 Width; // Width (1 based, 640 for example)
u32 Height; // Height (1 based, 480 for example)
u32 StretchWidth; // Default stretch width
u32 StretchHeight; // Default stretch height (used for Y double)
u32 Frames; // Number of frames (1 based, 100 = 100 frames)
u32 FrameNum; // Frame to *be* displayed (1 based)
u32 LastFrameNum; // Last frame decompressed or skipped (1 based)
u32 FrameRate; // Frame Rate Numerator
u32 FrameRateDiv; // Frame Rate Divisor (frame rate=numerator/divisor)
u32 ReadError; // Non-zero if a read error has ocurred
u32 OpenFlags; // flags used on open
u32 BinkType; // Bink flags
u32 Size; // size of file
u32 FrameSize; // The current frame's size in bytes
u32 SndSize; // The current frame sound tracks' size in bytes
BINKRECT FrameRects[BINKMAXDIRTYRECTS];// Dirty rects from BinkGetRects
s32 NumRects;
u32 YPlaneNum; // which YPlane is current
void PTR4* YPlane[2]; // pointer to the uncompressed Y (Cr and Cr follow)
u32 YWidth; // widths and heights of the video planes
u32 YHeight;
u32 UVWidth;
u32 UVHeight;
void PTR4* MaskPlane; // pointer to the mask plane (Ywidth/16*Yheight/16)
u32 MaskPitch; // Mask Pitch
u32 MaskLength; // total length of the mask plane
u32 LargestFrameSize; // Largest frame size
u32 InternalFrames; // how many frames were potentially compressed
s32 NumTracks; // how many tracks
u32 Highest1SecRate; // Highest 1 sec data rate
u32 Highest1SecFrame; // Highest 1 sec data rate starting frame
s32 Paused; // is the bink movie paused?
u32 BackgroundThread; // handle to background thread
// everything below is for internal Bink use
void PTR4* compframe; // compressed frame data
void PTR4* preloadptr; // preloaded compressed frame data
u32* frameoffsets; // offsets of each of the frames
BINKIO bio; // IO structure
u8 PTR4* ioptr; // io buffer ptr
u32 iosize; // io buffer size
u32 decompheight; // height not include interlacing
s32 trackindex; // track index
u32 PTR4* tracksizes; // largest single frame of track
u32 PTR4* tracktypes; // type of each sound track
s32 PTR4* trackIDs; // external track numbers
u32 numrects; // number of rects from BinkGetRects
u32 playedframes; // how many frames have we played
u32 firstframetime; // very first frame start
u32 startframetime; // start frame start
u32 startblittime; // start of blit period
u32 startsynctime; // start of synched time
u32 startsyncframe; // frame of startsynctime
u32 twoframestime; // two frames worth of time
u32 entireframetime; // entire frame time
u32 slowestframetime; // slowest frame in ms
u32 slowestframe; // slowest frame number
u32 slowest2frametime; // second slowest frame in ms
u32 slowest2frame; // second slowest frame
u32 soundon; // sound turned on?
u32 videoon; // video turned on?
u32 totalmem; // total memory used
u32 timedecomp; // total time decompressing
u32 timeblit; // total time blitting
u32 timeopen; // total open time
u32 fileframerate; // frame rate originally in the file
u32 fileframeratediv;
u32 threadcontrol; // controls the background reading thread
u32 runtimeframes; // max frames for runtime analysis
u32 runtimemoveamt; // bytes to move each frame
u32 PTR4* rtframetimes; // start times for runtime frames
u32 PTR4* rtdecomptimes; // decompress times for runtime frames
u32 PTR4* rtblittimes; // blit times for runtime frames
u32 PTR4* rtreadtimes; // read times for runtime frames
u32 lastdecompframe; // last frame number decompressed
u32 sndbufsize; // sound buffer size
u8 PTR4* sndbuf; // sound buffer
u8 PTR4* sndend; // end of the sound buffer
u8 PTR4* sndwritepos; // current write position
u8 PTR4* sndreadpos; // current read position
u32 sndcomp; // sound compression handle
u32 sndamt; // amount of sound currently in the buffer
volatile u32 sndreenter; // re-entrancy check on the sound
u32 sndconvert8; // convert back to 8-bit sound at runtime
BINKSND bsnd; // SND structure
u32 skippedlastblit; // skipped last frame?
u32 skippedblits; // how many blits were skipped
u32 soundskips; // number of sound stops
BUNDLEPOINTERS bunp; // pointers to internal temporary memory
} BINK;
typedef struct BINKSUMMARY {
u32 Width; // Width of frames
u32 Height; // Height of frames
u32 TotalTime; // total time (ms)
u32 FileFrameRate; // frame rate
u32 FileFrameRateDiv; // frame rate divisor
u32 FrameRate; // frame rate
u32 FrameRateDiv; // frame rate divisor
u32 TotalOpenTime; // Time to open and prepare for decompression
u32 TotalFrames; // Total Frames
u32 TotalPlayedFrames; // Total Frames played
u32 SkippedFrames; // Total number of skipped frames
u32 SkippedBlits; // Total number of skipped blits
u32 SoundSkips; // Total number of sound skips
u32 TotalBlitTime; // Total time spent blitting
u32 TotalReadTime; // Total time spent reading
u32 TotalDecompTime; // Total time spent decompressing
u32 TotalBackReadTime; // Total time spent reading in background
u32 TotalReadSpeed; // Total io speed (bytes/second)
u32 SlowestFrameTime; // Slowest single frame time (ms)
u32 Slowest2FrameTime; // Second slowest single frame time (ms)
u32 SlowestFrameNum; // Slowest single frame number
u32 Slowest2FrameNum; // Second slowest single frame number
u32 AverageDataRate; // Average data rate of the movie
u32 AverageFrameSize; // Average size of the frame
u32 HighestMemAmount; // Highest amount of memory allocated
u32 TotalIOMemory; // Total extra memory allocated
u32 HighestIOUsed; // Highest extra memory actually used
u32 Highest1SecRate; // Highest 1 second rate
u32 Highest1SecFrame; // Highest 1 second start frame
} BINKSUMMARY;
typedef struct BINKREALTIME {
u32 FrameNum; // Current frame number
u32 FrameRate; // frame rate
u32 FrameRateDiv; // frame rate divisor
u32 Frames; // frames in this sample period
u32 FramesTime; // time is ms for these frames
u32 FramesDecompTime; // time decompressing these frames
u32 FramesReadTime; // time reading these frames
u32 FramesBlitTime; // time blitting these frames
u32 ReadBufferSize; // size of read buffer
u32 ReadBufferUsed; // amount of read buffer currently used
u32 FramesDataRate; // data rate for these frames
} BINKREALTIME;
#define BINKMARKER 'fKIB'
typedef struct BINKHDR {
u32 Marker; // BNKa
u32 Size; // size of the file-8
u32 Frames; // Number of frames (1 based, 100 = 100 frames)
u32 LargestFrameSize; // Size in bytes of largest frame
u32 InternalFrames; // Number of internal frames
u32 Width; // Width (1 based, 640 for example)
u32 Height; // Height (1 based, 480 for example)
u32 FrameRate; // frame rate
u32 FrameRateDiv; // frame rate divisor (framerate/frameratediv=fps)
u32 Flags; // height compression options
u32 NumTracks; // number of tracks
} BINKHDR;
//=======================================================================
#define BINKFRAMERATE 0x00080000L // Override fr (call BinkFrameRate first)
#define BINKPRELOADALL 0x00100000L // Preload the entire animation
#define BINKSNDTRACK 0x00200000L // Set the track number to play
#define BINKNOSKIP 0x00400000L // Don't skip frames if falling behind
#define BINKNOFILLIOBUF 0x00800000L // Fill the IO buffer in SmackOpen
#define BINKSIMULATE 0x01000000L // Simulate the speed (call BinkSim first)
#define BINKFILEHANDLE 0x02000000L // Use when passing in a file handle
#define BINKIOSIZE 0x04000000L // Set an io size (call BinkIOSize first)
#define BINKIOPROCESSOR 0x08000000L // Set an io processor (call BinkIO first)
#define BINKFROMMEMORY 0x40000000L // Use when passing in a pointer to the file
#define BINKNOTHREADEDIO 0x80000000L // Don't use a background thread for IO
#define BINKSURFACEYINTERLACE 0x20000000L // Force interleaving Y scaling
#define BINKSURFACEYDOUBLE 0x10000000L // Force doubling Y scaling
#define BINKSURFACEYFORCENONE 0x30000000L // Force Y scaling off
#define BINKSURFACEFAST 0x00000000L
#define BINKSURFACESLOW 0x80000000L
#define BINKSURFACEDIRECT 0x40000000L
#define BINKSURFACEFLIPPED 0x08000000L
#define BINKSURFACECOPYALL 0x04000000L // copy all pixels (not just changed)
#define BINKSURFACENOSKIP 0x01000000L // don't skip the blit if behind in sound
#define BINKSURFACE24 0
#define BINKSURFACE32 1
#define BINKSURFACE555 2
#define BINKSURFACE565 3
#define BINKSURFACE655 4
#define BINKSURFACE664 5
#define BINKSURFACE8P 6
#define BINKSURFACEYUY2 7
#define BINKSURFACEUYVY 8
#define BINKSURFACEYV12 9
#define BINKSURFACEMASK 15
#define BINKGOTOQUICK 1
#define BINKGETKEYPREVIOUS 0
#define BINKGETKEYNEXT 1
#define BINKGETKEYCLOSEST 2
#define BINKGETKEYNOTEQUAL 128
//=======================================================================
RADEXPFUNC void PTR4* RADEXPLINK BinkLogoAddress(void);
RADEXPFUNC void RADEXPLINK BinkSetError(const char PTR4* err);
RADEXPFUNC char PTR4* RADEXPLINK BinkGetError(void);
RADEXPFUNC HBINK RADEXPLINK BinkOpen(const char PTR4* name,u32 flags);
#ifdef __RADMAC__
#include <files.h>
RADEXPFUNC HBINK RADEXPLINK BinkMacOpen(FSSpec* fsp,u32 flags);
#endif
RADEXPFUNC u32 RADEXPLINK BinkDoFrame(HBINK bnk);
RADEXPFUNC void RADEXPLINK BinkNextFrame(HBINK bnk);
RADEXPFUNC s32 RADEXPLINK BinkWait(HBINK bnk);
RADEXPFUNC void RADEXPLINK BinkClose(HBINK bnk);
RADEXPFUNC s32 RADEXPLINK BinkPause(HBINK bnk,s32 pause);
RADEXPFUNC s32 RADEXPLINK BinkCopyToBuffer(HBINK bnk,void* dest,u32 destpitch,u32 destheight,u32 destx,u32 desty,u32 flags);
RADEXPFUNC s32 RADEXPLINK BinkGetRects(HBINK bnk,u32 surfacetype);
RADEXPFUNC void RADEXPLINK BinkGoto(HBINK bnk,u32 frame,s32 flags); // use 1 for the first frame
RADEXPFUNC u32 RADEXPLINK BinkGetKeyFrame(HBINK bnk,u32 frame,s32 flags);
RADEXPFUNC u32 RADEXPLINK BinkSetVideoOnOff(HBINK bnk,s32 onoff);
RADEXPFUNC u32 RADEXPLINK BinkSetSoundOnOff(HBINK bnk,s32 onoff);
RADEXPFUNC void RADEXPLINK BinkSetVolume(HBINK bnk,s32 volume);
RADEXPFUNC void RADEXPLINK BinkSetPan(HBINK bnk,s32 pan);
RADEXPFUNC void RADEXPLINK BinkService(HBINK bink);
RADEXPFUNC u32 RADEXPLINK BinkGetTrackType(HBINK bnk,u32 trackindex);
RADEXPFUNC u32 RADEXPLINK BinkGetTrackID(HBINK bnk,u32 trackindex);
RADEXPFUNC u32 RADEXPLINK BinkGetTrackData(HBINK bnk,void PTR4* dest,u32 trackindex);
RADEXPFUNC void RADEXPLINK BinkGetSummary(HBINK bnk,BINKSUMMARY PTR4* sum);
RADEXPFUNC void RADEXPLINK BinkGetRealtime(HBINK bink,BINKREALTIME PTR4* run,u32 frames);
#define BINKNOSOUND 0xffffffff
RADEXPFUNC void RADEXPLINK BinkSetSoundTrack(u32 track);
RADEXPFUNC void RADEXPLINK BinkSetIO(BINKIOOPEN io);
RADEXPFUNC void RADEXPLINK BinkSetFrameRate(u32 forcerate,u32 forceratediv);
RADEXPFUNC void RADEXPLINK BinkSetSimulate(u32 sim);
RADEXPFUNC void RADEXPLINK BinkSetIOSize(u32 iosize);
RADEXPFUNC s32 RADEXPLINK BinkSetSoundSystem(BINKSNDSYSOPEN open, u32 param);
#ifdef __RADWIN__
RADEXPFUNC BINKSNDOPEN RADEXPLINK BinkOpenDirectSound(u32 param); // don't call directly
#define BinkSoundUseDirectSound(lpDS) BinkSetSoundSystem(BinkOpenDirectSound,(u32)lpDS)
#define BinkTimerSetup()
#define BinkTimerDone()
#define BinkTimerRead timeGetTime
#define INCLUDE_MMSYSTEM_H
#include "windows.h"
#include "windowsx.h"
#ifdef __RADNT__ // to combat WIN32_LEAN_AND_MEAN
#include "mmsystem.h"
RADEXPFUNC s32 RADEXPLINK BinkDDSurfaceType(void PTR4* lpDDS);
#endif
#endif
#ifndef __RADMAC__
RADEXPFUNC BINKSNDOPEN RADEXPLINK BinkOpenMiles(u32 param); // don't call directly
#define BinkSoundUseMiles(hdigdriver) BinkSetSoundSystem(BinkOpenMiles,(u32)hdigdriver)
#endif
#ifndef __RADDOS__
//=========================================================================
typedef struct BINKBUFFER * HBINKBUFFER;
typedef struct BINKBUFFER {
u32 Width;
u32 Height;
u32 WindowWidth;
u32 WindowHeight;
u32 SurfaceType;
void* Buffer;
u32 BufferPitch;
s32 ClientOffsetX;
s32 ClientOffsetY;
u32 ScreenWidth;
u32 ScreenHeight;
u32 ScreenDepth;
u32 ExtraWindowWidth;
u32 ExtraWindowHeight;
u32 ScaleFlags;
u32 StretchWidth;
u32 StretchHeight;
s32 surface;
void* ddsurface;
void* ddclipper;
s32 destx,desty;
u32 HWND;
s32 ddoverlay;
s32 ddoffscreen;
s32 lastovershow;
s32 issoftcur;
u32 cursorcount;
void* buffertop;
u32 type;
s32 noclipping;
} BINKBUFFER;
#define BINKBUFFERSTRETCHXINT 0x80000000
#define BINKBUFFERSTRETCHX 0x40000000
#define BINKBUFFERSHRINKXINT 0x20000000
#define BINKBUFFERSHRINKX 0x10000000
#define BINKBUFFERSTRETCHYINT 0x08000000
#define BINKBUFFERSTRETCHY 0x04000000
#define BINKBUFFERSHRINKYINT 0x02000000
#define BINKBUFFERSHRINKY 0x01000000
#define BINKBUFFERRESOLUTION 0x00800000
#define BINKBUFFERAUTO 0
#define BINKBUFFERPRIMARY 1
#define BINKBUFFERYV12OVERLAY 2
#define BINKBUFFERYUY2OVERLAY 3
#define BINKBUFFERUYVYOVERLAY 4
#define BINKBUFFERYV12OFFSCREEN 5
#define BINKBUFFERYUY2OFFSCREEN 6
#define BINKBUFFERUYVYOFFSCREEN 7
#define BINKBUFFERRGBOFFSCREENVIDEO 8
#define BINKBUFFERRGBOFFSCREENSYSTEM 9
#define BINKBUFFERDRAWDIB 10
#define BINKBUFFERTYPEMASK 31
RADEXPFUNC HBINKBUFFER RADEXPLINK BinkBufferOpen( HWND wnd, u32 width, u32 height, u32 bufferflags);
RADEXPFUNC void RADEXPLINK BinkBufferClose( HBINKBUFFER buf);
RADEXPFUNC s32 RADEXPLINK BinkBufferLock( HBINKBUFFER buf);
RADEXPFUNC s32 RADEXPLINK BinkBufferUnlock( HBINKBUFFER buf);
RADEXPFUNC void RADEXPLINK BinkBufferSetResolution( s32 w, s32 h, s32 bits);
RADEXPFUNC void RADEXPLINK BinkBufferCheckWinPos( HBINKBUFFER buf, s32 PTR4* destx, s32 PTR4* desty);
RADEXPFUNC s32 RADEXPLINK BinkBufferSetOffset( HBINKBUFFER buf, s32 destx, s32 desty);
RADEXPFUNC void RADEXPLINK BinkBufferBlit( HBINKBUFFER buf, BINKRECT PTR4* rects, u32 numrects );
RADEXPFUNC s32 RADEXPLINK BinkBufferSetScale( HBINKBUFFER buf, u32 w, u32 h);
RADEXPFUNC s32 RADEXPLINK BinkBufferSetHWND( HBINKBUFFER buf, HWND newwnd);
RADEXPFUNC char PTR4* RADEXPLINK BinkBufferDescription( HBINKBUFFER buf);
RADEXPFUNC char PTR4* RADEXPLINK BinkBufferGetError();
RADEXPFUNC s32 RADEXPLINK BinkDDSurfaceType(void PTR4* lpDDS);
RADEXPFUNC s32 RADEXPLINK BinkIsSoftwareCursor(void PTR4* lpDDSP,HCURSOR cur);
RADEXPFUNC s32 RADEXPLINK BinkCheckCursor(HWND wnd,s32 x,s32 y,s32 w,s32 h);
RADEXPFUNC void RADEXPLINK BinkRestoreCursor(s32 checkcount);
#endif
RADDEFEND
#endif
#endif

699
3dc/win95/bink_Rad.h
View file

@ -1,699 +0,0 @@
#ifndef __RAD__
#define __RAD__
#define RADCOPYRIGHT "Copyright (C) 1994-99 RAD Game Tools, Inc."
#ifndef __RADRES__
// __RADDOS__ means DOS code (16 or 32 bit)
// __RAD16__ means 16 bit code (Win16)
// __RAD32__ means 32 bit code (DOS, Win386, Win32s, Mac)
// __RADWIN__ means Windows code (Win16, Win386, Win32s)
// __RADWINEXT__ means Windows 386 extender (Win386)
// __RADNT__ means Win32s code
// __RADMAC__ means Macintosh
// __RAD68K__ means 68K Macintosh
// __RADPPC__ means PowerMac
#if (defined(__MWERKS__) && !defined(__INTEL__)) || defined(THINK_C) || defined(powerc) || defined(macintosh) || defined(__powerc)
#define __RADMAC__
#if defined(powerc) || defined(__powerc)
#define __RADPPC__
#else
#define __RAD68K__
#endif
#define __RAD32__
#else
#ifdef __MWERKS__
#define _WIN32
#endif
#ifdef __DOS__
#define __RADDOS__
#endif
#ifdef __386__
#define __RAD32__
#endif
#ifdef _Windows //For Borland
#ifdef __WIN32__
#define WIN32
#else
#define __WINDOWS__
#endif
#endif
#ifdef _WINDOWS //For MS
#ifndef _WIN32
#define __WINDOWS__
#endif
#endif
#ifdef _WIN32
#define __RADWIN__
#define __RADNT__
#define __RAD32__
#else
#ifdef __NT__
#define __RADWIN__
#define __RADNT__
#define __RAD32__
#else
#ifdef __WINDOWS_386__
#define __RADWIN__
#define __RADWINEXT__
#define __RAD32__
#else
#ifdef __WINDOWS__
#define __RADWIN__
#define __RAD16__
#else
#ifdef WIN32
#define __RADWIN__
#define __RADNT__
#define __RAD32__
#endif
#endif
#endif
#endif
#endif
#endif
#if (!defined(__RADDOS__) && !defined(__RADWIN__) && !defined(__RADMAC__))
#error RAD.H did not detect your platform. Define __DOS__, __WINDOWS__, WIN32, macintosh, or powerc.
#endif
#ifdef __RADMAC__
// this define is for CodeWarrior 11's stupid new libs (even though
// we don't use longlong's).
#define __MSL_LONGLONG_SUPPORT__
#define RADLINK
#define RADEXPLINK
#ifdef __CFM68K__
#ifdef __RADINDLL__
#define RADEXPFUNC RADDEFFUNC __declspec(export)
#else
#define RADEXPFUNC RADDEFFUNC __declspec(import)
#endif
#else
#define RADEXPFUNC RADDEFFUNC
#endif
#define RADASMLINK
#else
#ifdef __RADNT__
#ifndef _WIN32
#define _WIN32
#endif
#ifndef WIN32
#define WIN32
#endif
#endif
#ifdef __RADWIN__
#ifdef __RAD32__
#ifdef __RADNT__
#define RADLINK __stdcall
#define RADEXPLINK __stdcall
#ifdef __RADINEXE__
#define RADEXPFUNC RADDEFFUNC
#else
#ifndef __RADINDLL__
#define RADEXPFUNC RADDEFFUNC __declspec(dllimport)
#ifdef __BORLANDC__
#if __BORLANDC__<=0x460
#undef RADEXPFUNC
#define RADEXPFUNC RADDEFFUNC
#endif
#endif
#else
#define RADEXPFUNC RADDEFFUNC __declspec(dllexport)
#endif
#endif
#else
#define RADLINK __pascal
#define RADEXPLINK __far __pascal
#define RADEXPFUNC RADDEFFUNC
#endif
#else
#define RADLINK __pascal
#define RADEXPLINK __far __pascal __export
#define RADEXPFUNC RADDEFFUNC
#endif
#else
#define RADLINK __pascal
#define RADEXPLINK __pascal
#define RADEXPFUNC RADDEFFUNC
#endif
#define RADASMLINK __cdecl
#endif
#ifdef __RADWIN__
#ifndef _WINDOWS
#define _WINDOWS
#endif
#endif
#ifdef __cplusplus
#define RADDEFFUNC extern "C"
#define RADDEFSTART extern "C" {
#define RADDEFEND }
#else
#define RADDEFFUNC
#define RADDEFSTART
#define RADDEFEND
#endif
RADDEFSTART
#define s8 signed char
#define u8 unsigned char
#define u32 unsigned long
#define s32 signed long
#define u64 unsigned __int64
#define s64 signed __int64
#define f32 float
#define f64 double
#ifdef __RAD32__
#define PTR4
#define u16 unsigned short
#define s16 signed short
#ifdef __RADMAC__
#include <string.h>
#include <memory.h>
#include <OSUtils.h>
#define radstrlen strlen
#define radmemset memset
#define radmemcmp memcmp
#define radmemcpy(dest,source,size) BlockMoveData((Ptr)(source),(Ptr)(dest),size)
#define radmemcpydb(dest,source,size) BlockMoveData((Ptr)(source),(Ptr)(dest),size)
#define radstrcat strcat
#define radstrcpy strcpy
static u32 inline radsqr(s32 a) { return(a*a); }
#ifdef __RAD68K__
#pragma parameter __D0 mult64anddiv(__D0,__D1,__D2)
u32 mult64anddiv(u32 m1,u32 m2,u32 d) ={0x4C01,0x0C01,0x4C42,0x0C01};
// muls.l d1,d1:d0 divs.l d2,d1:d0
#pragma parameter radconv32a(__A0,__D0)
void radconv32a(void* p,u32 n) ={0x4A80,0x600C,0x2210,0xE059,0x4841,0xE059,0x20C1,0x5380,0x6EF2};
// tst.l d0 bra.s @loope @loop: move.l (a0),d1 ror.w #8,d1 swap d1 ror.w #8,d1 move.l d1,(a0)+ sub.l #1,d0 bgt.s @loop @loope:
#else
u32 mult64anddiv(u32 m1,u32 m2,u32 d);
void radconv32a(void* p,u32 n);
#endif
#else
#ifdef __WATCOMC__
u32 radsqr(s32 a);
#pragma aux radsqr = "mul eax" parm [eax] modify [EDX eax];
u32 mult64anddiv(u32 m1,u32 m2,u32 d);
#pragma aux mult64anddiv = "mul ecx" "div ebx" parm [eax] [ecx] [ebx] modify [EDX eax];
s32 radabs(s32 ab);
#pragma aux radabs = "test eax,eax" "jge skip" "neg eax" "skip:" parm [eax];
#define radabs32 radabs
u32 DOSOut(const char* str);
#pragma aux DOSOut = "cld" "mov ecx,0xffffffff" "xor eax,eax" "mov edx,edi" "repne scasb" "not ecx" "dec ecx" "mov ebx,1" "mov ah,0x40" "int 0x21" parm [EDI] modify [EAX EBX ECX EDX EDI] value [ecx];
void DOSOutNum(const char* str,u32 len);
#pragma aux DOSOutNum = "mov ah,0x40" "mov ebx,1" "int 0x21" parm [edx] [ecx] modify [eax ebx];
u32 ErrOut(const char* str);
#pragma aux ErrOut = "cld" "mov ecx,0xffffffff" "xor eax,eax" "mov edx,edi" "repne scasb" "not ecx" "dec ecx" "xor ebx,ebx" "mov ah,0x40" "int 0x21" parm [EDI] modify [EAX EBX ECX EDX EDI] value [ecx];
void ErrOutNum(const char* str,u32 len);
#pragma aux ErrOutNum = "mov ah,0x40" "xor ebx,ebx" "int 0x21" parm [edx] [ecx] modify [eax ebx];
void radmemset16(void* dest,u16 value,u32 size);
#pragma aux radmemset16 = "cld" "mov bx,ax" "shl eax,16" "mov ax,bx" "mov bl,cl" "shr ecx,1" "rep stosd" "mov cl,bl" "and cl,1" "rep stosw" parm [EDI] [EAX] [ECX] modify [EAX EDX EBX ECX EDI];
void radmemset(void* dest,u8 value,u32 size);
#pragma aux radmemset = "cld" "mov ah,al" "mov bx,ax" "shl eax,16" "mov ax,bx" "mov bl,cl" "shr ecx,2" "and bl,3" "rep stosd" "mov cl,bl" "rep stosb" parm [EDI] [AL] [ECX] modify [EAX EDX EBX ECX EDI];
void radmemset32(void* dest,u32 value,u32 size);
#pragma aux radmemset32 = "cld" "rep stosd" parm [EDI] [EAX] [ECX] modify [EAX EDX EBX ECX EDI];
void radmemcpy(void* dest,const void* source,u32 size);
#pragma aux radmemcpy = "cld" "mov bl,cl" "shr ecx,2" "rep movsd" "mov cl,bl" "and cl,3" "rep movsb" parm [EDI] [ESI] [ECX] modify [EBX ECX EDI ESI];
void __far *radfmemcpy(void __far* dest,const void __far* source,u32 size);
#pragma aux radfmemcpy = "cld" "push es" "push ds" "mov es,cx" "mov ds,dx" "mov ecx,eax" "shr ecx,2" "rep movsd" "mov cl,al" "and cl,3" "rep movsb" "pop ds" "pop es" parm [CX EDI] [DX ESI] [EAX] modify [ECX EDI ESI] value [CX EDI];
void radmemcpydb(void* dest,const void* source,u32 size); //Destination bigger
#pragma aux radmemcpydb = "std" "mov bl,cl" "lea esi,[esi+ecx-4]" "lea edi,[edi+ecx-4]" "shr ecx,2" "rep movsd" "and bl,3" "jz dne" "add esi,3" "add edi,3" "mov cl,bl" "rep movsb" "dne:" "cld" parm [EDI] [ESI] [ECX] modify [EBX ECX EDI ESI];
char* radstrcpy(void* dest,const void* source);
#pragma aux radstrcpy = "cld" "mov edx,edi" "lp:" "mov al,[esi]" "inc esi" "mov [edi],al" "inc edi" "cmp al,0" "jne lp" parm [EDI] [ESI] modify [EAX EDX EDI ESI] value [EDX];
char __far* radfstrcpy(void __far* dest,const void __far* source);
#pragma aux radfstrcpy = "cld" "push es" "push ds" "mov es,cx" "mov ds,dx" "mov edx,edi" "lp:" "lodsb" "stosb" "test al,0xff" "jnz lp" "pop ds" "pop es" parm [CX EDI] [DX ESI] modify [EAX EDX EDI ESI] value [CX EDX];
char* radstpcpy(void* dest,const void* source);
#pragma aux radstpcpy = "cld" "lp:" "mov al,[esi]" "inc esi" "mov [edi],al" "inc edi" "cmp al,0" "jne lp" "dec edi" parm [EDI] [ESI] modify [EAX EDI ESI] value [EDI];
char* radstpcpyrs(void* dest,const void* source);
#pragma aux radstpcpyrs = "cld" "lp:" "mov al,[esi]" "inc esi" "mov [edi],al" "inc edi" "cmp al,0" "jne lp" "dec esi" parm [EDI] [ESI] modify [EAX EDI ESI] value [ESI];
u32 radstrlen(const void* dest);
#pragma aux radstrlen = "cld" "mov ecx,0xffffffff" "xor eax,eax" "repne scasb" "not ecx" "dec ecx" parm [EDI] modify [EAX ECX EDI] value [ECX];
char* radstrcat(void* dest,const void* source);
#pragma aux radstrcat = "cld" "mov ecx,0xffffffff" "mov edx,edi" "xor eax,eax" "repne scasb" "dec edi" "lp:" "lodsb" "stosb" "test al,0xff" "jnz lp" \
parm [EDI] [ESI] modify [EAX ECX EDI ESI] value [EDX];
char* radstrchr(const void* dest,char chr);
#pragma aux radstrchr = "cld" "lp:" "lodsb" "cmp al,dl" "je fnd" "cmp al,0" "jnz lp" "mov esi,1" "fnd:" "dec esi" parm [ESI] [DL] modify [EAX ESI] value [esi];
s8 radmemcmp(const void* s1,const void* s2,u32 len);
#pragma aux radmemcmp = "cld" "rep cmpsb" "setne al" "jbe end" "neg al" "end:" parm [EDI] [ESI] [ECX] modify [ECX EDI ESI];
s8 radstrcmp(const void* s1,const void* s2);
#pragma aux radstrcmp = "lp:" "mov al,[esi]" "mov ah,[edi]" "cmp al,ah" "jne set" "cmp al,0" "je set" "inc esi" "inc edi" "jmp lp" "set:" "setne al" "jbe end" "neg al" "end:" \
parm [EDI] [ESI] modify [EAX EDI ESI];
s8 radstricmp(const void* s1,const void* s2);
#pragma aux radstricmp = "lp:" "mov al,[esi]" "mov ah,[edi]" "cmp al,'a'" "jb c1" "cmp al,'z'" "ja c1" "sub al,32" "c1:" "cmp ah,'a'" "jb c2" "cmp ah,'z'" "ja c2" "sub ah,32" "c2:" "cmp al,ah" "jne set" "cmp al,0" "je set" \
"inc esi" "inc edi" "jmp lp" "set:" "setne al" "jbe end" "neg al" "end:" \
parm [EDI] [ESI] modify [EAX EDI ESI];
s8 radstrnicmp(const void* s1,const void* s2,u32 len);
#pragma aux radstrnicmp = "lp:" "mov al,[esi]" "mov ah,[edi]" "cmp al,'a'" "jb c1" "cmp al,'z'" "ja c1" "sub al,32" "c1:" "cmp ah,'a'" "jb c2" "cmp ah,'z'" "ja c2" "sub ah,32" "c2:" "cmp al,ah" "jne set" "cmp al,0" "je set" \
"dec ecx" "jz set" "inc esi" "inc edi" "jmp lp" "set:" "setne al" "jbe end" "neg al" "end:" \
parm [EDI] [ESI] [ECX] modify [EAX ECX EDI ESI];
char* radstrupr(void* s1);
#pragma aux radstrupr = "mov ecx,edi" "lp:" "mov al,[edi]" "cmp al,'a'" "jb c1" "cmp al,'z'" "ja c1" "sub [edi],32" "c1:" "inc edi" "cmp al,0" "jne lp" parm [EDI] modify [EAX EDI] value [ecx];
char* radstrlwr(void* s1);
#pragma aux radstrlwr = "mov ecx,edi" "lp:" "mov al,[edi]" "cmp al,'A'" "jb c1" "cmp al,'Z'" "ja c1" "add [edi],32" "c1:" "inc edi" "cmp al,0" "jne lp" parm [EDI] modify [EAX EDI] value [ecx];
u32 radstru32(const void* dest);
#pragma aux radstru32 = "cld" "xor ecx,ecx" "xor ebx,ebx" "xor edi,edi" "lodsb" "cmp al,45" "jne skip2" "mov edi,1" "jmp skip" "lp:" "mov eax,10" "mul ecx" "lea ecx,[eax+ebx]" \
"skip:" "lodsb" "skip2:" "cmp al,0x39" "ja dne" "cmp al,0x30" "jb dne" "mov bl,al" "sub bl,0x30" "jmp lp" "dne:" "test edi,1" "jz pos" "neg ecx" "pos:" \
parm [ESI] modify [EAX EBX EDX EDI ESI] value [ecx];
u16 GetDS();
#pragma aux GetDS = "mov ax,ds" value [ax];
#ifdef __RADWINEXT__
#define _16To32(ptr16) ((void*)(((GetSelectorBase((u16)(((u32)(ptr16))>>16))+((u16)(u32)(ptr16)))-GetSelectorBase(GetDS()))))
#endif
#ifndef __RADWIN__
#define int86 int386
#define int86x int386x
#endif
#define u32regs x
#define u16regs w
#else
#define radstrcpy strcpy
#define radstrcat strcat
#define radmemcpy memcpy
#define radmemcpydb memmove
#define radmemcmp memcmp
#define radmemset memset
#define radstrlen strlen
#define radstrchr strchr
#define radtoupper toupper
#define radstru32(s) ((u32)atol(s))
#define radstricmp _stricmp
#define radstrcmp strcmp
#define radstrupr _strupr
#define radstrlwr _strlwr
#define BreakPoint() __asm {int 3}
#ifdef _MSC_VER
#pragma warning( disable : 4035)
typedef char* RADPCHAR;
u32 __inline radsqr(u32 m) {
__asm {
mov eax,[m]
mul eax
}
}
u32 __inline mult64anddiv(u32 m1,u32 m2, u32 d) {
__asm {
mov eax,[m1]
mov ecx,[m2]
mul ecx
mov ecx,[d]
div ecx
}
}
s32 __inline radabs(s32 ab) {
__asm {
mov eax,[ab]
test eax,eax
jge skip
neg eax
skip:
}
}
u8 __inline radinp(u16 p) {
__asm {
mov dx,[p]
in al,dx
}
}
void __inline radoutp(u16 p,u8 v) {
__asm {
mov dx,[p]
mov al,[v]
out dx,al
}
}
RADPCHAR __inline radstpcpy(char* p1, char* p2) {
__asm {
mov edx,[p1]
mov ecx,[p2]
cld
lp:
mov al,[ecx]
inc ecx
mov [edx],al
inc edx
cmp al,0
jne lp
dec edx
mov eax,edx
}
}
RADPCHAR __inline radstpcpyrs(char* p1, char* p2) {
__asm {
mov edx,[p1]
mov ecx,[p2]
cld
lp:
mov al,[ecx]
inc ecx
mov [edx],al
inc edx
cmp al,0
jne lp
dec ecx
mov eax,ecx
}
}
void __inline radmemset16(void* dest,u16 value,u32 sizeb) {
__asm {
mov edi,[dest]
mov ax,[value]
mov ecx,[sizeb]
shl eax,16
cld
mov ax,[value]
mov bl,cl
shr ecx,1
rep stosd
mov cl,bl
and cl,1
rep stosw
}
}
void __inline radmemset32(void* dest,u32 value,u32 sizeb) {
__asm {
mov edi,[dest]
mov eax,[value]
mov ecx,[sizeb]
cld
rep stosd
}
}
u32 __inline __stdcall RADsqrt(u32 sq) {
__asm {
fild dword ptr [sq]
fsqrt
fistp word ptr [sq]
movzx eax,word ptr [sq]
}
}
void __inline RADCycleTimerStartAddr(u32* addr)
{
__asm {
mov ecx,[addr]
#ifdef __MWERKS__
rdtsc
#else
#if _MSC_VER<=1100
__emit 0xf
__emit 0x31
#else
rdtsc
#endif
#endif
mov [ecx],eax
}
}
u32 __inline RADCycleTimerDeltaAddr(u32* addr)
{
__asm {
#ifdef __MWERKS__
rdtsc
#else
#if _MSC_VER<=1100
__emit 0xf
__emit 0x31
#else
rdtsc
#endif
#endif
mov ecx,[addr]
sub eax,[ecx]
mov [ecx],eax
}
}
#define RADCycleTimerStart(var) RADCycleTimerStartAddr(&var)
#define RADCycleTimerDelta(var) RADCycleTimerDeltaAddr(&var)
#pragma warning( default : 4035)
#endif
#endif
#endif
#else
#define PTR4 __far
#define u16 unsigned int
#define s16 signed int
#ifdef __WATCOMC__
u32 radsqr(s32 a);
#pragma aux radsqr = "shl edx,16" "mov dx,ax" "mov eax,edx" "xor edx,edx" "mul eax" "shld edx,eax,16" parm [dx ax] modify [DX ax] value [dx ax];
s16 radabs(s16 ab);
#pragma aux radabs = "test ax,ax" "jge skip" "neg ax" "skip:" parm [ax] value [ax];
s32 radabs32(s32 ab);
#pragma aux radabs32 = "test dx,dx" "jge skip" "neg dx" "neg ax" "sbb dx,0" "skip:" parm [dx ax] value [dx ax];
u32 DOSOut(const char far* dest);
#pragma aux DOSOut = "cld" "and edi,0xffff" "mov dx,di" "mov ecx,0xffffffff" "xor eax,eax" 0x67 "repne scasb" "not ecx" "dec ecx" "mov bx,1" "push ds" "push es" "pop ds" "mov ah,0x40" "int 0x21" "pop ds" "movzx eax,cx" "shr ecx,16" \
parm [ES DI] modify [AX BX CX DX DI ES] value [CX AX];
void DOSOutNum(const char far* str,u16 len);
#pragma aux DOSOutNum = "push ds" "mov ds,cx" "mov cx,bx" "mov ah,0x40" "mov bx,1" "int 0x21" "pop ds" parm [cx dx] [bx] modify [ax bx cx];
u32 ErrOut(const char far* dest);
#pragma aux ErrOut = "cld" "and edi,0xffff" "mov dx,di" "mov ecx,0xffffffff" "xor eax,eax" 0x67 "repne scasb" "not ecx" "dec ecx" "xor bx,bx" "push ds" "push es" "pop ds" "mov ah,0x40" "int 0x21" "pop ds" "movzx eax,cx" "shr ecx,16" \
parm [ES DI] modify [AX BX CX DX DI ES] value [CX AX];
void ErrOutNum(const char far* str,u16 len);
#pragma aux ErrOutNum = "push ds" "mov ds,cx" "mov cx,bx" "mov ah,0x40" "xor bx,bx" "int 0x21" "pop ds" parm [cx dx] [bx] modify [ax bx cx];
void radmemset(void far *dest,u8 value,u32 size);
#pragma aux radmemset = "cld" "and edi,0ffffh" "shl ecx,16" "mov cx,bx" "mov ah,al" "mov bx,ax" "shl eax,16" "mov ax,bx" "mov bl,cl" "shr ecx,2" 0x67 "rep stosd" "mov cl,bl" "and cl,3" "rep stosb" parm [ES DI] [AL] [CX BX];
void radmemset16(void far* dest,u16 value,u32 size);
#pragma aux radmemset16 = "cld" "and edi,0ffffh" "shl ecx,16" "mov cx,bx" "mov bx,ax" "shl eax,16" "mov ax,bx" "mov bl,cl" "shr ecx,1" "rep stosd" "mov cl,bl" "and cl,1" "rep stosw" parm [ES DI] [AX] [CX BX];
void radmemcpy(void far* dest,const void far* source,u32 size);
#pragma aux radmemcpy = "cld" "push ds" "mov ds,dx" "and esi,0ffffh" "and edi,0ffffh" "shl ecx,16" "mov cx,bx" "shr ecx,2" 0x67 "rep movsd" "mov cl,bl" "and cl,3" "rep movsb" "pop ds" parm [ES DI] [DX SI] [CX BX] modify [CX SI DI ES];
s8 radmemcmp(const void far* s1,const void far* s2,u32 len);
#pragma aux radmemcmp = "cld" "push ds" "mov ds,dx" "shl ecx,16" "mov cx,bx" "rep cmpsb" "setne al" "jbe end" "neg al" "end:" "pop ds" parm [ES DI] [DX SI] [CX BX] modify [CX SI DI ES];
char far* radstrcpy(void far* dest,const void far* source);
#pragma aux radstrcpy = "cld" "push ds" "mov ds,dx" "and esi,0xffff" "and edi,0xffff" "mov dx,di" "lp:" "lodsb" "stosb" "test al,0xff" "jnz lp" "pop ds" parm [ES DI] [DX SI] modify [AX DX DI SI ES] value [es dx];
char far* radstpcpy(void far* dest,const void far* source);
#pragma aux radstpcpy = "cld" "push ds" "mov ds,dx" "and esi,0xffff" "and edi,0xffff" "lp:" "lodsb" "stosb" "test al,0xff" "jnz lp" "dec di" "pop ds" parm [ES DI] [DX SI] modify [DI SI ES] value [es di];
u32 radstrlen(const void far* dest);
#pragma aux radstrlen = "cld" "and edi,0xffff" "mov ecx,0xffffffff" "xor eax,eax" 0x67 "repne scasb" "not ecx" "dec ecx" "movzx eax,cx" "shr ecx,16" parm [ES DI] modify [AX CX DI ES] value [CX AX];
char far* radstrcat(void far* dest,const void far* source);
#pragma aux radstrcat = "cld" "and edi,0xffff" "mov ecx,0xffffffff" "and esi,0xffff" "push ds" "mov ds,dx" "mov dx,di" "xor eax,eax" 0x67 "repne scasb" "dec edi" "lp:" "lodsb" "stosb" "test al,0xff" "jnz lp" "pop ds" \
parm [ES DI] [DX SI] modify [AX CX DI SI ES] value [es dx];
char far* radstrchr(const void far* dest,char chr);
#pragma aux radstrchr = "cld" "lp:" 0x26 "lodsb" "cmp al,dl" "je fnd" "cmp al,0" "jnz lp" "xor ax,ax" "mov es,ax" "mov si,1" "fnd:" "dec si" parm [ES SI] [DL] modify [AX SI ES] value [es si];
s8 radstricmp(const void far* s1,const void far* s2);
#pragma aux radstricmp = "and edi,0xffff" "push ds" "mov ds,dx" "and esi,0xffff" "lp:" "mov al,[esi]" "mov ah,[edi]" "cmp al,'a'" "jb c1" "cmp al,'z'" "ja c1" "sub al,32" "c1:" \
"cmp ah,'a'" "jb c2" "cmp ah,'z'" "ja c2" "sub ah,32" "c2:" "cmp al,ah" "jne set" "cmp al,0" "je set" \
"inc esi" "inc edi" "jmp lp" "set:" "setne al" "jbe end" "neg al" "end:" "pop ds" \
parm [ES DI] [DX SI] modify [AX DI SI];
u32 radstru32(const void far* dest);
#pragma aux radstru32 = "cld" "xor ecx,ecx" "xor ebx,ebx" "xor edi,edi" 0x26 "lodsb" "cmp al,45" "jne skip2" "mov edi,1" "jmp skip" "lp:" "mov eax,10" "mul ecx" "lea ecx,[eax+ebx]" \
"skip:" 0x26 "lodsb" "skip2:" "cmp al,0x39" "ja dne" "cmp al,0x30" "jb dne" "mov bl,al" "sub bl,0x30" "jmp lp" "dne:" "test edi,1" "jz pos" "neg ecx" "pos:" \
"movzx eax,cx" "shr ecx,16" parm [ES SI] modify [AX BX DX DI SI] value [cx ax];
u32 mult64anddiv(u32 m1,u32 m2,u32 d);
#pragma aux mult64anddiv = "shl ecx,16" "mov cx,ax" "shrd eax,edx,16" "mov ax,si" "mul ecx" "shl edi,16" "mov di,bx" "div edi" "shld edx,eax,16" "and edx,0xffff" "and eax,0xffff" parm [cx ax] [dx si] [di bx] \
modify [ax bx cx dx si di] value [dx ax];
#endif
#endif
RADDEFEND
#define u32neg1 ((u32)(s32)-1)
#define RAD_align(var) var; u8 junk##var[4-(sizeof(var)&3)];
#define RAD_align_after(var) u8 junk##var[4-(sizeof(var)&3)]={0};
#define RAD_align_init(var,val) var=val; u8 junk##var[4-(sizeof(var)&3)]={0};
#define RAD_align_array(var,num) var[num]; u8 junk##var[4-(sizeof(var)&3)];
#define RAD_align_string(var,str) char var[]=str; u8 junk##var[4-(sizeof(var)&3)]={0};
RADEXPFUNC void PTR4* RADEXPLINK radmalloc(u32 numbytes);
RADEXPFUNC void RADEXPLINK radfree(void PTR4* ptr);
#ifdef __WATCOMC__
char bkbhit();
#pragma aux bkbhit = "mov ah,1" "int 0x16" "lahf" "shr eax,14" "and eax,1" "xor al,1" ;
char bgetch();
#pragma aux bgetch = "xor ah,ah" "int 0x16" "test al,0xff" "jnz done" "mov al,ah" "or al,0x80" "done:" modify [AX];
void BreakPoint();
#pragma aux BreakPoint = "int 3";
u8 radinp(u16 p);
#pragma aux radinp = "in al,dx" parm [DX];
u8 radtoupper(u8 p);
#pragma aux radtoupper = "cmp al,'a'" "jb c1" "cmp al,'z'" "ja c1" "sub al,32" "c1:" parm [al] value [al];
void radoutp(u16 p,u8 v);
#pragma aux radoutp = "out dx,al" parm [DX] [AL];
#else
// for multi-processor machines
#ifdef __RADNT__
#define LockedIncrement(var) __asm { lock inc [var] }
#define LockedDecrement(var) __asm { lock dec [var] }
void __inline LockedIncrementFunc(void PTR4* var) {
__asm {
mov eax,[var]
lock inc [eax]
}
}
void __inline LockedDecrementFunc(void PTR4* var) {
__asm {
mov eax,[var]
lock dec [eax]
}
}
#else
#ifdef __RADMAC__
#define LockedIncrement(var) {++(var);}
#define LockedDecrement(var) {--(var);}
#define LockedIncrementFunc(ptr) {++(*((u32*)(var)));}
#define LockedDecrementFunc(ptr) {--(*((u32*)(var)));}
#else
#define LockedIncrement(var) __asm { inc [var] }
#define LockedDecrement(var) __asm { dec [var] }
void __inline LockedIncrementFunc(void PTR4* var) { __asm { mov eax,[var]
inc [eax] } }
void __inline LockedDecrementFunc(void PTR4* var) { __asm { mov eax,[var]
dec [eax] } }
#endif
#endif
#endif
#endif
#endif

364
3dc/win95/md5.c
View file

@ -1,364 +0,0 @@
/* md5.c - Functions to compute MD5 message digest of files or memory blocks
according to the definition of MD5 in RFC 1321 from April 1992.
Copyright (C) 1995 Software Foundation, Inc.
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, 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
/* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>. */
#define STDC_HEADERS 1
#include "advwin32.h"
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <sys/types.h>
#if STDC_HEADERS
# include <stdlib.h>
# include <string.h>
#else
# ifndef HAVE_MEMCPY
# define memcpy(d, s, n) bcopy ((s), (d), (n))
# endif
#endif
#include "md5.h"
#ifdef WORDS_BIGENDIAN
# define SWAP(n) \
(((n) << 24) | (((n) & 0xff00) << 8) | (((n) >> 8) & 0xff00) | ((n) >> 24))
#else
# define SWAP(n) (n)
#endif
/* This array contains the bytes used to pad the buffer to the next
64-byte boundary. (RFC 1321, 3.1: Step 1) */
static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ... */ };
/* Initialize structure containing state of computation.
(RFC 1321, 3.3: Step 3) */
void
md5_init_ctx (struct md5_ctx *ctx)
{
ctx->A = 0x67452301;
ctx->B = 0xefcdab89;
ctx->C = 0x98badcfe;
ctx->D = 0x10325476;
}
/* Put result from CTX in first 16 bytes following RESBUF. The result must
be in little endian byte order. */
void *
md5_read_ctx(const struct md5_ctx *ctx, void *resbuf)
{
((md5_uint32 *) resbuf)[0] = SWAP (ctx->A);
((md5_uint32 *) resbuf)[1] = SWAP (ctx->B);
((md5_uint32 *) resbuf)[2] = SWAP (ctx->C);
((md5_uint32 *) resbuf)[3] = SWAP (ctx->D);
return resbuf;
}
/* Compute MD5 message digest for bytes read from STREAM. The
resulting message digest number will be written into the 16 bytes
beginning at RESBLOCK. */
#ifdef _MSC_VER
#pragma warning(disable: 4701)
#endif
int md5_stream(FILE *stream, void *resblock)
{
/* Important: BLOCKSIZE must be a multiple of 64. */
#define BLOCKSIZE 64
struct md5_ctx ctx;
md5_uint32 len[2];
char buffer[BLOCKSIZE + 72];
size_t pad, sum;
/* Initialize the computation context. */
md5_init_ctx (&ctx);
len[0] = 0;
len[1] = 0;
/* Iterate over full file contents. */
while (1)
{
/* We read the file in blocks of BLOCKSIZE bytes. One call of the
computation function processes the whole buffer so that with the
next round of the loop another block can be read. */
size_t n;
sum = 0;
/* Read block. Take care for partial reads. */
do
{
n = fread (buffer, 1, BLOCKSIZE - sum, stream);
sum += n;
}
while (sum < BLOCKSIZE && n != 0);
if (n == 0 && ferror (stream))
return 1;
/* RFC 1321 specifies the possible length of the file up to 2^64 bits.
Here we only compute the number of bytes. Do a double word
increment. */
len[0] += sum;
if (len[0] < sum)
++len[1];
/* If end of file is reached, end the loop. */
if (n == 0)
break;
/* Process buffer with BLOCKSIZE bytes. Note that
BLOCKSIZE % 64 == 0
*/
md5_process_block (buffer, BLOCKSIZE, &ctx);
}
/* We can copy 64 byte because the buffer is always big enough. FILLBUF
contains the needed bits. */
memcpy (&buffer[sum], fillbuf, 64);
/* Compute amount of padding bytes needed. Alignment is done to
(N + PAD) % 64 == 56
There is always at least one byte padded. I.e. even the alignment
is correctly aligned 64 padding bytes are added. */
pad = sum & 63;
pad = pad >= 56 ? 64 + 56 - pad : 56 - pad;
/* Put the 64-bit file length in *bits* at the end of the buffer. */
*(md5_uint32 *) &buffer[sum + pad] = SWAP (len[0] << 3);
*(md5_uint32 *) &buffer[sum + pad + 4] = SWAP ((len[1] << 3)
| (len[0] >> 29));
/* Process last bytes. */
md5_process_block (buffer, sum + pad + 8, &ctx);
/* Construct result in desired memory. */
md5_read_ctx (&ctx, resblock);
return 0;
}
#ifdef _MSC_VER
#pragma warning(default: 4701)
#endif
/* Compute MD5 message digest for LEN bytes beginning at BUFFER. The
result is always in little endian byte order, so that a byte-wise
output yields to the wanted ASCII representation of the message
digest. */
void *
md5_buffer (const char *buffer, size_t len, void *resblock)
{
struct md5_ctx ctx;
char restbuf[64 + 72];
size_t blocks = len & ~63;
size_t pad, rest;
/* Initialize the computation context. */
md5_init_ctx (&ctx);
/* Process whole buffer but last len % 64 bytes. */
md5_process_block (buffer, blocks, &ctx);
/* REST bytes are not processed yet. */
rest = len - blocks;
/* Copy to own buffer. */
memcpy (restbuf, &buffer[blocks], rest);
/* Append needed fill bytes at end of buffer. We can copy 64 byte
because the buffer is always big enough. */
memcpy (&restbuf[rest], fillbuf, 64);
/* PAD bytes are used for padding to correct alignment. Note that
always at least one byte is padded. */
pad = rest >= 56 ? 64 + 56 - rest : 56 - rest;
/* Put length of buffer in *bits* in last eight bytes. */
*(md5_uint32 *) &restbuf[rest + pad] = (md5_uint32) SWAP (len << 3);
*(md5_uint32 *) &restbuf[rest + pad + 4] = (md5_uint32) SWAP (len >> 29);
/* Process last bytes. */
md5_process_block (restbuf, rest + pad + 8, &ctx);
/* Put result in desired memory area. */
return md5_read_ctx (&ctx, resblock);
}
/* These are the four functions used in the four steps of the MD5 algorithm
and defined in the RFC 1321. The first function is a little bit optimized
(as found in Colin Plumbs public domain implementation). */
/* #define FF(b, c, d) ((b & c) | (~b & d)) */
#define FF(b, c, d) (d ^ (b & (c ^ d)))
#define FG(b, c, d) FF (d, b, c)
#define FH(b, c, d) (b ^ c ^ d)
#define FI(b, c, d) (c ^ (b | ~d))
/* Process LEN bytes of BUFFER, accumulating context into CTX.
It is assumed that LEN % 64 == 0. */
void
md5_process_block (const void *buffer, size_t len, struct md5_ctx *ctx)
{
md5_uint32 correct_words[16];
const md5_uint32 *words = buffer;
size_t nwords = len / sizeof (md5_uint32);
const md5_uint32 *endp = words + nwords;
md5_uint32 A = ctx->A;
md5_uint32 B = ctx->B;
md5_uint32 C = ctx->C;
md5_uint32 D = ctx->D;
/* Process all bytes in the buffer with 64 bytes in each round of
the loop. */
while (words < endp)
{
md5_uint32 *cwp = correct_words;
md5_uint32 A_save = A;
md5_uint32 B_save = B;
md5_uint32 C_save = C;
md5_uint32 D_save = D;
/* First round: using the given function, the context and a constant
the next context is computed. Because the algorithms processing
unit is a 32-bit word and it is determined to work on words in
little endian byte order we perhaps have to change the byte order
before the computation. To reduce the work for the next steps
we store the swapped words in the array CORRECT_WORDS. */
#define OP(a, b, c, d, s, T) \
do \
{ \
a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T; \
++words; \
CYCLIC (a, s); \
a += b; \
} \
while (0)
/* It is unfortunate that C does not provide an operator for
cyclic rotation. Hope the C compiler is smart enough. */
#define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
/* Before we start, one word to the strange constants.
They are defined in RFC 1321 as
T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
*/
/* Round 1. */
OP (A, B, C, D, 7, 0xd76aa478);
OP (D, A, B, C, 12, 0xe8c7b756);
OP (C, D, A, B, 17, 0x242070db);
OP (B, C, D, A, 22, 0xc1bdceee);
OP (A, B, C, D, 7, 0xf57c0faf);
OP (D, A, B, C, 12, 0x4787c62a);
OP (C, D, A, B, 17, 0xa8304613);
OP (B, C, D, A, 22, 0xfd469501);
OP (A, B, C, D, 7, 0x698098d8);
OP (D, A, B, C, 12, 0x8b44f7af);
OP (C, D, A, B, 17, 0xffff5bb1);
OP (B, C, D, A, 22, 0x895cd7be);
OP (A, B, C, D, 7, 0x6b901122);
OP (D, A, B, C, 12, 0xfd987193);
OP (C, D, A, B, 17, 0xa679438e);
OP (B, C, D, A, 22, 0x49b40821);
/* For the second to fourth round we have the possibly swapped words
in CORRECT_WORDS. Redefine the macro to take an additional first
argument specifying the function to use. */
#undef OP
#define OP(f, a, b, c, d, k, s, T) \
do \
{ \
a += f (b, c, d) + correct_words[k] + T; \
CYCLIC (a, s); \
a += b; \
} \
while (0)
/* Round 2. */
OP (FG, A, B, C, D, 1, 5, 0xf61e2562);
OP (FG, D, A, B, C, 6, 9, 0xc040b340);
OP (FG, C, D, A, B, 11, 14, 0x265e5a51);
OP (FG, B, C, D, A, 0, 20, 0xe9b6c7aa);
OP (FG, A, B, C, D, 5, 5, 0xd62f105d);
OP (FG, D, A, B, C, 10, 9, 0x02441453);
OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);
OP (FG, B, C, D, A, 4, 20, 0xe7d3fbc8);
OP (FG, A, B, C, D, 9, 5, 0x21e1cde6);
OP (FG, D, A, B, C, 14, 9, 0xc33707d6);
OP (FG, C, D, A, B, 3, 14, 0xf4d50d87);
OP (FG, B, C, D, A, 8, 20, 0x455a14ed);
OP (FG, A, B, C, D, 13, 5, 0xa9e3e905);
OP (FG, D, A, B, C, 2, 9, 0xfcefa3f8);
OP (FG, C, D, A, B, 7, 14, 0x676f02d9);
OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
/* Round 3. */
OP (FH, A, B, C, D, 5, 4, 0xfffa3942);
OP (FH, D, A, B, C, 8, 11, 0x8771f681);
OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);
OP (FH, B, C, D, A, 14, 23, 0xfde5380c);
OP (FH, A, B, C, D, 1, 4, 0xa4beea44);
OP (FH, D, A, B, C, 4, 11, 0x4bdecfa9);
OP (FH, C, D, A, B, 7, 16, 0xf6bb4b60);
OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);
OP (FH, A, B, C, D, 13, 4, 0x289b7ec6);
OP (FH, D, A, B, C, 0, 11, 0xeaa127fa);
OP (FH, C, D, A, B, 3, 16, 0xd4ef3085);
OP (FH, B, C, D, A, 6, 23, 0x04881d05);
OP (FH, A, B, C, D, 9, 4, 0xd9d4d039);
OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);
OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);
OP (FH, B, C, D, A, 2, 23, 0xc4ac5665);
/* Round 4. */
OP (FI, A, B, C, D, 0, 6, 0xf4292244);
OP (FI, D, A, B, C, 7, 10, 0x432aff97);
OP (FI, C, D, A, B, 14, 15, 0xab9423a7);
OP (FI, B, C, D, A, 5, 21, 0xfc93a039);
OP (FI, A, B, C, D, 12, 6, 0x655b59c3);
OP (FI, D, A, B, C, 3, 10, 0x8f0ccc92);
OP (FI, C, D, A, B, 10, 15, 0xffeff47d);
OP (FI, B, C, D, A, 1, 21, 0x85845dd1);
OP (FI, A, B, C, D, 8, 6, 0x6fa87e4f);
OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
OP (FI, C, D, A, B, 6, 15, 0xa3014314);
OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);
OP (FI, A, B, C, D, 4, 6, 0xf7537e82);
OP (FI, D, A, B, C, 11, 10, 0xbd3af235);
OP (FI, C, D, A, B, 2, 15, 0x2ad7d2bb);
OP (FI, B, C, D, A, 9, 21, 0xeb86d391);
/* Add the starting values of the context. */
A += A_save;
B += B_save;
C += C_save;
D += D_save;
}
/* Put checksum in context given as argument. */
ctx->A = A;
ctx->B = B;
ctx->C = C;
ctx->D = D;
}

125
3dc/win95/md5.h
View file

@ -1,125 +0,0 @@
#ifdef __cplusplus
extern "C"{
#endif
/* md5.h - Declaration of functions and data types used for MD5 sum
computing library functions.
Copyright (C) 1995 Free Software Foundation, Inc.
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, 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. */
#ifndef _MD5_H
#define _MD5_H
#include <stdio.h>
#if defined HAVE_LIMITS_H || _LIBC
# include <limits.h>
#endif
/* The following contortions are an attempt to use the C preprocessor
to determine an unsigned integral type that is 32 bits wide. An
alternative approach is to use autoconf's AC_CHECK_SIZEOF macro, but
doing that would require that the configure script compile and *run*
the resulting executable. Locally running cross-compiled executables
is usually not possible. */
#if defined __STDC__ && __STDC__
# define UINT_MAX_32_BITS 4294967295U
#else
# define UINT_MAX_32_BITS 0xFFFFFFFF
#endif
/* If UINT_MAX isn't defined, assume it's a 32-bit type.
This should be valid for all systems GNU cares about because
that doesn't include 16-bit systems, and only modern systems
(that certainly have <limits.h>) have 64+-bit integral types. */
#ifndef UINT_MAX
# define UINT_MAX UINT_MAX_32_BITS
#endif
#if UINT_MAX == UINT_MAX_32_BITS
typedef unsigned int md5_uint32;
#else
# if USHRT_MAX == UINT_MAX_32_BITS
typedef unsigned short md5_uint32;
# else
# if ULONG_MAX == UINT_MAX_32_BITS
typedef unsigned long md5_uint32;
# else
/* The following line is intended to evoke an error.
Using #error is not portable enough. */
"Cannot determine unsigned 32-bit data type."
# endif
# endif
#endif
#undef __P
#if defined (__STDC__) && __STDC__
#define __P(x) x
#else
#define __P(x) ()
#endif
/* Structure to save state of computation between the single steps. */
struct md5_ctx
{
md5_uint32 A;
md5_uint32 B;
md5_uint32 C;
md5_uint32 D;
};
/*
* The following three functions are build up the low level used in
* the functions `md5_stream' and `md5_buffer'.
*/
/* Initialize structure containing state of computation.
(RFC 1321, 3.3: Step 3) */
void md5_init_ctx __P ((struct md5_ctx *ctx));
/* Starting with the result of former calls of this function (or the
initialzation function update the context for the next LEN bytes
starting at BUFFER.
It is necessary that LEN is a multiple of 64!!! */
void md5_process_block __P ((const void *buffer, size_t len,
struct md5_ctx *ctx));
/* Put result from CTX in first 16 bytes following RESBUF. The result is
always in little endian byte order, so that a byte-wise output yields
to the wanted ASCII representation of the message digest. */
void *md5_read_ctx __P ((const struct md5_ctx *ctx, void *resbuf));
/* Compute MD5 message digest for bytes read from STREAM. The
resulting message digest number will be written into the 16 bytes
beginning at RESBLOCK. */
int md5_stream __P ((FILE *stream, void *resblock));
/* Compute MD5 message digest for LEN bytes beginning at BUFFER. The
result is always in little endian byte order, so that a byte-wise
output yields to the wanted ASCII representation of the message
digest. */
//void *md5_buffer __P((const char *buffer, size_t len, void *resblock));
void *md5_buffer (const char *buffer, size_t len, void *resblock);
#endif
#ifdef __cplusplus
};
#endif

775
3dc/win95/smacker.c
View file

@ -1,775 +0,0 @@
/* KJL 15:25:20 8/16/97
*
* smacker.c - functions to handle FMV playback
*
*/
#include "3dc.h"
#include "module.h"
#include "inline.h"
#include "stratdef.h"
#include "gamedef.h"
#include "smacker.h"
#include "avp_menus.h"
#include "avp_userprofile.h"
#include "d3_func.h"
#define UseLocalAssert 1
#include "ourasert.h"
int VolumeOfNearestVideoScreen;
int PanningOfNearestVideoScreen;
extern char *ScreenBuffer;
extern LPDIRECTSOUND DSObject;
extern int GotAnyKey;
extern void DirectReadKeyboard(void);
extern IMAGEHEADER ImageHeaderArray[];
#if MaxImageGroups>1
extern int NumImagesArray[];
#else
extern int NumImages;
#endif
void PlayFMV(char *filenamePtr);
static int NextSmackerFrame(Smack *smackHandle);
static UpdatePalette(Smack *smackHandle);
static int GetSmackerPixelFormat(DDPIXELFORMAT *pixelFormatPtr);
void FindLightingValueFromFMV(unsigned short *bufferPtr);
void FindLightingValuesFromTriggeredFMV(unsigned char *bufferPtr, FMVTEXTURE *ftPtr);
int SmackerSoundVolume=ONE_FIXED/512;
int MoviesAreActive;
int IntroOutroMoviesAreActive=1;
int FmvColourRed;
int FmvColourGreen;
int FmvColourBlue;
void PlayFMV(char *filenamePtr)
{
Smack* smackHandle;
int playing = 1;
if (!IntroOutroMoviesAreActive) return;
/* use Direct sound */
SmackSoundUseDirectSound(DSObject);
/* open smacker file */
smackHandle = SmackOpen(filenamePtr,SMACKTRACKS,SMACKAUTOEXTRA);
if (!smackHandle)
{
char message[100];
sprintf(message,"Unable to access file: %s\n",filenamePtr);
MessageBox(NULL,message,"AvP Error",MB_OK+MB_SYSTEMMODAL);
exit(0x111);
return;
}
while(playing)
{
CheckForWindowsMessages();
if (!SmackWait(smackHandle))
playing = NextSmackerFrame(smackHandle);
/* do something else */
// *(ScreenBuffer + 300*640 + smackHandle->FrameNum) = 255;
FlipBuffers();
#if ALLOW_SKIP_INTRO
DirectReadKeyboard();
if (GotAnyKey) playing = 0;
#endif
}
/* close file */
SmackClose(smackHandle);
}
static int NextSmackerFrame(Smack *smackHandle)
{
/* do we have to change the palette? */
// if (smackHandle->NewPalette) UpdatePalette(smackHandle);
/* unpack frame */
extern DDPIXELFORMAT DisplayPixelFormat;
SmackToBuffer(smackHandle,(640-smackHandle->Width)/2,(480-smackHandle->Height)/2,640*2,480,(void*)ScreenBuffer,GetSmackerPixelFormat(&DisplayPixelFormat));
SmackDoFrame(smackHandle);
/* are we at the last frame yet? */
if ((smackHandle->FrameNum==(smackHandle->Frames-1))) return 0;
/* next frame, please */
SmackNextFrame(smackHandle);
return 1;
}
Smack* SmackHandle[4];
#define FMV_ON 0
void InitFMV(void)
{
#if FMV_ON
// char *filenamePtr = "fmvs/hugtest.smk";//"dd64_64.smk";//nintendo.smk";//"trailer.smk";//"m_togran.smk";
/* use Direct sound */
// SmackSoundUseDirectSound(DSObject);
/* open smacker file */
SmackHandle[0] = SmackOpen("fmvs/tyrargo.smk",SMACKTRACKS,SMACKAUTOEXTRA);
SmackHandle[1] = SmackOpen("fmvs/final.smk",SMACKTRACKS,SMACKAUTOEXTRA);
SmackHandle[2] = SmackOpen("fmvs/hugtest.smk",SMACKTRACKS,SMACKAUTOEXTRA);
SmackHandle[3] = SmackOpen("fmvs/alien.smk",SMACKTRACKS,SMACKAUTOEXTRA);
#endif
}
int NextFMVFrame(void*bufferPtr, int x, int y, int w, int h, int fmvNumber)
{
#if FMV_ON
int smackerFormat;
if(!SmackHandle[fmvNumber]) return 0;
if (SmackWait(SmackHandle[fmvNumber])) return 0;
/* unpack frame */
{
extern D3DINFO d3d;
smackerFormat = GetSmackerPixelFormat(&(d3d.TextureFormat[d3d.CurrentTextureFormat].ddsd.ddpfPixelFormat));
}
if (smackerFormat) w*=2;
// if (fmvNumber==0) FindLightingValueFromFMV((unsigned short *)bufferPtr);
SmackToBuffer(SmackHandle[fmvNumber],x,y,w,h,(void*)bufferPtr,smackerFormat);
SmackDoFrame(SmackHandle[fmvNumber]);
// textprint("at frame %d\n",SmackHandle->FrameNum);
/* next frame, please */
SmackNextFrame(SmackHandle[fmvNumber]);
#endif
return 1;
}
void UpdateFMVPalette(PALETTEENTRY *FMVPalette, int fmvNumber)
{
unsigned char *c;
int i;
if(!SmackHandle[fmvNumber]) return;
c=SmackHandle[fmvNumber]->Palette;
for(i=0;i<256;i++)
{
FMVPalette[i].peRed=(*c++);
FMVPalette[i].peGreen=(*c++);
FMVPalette[i].peBlue=(*c++);
}
}
void CloseFMV(void)
{
#if FMV_ON
extern void KillFMVTexture(void);
if(SmackHandle[0]) SmackClose(SmackHandle[0]);
if(SmackHandle[1]) SmackClose(SmackHandle[1]);
if(SmackHandle[2]) SmackClose(SmackHandle[2]);
if(SmackHandle[3]) SmackClose(SmackHandle[3]);
KillFMVTexture();
#endif
}
static int GetSmackerPixelFormat(DDPIXELFORMAT *pixelFormatPtr)
{
if( (pixelFormatPtr->dwFlags & DDPF_RGB) && !(pixelFormatPtr->dwFlags & DDPF_PALETTEINDEXED8) )
{
int m;
int redShift=0;
m = pixelFormatPtr->dwRBitMask;
LOCALASSERT(m);
while(!(m&1)) m>>=1;
while(m&1)
{
m>>=1;
redShift++;
}
if(redShift == 5)
{
/* Red componant is 5. */
int greenShift=0;
m = pixelFormatPtr->dwGBitMask;
LOCALASSERT(m);
while(!(m&1)) m>>=1;
while(m&1)
{
m>>=1;
greenShift++;
}
if(greenShift == 5)
{
/* Green componant is 5. */
int blueShift=0;
m = pixelFormatPtr->dwBBitMask;
LOCALASSERT(m);
while(!(m&1)) m>>=1;
while(m&1)
{
m>>=1;
blueShift++;
}
if(blueShift == 5)
{
/* Blue componant is 5. */
return SMACKBUFFER555;
}
else
{
/* Blue componant is 6. */
// not supported
LOCALASSERT("Smacker does not support this pixel format"==0);
return SMACKBUFFER555;
//return SMACKBUFFER556;
}
}
else
{
/* Green componant is 6. */
return SMACKBUFFER565;
}
}
else
{
/* Red componant is 6. */
// not supported
LOCALASSERT("Smacker does not support this pixel format"==0);
return SMACKBUFFER555;
//return SMACKBUFFER655;
}
}
else
{
return 0;
}
}
void StartMenuMusic(void)
{
char *filenamePtr = "fmvs/introsound.smk";
/* use Direct sound */
SmackSoundUseDirectSound(DSObject);
/* open smacker file */
SmackHandle[0] = SmackOpen(filenamePtr,SMACKTRACKS|SMACKNEEDVOLUME|SMACKNEEDPAN,SMACKAUTOEXTRA);
}
void PlayMenuMusic(void)
{
if(!SmackHandle[0]) return;
SmackVolumePan(SmackHandle[0],SMACKTRACKS,SmackerSoundVolume*256,32768);
if (SmackWait(SmackHandle[0])) return;
/* unpack frame */
SmackDoFrame(SmackHandle[0]);
/* next frame, please */
SmackNextFrame(SmackHandle[0]);
}
void EndMenuMusic(void)
{
if(!SmackHandle[0]) return;
SmackClose(SmackHandle[0]);
}
void FindLightingValueFromFMV(unsigned short *bufferPtr)
{
unsigned int totalRed=0;
unsigned int totalBlue=0;
unsigned int totalGreen=0;
int pixels = 128*96;//64*48;//256*192;
do
{
int source = (int)(*bufferPtr++);
totalBlue += source&31;
source>>=5;
totalGreen += source&63;
source>>=6;
totalRed += source&31;
}
while(--pixels);
FmvColourRed = totalRed*4/24;
FmvColourGreen = totalGreen*4/48;
FmvColourBlue = totalBlue*4/24;
}
void FindLightingValueFromCentredFMV(unsigned short *bufferPtr)
{
unsigned int totalRed=0;
unsigned int totalBlue=0;
unsigned int totalGreen=0;
int x,y;
for (y=32; y<32+48; y++)
for (x=32; x<32+64; x++)
{
int source = (int)(*(unsigned short*)(bufferPtr+x+y*128));
totalBlue += source&31;
source>>=5;
totalGreen += source&63;
source>>=6;
totalRed += source&31;
}
FmvColourRed = totalRed*4/24;
FmvColourGreen = totalGreen*4/48;
FmvColourBlue = totalBlue*4/24;
}
/* KJL 12:45:23 10/08/98 - FMVTEXTURE stuff */
#define MAX_NO_FMVTEXTURES 10
FMVTEXTURE FMVTexture[MAX_NO_FMVTEXTURES];
int NumberOfFMVTextures;
void ScanImagesForFMVs(void)
{
extern void SetupFMVTexture(FMVTEXTURE *ftPtr);
int i;
IMAGEHEADER *ihPtr;
NumberOfFMVTextures=0;
#if MaxImageGroups>1
for (j=0; j<MaxImageGroups; j++)
{
if (NumImagesArray[j])
{
ihPtr = &ImageHeaderArray[j*MaxImages];
for (i = 0; i<NumImagesArray[j]; i++, ihPtr++)
{
#else
{
if(NumImages)
{
ihPtr = &ImageHeaderArray[0];
for (i = 0; i<NumImages; i++, ihPtr++)
{
#endif
char *strPtr;
if(strPtr = strstr(ihPtr->ImageName,"FMVs"))
{
Smack *smackHandle;
char filename[30];
{
char *filenamePtr = filename;
do
{
*filenamePtr++ = *strPtr;
}
while(*strPtr++!='.');
*filenamePtr++='s';
*filenamePtr++='m';
*filenamePtr++='k';
*filenamePtr=0;
}
smackHandle = SmackOpen(filename,SMACKTRACKS|SMACKNEEDVOLUME|SMACKNEEDPAN,SMACKAUTOEXTRA);
if (smackHandle)
{
FMVTexture[NumberOfFMVTextures].IsTriggeredPlotFMV = 0;
}
else
{
FMVTexture[NumberOfFMVTextures].IsTriggeredPlotFMV = 1;
}
{
FMVTexture[NumberOfFMVTextures].SmackHandle = smackHandle;
FMVTexture[NumberOfFMVTextures].ImagePtr = ihPtr;
FMVTexture[NumberOfFMVTextures].StaticImageDrawn=0;
SetupFMVTexture(&FMVTexture[NumberOfFMVTextures]);
NumberOfFMVTextures++;
}
}
}
}
}
}
void UpdateAllFMVTextures(void)
{
extern void UpdateFMVTexture(FMVTEXTURE *ftPtr);
int i = NumberOfFMVTextures;
while(i--)
{
UpdateFMVTexture(&FMVTexture[i]);
}
}
void ReleaseAllFMVTextures(void)
{
extern void UpdateFMVTexture(FMVTEXTURE *ftPtr);
int i = NumberOfFMVTextures;
while(i--)
{
FMVTexture[i].MessageNumber = 0;
if(FMVTexture[i].SmackHandle)
{
SmackClose(FMVTexture[i].SmackHandle);
FMVTexture[i].SmackHandle=0;
}
if (FMVTexture[i].SrcTexture)
{
ReleaseD3DTexture(FMVTexture[i].SrcTexture);
FMVTexture[i].SrcTexture=0;
}
if (FMVTexture[i].SrcSurface)
{
ReleaseDDSurface(FMVTexture[i].SrcSurface);
FMVTexture[i].SrcSurface=0;
}
if (FMVTexture[i].DestTexture)
{
ReleaseD3DTexture(FMVTexture[i].DestTexture);
FMVTexture[i].DestTexture = 0;
}
}
}
int NextFMVTextureFrame(FMVTEXTURE *ftPtr, void *bufferPtr)
{
int smackerFormat;
int w = 128;
{
extern D3DINFO d3d;
smackerFormat = GetSmackerPixelFormat(&(d3d.TextureFormat[d3d.CurrentTextureFormat].ddsd.ddpfPixelFormat));
}
if (smackerFormat) w*=2;
if (MoviesAreActive && ftPtr->SmackHandle)
{
int volume = MUL_FIXED(SmackerSoundVolume*256,GetVolumeOfNearestVideoScreen());
SmackVolumePan(ftPtr->SmackHandle,SMACKTRACKS,volume,PanningOfNearestVideoScreen);
ftPtr->SoundVolume = SmackerSoundVolume;
if (SmackWait(ftPtr->SmackHandle)) return 0;
/* unpack frame */
SmackToBuffer(ftPtr->SmackHandle,0,0,w,96,bufferPtr,smackerFormat);
SmackDoFrame(ftPtr->SmackHandle);
/* are we at the last frame yet? */
if (ftPtr->IsTriggeredPlotFMV && (ftPtr->SmackHandle->FrameNum==(ftPtr->SmackHandle->Frames-1)) )
{
SmackClose(ftPtr->SmackHandle);
ftPtr->SmackHandle = 0;
ftPtr->MessageNumber = 0;
}
else
{
/* next frame, please */
SmackNextFrame(ftPtr->SmackHandle);
}
ftPtr->StaticImageDrawn=0;
}
else if (!ftPtr->StaticImageDrawn || smackerFormat)
{
int i = w*96/4;
unsigned int seed = FastRandom();
int *ptr = (int*)bufferPtr;
do
{
seed = ((seed*1664525)+1013904223);
*ptr++ = seed;
}
while(--i);
ftPtr->StaticImageDrawn=1;
}
FindLightingValuesFromTriggeredFMV((unsigned char*)bufferPtr,ftPtr);
return 1;
}
void UpdateFMVTexturePalette(FMVTEXTURE *ftPtr)
{
unsigned char *c;
int i;
if (MoviesAreActive && ftPtr->SmackHandle)
{
c=ftPtr->SmackHandle->Palette;
for(i=0;i<256;i++)
{
ftPtr->SrcPalette[i].peRed=(*c++);
ftPtr->SrcPalette[i].peGreen=(*c++);
ftPtr->SrcPalette[i].peBlue=(*c++);
}
}
else
{
{
unsigned int seed = FastRandom();
for(i=0;i<256;i++)
{
int l = (seed&(seed>>24)&(seed>>16));
seed = ((seed*1664525)+1013904223);
ftPtr->SrcPalette[i].peRed=l;
ftPtr->SrcPalette[i].peGreen=l;
ftPtr->SrcPalette[i].peBlue=l;
}
}
}
}
extern void StartTriggerPlotFMV(int number)
{
int i = NumberOfFMVTextures;
char buffer[25];
if (CheatMode_Active != CHEATMODE_NONACTIVE) return;
sprintf(buffer,"FMVs//message%d.smk",number);
{
FILE* file=fopen(buffer,"rb");
if(!file)
{
return;
}
fclose(file);
}
while(i--)
{
if (FMVTexture[i].IsTriggeredPlotFMV)
{
if(FMVTexture[i].SmackHandle)
{
SmackClose(FMVTexture[i].SmackHandle);
}
FMVTexture[i].SmackHandle = SmackOpen(&buffer,SMACKTRACKS|SMACKNEEDVOLUME|SMACKNEEDPAN,SMACKAUTOEXTRA);
FMVTexture[i].MessageNumber = number;
}
}
}
extern void StartFMVAtFrame(int number, int frame)
{
int i = NumberOfFMVTextures;
StartTriggerPlotFMV(number);
while(i--)
{
if (FMVTexture[i].IsTriggeredPlotFMV)
{
if(FMVTexture[i].SmackHandle)
{
SmackSoundOnOff(FMVTexture[i].SmackHandle,0); // turn off sound so that it is synched
SmackGoto(FMVTexture[i].SmackHandle,frame);
SmackSoundOnOff(FMVTexture[i].SmackHandle,1); // turn on sound so that it is synched
// SmackNextFrame(FMVTexture[i].SmackHandle);
}
}
}
}
extern void GetFMVInformation(int *messageNumberPtr, int *frameNumberPtr)
{
int i = NumberOfFMVTextures;
while(i--)
{
if (FMVTexture[i].IsTriggeredPlotFMV)
{
if(FMVTexture[i].SmackHandle)
{
*messageNumberPtr = FMVTexture[i].MessageNumber;
*frameNumberPtr = FMVTexture[i].SmackHandle->FrameNum;
return;
}
}
}
*messageNumberPtr = 0;
*frameNumberPtr = 0;
}
extern void InitialiseTriggeredFMVs(void)
{
int i = NumberOfFMVTextures;
while(i--)
{
if (FMVTexture[i].IsTriggeredPlotFMV)
{
if(FMVTexture[i].SmackHandle)
{
SmackClose(FMVTexture[i].SmackHandle);
FMVTexture[i].MessageNumber = 0;
}
FMVTexture[i].SmackHandle = 0;
}
}
}
void FindLightingValuesFromTriggeredFMV(unsigned char *bufferPtr, FMVTEXTURE *ftPtr)
{
unsigned int totalRed=0;
unsigned int totalBlue=0;
unsigned int totalGreen=0;
#if 0
int pixels = 128*96;//64*48;//256*192;
do
{
unsigned char source = (*bufferPtr++);
totalBlue += ftPtr->SrcPalette[source].peBlue;
totalGreen += ftPtr->SrcPalette[source].peGreen;
totalRed += ftPtr->SrcPalette[source].peRed;
}
while(--pixels);
#else
int pixels = 128*96/4;//64*48;//256*192;
unsigned int *source = (unsigned int*) (bufferPtr);
do
{
int s = *source++;
{
int t = s&255;
totalBlue += ftPtr->SrcPalette[t].peBlue;
totalGreen += ftPtr->SrcPalette[t].peGreen;
totalRed += ftPtr->SrcPalette[t].peRed;
}
#if 0
s >>=8;
{
int t = s&255;
totalBlue += ftPtr->SrcPalette[t].peBlue;
totalGreen += ftPtr->SrcPalette[t].peGreen;
totalRed += ftPtr->SrcPalette[t].peRed;
}
s >>=8;
{
int t = s&255;
totalBlue += ftPtr->SrcPalette[t].peBlue;
totalGreen += ftPtr->SrcPalette[t].peGreen;
totalRed += ftPtr->SrcPalette[t].peRed;
}
s >>=8;
{
int t = s;
totalBlue += ftPtr->SrcPalette[t].peBlue;
totalGreen += ftPtr->SrcPalette[t].peGreen;
totalRed += ftPtr->SrcPalette[t].peRed;
}
#endif
}
while(--pixels);
#endif
FmvColourRed = totalRed/48*16;
FmvColourGreen = totalGreen/48*16;
FmvColourBlue = totalBlue/48*16;
}
extern int NumActiveBlocks;
extern DISPLAYBLOCK *ActiveBlockList[];
#include "showcmds.h"
int GetVolumeOfNearestVideoScreen(void)
{
extern VIEWDESCRIPTORBLOCK *Global_VDB_Ptr;
int numberOfObjects = NumActiveBlocks;
int leastDistanceRecorded = 0x7fffffff;
VolumeOfNearestVideoScreen = 0;
{
extern char LevelName[];
if (!_stricmp(LevelName,"invasion_a"))
{
VolumeOfNearestVideoScreen = ONE_FIXED;
PanningOfNearestVideoScreen = ONE_FIXED/2;
}
}
while (numberOfObjects)
{
DISPLAYBLOCK* objectPtr = ActiveBlockList[--numberOfObjects];
STRATEGYBLOCK* sbPtr = objectPtr->ObStrategyBlock;
if (sbPtr)
{
if (sbPtr->I_SBtype == I_BehaviourVideoScreen)
{
int dist;
VECTORCH disp;
disp.vx = objectPtr->ObWorld.vx - Global_VDB_Ptr->VDB_World.vx;
disp.vy = objectPtr->ObWorld.vy - Global_VDB_Ptr->VDB_World.vy;
disp.vz = objectPtr->ObWorld.vz - Global_VDB_Ptr->VDB_World.vz;
dist = Approximate3dMagnitude(&disp);
if (dist<leastDistanceRecorded && dist<ONE_FIXED)
{
leastDistanceRecorded = dist;
VolumeOfNearestVideoScreen = ONE_FIXED + 1024 - dist/2;
if (VolumeOfNearestVideoScreen>ONE_FIXED) VolumeOfNearestVideoScreen = ONE_FIXED;
{
VECTORCH rightEarDirection;
#if 0
rightEarDirection.vx = Global_VDB_Ptr->VDB_Mat.mat11;
rightEarDirection.vy = Global_VDB_Ptr->VDB_Mat.mat12;
rightEarDirection.vz = Global_VDB_Ptr->VDB_Mat.mat13;
Normalise(&disp);
#else
rightEarDirection.vx = Global_VDB_Ptr->VDB_Mat.mat11;
rightEarDirection.vy = 0;
rightEarDirection.vz = Global_VDB_Ptr->VDB_Mat.mat31;
disp.vy=0;
Normalise(&disp);
Normalise(&rightEarDirection);
#endif
PanningOfNearestVideoScreen = 32768 + DotProduct(&disp,&rightEarDirection)/2;
}
}
}
}
}
PrintDebuggingText("Volume: %d, Pan %d\n",VolumeOfNearestVideoScreen,PanningOfNearestVideoScreen);
return VolumeOfNearestVideoScreen;
}

43
3dc/win95/smacker.h
View file

@ -1,43 +0,0 @@
/* KJL 15:25:20 8/16/97
*
* smacker.h - functions to handle FMV playback
*
*/
#include "smack.h"
extern void PlayFMV(char *filenamePtr);
extern void StartMenuMusic(void);
extern void PlayMenuMusic(void);
extern void EndMenuMusic(void);
typedef struct
{
IMAGEHEADER *ImagePtr;
Smack *SmackHandle;
int SoundVolume;
int IsTriggeredPlotFMV;
int StaticImageDrawn;
int MessageNumber;
LPDIRECTDRAWSURFACE SrcSurface;
LPDIRECT3DTEXTURE SrcTexture;
LPDIRECT3DTEXTURE DestTexture;
PALETTEENTRY SrcPalette[256];
int RedScale;
int GreenScale;
int BlueScale;
} FMVTEXTURE;
extern int NextFMVTextureFrame(FMVTEXTURE *ftPtr, void *bufferPtr);
extern void UpdateFMVTexturePalette(FMVTEXTURE *ftPtr);
extern void InitialiseTriggeredFMVs(void);
extern void StartTriggerPlotFMV(int number);
extern void StartFMVAtFrame(int number, int frame);
extern void GetFMVInformation(int *messageNumberPtr, int *frameNumberPtr);

BIN
3dc/win95/vssver.scc
View file

Binary file not shown.

2100
AvP.dsp
View file

File diff suppressed because it is too large Load diff

29
AvP.dsw
View file

@ -1,29 +0,0 @@
Microsoft Developer Studio Workspace File, Format Version 6.00
# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
###############################################################################
Project: "AvP"=.\AvP.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
}}}
###############################################################################
Global:
Package=<5>
{{{
}}}
Package=<3>
{{{
}}}
###############################################################################

BIN
AvP.opt
View file

Binary file not shown.

515
AvP.plg
View file

@ -1,515 +0,0 @@
<html>
<body>
<pre>
<h1>Build Log</h1>
<h3>
--------------------Configuration: AvP - Win32 Release For Fox--------------------
</h3>
<h3>Command Lines</h3>
Creating temporary file "c:\windows\TEMP\RSPA0F3.TMP" with contents
[
/nologo /Zp4 /MT /W3 /GX /O2 /I "c:\mssdk\include" /I "3dc" /I "3dc\avp" /I "3dc\avp\support" /I "3dc\avp\win95" /I "3dc\avp\win95\frontend" /I "3dc\avp\win95\gadgets" /I "3dc\include" /I "3dc\win95" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D engine=1 /D "__STDC__" /Fp"AvP___Win32_Release_For_Fox/AvP.pch" /YX /Fo"AvP___Win32_Release_For_Fox/" /Fd"AvP___Win32_Release_For_Fox/" /FD /c
"C:\AvP_vc\3dc\Afont.c"
"C:\AvP_vc\3dc\avp\win95\gadgets\ahudgadg.cpp"
"C:\AvP_vc\3dc\avp\AI_Sight.c"
"C:\AvP_vc\3dc\win95\alt_tab.cpp"
"C:\AvP_vc\3dc\win95\Animchnk.cpp"
"C:\AvP_vc\3dc\win95\animobs.cpp"
"C:\AvP_vc\3dc\avp\win95\Frontend\AvP_EnvInfo.c"
"C:\AvP_vc\3dc\avp\win95\Frontend\AvP_Intro.cpp"
"C:\AvP_vc\3dc\avp\win95\Frontend\AvP_MenuData.c"
"C:\AvP_vc\3dc\avp\win95\Frontend\AvP_MenuGfx.cpp"
"C:\AvP_vc\3dc\avp\win95\Frontend\AvP_Menus.c"
"C:\AvP_vc\3dc\avp\win95\Frontend\AvP_MP_Config.cpp"
"C:\AvP_vc\3dc\avp\win95\Frontend\AvP_UserProfile.cpp"
"C:\AvP_vc\3dc\avp\win95\Avpchunk.cpp"
"C:\AvP_vc\3dc\avp\win95\AvpReg.cpp"
"C:\AvP_vc\3dc\avp\Avpview.c"
"C:\AvP_vc\3dc\win95\awBmpLd.cpp"
"C:\AvP_vc\3dc\win95\awIffLd.cpp"
"C:\AvP_vc\3dc\win95\awPnmLd.cpp"
"C:\AvP_vc\3dc\win95\awTexLd.cpp"
"C:\AvP_vc\3dc\avp\bh_agun.c"
"C:\AvP_vc\3dc\avp\bh_ais.c"
"C:\AvP_vc\3dc\avp\Bh_alien.c"
"C:\AvP_vc\3dc\avp\Bh_binsw.c"
"C:\AvP_vc\3dc\avp\bh_cable.c"
"C:\AvP_vc\3dc\avp\bh_corpse.c"
"C:\AvP_vc\3dc\avp\bh_deathvol.c"
"C:\AvP_vc\3dc\avp\Bh_debri.c"
"C:\AvP_vc\3dc\avp\bh_dummy.c"
"C:\AvP_vc\3dc\avp\bh_fan.c"
"C:\AvP_vc\3dc\avp\bh_far.c"
"C:\AvP_vc\3dc\avp\Bh_fhug.c"
"C:\AvP_vc\3dc\avp\Bh_gener.c"
"C:\AvP_vc\3dc\avp\bh_ldoor.c"
"C:\AvP_vc\3dc\avp\bh_lift.c"
"C:\AvP_vc\3dc\avp\bh_light.c"
"C:\AvP_vc\3dc\avp\Bh_lnksw.c"
"C:\AvP_vc\3dc\avp\bh_ltfx.c"
"C:\AvP_vc\3dc\avp\Bh_marin.c"
"C:\AvP_vc\3dc\avp\bh_mission.c"
"C:\AvP_vc\3dc\avp\Bh_near.c"
"C:\AvP_vc\3dc\avp\bh_pargen.c"
"C:\AvP_vc\3dc\avp\bh_plachier.c"
"C:\AvP_vc\3dc\avp\bh_plift.c"
"C:\AvP_vc\3dc\avp\Bh_pred.c"
"C:\AvP_vc\3dc\avp\bh_queen.c"
"C:\AvP_vc\3dc\avp\bh_RubberDuck.c"
"C:\AvP_vc\3dc\avp\bh_selfdest.c"
"C:\AvP_vc\3dc\avp\bh_snds.c"
"C:\AvP_vc\3dc\avp\bh_spcl.c"
"C:\AvP_vc\3dc\avp\Bh_swdor.c"
"C:\AvP_vc\3dc\avp\bh_track.c"
"C:\AvP_vc\3dc\avp\Bh_types.c"
"C:\AvP_vc\3dc\avp\bh_videoscreen.c"
"C:\AvP_vc\3dc\avp\bh_waypt.c"
"C:\AvP_vc\3dc\avp\bh_weap.c"
"C:\AvP_vc\3dc\avp\Bh_xeno.c"
"C:\AvP_vc\3dc\win95\bink.c"
"C:\AvP_vc\3dc\win95\Bmpnames.cpp"
"C:\AvP_vc\3dc\avp\BonusAbilities.c"
"C:\AvP_vc\3dc\avp\cconvars.cpp"
"C:\AvP_vc\3dc\win95\CD_player.c"
"C:\AvP_vc\3dc\avp\CDTrackSelection.cpp"
"C:\AvP_vc\3dc\avp\win95\Cheat.c"
"C:\AvP_vc\3dc\avp\CheatModes.c"
"C:\AvP_vc\3dc\win95\chnkload.cpp"
"C:\AvP_vc\3dc\win95\Chnktexi.cpp"
"C:\AvP_vc\3dc\win95\Chnktype.cpp"
"C:\AvP_vc\3dc\avp\win95\chtcodes.cpp"
"C:\AvP_vc\3dc\win95\Chunk.cpp"
"C:\AvP_vc\3dc\win95\Chunkpal.cpp"
"C:\AvP_vc\3dc\avp\comp_map.c"
"C:\AvP_vc\3dc\avp\Comp_shp.c"
"C:\AvP_vc\3dc\avp\support\consbind.cpp"
"C:\AvP_vc\3dc\avp\support\consbtch.cpp"
"C:\AvP_vc\3dc\avp\win95\gadgets\conscmnd.cpp"
"C:\AvP_vc\3dc\avp\ConsoleLog.cpp"
"C:\AvP_vc\3dc\avp\win95\gadgets\conssym.cpp"
"C:\AvP_vc\3dc\avp\win95\gadgets\consvar.cpp"
"C:\AvP_vc\3dc\avp\support\Coordstr.cpp"
"C:\AvP_vc\3dc\avp\shapes\Cube.c"
"C:\AvP_vc\3dc\win95\d3_func.cpp"
"C:\AvP_vc\3dc\avp\win95\d3d_hud.cpp"
"C:\AvP_vc\3dc\avp\win95\d3d_render.cpp"
"C:\AvP_vc\3dc\avp\support\Daemon.cpp"
"C:\AvP_vc\3dc\avp\davehook.cpp"
"C:\AvP_vc\3dc\win95\db.c"
"C:\AvP_vc\3dc\win95\Dd_func.cpp"
"C:\AvP_vc\3dc\avp\win95\Ddplat.cpp"
"C:\AvP_vc\3dc\avp\deaths.c"
"C:\AvP_vc\3dc\win95\Debuglog.cpp"
"C:\AvP_vc\3dc\avp\decal.c"
"C:\AvP_vc\3dc\avp\DetailLevels.c"
"C:\AvP_vc\3dc\win95\Di_func.cpp"
"C:\AvP_vc\3dc\avp\win95\DirectPlay.c"
"C:\AvP_vc\3dc\avp\win95\Dp_func.c"
"C:\AvP_vc\3dc\avp\win95\dplayext.c"
"C:\AvP_vc\3dc\win95\DummyObjectChunk.cpp"
"C:\AvP_vc\3dc\avp\win95\dx_proj.cpp"
"C:\AvP_vc\3dc\win95\Dxlog.c"
"C:\AvP_vc\3dc\avp\Dynamics.c"
"C:\AvP_vc\3dc\avp\Dynblock.c"
"C:\AvP_vc\3dc\avp\win95\endianio.c"
"C:\AvP_vc\3dc\win95\Enumchnk.cpp"
"C:\AvP_vc\3dc\win95\Enumsch.cpp"
"C:\AvP_vc\3dc\win95\Envchunk.cpp"
"C:\AvP_vc\3dc\avp\Equipmnt.c"
"C:\AvP_vc\3dc\avp\equiputl.cpp"
"C:\AvP_vc\3dc\avp\extents.c"
"C:\AvP_vc\3dc\win95\fail.c"
"C:\AvP_vc\3dc\avp\win95\Ffread.cpp"
"C:\AvP_vc\3dc\avp\win95\Ffstdio.cpp"
"C:\AvP_vc\3dc\win95\fragchnk.cpp"
"C:\AvP_vc\3dc\frustrum.c"
"C:\AvP_vc\3dc\avp\win95\gadgets\gadget.cpp"
"C:\AvP_vc\3dc\avp\Game.c"
"C:\AvP_vc\3dc\avp\game_statistics.c"
"C:\AvP_vc\3dc\avp\gamecmds.cpp"
"C:\AvP_vc\3dc\avp\gameflow.c"
"C:\AvP_vc\3dc\avp\gamevars.cpp"
"C:\AvP_vc\3dc\avp\win95\GammaControl.cpp"
"C:\AvP_vc\3dc\avp\win95\gflwplat.c"
"C:\AvP_vc\3dc\win95\Gsprchnk.cpp"
"C:\AvP_vc\3dc\win95\hierchnk.cpp"
"C:\AvP_vc\3dc\avp\win95\hierplace.cpp"
"C:\AvP_vc\3dc\avp\HModel.c"
"C:\AvP_vc\3dc\avp\Hud.c"
"C:\AvP_vc\3dc\avp\win95\gadgets\hudgadg.cpp"
"C:\AvP_vc\3dc\win95\huffman.cpp"
"C:\AvP_vc\3dc\win95\iff.cpp"
"C:\AvP_vc\3dc\win95\iff_ILBM.cpp"
"C:\AvP_vc\3dc\win95\ILBM_ext.cpp"
"C:\AvP_vc\3dc\avp\support\indexfnt.cpp"
"C:\AvP_vc\3dc\avp\win95\intro.cpp"
"C:\AvP_vc\3dc\avp\Inventry.c"
"C:\AvP_vc\3dc\win95\io.c"
"C:\AvP_vc\3dc\avp\win95\iofocus.cpp"
"C:\AvP_vc\3dc\avp\win95\jsndsup.cpp"
"C:\AvP_vc\3dc\Kshape.c"
"C:\AvP_vc\3dc\avp\win95\Kzsort.c"
"C:\AvP_vc\3dc\avp\win95\Langplat.c"
"C:\AvP_vc\3dc\avp\Language.c"
"C:\AvP_vc\3dc\avp\Lighting.c"
"C:\AvP_vc\3dc\win95\list_tem.cpp"
"C:\AvP_vc\3dc\avp\load_shp.c"
"C:\AvP_vc\3dc\avp\los.c"
"C:\AvP_vc\3dc\win95\Ltchunk.cpp"
"C:\AvP_vc\3dc\Map.c"
"C:\AvP_vc\3dc\avp\Maps.c"
"C:\AvP_vc\3dc\Maths.c"
"C:\AvP_vc\3dc\win95\md5.c"
"C:\AvP_vc\3dc\win95\media.cpp"
"C:\AvP_vc\3dc\mem3dc.c"
"C:\AvP_vc\3dc\Mem3dcpp.cpp"
"C:\AvP_vc\3dc\avp\mempool.c"
"C:\AvP_vc\3dc\avp\MessageHistory.c"
"C:\AvP_vc\3dc\win95\Mishchnk.cpp"
"C:\AvP_vc\3dc\avp\missions.cpp"
"C:\AvP_vc\3dc\avp\win95\modcmds.cpp"
"C:\AvP_vc\3dc\Module.c"
"C:\AvP_vc\3dc\Morph.c"
"C:\AvP_vc\3dc\avp\win95\MouseCentreing.cpp"
"C:\AvP_vc\3dc\avp\movement.c"
"C:\AvP_vc\3dc\avp\mp_launch.c"
"C:\AvP_vc\3dc\Mslhand.c"
"C:\AvP_vc\3dc\avp\win95\Npcsetup.cpp"
"C:\AvP_vc\3dc\win95\Obchunk.cpp"
"C:\AvP_vc\3dc\Object.c"
"C:\AvP_vc\3dc\avp\win95\Objsetup.cpp"
"C:\AvP_vc\3dc\win95\OEChunk.cpp"
"C:\AvP_vc\3dc\win95\Our_mem.c"
"C:\AvP_vc\3dc\avp\Paintball.c"
"C:\AvP_vc\3dc\avp\particle.c"
"C:\AvP_vc\3dc\avp\win95\PathChnk.cpp"
"C:\AvP_vc\3dc\avp\win95\Pcmenus.cpp"
"C:\AvP_vc\3dc\avp\Pfarlocs.c"
"C:\AvP_vc\3dc\avp\Pheromon.c"
"C:\AvP_vc\3dc\win95\plat_shp.c"
"C:\AvP_vc\3dc\avp\win95\Platsup.c"
"C:\AvP_vc\3dc\avp\Player.c"
"C:\AvP_vc\3dc\avp\win95\Pldghost.c"
"C:\AvP_vc\3dc\avp\win95\Pldnet.c"
"C:\AvP_vc\3dc\win95\plspecfn.c"
"C:\AvP_vc\3dc\avp\Pmove.c"
"C:\AvP_vc\3dc\avp\win95\progress_bar.cpp"
"C:\AvP_vc\3dc\avp\win95\Projload.cpp"
"C:\AvP_vc\3dc\avp\Psnd.c"
"C:\AvP_vc\3dc\avp\win95\Psndplat.c"
"C:\AvP_vc\3dc\avp\Psndproj.c"
"C:\AvP_vc\3dc\avp\Pvisible.c"
"C:\AvP_vc\3dc\avp\support\r2base.cpp"
"C:\AvP_vc\3dc\avp\support\r2pos666.cpp"
"C:\AvP_vc\3dc\avp\support\reflist.cpp"
"C:\AvP_vc\3dc\avp\support\refobj.cpp"
"C:\AvP_vc\3dc\avp\support\rentrntq.cpp"
"C:\AvP_vc\3dc\avp\win95\gadgets\rootgadg.cpp"
"C:\AvP_vc\3dc\avp\savegame.c"
"C:\AvP_vc\3dc\avp\scream.cpp"
"C:\AvP_vc\3dc\avp\win95\Scrshot.cpp"
"C:\AvP_vc\3dc\avp\support\scstring.cpp"
"C:\AvP_vc\3dc\avp\SecStats.c"
"C:\AvP_vc\3dc\avp\sfx.c"
"C:\AvP_vc\3dc\shpanim.c"
"C:\AvP_vc\3dc\win95\Shpchunk.cpp"
"C:\AvP_vc\3dc\win95\smacker.c"
"C:\AvP_vc\3dc\win95\Sndchunk.cpp"
"C:\AvP_vc\3dc\sphere.c"
"C:\AvP_vc\3dc\win95\Sprchunk.cpp"
"C:\AvP_vc\3dc\avp\win95\Strachnk.cpp"
"C:\AvP_vc\3dc\avp\Stratdef.c"
"C:\AvP_vc\3dc\win95\String.cpp"
"C:\AvP_vc\3dc\avp\support\strtab.cpp"
"C:\AvP_vc\3dc\avp\support\strutil.c"
"C:\AvP_vc\3dc\avp\win95\system.c"
"C:\AvP_vc\3dc\avp\win95\gadgets\t_ingadg.cpp"
"C:\AvP_vc\3dc\Tables.c"
"C:\AvP_vc\3dc\avp\support\tallfont.cpp"
"C:\AvP_vc\3dc\avp\targeting.c"
"C:\AvP_vc\3dc\avp\win95\gadgets\teletype.cpp"
"C:\AvP_vc\3dc\win95\Texio.c"
"C:\AvP_vc\3dc\avp\win95\gadgets\textexp.cpp"
"C:\AvP_vc\3dc\avp\win95\gadgets\textin.cpp"
"C:\AvP_vc\3dc\win95\Toolchnk.cpp"
"C:\AvP_vc\3dc\avp\track.c"
"C:\AvP_vc\3dc\avp\win95\gadgets\trepgadg.cpp"
"C:\AvP_vc\3dc\avp\support\trig666.cpp"
"C:\AvP_vc\3dc\avp\Triggers.c"
"C:\AvP_vc\3dc\win95\Txioctrl.cpp"
"C:\AvP_vc\3dc\avp\win95\Usr_io.c"
"C:\AvP_vc\3dc\Vdb.c"
"C:\AvP_vc\3dc\version.c"
"C:\AvP_vc\3dc\win95\VideoModes.cpp"
"C:\AvP_vc\3dc\avp\win95\Vision.c"
"C:\AvP_vc\3dc\win95\Vramtime.c"
"C:\AvP_vc\3dc\avp\Weapons.c"
"C:\AvP_vc\3dc\win95\win_func.cpp"
"C:\AvP_vc\3dc\avp\win95\win_proj.cpp"
"C:\AvP_vc\3dc\avp\win95\winmain.c"
"C:\AvP_vc\3dc\win95\wpchunk.cpp"
"C:\AvP_vc\3dc\avp\support\wrapstr.cpp"
"C:\AvP_vc\3dc\win95\Zsp.cpp"
]
Creating command line "cl.exe @c:\windows\TEMP\RSPA0F3.TMP"
Creating temporary file "c:\windows\TEMP\RSPA0F4.TMP" with contents
[
kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib ddraw.lib dsound.lib dplayx.lib dinput.lib smackw32.lib binkw32.lib winmm.lib /nologo /subsystem:windows /incremental:no /pdb:"AvP___Win32_Release_For_Fox/AvP.pdb" /machine:I386 /out:"AvP.exe" /libpath:"c:\mssdk\lib" /libpath:"3dc"
.\AvP___Win32_Release_For_Fox\Afont.obj
.\AvP___Win32_Release_For_Fox\ahudgadg.obj
.\AvP___Win32_Release_For_Fox\AI_Sight.obj
.\AvP___Win32_Release_For_Fox\alt_tab.obj
.\AvP___Win32_Release_For_Fox\Animchnk.obj
.\AvP___Win32_Release_For_Fox\animobs.obj
.\AvP___Win32_Release_For_Fox\AvP_EnvInfo.obj
.\AvP___Win32_Release_For_Fox\AvP_Intro.obj
.\AvP___Win32_Release_For_Fox\AvP_MenuData.obj
.\AvP___Win32_Release_For_Fox\AvP_MenuGfx.obj
.\AvP___Win32_Release_For_Fox\AvP_Menus.obj
.\AvP___Win32_Release_For_Fox\AvP_MP_Config.obj
.\AvP___Win32_Release_For_Fox\AvP_UserProfile.obj
.\AvP___Win32_Release_For_Fox\Avpchunk.obj
.\AvP___Win32_Release_For_Fox\AvpReg.obj
.\AvP___Win32_Release_For_Fox\Avpview.obj
.\AvP___Win32_Release_For_Fox\awBmpLd.obj
.\AvP___Win32_Release_For_Fox\awIffLd.obj
.\AvP___Win32_Release_For_Fox\awPnmLd.obj
.\AvP___Win32_Release_For_Fox\awTexLd.obj
.\AvP___Win32_Release_For_Fox\bh_agun.obj
.\AvP___Win32_Release_For_Fox\bh_ais.obj
.\AvP___Win32_Release_For_Fox\Bh_alien.obj
.\AvP___Win32_Release_For_Fox\Bh_binsw.obj
.\AvP___Win32_Release_For_Fox\bh_cable.obj
.\AvP___Win32_Release_For_Fox\bh_corpse.obj
.\AvP___Win32_Release_For_Fox\bh_deathvol.obj
.\AvP___Win32_Release_For_Fox\Bh_debri.obj
.\AvP___Win32_Release_For_Fox\bh_dummy.obj
.\AvP___Win32_Release_For_Fox\bh_fan.obj
.\AvP___Win32_Release_For_Fox\bh_far.obj
.\AvP___Win32_Release_For_Fox\Bh_fhug.obj
.\AvP___Win32_Release_For_Fox\Bh_gener.obj
.\AvP___Win32_Release_For_Fox\bh_ldoor.obj
.\AvP___Win32_Release_For_Fox\bh_lift.obj
.\AvP___Win32_Release_For_Fox\bh_light.obj
.\AvP___Win32_Release_For_Fox\Bh_lnksw.obj
.\AvP___Win32_Release_For_Fox\bh_ltfx.obj
.\AvP___Win32_Release_For_Fox\Bh_marin.obj
.\AvP___Win32_Release_For_Fox\bh_mission.obj
.\AvP___Win32_Release_For_Fox\Bh_near.obj
.\AvP___Win32_Release_For_Fox\bh_pargen.obj
.\AvP___Win32_Release_For_Fox\bh_plachier.obj
.\AvP___Win32_Release_For_Fox\bh_plift.obj
.\AvP___Win32_Release_For_Fox\Bh_pred.obj
.\AvP___Win32_Release_For_Fox\bh_queen.obj
.\AvP___Win32_Release_For_Fox\bh_RubberDuck.obj
.\AvP___Win32_Release_For_Fox\bh_selfdest.obj
.\AvP___Win32_Release_For_Fox\bh_snds.obj
.\AvP___Win32_Release_For_Fox\bh_spcl.obj
.\AvP___Win32_Release_For_Fox\Bh_swdor.obj
.\AvP___Win32_Release_For_Fox\bh_track.obj
.\AvP___Win32_Release_For_Fox\Bh_types.obj
.\AvP___Win32_Release_For_Fox\bh_videoscreen.obj
.\AvP___Win32_Release_For_Fox\bh_waypt.obj
.\AvP___Win32_Release_For_Fox\bh_weap.obj
.\AvP___Win32_Release_For_Fox\Bh_xeno.obj
.\AvP___Win32_Release_For_Fox\bink.obj
.\AvP___Win32_Release_For_Fox\Bmpnames.obj
.\AvP___Win32_Release_For_Fox\BonusAbilities.obj
.\AvP___Win32_Release_For_Fox\cconvars.obj
.\AvP___Win32_Release_For_Fox\CD_player.obj
.\AvP___Win32_Release_For_Fox\CDTrackSelection.obj
.\AvP___Win32_Release_For_Fox\Cheat.obj
.\AvP___Win32_Release_For_Fox\CheatModes.obj
.\AvP___Win32_Release_For_Fox\chnkload.obj
.\AvP___Win32_Release_For_Fox\Chnktexi.obj
.\AvP___Win32_Release_For_Fox\Chnktype.obj
.\AvP___Win32_Release_For_Fox\chtcodes.obj
.\AvP___Win32_Release_For_Fox\Chunk.obj
.\AvP___Win32_Release_For_Fox\Chunkpal.obj
.\AvP___Win32_Release_For_Fox\comp_map.obj
.\AvP___Win32_Release_For_Fox\Comp_shp.obj
.\AvP___Win32_Release_For_Fox\consbind.obj
.\AvP___Win32_Release_For_Fox\consbtch.obj
.\AvP___Win32_Release_For_Fox\conscmnd.obj
.\AvP___Win32_Release_For_Fox\ConsoleLog.obj
.\AvP___Win32_Release_For_Fox\conssym.obj
.\AvP___Win32_Release_For_Fox\consvar.obj
.\AvP___Win32_Release_For_Fox\Coordstr.obj
.\AvP___Win32_Release_For_Fox\Cube.obj
.\AvP___Win32_Release_For_Fox\d3_func.obj
.\AvP___Win32_Release_For_Fox\d3d_hud.obj
.\AvP___Win32_Release_For_Fox\d3d_render.obj
.\AvP___Win32_Release_For_Fox\Daemon.obj
.\AvP___Win32_Release_For_Fox\davehook.obj
.\AvP___Win32_Release_For_Fox\db.obj
.\AvP___Win32_Release_For_Fox\Dd_func.obj
.\AvP___Win32_Release_For_Fox\Ddplat.obj
.\AvP___Win32_Release_For_Fox\deaths.obj
.\AvP___Win32_Release_For_Fox\Debuglog.obj
.\AvP___Win32_Release_For_Fox\decal.obj
.\AvP___Win32_Release_For_Fox\DetailLevels.obj
.\AvP___Win32_Release_For_Fox\Di_func.obj
.\AvP___Win32_Release_For_Fox\DirectPlay.obj
.\AvP___Win32_Release_For_Fox\Dp_func.obj
.\AvP___Win32_Release_For_Fox\dplayext.obj
.\AvP___Win32_Release_For_Fox\DummyObjectChunk.obj
.\AvP___Win32_Release_For_Fox\dx_proj.obj
.\AvP___Win32_Release_For_Fox\Dxlog.obj
.\AvP___Win32_Release_For_Fox\Dynamics.obj
.\AvP___Win32_Release_For_Fox\Dynblock.obj
.\AvP___Win32_Release_For_Fox\endianio.obj
.\AvP___Win32_Release_For_Fox\Enumchnk.obj
.\AvP___Win32_Release_For_Fox\Enumsch.obj
.\AvP___Win32_Release_For_Fox\Envchunk.obj
.\AvP___Win32_Release_For_Fox\Equipmnt.obj
.\AvP___Win32_Release_For_Fox\equiputl.obj
.\AvP___Win32_Release_For_Fox\extents.obj
.\AvP___Win32_Release_For_Fox\fail.obj
.\AvP___Win32_Release_For_Fox\Ffread.obj
.\AvP___Win32_Release_For_Fox\Ffstdio.obj
.\AvP___Win32_Release_For_Fox\fragchnk.obj
.\AvP___Win32_Release_For_Fox\frustrum.obj
.\AvP___Win32_Release_For_Fox\gadget.obj
.\AvP___Win32_Release_For_Fox\Game.obj
.\AvP___Win32_Release_For_Fox\game_statistics.obj
.\AvP___Win32_Release_For_Fox\gamecmds.obj
.\AvP___Win32_Release_For_Fox\gameflow.obj
.\AvP___Win32_Release_For_Fox\gamevars.obj
.\AvP___Win32_Release_For_Fox\GammaControl.obj
.\AvP___Win32_Release_For_Fox\gflwplat.obj
.\AvP___Win32_Release_For_Fox\Gsprchnk.obj
.\AvP___Win32_Release_For_Fox\hierchnk.obj
.\AvP___Win32_Release_For_Fox\hierplace.obj
.\AvP___Win32_Release_For_Fox\HModel.obj
.\AvP___Win32_Release_For_Fox\Hud.obj
.\AvP___Win32_Release_For_Fox\hudgadg.obj
.\AvP___Win32_Release_For_Fox\huffman.obj
.\AvP___Win32_Release_For_Fox\iff.obj
.\AvP___Win32_Release_For_Fox\iff_ILBM.obj
.\AvP___Win32_Release_For_Fox\ILBM_ext.obj
.\AvP___Win32_Release_For_Fox\indexfnt.obj
.\AvP___Win32_Release_For_Fox\intro.obj
.\AvP___Win32_Release_For_Fox\Inventry.obj
.\AvP___Win32_Release_For_Fox\io.obj
.\AvP___Win32_Release_For_Fox\iofocus.obj
.\AvP___Win32_Release_For_Fox\jsndsup.obj
.\AvP___Win32_Release_For_Fox\Kshape.obj
.\AvP___Win32_Release_For_Fox\Kzsort.obj
.\AvP___Win32_Release_For_Fox\Langplat.obj
.\AvP___Win32_Release_For_Fox\Language.obj
.\AvP___Win32_Release_For_Fox\Lighting.obj
.\AvP___Win32_Release_For_Fox\list_tem.obj
.\AvP___Win32_Release_For_Fox\load_shp.obj
.\AvP___Win32_Release_For_Fox\los.obj
.\AvP___Win32_Release_For_Fox\Ltchunk.obj
.\AvP___Win32_Release_For_Fox\Map.obj
.\AvP___Win32_Release_For_Fox\Maps.obj
.\AvP___Win32_Release_For_Fox\Maths.obj
.\AvP___Win32_Release_For_Fox\md5.obj
.\AvP___Win32_Release_For_Fox\media.obj
.\AvP___Win32_Release_For_Fox\mem3dc.obj
.\AvP___Win32_Release_For_Fox\Mem3dcpp.obj
.\AvP___Win32_Release_For_Fox\mempool.obj
.\AvP___Win32_Release_For_Fox\MessageHistory.obj
.\AvP___Win32_Release_For_Fox\Mishchnk.obj
.\AvP___Win32_Release_For_Fox\missions.obj
.\AvP___Win32_Release_For_Fox\modcmds.obj
.\AvP___Win32_Release_For_Fox\Module.obj
.\AvP___Win32_Release_For_Fox\Morph.obj
.\AvP___Win32_Release_For_Fox\MouseCentreing.obj
.\AvP___Win32_Release_For_Fox\movement.obj
.\AvP___Win32_Release_For_Fox\mp_launch.obj
.\AvP___Win32_Release_For_Fox\Mslhand.obj
.\AvP___Win32_Release_For_Fox\Npcsetup.obj
.\AvP___Win32_Release_For_Fox\Obchunk.obj
.\AvP___Win32_Release_For_Fox\Object.obj
.\AvP___Win32_Release_For_Fox\Objsetup.obj
.\AvP___Win32_Release_For_Fox\OEChunk.obj
.\AvP___Win32_Release_For_Fox\Our_mem.obj
.\AvP___Win32_Release_For_Fox\Paintball.obj
.\AvP___Win32_Release_For_Fox\particle.obj
.\AvP___Win32_Release_For_Fox\PathChnk.obj
.\AvP___Win32_Release_For_Fox\Pcmenus.obj
.\AvP___Win32_Release_For_Fox\Pfarlocs.obj
.\AvP___Win32_Release_For_Fox\Pheromon.obj
.\AvP___Win32_Release_For_Fox\plat_shp.obj
.\AvP___Win32_Release_For_Fox\Platsup.obj
.\AvP___Win32_Release_For_Fox\Player.obj
.\AvP___Win32_Release_For_Fox\Pldghost.obj
.\AvP___Win32_Release_For_Fox\Pldnet.obj
.\AvP___Win32_Release_For_Fox\plspecfn.obj
.\AvP___Win32_Release_For_Fox\Pmove.obj
.\AvP___Win32_Release_For_Fox\progress_bar.obj
.\AvP___Win32_Release_For_Fox\Projload.obj
.\AvP___Win32_Release_For_Fox\Psnd.obj
.\AvP___Win32_Release_For_Fox\Psndplat.obj
.\AvP___Win32_Release_For_Fox\Psndproj.obj
.\AvP___Win32_Release_For_Fox\Pvisible.obj
.\AvP___Win32_Release_For_Fox\r2base.obj
.\AvP___Win32_Release_For_Fox\r2pos666.obj
.\AvP___Win32_Release_For_Fox\reflist.obj
.\AvP___Win32_Release_For_Fox\refobj.obj
.\AvP___Win32_Release_For_Fox\rentrntq.obj
.\AvP___Win32_Release_For_Fox\rootgadg.obj
.\AvP___Win32_Release_For_Fox\savegame.obj
.\AvP___Win32_Release_For_Fox\scream.obj
.\AvP___Win32_Release_For_Fox\Scrshot.obj
.\AvP___Win32_Release_For_Fox\scstring.obj
.\AvP___Win32_Release_For_Fox\SecStats.obj
.\AvP___Win32_Release_For_Fox\sfx.obj
.\AvP___Win32_Release_For_Fox\shpanim.obj
.\AvP___Win32_Release_For_Fox\Shpchunk.obj
.\AvP___Win32_Release_For_Fox\smacker.obj
.\AvP___Win32_Release_For_Fox\Sndchunk.obj
.\AvP___Win32_Release_For_Fox\sphere.obj
.\AvP___Win32_Release_For_Fox\Sprchunk.obj
.\AvP___Win32_Release_For_Fox\Strachnk.obj
.\AvP___Win32_Release_For_Fox\Stratdef.obj
.\AvP___Win32_Release_For_Fox\String.obj
.\AvP___Win32_Release_For_Fox\strtab.obj
.\AvP___Win32_Release_For_Fox\strutil.obj
.\AvP___Win32_Release_For_Fox\system.obj
.\AvP___Win32_Release_For_Fox\t_ingadg.obj
.\AvP___Win32_Release_For_Fox\Tables.obj
.\AvP___Win32_Release_For_Fox\tallfont.obj
.\AvP___Win32_Release_For_Fox\targeting.obj
.\AvP___Win32_Release_For_Fox\teletype.obj
.\AvP___Win32_Release_For_Fox\Texio.obj
.\AvP___Win32_Release_For_Fox\textexp.obj
.\AvP___Win32_Release_For_Fox\textin.obj
.\AvP___Win32_Release_For_Fox\Toolchnk.obj
.\AvP___Win32_Release_For_Fox\track.obj
.\AvP___Win32_Release_For_Fox\trepgadg.obj
.\AvP___Win32_Release_For_Fox\trig666.obj
.\AvP___Win32_Release_For_Fox\Triggers.obj
.\AvP___Win32_Release_For_Fox\Txioctrl.obj
.\AvP___Win32_Release_For_Fox\Usr_io.obj
.\AvP___Win32_Release_For_Fox\Vdb.obj
.\AvP___Win32_Release_For_Fox\version.obj
.\AvP___Win32_Release_For_Fox\VideoModes.obj
.\AvP___Win32_Release_For_Fox\Vision.obj
.\AvP___Win32_Release_For_Fox\Vramtime.obj
.\AvP___Win32_Release_For_Fox\Weapons.obj
.\AvP___Win32_Release_For_Fox\win_func.obj
.\AvP___Win32_Release_For_Fox\win_proj.obj
.\AvP___Win32_Release_For_Fox\winmain.obj
.\AvP___Win32_Release_For_Fox\wpchunk.obj
.\AvP___Win32_Release_For_Fox\wrapstr.obj
.\AvP___Win32_Release_For_Fox\Zsp.obj
]
Creating command line "link.exe @c:\windows\TEMP\RSPA0F4.TMP"
<h3>Output Window</h3>
Compiling...
Afont.c
ahudgadg.cpp
AI_Sight.c
C:\AvP_vc\3dc\avp\AI_Sight.c(177) : warning C4013: 'AGunSight_FrustrumReject' undefined; assuming extern returning int
alt_tab.cpp
Animchnk.cpp
animobs.cpp
AvP_EnvInfo.c
AvP_Intro.cpp
</pre>
</body>
</html>

1
License.txt
View file

@ -1 +0,0 @@
The source code to Aliens Vs Predator is copyright (c) 1999-2000 Rebellion and is provided as is with no warranty for its suitability for use. You may not use this source code in full or in part for commercial purposes. Any use must include a clearly visible credit to Rebellion as the creators and owners, and reiteration of this license.

4
avp395.mk
View file

@ -1,4 +0,0 @@
project : c:\avp_copy\avpprog.exe c:\avp_copy\release\avp.exe .SYMBOLIC
!include c:\avp_copy\avpprog.mk1
!include c:\avp_copy\release\avp.mk1

63
avp395.wpj
View file

@ -1,63 +0,0 @@
40
projectIdent
0
VpeMain
1
WRect
0
0
10240
10240
2
MProject
3
MCommand
0
4
MCommand
0
2
5
WFileName
11
avpprog.tgt
6
WFileName
19
wat_release\avp.tgt
7
WVList
2
8
VComponent
9
WRect
160
0
4240
4800
0
0
10
WFileName
11
avpprog.tgt
203
205
11
VComponent
12
WRect
4560
0
4160
4800
0
0
13
WFileName
19
wat_release\avp.tgt
0
4
8

2
avpprog.lk1
View file

@ -1,2 +0,0 @@
FIL mmx_math.obj,afont.obj,ai_sight.obj,avpview.obj,bh_agun.obj,bh_ais.obj,bh_alien.obj,bh_binsw.obj,bh_cable.obj,bh_corpse.obj,bh_deathvol.obj,bh_debri.obj,bh_dummy.obj,bh_fan.obj,bh_far.obj,bh_fhug.obj,bh_gener.obj,bh_ldoor.obj,bh_lift.obj,bh_light.obj,bh_lnksw.obj,bh_ltfx.obj,bh_marin.obj,bh_mission.obj,bh_near.obj,bh_pargen.obj,bh_plachier.obj,bh_plift.obj,bh_pred.obj,bh_queen.obj,bh_rubberduck.obj,bh_selfdest.obj,bh_snds.obj,bh_spcl.obj,bh_swdor.obj,bh_track.obj,bh_types.obj,bh_videoscreen.obj,bh_waypt.obj,bh_weap.obj,bh_xeno.obj,bonusabilities.obj,cheatmodes.obj,comp_map.obj,comp_shp.obj,deaths.obj,decal.obj,detaillevels.obj,dynamics.obj,dynblock.obj,equipmnt.obj,extents.obj,game.obj,game_statistics.obj,gameflow.obj,hmodel.obj,hud.obj,inventry.obj,language.obj,lighting.obj,los.obj,mempool.obj,messagehistory.obj,movement.obj,mp_launch.obj,paintball.obj,particle.obj,pfarlocs.obj,pheromon.obj,player.obj,pmove.obj,psnd.obj,psndproj.obj,pvisible.obj,savegame.obj,secstats.obj,sfx.obj,cube.obj,stratdef.obj,strutil.obj,targeting.obj,track.obj,triggers.obj,weapons.obj,cheat.obj,directplay.obj,dp_func.obj,dplayext.obj,endianio.obj,avp_envinfo.obj,avp_menudata.obj,avp_menus.obj,gflwplat.obj,kzsort.obj,langplat.obj,platsup.obj,pldghost.obj,pldnet.obj,psndplat.obj,system.obj,usr_io.obj,vision.obj,winmain.obj,frustrum.obj,kshape.obj,map.obj,maths.obj,mem3dc.obj,module.obj,morph.obj,mslhand.obj,object.obj,shpanim.obj,sphere.obj,tables.obj,vdb.obj,version.obj,bink.obj,cd_player.obj,db.obj,dxlog.obj,fail.obj,io.obj,md5.obj,our_mem.obj,plat_shp.obj,plspecfn.obj,smacker.obj,texio.obj,vramtime.obj,cconvars.obj,cdtrackselection.obj,consolelog.obj,davehook.obj,equiputl.obj,gamecmds.obj,gamevars.obj,missions.obj,scream.obj,consbind.obj,consbtch.obj,coordstr.obj,daemon.obj,indexfnt.obj,r2base.obj,r2pos666.obj,reflist.obj,refobj.obj,rentrntq.obj,scstring.obj,strtab.obj,tallfont.obj,trig666.obj,wrapstr.obj,avpchunk.obj,avpreg.obj,chtcodes.obj,d3d_hud.obj,d3d_render.obj,ddplat.obj,dx_proj.obj,ffread.obj,ffstdio.obj,avp_intro.obj,avp_menugfx.obj,avp_mp_config.obj,avp_userprofile.obj,ahudgadg.obj,conscmnd.obj,conssym.obj,consvar.obj,gadget.obj,hudgadg.obj,rootgadg.obj,t_ingadg.obj,teletype.obj,textexp.obj,textin.obj,trepgadg.obj,gammacontrol.obj,hierplace.obj,intro.obj,iofocus.obj,jsndsup.obj,modcmds.obj,mousecentreing.obj,npcsetup.obj,objsetup.obj,pathchnk.obj,pcmenus.obj,progress_bar.obj,projload.obj,scrshot.obj,strachnk.obj,win_proj.obj,mem3dcpp.obj,alt_tab.obj,animchnk.obj,animobs.obj,awbmpld.obj,awiffld.obj,awpnmld.obj,awtexld.obj,bmpnames.obj,bonechunk.obj,chnkload.obj,chnktexi.obj,chnktype.obj,chunk.obj,chunkpal.obj,d3_func.obj,dd_func.obj,debuglog.obj,di_func.obj,envchunk.obj,fragchnk.obj,gsprchnk.obj,hierchnk.obj,huffman.obj,iff.obj,iff_ilbm.obj,list_tem.obj,ltchunk.obj,media.obj,mishchnk.obj,obchunk.obj,shpchunk.obj,sndchunk.obj,sprchunk.obj,txioctrl.obj,videomodes.obj,win_func.obj,wpchunk.obj

2278
avpprog.mk1
View file

File diff suppressed because it is too large Load diff

4862
avpprog.tgt
View file

File diff suppressed because it is too large Load diff

0
3dc/CD Tracks.txt → cd tracks.txt
View file

0
3dc/default.cfg → default.cfg.bin
View file

0
3dc/ENGLISH.TXT → english.txt
View file

0
3dc/fontbr.pgm → fontbr.pgm
View file

0
3dc/Language.txt → language.dat
View file

0
3dc/AFONT.C → src/afont.c
View file

0
3dc/avp/AI_Sight.c → src/avp/ai_sight.c
View file

0
3dc/avp/AI_Sight.h → src/avp/ai_sight.h
View file

0
3dc/avp/avpitems.cpp → src/avp/avpitems.cpp
View file

0
3dc/avp/avpitems.hpp → src/avp/avpitems.hpp
View file

0
3dc/avp/avppages.cpp → src/avp/avppages.cpp
View file

0
3dc/avp/avppages.hpp → src/avp/avppages.hpp
View file

0
3dc/avp/Avpview.c → src/avp/avpview.c
View file

0
3dc/avp/AVPVIEW.H → src/avp/avpview.h
View file

0
3dc/avp/bh_agun.c → src/avp/bh_agun.c
View file

0
3dc/avp/bh_agun.h → src/avp/bh_agun.h
View file

0
3dc/avp/bh_ais.c → src/avp/bh_ais.c
View file

0
3dc/avp/bh_ais.h → src/avp/bh_ais.h
View file

0
3dc/avp/BH_ALIEN.C → src/avp/bh_alien.c
View file

0
3dc/avp/BH_ALIEN.H → src/avp/bh_alien.h
View file

0
3dc/avp/BH_BINSW.C → src/avp/bh_binsw.c
View file

0
3dc/avp/BH_BINSW.H → src/avp/bh_binsw.h
View file

0
3dc/avp/bh_cable.c → src/avp/bh_cable.c
View file

0
3dc/avp/bh_cable.h → src/avp/bh_cable.h
View file

0
3dc/avp/bh_corpse.c → src/avp/bh_corpse.c
View file

0
3dc/avp/bh_corpse.h → src/avp/bh_corpse.h
View file

0
3dc/avp/bh_deathvol.c → src/avp/bh_deathvol.c
View file

0
3dc/avp/bh_deathvol.h → src/avp/bh_deathvol.h
View file

0
3dc/avp/Bh_debri.c → src/avp/bh_debri.c
View file

0
3dc/avp/bh_debri.h → src/avp/bh_debri.h
View file

0
3dc/avp/bh_dummy.c → src/avp/bh_dummy.c
View file

0
3dc/avp/bh_dummy.h → src/avp/bh_dummy.h
View file

0
3dc/avp/bh_fan.c → src/avp/bh_fan.c
View file

0
3dc/avp/bh_fan.h → src/avp/bh_fan.h
View file

0
3dc/avp/bh_far.c → src/avp/bh_far.c
View file

0
3dc/avp/BH_FAR.H → src/avp/bh_far.h
View file

0
3dc/avp/BH_FHUG.C → src/avp/bh_fhug.c
View file

0
3dc/avp/BH_FHUG.H → src/avp/bh_fhug.h
View file

0
3dc/avp/BH_GENER.C → src/avp/bh_gener.c
View file

0
3dc/avp/BH_GENER.H → src/avp/bh_gener.h
View file

0
3dc/avp/bh_ldoor.c → src/avp/bh_ldoor.c
View file

0
3dc/avp/bh_ldoor.h → src/avp/bh_ldoor.h
View file

0
3dc/avp/bh_lift.c → src/avp/bh_lift.c
View file

0
3dc/avp/bh_lift.h → src/avp/bh_lift.h
View file

0
3dc/avp/bh_light.c → src/avp/bh_light.c
View file

0
3dc/avp/bh_light.h → src/avp/bh_light.h
View file

0
3dc/avp/BH_LNKSW.C → src/avp/bh_lnksw.c
View file

0
3dc/avp/BH_LNKSW.H → src/avp/bh_lnksw.h
View file

0
3dc/avp/bh_ltfx.c → src/avp/bh_ltfx.c
View file

0
3dc/avp/bh_ltfx.h → src/avp/bh_ltfx.h
View file

0
3dc/avp/Bh_marin.c → src/avp/bh_marin.c
View file

Some files were not shown because too many files have changed in this diff Show more