dxsdk3 - from F:\code

[git-p4: depot-paths = "//code/dxsdk3/": change = 1612]
This commit is contained in:
mason 2011-10-23 09:52:35 -05:00
commit 6cc92a9e69
1285 changed files with 149182 additions and 0 deletions

170
docs/readme/conv3ds.txt Normal file
View File

@ -0,0 +1,170 @@
conv3ds
-------
conv3ds converts 3ds models produced by Autodesk 3D Studio and other
modelling packages into X Files. By default it produces binary X files
with no templates.
How to use it
-------------
At its simplest you can run it with no options and it will (endeavour) to
produce an X file containing a hiearchy of frames. For example:
conv3ds file.3ds
will produce an X File file.x. Use Frame::Load to load the frame.
If the 3ds file contains key frame data then you can produce an X file
which contains an animation set using the -A option. For example:
conv3ds -A file.3ds
Use AnimationSet::Load to load the animation.
If you want to make an X file containing a single mesh made from all the
objects in the 3ds file then use the -m option.
conv3ds -m file.3ds
Use MeshBuilder::Load to load the mesh.
Other useful options
--------------------
* The -T option will wrap all the objects and frame hierarchies in a single
"toplevel" frame. This enables you to load all the frames and objects in
the 3ds file with a single call to Frame::Load, using the default options
(ie. Load the first toplevel frame hiearchy in the X file). The frame
containing all the other frames and meshes is called "x3ds_filename"
(without the .3ds extension). When used with the -m option this option has
no affect.
* The -s option allows you to specify a scale factor for all the objects
converted in the 3ds file. For example
conv3ds -s10 file.3ds
will make all the objects 10 times bigger, and
conv3ds -s0.1 file.3ds
will make all the objects 10 times smaller
* The -r option reverses the winding order of the faces when the 3ds file is
converted. If after converting the 3ds file and viewing it in D3D, the object
appears "inside-out" try converting it with the -r option. All Lightwave
models (see notes below) exported as 3ds files will need this option.
* The -v option turns on verbose output mode. Specifiy an integer with it.
The only useful (currently) integers are:
-v1, print out warnings about bad objects and general information
about what the converter is doing
-v2, print out basic keyframe information, objects being included in the
conversion process, and information about the objects while being saved.
-v3, very verbose (mostly useful for debugging) information.
The default is -v0.
* The -e option allows you to change the extension for texture map files. For
example:
conv3ds -e"ppm" file.3ds
and file.3ds contains objects which reference the texture map file brick.gif,
the X file will reference the texture map file brick.ppm. The converter does
not convert the texture map file. The texture map files must also be in the
D3DPATH when the resulting X File is loaded.
* The -x option forces conv3ds to produce a text X file, not a binary
X file. Text files are larger but can be hand edited easily.
* The -X option forces conv3ds to include the D3DRM X File templates in
the file. By default the templates are not included.
Other options
-------------
* The -t option specifies that the X File produced will not contain texture
information.
* The -N option specifies that the X file produced will not contain Normal
information. All the D3DRM Load calls will generate normals for objects
with no normals in the X file.
* The -c option specifies that the X file produced should not contain
texture coordinates. By default if you use the -m option the outputted mesh
will contain 0,0 uv texture coordinates if the 3ds object had no texture
coordinates.
* The -f option specifies that the X file produced should not contain any
FrameTransformMatrix.
* The -z and -Z options allow you to adjust the alpha face color value of
all the materials referenced by objects in the X File.
This is best illustrated with an example:
conv3ds -z0.1 -Z0.2 file.3ds
says add 0.1 to all alpha values under 0.2. And
conv3ds-z"-0.2" -z1 file.3ds
says subtract 0.2 from the alpha values for all alphas.
* The -o option allows you to specify the filename for the .X File produced.
* The -h option tells the converter not to try to resolve any hiearchy
information in the 3ds file (usually produced by the keyframer). Instead all
the objects (when the converter is not used with the -m option) are outputted
in toplevel frames.
3ds file produced from lightwave objects
----------------------------------------
There are a number of issues with 3ds files exported by the trans3d
plugin for lightwave. These are best handled using the following
options to conv3ds.
conv3ds -r -N -f -h -T|m trans3dfile.3ds
All the 3ds objects which we've come across produced by trans3d and the
lightwave object editor need their winding order reversing (otherwise they
appear "inside-out" when displayed) and contain no normal information.
Hints and Tips
--------------
Some of these are pretty obvious but are probably worth saying anyway.
If, after loading an object produced by conv3ds into the D3DRM viewer,
you can't see the object then try using the -s object
with an integer of say, 100, to increase the X file objects scale.
If, after loading the object into the viewer and switching from flat
shading into Gourard shading the object turns dark grey try converting
with the -N option.
Textures can be the biggest problem. If after converting the object the
textures don't get loaded then make sure that the object is referencing
either .ppm or .bmp files (using the -e option), make sure the textures
width and height is a power of 2, and make sure the textures are stored
in one of the directories in your D3DPATH.
Known bugs and problems
-----------------------
Currently conv3ds can't handle dummy frames used in 3ds animations.
It just ignores them (but will convert any child objects).

156
docs/readme/d3d.txt Normal file
View File

@ -0,0 +1,156 @@
**********************
*** ***
*** ***
*** Direct3D Notes ***
*** ***
*** ***
**********************
Last updated September 5, 1996
Notes on the software emulation drivers
=======================================
RAMP driver support
===================
Optional Z buffering.
Color key and stippled transparency.
Mono interpolated rasterization only.
Point sampled perspective correct textures.
Flat and Gouraud shade modes.
Performance notes for the RAMP driver
=====================================
Texture mapping performance is heavily gated by the speed of memory.
There are a number of ways of maximizing the cache performance of your
textures. The smaller the textures are, the better chance they have of being
maintained in the secondary cache. This is crucial for keeping performance
high. Also, changing the texture per primitive will thrash the cache. Try
and keep polygons grouped in order of the textures they use.
When using Z buffering and texturing, rendering your scene from front to
back will increase performance. The textured Z buffered primitives
pre-test the Z buffer on a scanline basis. If a scanline is hidden by a
previously rendered polygon it is trivially rejected. If this is the case, Z
buffering performance can exceed non-Z performance.
The retained mode API automatically orders its scenes from front to back
to facilitate this optimization.
In it often a good idea to use the D3DTest program to verify performance
results with different drivers, especially where hardware is involved.
RGB driver
==========
There is now an MMX optimized version of the RGB driver.
If you have an MMX capable PC the RGB software emulation will automatically
be accelerated. There is an application included in the sdk\bin directory,
mmxtog.exe which allows you to switch MMX acceleration off and on for the
RGB driver.
Release notes for D3D MMX driver
Functionality
-------------
1. D3D's external interfaces unchanged, all examples and all apps that
can use the RGB driver should be able to run with the RGB MMX driver.
2. Only 16-bit color depths have been optimised. There is a relatively
minor (2X) improvement in 8-bit dithered RGB rendering.
3. The following are yet-to-be-implemented: mip-mapping, 16-bit dithering.
4. The Z-buffer is 16-bit, but is signed, so the farthest Z-value is 0x7fff,
and the nearest is 0x8000. This should not affect you unless you examine
the Z-buffer directly.
5. There are still some accuracy problems with the rendering: these are
most clearly shown by the colored flashes that appear in the "twist"
example. We're working on this problem right now, and should have
fixes soon.
6. The driver only supports the PAL8 texture format. D3D apps should detect
this and create the texture appropriately. This format is the same as
the one supported by the ramp driver.
Performance
-----------
1. Performance is much better when all surfaces are in systemmemory, this
includes the rendering target and all textures.
2. The current MMX RGB driver is not complete, and there are several
major performance improvements that we plan to make. Expect another
improvement of about 10% in all benchmarks for the MMX RGB driver,
though the more sophisticated the rendering operation, the bigger the
improvement. The biggest improvement should be in Z-buffered
gouraud-shaded perspective-correct texture-mapping. Perspective
correction will be much faster in the next beta.
3. Performance is better than that of ramp mode in most situations.
There are some performance bottlenecks that we have yet to address.
We suggest you run the "tunnel" example with the MMX driver to get a
feel for the changed relative costs of rendering qualities: for
example, the speed of gouraud shading is now much closer to that of
flat-shading. To get the best performance from the tunnel, do the
following:
Specular highlights OFF
Fog OFF
Perspective Correction OFF
Gouraud shading ON
With these settings, you should be getting about 29Hz for the tunnel
running in systemmemory fullscreen at 640x400x16.
4. The existing ramp driver works best on textures that are 256x256.
This restriction has been removed in the MMX driver: it supports all
texture dimensions equally well. It is still important to keep the total
texture size as small as possible to reduce memory bandwidth. Note how
fast the tiny checker texture runs in the tunnel. The checker texture is
only 64 bytes instead of 64k like most of the other textures in the SDK.
256x2048 is a reasonable size for the texture in a game.
Known Issues
============
When using RGB software rasterisation, D3DRMMATERIALMODE_FROMFRAME
does not work correctly if the object is unlit.
It is not currently possible to load textures from resources if the code
resides in a dll.
Background depth images do not double buffer correctly in the retained
mode api (page flipping scenario). Use IDirect3DRMViewport::ForceUpdate()
to force the dirty region to be updated.
The following issues is not made clear in the documentation:
1) SetOrientation overrides any previous shear or scale applied to a
frame.
2) Texture Transparency. If the retained mode API has to sample down
the colors used in a texture in order to, for example, palettize it,
the color you're using as the transparent color may get remapped to
another close color and transparency will no longer work. In order to
stop this happening, pick a color to use for transparency that is not
close to any other color in the texture.
The Matrox Millenium driver does not render correctly fullscreen
unless Clear is called at least once. Since the Millenium does not
support texture mapping, this will not affect the types of application
which do not use Clear. A workaround for this issue is to call Clear
in your application once before entering the rendering loop.
When using the Retained Mode method IDirect3DRM::LoadTexture, the texture
is inverted when loaded from a BMP file. The simplest work around is to
reverse the meshs texture coordinates or load from a PPM file.

784
docs/readme/ddraw.txt Normal file
View File

@ -0,0 +1,784 @@
************************
*** ***
*** ***
*** DirectDraw Notes ***
*** ***
*** ***
************************
Last updated September 10, 1996
Notes for DirectDraw 3.0
========================================
The CoCreateInstance API cannot be used to create an IDirectDraw2 object.
To work around this problem, create a DirectDraw object and call
QueryInterface on it to get the IDirectDraw2 interface.
IDirectDrawSurface2::Flip may cause your machine to hang. To work around this
problem, call IDirectDrawSurface::Flip instead.
Notes for DirectDraw 2.0
========================================
In some hardware configurations, stretched transparent blits do not work
correctly. If at all possible, when writing DirectDraw applications, you
should avoid using stretched transparent blits. To work around this
limitation, you can do a stretched blit to an intermediate surface, followed
by a transparent blit to your original destination surface.
On some, relatively rare, older video boards, source color key blitting
to the primary surface may not work. You can work around this by composing
your image with transparency to a back buffer, then blitting the result to
the primary surface.
DirectDraw::Initialize() is now called if the DirectDraw object
is created with standard COM methods.
Notes for DirectDraw 2.0 Beta 3
========================================
SetDisplayMode now supports setting the monitor refresh rate
------------------------------------------------------------
The IDirectDraw2::SetDisplayMode function now takes two additional
parameters. The dwRefreshRate parameter can be used to specify a
monitor refresh rate in Hz. Valid refresh rates can now be enumerated
with the IDirectDraw2::EnumDisplayModes function. The refresh rate is
returned in the dwRefreshRate field of the DDSURFACEDESC structure.
If a refresh rate of 0 is specified in SetDisplayMode, this means to
revert back to the IDirectDraw behaviour and set the default refresh
rate for the specified mode. The display driver may or may not enumerate
specific refresh rates for each mode. If no refresh rate is specified
by the driver for a particular mode, the dwRefreshRate field in the
DDSURFACEDESC structure set by EnumDisplayModes will be 0.
Direct Draw modes now respect monitor settings
----------------------------------------------
Windows 95 allows a user to specify the type of monitor that is being
used. DirectDraw now checks the display modes that it knows about against
the display restrictions of the installed monitor. If it is determined
that the requested mode is not compatible with the monitor, then SetDisplayMode
will fail. Only modes which are supported on the installed monitor will be
enumerated in EnumDisplayModes.
IDirectDrawSurface2::DDGetInterface now supported
-------------------------------------------------
A new method has been added to the IDirectDrawSurface2 interface which is
call DDGetInterface. This function returns a pointer to the DirectDraw
object that was used to create the specified surface.
Direct Draw clipper objects now have a COM class factory
--------------------------------------------------------
Direct Draw clipper objects now have full class factory support for COM
compliance. Clippers can now be created using either CoGetClassObject
to obtain a class factory and then calling CreateInstance or by calling
CoCreateInstance directly. The class identifier for the clipper class is
CLSID_DirectDrawClipper. Please note that it is still possible to create
clipper objects using either of the two existing API functions;
DirectDrawCreateClipper or IDirectDraw::CreateClipper. Class factory
support is provided in addition to these functions rather than in
replacement of them.
Clippers created by the class factory mechanism must be initialized
with the IDirectDrawClipper::Initialize member before use. Initialize
takes two parameters; a DirectDraw driver object interface pointer and
a flags field. Currently the flags field must be 0. If a NULL driver object
is specified then the clipper is not owned by a Direct Draw driver object
and behaves identically to clippers created with DirectDrawCreateClipper.
If a driver object is specified the clipper will be owned by that driver
object and behaves identically to IDirectDraw::CreateClipper.
Flip now flips all levels of a mip-map
--------------------------------------
Previously, Flip only flipped the the mip-map level supplied as an
argument. Now, however, Flip will flip all the levels of a mip-map
from the level supplied to the lowest level in the map. A destination
surface can also be provided in which case all levels in the mip-map will
flip to the back buffer in thier flippable chain which matches the supplied
override. For example, if the third back buffer in the top level
flippable chain is supplied all levels in the mip-map will flip to thier
third back buffer.
The number of levels in a mip-map is now stored explicitly
----------------------------------------------------------
The number of levels in a mip-map chain is now stored explicitly.
When the surface description of a mip-map is obtained (via
IDirectDrawSurface::Lock or IDirectDrawSurface::GetSurfaceDesc) the
dwMipMapCount field will contain the number of levels in a mip-map
including the top-level. Note, for levels other than the top-level
in the map, dwMipMapCount will specify the number of levels from
that map to the smallest map in the chain.
New surface capability bit for Direct3D texture loading
-------------------------------------------------------
A new surface capability bit, DDSCAPS_ALLOCONLOAD, has been added
to support device dependent and compressed texture surfaces. This
capability bit specifies that a given texture surface does not
have memory allocated for it when it is created. Instead, sufficient
memory will be allocated when the texture is loaded using the Direct3D
texture Load member. Currently the semantics of this bit are not fully
implemented and the width, height and pixel format of the texture
surface should be specified when DDSCAPS_ALLOCONLOAD is specified.
However, for the final release, width, height and pixel format will
not be specified at create time but will be initialized when the
texture is loaded. If DDSCAPS_ALLOCONLOAD is specified so must
DDSCAPS_TEXTURE. For further information see the Direct3D documentation
on the IDirect3DTexture::Load member function.
Notes for DirectDraw 2.0 Beta 2
========================================
Support for high resolutions and TrueColor bit depths
-----------------------------------------------------
Direct Draw supports all of the screen resolutions and depths supported
by the Display Driver. Version 1.0 of Direct Draw limited the available
video modes to 640x480 with pixel depths of 8 bits per pixel and 16 bits
per pixel. This restriction has been relaxed and Direct Draw now allows
an application to change the mode into any mode supported by the Display
Driver. This includes all supported 24 and 32 bits-per-pixel modes.
Note that this release of Direct Draw does not check the monitor capabilities
stored by the system to determine if a particular display resolution is
compatible with the monitor. This means that an application may use
EnumerateDisplayModes to determine the available video modes and then switch
into a mode that is not supported by the monitor. This is a defect which
will be corrected in the next release.
HEL Blitting Support for 24 and 32 bit Surfaces
-----------------------------------------------
Direct Draw now supports HEL blitting of 24 and 32 bits-per-pixel surfaces.
If the Display Driver supports blitting at these resolutions then the
hardware blitter will be used for vram to vram blits. Otherwise, the
Hardware Emulation Layer (HEL) will be used to do the blits.
Multiple Direct Draw Objects per Process
----------------------------------------
Direct Draw 1.0 only allowed the creation of one Direct Draw object per
process. If your process happened to use another system component (such
as Direct Play) that created a Direct Draw object, the process would be
unable to create another Direct Draw object for its own use.
This restriction has been eliminated in this release. It is now possible
for a process to call DirectDrawCreate as many times as necessary. A
unique and independent interface will be returned from each call. Each
DirectDraw object may be used as desired. There are no dependencies
between the objects. They behave exactly as they would if they had been
created by two different processes.
Since the Direct Draw objects are independent, surface, palette, and
clipper objects which are created with a particular Direct Draw object
should not be used with other Direct Draw objects. This is because these
objects are automatically released when the Direct Draw object is
destroyed. If they are used with another Direct Draw object, they
may go away if the original object is destroyed.
Clipper objects which are created with DirectDrawClipperCreate are
independent of any particular Direct Draw object and may be used with
one or more Direct Draw objects.
SetCooperativeLevel Doesn't Require an HWND for non-Exclusive Mode
------------------------------------------------------------------
Direct Draw 1.0 required an HWND to be specified in the SetCooperativeLevel
call regardless of whether or not Full-screen Exclusive mode was being
requested. This function no longer requires an HWND to be specified
if the application is requesting DDSCL_NORMAL mode. It is now possible
for an application to use Direct Draw with multiple windows. All of these
windows may be used simultaneously in normal windowed mode.
New IDirectDraw2 and IDirectDrawSurface2 interfaces
---------------------------------------------------
The COM model that Direct Draw uses specifies that additional functionality
is provided by providing new interfaces. This release of Direct Draw
implements a new Direct Draw interface and a new Direct Draw Surface
interface. These new interfaces may be obtained by using QueryInterface
as shown in the following code fragment:
/*
* create an IDirectDraw2 interface
*/
LPDIRECTDRAW lpDD;
LPDIRECTDRAW2 lpDD2;
ddrval = DirectDrawCreate( NULL, &lpDD, NULL );
if( ddrval != DD_OK )
return;
ddrval = lpDD->SetCooperativeLevel( hwnd, DDSCL_NORMAL );
if( ddrval != DD_OK )
return;
ddrval = lpDD->QueryInterface( IID_IDirectDraw2, (LPVOID *)&lpDD2);
if( ddrval != DD_OK )
return;
ddscaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
ddrval = lpDD2->GetAvailableVidMem(&ddscaps, &total, &free);
if( ddrval != DD_OK )
return;
This code fragment shows C++ syntax for creating an IDirectDraw interface
and then using QueryInterface to create an IDirectDraw2 interface. It is
this interface which contains the GetAvailableVidMem function. An attempt
to use the GetAvailableVidMem function from an IDirectDraw interface will
result in a compile-time error.
The IDirectDraw2 interface contains all of the same member functions as the
IDirectDraw interface along with one additional member functions called
GetAvailableVidMem. The SetDisplayMode function in this interface will
allow refresh rates to be specified. This is not enabled for this beta and
this function will return DDERR_UNSUPPORTED. The SetDisplayMode function
in the IDirectDraw interface can be used instead.
The IDirectDrawSurface2 interface contains all of the same member functions
as the IDirectDrawSurface interface with two additional member functions
called PageLock and PageUnlock. The following code fragment shows how to
create an IDirectDrawSurface2 interface:
LPDIRECTDRAWSURFACE lpSurf;
LPDIRECTDRAWSURFACE2 lpSurf2;
// Create surfaces
memset( &ddsd, 0, sizeof( ddsd ) );
ddsd.dwSize = sizeof( ddsd );
ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN |
DDSCAPS_SYSTEMMEMORY;
ddsd.dwWidth = 10;
ddsd.dwHeight = 10;
ddrval = lpDD2->CreateSurface( &ddsd, &lpSurf, NULL );
if( ddrval != DD_OK )
return;
ddrval = lpSurf->QueryInterface( IID_IDirectDrawSurface2, (LPVOID *)&lpSurf2);
if( ddrval != DD_OK )
return;
ddrval = lpSurf2->PageLock( 0 );
if( ddrval != DD_OK )
return;
ddrval = lpSurf2->PageUnlock( 0 );
if( ddrval != DD_OK )
return;
New PageLock and PageUnlock functions
-------------------------------------
A new feature that is supported with this release is the capability for
DirectDraw to allow a driver to control the blitting to or from a system
memory surface. A driver may choose to do this blitting by copying the
bytes one by one or by using DMA transfers. If the driver uses a DMA
transfer, it is important that the system memory which contains the bits
for the surface is locked so that it cannot be paged out while the DMA is
in progress. This can be done using the PageLock and PageUnlock functions
available in the IDirectDrawSurface2 interface.
HRESULT PageLock( LPDIRECTDRAWSURFACE lpddSurf, DWORD dwFlags );
HRESULT PageUnlock( LPDIRECTDRAWSURFACE lpddSurf, DWORD dwFlags );
There are no flags currently defined for these functions so the only valid
value for dwFlags is 0. This function may be called on a vram surface but
it will simply return DD_OK without doing anything. If called on a Sytem
Memory surface (ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY is nonzero) then all
of the memory pages used by this surface will be locked so that they cant
be paged out. A Lock count is maintained for each surface and incremented
each time PageLock is called for that surface. The count is decremented
when PageUnlock is called. When the count reaches 0, the memory is unlocked
and may then be paged by the operating system. Note that the performance
of the operating system may be negatively affected if too much memory is
locked.
The following codes may be returned from these two functions:
DD_OK
DDERR_INVALIDOBJECT
DDERR_INVALIDPARAMS
DDERR_SURFACE_LOCK
DDERR_CANTPAGELOCK
Driver can now Blit to and from System Memory surfaces
------------------------------------------------------
In DirectDraw 1.0, if a surface was in system memory, the HEL automatically
performed the blit. Some display cards have DMA hardware which allows them
to efficiently blit to and from system memory surfaces. The DDCAPS
structure has been expanded to allow drivers to report this capability.
The following fields have been added.
DWORD dwSVBCaps
DWORD dwSVBCKeyCaps
DWORD dwSVBFXCaps
DWORD dwSVBRops[DD_ROP_SPACE]
DWORD dwVSBCaps
DWORD dwVSBCKeyCaps
DWORD dwVSBFXCaps
DWORD dwVSBRops[DD_ROP_SPACE]
DWORD dwSSBCaps
DWORD dwSSBCKeyCaps
DWORD dwSSBFXCaps
DWORD dwSSBRops[DD_ROP_SPACE]
The SVB prefix indicates capabilities bits that relate to System memory to
Video memory Blits. The VSB prefix indicates capabilities bits that relate
to Video memory to System memory Blits. The SSB prefix indicates
capabilities bits that relate to System memory to System memory Blits.
The dwSVBCaps field corresponds to the dwCaps field except that it describes
the blitting capabilities of the display driver for System Memory to Video
Memory blits. Likewise, the dwSVBCKeyCaps corresponds to the dwCKeyCaps
field and dwSVBFXCaps corresponds to dwFXCaps. The dwSVBRops array describes
the raster ops that the driver supports for this type of blit.
These fields are only valid if the DDCAPS_CANBLTSYSMEM bit is set in dwCaps
indicating that the driver is able to blit to or from system memory.
If the system memory surface being used by the hardware blitter is not
locked, Direct Draw will automatically call PageLock on the surface to insure
that the memory has been locked.
DirectDraw Palette Objects
==========================
Setting Palettes on Non-Primary surfaces
----------------------------------------
In DirectDraw 1.0 palettes could only be attached to the primary surface.
Palettes can now be attached to any palletized surface (primary, back
buffer, offscreen plain or texture map). Only those palettes attached
to primary surfaces will have any effect on the system palette. In it
important to note that DirectDraw blits never perform color conversion -
any palettes attached to the source or destination surface of a blit are
ignored. Furthermore, the DirectDraw surface function GetDC() also ignores
any DirectDraw palette selected into the surface.
Non-primary surface palettes are intended for use by applications or
Direct3D (or other 3D renderer).
Sharing Palettes
----------------
Palettes can now be shared between multiple surfaces. The same palette
can be set on the front and back buffer of a flipping chain or shared
between multiple texture surfaces. When a palette is attached to a
surface with SetPalette(), the surface increments the reference count
of that palette. When the reference count of the surface reaches zero
it will decrement the reference count of the attached palette. In
addition, if a palette is detached from a surface by calling SetPalette()
with a NULL palette interface pointer, the reference count of the
surface's palette will be decremented. Please note that if SetPalette()
is called several times consecutively for the same surface with the
same palette the reference count for the palette will be incremented
once only. Subsequent calls will not effect the palettes reference count.
New Palette Types
-----------------
In additional to the 8-bit (256 entry) palettes supported previously,
DirectDraw 2.0 supports 1-bit (2 entry), 2-bit (4 entry) and 4-bit
(16 entry) palettes. Such palettes can by created by specifying one of
the new palette capability flags; DDPCAPS_1BIT, DDPCAPS_2BIT and
DDPCAPS_4BIT. Matching capability flags have been added for surface
pixel formats (DDPF_PALETTEINDEXED1, DDPF_PALETTEINDEXED2 and
DDPF_PALETTEINDEXED4). A palette can only be attached to a surface with
a matching pixel format. For example, a 2 entry palette created with the
DDPCAPS_1BIT flag can only be attached to a 1-bit surface created with
the pixel format flag DDPF_PALETTEINDEXED1 etc. Furthermore, it is now
possible to create indexed palettes. An indexed palette is one whose
entries do not hold RGB colors but integer indices into the array of
PALETTEENTRYs of some target palette. An indexed palette's color table
is an array of 2, 4, 16 or 256 bytes where each byte is an index into
some unspecified, destination palette.
To create an indexed palette specify the palette capability flag
DDPCAPS_8BITENTRIES when calling CreatePalette(). For example, to
create a 4-bit, indexed palette specify DPCAPS_4BIT | DDPCAPS_8BITENTRIES.
When creating an indexed palette a pointer to an array of BYTEs is passed
rather than a pointer to an array of PALETTEENTRY structures. The pointer
to the array of BYTEs must be cast to an LPPALETTEENTRY when calling
CreatePalette().
DirectDraw Clipper Objects
==========================
Sharing Clippers
----------------
Clippers can now be shared between multiple surfaces. For example, the
same clipper can be set on both the front and back buffers of a flipping
chain. When a clipper is attached to a surface with SetClipper(), the
surface increments the reference count of that clipper. When the reference
count of the surface reaches zero it will decrement the reference count
of the attached clipper. In addition, if a clipper is detached from a
surface by calling SetClipper() with a NULL clipper interface pointer,
the reference count of the surface's clipper will be decremented.
Please note that if SetClipper() is called several times consecutively
for the same surface with the same clipper the reference count for the
clipper will be incremented once only. Subsequent calls will not
effect the clipper's reference count.
Driver Independent Clippers
---------------------------
It is now possible to create clipper objects which are not owned by a
DirectDraw driver object. Such clippers can be shared across multiple
driver objects. Driver independent clipper objects are created with
the new DirectDraw API function DirectDrawCreateClipper(). This function
can be called before any DirectDraw driver objects are created. As these
clippers are not owned by any DirectDraw driver object, they are not
automatically released when an application's driver objects are released.
If not released explicitly by the application such clippers will be
released by DirectDraw when the application terminates.
It is still possible to create clippers with the DirectDraw interface
member function CreateClipper(). Such clippers behave identically to
the clippers of DirectDraw 1.0. Specifically they will be automatically
released when the driver object from which they were created is released.
Enhanced Surface Format Support in the Hardware Emulation Layer (HEL)
=====================================================================
In DirectDraw 1.0 the Hardware Emulation Layer (HEL) could only create
surfaces whose pixel format exactly matched that of the current primary
surface. This restriction has been relaxed for DirectDraw 2.0.
The HEL now supports the following pixel formats for offscreen plain
surfaces.
Pixel Format Flags Bit Depth Red Mask Green Mask Blue Mask Alpha Mask
DDPF_RGB | DDPF_PALETTEINDEXED1 1 0x00000000 0x00000000 0x00000000 0x00000000
DDPF_RGB | DDPF_PALETTEINDEXED2 2 0x00000000 0x00000000 0x00000000 0x00000000
DDPF_RGB | DDPF_PALETTEINDEXED4 4 0x00000000 0x00000000 0x00000000 0x00000000
DDPF_RGB | DDPF_PALETTEINDEXED8 8 0x00000000 0x00000000 0x00000000 0x00000000
DDPF_RGB 16 0x0000F800 0x000007E0 0x0000001F 0x00000000
DDPF_RGB 16 0x00007C00 0x000003E0 0x0000001F 0x00000000
DDPF_RGB 24 0x00FF0000 0x0000FF00 0x000000FF 0x00000000
DDPF_RGB 24 0x000000FF 0x0000FF00 0x00FF0000 0x00000000
DDPF_RGB 32 0x00FF0000 0x0000FF00 0x000000FF 0x00000000
DDPF_RGB 32 0x000000FF 0x0000FF00 0x00FF0000 0x00000000
In addition to supporting a wider range of offscreen surface formats the
HEL also supports surfaces intended for use by Direct3D (or other 3D
renders). These surfaces are discussed in the next section.
Support for 3D Surfaces
=======================
Support for surfaces specific to 3D rendering has been enhanced in
DirectDraw 2.0. The 3D specific surface types; texture maps, mipmaps
and Z-buffers will be discussed below.
Texture Maps
------------
The surface capability flag used to indicate that a surface is a texture
is DDSCAPS_TEXTURE. This flag was previously DDSCAPS_TEXTUREMAP but was
modified for consistency with Direct3D. Texture maps can now be allocated
in system memory using the HEL. To allocate a texture map surface specify
the DDSCAPS_TEXTURE flag in the ddsCaps field of the surface description
passed to CreateSurface(). A wide range of texture pixel formats are
supported by the HEL. These formats are as follows:
Pixel Format Flags Bit Depth Red Mask Green Mask Blue Mask Alpha Mask
DDPF_RGB | DDPF_PALETTEINDEXED1, 1 0x00000000 0x00000000 0x00000000 0x00000000
DDPF_RGB | DDPF_PALETTEINDEXED1 |
DDPF_PALETTEINDEXEDTO8 1 0x00000000 0x00000000 0x00000000 0x00000000
DDPF_RGB | DDPF_PALETTEINDEXED2 2 0x00000000 0x00000000 0x00000000 0x00000000
DDPF_RGB | DDPF_PALETTEINDEXED2 |
DDPF_PALETTEINDEXEDTO8 2 0x00000000 0x00000000 0x00000000 0x00000000
DDPF_RGB | DDPF_PALETTEINDEXED4 4 0x00000000 0x00000000 0x00000000 0x00000000
DDPF_RGB | DDPF_PALETTEINDEXED4 |
DDPF_PALETTEINDEXEDTO8 4 0x00000000 0x00000000 0x00000000 0x00000000
DDPF_RGB | DDPF_PALETTEINDEXED8 8 0x00000000 0x00000000 0x00000000 0x00000000
DDPF_RGB, 8 0x000000E0 0x0000001C 0x00000003 0x00000000
DDPF_RGB | DDPF_ALPHAPIXELS, 16 0x00000F00 0x000000F0 0x0000000F 0x0000F000
DDPF_RGB, 16 0x0000F800 0x000007E0 0x0000001F 0x00000000
DDPF_RGB, 16 0x0000001F 0x000007E0 0x0000F800 0x00000000
DDPF_RGB, 16 0x00007C00 0x000003E0 0x0000001F 0x00000000
DDPF_RGB | DDPF_ALPHAPIXELS, 16 0x00007C00 0x000003E0 0x0000001F 0x00008000
DDPF_RGB, 24 0x00FF0000 0x0000FF00 0x000000FF 0x00000000
DDPF_RGB, 24 0x000000FF 0x0000FF00 0x00FF0000 0x00000000
DDPF_RGB, 32 0x00FF0000 0x0000FF00 0x000000FF 0x00000000
DDPF_RGB, 32 0x000000FF 0x0000FF00 0x00FF0000 0x00000000
DDPF_RGB | DDPF_ALPHAPIXELS, 32 0x00FF0000 0x0000FF00 0x000000FF 0xFF000000
DDPF_RGB | DDPF_ALPHAPIXELS, 32 0x000000FF 0x0000FF00 0x00FF0000 0xFF000000
The above formats are those which can be created by the HEL in system
memory. The DirectDraw driver for a 3D accelerated video card is free to
create textures of other formats in video memory. Such a driver should
export the DDSCAPS_TEXTURE bit to indicate that it can create textures
and should be prepared to handle the DirectDraw HAL callback,
CanCreateSurface() to verify that the surface description for a texture
map is one the driver is prepared to create.
Mipmaps
-------
DirectDraw 2.0 supports mipmapped texture surfaces. A mipmap is a
sequence of textures, each of which is a progressively lower resolution,
pre-filtered representation of the same image. Mipmaps are a
computationally low cost way of improving the quality of rendered textures.
Each pre-filtered image (or level) in the mipmap is a power of two
smaller than the previous level. In DirectDraw 2.0 mipmaps are represented
as a chain of attached surfaces. The highest resolution texture is at the
head of the chain and has, as an attachment, the next level of the mipmap
which has, in turn, an attachment which is the next level in the mipmap
and so on down to the lowest resolution level of the mipmap.
To create a surface representing a single level of a mipmap specify the
DDSCAPS_MIPMAP surface capability in the surface description passed to
CreateSurface(). As all mipmaps are also textures the DDSCAPS_TEXTURE
capability must also be specified. It is possible to create each level
manually and build the chain with AddAttachedSurface(). However,
CreateSurface() can be used to build an entire mipmap chain in a single
operation. The following code fragment demonstrates building a chain
of five mipmap levels of sizes 256x256, 128x128, 64x64, 32x32 and 16x16.
DDSURFACEDESC ddsd;
LPDIRECTDRAWSURFACE lpDDMipMap;
ZeroMemory(&ddsd, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_MIPMAPCOUNT;
ddsd.dwMipMapCount = 5;
ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_MIPMAP |
DDSCAPS_COMPLEX;
ddsd.dwWidth = 256UL;
ddsd.dwHeight = 256UL;
ddres = lpDD->CreateSurface(&ddsd, &lpDDMipMap);
if (FAILED(ddres))
...
It is permissible to omit the number of mipmaps levels, in which case
CreateSurface() will create a chain of surfaces each a power of two
smaller than the previous one down to the smallest possible size. It is
also possible to omit the width and height in which case CreateSurface()
will create the number of levels you specify with a minimum level size of
1x1.
A chain of mipmap surfaces is traversed using GetAttachedSurface()
specifying the DDSCAPS_MIPMAP and DDSCAPS_TEXTURE capability flags. The
following code fragment traverses a mipmap chain from highest to lowest
resolutions.
LPDIRECTDRAWSURFACE lpDDLevel, lpDDNextLevel;
DDSCAPS ddsCaps;
lpDDLevel = lpDDMipMap;
lpDDLevel->AddRef();
ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_MIPMAP;
ddres = DD_OK;
while (ddres == DD_OK)
{
// Process this level
...
ddres = lpDDLevel->GetAttachedSurface(&ddsCaps,
&lpDDNextLevel);
lpDDLevel->Release();
lpDDLevel = lpDDNextLevel;
}
if ((ddres != DD_OK) && (ddres != DDERR_NOTFOUND))
...
It is also possible to build flippable chains of mipmaps. In this
scenario each mipmap level has an associated chain of back buffer
texture surfaces. Each back buffer texture is attached to one level
of the mipmap. Only the front buffer in the chain has DDSCAPS_MIPMAP
set, the others are simply texture maps (DDSCAPS_TEXTURE). A mipmap
level can have two attached texture maps, one with the capability flag
DDSCAPS_MIPMAP set, which is the next level in the mipmap chain, and one
with the capability flag DDSCAPS_BACKBUFFER set, which is back buffer
of the flippable chain. Note that all the surfaces in each flippable
chain must be of the same size.
It is not possible to build such a surface arrangement with a single
call to CreateSurface(). To construct a flippable mipmap either build
a complex mipmap chain and manually attach backbuffers with
AddAttachedSurface() or create a sequence of flippable chains and
build the mipmap with AddAttachedSurface().
It is important to note that blit operations apply to only a single
level in the mipmap chain. To blit an entire chain of mipmaps each
level must be blit separately. Also note that Flip()will not currently
flip an entire mipmap chain but only a single level of the mipmap. This
is a defect and will be corrected.
Z Buffers
---------
The DirectDraw HEL can now create Z buffers for use by Direct3D (or
other 3D rendering software). The HEL supports both 16 and 32-bit
Z buffers. The DirectDraw driver for a 3D accelerated video card can
permit the creation of Z buffers in video memory by exporting the surface
capability bit DDSCAPS_ZBUFFER. It should also specify the Z buffer
depths it supports using the dwZBufferBitDepth field of the DDCAPS
structure.
Z buffers can be cleared using the DirectDraw surface function Blt().
A new DDBLT_ flag (DDBLT_DEPTHFILL) has been defined to indicate that
the blit is a Z buffer clear. If this flag is specified the DDBLTFX
structure passed to Blt() should have its dwFillDepth field set to
the required Z depth. If the DirectDraw driver for a 3D accelerated
video card wishes to provide support for Z buffer clearing in hardware
it should export the capability flag DDCAPS_BLTDEPTHFILL and should
have code to handle DDBLT_DEPTHFILL blits. The destination surface
of a depth fill blit must be a Z buffer. Please note that the actual
interpretation of depth value is 3D renderer specific.
Direct3D Integration
====================
DirectDraw 2.0 is very tightly integrated with Direct3D. The most
important aspects of this integration are discussed below.
The Direct3D Driver Interface
-----------------------------
DirectDraw 2.0 presents a single, unified driver object to the
application programmer. This driver object encapsulates both
DirectDraw and Direct3D state. The DirectDraw driver COM interfaces
(IID_IDirectDraw or IID_IDirectDraw2) and the Direct3D driver COM interface
(IID_IDirect3D) are both interfaces which allow the application programmer
to communicate with the same underlying driver object. Hence no Direct3D
driver object is created. Rather a Direct3D interface to the DirectDraw
driver object is obtained. This is achieved using the standard COM
QueryInterface() function.
The following code fragment demonstrates creating the DirectDraw driver
object and obtaining a Direct3D interface for communicating with that object.
LPDIRECTDRAW lpDD;
LPDIRECT3D lpD3D;
ddres = DirectDrawCreate(NULL, &lpDD, NULL);
if (FAILED(ddres))
...
ddres = lpDD->QueryInterface(IID_IDirect3D, &lpD3D);
if (FAILED(ddres))
...
The above code creates a single object and obtains two interfaces to
that object. Hence, the reference count of the driver object after the
QueryInterface() is two. The important implication of this is that the
lifetime of the Direct3D driver state is the same as that of the DirectDraw
object. Releasing the Direct3D interface does not destroy the Direct3D
driver state. That state is not destroyed until all references (both
DirectDraw and Direct3D) to that driver object have been released.
Hence, if you release a Direct3D interface, while holding a reference
to a DirectDraw driver interface, and then re-query the Direct3D
interface all the Direct3D state will be preserved.
The Direct3D Device Interface
-----------------------------
As with the driver object, there is no distinct Direct3D device object.
A Direct3D device is simply an interface for communicating with a
DirectDraw surface used as a 3D rendering target. For example, the
following code fragment creates a Direct3D device interface to a
DirectDraw surface object.
LPDIRECTDRAWSURFACE lpDDSurface;
LPDIRECT3DDEVICE lpD3DDevice;
ddres = lpDD->CreateSurface(&ddsd, &lpDDSurface, NULL);
if (FAILED(ddres))
...
ddres = lpDDSurface->QueryInterface(lpGuid, &lpD3DDevice);
if (FAILED(ddres))
...
The same rules of reference counting and state lifetime discussed for
driver objects apply to DirectDraw surfaces and Direct3D devices.
Additionally, multiple, distinct Direct3D device interfaces can be
obtained for the same DirectDraw surface. Hence, it is possible that
a single DirectDraw surface be the target for both a ramp based device
and an RGB based device.
The Direct3D Texture Interface
------------------------------
Direct3D textures are, once again, not a distinct object type but
rather another interface of DirectDraw surface objects. The following
code fragment obtains a Direct3D texture interface from a DirectDraw
surface object.
LPDIRECTDRAWSURFACE lpDDSurface;
LPDIRECT3DTEXTURE lpD3DTexture;
ddres = lpDD->CreateSurface(&ddsd, &lpDDSurface, NULL);
if (FAILED(ddres))
...
ddres = lpDDSurface->QueryInterface(IID_IDirect3DTexture,
&lpD3DTexture);
if (FAILED(ddres))
...
The same reference counting and state lifetime rules of driver objects
and devices apply. It is possible to use a single DirectDraw surface as
both a rendering target and a texture.
The DirectDraw HEL and Direct3D
-------------------------------
The DirectDraw HEL has been enhanced to support the creation of texture,
mipmap and Z buffer surfaces. Furthermore, due to the tight integration
of DirectDraw and Direct3D, a DirectDraw enabled system will always
provide Direct3D support (in software emulation at least). Hence, the
DirectDraw HEL exports the DDCAPS_3D capability flag to indicate the
availability of Direct3D in software emulation. A DirectDraw driver for
a hardware accelerated 3D video card should export this capability flag
to indicate the presence of hardware accelerated 3D.
GetAvailableVidMem
==================
DirectDraw 2.0 adds a new DirectDraw interface function to query the
amount of video memory available to a specific type of surface as
defined by surface capability flags. To ensure COM compliance this
function is not a member of the DirectDraw 1.0 interface but is part
of the new DirectDraw 2.0 interface, IID_IDirectDraw2. To invoke this
function you must first query for the new DirectDraw interface.
The following code fragment demonstrates using GetAvailableVidMem()
to determine both the total and free video memory available for
texture map surfaces.
LPDIRECTDRAW2 lpDD2;
DDSCAPS ddsCaps;
DWORD dwTotal;
DWORD dwFree;
ddres = lpDD->QueryInterface(IID_IDirectDraw2, &lpDD2);
if (FAILED(ddres))
...
ddsCaps.dwCaps = DDSCAPS_TEXTURE;
ddres = lpDD2->GetAvailableVidMem(&ddsCaps, &dwTotal, &dwFree);
if (FAILED(ddres))
...
It should be noted that this function gives a snapshot of the current
video memory state only. The amount of free video memory is subject to
change as surfaces are created and released. Hence, the free memory
figure should be used as a rough guide only. In addition, a particular
video card may make no distinction between two different memory types.
For example, it may use the same portion of video memory to store Z
buffers and textures. Hence, allocating one type of surface (a Z buffer
say) may affect the amount of video memory available for another type
of surface (textures say). Therefore, it is best to first allocate an
application's fixed resources (such as front, back and Z buffer) before
determining how much memory is available for dynamic use (for texture
mapping, for example).
Miscellaneous Changes
=====================
New Error Return Codes
----------------------
DDERR_NOMIPMAPHW - an attempt was made to create a mipmap in video
memory but the hardware DirectDraw driver does not support mipmaps.
DDERR_INVALIDSURFACETYPE - an attempt was made to perform an operation
on a surface but the capabilities of that surface do not support the
operation.

37
docs/readme/dinput.txt Normal file
View File

@ -0,0 +1,37 @@
DirectInput 3.0 release notes
What's new in DirectInput 3.0
=============================
-COM interface that supports mouse and keyboard data. Examples are provided in Flip2D (mouse), Duel (keyboard) and scrawl. For detailed information on the new interface see DInput3e.doc. These new interfaces are not described in the DirectX help file.
-Bug fixes to VJOYD.VXD and joy.cpl. A few key fixes are listed below:
VJOYD polling is no longer interrupted by DMA access. This should fix the problem of the joystick behaving erratically when audio is being played.
VJOYD now passes the data in the dwReserved2 field of the JOYINFOEX structure to the mini-driver on request.
Devices without buttons can now be calibrated in joy.cpl.
VJOYD.VXD now works correctly with global port drivers.
INITGUID vs. DXGUID.LIB
=======================
You can generate the DirectInput GUIDs yourself by defining INITGUID. However, if you want to avoid generating all of the DirectInput GUIDs (including the ones you don't use), link to DXGUID.LIB instead of defining INITGUID.
Documentation for for DirectInput 3.0
=====================================
The documentation for the COM interfaces to support mouse and keyboard devices are not in the DirectX help file. They are documented in the file dinput3e.doc which can be found in the \docs directory. The joystick APIs, however, are still documented in the DirectX help file.
DirectInput 3.0 for the Windows NT Operating System
===================================================
In the EXTRAS\dinput directory on the CD is a preliminary version of DirectInput 3.0 for the Windows NT Operating System. See the readme in that directory for more information.
The implementation of DirectInput 3.0 for Windows NT has the following limitations:
* The keyboard can be acquired only in non-exclusive foreground mode.
* The mouse can be acquired only in exclusive foreground mode.

149
docs/readme/dplay.txt Normal file
View File

@ -0,0 +1,149 @@
DirectPlay Notes:
1. What's New!
--------------
See the DirectPlay section in the DirectX help file for more details
on what's new.
Highlights include:
- IDirectPlayLobby - an interface that allows an external application
to launch a DirectPlay 3.0 application and provide it with all the
connection information needed to get connected to a session.
Try out the DPLAUNCH sample application for a demo of this!
- Internet TCP/IP service provider - now you can have multiplayer
applications over the Internet
- Unicode support
- Host migration
- Automatic player data propagation
- Better performance, less overhead, more stability and robustness
- Support for 3rd-party network service providers
All the new functionality of DirectPlay is in the IDirectPlay2
(Unicode) and IDirectPlay2A (ANSI) interfaces. When compiling, it is
recommended that you define the symbol IDIRECTPLAY2_OR_GREATER to make
sure that you are not using any obsolete flags or structures. The
IDirectPlay interface has not changed from previous versions of
DirectPlay.
2. Samples
----------
The following samples can be examined for examples of how to use
DirectPlay
SDK/SAMPLES/DUEL
- This simple multiplayer game uses the new IDirectPlay2 interface
- It also uses IDirectPlayLobby to make it lobby-able
SDK/SAMPLES/DPLAUNCH
- This stand-alone application demonstrates how a DirectPlay 3 app
can be launched from an external source using the IDirectPlayLobby
interface
SDK/SAMPLES/IKLOWNS
- Another multiplayer game which still uses the old IDirectPlay
interface
- It also use IDirectPlayLobby to make it lobby-able
3. General Notes
----------------
-- The names of the DirectPlay 3 DLLs have changed. The names of the
new DLLs are:
dplayx.dll - DirectPlay 3 dll
dpwsockx.dll - Winsock service provider (TCP/IP and IPX)
dpmodemx.dll - modem and serial service provider.
Make sure that any applications in development link to DPLAYX.LIB.
Applications compiled with DirectPlay 2 or earlier will not use these
new DLLs and therefore not benefit from the enhancements of DirectPlay 3.
*** If you installed Beta1 of DirectX 3, the DirectPlay 3 DLLs will
have overwritten any DirectPlay 2 DLLs you may have had installed.
Beta2 will delete these DLLs if they have the version number of
DirectX 3 (4.04.xxxx)
*** To restore them, simply reinstall DirectX 2 or any game that uses
DirectX 2. Alternatively, copy the files DPLAY.DLL, DPWSOCK.DLL and
DPSERIAL.DLL from your DirectX 2 CD to the windows SYSTEM directory.
-- The synchronization event parameter in IDirectPlay2::CreatePlayer has
been changed to a HANDLE (from an LPHANDLE). The handle must be
created by the application. Passing in an LPHANDLE will NOT generate
a compiler error but it will cause the method to return an error.
-- Make sure you read and understand the behavior of the DPSEND_GUARANTEED
flag in the Send() API. Additional text has been added to clarify the
usage of this flag.
-- The Internet TCP/IP service provider now maintains a cache of open
sockets to improve the performance of guaranteed messages i.e. sockets
will not be opened and closed for each individual message. Calling
GetCaps() and asking for the guaranteed capabilities will tell you
how many players can be supported (dwMaxPlayers).
-- If an application tries to send messages that are larger than the
maximum packet size of a protocol, DirectPlay will break it up
and send it using multiple packets and reassembling the packets on
the receiving end into a single message.
-- Added ability to host more than one game on a single machine (TCP/IP only)
-- The DirectPlay Address structure now uses GUIDs to identify chunks
in the address instead of four character codes.
-- Applications with short timeouts will not work over the Internet
due to the long latencies. Applications should specify a timeout value
of zero in EnumSessions in which case an appropriate timeout will
be calculated by the service provider.
-- DirectPlayConnect is obsolete. An application will need to create an
IDirectPlayLobby interface. It may query the connection settings that
the lobby passed in using GetConnectionSettings, and modify them using
SetConnectionSettings. It highly recommended that the application
verify that the correct session description flags are set using this
method. Finally, the application should call the Connect method and
then Release the IDirectPlayLobby interface.
-- There is now an ANSI and a UNICODE version of the DirectPlayLobbyCreate
API. The version is selected based on the UNICODE compile-time flag.
-- To use TCP/IP over the Internet, the users joining the session must
enter the IP address of the machine that hosted the game when prompted
by the service provider.
You can find out the IP address of your machine by running "winipcfg".
If you have a net card and a modem installed, you will need to make
sure you read the IP address of the modem connection to the Internet.
The IP address information for the modem will typically show up under
"PPP Adapter".
4. Known Problems
-----------------
-- Inside of any DirectPlay enumeration callback only the thread running
the callback can make calls back into the DirectPlay API. Other threads
and the service provider will be blocked from calling DirectPlay until
the enumeration has completed, so it is important to have enumeration
callbacks complete quickly.
-- IPX will not allow playing more than one game simultaneously. Use
TCP/IP to do that.
-- There is no multi-home support for IPX. Use TCP/IP if multi-homing
is needed.
-- If an application sets the player name or remote data for a non-local
player, the change will not be propagated to the remote applications.
-- DirectPlay generally will not work through proxies and firewalls.

75
docs/readme/dsound.txt Normal file
View File

@ -0,0 +1,75 @@
DirectSound 3 Readme File
1. New Features in DirectSound 3
================================
- DirectSound3D is finally available! This implementation includes
the ability to position and move sounds in 3D space, complete with Doppler
shifting, attenation due to distance, and a sound cone feature which
allows you to create sounds which are louder when pointing straight at
you than when they are pointing away. DirectSound3D has a flexible
coordinate system which allows you to use your internal game coordinates
and still get the effects you want. To learn more, check out the help
files, or look at the following samples:
\dxsdk\sdk\samples\ds3dview
\dxsdk\sdk\samples\dsshow3d
\dxsdk\rockem
- Global Sounds. Many developers wanted to make sounds even when their
application is not the foreground application. Now you can! Just create
your sound sound buffer with the DSBCAPS_GLOBALFOCUS flag specified and
the sound buffer will be audible regardless of sound focus. However,
please note the following caveats:
a) Global sounds will not be audible if the sound focus application
has the DSSCL_EXCLUSIVE level set. That application has requested
that it not be interrupted, so we respect that request.
b) You can't create a global sound on a DirectSound object that has
DSSCL_WRITEPRIMARY.
2. New Sound Driver Support
===========================
This release contains support for the ESS 1788 card and new versions of
the ESS 1688 and SoundBlaster AWE 32 cards, in addition to the drivers
supported in DirectX 1 and 2. This brings our total sound card coverage
to the following:
- Sound Blaster: 8-bit cards, 16-bit cards, and the AWE32.
- ESS: 488, 688, 1488, 1688, 1788.
- MediaVision: PAS 16, PAS Studio, PAS Plus, Pro 3D, and Blue Lite Special.
- Aztech: Nova 16, Washington 16, Rocky 2.
- Microsoft: Windows Sound System.
Sound cards which do not have DirectSound drivers can still be accessed
through DirectSound. If no driver is available, DirectSound will use its
emulation layer to communicate with the device through the standard Wave
driver interface. This provides full DirectSound functionality, but
increases latency significantly and prevents access to hardware
acceleration.
We have also encountered faults in certain situations on the Roland
Rap 10 and the Gravis UltraSound MAX.
3. Known Problems with this release
===================================
- DirectSound3D consumes more CPU than ordinary mixing. Our measurements
indicate that it consumes about 6% of a P90 per sound. If you ask
DirectSound to play more 3D sounds than the processor is capable of, we
will do our best to satisfy your demand. In practice, this will mean
that the CPU will be overloaded and will be unable to spend any cycles
on ordinary things like updating your display or reading your keyboard.
So be sure to test your application to make sure that it runs on your
low-end target platform.
Thanks!
The DirectSound Team.

41
docs/web/begindoc.htm Normal file
View File

@ -0,0 +1,41 @@
<html>
<head>
<title>Writing 3D Applications</title>
</head>
<body bgcolor=#000000 text=#FFFFFF link=#FF0000 vlink=#FFFF00>
<basefont face="Times New Roman" size=3>
<TABLE CELLPADDING=0 CELLSPACING=0 BORDER=0>
<BLOCKQUOTE>
<FONT FACE="arial" SIZE="2">
<!--DocHeaderEnd-->
<!-- This is a PANDA Generated HTML file. The source is a WinWord Document. -->
<h2>Writing Direct3D Apps for Hardware Accelerators: The BeginScene()/EndScene() API Calls</h2>
<P>The DirectX Team
<P>August 2, 1996
<P><h4>Introduction</H4>
<P>Proper use of Direct3D's <b>BeginScene()</b> and <b>EndScene()</b> is essential to making your application work properly with hardware 3-D accelerators. This article describes the operation of <b>BeginScene()</b> and <b>EndScene()</b> and gives guidelines for their use. Failure to follow these guidelines may cause your application to render incorrectly on a broad class of forthcoming 3-D hardware.
<P><h4>Definition</H4>
<P>A <i>scene</i> in the Direct3D immediate mode is a collection of all the vertices and drawing primitives (triangles, lines, and points) used to draw a single frame. <b>BeginScene()</b> marks the beginning of a scene (and hence the start of a frame) and <b>EndScene()</b> marks the end of a scene (and hence the end of the frame).
<P>In keeping with this definition, it is essential that all the execute buffer executions used to draw a single frame be bracketed by a single <b>BeginScene()</b>/<b>EndScene()</b> pair.
<P><h4>Justification</H4>
<P>Correct use of <b>BeginScene()</b> and <b>EndScene()</b> is important to support a class of emerging 3-D hardware accelerators which do not use a conventional z-buffer to perform hidden surface removal. Such accelerators may implement a number of mechanisms for performing hidden surface removal (such as internal tiling and polygon sorting). However, to perform hidden surface removal, they all must process a copy of the entire geometric database for a single frame.
<P>To accomplish this task, such accelerators must perform <i>Scene Capture</i>. In other words, they must store, for later processing, the geometric information passed to them via execute buffers.To ensure the hidden surface processing is correct, a single <b>BeginScene()</b> and <b>EndScene()</b> must bracket <b>all</b> the drawing instructions comprising a single frame. If multiple <b>BeginScene()</b> and <b>EndScene()</b> calls are made while composing a single frame, the accelerator will be unable to correctly resolve hidden surface interactions between triangles executed in different scene contexts.
<P>Furthermore, an application should not assume that multiple <b>BeginScene()</b>/<b>EndScene()</b> calls per frame are permissible simply because it knows there are no hidden surface interactions between the triangles in different scene contexts. Certain accelerators use scene capture to perform high-quality rendering effects in addition to hidden surface removal. For example, a scene-capturing accelerator may be able to render shadows and semitransparent objects. These effects rely on the entire geometric database for a frame being available to the accelerator for processing. Multiple <b>BeginScene()</b> and <b>EndScene()</b> contexts will break such effects.
<P><h4>2-D and 3-D Interaction</H4>
<P>Accelerators that perform scene capture probably will be unable to interleave 2-D drawing operations such as blits and direct writes with 3-D drawing operations in a scene context. Accelerators that have this restriction export the DirectDraw capability bit DDCAPS2_NO2DDURING3DSCENE. Therefore, an application should check this capability bit and, if it is present, not perform <b>DirectDraw Blt()</b>, <b>GetDC()</b>, or <b>Lock()</b> calls on the rendering surface between calls to <b>BeginScene()</b> and <b>EndScene()</b>.
<P><h4>What to Do</H4>
<P>To make sure that your application correctly renders on all 3-D accelerators (including those that perform scene capture), do the following:
<P>1. Ensure that all the execution of execute buffers that hold triangles (and other rendering primitives instructions) for a single frame are preceded by a single call to <b>BeginScene()</b> and followed by a single call to <b>EndScene()</b>.
<P>2. Check the DirectDraw caps bit DDCAPS2_NO2DDURING3DSCENE. If it is set, do not call DirectDraw's <b>Blt()</b>, <b>GetDC()</b> or <b>Lock()</b> functions on the rendering surface between a call to <b>BeginScene()</b> and <b>EndScene()</b>. Such 2-D operations can be performed after <b>EndScene()</b> has been invoked.
<P>3. Ensure that your application does not assume that any rendering primitives included in an execute buffer have been rendered to the target surface when <b>Execute()</b> returns. Scene capture cards will postpone rendering until the scene is complete (<b>EndScene()</b> has been called).
<P>
</body>
</html>

BIN
docs/web/contents.gif Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 2.6 KiB

88
docs/web/d3dcd.htm Normal file
View File

@ -0,0 +1,88 @@
<html>
<head>
<title>Direct3D</title>
</head>
<body bgcolor="#000000" text="#FFFFFF" link="#FFFF00" vlink="#FF0000">
<center><i><h1><font size 8>Direct3D</font></h1></i></center>
<br><br>
<table width=100% cellspacing="10">
<tr>
<td> <h3>Articles of Interest</h3> </td>
</tr>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<tr>
<td> <a href="begindoc.htm"><i>Tips for Writing Direct3D Applications </i></a></td>
<td> Writing Direct3D Apps for Hardware Accelerators: The BeginScene() / EndScene() API Calls</td>
</tr>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <a href="d3dramp.htm"><i>Running fast with the D3D Ramp driver </i></a></td>
<td> There are a number of ways to get maximum performance from the ramp driver.
This document details the two most useful texturing modes, Copy Mode and Shaded
Ramp Mode. This document covers rasterization performance tips for these modes.
When used correctly, the ramp driver should be able to run faster than some hardware
alternatives.</td>
</tr>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<br>
<td> <h3>CD Links</h3> </td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <a href="../readme/conv3ds.txt"><i>Conv3DS Readme File</i></a></td>
<td>Conv3ds converts 3Ds models produced by Autodesk 3D Studio and other
modelling packages into X Files. By default it produces binary X files
with no templates.</td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <a href="../readme/d3d.txt"><i>Direct 3D Readme File</i></a></td>
<td>Includes notes on the software emulation drivers, RAMP driver support and performance
notes, RGB driver, Functionality, Performance, and Known Issues </td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<br>
<br>
<td> <h3>Samples of Direct3D</h3> </td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<tr><td><a href="../../sdk/bin/flipcube.exe "><i>FlipCube</i></a></td><tr>
<tr><td> <a href="../../sdk/bin/globe.exe "><i>Globe</i></a></td></tr>
<tr><td> <a href="../../sdk/bin/twist.exe "><i>Twist</i></a></td></tr>
<tr><td> <a href="../../sdk/bin/tunnel.exe "><i>Tunnel</i></a></td></tr>
<tr><td> <a href="../../sdk/bin/viewer.exe "><i>Viewer</i></a></td></tr>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
</table>
<br><br>
<align=bottom border=0 width=144 height=131>
<IMG SRC="screen2.jpg">&nbsp;
<IMG SRC="screen3.jpg">&nbsp;
<IMG SRC="screen4.jpg">
<a href="http://www.microsoft.com/windows/anniversary/favor.htm">Download a Direct3D Screen Saver
</body>
</html>

48
docs/web/d3dramp.htm Normal file
View File

@ -0,0 +1,48 @@
<html>
<head>
<title>Running fast with the D3D Ramp Driver</title>
</head>
<body bgcolor=#000000 text=#FFFFFF link=#FF0000 vlink=#FFFF00>
<basefont face="Times New Roman" size=3>
<TABLE CELLPADDING=0 CELLSPACING=0 BORDER=0>
<BLOCKQUOTE>
<FONT FACE="arial" SIZE="2">
<!--DocHeaderEnd-->
<!-- This is a PANDA Generated HTML file. The source is a WinWord Document. -->
<h2>Running fast with the D3D Ramp Driver</h2>
<P>The DirectX Team
<P>September 5, 1996
<P><h4>Introduction</H4>
<P>There are a number of ways to get maximum performance from the ramp driver. This document details the two most useful texturing modes,<i> Copy Mode and Shaded Ramp Mode</i>. This document covers rasterization performance tips for these modes. When used correctly, the ramp driver should be able to run faster than some hardware alternatives.
<P><h4>Copy Mode</H4>
<P>Copy Mode is the simplest form of rasterization and hence the fastest. When copy mode rasterization is used, no lighting or shading is performed on the texture. The bytes from the texture is copied directly to the screen and mapped onto the polygon using the texture co-ordinates in the vertex. Hence, when using copy mode, the texture format must match the format of the screen. For this reason copy mode is only really useful in 8 bit colour as in 16 bit colour the texture size is doubled, this makes copy mode slower than other rendering modes in 16 bit colour.
<P>Copymode only implements two rasterization options, Z buffering and chroma key transparency. The fastest mode is to just map with no transparency and no Z. Enabling chroma key accelerates the rasterization of invisible pixels as just the texture read is performed, but visible pixels will incur a slight performance hit due to the chroma test.
<P>Enabling Zbuffering incurs the biggest hit for 8 bit copy mode as now a 16 bit value has to be read and conditionally written per pixel. Z buffering copymode can only be faster than non Z copy mode when the average overdraw goes over 2, and the scene is rendered in front to back polygon order.
<P>If your scene has overdraw less than 2 (which is very likely) you should ignore using the Z buffer. The only exception to this rule is if the scene complexity is very high. For example, if you have more than about 1500 rendered polys in the scene the sort overhead begins to get high and it may be worth considering a Z buffer again.
<P>Direct3D will go fastest when all it needs to do is draw one long triangle instruction. Render state changes just get in the way of this, the longer the average triangle instruction the better triangle throughput. Hence peak sorting performance can be achieved when all the texture for a given scene is contained in only one texture map or texture page. This adds the restriction that no texture co-ordinate can be larger than 1.0 but has the performance benefit of no texture state changes at all!
<P>So for normal simple scenes use one texture, one material and sort your triangles, only use Z when the scene gets complex.
<P><h4>A Few Further Tips On Sorting</H4>
<P>If you are sorting, you need to implement your own transform and clipping as Direct3D only accepts unclipped TLVertices (until DX4). In this scenario you will almost certainly be building execute buffers on the fly. One of the simplest ways of doing this is to put all the instructions in the front of the buffer and all the vertices at the end. Say your whole buffer is big enough to contain 1024 vertices, the first triangle generated would be placed at the front of the buffer indexing vertex 1022,1023 and 1024 at the end of the buffer. This scheme means that no buffer space is wasted and there is no dependency on maximum buffer size, as when the instructions growing from the bottom up meet the vertices growing from the top down the buffer is dispatched and a new one started.
<P><h4>Introducing Lighting</H4>
<P>When lighting is used we will almost certainly want to Gouraud shade. Ramp mode Gouraud shading is about 15-20% faster in 8 bit than in 16 bit colour due the decreased memory bandwidth. When lighting, we are using more CPU for rasterization than copy mode, it is not so crucial (but still advisable) to avoid state changes. If you have a few large background polygons in the scene you should try and flat shade them as this is 20-30% faster than gouraud for large polygons.
<P>We now need to worry about materials, in a textured scene you should only need two materials and may even be able to get away with one. Materials allow modulation of the texture colour, this operation should be left to RGB drivers (mainly MMX and HW) in ramp it is best just to stick with intensity modulation.ff
The Ramp driver is named after its use of ramps (colour lookup tables) A d3d material contains a set of colour values and a texture handle. For each colour in the textures palette the ramp driver builds a lookup table of intensities (ramp). The size of the ramps are determined by the shades field in the d3d material. So a texture with a palette of 32 colours in a material with shades set to 16 will generate 32 16 entry ramps. The more ramps there are in a scene the slower the performance due to the worse use of the CPU cache. It is best to use one material setting for all textures and the same palette of 64 or preferably less colours for all textures in the scene. If two textures use the same material any colours that are the same between the two texture palettes will share the same ramp.
<P>As for copy mode Z buffering does incur a performance hit for low overdraw scenes and the same technique of tiling as many textures as possible in to larger texture pages is still beneficial, all the copy mode sorting tips still apply when using shading.
<P><h4>System or Video Memory</H4>
<P>Where should the back buffer go? This can have a large affect on performance but can vary wildly depending on the application and the HW configuration. On faster CPU's, both the above rendering modes will tend to render faster to system memory than video memory as they are helped by the CPU cache. This performance boost is offset by the fact the app can no longer use page flipping and instead must blit from the system memory back buffer to a video memory back buffer. The cost of this blit will often be the decider in the performance. This is especially true of the MMX driver which renders MUCH faster to system memory than video. The only way to really know which is to run and time the app for a few frames in each configuration. All the D3D samples have a system memory option to enable this.
</body>
</html>

45
docs/web/dbugcd.htm Normal file
View File

@ -0,0 +1,45 @@
<html>
<head>
<title>DirectX Bugs</title>
</head>
<body bgcolor=#000000 text=#FFFFFF link=#FFFF00 vlink=#FF0000>
<basefont face="Times New Roman" size=3>
<center><i><h1><font size 8>DirectX Bug Reporting</font></h1></i></center>
<table>
<table width=100% cellspacing="8">
<tr>
<td> <img height=35 width=40 src="word.bmp" alt="Word"> </td>
<td> <a href="dxbugs.doc"><i>DirectX Bug Reporting Template</i></a></td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<P>Name:
<P>Email Name:
<P>Phone Number:
<P>Company:
<P>DirectX Area
(DirectPlay, DirectSound, Direct3D, DirectDraw, DirectInput):
<P>What Build:
<P>Your System Configuration:
<P>Problem in Detail:
<P>Steps to Reproduce:
</table><br><br>
<a href="mailto:dxbugs@microsoft.com">Send Mail to: DirectX Bug Reporting Mail Alias</a>
</body>
</html>

59
docs/web/ddrwcd.htm Normal file
View File

@ -0,0 +1,59 @@
<html>
<head>
<title>DirectDraw</title>
</head>
<body bgcolor=#000000 text=#FFFFFF link=#FFFF00 vlink=#FF0000>
<basefont face="Times New Roman" size=3>
<font size=8 ><i><center><h1>DirectDraw</h1></center></i></font>
<table width=100% cellspacing="10">
<tr>
<td> <h3>Articles of Interest</h3> </td>
</tr>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<tr>
<td> <a href="http://www.microsoft.com/GAMESDEV/GGRAPHIC/gklopf.htm"><i>DirectDraw Articles </i></a></td>
<td>Basics of DirectDraw Game Programming </td>
</tr>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<br>
<td> <h3>CD Links</h3> </td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <a href="../readme/ddraw.txt"><i>DirectDraw Readme File</i></a></td>
<td>Some of the many topics covered are; SetDisplayMode now supports setting the
monitor refresh rate, Direct Draw modes now respect monitor settings
IDirectDrawSurface2::DDGetInterface now supported, Direct Draw clipper
objects now have a COM class factory. </td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<br>
<td> <h3>DirectDraw Samples</h3> </td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <a href="../../sdk/bin/donuts.exe"><i>Space Donuts</i></a></td>
<td>Space Donuts Game Sample</td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <a href="../../iklowns/iklowns.exe"><i>IKlowns</i></a></td>
<td>IKlowns Game Sample</td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
</table>
</body>
</html>

62
docs/web/dinpcd.htm Normal file
View File

@ -0,0 +1,62 @@
<html>
<head>
<title>DirectInput</title>
</head>
<body bgcolor=#000000 text=#FFFFFF link=#FFFF00 vlink=#FF0000>
<basefont face="Times New Roman" size=3>
<font size=8 ><i><center><h1>DirectInput</h1></center></i></font>
<table width=100% cellspacing="10">
<tr>
<td> <h3>Articles of Interest</h3> </td>
</tr>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<tr>
<td> <a href="http://www.microsoft.com/gamesDEV/gNETWORK/gjoystic.HTM"><i>Extending DirectInput's Joystick Subsystem Services</i></a></td>
<td> DirectInput™, the joystick driver subsystem for Windows® 95, is the much-needed new standard for game developers working with input devices such as joysticks and game pads. The new digital joystick devices, such Microsoft® SideWinder™ 3D Pro, support multiple devices on a single port and provide discrete button and position information. DirectInput provides support for multiple joysticks, and it supports the latest in gaming-device technology, without the developer having to know the intricacies of the device. </td>
</tr>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<br>
<br>
<td> <h3>CD Links</h3> </td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <a href="..\readme\dinput.txt"><i>DirectInput Readme File</i></a></td>
<td>Introduction to what's new with DirectInput</td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<br>
<br>
<td> <h3>DirectInput Samples</h3> </td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<tr>
<td> <a href="../../sdk/bin/duel.exe"><i>Duel</i></a></td>
<td> <img src="playduel.gif"HEIGHT=64 WIDTH=176 ALT="Play Duel" BORDER=0 VSPACE=5>DirectInput Gaming Sample - Duel </A></td>
</tr>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<tr>
<td> <a href="../../sdk/bin/scrawl.exe"><i>Scrawl</i></a></td>
<td>DirectInput's Scrawl</td>
</tr>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<tr>
<td> <a href="../../sdk/bin/flip2d.exe"><i>FlipCube 2D</i></a></td>
<td>FlipCube 2D Sample</td>
</tr>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
</table>
</body>
</html>

27
docs/web/directx.htm Normal file
View File

@ -0,0 +1,27 @@
<html>
<head>
<title>DirectX</title>
</head>
<body bgcolor="#000000" text="#FFFFFF" link="#FFFF00" vlink="#FF0000">
<p align=center><font size=3><img src="hammer.jpg" align=bottom width=400 height=400></font></p>
<div align=center><center>
<table cellpadding=10 cellspacing=8 width=100 height=15 align="center">
<font size=3>
<tr>
<td><a href="d3dcd.htm">Direct3D</td>
<td><a href="ddrwcd.htm">DirectDraw</td>
<td><a href="dinpcd.htm">DirectInput</td>
<td><a href="dplycd.htm">DirectPlay</td>
<tr><td><a href="dsndcd.htm">DirectSound</td>
<td><a href="dbugcd.htm">Bug Reports</td>
<td><a href="hot.htm">Hot Links</td>
<td><a href="dxbook.htm">Documentation and Help</td></tr>
</font>
</table>
</center></div>
</body>
</html>

92
docs/web/dplaydoc.htm Normal file
View File

@ -0,0 +1,92 @@
<html>
<FONT FACE="arial" SIZE="2">
<head>
<title>DirectPlay Document</title>
<TR><TD COLSPAN=2 VALIGN=Bottom HEIGHT=25 WIDTH=640>
<P>
<H2>About DirectPlay</H2>
<P>The DirectX Team
<P>September 5, 1996
<P>
<P><i><h3>Introduction</h3></i>
<P>
The Microsoft&reg; DirectPlay&trade; application programming interface
(API) for Windows&reg; 95 is a software interface that simplifies
application access to communication services. DirectPlay has
become a technology family that provides a way for applications
to communicate with each other that is independent of the underlying
transport, protocol, or online service. Instead of forcing the
developer to deal with the differences that each of these connectivity
solutions represents, DirectPlay provides well defined, generalized
communication capabilities. DirectPlay shields the developer
from the underlying complexities of diverse connectivity implementations,
freeing them to concentrate on producing a great application.
<P>
<I><H3>DirectPlay Architecture</h3></I>
<P>
The DirectPlay architecture is composed of two types of components:
DirectPlay itself and the <I>Service Provider</I>. DirectPlay
is provided by Microsoft and presents a common interface to the
application. The service providers furnish medium-specific communications
services as requested by DirectPlay. Anyone, including online
services, can supply service providers for specialized hardware
and communications media. Microsoft supplies service providers
for direct modem-to-modem (TAPI) connections, COM port serial
connections, Internet TCP/IP, and IPX protocols with DirectPlay.
<P>
The DirectPlay interface hides the complexities and unique tasks
required to establish an arbitrary communications link inside
the DirectPlay service provider implementation. A application
using DirectPlay need only concern itself with the performance
of the communications medium (e.g. bandwidth and latency), not
whether that medium is being provided by a modem, network, or
online service.
<P>
DirectPlay supports a peer-to-peer communication model; that is,
every participant in the communications session can communicate
directly with anyone else and it is expected that each participant
is maintaining information on the complete state of the session.
There is one participant called the <I>session host</I> which
controls new participants joining the session and assigning player
and group ID numbers.
<P>
DirectPlay features:
<UL>
<LI><B>Network independence</B> - the only thing necessary to
run the application on another network is to write a service provider
for it. No need to change the application at all!
<LI><B>Service provider model</B> - this allows DirectPlay to
take advantage of network capabilities like multicasting to optimize
operations like sending messages to all participants.
<LI><B>Simple send/receive</B> model for exchanging messages between
players.
<LI><B>Player and group management functions</B> - automatic messages
generated when new players are created, destroyed, added/deleted
from groups, etc.; function to help manage application specific
data associated with the player/group.
<LI><B>Naming of players and groups</B>.
<LI><B>Remote shared data</B> - changes in remote data are propagated
to all the other machines automatically.
<LI><B>Unicode </B>and<B> ANSI </B>support.
<LI><B>Keep alive</B> - DirectPlay will monitor when players lose
their connection.
<LI><B>Lobby functions</B> - a matchmaking service can bring together
players and automatically start the application on all the participant's
machines and connect them to each other in a communications channel.
Once the game is in progress the lobby software and the application
can exchange information while the session is in progress.
</UL>
</head>
<body bgcolor=#000000 text=#FFFFFF link=#FFFF00 vlink=#FF0000>
<basefont face="Times New Roman" size=3>
</body>
</html>

74
docs/web/dplycd.htm Normal file
View File

@ -0,0 +1,74 @@
<html>
<head>
<title>DirectPlay</title>
</head>
<body bgcolor=#000000 text=#FFFFFF link=#FFFF00 vlink=#FF0000>
<basefont face="Times New Roman" size=3>
<font size=8 ><i><center><h1>DirectPlay</h1></center></i></font>
<table width=100% cellspacing="10">
<tr>
<td> <h3>Articles of Interest</h3> </td>
</tr>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<tr>
<td> <a href="dplaydoc.htm"><i>About DirectPlay</i></a></td>
<td> The Microsoft® DirectPlay™ application programming interface (API) for Windows® 95 is a software interface that simplifies application access to communication services. </td>
</tr>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <h3>CD Links</h3> </td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <a href="../readme/dplay.txt"><i>DirectPlay Readme File</i></a></td>
<td>What's New with DirectPlay? Highlights include, IDirectPlayLobby
Internet TCP/IP service provider, Unicode support, Host migration
Automatic player data propagation, Better performance, less overhead,
more stability and robustness and Support for 3rd-party network
service providers
</td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<br>
<tr>
<td> <h3>DirectPlay Samples</h3> </td>
</tr>
<tr>
<td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<tr>
<td> <a href="../../sdk/bin/duel.exe"><i>Duel</i></a></td>
<td> <img src="playduel.gif"HEIGHT=64 WIDTH=176 ALT="Play Duel" BORDER=0 VSPACE=5>DirectPlay Gaming Sample - Duel </A></td>
</tr>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<tr>
<td> <a href="../../iklowns/iklowns.exe"><i>IKlowns</i></a></td>
<td> <img src="play_ik.gif"HEIGHT=64 WIDTH=176 ALT="
" BORDER=0 VSPACE=5>DirectPlay Gaming Sample - IKlowns </A></td>
</tr>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
</table>
</body>
</html>

81
docs/web/dsndcd.htm Normal file
View File

@ -0,0 +1,81 @@
<html>
<head>
<title>DirectSound</title>
</head>
<body bgcolor=#000000 text=#FFFFFF link=#FFFF00 vlink=#FF0000>
<basefont face="Times New Roman" size=3>
<font size=8 ><i><center><h1>DirectSound</h1></center></i></font>
<table width=100% cellspacing="10">
<tr>
<td> <h3>Articles of Interest</h3> </td>
</tr>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<tr>
<td> <a href="http://www.microsoft.com/mediadev/audio/optaudi1.htm"><i>Optimizing Audio Performance with DirectX</i></a></td>
<td>The audio components of Microsoft® DirectX™--DirectSound™ and DirectSound3D™--include powerful tools for games and interactive-media programmers. DirectX takes advantage of sound-accelerator hardware whenever possible to improve performance and minimize CPU usage, but audio can still have a significant impact on system performance. This article describes techniques that will help you use DirectSound and DirectSound3D to minimize the performance impact of audio playback. </td>
</tr>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<br><br>
<td> <h3>CD Links</h3> </td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <a href="../readme/dsound.txt"><i>DirectSound Readme File</i></a></td>
<td>DirectSound3D is Now Available! Read about global sounds,
and new driver support!</td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<br><br>
<td> <h3>DirectSound Samples</h3> </td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<tr>
<td> <a href="../../sdk/bin/duel.exe"><i>Duel</i></a></td>
<td> <img src="playduel.gif"HEIGHT=64 WIDTH=176 ALT="Play Duel" BORDER=0 VSPACE=5>Duel, featuring DirectSound3D </A></td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <a href="../../sdk/bin/dsshow.exe"><i>DSShow</i></a></td>
<td>DirectSound Sample </td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <a href="../../sdk/bin/dsshow3d.exe"><i>DSShow3D</i></a></td>
<td>DirectSound3D Sample </td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <a href="../../sdk/bin/dsstream.exe"><i>DSStream</i></a></td>
<td>DirectSound Streaming Sample </td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <a href="../../sdk/bin/ds3dview.exe"><i>DirectSound3D Viewer</i></a></td>
<td>DirectSound3D Viewer Sample </td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <a href="../../sdk/bin/donuts.exe"><i>Donuts</i></a></td>
<td>Donuts Game Sample</td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
</table>
</body>
</html>

BIN
docs/web/dx3d.gif Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 32 KiB

115
docs/web/dxbook.htm Normal file
View File

@ -0,0 +1,115 @@
<html>
<head>
<title>DirectX Help</title>
</head>
<body bgcolor=#000000 text=#FFFFFF link=#FFFF00 vlink=#FF0000>
<basefont face="Times New Roman" size=3>
<center><i><h1><font size 8>DirectX Documentation</font></h1></i></center>
<table width=100% cellspacing="25">
<td> <h3>The DirectX documentation in these directories contain the same information
as the WinHelp documentation in the <A HREF="../winhelp/directx.hlp">Help</A> directory of this SDK</h3> </td>
<br>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <a href="../worddoc/dxintro.doc"><i>Chapter 1</i></a></td>
<td>Introducing DirectX 3: The Microsoft® DirectX™ Software Development Kit (SDK)
provides a finely tuned set of application programming interfaces (APIs) that give
you the resources you need to design high-performance, real-time applications. The
next generation of computer games and multimedia applications will be built using
DirectX technology. </td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <a href="../worddoc/ddraw.doc"><i>Chapter 2</i></a></td>
<td>About DirectDraw: DirectDraw™ is a DirectX™ 3 SDK component that allows direct
manipulation of display memory, hardware blitters, hardware overlays, and flipping.
DirectDraw provides this functionality while maintaining compatibility with existing
Microsoft® Windows® applications and device drivers. </td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <a href="../worddoc/dsound.doc"><i>Chapter 3</i></a></td>
<td>About DirectSound: The Microsoft® DirectSound™ application programming
interface (API) is the audio component of the DirectX™ 3 Software Development
Kit (SDK) that provides low-latency mixing, hardware acceleration, and direct
access to the sound device. DirectSound provides this functionality while
maintaining compatibility with existing Windows®-based applications and
device drivers. </td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <a href="../worddoc/dplay.doc"><i>Chapter 4</i></a></td>
<td>About DirectPlay: The Microsoft® DirectPlay™ application programming
interface (API) for Windows® is a software interface that simplifies your
application's access to communication services. DirectPlay has become a
technology family that not only provides a way for applications to communicate
with each other that is independent of the underlying transport, protocol, or
online service, but also provides this independence for matchmaking (lobby) servers. </td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <a href="../worddoc/d3dover.doc"><i>Chapter 5</i></a></td>
<td>About Direct3D: The Microsoft family of advanced 3D-graphics solutions includes the
Direct3D™ and OpenGL® application programming interfaces (APIs). </td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <a href="../worddoc/d3drmref.doc"><i>Chapter 5, Section 1</i></a></td>
<td>Retained-Mode Reference</td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <a href="../worddoc/d3dimref.doc"><i>Chapter 5, Section 2</i></a></td>
<td>Immediate-Mode Reference</td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <a href="../worddoc/dinput.doc"><i>Chapter 6</i></a></td>
<td>Introduction to Joysticks: The Microsoft® DirectInput™ application
programming interface (API) provides fast and consistent access to analog
and digital joysticks. The DirectInput API maintains consistency with the
joystick APIs of the Microsoft Win32® Software Development Kit (SDK), but has
improved responsiveness and reliability by changing the device driver model.
DirectInput device drivers use the registry to store settings for standard
joysticks, calibration information for previously configured joysticks, and
settings for OEM-supplied joysticks. </td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <a href="../worddoc/dinput3e.doc"><i>DirectInput Keyboard and Mouse</i></a></td>
<td>Introduction to using DirectInput keyboard and mouse support: One of the
most frequently received requests for enhancements to the DirectX SDK has
been to allow faster access to mouse and keyboard data than Windows currently
provides. DirectInput 3 provides fast low-latency access to mouse and
keyboard data. This late-breaking info is only available from this
doc file, it is not in the help files yet!</td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
<td> <a href="../worddoc/dsetup.doc"><i>Chapter 7</i></a></td>
<td>About DirectSetup: DirectSetup is a simple application programming
interface (API) that provides you with a one-call installation for the DirectX™ 3 \
components. This is more than a convenience; DirectX 3 is a complex product and its
installation is an involved task. You should not attempt a manual installation of
DirectX 3. </td>
<tr><td colspan="4"><img src="fireline.gif" height=5 width=100%></td></tr>
</table>
<br><br>
</body>
</html>

BIN
docs/web/dxbugs.doc Normal file

Binary file not shown.

BIN
docs/web/fireline.gif Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 5.1 KiB

BIN
docs/web/gamezone.gif Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 52 KiB

BIN
docs/web/ghome3.gif Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 15 KiB

BIN
docs/web/hammer.jpg Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 180 KiB

BIN
docs/web/hell.gif Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 14 KiB

58
docs/web/hot.htm Normal file
View File

@ -0,0 +1,58 @@
<html>
<head>
<title>Hot Links</title>
</head>
<body bgcolor=#000000 text=#FFFFFF link=#FFFF00 vlink=#FF0000>
<basefont face="Times New Roman" size=3>
<center><i><h1><font size 8>DirectX Hot Links</font></h1></i></center>
<br><br>
<h2>DirectX Developer Information</h2>
<img src="fireline.gif" height=5 width=100%>
<br><br>
<p align=left>
<table border=0>
<tr>
<td><a href="http://www.microsoft.com/mediadev" target="_top"><img src="ghome3.gif" align bottom border=0 height="101" width="285"></a></td>
<tr><td><a href="http://www.microsoft.com/mediadev" target="_top"><font size=3>Check out the latest DirectX Development Information</font></a></tr>
<br><br>
<h2>Cool Microsoft DirectX Games</h2>
<img src="fireline.gif" height=5 width=100%>
<p align=center>
<table border=0>
<tr><td><a href="http://www.zone.com" target="_top"><img src="Gamezone.gif" align=bottom border=0 width=368 height=112></a></td></tr>
<tr><td><a href="http://www.zone.com" target="_top"><font size=4>See games launching automagically out of a web page</font></a></td></tr>
</table>
</p>
<br><br>
<p align=left>
<table border=0>
<tr>
<td><a href="http://www.microsoft.com/games/monster/" target="_top"><font size=3>Microsoft Monster Truck Madness</font></a></td>
<td><a href="http://www.microsoft.com/games/monster/" target="_top"><img src="Monster.gif" align=bottom border=0 width=200 height=183></a></td>
</tr>
</table>
</p>
<br>
<p align=right>
<table border=0>
<tr>
<td><a href="http://www.microsoft.com/games/hellbender/default.htm" target="_top"><img src="Hell.gif" align=bottom border=0 width=348 height=108></a></td>
<td><a href="http://www.microsoft.com/games/hellbender/default.htm" target="_top"><font size=3>Microsoft Hellbender</font></a>
</tr>
</table>
</p>
<br><br><br><br>
</body>
</html>

BIN
docs/web/monster.gif Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 24 KiB

BIN
docs/web/play_ik.gif Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 4.5 KiB

BIN
docs/web/playduel.gif Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 3.3 KiB

BIN
docs/web/screen2.jpg Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 5.0 KiB

BIN
docs/web/screen3.jpg Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 6.7 KiB

BIN
docs/web/screen4.jpg Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 4.4 KiB

BIN
docs/web/word.bmp Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 2.4 KiB

View File

@ -0,0 +1,23 @@
:Base autoplay.hlp
:Title AutoPlay
:Index AutoPlay=AUTOPLAY.HLP
1 AutoPlay
2 About AutoPlay
2 Introduction =autoplay_2_
2 How AutoPlay Works =autoplay_3_
2 The Autorun.inf File =autoplay_4_
3 Tips for Writing AutoPlay Applications
3 Introduction =autoplay_6_
3 Opening a Startup Application =autoplay_7_
3 Loading in the Background =autoplay_8_
3 Conserving Hard Disk Space =autoplay_9_
3 Using the Registry =autoplay_10_
3 Setting the NoDriveTypeAutoRun Value =autoplay_11_
2 Suppressing AutoPlay =autoplay_12_
2 AutoPlay for MS-DOSBased Applications =autoplay_13_
2 AutoPlay Command Reference
2 defaulticon =autoplay_15_
2 icon =autoplay_16_
2 open =autoplay_17_
2 shell =autoplay_18_
2 shell\verb=autoplay_19_

Binary file not shown.

View File

@ -0,0 +1,135 @@
:Base ddraw.hlp
:Title DirectDraw
:Index DirectPlay=DDRAW.HLP
1 DirectDraw
2 Help Contents Topic =HelpContents1
2 About DirectDraw =AboutDirectDraw.2
2 DirectDraw Overview =DirectDrawOverview.3
2 Architectural Overview =ArchitecturalOverview.4
3 DirectDraw - Architectural Overview - DirectDraw =DirectDraw.5
3 DirectDraw HAL =DirectDrawHAL.6
3 DirectDraw Software Emulation =DirectDrawSoftwareEmulation.7
3 DirectDraw, DirectDrawSurface, DirectDrawPalette, and DirectDrawClipper =DirectDraw.DirectDrawSurface.DirectDrawPalette.andDirectDrawClipper.8
2 Using DirectDraw =UsingDirectDraw.9
3 Frame buffer access =Framebufferaccess.10
3 Primary Surface resource sharing model =PrimarySurfaceresourcesharingmodel.11
3 Changing modes and exclusive access =Changingmodesandexclusiveaccess.12
3 Losing surfaces =Losingsurfaces.13
3 Cliplists =Cliplists.14
3 Color and Format Conversion =ColorandFormatConversion.15
3 Specifying Color Keys =SpecifyingColorKeys.16
3 Colorkeying =Colorkeying.17
3 Flipping Surfaces and GDI's 'frame rate' =FlippingSurfacesandGDI.s.framerate..18
3 Overlay Z Order =OverlayZOrder.19
3 Palettes and Pixel Formats =PalettesandPixelFormats.20
2 DirectDraw Structures
3 Data Structure Summary =DataStructureSummary.21
3 DDBLTBATCH =DDBLTBATCH.22
3 DDBLTFX =DDBLTFX.23
3 DDCAPS =DDCAPS.24
3 DDCOLORKEY =DDCOLORKEY.25
3 DDMODEDESC =DDMODEDESC.26
3 DDOVERLAYFX =DDOVERLAYFX.27
3 DDPIXELFORMAT =DDPIXELFORMAT.28
3 DDRVAL =DDRVAL.29
3 DDSCAPS =DDSCAPS.30
3 DDSURFACEDESC =DDSURFACEDESC.31
2 DirectDraw Return Values
3 DD OK =DDOK.32
3 DirectDraw Enumeration Callback Return Codes =DirectDrawEnumerationCallbackReturnCodes.33
3 DirectDraw Error Return Codes =DirectDrawErrorReturnCodes.34
2 DirectDraw APIs
3 APIs =APIs.35
3 DirectDrawCreate =DirectDrawCreate.36
3 DirectDrawEnumerate =DirectDrawEnumerate.37
2 DirectDraw Member Reference
3 DirectDraw Member Reference - Overview =Overview.38
3 DirectDraw Member Implementation =DirectDrawMemberImplementation.39
3 DirectDraw Members =DirectDrawMembers.40
4 DirectDraw Member Reference - DirectDraw Members - AddRef =AddRef.41
4 Compact =Compact.42
4 CreateClipper =CreateClipper.43
4 CreatePalette =CreatePalette.44
4 CreateSurface =CreateSurface.45
4 DuplicateSurface =DuplicateSurface.46
4 EnumDisplayModes =EnumDisplayModes.47
4 EnumSurfaces =EnumSurfaces.48
4 FlipToGDISurface =FlipToGDISurface.49
4 DirectDraw Member Reference - DirectDraw Members - GetCaps =GetCaps.50
4 GetDisplayMode =GetDisplayMode.51
4 GetFourCCCodes =GetFourCCCodes.52
4 GetGDISurface =GetGDISurface.53
4 GetMonitorFrequency =GetMonitorFrequency.54
4 GetScanLine =GetScanLine.55
4 GetVerticalBlankStatus =GetVerticalBlankStatus.56
4 DirectDraw Member Reference - DirectDraw Members - Initialize =Initialize.57
4 DirectDraw Member Reference - DirectDraw Members - QueryInterface =QueryInterface.58
4 DirectDraw Member Reference - DirectDraw Members - Release =Release.59
4 RestoreDisplayMode =RestoreDisplayMode.60
4 SetCooperativeLevel =SetCooperativeLevel.61
4 SetDisplayMode =SetDisplayMode.62
4 WaitForVerticalBlank =WaitForVerticalBlank.63
2 DirectDrawSurface Member Reference
3 DirectDrawSurface Member Reference - Overview =Overview.64
3 DIRECTDRAWSURFACE Member Implementation =DIRECTDRAWSURFACEMemberImplementation.65
3 DirectDrawSurface Member Reference - Members =Members.66
4 AddAttachedSurface =AddAttachedSurface.67
4 AddOverlayDirtyRect =AddOverlayDirtyRect.68
4 DirectDrawSurface Member Reference - Members - AddRef =AddRef.69
4 Blt =Blt.70
4 BltBatch =BltBatch.71
4 BltFast =BltFast.72
4 DeleteAttachedSurfaces =DeleteAttachedSurfaces.73
4 EnumAttachedSurfaces =EnumAttachedSurfaces.74
4 EnumOverlayZOrders =EnumOverlayZOrders.75
4 Flip =Flip.76
4 GetAttachedSurface =GetAttachedSurface.77
4 GetBltStatus =GetBltStatus.78
4 DirectDrawSurface Member Reference - Members - GetCaps =GetCaps.79
4 GetClipper =GetClipper.80
4 GetColorKey =GetColorKey.81
4 GetDC =GetDC.82
4 GetFlipStatus =GetFlipStatus.83
4 GetOverlayPosition =GetOverlayPosition.84
4 GetPalette =GetPalette.85
4 GetPixelFormat =GetPixelFormat.86
4 GetSurfaceDesc =GetSurfaceDesc.87
4 DirectDrawSurface Member Reference - Members - Initialize =Initialize.88
4 IsLost =IsLost.89
4 Lock =Lock.90
4 DirectDrawSurface Member Reference - Members - QueryInterface =QueryInterface.91
4 DirectDrawSurface Member Reference - Members - Release =Release.92
4 ReleaseDC =ReleaseDC.93
4 Restore =Restore.94
4 SetClipper =SetClipper.95
4 SetColorKey =SetColorKey.96
4 SetOverlayPosition =SetOverlayPosition.97
4 SetPalette =SetPalette.98
4 Unlock =Unlock.99
4 UpdateOverlay =UpdateOverlay.100
4 UpdateOverlayDisplay =UpdateOverlayDisplay.101
4 UpdateOverlayZOrder =UpdateOverlayZOrder.102
2 DirectDrawPalette Member Reference
3 DirectDrawPalette Member Reference - Overview =Overview.103
3 DIRECTDRAWPALETTE Member Implementation =DIRECTDRAWPALETTEMemberImplementation.104
3 DirectDrawPalette Member Reference - Members =Members.105
4 DirectDrawPalette Member Reference - Members - AddRef =AddRef.106
4 DirectDrawPalette Member Reference - Members - GetCaps =GetCaps.107
4 GetEntries =GetEntries.108
4 DirectDrawPalette Member Reference - Members - Initialize =Initialize.109
4 DirectDrawPalette Member Reference - Members - QueryInterface =QueryInterface.110
4 DirectDrawPalette Member Reference - Members - Release =Release.111
4 SetEntries =SetEntries.112
2 DirectDrawClipper Member Reference
3 DirectDrawClipper Member Reference - Overview =Overview.113
3 DIRECTDRAWCLIPPER Member Implementation =DIRECTDRAWCLIPPERMemberImplementation.114
3 DirectDrawClipper Member Reference - Members =Members.115
4 DirectDrawClipper Member Reference - Members - AddRef =AddRef.116
4 GetClipList =GetClipList.117
4 GetHWnd =GetHWnd.118
4 DirectDrawClipper Member Reference - Members - Initialize =Initialize.119
4 IsClipListChanged =IsClipListChanged.120
4 DirectDrawClipper Member Reference - Members - QueryInterface =QueryInterface.121
4 DirectDrawClipper Member Reference - Members - Release =Release.122
4 SetClipList =SetClipList.123
4 SetHWnd =SetHWnd.124

Binary file not shown.

View File

@ -0,0 +1,21 @@
:Base dinput.hlp
:Title DirectInput
:Index DirectInput=DINPUT.HLP
1 DirectInput
2 About DirectInput
2 Introduction to Joysticks =dinput_2_
2 Joystick Capabilities =dinput_3_
2 Joystick Calibration and Testing =dinput_4_
2 Joystick Position =dinput_5_
2 DirectInput Reference
2 Joystick Groups =dinput_7_
3 Functions
3 Introduction =dinput_9_
3 joyConfigChanged =dinput_10_
3 joyGetDevCaps =dinput_11_
3 joyGetNumDevs =dinput_12_
3 joyGetPosEx =dinput_13_
3 Structures
3 Introduction =dinput_15_
3 JOYCAPS =dinput_16_
3 JOYINFOEX =dinput_17_

Binary file not shown.

View File

@ -0,0 +1,63 @@
:Base dplay.hlp
:Title DirectPlay
:Index DirectPlay=DPLAY.HLP
1 DirectPlay
2 Help Contents Topic =HelpContents1
2 DirectPlay
3 About DirectPlay =AboutDirectPlay.2
3 DirectPlay Architecture =DirectPlayArchitecture.3
3 Globally Unique Identifiers =GloballyUniqueIdentifiers.4
3 Using DirectPlay =UsingDirectPlay.5
3 Session Management =SessionManagement.6
3 Player Management =PlayerManagement.7
3 Group Management =GroupManagement.8
3 Message Management =MessageManagement.9
2 DirectPlay Stuctures
3 Structure Summary =StructureSummary.10
3 Data Structures
4 DPCAPS =DPCAPS.12
4 DPSESSIONDESC =DPSESSIONDESC.13
3 System Messages
4 System Messages =SystemMessageStructures.14
4 DPMSG_ADDPLAYER =DPMSG.ADDPLAYER.15
4 DPMSG_DELETEPLAYER =DPMSG.DELETEPLAYER.16
4 DPMSG_GENERIC =DPMSG.GENERIC.17
4 DPMSG_GROUPADD =DPMSG.GROUPADD.18
4 DPMSG_GROUPDELETE =DPMSG.GROUPDELETE.19
2 DirectPlay Return Values
3 DP_OK =DP.OK.20
3 DirectPlay Error Return Codes =DirectPlayErrorReturnCodes.21
2 DirectPlay APIs
3 APIs =APIs.22
3 DirectPlayCreate =DirectPlayCreate.23
4 DirectPlayEnumerate =DirectPlayEnumerate.24
2 DirectPlay Members
3 Member Summary =MemberSummary.25
3 DirectPlay Members
4 DirectPlay Members = DirectPlayMembers.26
4 AddPlayerToGroup =AddPlayerToGroup.27
4 AddRef =AddRef.28
4 Close =Close.29
4 CreateGroup =CreateGroup.30
4 CreatePlayer =CreatePlayer.31
4 DeletePlayerFromGroup =DeletePlayerFromGroup.32
4 DestroyGroup =DestroyGroup.33
4 DestroyPlayer =DestroyPlayer.34
4 EnableNewPlayers =EnableNewPlayers.35
4 EnumGroups =EnumGroups.36
4 EnumGroupPlayers =EnumGroupPlayers.37
4 EnumPlayers =EnumPlayers.38
4 EnumSessions =EnumSessions.39
4 GetCaps =GetCaps.40
4 GetMessageCount =GetMessageCount.41
4 GetPlayerCaps =GetPlayerCaps.42
4 GetPlayerName =GetPlayerName.43
4 Initialize =Initialize.44
4 Open =Open.45
4 QueryInterface =QueryInterface.46
4 Receive =Receive.47
4 Release =Release.48
4 SaveSession =SaveSession.49
4 Send =Send.50
4 SetPlayerName =SetPlayerName.51

Binary file not shown.

View File

@ -0,0 +1,87 @@
:Base dsound.hlp
:Title DirectSound
:Index DirectSound=DSOUND.HLP
1 DirectSound
2 About DirectSound
2 Introduction =dsound_2_
3 Object Types
3 Introduction =dsound_4_
3 The DirectSound Object =dsound_5_
3 The DirectSoundBuffer Object =dsound_6_
2 Software Emulation =dsound_7_
2 Device Drivers =dsound_8_
2 System Integration =dsound_9_
3 DirectSound Features
3 Mixing =dsound_11_
3 Hardware Acceleration =dsound_12_
3 Access to the Primary Buffer =dsound_13_
2 IDirectSound Interface
2 Introduction =dsound_15_
2 Device Capabilities =dsound_16_
2 Creating Buffers =dsound_17_
2 Speaker Configuration =dsound_18_
2 Hardware Memory Management =dsound_19_
2 IDirectSoundBuffer Interface
2 IDirectSoundBuffer Introduction =dsound_21_
2 Play Management =dsound_22_
2 Sound-Environment Management =dsound_23_
2 Information =dsound_24_
2 Memory Management =dsound_25_
2 IUnknown Interface =dsound_26_
2 Using DirectSound
2 Introduction =dsound_28_
2 Implementation: A Broad Overview =dsound_29_
2 Creating a DirectSound Object =dsound_30_
2 Querying the Hardware Capabilities =dsound_31_
3 Creating Sound Buffers
3 Introduction =dsound_33_
3 Creating a Basic Sound Buffer =dsound_34_
3 Control Options =dsound_35_
3 Static and Streaming Sound Buffers =dsound_36_
3 Hardware and Software Sound Buffers =dsound_37_
3 Primary and Secondary Sound Buffers =dsound_38_
2 Writing to Sound Buffers =dsound_39_
2 Using the DirectSound Mixer =dsound_40_
2 Using a Custom Mixer =dsound_41_
2 Using Compressed Wave Formats =dsound_42_
2 DirectSound Reference
3 Functions
3 DirectSoundCreate =dsound_45_
3 DirectSoundEnumCallback =dsound_46_
3 DirectSoundEnumerate =dsound_47_
3 IDirectSound Interface and Member Functions
3 IDirectSound =dsound_49_
3 IDirectSound::Compact =dsound_50_
3 IDirectSound::CreateSoundBuffer =dsound_51_
3 IDirectSound::DuplicateSoundBuffer =dsound_52_
3 IDirectSound::GetCaps =dsound_53_
3 IDirectSound::GetSpeakerConfig =dsound_54_
3 IDirectSound::Initialize =dsound_55_
3 IDirectSound::SetCooperativeLevel =dsound_56_
3 IDirectSound::SetSpeakerConfig =dsound_57_
3 IDirectSoundBuffer Interface and Member Functions
3 IDirectSoundBuffer =dsound_59_
3 IDirectSoundBuffer::GetCaps =dsound_60_
3 IDirectSoundBuffer::GetCurrentPosition =dsound_61_
3 IDirectSoundBuffer::GetFormat =dsound_62_
3 IDirectSoundBuffer::GetFrequency =dsound_63_
3 IDirectSoundBuffer::GetPan =dsound_64_
3 IDirectSoundBuffer::GetStatus =dsound_65_
3 IDirectSoundBuffer::GetVolume =dsound_66_
3 IDirectSoundBuffer::Initialize =dsound_67_
3 IDirectSoundBuffer::Lock =dsound_68_
3 IDirectSoundBuffer::Play =dsound_69_
3 IDirectSoundBuffer::Restore =dsound_70_
3 IDirectSoundBuffer::SetCurrentPosition =dsound_71_
3 IDirectSoundBuffer::SetFormat =dsound_72_
3 IDirectSoundBuffer::SetFrequency =dsound_73_
3 IDirectSoundBuffer::SetPan =dsound_74_
3 IDirectSoundBuffer::SetVolume =dsound_75_
3 IDirectSoundBuffer::Stop =dsound_76_
3 IDirectSoundBuffer::Unlock =dsound_77_
3 Structures
3 DSBCAPS =dsound_79_
3 DSBUFFERDESC =dsound_80_
3 DSCAPS =dsound_81_
3 Constants
3 Error Values =dsound_83_

Binary file not shown.

View File

@ -0,0 +1,29 @@
:Base gamesdk.hlp
:Title Windows 95 Game SDK
:Index Introducing the Windows 95 Game SDK =GAMESDK.HLP
:include legal.cnt
1 Introducing the Game Software Development Kit
2 Programming Games in Windows
2 Introduction =gamesdk_2_
2 Reasons for Developing Windows-Based Games =gamesdk_3_
2 Providing Standards for Hardware Accelerators =gamesdk_4_
2 Windows 95 Game Features
2 Introduction =gamesdk_6_
2 DirectDraw =gamesdk_7_
2 DirectSound =gamesdk_8_
2 DirectPlay =gamesdk_9_
2 DirectInput =gamesdk_10_
2 AutoPlay =gamesdk_11_
2 Sample Applications =gamesdk_12_
2 Games and the Component Object Model
2 Introduction =gamesdk_14_
2 The Component Object Model =gamesdk_15_
2 Accessing COM Objects Using C =gamesdk_16_
2 Game SDK COM Interfaces =gamesdk_17_
1 Conventions =gamesdk_18_
:include ddraw.cnt
:include dsound.cnt
:include dplay.cnt
:include dinput.cnt
:include install.cnt
:include autoplay.cnt

Binary file not shown.

View File

@ -0,0 +1,10 @@
:Base install.hlp
:Title DirectSetup
:Index DirectSetup=INSTALL.HLP
1 DirectSetup
2 Contents Topic =HelpContents1
2 About DirectSetup = AboutDirectSetup.2
2 Using DirectSetup = UsingDirectSetup.3
2 DirectSetup API
3 API =API.4
4 DirectXSetup = DirectXSetup.5

Binary file not shown.

View File

@ -0,0 +1,4 @@
:Base legal.hlp
:Title Copyright Notice
:Index Introducing the Windows 95 Game SDK =LEGAL.HLP
1 Copyright Notice=legal_0_

Binary file not shown.

File diff suppressed because it is too large Load Diff

Binary file not shown.

View File

@ -0,0 +1,9 @@
This directory contains an archive of the documentation for both the
Microsoft Game SDK and Microsoft DirectX 2 SDK. The Game SDK information
is located in the \DIRECTX1 directory. The DirectX 2 SDK information
is located in the \DIRECTX2 directory.
The information found in these directories is not directly related
to the documentation for the DirectX 3 SDK. However, it is included here
in case you need information about previous versions of a COM interface.

BIN
docs/winhelp/directx.GID Normal file

Binary file not shown.

1332
docs/winhelp/directx.cnt Normal file

File diff suppressed because it is too large Load Diff

BIN
docs/winhelp/directx.hlp Normal file

Binary file not shown.

BIN
docs/worddoc/autoplay.doc Normal file

Binary file not shown.

BIN
docs/worddoc/d3dimref.doc Normal file

Binary file not shown.

BIN
docs/worddoc/d3dover.doc Normal file

Binary file not shown.

BIN
docs/worddoc/d3drmref.doc Normal file

Binary file not shown.

BIN
docs/worddoc/ddraw.doc Normal file

Binary file not shown.

BIN
docs/worddoc/dinput.doc Normal file

Binary file not shown.

BIN
docs/worddoc/dinput3e.doc Normal file

Binary file not shown.

BIN
docs/worddoc/dplay.doc Normal file

Binary file not shown.

BIN
docs/worddoc/dsetup.doc Normal file

Binary file not shown.

BIN
docs/worddoc/dsound.doc Normal file

Binary file not shown.

BIN
docs/worddoc/dxintro.doc Normal file

Binary file not shown.

BIN
docs/worddoc/glossary.doc Normal file

Binary file not shown.

15
docs/worddoc/readme.txt Normal file
View File

@ -0,0 +1,15 @@
The DirectX documentation in this directory contains the same information
as the WinHelp documentation in the WinHelp directory of this SDK. The
WinHelp format of the documentation is generally easier to use than the Word
format because of its many hypertext links and other navigational aids.
Before printing any of the Word documentation, you should rebuild the table
of contents for that file so that the page numbers are accurate for your
printer. To do this, select the table of contents in Word, right-click the
selection, and then click Update Field. In the Update Table Of Contents
dialog box, click the Update Entire Table option, and then click OK.
The Word format of the Direct3D documentation is provided in several
files so that the file sizes are more manageable. (The Direct3D
documentation appears as one section in the WinHelp format.)

12
dx3dsdk.inf Normal file
View File

@ -0,0 +1,12 @@
[version]
signature="$CHICAGO$"
[DefaultInstall]
AddReg=add.reg
[add.reg]
HKLM,"%DP%","D3D Path",,"C:\CODE\DXSDK3\sdk\media"
[Strings]
DP = "Software\Microsoft\Direct3D"

BIN
foxbear/foxbear.art Normal file

Binary file not shown.

BIN
foxbear/foxbear.exe Executable file

Binary file not shown.

BIN
iklowns/data/backdrop.bmp Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 301 KiB

BIN
iklowns/data/bang.wav Normal file

Binary file not shown.

BIN
iklowns/data/bigtbig.bmp Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 101 KiB

BIN
iklowns/data/bigtbig.tle Normal file

Binary file not shown.

BIN
iklowns/data/bigtop.bmp Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 61 KiB

BIN
iklowns/data/bigtop.tle Normal file

Binary file not shown.

BIN
iklowns/data/bigtsml.bmp Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 21 KiB

BIN
iklowns/data/bigtsml.tle Normal file

Binary file not shown.

BIN
iklowns/data/bkgrnd.bmp Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 297 KiB

BIN
iklowns/data/blow1.wav Normal file

Binary file not shown.

BIN
iklowns/data/blow2.wav Normal file

Binary file not shown.

BIN
iklowns/data/c1block.bmp Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 47 KiB

77
iklowns/data/c1block.spr Normal file
View File

@ -0,0 +1,77 @@
[BlockLeft]
C1blol01.dib=1
C1blol03.dib=1
C1blol05.dib=1
C1blol07.dib=1
C1blol09.dib=1
[C1blol01.dib]
X=0
Y=0
Width=57
Height=133
[C1blol03.dib]
X=57
Y=0
Width=57
Height=133
[C1blol05.dib]
X=57
Y=0
Width=57
Height=133
[C1blol07.dib]
X=171
Y=0
Width=57
Height=133
[C1blol09.dib]
X=114
Y=0
Width=57
Height=133
[Sequences]
BlockLeft=3
BlockRight=3
[BlockRight]
C1blor01.dib=1
C1blor03.dib=1
C1blor05.dib=1
C1blor07.dib=1
C1blor09.dib=1
[C1blor01.dib]
X=0
Y=133
Width=58
Height=133
[C1blor03.dib]
X=58
Y=133
Width=58
Height=133
[C1blor05.dib]
X=58
Y=133
Width=58
Height=133
[C1blor07.dib]
X=174
Y=133
Width=58
Height=133
[C1blor09.dib]
X=116
Y=133
Width=58
Height=133

BIN
iklowns/data/c1duck.bmp Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 92 KiB

78
iklowns/data/c1duck.spr Normal file
View File

@ -0,0 +1,78 @@
[DuckLeft]
C1ducl01.dib=1
C1ducl05.dib=1
C1ducl09.dib=1
C1ducl13.dib=1
C1ducl17.dib=1
[C1ducl01.dib]
X=0
Y=0
Width=58
Height=132
[C1ducl05.dib]
X=58
Y=0
Width=66
Height=132
[C1ducl09.dib]
X=124
Y=0
Width=74
Height=134
[C1ducl13.dib]
X=198
Y=0
Width=70
Height=134
[C1ducl17.dib]
X=268
Y=0
Width=63
Height=133
[Sequences]
DuckLeft=5
DuckRight=5
[DuckRight]
C1ducr01.dib=1
C1ducr05.dib=1
C1ducr09.dib=1
C1ducr13.dib=1
C1ducr17.dib=1
[C1ducr01.dib]
X=0
Y=134
Width=72
Height=132
[C1ducr05.dib]
X=72
Y=134
Width=68
Height=131
[C1ducr09.dib]
X=140
Y=134
Width=65
Height=131
[C1ducr13.dib]
X=205
Y=134
Width=68
Height=131
[C1ducr17.dib]
X=273
Y=134
Width=72
Height=132

BIN
iklowns/data/c1piefac.bmp Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 74 KiB

63
iklowns/data/c1piefac.spr Normal file
View File

@ -0,0 +1,63 @@
[PieFaceLeft]
C1pfal01.dib=1
C1pfal03.dib=1
C1pfal05.dib=1
Piefacel.bmp=1
[C1pfal01.dib]
X=0
Y=0
Width=70
Height=133
[C1pfal03.dib]
X=70
Y=0
Width=70
Height=133
[C1pfal05.dib]
X=140
Y=0
Width=70
Height=133
[Piefacel.bmp]
X=210
Y=0
Width=70
Height=133
[Sequences]
PieFaceLeft=4
PieFaceRight=4
[PieFaceRight]
C1pfar01.dib=1
C1pfar03.dib=1
C1pfar05.dib=1
Piefacer.bmp=1
[C1pfar01.dib]
X=0
Y=133
Width=70
Height=133
[C1pfar03.dib]
X=70
Y=133
Width=58
Height=133
[C1pfar05.dib]
X=128
Y=133
Width=58
Height=133
[Piefacer.bmp]
X=186
Y=133
Width=58
Height=133

BIN
iklowns/data/c1piehed.bmp Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 106 KiB

63
iklowns/data/c1piehed.spr Normal file
View File

@ -0,0 +1,63 @@
[PieHeadLeft]
C1phel01.dib=1
C1phel03.dib=1
C1phel05.dib=1
Pieheadl.bmp=1
[C1phel01.dib]
X=0
Y=0
Width=100
Height=133
[C1phel03.dib]
X=100
Y=0
Width=76
Height=133
[C1phel05.dib]
X=176
Y=0
Width=57
Height=133
[Pieheadl.bmp]
X=233
Y=0
Width=57
Height=133
[Sequences]
PieHeadLeft=4
PieHeadRight=4
[PieHeadRight]
C1pher01.dib=1
C1pher03.dib=1
C1pher05.dib=1
Pieheadr.bmp=1
[C1pher01.dib]
X=0
Y=133
Width=101
Height=133
[C1pher03.dib]
X=101
Y=133
Width=101
Height=133
[C1pher05.dib]
X=202
Y=133
Width=101
Height=133
[Pieheadr.bmp]
X=303
Y=133
Width=101
Height=133

BIN
iklowns/data/c1poke.bmp Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 49 KiB

77
iklowns/data/c1poke.spr Normal file
View File

@ -0,0 +1,77 @@
[PokeLeft]
C1eyel01.dib=1
C1eyel03.dib=1
C1eyel05.dib=1
C1eyel07.dib=1
C1eyel09.dib=1
[C1eyel01.dib]
X=0
Y=0
Width=61
Height=133
[C1eyel03.dib]
X=61
Y=0
Width=61
Height=133
[C1eyel05.dib]
X=61
Y=0
Width=61
Height=133
[C1eyel07.dib]
X=183
Y=0
Width=61
Height=133
[C1eyel09.dib]
X=122
Y=0
Width=61
Height=133
[Sequences]
PokeLeft=3
PokeRight=3
[PokeRight]
C1eyer01.dib=1
C1eyer03.dib=1
C1eyer05.dib=1
C1eyer07.dib=1
C1eyer09.dib=1
[C1eyer01.dib]
X=0
Y=133
Width=58
Height=133
[C1eyer03.dib]
X=58
Y=133
Width=58
Height=133
[C1eyer05.dib]
X=58
Y=133
Width=59
Height=133
[C1eyer07.dib]
X=175
Y=133
Width=58
Height=133
[C1eyer09.dib]
X=117
Y=133
Width=58
Height=133

BIN
iklowns/data/c1run.bmp Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 217 KiB

119
iklowns/data/c1run.spr Normal file
View File

@ -0,0 +1,119 @@
[RunLeft]
C1-rul01.dib=1
C1-rul03.dib=1
C1-rul05.dib=1
C1-rul07.dib=1
C1-rul09.dib=1
C1-rul11.dib=1
C1-rul13.dib=1
C1-rul15.dib=1
[C1-rul01.dib]
X=0
Y=0
Width=110
Height=125
[C1-rul03.dib]
X=110
Y=0
Width=94
Height=137
[C1-rul05.dib]
X=204
Y=0
Width=91
Height=134
[C1-rul07.dib]
X=295
Y=0
Width=107
Height=131
[C1-rul09.dib]
X=402
Y=0
Width=110
Height=123
[C1-rul11.dib]
X=512
Y=0
Width=95
Height=131
[C1-rul13.dib]
X=607
Y=0
Width=91
Height=137
[C1-rul15.dib]
X=698
Y=0
Width=106
Height=130
[Sequences]
RunLeft=8
RunRight=8
[RunRight]
C1-rur01.dib=1
C1-rur03.dib=1
C1-rur05.dib=1
C1-rur07.dib=1
C1-rur09.dib=1
C1-rur11.dib=1
C1-rur13.dib=1
C1-rur15.dib=1
[C1-rur01.dib]
X=0
Y=137
Width=105
Height=123
[C1-rur03.dib]
X=105
Y=137
Width=87
Height=136
[C1-rur05.dib]
X=192
Y=137
Width=90
Height=133
[C1-rur07.dib]
X=282
Y=137
Width=110
Height=130
[C1-rur09.dib]
X=392
Y=137
Width=106
Height=125
[C1-rur11.dib]
X=498
Y=137
Width=87
Height=132
[C1-rur13.dib]
X=585
Y=137
Width=95
Height=138
[C1-rur15.dib]
X=680
Y=137
Width=109
Height=131

BIN
iklowns/data/c1sad.bmp Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 384 KiB

151
iklowns/data/c1sad.spr Normal file
View File

@ -0,0 +1,151 @@
[C1SadDone]
C1sadl10.dib=1
[C1SadLeft]
C1sadl01.dib=1
C1sadl02.dib=1
C1sadl03.dib=1
C1sadl04.dib=1
C1sadl05.dib=1
C1sadl06.dib=1
C1sadl07.dib=1
C1sadl08.dib=1
C1sadl09.dib=1
C1sadl10.dib=1
[C1sadl01.dib]
X=0
Y=0
Width=140
Height=140
[C1sadl02.dib]
X=140
Y=0
Width=140
Height=140
[C1sadl03.dib]
X=280
Y=0
Width=140
Height=140
[C1sadl04.dib]
X=420
Y=0
Width=140
Height=140
[C1sadl05.dib]
X=560
Y=0
Width=140
Height=140
[C1sadl06.dib]
X=700
Y=0
Width=140
Height=140
[C1sadl07.dib]
X=840
Y=0
Width=140
Height=140
[C1sadl08.dib]
X=980
Y=0
Width=140
Height=140
[C1sadl09.dib]
X=1120
Y=0
Width=140
Height=140
[C1sadl10.dib]
X=1260
Y=0
Width=140
Height=140
[Sequences]
C1SadLeft=10
C1SadRight=10
C1SadDone=1
[C1SadRight]
C1sadr01.dib=1
C1sadr02.dib=1
C1sadr03.dib=1
C1sadr04.dib=1
C1sadr05.dib=1
C1sadr06.dib=1
C1sadr07.dib=1
C1sadr08.dib=1
C1sadr09.dib=1
C1sadr10.dib=1
[C1sadr01.dib]
X=0
Y=140
Width=140
Height=140
[C1sadr02.dib]
X=140
Y=140
Width=140
Height=140
[C1sadr03.dib]
X=280
Y=140
Width=140
Height=140
[C1sadr04.dib]
X=420
Y=140
Width=140
Height=140
[C1sadr05.dib]
X=560
Y=140
Width=140
Height=140
[C1sadr06.dib]
X=700
Y=140
Width=140
Height=140
[C1sadr07.dib]
X=840
Y=140
Width=140
Height=140
[C1sadr08.dib]
X=980
Y=140
Width=140
Height=140
[C1sadr09.dib]
X=1120
Y=140
Width=140
Height=140
[C1sadr10.dib]
X=1260
Y=140
Width=140
Height=140

BIN
iklowns/data/c1stand.bmp Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 28 KiB

21
iklowns/data/c1stand.spr Normal file
View File

@ -0,0 +1,21 @@
[StandLeft]
C1thrl01.dib=1
[C1thrl01.dib]
X=0
Y=0
Width=57
Height=133
[Sequences]
StandLeft=1
StandRight=1
[StandRight]
C1thrr01.dib=1
[C1thrr01.dib]
X=0
Y=133
Width=79
Height=133

BIN
iklowns/data/c1throw.bmp Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 82 KiB

63
iklowns/data/c1throw.spr Normal file
View File

@ -0,0 +1,63 @@
[ThrowLeft]
c1thrl01.dib=1
c1thrl05.dib=1
c1thrl09.dib=1
c1thrl13.dib=1
[c1thrl01.dib]
X=0
Y=0
Width=57
Height=133
[c1thrl05.dib]
X=57
Y=0
Width=57
Height=133
[c1thrl09.dib]
X=114
Y=0
Width=57
Height=133
[c1thrl13.dib]
X=171
Y=0
Width=57
Height=133
[Sequences]
ThrowLeft=4
ThrowRight=4
[ThrowRight]
c1thrr01.dib=1
c1thrr05.dib=1
c1thrr09.dib=1
c1thrr13.dib=1
[c1thrr01.dib]
X=0
Y=133
Width=80
Height=133
[c1thrr05.dib]
X=80
Y=133
Width=79
Height=133
[c1thrr09.dib]
X=159
Y=133
Width=79
Height=133
[c1thrr13.dib]
X=238
Y=133
Width=73
Height=133

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