ShuriZma
/
Cxbx-Reloaded
mirror of https://github.com/Cxbx-Reloaded/Cxbx-Reloaded.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Expanded tabs and trimmed EOL whitespace.

This commit is contained in:
Daniel Stien 2008-08-23 01:29:07 +00:00
parent df389d51f4
commit 199136e926
160 changed files with 2929 additions and 2929 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
import/OpenXDK/include/xboxkrnl/dbg.h
View File

@ -1,5 +1,5 @@
// ******************************************************************
// *
// *
// * proj : OpenXDK
// *
// * desc : Open Source XBox Development Kit

18
import/OpenXDK/include/xboxkrnl/ex.h
View File

@ -1,5 +1,5 @@
// ******************************************************************
// *
// *
// * proj : OpenXDK
// *
// * desc : Open Source XBox Development Kit
@ -24,7 +24,7 @@ XBSYSAPI VOID *ExAcquireReadWriteLockShared;
// ******************************************************************
XBSYSAPI EXPORTNUM(14) PVOID NTAPI ExAllocatePool
(
IN ULONG NumberOfBytes
IN ULONG NumberOfBytes
);
// ******************************************************************
@ -36,8 +36,8 @@ XBSYSAPI EXPORTNUM(14) PVOID NTAPI ExAllocatePool
// ******************************************************************
XBSYSAPI EXPORTNUM(15) PVOID NTAPI ExAllocatePoolWithTag
(
IN SIZE_T NumberOfBytes,
IN ULONG Tag
IN SIZE_T NumberOfBytes,
IN ULONG Tag
);
XBSYSAPI VOID *ExEventObjectType;
@ -66,11 +66,11 @@ XBSYSAPI VOID *ExQueryPoolBlockSize;
// ******************************************************************
XBSYSAPI EXPORTNUM(24) NTSTATUS NTAPI ExQueryNonVolatileSetting
(
IN DWORD ValueIndex,
OUT DWORD *Type,
OUT PUCHAR Value,
IN SIZE_T ValueLength,
OUT PSIZE_T ResultLength OPTIONAL
IN DWORD ValueIndex,
OUT DWORD *Type,
OUT PUCHAR Value,
IN SIZE_T ValueLength,
OUT PSIZE_T ResultLength OPTIONAL
);
XBSYSAPI VOID *ExReadWriteRefurbInfo;

4
import/OpenXDK/include/xboxkrnl/hal.h
View File

@ -1,5 +1,5 @@
// ******************************************************************
// *
// *
// * proj : OpenXDK
// *
// * desc : Open Source XBox Development Kit
@ -59,7 +59,7 @@ XBSYSAPI VOID *HalRequestSoftwareInterrupt;
// ******************************************************************
XBSYSAPI EXPORTNUM(49) VOID DECLSPEC_NORETURN HalReturnToFirmware
(
RETURN_FIRMWARE Routine
RETURN_FIRMWARE Routine
);
// ******************************************************************

2
import/OpenXDK/include/xboxkrnl/io.h
View File

@ -1,5 +1,5 @@
// ******************************************************************
// *
// *
// * proj : OpenXDK
// *
// * desc : Open Source XBox Development Kit

2
import/OpenXDK/include/xboxkrnl/kernel.h
View File

@ -1,5 +1,5 @@
// ******************************************************************
// *
// *
// * proj : OpenXDK
// *
// * desc : Open Source XBox Development Kit

20
import/OpenXDK/include/xboxkrnl/mm.h
View File

@ -1,5 +1,5 @@
// ******************************************************************
// *
// *
// * proj : OpenXDK
// *
// * desc : Open Source XBox Development Kit
@ -18,13 +18,13 @@ XBSYSAPI VOID *MmGlobalData;
// * MmAllocateContiguousMemory
// ******************************************************************
// *
// * Allocates a range of physically contiguous, cache-aligned
// * Allocates a range of physically contiguous, cache-aligned
// * memory from nonpaged pool (main pool on xbox).
// *
// ******************************************************************
XBSYSAPI EXPORTNUM(165) PVOID NTAPI MmAllocateContiguousMemory
(
IN ULONG NumberOfBytes
IN ULONG NumberOfBytes
);
// ******************************************************************
@ -32,11 +32,11 @@ XBSYSAPI EXPORTNUM(165) PVOID NTAPI MmAllocateContiguousMemory
// ******************************************************************
XBSYSAPI EXPORTNUM(166) PVOID NTAPI MmAllocateContiguousMemoryEx
(
IN ULONG NumberOfBytes,
IN PHYSICAL_ADDRESS LowestAcceptableAddress,
IN PHYSICAL_ADDRESS HighestAcceptableAddress,
IN ULONG Alignment OPTIONAL,
IN ULONG ProtectionType
IN ULONG NumberOfBytes,
IN PHYSICAL_ADDRESS LowestAcceptableAddress,
IN PHYSICAL_ADDRESS HighestAcceptableAddress,
IN ULONG Alignment OPTIONAL,
IN ULONG ProtectionType
);
// ******************************************************************
@ -57,7 +57,7 @@ XBSYSAPI VOID *MmDeleteKernelStack;
// ******************************************************************
XBSYSAPI EXPORTNUM(171) VOID NTAPI MmFreeContiguousMemory
(
IN PVOID BaseAddress
IN PVOID BaseAddress
);
// ******************************************************************
@ -83,7 +83,7 @@ XBSYSAPI VOID *MmIsAddressValid;
XBSYSAPI EXPORTNUM(175) PHYSICAL_ADDRESS NTAPI MmLockUnlockBufferPages
(
IN PHYSICAL_ADDRESS BaseAddress,
IN ULONG NumberOfBytes,
IN ULONG NumberOfBytes,
IN ULONG Protect
);

88
import/OpenXDK/include/xboxkrnl/nt.h
View File

@ -1,5 +1,5 @@
// ******************************************************************
// *
// *
// * proj : OpenXDK
// *
// * desc : Open Source XBox Development Kit
@ -43,7 +43,7 @@ XBSYSAPI EXPORTNUM(186) NTSTATUS NTAPI NtClearEvent
// ******************************************************************
XBSYSAPI EXPORTNUM(187) NTSTATUS NTAPI NtClose
(
IN HANDLE Handle
IN HANDLE Handle
);
XBSYSAPI VOID *NtCreateDirectoryObject;
@ -70,15 +70,15 @@ XBSYSAPI EXPORTNUM(189) NTSTATUS NTAPI NtCreateEvent
// ******************************************************************
XBSYSAPI EXPORTNUM(190) NTSTATUS NTAPI NtCreateFile
(
OUT PHANDLE FileHandle,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes,
OUT PIO_STATUS_BLOCK IoStatusBlock,
IN PLARGE_INTEGER AllocationSize OPTIONAL,
IN ULONG FileAttributes,
IN ULONG ShareAccess,
IN ULONG CreateDisposition,
IN ULONG CreateOptions
OUT PHANDLE FileHandle,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes,
OUT PIO_STATUS_BLOCK IoStatusBlock,
IN PLARGE_INTEGER AllocationSize OPTIONAL,
IN ULONG FileAttributes,
IN ULONG ShareAccess,
IN ULONG CreateDisposition,
IN ULONG CreateOptions
);
XBSYSAPI VOID *NtCreateIoCompletion;
@ -172,7 +172,7 @@ XBSYSAPI VOID *NtQueryEvent;
// * NtQueryFullAttributesFile
// ******************************************************************
XBSYSAPI EXPORTNUM(210) NTSTATUS NTAPI NtQueryFullAttributesFile
(
(
IN POBJECT_ATTRIBUTES ObjectAttributes,
OUT PVOID Attributes
);
@ -185,11 +185,11 @@ XBSYSAPI EXPORTNUM(210) NTSTATUS NTAPI NtQueryFullAttributesFile
// *
// ******************************************************************
XBSYSAPI EXPORTNUM(211) NTSTATUS NTAPI NtQueryInformationFile
(
(
IN HANDLE FileHandle,
OUT PIO_STATUS_BLOCK IoStatusBlock,
OUT PVOID FileInformation,
IN ULONG Length,
OUT PVOID FileInformation,
IN ULONG Length,
IN FILE_INFORMATION_CLASS FileInfo
);
@ -221,14 +221,14 @@ XBSYSAPI EXPORTNUM(218) NTSTATUS NTAPI NtQueryVolumeInformationFile
// ******************************************************************
XBSYSAPI EXPORTNUM(219) NTSTATUS NTAPI NtReadFile
(
IN HANDLE FileHandle, // TODO: correct paramters
IN HANDLE Event OPTIONAL,
IN PVOID ApcRoutine OPTIONAL,
IN PVOID ApcContext,
OUT PVOID IoStatusBlock,
OUT PVOID Buffer,
IN ULONG Length,
IN PLARGE_INTEGER ByteOffset OPTIONAL
IN HANDLE FileHandle, // TODO: correct paramters
IN HANDLE Event OPTIONAL,
IN PVOID ApcRoutine OPTIONAL,
IN PVOID ApcContext,
OUT PVOID IoStatusBlock,
OUT PVOID Buffer,
IN ULONG Length,
IN PLARGE_INTEGER ByteOffset OPTIONAL
);
XBSYSAPI VOID *NtReadFileScatter;
@ -271,12 +271,12 @@ XBSYSAPI EXPORTNUM(225) NTSTATUS NTAPI NtSetEvent
// *
// ******************************************************************
XBSYSAPI EXPORTNUM(226) NTSTATUS NTAPI NtSetInformationFile
(
IN HANDLE FileHandle, // TODO: correct paramters
OUT PVOID IoStatusBlock,
IN PVOID FileInformation,
IN ULONG Length,
IN ULONG FileInformationClass
(
IN HANDLE FileHandle, // TODO: correct paramters
OUT PVOID IoStatusBlock,
IN PVOID FileInformation,
IN ULONG Length,
IN ULONG FileInformationClass
);
XBSYSAPI VOID *NtSetIoCompletion;
@ -307,16 +307,16 @@ XBSYSAPI EXPORTNUM(232) VOID NTAPI NtUserIoApcDispatcher
// * NtWaitForSingleObject
// ******************************************************************
// *
// * Put the current thread into a wait state until the given
// * dispatcher object is set to a signaled state or (optionally)
// * Put the current thread into a wait state until the given
// * dispatcher object is set to a signaled state or (optionally)
// * until the wait times out.
// *
// ******************************************************************
XBSYSAPI EXPORTNUM(233) NTSTATUS NTAPI NtWaitForSingleObject
(
IN HANDLE Handle,
IN BOOLEAN Alertable,
IN PVOID Timeout
(
IN HANDLE Handle,
IN BOOLEAN Alertable,
IN PVOID Timeout
);
// ******************************************************************
@ -351,15 +351,15 @@ XBSYSAPI EXPORTNUM(235) NTSTATUS NTAPI NtWaitForMultipleObjectsEx
// *
// ******************************************************************
XBSYSAPI EXPORTNUM(236) NTSTATUS NTAPI NtWriteFile
(
IN HANDLE FileHandle, // TODO: correct paramters
IN PVOID Event,
IN PVOID ApcRoutine,
IN PVOID ApcContext,
OUT PVOID IoStatusBlock,
IN PVOID Buffer,
IN ULONG Length,
IN PLARGE_INTEGER ByteOffset
(
IN HANDLE FileHandle, // TODO: correct paramters
IN PVOID Event,
IN PVOID ApcRoutine,
IN PVOID ApcContext,
OUT PVOID IoStatusBlock,
IN PVOID Buffer,
IN ULONG Length,
IN PLARGE_INTEGER ByteOffset
);
XBSYSAPI VOID *NtWriteFileGather;

4
import/OpenXDK/include/xboxkrnl/ob.h
View File

@ -1,5 +1,5 @@
// ******************************************************************
// *
// *
// * proj : OpenXDK
// *
// * desc : Open Source XBox Development Kit
@ -25,7 +25,7 @@ XBSYSAPI VOID *ObpObjectHandleTable;
XBSYSAPI EXPORTNUM(246) BOOLEAN NTAPI ObReferenceObjectByHandle
( unsigned int a,
unsigned int b,
unsigned int c
unsigned int c
);

2
import/OpenXDK/include/xboxkrnl/ps.h
View File

@ -1,5 +1,5 @@
// ******************************************************************
// *
// *
// * proj : OpenXDK
// *
// * desc : Open Source XBox Development Kit

20
import/OpenXDK/include/xboxkrnl/rtl.h
View File

@ -1,5 +1,5 @@
// ******************************************************************
// *
// *
// * proj : OpenXDK
// *
// * desc : Open Source XBox Development Kit
@ -39,10 +39,10 @@ XBSYSAPI VOID *RtlAppendUnicodeToString;
// ******************************************************************
XBSYSAPI EXPORTNUM(264) VOID NTAPI RtlAssert
(
PVOID FailedAssertion,
PVOID FileName,
ULONG LineNumber,
PCHAR Message
PVOID FailedAssertion,
PVOID FileName,
ULONG LineNumber,
PCHAR Message
);
XBSYSAPI VOID *RtlCaptureContext;
@ -76,8 +76,8 @@ XBSYSAPI VOID *RtlCompareUnicodeString;
// ******************************************************************
XBSYSAPI EXPORTNUM(272) VOID NTAPI RtlCopyString
(
IN OUT PVOID Destination, // TODO: should be STRING
IN PVOID Source OPTIONAL // TODO: should be STRING
IN OUT PVOID Destination, // TODO: should be STRING
IN PVOID Source OPTIONAL // TODO: should be STRING
);
XBSYSAPI VOID *RtlCopyUnicodeString;
@ -112,7 +112,7 @@ XBSYSAPI VOID *RtlGetCallersAddress;
// * Initialize a counted ANSI string.
// *
// ******************************************************************
XBSYSAPI EXPORTNUM(289) VOID NTAPI RtlInitAnsiString
XBSYSAPI EXPORTNUM(289) VOID NTAPI RtlInitAnsiString
(
IN OUT PANSI_STRING DestinationString,
IN PCSZ SourceString
@ -171,7 +171,7 @@ XBSYSAPI VOID *RtlMultiByteToUnicodeSize;
// ******************************************************************
XBSYSAPI EXPORTNUM(301) ULONG NTAPI RtlNtStatusToDosError
(
IN NTSTATUS Status
IN NTSTATUS Status
);
XBSYSAPI VOID *RtlRaiseException;
@ -192,7 +192,7 @@ XBSYSAPI EXPORTNUM(304) BOOLEAN NTAPI RtlTimeFieldsToTime
XBSYSAPI EXPORTNUM(305) VOID NTAPI RtlTimeToTimeFields
(
IN PLARGE_INTEGER Time,
OUT PTIME_FIELDS TimeFields
OUT PTIME_FIELDS TimeFields
);
// ******************************************************************

28
import/OpenXDK/include/xboxkrnl/xbox.h
View File

@ -1,5 +1,5 @@
// ******************************************************************
// *
// *
// * proj : OpenXDK
// *
// * desc : Open Source XBox Development Kit
@ -22,10 +22,10 @@ XBSYSAPI EXPORTNUM(1) PVOID NTAPI AvGetSavedDataAddress();
// ******************************************************************
XBSYSAPI EXPORTNUM(2) VOID NTAPI AvSendTVEncoderOption
(
IN PVOID RegisterBase,
IN ULONG Option,
IN ULONG Param,
OUT ULONG *Result
IN PVOID RegisterBase,
IN ULONG Option,
IN ULONG Param,
OUT ULONG *Result
);
// ******************************************************************
@ -33,12 +33,12 @@ XBSYSAPI EXPORTNUM(2) VOID NTAPI AvSendTVEncoderOption
// ******************************************************************
XBSYSAPI EXPORTNUM(4) ULONG NTAPI AvSetDisplayMode
(
IN PVOID RegisterBase,
IN ULONG Step,
IN ULONG Mode,
IN ULONG Format,
IN ULONG Pitch,
IN ULONG FrameBuffer
IN PVOID RegisterBase,
IN ULONG Step,
IN ULONG Mode,
IN ULONG Format,
IN ULONG Pitch,
IN ULONG FrameBuffer
);
// ******************************************************************
@ -46,7 +46,7 @@ XBSYSAPI EXPORTNUM(4) ULONG NTAPI AvSetDisplayMode
// ******************************************************************
XBSYSAPI EXPORTNUM(4) VOID NTAPI AvSetSavedDataAddress
(
IN PVOID Address
IN PVOID Address
);
XBSYSAPI VOID *FscGetCacheSize;
@ -65,7 +65,7 @@ XBSYSAPI VOID *KdDebuggerNotPresent;
// ******************************************************************
XBSYSAPI EXPORTNUM(160) UCHAR NTAPI KfRaiseIrql
(
IN UCHAR NewIrql
IN UCHAR NewIrql
);
// ******************************************************************
@ -73,7 +73,7 @@ XBSYSAPI EXPORTNUM(160) UCHAR NTAPI KfRaiseIrql
// ******************************************************************
XBSYSAPI EXPORTNUM(161) UCHAR NTAPI KfLowerIrql
(
IN UCHAR NewIrql
IN UCHAR NewIrql
);
XBSYSAPI VOID *KiBugCheckData;

54
import/OpenXDK/include/xboxkrnl/xboxkrnl.h
View File

@ -1,5 +1,5 @@
// ******************************************************************
// *
// *
// * proj : OpenXDK
// *
// * desc : Open Source XBox Development Kit
@ -117,42 +117,42 @@ typedef void* LPSECURITY_ATTRIBUTES;
typedef long NTSTATUS;
#define NT_SUCCESS(Status) ((NTSTATUS) (Status) >= 0)
#define STATUS_SUCCESS ((DWORD )0x00000000L)
#define STATUS_SUCCESS ((DWORD )0x00000000L)
#ifndef STATUS_PENDING
#define STATUS_PENDING ((DWORD )0x00000103L)
#define STATUS_PENDING ((DWORD )0x00000103L)
#endif
#define STATUS_TIMER_RESUME_IGNORED ((DWORD )0x40000025L)
#define STATUS_UNSUCCESSFUL ((DWORD )0xC0000001)
#define STATUS_UNRECOGNIZED_MEDIA ((DWORD )0xC0000014)
#define STATUS_TIMER_RESUME_IGNORED ((DWORD )0x40000025L)
#define STATUS_UNSUCCESSFUL ((DWORD )0xC0000001)
#define STATUS_UNRECOGNIZED_MEDIA ((DWORD )0xC0000014)
#ifndef STATUS_NO_MEMORY
#define STATUS_NO_MEMORY ((DWORD )0xC0000017L)
#define STATUS_NO_MEMORY ((DWORD )0xC0000017L)
#endif
#define STATUS_ALERTED ((DWORD )0x00000101)
#define STATUS_USER_APC ((DWORD )0x000000C0L)
#define STATUS_ALERTED ((DWORD )0x00000101)
#define STATUS_USER_APC ((DWORD )0x000000C0L)
// The SCSI input buffer was too large (not necessarily an error!)
#define STATUS_DATA_OVERRUN ((DWORD )0xC000003CL)
#define STATUS_INVALID_IMAGE_FORMAT ((DWORD )0xC000007BL)
#define STATUS_INSUFFICIENT_RESOURCES ((DWORD )0xC000009AL)
#define STATUS_TOO_MANY_SECRETS ((DWORD )0xC0000156L)
#define STATUS_XBE_REGION_MISMATCH ((DWORD )0xC0050001L)
#define STATUS_XBE_MEDIA_MISMATCH ((DWORD )0xC0050002L)
#define STATUS_DATA_OVERRUN ((DWORD )0xC000003CL)
#define STATUS_INVALID_IMAGE_FORMAT ((DWORD )0xC000007BL)
#define STATUS_INSUFFICIENT_RESOURCES ((DWORD )0xC000009AL)
#define STATUS_TOO_MANY_SECRETS ((DWORD )0xC0000156L)
#define STATUS_XBE_REGION_MISMATCH ((DWORD )0xC0050001L)
#define STATUS_XBE_MEDIA_MISMATCH ((DWORD )0xC0050002L)
#define STATUS_OBJECT_NAME_NOT_FOUND ((DWORD )0xC0000034L)
#define STATUS_OBJECT_NAME_COLLISION ((DWORD )0xC0000035L)
// ******************************************************************
// * PAGE Masks
// ******************************************************************
#define PAGE_NOACCESS 0x01
#define PAGE_READONLY 0x02
#define PAGE_READWRITE 0x04
#define PAGE_WRITECOPY 0x08
#define PAGE_EXECUTE 0x10
#define PAGE_EXECUTE_READ 0x20
#define PAGE_EXECUTE_READWRITE 0x40
#define PAGE_EXECUTE_WRITECOPY 0x80
#define PAGE_GUARD 0x100
#define PAGE_NOCACHE 0x200
#define PAGE_WRITECOMBINE 0x400
#define PAGE_NOACCESS 0x01
#define PAGE_READONLY 0x02
#define PAGE_READWRITE 0x04
#define PAGE_WRITECOPY 0x08
#define PAGE_EXECUTE 0x10
#define PAGE_EXECUTE_READ 0x20
#define PAGE_EXECUTE_READWRITE 0x40
#define PAGE_EXECUTE_WRITECOPY 0x80
#define PAGE_GUARD 0x100
#define PAGE_NOCACHE 0x200
#define PAGE_WRITECOMBINE 0x400
// ******************************************************************
// * calling conventions
@ -403,7 +403,7 @@ FS_INFORMATION_CLASS, *PFS_INFORMATION_CLASS;
// ******************************************************************
// * FILE_DIRECTORY_INFORMATION
// ******************************************************************
typedef struct _FILE_DIRECTORY_INFORMATION
typedef struct _FILE_DIRECTORY_INFORMATION
{
ULONG NextEntryOffset;
ULONG FileIndex;

8
src/Common/CxbxUtil.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Cxbx.h

8
src/Common/Error.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Core->Error.cpp

8
src/Common/Error.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Core->Error.h

8
src/Common/Exe.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Core->Exe.cpp

10
src/Common/Exe.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Core->Exe.h
@ -231,7 +231,7 @@ class Exe : public Error
// typical DOS stub
static uint08 bzDOSStub[] =
{
0x4D, 0x5A, 0x90, 0x00, 0x03, 0x00, 0x00, 0x00,
0x4D, 0x5A, 0x90, 0x00, 0x03, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00,
0xB8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

8
src/Common/Linux/AlignPosfix1.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Linux->AlignPosfix1.h

8
src/Common/Linux/AlignPrefix1.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Linux->AlignPrefix1.h

84
src/Common/OpenXDK.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Core->OpenXDK.cpp
@ -36,44 +36,44 @@
// OpenXDK logo bitmap
uint08 OpenXDK[] =
{
0x5A, 0x06, 0x23, 0x49, 0x13, 0x0F, 0x33, 0x49, 0x13, 0x0F,
0x13, 0x4F, 0x33, 0x0D, 0x13, 0x49, 0x23, 0x46, 0x00, 0x23,
0x4D, 0x33, 0x0D, 0x13, 0x43, 0x22, 0x00, 0x43, 0x13, 0x22,
0x00, 0xC3, 0x22, 0xF0, 0xC3, 0x05, 0x33, 0xD3, 0x22, 0xF0,
0x83, 0x09, 0x73, 0x2A, 0xF0, 0x07, 0x83, 0x22, 0xF0, 0xD3,
0x33, 0x03, 0x73, 0xC3, 0x33, 0x0B, 0x33, 0xC3, 0x73, 0x05,
0x73, 0x22, 0xF0, 0xE3, 0x63, 0x07, 0x43, 0xF3, 0x22, 0x00,
0xF3, 0x43, 0x22, 0x00, 0xF3, 0x73, 0x33, 0x09, 0x33, 0x73,
0xF3, 0x05, 0x43, 0xF3, 0x43, 0x23, 0x07, 0x13, 0x43, 0x93,
0xB3, 0x09, 0x73, 0xC3, 0x13, 0x0D, 0x45, 0x07, 0xB3, 0x93,
0x43, 0x09, 0x23, 0x43, 0xF3, 0x43, 0x03, 0x13, 0xA3, 0xF3,
0x73, 0x07, 0x73, 0xF3, 0xA3, 0x13, 0x05, 0x73, 0xB3, 0x0B,
0x13, 0x43, 0xC3, 0x73, 0x07, 0x43, 0xF3, 0x22, 0x00, 0xF3,
0x43, 0x22, 0x00, 0xF3, 0x43, 0x0D, 0x43, 0xF3, 0x23, 0x73,
0x93, 0xF3, 0x7F, 0xB5, 0x05, 0x75, 0xB3, 0xD3, 0x7D, 0x63,
0x0B, 0xB3, 0x73, 0x0F, 0xF3, 0x43, 0x07, 0x53, 0xE3, 0xC3,
0x63, 0xC3, 0xE3, 0x53, 0x09, 0x73, 0xB3, 0x0F, 0xB3, 0x73,
0x03, 0x63, 0x73, 0x93, 0xF3, 0x7B, 0x83, 0xB3, 0xD3, 0xF3,
0x43, 0x22, 0x00, 0xF3, 0x43, 0x0D, 0x43, 0xF3, 0x33, 0xB3,
0xC3, 0xF3, 0xBD, 0xA3, 0x73, 0x63, 0x05, 0xB5, 0xD3, 0xE3,
0xBD, 0x83, 0x0B, 0xB3, 0x73, 0x0F, 0xF3, 0x43, 0x09, 0x13,
0xE3, 0xF3, 0xE3, 0x13, 0x0B, 0x73, 0xB3, 0x0F, 0xB3, 0x73,
0x03, 0x83, 0xB3, 0xC3, 0xF3, 0xBB, 0xD3, 0xF5, 0xB3, 0x23,
0x22, 0x00, 0xF3, 0x43, 0x0D, 0x43, 0xF3, 0x05, 0x43, 0xF3,
0x36, 0x00, 0x73, 0xB3, 0x32, 0x00, 0xB3, 0x73, 0x0F, 0xF3,
0x43, 0x07, 0x33, 0xC3, 0xE3, 0x73, 0xE3, 0xC3, 0x33, 0x09,
0x73, 0xB3, 0x0F, 0xB3, 0x73, 0x07, 0x43, 0xF3, 0x0D, 0x13,
0x43, 0xF3, 0x43, 0x22, 0x00, 0xF3, 0xC3, 0xA3, 0x79, 0xA3,
0xC3, 0xF3, 0x05, 0x43, 0xF3, 0x36, 0x00, 0x73, 0xE3, 0x93,
0x7B, 0x93, 0xB3, 0xC3, 0x07, 0xB3, 0x73, 0x0F, 0xF3, 0x43,
0x05, 0x73, 0xF3, 0xA3, 0x13, 0x03, 0x13, 0xA3, 0xF3, 0x73,
0x07, 0x73, 0xD3, 0x7B, 0x83, 0xB3, 0xE3, 0x73, 0x07, 0x43,
0xF3, 0x22, 0x00, 0xF3, 0x43, 0x22, 0x00, 0x53, 0x73, 0x83,
0xB9, 0x93, 0x73, 0x53, 0x05, 0x33, 0xB3, 0x36, 0x00, 0x43,
0x73, 0xA3, 0xBD, 0x83, 0x73, 0x07, 0x83, 0x63, 0x0F, 0xB3,
0x33, 0x03, 0x63, 0xE3, 0x53, 0x0B, 0x53, 0xE3, 0x63, 0x05,
0x63, 0xBF, 0x75, 0x23, 0x07, 0x33, 0xB3, 0x22, 0x00, 0xB3,
0x33, 0xFA, 0x00, 0x13, 0x0F, 0x13, 0xBE, 0x06, 0x03,
0x5A, 0x06, 0x23, 0x49, 0x13, 0x0F, 0x33, 0x49, 0x13, 0x0F,
0x13, 0x4F, 0x33, 0x0D, 0x13, 0x49, 0x23, 0x46, 0x00, 0x23,
0x4D, 0x33, 0x0D, 0x13, 0x43, 0x22, 0x00, 0x43, 0x13, 0x22,
0x00, 0xC3, 0x22, 0xF0, 0xC3, 0x05, 0x33, 0xD3, 0x22, 0xF0,
0x83, 0x09, 0x73, 0x2A, 0xF0, 0x07, 0x83, 0x22, 0xF0, 0xD3,
0x33, 0x03, 0x73, 0xC3, 0x33, 0x0B, 0x33, 0xC3, 0x73, 0x05,
0x73, 0x22, 0xF0, 0xE3, 0x63, 0x07, 0x43, 0xF3, 0x22, 0x00,
0xF3, 0x43, 0x22, 0x00, 0xF3, 0x73, 0x33, 0x09, 0x33, 0x73,
0xF3, 0x05, 0x43, 0xF3, 0x43, 0x23, 0x07, 0x13, 0x43, 0x93,
0xB3, 0x09, 0x73, 0xC3, 0x13, 0x0D, 0x45, 0x07, 0xB3, 0x93,
0x43, 0x09, 0x23, 0x43, 0xF3, 0x43, 0x03, 0x13, 0xA3, 0xF3,
0x73, 0x07, 0x73, 0xF3, 0xA3, 0x13, 0x05, 0x73, 0xB3, 0x0B,
0x13, 0x43, 0xC3, 0x73, 0x07, 0x43, 0xF3, 0x22, 0x00, 0xF3,
0x43, 0x22, 0x00, 0xF3, 0x43, 0x0D, 0x43, 0xF3, 0x23, 0x73,
0x93, 0xF3, 0x7F, 0xB5, 0x05, 0x75, 0xB3, 0xD3, 0x7D, 0x63,
0x0B, 0xB3, 0x73, 0x0F, 0xF3, 0x43, 0x07, 0x53, 0xE3, 0xC3,
0x63, 0xC3, 0xE3, 0x53, 0x09, 0x73, 0xB3, 0x0F, 0xB3, 0x73,
0x03, 0x63, 0x73, 0x93, 0xF3, 0x7B, 0x83, 0xB3, 0xD3, 0xF3,
0x43, 0x22, 0x00, 0xF3, 0x43, 0x0D, 0x43, 0xF3, 0x33, 0xB3,
0xC3, 0xF3, 0xBD, 0xA3, 0x73, 0x63, 0x05, 0xB5, 0xD3, 0xE3,
0xBD, 0x83, 0x0B, 0xB3, 0x73, 0x0F, 0xF3, 0x43, 0x09, 0x13,
0xE3, 0xF3, 0xE3, 0x13, 0x0B, 0x73, 0xB3, 0x0F, 0xB3, 0x73,
0x03, 0x83, 0xB3, 0xC3, 0xF3, 0xBB, 0xD3, 0xF5, 0xB3, 0x23,
0x22, 0x00, 0xF3, 0x43, 0x0D, 0x43, 0xF3, 0x05, 0x43, 0xF3,
0x36, 0x00, 0x73, 0xB3, 0x32, 0x00, 0xB3, 0x73, 0x0F, 0xF3,
0x43, 0x07, 0x33, 0xC3, 0xE3, 0x73, 0xE3, 0xC3, 0x33, 0x09,
0x73, 0xB3, 0x0F, 0xB3, 0x73, 0x07, 0x43, 0xF3, 0x0D, 0x13,
0x43, 0xF3, 0x43, 0x22, 0x00, 0xF3, 0xC3, 0xA3, 0x79, 0xA3,
0xC3, 0xF3, 0x05, 0x43, 0xF3, 0x36, 0x00, 0x73, 0xE3, 0x93,
0x7B, 0x93, 0xB3, 0xC3, 0x07, 0xB3, 0x73, 0x0F, 0xF3, 0x43,
0x05, 0x73, 0xF3, 0xA3, 0x13, 0x03, 0x13, 0xA3, 0xF3, 0x73,
0x07, 0x73, 0xD3, 0x7B, 0x83, 0xB3, 0xE3, 0x73, 0x07, 0x43,
0xF3, 0x22, 0x00, 0xF3, 0x43, 0x22, 0x00, 0x53, 0x73, 0x83,
0xB9, 0x93, 0x73, 0x53, 0x05, 0x33, 0xB3, 0x36, 0x00, 0x43,
0x73, 0xA3, 0xBD, 0x83, 0x73, 0x07, 0x83, 0x63, 0x0F, 0xB3,
0x33, 0x03, 0x63, 0xE3, 0x53, 0x0B, 0x53, 0xE3, 0x63, 0x05,
0x63, 0xBF, 0x75, 0x23, 0x07, 0x33, 0xB3, 0x22, 0x00, 0xB3,
0x33, 0xFA, 0x00, 0x13, 0x0F, 0x13, 0xBE, 0x06, 0x03,
};
// size, in bytes, of the OpenXDK logo bitmap

8
src/Common/Win32/AlignPosfix1.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->AlignPosfix1.h

8
src/Common/Win32/AlignPrefix1.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->AlignPrefix1.h

16
src/Common/Win32/EmuShared.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuShared.cpp
@ -74,7 +74,7 @@ CXBXKRNL_API void EmuShared::Init()
// ******************************************************************
{
hMapObject = CreateFileMapping
(
(
INVALID_HANDLE_VALUE, // Paging file
NULL, // default security attributes
PAGE_READWRITE, // read/write access
@ -84,7 +84,7 @@ CXBXKRNL_API void EmuShared::Init()
);
if(hMapObject == NULL)
CxbxKrnlCleanup("Could not map shared memory!");
CxbxKrnlCleanup("Could not map shared memory!");
if(GetLastError() == ERROR_ALREADY_EXISTS)
init = false;
@ -103,8 +103,8 @@ CXBXKRNL_API void EmuShared::Init()
0 // default: map entire file
);
if(g_EmuShared == NULL)
CxbxKrnlCleanup("Could not map view of shared memory!");
if(g_EmuShared == NULL)
CxbxKrnlCleanup("Could not map view of shared memory!");
}
// ******************************************************************

14
src/Common/Win32/Mutex.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->Mutex.cpp
@ -55,9 +55,9 @@ void Mutex::Lock()
#if (_MSC_VER < 1300) // We are not using VC++.NET
while(InterlockedCompareExchange((LPVOID*)&m_MutexLock, (LPVOID)1, (LPVOID)0))
#else
while(InterlockedCompareExchange((LPLONG)&m_MutexLock, (LONG)1, (LONG)0))
while(InterlockedCompareExchange((LPLONG)&m_MutexLock, (LONG)1, (LONG)0))
#endif
Sleep(1);
Sleep(1);
// Are we the the new owner?
if (!m_OwnerProcess)
@ -105,7 +105,7 @@ void Mutex::Unlock()
#if (_MSC_VER < 1300) // We are not using VC++.NET
while(InterlockedCompareExchange((LPVOID*)&m_MutexLock, (LPVOID)1, (LPVOID)0))
#else
while (InterlockedCompareExchange((LPLONG)&m_MutexLock, (LONG)1, (LONG)0))
while (InterlockedCompareExchange((LPLONG)&m_MutexLock, (LONG)1, (LONG)0))
#endif
Sleep(1);

8
src/Common/Win32/Mutex.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->Mutex.h

38
src/Common/Win32/XBController.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->XBController.cpp
@ -321,7 +321,7 @@ bool XBController::ConfigPoll(char *szStatus)
dwHow = FIELD_OFFSET(XTL::DIJOYSTATE, lRz);
dwFlags |= (JoyState.lRz > 0) ? (DEVICE_FLAG_AXIS | DEVICE_FLAG_POSITIVE) : (DEVICE_FLAG_AXIS | DEVICE_FLAG_NEGATIVE);
}
else
else
{
for(int b=0;b<2;b++)
{
@ -1116,7 +1116,7 @@ BOOL XBController::EnumGameCtrlCallback(XTL::LPCDIDEVICEINSTANCE lpddi)
return DIENUM_CONTINUE;
HRESULT hRet = m_pDirectInput8->CreateDevice(lpddi->guidInstance, &m_InputDevice[m_dwInputDeviceCount].m_Device, NULL);
if(!FAILED(hRet))
{
m_InputDevice[m_dwInputDeviceCount].m_Flags = DEVICE_FLAG_JOYSTICK;
@ -1137,14 +1137,14 @@ BOOL XBController::EnumObjectsCallback(XTL::LPCDIDEVICEOBJECTINSTANCE lpddoi)
{
if(lpddoi->dwType & DIDFT_AXIS)
{
XTL::DIPROPRANGE diprg;
XTL::DIPROPRANGE diprg;
diprg.diph.dwSize = sizeof(XTL::DIPROPRANGE);
diprg.diph.dwHeaderSize = sizeof(XTL::DIPROPHEADER);
diprg.diph.dwHow = DIPH_BYID;
diprg.diph.dwSize = sizeof(XTL::DIPROPRANGE);
diprg.diph.dwHeaderSize = sizeof(XTL::DIPROPHEADER);
diprg.diph.dwHow = DIPH_BYID;
diprg.diph.dwObj = lpddoi->dwType;
diprg.lMin = 0 - 32768;
diprg.lMax = 0 + 32767;
diprg.lMin = 0 - 32768;
diprg.lMax = 0 + 32767;
HRESULT hRet = m_InputDevice[m_dwCurObject].m_Device->SetProperty(DIPROP_RANGE, &diprg.diph);
@ -1158,14 +1158,14 @@ BOOL XBController::EnumObjectsCallback(XTL::LPCDIDEVICEOBJECTINSTANCE lpddoi)
}
else if(lpddoi->dwType & DIDFT_BUTTON)
{
XTL::DIPROPRANGE diprg;
XTL::DIPROPRANGE diprg;
diprg.diph.dwSize = sizeof(XTL::DIPROPRANGE);
diprg.diph.dwHeaderSize = sizeof(XTL::DIPROPHEADER);
diprg.diph.dwHow = DIPH_BYID;
diprg.diph.dwSize = sizeof(XTL::DIPROPRANGE);
diprg.diph.dwHeaderSize = sizeof(XTL::DIPROPHEADER);
diprg.diph.dwHow = DIPH_BYID;
diprg.diph.dwObj = lpddoi->dwType;
diprg.lMin = 0;
diprg.lMax = 255;
diprg.lMin = 0;
diprg.lMax = 255;
HRESULT hRet = m_InputDevice[m_dwCurObject].m_Device->SetProperty(DIPROP_RANGE, &diprg.diph);
@ -1204,7 +1204,7 @@ BOOL CALLBACK WrapEnumObjectsCallback(XTL::LPCDIDEVICEOBJECTINSTANCE lpddoi, LPV
// ******************************************************************
// * Input Device Name Lookup Table
// ******************************************************************
const char *XBController::m_DeviceNameLookup[XBCTRL_OBJECT_COUNT] =
const char *XBController::m_DeviceNameLookup[XBCTRL_OBJECT_COUNT] =
{
// ******************************************************************
// * Analog Axis

8
src/Common/Win32/XBController.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->Cxbx->XBController.h

8
src/Common/Win32/XBVideo.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->XBVideo.cpp

8
src/Common/Win32/XBVideo.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->Cxbx->XBVideo.h

12
src/Common/Xbe.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Core->Xbe.cpp
@ -611,7 +611,7 @@ Xbe::Xbe(class Exe *x_Exe, const char *x_szTitle, bool x_bRetail)
if(x_Exe->m_bzSection[v][r--] != 0)
break;
}
// word aligned
m_SectionHeader[v].dwSizeofRaw = RoundUp(r+2, 4);
}
@ -1240,7 +1240,7 @@ void Xbe::DumpInformation(FILE *x_file)
fprintf(x_file, "Library Name : %s\n", tmp);
fprintf(x_file, "Version : %d.%d.%d\n", m_LibraryVersion[v].wMajorVersion, m_LibraryVersion[v].wMinorVersion, m_LibraryVersion[v].wBuildVersion);
// print flags
{
fprintf(x_file, "Flags : ");

12
src/Common/Xbe.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Core->Xbe.h
@ -116,7 +116,7 @@ class Xbe : public Error
m_Header;
// Xbe header extra byte (used to preserve unknown data)
char *m_HeaderEx;
char *m_HeaderEx;
// Xbe certificate
#include "AlignPrefix1.h"
@ -267,7 +267,7 @@ const uint32 XBEIMAGE_GAME_REGION_NA = 0x00000001;
const uint32 XBEIMAGE_GAME_REGION_JAPAN = 0x00000002;
const uint32 XBEIMAGE_GAME_REGION_RESTOFWORLD = 0x00000004;
const uint32 XBEIMAGE_GAME_REGION_MANUFACTURING = 0x80000000;
// media type flags for Xbe certificate
const uint32 XBEIMAGE_MEDIA_TYPE_HARD_DISK = 0x00000001;
const uint32 XBEIMAGE_MEDIA_TYPE_DVD_X2 = 0x00000002;

10
src/Core/Error.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Core->Error.cpp
@ -39,7 +39,7 @@
bool Error::ClearError()
{
if(m_bFatal)
return false;
return false;
delete[] m_szError;

8
src/Core/Exe.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Core->Exe.cpp

84
src/Core/OpenXDK.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Core->OpenXDK.cpp
@ -36,44 +36,44 @@
// OpenXDK logo bitmap
uint08 OpenXDK[] =
{
0x5A, 0x06, 0x23, 0x49, 0x13, 0x0F, 0x33, 0x49, 0x13, 0x0F,
0x13, 0x4F, 0x33, 0x0D, 0x13, 0x49, 0x23, 0x46, 0x00, 0x23,
0x4D, 0x33, 0x0D, 0x13, 0x43, 0x22, 0x00, 0x43, 0x13, 0x22,
0x00, 0xC3, 0x22, 0xF0, 0xC3, 0x05, 0x33, 0xD3, 0x22, 0xF0,
0x83, 0x09, 0x73, 0x2A, 0xF0, 0x07, 0x83, 0x22, 0xF0, 0xD3,
0x33, 0x03, 0x73, 0xC3, 0x33, 0x0B, 0x33, 0xC3, 0x73, 0x05,
0x73, 0x22, 0xF0, 0xE3, 0x63, 0x07, 0x43, 0xF3, 0x22, 0x00,
0xF3, 0x43, 0x22, 0x00, 0xF3, 0x73, 0x33, 0x09, 0x33, 0x73,
0xF3, 0x05, 0x43, 0xF3, 0x43, 0x23, 0x07, 0x13, 0x43, 0x93,
0xB3, 0x09, 0x73, 0xC3, 0x13, 0x0D, 0x45, 0x07, 0xB3, 0x93,
0x43, 0x09, 0x23, 0x43, 0xF3, 0x43, 0x03, 0x13, 0xA3, 0xF3,
0x73, 0x07, 0x73, 0xF3, 0xA3, 0x13, 0x05, 0x73, 0xB3, 0x0B,
0x13, 0x43, 0xC3, 0x73, 0x07, 0x43, 0xF3, 0x22, 0x00, 0xF3,
0x43, 0x22, 0x00, 0xF3, 0x43, 0x0D, 0x43, 0xF3, 0x23, 0x73,
0x93, 0xF3, 0x7F, 0xB5, 0x05, 0x75, 0xB3, 0xD3, 0x7D, 0x63,
0x0B, 0xB3, 0x73, 0x0F, 0xF3, 0x43, 0x07, 0x53, 0xE3, 0xC3,
0x63, 0xC3, 0xE3, 0x53, 0x09, 0x73, 0xB3, 0x0F, 0xB3, 0x73,
0x03, 0x63, 0x73, 0x93, 0xF3, 0x7B, 0x83, 0xB3, 0xD3, 0xF3,
0x43, 0x22, 0x00, 0xF3, 0x43, 0x0D, 0x43, 0xF3, 0x33, 0xB3,
0xC3, 0xF3, 0xBD, 0xA3, 0x73, 0x63, 0x05, 0xB5, 0xD3, 0xE3,
0xBD, 0x83, 0x0B, 0xB3, 0x73, 0x0F, 0xF3, 0x43, 0x09, 0x13,
0xE3, 0xF3, 0xE3, 0x13, 0x0B, 0x73, 0xB3, 0x0F, 0xB3, 0x73,
0x03, 0x83, 0xB3, 0xC3, 0xF3, 0xBB, 0xD3, 0xF5, 0xB3, 0x23,
0x22, 0x00, 0xF3, 0x43, 0x0D, 0x43, 0xF3, 0x05, 0x43, 0xF3,
0x36, 0x00, 0x73, 0xB3, 0x32, 0x00, 0xB3, 0x73, 0x0F, 0xF3,
0x43, 0x07, 0x33, 0xC3, 0xE3, 0x73, 0xE3, 0xC3, 0x33, 0x09,
0x73, 0xB3, 0x0F, 0xB3, 0x73, 0x07, 0x43, 0xF3, 0x0D, 0x13,
0x43, 0xF3, 0x43, 0x22, 0x00, 0xF3, 0xC3, 0xA3, 0x79, 0xA3,
0xC3, 0xF3, 0x05, 0x43, 0xF3, 0x36, 0x00, 0x73, 0xE3, 0x93,
0x7B, 0x93, 0xB3, 0xC3, 0x07, 0xB3, 0x73, 0x0F, 0xF3, 0x43,
0x05, 0x73, 0xF3, 0xA3, 0x13, 0x03, 0x13, 0xA3, 0xF3, 0x73,
0x07, 0x73, 0xD3, 0x7B, 0x83, 0xB3, 0xE3, 0x73, 0x07, 0x43,
0xF3, 0x22, 0x00, 0xF3, 0x43, 0x22, 0x00, 0x53, 0x73, 0x83,
0xB9, 0x93, 0x73, 0x53, 0x05, 0x33, 0xB3, 0x36, 0x00, 0x43,
0x73, 0xA3, 0xBD, 0x83, 0x73, 0x07, 0x83, 0x63, 0x0F, 0xB3,
0x33, 0x03, 0x63, 0xE3, 0x53, 0x0B, 0x53, 0xE3, 0x63, 0x05,
0x63, 0xBF, 0x75, 0x23, 0x07, 0x33, 0xB3, 0x22, 0x00, 0xB3,
0x33, 0xFA, 0x00, 0x13, 0x0F, 0x13, 0xBE, 0x06, 0x03,
0x5A, 0x06, 0x23, 0x49, 0x13, 0x0F, 0x33, 0x49, 0x13, 0x0F,
0x13, 0x4F, 0x33, 0x0D, 0x13, 0x49, 0x23, 0x46, 0x00, 0x23,
0x4D, 0x33, 0x0D, 0x13, 0x43, 0x22, 0x00, 0x43, 0x13, 0x22,
0x00, 0xC3, 0x22, 0xF0, 0xC3, 0x05, 0x33, 0xD3, 0x22, 0xF0,
0x83, 0x09, 0x73, 0x2A, 0xF0, 0x07, 0x83, 0x22, 0xF0, 0xD3,
0x33, 0x03, 0x73, 0xC3, 0x33, 0x0B, 0x33, 0xC3, 0x73, 0x05,
0x73, 0x22, 0xF0, 0xE3, 0x63, 0x07, 0x43, 0xF3, 0x22, 0x00,
0xF3, 0x43, 0x22, 0x00, 0xF3, 0x73, 0x33, 0x09, 0x33, 0x73,
0xF3, 0x05, 0x43, 0xF3, 0x43, 0x23, 0x07, 0x13, 0x43, 0x93,
0xB3, 0x09, 0x73, 0xC3, 0x13, 0x0D, 0x45, 0x07, 0xB3, 0x93,
0x43, 0x09, 0x23, 0x43, 0xF3, 0x43, 0x03, 0x13, 0xA3, 0xF3,
0x73, 0x07, 0x73, 0xF3, 0xA3, 0x13, 0x05, 0x73, 0xB3, 0x0B,
0x13, 0x43, 0xC3, 0x73, 0x07, 0x43, 0xF3, 0x22, 0x00, 0xF3,
0x43, 0x22, 0x00, 0xF3, 0x43, 0x0D, 0x43, 0xF3, 0x23, 0x73,
0x93, 0xF3, 0x7F, 0xB5, 0x05, 0x75, 0xB3, 0xD3, 0x7D, 0x63,
0x0B, 0xB3, 0x73, 0x0F, 0xF3, 0x43, 0x07, 0x53, 0xE3, 0xC3,
0x63, 0xC3, 0xE3, 0x53, 0x09, 0x73, 0xB3, 0x0F, 0xB3, 0x73,
0x03, 0x63, 0x73, 0x93, 0xF3, 0x7B, 0x83, 0xB3, 0xD3, 0xF3,
0x43, 0x22, 0x00, 0xF3, 0x43, 0x0D, 0x43, 0xF3, 0x33, 0xB3,
0xC3, 0xF3, 0xBD, 0xA3, 0x73, 0x63, 0x05, 0xB5, 0xD3, 0xE3,
0xBD, 0x83, 0x0B, 0xB3, 0x73, 0x0F, 0xF3, 0x43, 0x09, 0x13,
0xE3, 0xF3, 0xE3, 0x13, 0x0B, 0x73, 0xB3, 0x0F, 0xB3, 0x73,
0x03, 0x83, 0xB3, 0xC3, 0xF3, 0xBB, 0xD3, 0xF5, 0xB3, 0x23,
0x22, 0x00, 0xF3, 0x43, 0x0D, 0x43, 0xF3, 0x05, 0x43, 0xF3,
0x36, 0x00, 0x73, 0xB3, 0x32, 0x00, 0xB3, 0x73, 0x0F, 0xF3,
0x43, 0x07, 0x33, 0xC3, 0xE3, 0x73, 0xE3, 0xC3, 0x33, 0x09,
0x73, 0xB3, 0x0F, 0xB3, 0x73, 0x07, 0x43, 0xF3, 0x0D, 0x13,
0x43, 0xF3, 0x43, 0x22, 0x00, 0xF3, 0xC3, 0xA3, 0x79, 0xA3,
0xC3, 0xF3, 0x05, 0x43, 0xF3, 0x36, 0x00, 0x73, 0xE3, 0x93,
0x7B, 0x93, 0xB3, 0xC3, 0x07, 0xB3, 0x73, 0x0F, 0xF3, 0x43,
0x05, 0x73, 0xF3, 0xA3, 0x13, 0x03, 0x13, 0xA3, 0xF3, 0x73,
0x07, 0x73, 0xD3, 0x7B, 0x83, 0xB3, 0xE3, 0x73, 0x07, 0x43,
0xF3, 0x22, 0x00, 0xF3, 0x43, 0x22, 0x00, 0x53, 0x73, 0x83,
0xB9, 0x93, 0x73, 0x53, 0x05, 0x33, 0xB3, 0x36, 0x00, 0x43,
0x73, 0xA3, 0xBD, 0x83, 0x73, 0x07, 0x83, 0x63, 0x0F, 0xB3,
0x33, 0x03, 0x63, 0xE3, 0x53, 0x0B, 0x53, 0xE3, 0x63, 0x05,
0x63, 0xBF, 0x75, 0x23, 0x07, 0x33, 0xB3, 0x22, 0x00, 0xB3,
0x33, 0xFA, 0x00, 0x13, 0x0F, 0x13, 0xBE, 0x06, 0x03,
};
// size, in bytes, of the OpenXDK logo bitmap

12
src/Core/Xbe.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Core->Xbe.cpp
@ -610,7 +610,7 @@ Xbe::Xbe(class Exe *x_Exe, const char *x_szTitle, bool x_bRetail)
if(x_Exe->m_bzSection[v][r--] != 0)
break;
}
// word aligned
m_SectionHeader[v].dwSizeofRaw = RoundUp(r+2, 4);
}
@ -1239,7 +1239,7 @@ void Xbe::DumpInformation(FILE *x_file)
fprintf(x_file, "Library Name : %s\n", tmp);
fprintf(x_file, "Version : %d.%d.%d\n", m_LibraryVersion[v].wMajorVersion, m_LibraryVersion[v].wMinorVersion, m_LibraryVersion[v].wBuildVersion);
// print flags
{
fprintf(x_file, "Flags : ");

12
src/Cxbe/Main.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Standard->Cxbe->Main.cpp
@ -236,7 +236,7 @@ cleanup:
if(szErrorMessage[0] != 0)
{
ShowUsage();
printf("\n");
printf(" * Error : %s\n", szErrorMessage);
@ -253,7 +253,7 @@ static void ShowUsage()
(
"CXBE XBE->EXE (XBox->Win32) Relinker (CXBX Core Version " _CXBX_VERSION ")\n"
"Copyright (C) Aaron Robinson 2002-2003. All rights reserved.\n"
"\n"
"\n"
"Usage : cxbe [options] [exefile]\n"
"\n"
"Options :\n"

8
src/Cxbx.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Cxbx.h

80
src/Cxbx/DlgControllerConfig.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Cxbx->DlgControllerConfig.cpp
@ -55,7 +55,7 @@ static BOOL g_bHasChanges = FALSE;
VOID ShowControllerConfig(HWND hwnd)
{
/*! reset changes flag */
g_bHasChanges = FALSE;
g_bHasChanges = FALSE;
/*! retrieve controller configuration */
g_EmuShared->GetXBController(&g_XBController);
@ -90,8 +90,8 @@ INT_PTR CALLBACK DlgControllerConfigProc(HWND hWndDlg, UINT uMsg, WPARAM wParam,
case IDYES:
PostMessage(hWndDlg, WM_COMMAND, IDC_INPUT_CONFIG_ACCEPT, 0);
break;
case IDNO:
PostMessage(hWndDlg, WM_COMMAND, IDC_INPUT_CONFIG_CANCEL, 0);
case IDNO:
PostMessage(hWndDlg, WM_COMMAND, IDC_INPUT_CONFIG_CANCEL, 0);
break;
}
break;
@ -99,16 +99,16 @@ INT_PTR CALLBACK DlgControllerConfigProc(HWND hWndDlg, UINT uMsg, WPARAM wParam,
PostMessage(hWndDlg, WM_COMMAND, IDC_INPUT_CONFIG_CANCEL, 0);
}
break;
break;
case WM_COMMAND:
{
HWND hWndButton = GetDlgItem(hWndDlg, LOWORD(wParam));
switch(LOWORD(wParam))
{
{
case IDC_INPUT_CONFIG_CANCEL:
EndDialog(hWndDlg, wParam);
EndDialog(hWndDlg, wParam);
break;
case IDC_INPUT_CONFIG_ACCEPT:
@ -159,51 +159,51 @@ INT_PTR CALLBACK DlgControllerConfigProc(HWND hWndDlg, UINT uMsg, WPARAM wParam,
case IDC_SET_A:
ConfigureInput(hWndDlg, hWndButton, XBCTRL_OBJECT_A);
break;
case IDC_SET_B:
ConfigureInput(hWndDlg, hWndButton, XBCTRL_OBJECT_B);
break;
case IDC_SET_WHITE:
ConfigureInput(hWndDlg, hWndButton, XBCTRL_OBJECT_WHITE);
break;
case IDC_SET_BLACK:
ConfigureInput(hWndDlg, hWndButton, XBCTRL_OBJECT_BLACK);
break;
case IDC_SET_LTRIGGER:
ConfigureInput(hWndDlg, hWndButton, XBCTRL_OBJECT_LTRIGGER);
break;
case IDC_SET_RTRIGGER:
ConfigureInput(hWndDlg, hWndButton, XBCTRL_OBJECT_RTRIGGER);
break;
case IDC_SET_DPAD_UP:
ConfigureInput(hWndDlg, hWndButton, XBCTRL_OBJECT_DPADUP);
break;
case IDC_SET_DPAD_DOWN:
ConfigureInput(hWndDlg, hWndButton, XBCTRL_OBJECT_DPADDOWN);
break;
case IDC_SET_DPAD_LEFT:
ConfigureInput(hWndDlg, hWndButton, XBCTRL_OBJECT_DPADLEFT);
break;
case IDC_SET_DPAD_RIGHT:
ConfigureInput(hWndDlg, hWndButton, XBCTRL_OBJECT_DPADRIGHT);
break;
case IDC_SET_BACK:
ConfigureInput(hWndDlg, hWndButton, XBCTRL_OBJECT_BACK);
break;
case IDC_SET_START:
ConfigureInput(hWndDlg, hWndButton, XBCTRL_OBJECT_START);
break;
case IDC_SET_LTHUMB:
ConfigureInput(hWndDlg, hWndButton, XBCTRL_OBJECT_LTHUMB);
break;
@ -221,31 +221,31 @@ INT_PTR CALLBACK DlgControllerConfigProc(HWND hWndDlg, UINT uMsg, WPARAM wParam,
int idcVal;
XBCtrlObject ctrl;
}
configObj[] =
configObj[] =
{
{ IDC_SET_X, XBCTRL_OBJECT_X },
{ IDC_SET_X, XBCTRL_OBJECT_X },
{ IDC_SET_Y, XBCTRL_OBJECT_Y },
{ IDC_SET_A, XBCTRL_OBJECT_A },
{ IDC_SET_A, XBCTRL_OBJECT_A },
{ IDC_SET_B, XBCTRL_OBJECT_B },
{ IDC_SET_WHITE, XBCTRL_OBJECT_WHITE },
{ IDC_SET_WHITE, XBCTRL_OBJECT_WHITE },
{ IDC_SET_BLACK, XBCTRL_OBJECT_BLACK },
{ IDC_SET_LTRIGGER, XBCTRL_OBJECT_LTRIGGER },
{ IDC_SET_LTRIGGER, XBCTRL_OBJECT_LTRIGGER },
{ IDC_SET_RTRIGGER, XBCTRL_OBJECT_RTRIGGER },
{ IDC_SET_DPAD_UP, XBCTRL_OBJECT_DPADUP },
{ IDC_SET_DPAD_UP, XBCTRL_OBJECT_DPADUP },
{ IDC_SET_DPAD_DOWN, XBCTRL_OBJECT_DPADDOWN },
{ IDC_SET_DPAD_LEFT, XBCTRL_OBJECT_DPADLEFT },
{ IDC_SET_DPAD_LEFT, XBCTRL_OBJECT_DPADLEFT },
{ IDC_SET_DPAD_RIGHT, XBCTRL_OBJECT_DPADRIGHT },
{ IDC_SET_BACK, XBCTRL_OBJECT_BACK },
{ IDC_SET_BACK, XBCTRL_OBJECT_BACK },
{ IDC_SET_START, XBCTRL_OBJECT_START },
{ IDC_SET_LTHUMB, XBCTRL_OBJECT_LTHUMB },
{ IDC_SET_LTHUMB, XBCTRL_OBJECT_LTHUMB },
{ IDC_SET_RTHUMB, XBCTRL_OBJECT_RTHUMB },
{ IDC_SET_LEFT_POSY, XBCTRL_OBJECT_LTHUMBPOSY },
{ IDC_SET_LEFT_POSY, XBCTRL_OBJECT_LTHUMBPOSY },
{ IDC_SET_LEFT_NEGY, XBCTRL_OBJECT_LTHUMBNEGY },
{ IDC_SET_LEFT_NEGX, XBCTRL_OBJECT_LTHUMBNEGX },
{ IDC_SET_LEFT_NEGX, XBCTRL_OBJECT_LTHUMBNEGX },
{ IDC_SET_LEFT_POSX, XBCTRL_OBJECT_LTHUMBPOSX },
{ IDC_SET_RIGHT_POSY, XBCTRL_OBJECT_RTHUMBPOSY },
{ IDC_SET_RIGHT_POSY, XBCTRL_OBJECT_RTHUMBPOSY },
{ IDC_SET_RIGHT_NEGY, XBCTRL_OBJECT_RTHUMBNEGY },
{ IDC_SET_RIGHT_NEGX, XBCTRL_OBJECT_RTHUMBNEGX },
{ IDC_SET_RIGHT_NEGX, XBCTRL_OBJECT_RTHUMBNEGX },
{ IDC_SET_RIGHT_POSX, XBCTRL_OBJECT_RTHUMBPOSX },
};
@ -257,11 +257,11 @@ INT_PTR CALLBACK DlgControllerConfigProc(HWND hWndDlg, UINT uMsg, WPARAM wParam,
break;
}
}
}
}
break;
}
return FALSE;
}
return FALSE;
}
VOID ConfigureInput(HWND hWndDlg, HWND hWndButton, XBCtrlObject object)
@ -273,7 +273,7 @@ VOID ConfigureInput(HWND hWndDlg, HWND hWndButton, XBCtrlObject object)
bConfigDone = false;
g_bHasChanges = TRUE;
g_bHasChanges = TRUE;
/*! disable all buttons */
EnableButtonWindows(hWndDlg, hWndButton, FALSE);
@ -352,7 +352,7 @@ VOID EnableButtonWindows(HWND hWndDlg, HWND hExclude, BOOL bEnable)
int v=0;
/*! list of applicable child windows */
int itemList[] =
int itemList[] =
{
IDC_SET_X, IDC_SET_Y, IDC_SET_A, IDC_SET_B,
IDC_SET_WHITE, IDC_SET_BLACK,

8
src/Cxbx/DlgControllerConfig.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Cxbx->DlgControllerConfig.h

24
src/Cxbx/DlgVideoConfig.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Cxbx->DlgVideoConfig.cpp
@ -154,8 +154,8 @@ INT_PTR CALLBACK DlgVideoConfigProc(HWND hWndDlg, UINT uMsg, WPARAM wParam, LPAR
case IDYES:
PostMessage(hWndDlg, WM_COMMAND, IDC_VC_ACCEPT, 0);
break;
case IDNO:
PostMessage(hWndDlg, WM_COMMAND, IDC_VC_CANCEL, 0);
case IDNO:
PostMessage(hWndDlg, WM_COMMAND, IDC_VC_CANCEL, 0);
break;
}
break;
@ -170,11 +170,11 @@ INT_PTR CALLBACK DlgVideoConfigProc(HWND hWndDlg, UINT uMsg, WPARAM wParam, LPAR
HWND hWndButton = GetDlgItem(hWndDlg, LOWORD(wParam));
switch(LOWORD(wParam))
{
{
case IDC_VC_CANCEL:
EndDialog(hWndDlg, wParam);
EndDialog(hWndDlg, wParam);
break;
case IDC_VC_ACCEPT:
{
/*! save video resolution configuration */
@ -230,8 +230,8 @@ INT_PTR CALLBACK DlgVideoConfigProc(HWND hWndDlg, UINT uMsg, WPARAM wParam, LPAR
}
}
break;
}
return FALSE;
}
return FALSE;
}
VOID RefreshDisplayAdapter()
@ -368,6 +368,6 @@ VOID RefreshDirect3DDevice()
/*! activate configured display mode */
SendMessage(g_hVideoResolution, CB_SETCURSEL, dwVideoResolution, 0);
return;
}

8
src/Cxbx/DlgVideoConfig.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->Cxbx->DlgVideoConfig.h

10
src/Cxbx/EmuExe.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->Cxbx->EmuExe.cpp
@ -611,7 +611,7 @@ EmuExe::EmuExe(Xbe *x_Xbe, DebugMode x_debug_mode, char *x_debug_filename, HWND
// ******************************************************************
for(uint32 v=0;v<x_Xbe->m_Header.dwSections;v++)
{
uint32 imag_base = m_OptionalHeader.m_image_base;
uint32 imag_base = m_OptionalHeader.m_image_base;
uint32 virt_addr = m_SectionHeader[v].m_virtual_addr;
uint32 virt_size = m_SectionHeader[v].m_virtual_size;

8
src/Cxbx/EmuExe.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->Cxbx->EmuExe.h

8
src/Cxbx/Prolog.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->Cxbx->Prolog.cpp

8
src/Cxbx/Prolog.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->Cxbx->Prolog.h

2
src/Cxbx/ResCxbx.h
View File

@ -97,7 +97,7 @@
#define ID_EMULATION_STOP 40082
// Next default values for new objects
//
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE 119

8
src/Cxbx/WinMain.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->Cxbx->WinMain.cpp

24
src/Cxbx/Wnd.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->Cxbx->Wnd.cpp
@ -90,7 +90,7 @@ bool Wnd::ProcessMessages()
wnd_class.hbrBackground = m_background;
m_class = RegisterClass(&wnd_class);
m_hwnd = CreateWindowEx
(
NULL,
@ -120,7 +120,7 @@ cleanup:;
}
MSG msg;
MSG msg;
if(PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE))
{
@ -155,7 +155,7 @@ LRESULT CALLBACK Wnd::WndProcForward(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
}
return forward_to->WndProc(hwnd, uMsg, wParam, lParam);
}
@ -165,16 +165,16 @@ LRESULT CALLBACK Wnd::WndProcForward(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM
LRESULT CALLBACK Wnd::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch(uMsg)
{
{
case WM_CLOSE:
DestroyWindow(hwnd);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
break;
default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return 0;
}

8
src/Cxbx/Wnd.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->Cxbx->Wnd.h

24
src/Cxbx/WndAbout.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->Cxbx->WndAbout.cpp
@ -68,8 +68,8 @@ WndAbout::~WndAbout()
// window message processing procedure
LRESULT CALLBACK WndAbout::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch(uMsg)
{
switch(uMsg)
{
case WM_CREATE:
{
// resize window so that client area := 400x300
@ -92,7 +92,7 @@ LRESULT CALLBACK WndAbout::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM l
int nHeight = -MulDiv(8, GetDeviceCaps(hDC, LOGPIXELSY), 72);
m_hFont = CreateFont(nHeight, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, ANTIALIASED_QUALITY, FF_ROMAN, "Verdana");
m_hFont = CreateFont(nHeight, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, ANTIALIASED_QUALITY, FF_ROMAN, "Verdana");
m_BackBmp = CreateCompatibleBitmap(hDC, 400, 300);
@ -166,21 +166,21 @@ LRESULT CALLBACK WndAbout::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM l
case WM_LBUTTONUP:
SendMessage(hwnd, WM_CLOSE, 0, 0);
break;
break;
case WM_CLOSE:
EnableWindow(m_parent, TRUE);
DestroyWindow(hwnd);
break;
break;
case WM_DESTROY:
DeleteObject(m_hFont);
PostQuitMessage(0);
break;
break;
default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return 0;
}

10
src/Cxbx/WndAbout.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->Cxbx->WndAbout.h
@ -64,7 +64,7 @@ class WndAbout : public Wnd
HDC m_BackDC;
HBITMAP m_OrigBmp;
HBITMAP m_BackBmp;
HFONT m_hFont;
HFONT m_hFont;
};
#endif

366
src/Cxbx/WndMain.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->Cxbx->WndMain.cpp
@ -52,8 +52,8 @@ WndMain::WndMain(HINSTANCE x_hInstance) : Wnd(x_hInstance), m_bCreated(false), m
m_w = 640;
m_h = 480;
m_ExeFilename = (char*)calloc(1, 260);
m_XbeFilename = (char*)calloc(1, 260);
m_ExeFilename = (char*)calloc(1, 260);
m_XbeFilename = (char*)calloc(1, 260);
m_CxbxDebugFilename = (char*)calloc(1, 260);
m_KrnlDebugFilename = (char*)calloc(1, 260);
@ -214,8 +214,8 @@ WndMain::~WndMain()
// window message processing procedure
LRESULT CALLBACK WndMain::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch(uMsg)
{
switch(uMsg)
{
case WM_CREATE:
{
// initialize menu
@ -240,7 +240,7 @@ LRESULT CALLBACK WndMain::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lP
}
// initialize back buffer
{
{
HDC hDC = GetDC(hwnd);
m_BackBmp = CreateCompatibleBitmap(hDC, 640, 480);
@ -282,7 +282,7 @@ LRESULT CALLBACK WndMain::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lP
}
m_LogoBmp = (HBITMAP)LoadImage(m_hInstance, MAKEINTRESOURCE(IDB_LOGO), IMAGE_BITMAP, 0, 0, 0);
m_BackDC = CreateCompatibleDC(hDC);
m_LogoDC = CreateCompatibleDC(hDC);
@ -358,29 +358,29 @@ LRESULT CALLBACK WndMain::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lP
HDC hDC = GetDC(hwnd);
// draw splash / logo / status
{
{
static const int nLogoBmpW = 100, nLogoBmpH = 17;
BitBlt(hDC, 0, 0, 640, 480, m_BackDC, 0, 0, SRCCOPY);
// BitBlt(hDC, 0, 10, 320, 160, m_BackDC, 0, 0, SRCCOPY);
BitBlt(hDC, 640-nLogoBmpW-4, 480-nLogoBmpH-4, nLogoBmpW, nLogoBmpH, m_LogoDC, 0, 0, SRCCOPY);
// BitBlt(hDC, 0, 10, 320, 160, m_BackDC, 0, 0, SRCCOPY);
BitBlt(hDC, 640-nLogoBmpW-4, 480-nLogoBmpH-4, nLogoBmpW, nLogoBmpH, m_LogoDC, 0, 0, SRCCOPY);
int nHeight = -MulDiv(8, GetDeviceCaps(hDC, LOGPIXELSY), 72);
int nHeight = -MulDiv(8, GetDeviceCaps(hDC, LOGPIXELSY), 72);
HFONT hFont = CreateFont(nHeight, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, ANTIALIASED_QUALITY, FF_ROMAN, "Verdana");
HFONT hFont = CreateFont(nHeight, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, ANTIALIASED_QUALITY, FF_ROMAN, "Verdana");
HGDIOBJ tmpObj = SelectObject(hDC, hFont);
SetBkColor(hDC, RGB(0,0,0));
SetTextColor(hDC, RGB(255,255,255));
SetTextColor(hDC, RGB(255,255,255));
char buffer[255];
if(m_Xbe != 0 && m_Xbe->GetError() == 0)
sprintf(buffer, "%s Loaded!", m_Xbe->m_szAsciiTitle);
else
sprintf(buffer, "%s", "Disclaimer: Cxbx has no affiliation with Microsoft");
sprintf(buffer, "%s", "Disclaimer: Cxbx has no affiliation with Microsoft");
RECT rect = {0, 480-15-5, 640-100-4-69, 480-5};
@ -389,7 +389,7 @@ LRESULT CALLBACK WndMain::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lP
SelectObject(hDC, tmpObj);
DeleteObject(hFont);
}
}
if(hDC != NULL)
ReleaseDC(hwnd, hDC);
@ -468,20 +468,20 @@ LRESULT CALLBACK WndMain::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lP
case ID_FILE_CLOSE_XBE:
CloseXbe();
break;
break;
case ID_FILE_SAVEXBEFILE:
{
case ID_FILE_SAVEXBEFILE:
{
if(m_XbeFilename[0] == '\0')
SaveXbeAs();
else
SaveXbe(m_XbeFilename);
}
break;
SaveXbe(m_XbeFilename);
}
break;
case ID_FILE_SAVEXBEFILEAS:
case ID_FILE_SAVEXBEFILEAS:
SaveXbeAs();
break;
break;
case ID_FILE_IMPORTFROMEXE:
{
@ -585,43 +585,43 @@ LRESULT CALLBACK WndMain::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lP
SendMessage(hwnd, WM_CLOSE, 0, 0);
break;
case ID_EDIT_LOGOBITMAP_EXPORT:
{
case ID_EDIT_LOGOBITMAP_EXPORT:
{
OPENFILENAME ofn = {0};
char filename[260] = "logo.bmp";
char filename[260] = "logo.bmp";
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = m_hwnd;
ofn.lpstrFilter = "Bitmap Image Files (*.bmp)\0*.bmp\0";
ofn.lpstrFile = filename;
ofn.nMaxFile = 260;
ofn.nFilterIndex = 1;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrInitialDir = NULL;
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = m_hwnd;
ofn.lpstrFilter = "Bitmap Image Files (*.bmp)\0*.bmp\0";
ofn.lpstrFile = filename;
ofn.nMaxFile = 260;
ofn.nFilterIndex = 1;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrInitialDir = NULL;
ofn.lpstrDefExt = "bmp";
ofn.lpstrTitle = "Export Logo Bitmap";
ofn.Flags = OFN_PATHMUSTEXIST;
ofn.Flags = OFN_PATHMUSTEXIST;
if(GetSaveFileName(&ofn) == TRUE)
if(GetSaveFileName(&ofn) == TRUE)
{
// ask permission to overwrite if file already exists
if(_access(ofn.lpstrFile, 0) != -1)
{
if(MessageBox(m_hwnd, "Overwrite existing file?", "Cxbx", MB_ICONQUESTION | MB_YESNO) != IDYES)
return TRUE;
}
if(_access(ofn.lpstrFile, 0) != -1)
{
if(MessageBox(m_hwnd, "Overwrite existing file?", "Cxbx", MB_ICONQUESTION | MB_YESNO) != IDYES)
return TRUE;
}
// export logo bitmap
{
{
uint08 i_gray[100*17];
m_Xbe->ExportLogoBitmap(i_gray);
m_Xbe->ExportLogoBitmap(i_gray);
if(m_Xbe->GetError() == 0)
{
FILE *LogoBitmap = fopen(ofn.lpstrFile, "wb");
if(m_Xbe->GetError() == 0)
{
FILE *LogoBitmap = fopen(ofn.lpstrFile, "wb");
// write bitmap header
{
@ -676,11 +676,11 @@ LRESULT CALLBACK WndMain::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lP
fwrite(&pad, 2, 1, LogoBitmap);
}
fclose(LogoBitmap);
}
fclose(LogoBitmap);
}
if(m_Xbe->GetError() != 0)
MessageBox(m_hwnd, m_Xbe->GetError(), "Cxbx", MB_ICONSTOP | MB_OK);
if(m_Xbe->GetError() != 0)
MessageBox(m_hwnd, m_Xbe->GetError(), "Cxbx", MB_ICONSTOP | MB_OK);
else
{
char buffer[255];
@ -690,40 +690,40 @@ LRESULT CALLBACK WndMain::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lP
MessageBox(m_hwnd, buffer, "Cxbx", MB_ICONINFORMATION | MB_OK);
printf("WndMain: %s\n", buffer);
}
}
}
}
}
}
break;
}
break;
case ID_EDIT_LOGOBITMAP_IMPORT:
{
case ID_EDIT_LOGOBITMAP_IMPORT:
{
OPENFILENAME ofn = {0};
char filename[260] = "*.bmp";
char filename[260] = "*.bmp";
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = m_hwnd;
ofn.lpstrFilter = "Bitmap Image Files (*.bmp)\0*.bmp\0";
ofn.lpstrFile = filename;
ofn.nMaxFile = 260;
ofn.nFilterIndex = 1;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrInitialDir = NULL;
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = m_hwnd;
ofn.lpstrFilter = "Bitmap Image Files (*.bmp)\0*.bmp\0";
ofn.lpstrFile = filename;
ofn.nMaxFile = 260;
ofn.nFilterIndex = 1;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrInitialDir = NULL;
ofn.lpstrDefExt = "bmp";
ofn.lpstrTitle = "Import Logo Bitmap";
ofn.Flags = OFN_PATHMUSTEXIST;
ofn.Flags = OFN_PATHMUSTEXIST;
if(GetOpenFileName(&ofn) == TRUE)
if(GetOpenFileName(&ofn) == TRUE)
{
// import logo bitmap
{
{
uint08 i_gray[100*17];
// read bitmap file
{
FILE *logo = fopen(ofn.lpstrFile, "rb");
FILE *logo = fopen(ofn.lpstrFile, "rb");
char *bmp_err = 0;
@ -771,11 +771,11 @@ LRESULT CALLBACK WndMain::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lP
}
}
m_Xbe->ImportLogoBitmap(i_gray);
m_Xbe->ImportLogoBitmap(i_gray);
if(m_Xbe->GetError() != 0)
if(m_Xbe->GetError() != 0)
{
MessageBox(m_hwnd, m_Xbe->GetError(), "Cxbx", MB_ICONSTOP | MB_OK);
MessageBox(m_hwnd, m_Xbe->GetError(), "Cxbx", MB_ICONSTOP | MB_OK);
if(m_Xbe->IsFatal())
CloseXbe();
@ -796,11 +796,11 @@ LRESULT CALLBACK WndMain::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lP
printf("WndMain: %s\n", buffer);
MessageBox(m_hwnd, buffer, "Cxbx", MB_ICONINFORMATION | MB_OK);
}
}
}
}
}
}
break;
}
break;
case ID_EDIT_PATCH_ALLOW64MB:
{
@ -858,28 +858,28 @@ LRESULT CALLBACK WndMain::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lP
{
OPENFILENAME ofn = {0};
char filename[260] = "Xbe.txt";
char filename[260] = "Xbe.txt";
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = m_hwnd;
ofn.lpstrFilter = "Text Documents (*.txt)\0*.txt\0";
ofn.lpstrFile = filename;
ofn.nMaxFile = 260;
ofn.nFilterIndex = 1;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrInitialDir = NULL;
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = m_hwnd;
ofn.lpstrFilter = "Text Documents (*.txt)\0*.txt\0";
ofn.lpstrFile = filename;
ofn.nMaxFile = 260;
ofn.nFilterIndex = 1;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrInitialDir = NULL;
ofn.lpstrDefExt = "txt";
ofn.Flags = OFN_PATHMUSTEXIST;
ofn.Flags = OFN_PATHMUSTEXIST;
if(GetSaveFileName(&ofn) == TRUE)
if(GetSaveFileName(&ofn) == TRUE)
{
// ask permission to overwrite if file exists
if(_access(ofn.lpstrFile, 0) != -1)
{
if(MessageBox(m_hwnd, "Overwrite existing file?", "Cxbx", MB_ICONQUESTION | MB_YESNO) != IDYES)
return TRUE;
}
if(_access(ofn.lpstrFile, 0) != -1)
{
if(MessageBox(m_hwnd, "Overwrite existing file?", "Cxbx", MB_ICONQUESTION | MB_YESNO) != IDYES)
return TRUE;
}
// dump xbe information to file
{
@ -973,21 +973,21 @@ LRESULT CALLBACK WndMain::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lP
{
OPENFILENAME ofn = {0};
char filename[260] = "KrnlDebug.txt";
char filename[260] = "KrnlDebug.txt";
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = m_hwnd;
ofn.lpstrFilter = "Text Documents (*.txt)\0*.txt\0";
ofn.lpstrFile = filename;
ofn.nMaxFile = 260;
ofn.nFilterIndex = 1;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrInitialDir = NULL;
ofn.hwndOwner = m_hwnd;
ofn.lpstrFilter = "Text Documents (*.txt)\0*.txt\0";
ofn.lpstrFile = filename;
ofn.nMaxFile = 260;
ofn.nFilterIndex = 1;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrInitialDir = NULL;
ofn.lpstrDefExt = "txt";
ofn.Flags = OFN_PATHMUSTEXIST;
ofn.Flags = OFN_PATHMUSTEXIST;
if(GetSaveFileName(&ofn) != FALSE)
if(GetSaveFileName(&ofn) != FALSE)
{
MessageBox(m_hwnd, "This will not take effect until emulation is (re)started.\n", "Cxbx", MB_OK);
@ -1006,7 +1006,7 @@ LRESULT CALLBACK WndMain::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lP
break;
case ID_EMULATION_DEBUGOUTPUTGUI_CONSOLE:
{
{
if(m_CxbxDebug == DM_NONE || m_CxbxDebug == DM_FILE)
m_CxbxDebug = DM_CONSOLE;
else
@ -1015,8 +1015,8 @@ LRESULT CALLBACK WndMain::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lP
RefreshMenus();
UpdateDebugConsoles();
}
break;
}
break;
case ID_EMULATION_DEBUGOUTPUTGUI_FILE:
{
@ -1032,21 +1032,21 @@ LRESULT CALLBACK WndMain::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lP
{
OPENFILENAME ofn = {0};
char filename[260] = "CxbxDebug.txt";
char filename[260] = "CxbxDebug.txt";
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = m_hwnd;
ofn.lpstrFilter = "Text Documents (*.txt)\0*.txt\0";
ofn.lpstrFile = filename;
ofn.nMaxFile = 260;
ofn.nFilterIndex = 1;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrInitialDir = NULL;
ofn.hwndOwner = m_hwnd;
ofn.lpstrFilter = "Text Documents (*.txt)\0*.txt\0";
ofn.lpstrFile = filename;
ofn.nMaxFile = 260;
ofn.nFilterIndex = 1;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrInitialDir = NULL;
ofn.lpstrDefExt = "txt";
ofn.Flags = OFN_PATHMUSTEXIST;
ofn.Flags = OFN_PATHMUSTEXIST;
if(GetSaveFileName(&ofn) != FALSE)
if(GetSaveFileName(&ofn) != FALSE)
{
strncpy(m_CxbxDebugFilename, ofn.lpstrFile, 259);
@ -1116,7 +1116,7 @@ LRESULT CALLBACK WndMain::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lP
}
case WM_CLOSE:
{
{
if(m_Xbe != 0)
CloseXbe();
@ -1143,7 +1143,7 @@ LRESULT CALLBACK WndMain::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lP
DeleteObject(m_BackBmp);
ReleaseDC(hwnd, hDC);
ReleaseDC(hwnd, hDC);
delete m_Xbe;
@ -1154,8 +1154,8 @@ LRESULT CALLBACK WndMain::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lP
break;
default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return 0;
}
@ -1201,7 +1201,7 @@ void WndMain::XbeLoaded()
InvalidateRgn(m_hwnd, NULL, TRUE);
printf("WndMain: %s loaded.\n", m_Xbe->m_szAsciiTitle);
printf("WndMain: %s loaded.\n", m_Xbe->m_szAsciiTitle);
}
// load logo bitmap
@ -1243,16 +1243,16 @@ void WndMain::RefreshMenus()
// file menu
{
HMENU file_menu = GetSubMenu(menu, 0);
HMENU file_menu = GetSubMenu(menu, 0);
// enable/disable close .xbe file
EnableMenuItem(file_menu, ID_FILE_CLOSE_XBE, MF_BYCOMMAND | (m_Xbe == 0) ? MF_GRAYED : MF_ENABLED);
// enable/disable save .xbe file
EnableMenuItem(file_menu, ID_FILE_SAVEXBEFILE, MF_BYCOMMAND | (m_Xbe == 0) ? MF_GRAYED : MF_ENABLED);
// enable/disable save .xbe file
EnableMenuItem(file_menu, ID_FILE_SAVEXBEFILE, MF_BYCOMMAND | (m_Xbe == 0) ? MF_GRAYED : MF_ENABLED);
// enable/disable save .xbe file as
EnableMenuItem(file_menu, ID_FILE_SAVEXBEFILEAS, MF_BYCOMMAND | (m_Xbe == 0) ? MF_GRAYED : MF_ENABLED);
// enable/disable save .xbe file as
EnableMenuItem(file_menu, ID_FILE_SAVEXBEFILEAS, MF_BYCOMMAND | (m_Xbe == 0) ? MF_GRAYED : MF_ENABLED);
// enable/disable export to .exe
EnableMenuItem(file_menu, ID_FILE_EXPORTTOEXE, MF_BYCOMMAND | (m_Xbe == 0) ? MF_GRAYED : MF_ENABLED);
@ -1356,7 +1356,7 @@ void WndMain::RefreshMenus()
HMENU sett_menu = GetSubMenu(menu, 3);
HMENU auto_menu = GetSubMenu(sett_menu, 4);
// check appropriate choice
// check appropriate choice
if(m_AutoConvertToExe == AUTO_CONVERT_WINDOWS_TEMP)
{
CheckMenuItem(auto_menu, ID_SETTINGS_GENWT, MF_BYCOMMAND | MF_CHECKED);
@ -1437,7 +1437,7 @@ void WndMain::UpdateRecentFiles()
// clear existing menu items
{
int v, max;
max = GetMenuItemCount(RXbeMenu);
for(v=0;v<max;v++)
RemoveMenu(RXbeMenu, 0, MF_BYPOSITION);
@ -1618,18 +1618,18 @@ void WndMain::CloseXbe()
void WndMain::SaveXbe(const char *x_filename)
{
// ask permission to overwrite if the file already exists
if(_access(x_filename, 0) != -1)
{
if(MessageBox(m_hwnd, "Overwrite existing file?", "Cxbx", MB_ICONQUESTION | MB_YESNO) != IDYES)
return;
}
if(_access(x_filename, 0) != -1)
{
if(MessageBox(m_hwnd, "Overwrite existing file?", "Cxbx", MB_ICONQUESTION | MB_YESNO) != IDYES)
return;
}
// export xbe file
{
{
m_Xbe->Export(x_filename);
if(m_Xbe->GetError() != 0)
MessageBox(m_hwnd, m_Xbe->GetError(), "Cxbx", MB_ICONSTOP | MB_OK);
if(m_Xbe->GetError() != 0)
MessageBox(m_hwnd, m_Xbe->GetError(), "Cxbx", MB_ICONSTOP | MB_OK);
else
{
char buffer[255];
@ -1641,8 +1641,8 @@ void WndMain::SaveXbe(const char *x_filename)
MessageBox(m_hwnd, buffer, "Cxbx", MB_ICONINFORMATION | MB_OK);
m_bXbeChanged = false;
}
}
}
}
}
// save xbe as
@ -1650,24 +1650,24 @@ void WndMain::SaveXbeAs()
{
OPENFILENAME ofn = {0};
char filename[260] = "default.xbe";
char filename[260] = "default.xbe";
SuggestFilename(m_XbeFilename, filename, ".xbe");
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = m_hwnd;
ofn.lpstrFilter = "Xbox Executables (*.xbe)\0*.xbe\0";
ofn.lpstrFile = filename;
ofn.nMaxFile = 260;
ofn.nFilterIndex = 1;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrInitialDir = NULL;
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = m_hwnd;
ofn.lpstrFilter = "Xbox Executables (*.xbe)\0*.xbe\0";
ofn.lpstrFile = filename;
ofn.nMaxFile = 260;
ofn.nFilterIndex = 1;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrInitialDir = NULL;
ofn.lpstrDefExt = "xbe";
ofn.Flags = OFN_PATHMUSTEXIST;
ofn.Flags = OFN_PATHMUSTEXIST;
if(GetSaveFileName(&ofn) == TRUE)
SaveXbe(ofn.lpstrFile);
if(GetSaveFileName(&ofn) == TRUE)
SaveXbe(ofn.lpstrFile);
}
// import an exe file
@ -1758,7 +1758,7 @@ void WndMain::ImportExe(const char *x_filename)
// convert to exe file
bool WndMain::ConvertToExe(const char *x_filename, bool x_bVerifyIfExists, HWND hwndParent)
{
char filename[260] = "default.exe";
char filename[260] = "default.exe";
if(x_filename == NULL)
{
@ -1767,18 +1767,18 @@ bool WndMain::ConvertToExe(const char *x_filename, bool x_bVerifyIfExists, HWND
SuggestFilename(m_XbeFilename, filename, ".exe");
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = m_hwnd;
ofn.lpstrFilter = "Windows Executables (*.exe)\0*.exe\0";
ofn.lpstrFile = filename;
ofn.nMaxFile = 260;
ofn.nFilterIndex = 1;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrInitialDir = NULL;
ofn.hwndOwner = m_hwnd;
ofn.lpstrFilter = "Windows Executables (*.exe)\0*.exe\0";
ofn.lpstrFile = filename;
ofn.nMaxFile = 260;
ofn.nFilterIndex = 1;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrInitialDir = NULL;
ofn.lpstrDefExt = "exe";
ofn.Flags = OFN_PATHMUSTEXIST;
ofn.Flags = OFN_PATHMUSTEXIST;
if(GetSaveFileName(&ofn) == FALSE)
if(GetSaveFileName(&ofn) == FALSE)
return false;
strcpy(filename, ofn.lpstrFile);
@ -1789,24 +1789,24 @@ bool WndMain::ConvertToExe(const char *x_filename, bool x_bVerifyIfExists, HWND
}
// ask permission to overwrite if this file already exists
if(x_bVerifyIfExists)
{
if(_access(filename, 0) != -1)
{
if(MessageBox(m_hwnd, "Overwrite existing file?", "Cxbx", MB_ICONQUESTION | MB_YESNO) != IDYES)
return false;
}
}
if(x_bVerifyIfExists)
{
if(_access(filename, 0) != -1)
{
if(MessageBox(m_hwnd, "Overwrite existing file?", "Cxbx", MB_ICONQUESTION | MB_YESNO) != IDYES)
return false;
}
}
// convert file
{
EmuExe i_EmuExe(m_Xbe, m_KrnlDebug, m_KrnlDebugFilename, hwndParent);
{
EmuExe i_EmuExe(m_Xbe, m_KrnlDebug, m_KrnlDebugFilename, hwndParent);
i_EmuExe.Export(filename);
i_EmuExe.Export(filename);
if(i_EmuExe.GetError() != 0)
if(i_EmuExe.GetError() != 0)
{
MessageBox(m_hwnd, i_EmuExe.GetError(), "Cxbx", MB_ICONSTOP | MB_OK);
MessageBox(m_hwnd, i_EmuExe.GetError(), "Cxbx", MB_ICONSTOP | MB_OK);
return false;
}
else
@ -1817,7 +1817,7 @@ bool WndMain::ConvertToExe(const char *x_filename, bool x_bVerifyIfExists, HWND
m_bExeChanged = false;
}
}
}
return true;
}

8
src/Cxbx/WndMain.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->Cxbx->WndMain.h

14
src/Cxbx/jpegdec/jpegdec.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->Cxbx->jpegdec->jpegdec.cpp
@ -48,7 +48,7 @@ static void init_source(j_decompress_ptr cinfo)
static boolean fill_input_buffer(j_decompress_ptr cinfo)
{
return FALSE;
return FALSE;
}
static void skip_input_data(j_decompress_ptr cinfo, long num_bytes)
@ -65,7 +65,7 @@ static void skip_input_data(j_decompress_ptr cinfo, long num_bytes)
static void term_source(j_decompress_ptr cinfo)
{
// do nothing!
}
}
void jpeg_memory_src(j_decompress_ptr cinfo, uint08 *buffer, uint32 bufferSize)
{
@ -130,7 +130,7 @@ uint08 *jpeg2bmp(uint08 *jpeg, uint32 jpegSize, uint32 *bmpSize, uint32 *bmpWidt
// re-order color data
{
uint32 v=0;
for(v=0;v<cinfo.output_width*cinfo.output_height;v++)
{
uint08 r = buffer[v*3+2];

8
src/Cxbx/jpegdec/jpegdec.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->Cxbx->jpegdec->jpegdec.h

12
src/CxbxKrnl/CxbxKrnl.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->CxbxKrnl.cpp
@ -79,7 +79,7 @@ extern "C" CXBXKRNL_API bool CxbxKrnlVerifyVersion(const char *szVersion)
extern "C" CXBXKRNL_API void CxbxKrnlInit
(
HWND hwndParent,
void *pTLSData,
void *pTLSData,
Xbe::TLS *pTLS,
Xbe::LibraryVersion *pLibraryVersion,
DebugMode DbgMode,
@ -108,7 +108,7 @@ extern "C" CXBXKRNL_API void CxbxKrnlInit
SetConsoleTitle("Cxbx : Kernel Debug Console");
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_RED);
printf("EmuMain (0x%X): Cxbx Version %s\n", GetCurrentThreadId(), _CXBX_VERSION);
printf("EmuMain (0x%X): Debug Console Allocated (DM_CONSOLE).\n", GetCurrentThreadId());
}

8
src/CxbxKrnl/CxbxKrnl.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->CxbxKrnl.h

12
src/CxbxKrnl/DbgConsole.cpp
View File

@ -106,7 +106,7 @@ void DbgConsole::Reset()
printf("CxbxDbg> ");
fflush(stdout);
m_szInput[0] = '\0';
}
@ -231,7 +231,7 @@ void DbgConsole::ParseCommand()
else if(_stricmp(szCmd, "lvb") == 0 || _stricmp(szCmd, "ListVB") == 0)
{
int v=0;
g_VBTrackTotal.Lock();
RTNode *cur = g_VBTrackTotal.getHead();
@ -252,7 +252,7 @@ void DbgConsole::ParseCommand()
int n=0, m=0;
int c = sscanf(m_szInput, "%*s %d-%d", &n, &m);
if(c == 1)
{
EnableTracker(g_VBTrackTotal, g_VBTrackDisable, n, n, ETA_DISABLE);
@ -271,7 +271,7 @@ void DbgConsole::ParseCommand()
int n=0, m=0;
int c = sscanf(m_szInput, "%*s %d-%d", &n, &m);
if(c == 1)
{
EnableTracker(g_VBTrackTotal, g_VBTrackDisable, n, n, ETA_ENABLE);
@ -315,7 +315,7 @@ void DbgConsole::ParseCommand()
int n=0, m=0;
int c = sscanf(m_szInput, "%*s %d-%d", &n, &m);
if(c == 1)
{
EnableTracker(g_PBTrackTotal, g_PBTrackShowOnce, n, n, ETA_SHOW);
@ -334,7 +334,7 @@ void DbgConsole::ParseCommand()
int n=0, m=0;
int c = sscanf(m_szInput, "%*s %d-%d", &n, &m);
if(c == 1)
{
EnableTracker(g_PBTrackTotal, g_PBTrackDisable, n, n, ETA_DISABLE);

8
src/CxbxKrnl/DbgConsole.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuD3D8->VertexShader.h

14
src/CxbxKrnl/Emu.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->Emu.cpp
@ -241,7 +241,7 @@ extern int EmuException(LPEXCEPTION_POINTERS e)
//if(e->ContextRecord->Ecx == 0x00000200 || e->ContextRecord->Ecx == 0x00000100)
//{
// Battlestar Galactica WBINVD skip
e->ContextRecord->Eip += 2;
e->ContextRecord->Eip += 2;
DbgPrintf("EmuMain (0x%X): Battlestar Galactica Hack 1 was applied!\n", GetCurrentThreadId());
@ -278,7 +278,7 @@ extern int EmuException(LPEXCEPTION_POINTERS e)
if(e->ExceptionRecord->ExceptionCode == 0x80000003)
{
sprintf(buffer,
sprintf(buffer,
"Recieved Breakpoint Exception (int 3) @ EIP := 0x%.08X\n"
"\n"
" Press Abort to terminate emulation.\n"
@ -311,7 +311,7 @@ extern int EmuException(LPEXCEPTION_POINTERS e)
}
else
{
sprintf(buffer,
sprintf(buffer,
"Recieved Exception Code 0x%.08X @ EIP := 0x%.08X\n"
"\n"
" Press \"OK\" to terminate emulation.\n"

8
src/CxbxKrnl/Emu.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->Emu.h

388
src/CxbxKrnl/EmuD3D8.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuD3D8.cpp
@ -208,7 +208,7 @@ VOID XTL::EmuD3DInit(Xbe::Header *XbeHeader, uint32 XbeHeaderSize)
g_pD3D8->GetDeviceCaps(g_XBVideo.GetDisplayAdapter(), DevType, &g_D3DCaps);
}
SetFocus(g_hEmuWindow);
SetFocus(g_hEmuWindow);
// create default device
{
@ -286,7 +286,7 @@ static DWORD WINAPI EmuRenderWindow(LPVOID lpVoid)
EmuMsgProc,
0, 0, GetModuleHandle(NULL),
LoadIcon(hCxbxDll, MAKEINTRESOURCE(IDI_CXBX)),
LoadCursor(NULL, IDC_ARROW),
LoadCursor(NULL, IDC_ARROW),
(HBRUSH)(g_hBgBrush), NULL,
"CxbxRender",
NULL
@ -363,7 +363,7 @@ static DWORD WINAPI EmuRenderWindow(LPVOID lpVoid)
DbgPrintf("EmuD3D8 (0x%X): Message-Pump thread is running.\n", GetCurrentThreadId());
SetFocus(g_hEmuWindow);
SetFocus(g_hEmuWindow);
DbgConsole *dbgConsole = new DbgConsole();
@ -619,7 +619,7 @@ static DWORD WINAPI EmuUpdateTickCount(LPVOID)
if(hDevice == 0)
continue;
DWORD dwLatency = g_pXInputSetStateStatus[v].dwLatency++;
if(dwLatency < XINPUT_SETSTATE_LATENCY)
@ -739,7 +739,7 @@ static DWORD WINAPI EmuCreateDeviceProxy(LPVOID)
}
g_EmuCDPD.pPresentationParameters->Flags = D3DPRESENTFLAG_LOCKABLE_BACKBUFFER;
// retrieve resolution from configuration
if(g_EmuCDPD.pPresentationParameters->Windowed)
{
@ -756,8 +756,8 @@ static DWORD WINAPI EmuCreateDeviceProxy(LPVOID)
{
char szBackBufferFormat[16];
sscanf(g_XBVideo.GetVideoResolution(), "%d x %d %*dbit %s (%d hz)",
&g_EmuCDPD.pPresentationParameters->BackBufferWidth,
sscanf(g_XBVideo.GetVideoResolution(), "%d x %d %*dbit %s (%d hz)",
&g_EmuCDPD.pPresentationParameters->BackBufferWidth,
&g_EmuCDPD.pPresentationParameters->BackBufferHeight,
szBackBufferFormat,
&g_EmuCDPD.pPresentationParameters->FullScreen_RefreshRateInHz);
@ -875,7 +875,7 @@ static DWORD WINAPI EmuCreateDeviceProxy(LPVOID)
ddsd2.dwSize = sizeof(ddsd2);
ddsd2.dwFlags = DDSD_CAPS;
ddsd2.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
HRESULT hRet = g_pDD7->CreateSurface(&ddsd2, &g_pDDSPrimary, 0);
if(FAILED(hRet))
@ -926,7 +926,7 @@ static DWORD WINAPI EmuCreateDeviceProxy(LPVOID)
g_pD3DDevice8->EndScene();
g_EmuCDPD.hRet = g_pD3DDevice8->Release();
if(g_EmuCDPD.hRet == 0)
g_pD3DDevice8 = 0;
}
@ -1360,7 +1360,7 @@ HRESULT WINAPI XTL::EmuIDirect3DDevice8_LoadVertexShader
");\n",
GetCurrentThreadId(), Handle,Address);
if(Address < 136 && VshHandleIsVertexShader(Handle))
if(Address < 136 && VshHandleIsVertexShader(Handle))
{
VERTEX_SHADER *pVertexShader = (VERTEX_SHADER *)(VshHandleGetVertexShader(Handle))->Handle;
for (DWORD i = Address; i < pVertexShader->Size; i++)
@ -1688,7 +1688,7 @@ HRESULT WINAPI XTL::EmuIDirect3DDevice8_BeginStateBig()
//ULONG ret = g_pD3DDevice8->BeginStateBlock();
CxbxKrnlCleanup("BeginStateBig is not implemented");
CxbxKrnlCleanup("BeginStateBig is not implemented");
EmuSwapFS(); // XBox FS
@ -1793,7 +1793,7 @@ HRESULT WINAPI XTL::EmuIDirect3DDevice8_CopyRects
HRESULT hRet = g_pD3DDevice8->CopyRects
(
pSourceSurface->EmuSurface8,
pSourceSurface->EmuSurface8,
pSourceRectsArray,
cRects,
pDestinationSurface->EmuSurface8,
@ -2724,11 +2724,11 @@ HRESULT WINAPI XTL::EmuIDirect3DDevice8_SetPixelShader
if(dwHandle == 0)
{
// simplest possible pixel shader, simply output the texture input
// simplest possible pixel shader, simply output the texture input
static const char szDiffusePixelShader[] =
"ps.1.0\n"
"tex t0\n"
"mov r0, t0\n";
"ps.1.0\n"
"tex t0\n"
"mov r0, t0\n";
LPD3DXBUFFER pShader = 0;
LPD3DXBUFFER pErrors = 0;
@ -2882,7 +2882,7 @@ HRESULT WINAPI XTL::EmuIDirect3DDevice8_CreateTexture
hRet = g_pD3DDevice8->CreateTexture
(
Width, Height, Levels,
Width, Height, Levels,
PCUsage, // TODO: Xbox Allows a border to be drawn (maybe hack this in software ;[)
PCFormat, PCPool, &((*ppTexture)->EmuTexture8)
);
@ -2920,7 +2920,7 @@ HRESULT WINAPI XTL::EmuIDirect3DDevice8_CreateTexture
// If YUY2 is not supported in hardware, we'll actually mark this as a special fake texture (set highest bit)
*ppTexture = new X_D3DTexture();
(*ppTexture)->Data = X_D3DRESOURCE_DATA_FLAG_SPECIAL | X_D3DRESOURCE_DATA_FLAG_YUVSURF;
(*ppTexture)->Lock = dwPtr;
(*ppTexture)->Format = 0x24;
@ -3004,7 +3004,7 @@ HRESULT WINAPI XTL::EmuIDirect3DDevice8_CreateVolumeTexture
hRet = g_pD3DDevice8->CreateVolumeTexture
(
Width, Height, Depth, Levels,
Width, Height, Depth, Levels,
0, // TODO: Xbox Allows a border to be drawn (maybe hack this in software ;[)
PCFormat, D3DPOOL_MANAGED, &((*ppVolumeTexture)->EmuVolumeTexture8)
);
@ -3095,7 +3095,7 @@ HRESULT WINAPI XTL::EmuIDirect3DDevice8_CreateCubeTexture
HRESULT hRet = g_pD3DDevice8->CreateCubeTexture
(
EdgeLength, Levels,
EdgeLength, Levels,
0, // TODO: Xbox Allows a border to be drawn (maybe hack this in software ;[)
PCFormat, D3DPOOL_MANAGED, &((*ppCubeTexture)->EmuCubeTexture8)
);
@ -3152,7 +3152,7 @@ HRESULT WINAPI XTL::EmuIDirect3DDevice8_CreateIndexBuffer
{
BYTE *pData = NULL;
(*ppIndexBuffer)->EmuIndexBuffer8->Lock(0, Length, &pData, NULL);
(*ppIndexBuffer)->Data = (DWORD)pData;
@ -3169,7 +3169,7 @@ HRESULT WINAPI XTL::EmuIDirect3DDevice8_CreateIndexBuffer
XTL::X_D3DIndexBuffer * WINAPI XTL::EmuIDirect3DDevice8_CreateIndexBuffer2(UINT Length)
{
X_D3DIndexBuffer *pIndexBuffer = NULL;
EmuIDirect3DDevice8_CreateIndexBuffer
(
Length,
@ -3265,7 +3265,7 @@ HRESULT WINAPI XTL::EmuIDirect3DDevice8_SetTexture
EmuD3DActiveTexture[Stage] = pTexture;
if(pTexture != NULL)
{
{
EmuVerifyResourceIsRegistered(pTexture);
if(IsSpecialResource(pTexture->Data) && (pTexture->Data & X_D3DRESOURCE_DATA_FLAG_YUVSURF))
@ -3309,13 +3309,13 @@ HRESULT WINAPI XTL::EmuIDirect3DDevice8_SetTexture
sprintf(szBuffer, _DEBUG_DUMP_TEXTURE_SETTEXTURE "SetTextureCube%d - %.03d (0x%.08X).bmp", face, dwDumpTexture++, pTexture->EmuTexture8);
pTexture->EmuCubeTexture8->UnlockRect((D3DCUBEMAP_FACES)face, 0);
D3DXSaveTextureToFile(szBuffer, D3DXIFF_BMP, pTexture->EmuTexture8, NULL);
}
}
break;
}
}
}
#endif
}
}
@ -3413,7 +3413,7 @@ VOID __fastcall XTL::EmuIDirect3DDevice8_SwitchTexture
pTexture->EmuTexture8->UnlockRect(0);
D3DXSaveTextureToFile(szBuffer, D3DXIFF_BMP, pTexture->EmuBaseTexture8, NULL);
}
}
//*/
}
@ -3452,9 +3452,9 @@ HRESULT WINAPI XTL::EmuIDirect3DDevice8_GetDisplayMode
// TODO: Make this configurable in the future?
pMode->Flags = 0x000000A1; // D3DPRESENTFLAG_FIELD | D3DPRESENTFLAG_INTERLACED | D3DPRESENTFLAG_LOCKABLE_BACKBUFFER
// TODO: Retrieve from current CreateDevice settings?
// TODO: Retrieve from current CreateDevice settings?
pMode->Width = 640;
pMode->Height = 457; // Battlestar Galactica PAL Version
pMode->Height = 457; // Battlestar Galactica PAL Version
}
EmuSwapFS(); // XBox FS
@ -3737,7 +3737,7 @@ HRESULT WINAPI XTL::EmuIDirect3DDevice8_SetVertexData4f
g_IVBFVF |= D3DFVF_XYZRHW;
}
break;
default:
CxbxKrnlCleanup("Unknown IVB Register : %d", Register);
}
@ -3850,7 +3850,7 @@ HRESULT WINAPI XTL::EmuIDirect3DDevice8_Clear
");\n",
GetCurrentThreadId(), Count, pRects, Flags,
Color, Z, Stencil);
// make adjustments to parameters to make sense with windows d3d
{
// TODO: D3DCLEAR_TARGET_A, *R, *G, *B don't exist on windows
@ -4122,7 +4122,7 @@ HRESULT WINAPI XTL::EmuIDirect3DResource8_Register
X_D3DFORMAT X_Format = (X_D3DFORMAT)((pPixelContainer->Format & X_D3DFORMAT_FORMAT_MASK) >> X_D3DFORMAT_FORMAT_SHIFT);
D3DFORMAT Format = EmuXB2PC_D3DFormat(X_Format);
D3DFORMAT CacheFormat;
D3DFORMAT CacheFormat;
// TODO: check for dimensions
// TODO: HACK: Temporary?
@ -4232,7 +4232,7 @@ HRESULT WINAPI XTL::EmuIDirect3DResource8_Register
g_dwOverlayH = dwHeight;
g_dwOverlayP = RoundUp(g_dwOverlayW, 64)*2;
//
//
// create texture resource
//
@ -4289,7 +4289,7 @@ HRESULT WINAPI XTL::EmuIDirect3DResource8_Register
{
EmuWarning("Expanding texture width (%d->4)", dwWidth);
dwWidth = 4;
dwMipMapLevels = 3;
}
@ -4301,15 +4301,15 @@ HRESULT WINAPI XTL::EmuIDirect3DResource8_Register
dwMipMapLevels = 3;
}
// HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK
// Since most modern graphics cards does not support
// palette based textures we need to expand it to
// ARGB texture format
if (Format == D3DFMT_P8) //Palette
{
CacheFormat = Format; // Save this for later
Format = D3DFMT_A8R8G8B8; // ARGB
}
// HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK
// Since most modern graphics cards does not support
// palette based textures we need to expand it to
// ARGB texture format
if (Format == D3DFMT_P8) //Palette
{
CacheFormat = Format; // Save this for later
Format = D3DFMT_A8R8G8B8; // ARGB
}
if(bCubemap)
{
@ -4409,69 +4409,69 @@ HRESULT WINAPI XTL::EmuIDirect3DResource8_Register
}
else
{
if (CacheFormat == D3DFMT_P8) //Palette
{
EmuWarning("Unsupported texture format D3DFMT_P8,\nexpanding to D3DFMT_A8R8G8B8");
if (CacheFormat == D3DFMT_P8) //Palette
{
EmuWarning("Unsupported texture format D3DFMT_P8,\nexpanding to D3DFMT_A8R8G8B8");
//
// create texture resource
//
BYTE *pPixelData = (BYTE*)LockedRect.pBits;
DWORD dwDataSize = dwMipWidth*dwMipHeight*4;
DWORD dwPaletteSize = 256*4; // Note: This is not allways true, it can be 256- 128- 64- or 32*4
//
// create texture resource
//
BYTE *pPixelData = (BYTE*)LockedRect.pBits;
DWORD dwDataSize = dwMipWidth*dwMipHeight*4;
DWORD dwPaletteSize = 256*4; // Note: This is not allways true, it can be 256- 128- 64- or 32*4
BYTE* pTextureCache = (BYTE*)CxbxMalloc(dwDataSize);
BYTE* pExpandedTexture = (BYTE*)CxbxMalloc(dwDataSize);
BYTE* pTexturePalette = (BYTE*)CxbxMalloc(256*4);
// First we need to unswizzle the texture data
XTL::EmuXGUnswizzleRect
(
pSrc + dwMipOffs, dwMipWidth, dwMipHeight, dwDepth, LockedRect.pBits,
LockedRect.Pitch, iRect, iPoint, dwBPP
);
BYTE* pTextureCache = (BYTE*)CxbxMalloc(dwDataSize);
BYTE* pExpandedTexture = (BYTE*)CxbxMalloc(dwDataSize);
BYTE* pTexturePalette = (BYTE*)CxbxMalloc(256*4);
// Copy the unswizzled data to a temporary buffer
memcpy(pTextureCache, pPixelData, dwDataSize);
// First we need to unswizzle the texture data
XTL::EmuXGUnswizzleRect
(
pSrc + dwMipOffs, dwMipWidth, dwMipHeight, dwDepth, LockedRect.pBits,
LockedRect.Pitch, iRect, iPoint, dwBPP
);
// Copy the currently selected palette's data to the buffer
memcpy(pTexturePalette, pCurrentPalette, dwPaletteSize);
// Copy the unswizzled data to a temporary buffer
memcpy(pTextureCache, pPixelData, dwDataSize);
unsigned int w = 0;
unsigned int c = 0;
unsigned char p = 0;
for (unsigned int y = 0;y < dwDataSize/4;y++)
{
if(c == dwMipWidth)
{
w += dwMipWidth*3;
c = 0;
}
p = (unsigned char)pTextureCache[w];
pExpandedTexture[y*4+0] = pTexturePalette[p*4+0];
pExpandedTexture[y*4+1] = pTexturePalette[p*4+1];
pExpandedTexture[y*4+2] = pTexturePalette[p*4+2];
pExpandedTexture[y*4+3] = pTexturePalette[p*4+3];
w++;
c++;
}
// Copy the expanded texture back to the buffer
memcpy(pPixelData, pExpandedTexture, dwDataSize);
// Flush unused data buffers
CxbxFree(pTexturePalette);
CxbxFree(pExpandedTexture);
CxbxFree(pTextureCache);
}
else
{
XTL::EmuXGUnswizzleRect
(
pSrc + dwMipOffs, dwMipWidth, dwMipHeight, dwDepth, LockedRect.pBits,
LockedRect.Pitch, iRect, iPoint, dwBPP
);
}
// Copy the currently selected palette's data to the buffer
memcpy(pTexturePalette, pCurrentPalette, dwPaletteSize);
unsigned int w = 0;
unsigned int c = 0;
unsigned char p = 0;
for (unsigned int y = 0;y < dwDataSize/4;y++)
{
if(c == dwMipWidth)
{
w += dwMipWidth*3;
c = 0;
}
p = (unsigned char)pTextureCache[w];
pExpandedTexture[y*4+0] = pTexturePalette[p*4+0];
pExpandedTexture[y*4+1] = pTexturePalette[p*4+1];
pExpandedTexture[y*4+2] = pTexturePalette[p*4+2];
pExpandedTexture[y*4+3] = pTexturePalette[p*4+3];
w++;
c++;
}
// Copy the expanded texture back to the buffer
memcpy(pPixelData, pExpandedTexture, dwDataSize);
// Flush unused data buffers
CxbxFree(pTexturePalette);
CxbxFree(pExpandedTexture);
CxbxFree(pTextureCache);
}
else
{
XTL::EmuXGUnswizzleRect
(
pSrc + dwMipOffs, dwMipWidth, dwMipHeight, dwDepth, LockedRect.pBits,
LockedRect.Pitch, iRect, iPoint, dwBPP
);
}
}
}
else if(bCompressed)
@ -4567,8 +4567,8 @@ HRESULT WINAPI XTL::EmuIDirect3DResource8_Register
}
}
break;
case X_D3DCOMMON_TYPE_PALETTE:
case X_D3DCOMMON_TYPE_PALETTE:
{
DbgPrintf("EmuIDirect3DResource8_Register :-> Palette...\n");
@ -4586,7 +4586,7 @@ HRESULT WINAPI XTL::EmuIDirect3DResource8_Register
pPalette->Lock = X_D3DRESOURCE_LOCK_FLAG_NOSIZE;
}
pCurrentPalette = pBase;
pCurrentPalette = pBase;
pResource->Data = (ULONG)pBase;
}
@ -5382,10 +5382,10 @@ XTL::X_D3DVertexBuffer* WINAPI XTL::EmuIDirect3DDevice8_CreateVertexBuffer2
HRESULT hRet = g_pD3DDevice8->CreateVertexBuffer
(
Length,
Length,
0,
0,
D3DPOOL_MANAGED,
D3DPOOL_MANAGED,
&pD3DVertexBuffer->EmuVertexBuffer8
);
@ -5448,7 +5448,7 @@ VOID WINAPI XTL::EmuIDirect3DDevice8_EnableOverlay
ddsd2.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT;
ddsd2.ddsCaps.dwCaps = DDSCAPS_OVERLAY;
ddsd2.dwWidth = g_dwOverlayW;
ddsd2.dwHeight = g_dwOverlayH;
ddsd2.dwHeight = g_dwOverlayH;
ddsd2.ddpfPixelFormat.dwSize = sizeof(XTL::DDPIXELFORMAT);
ddsd2.ddpfPixelFormat.dwFlags = DDPF_FOURCC;
ddsd2.ddpfPixelFormat.dwFourCC = MAKEFOURCC('Y','U','Y','2');
@ -6706,7 +6706,7 @@ HRESULT WINAPI XTL::EmuIDirect3DDevice8_SetTransform
g_bSkipPush = FALSE;
printf("SkipPush OFF\n");
}
*/
*/
State = EmuXB2PC_D3DTS(State);
@ -6802,7 +6802,7 @@ BYTE* WINAPI XTL::EmuIDirect3DVertexBuffer8_Lock2
BYTE *pbData = NULL;
HRESULT hRet = pVertexBuffer8->Lock(0, 0, &pbData, EmuXB2PC_D3DLock(Flags)); // Fixed flags check, Battlestar Galactica now displays graphics correctly
HRESULT hRet = pVertexBuffer8->Lock(0, 0, &pbData, EmuXB2PC_D3DLock(Flags)); // Fixed flags check, Battlestar Galactica now displays graphics correctly
EmuSwapFS(); // XBox FS
@ -6901,19 +6901,19 @@ HRESULT WINAPI XTL::EmuIDirect3DDevice8_SetVertexShader
" Handle : 0x%.08X\n"
");\n",
GetCurrentThreadId(), Handle);
HRESULT hRet = D3D_OK;
g_CurrentVertexShader = Handle;
/* What have you been trying to do here?
XTL::D3DXVECTOR4 vOffset;
XTL::D3DXVECTOR4 vOffset;
XTL::D3DXVECTOR4 vScale;
EmuSwapFS();
EmuIDirect3DDevice8_GetViewportOffsetAndScale(&vOffset, &vScale);
EmuSwapFS();
*/
*/
if(g_VertexShaderConstantMode != X_VSCM_NONERESERVED)
{
//g_pD3DDevice8->SetVertexShaderConstant( 58, &vScale, 1 );
@ -7044,7 +7044,7 @@ VOID WINAPI XTL::EmuIDirect3DDevice8_DrawVerticesUP
/*
// DEBUG
{
static FLOAT fixer[] =
static FLOAT fixer[] =
{
0.0f, 0.0f, 1.0f,
0.0f, 480.0f, 1.0f,
@ -7053,7 +7053,7 @@ VOID WINAPI XTL::EmuIDirect3DDevice8_DrawVerticesUP
};
DWORD *pdwVB = (DWORD*)pVertexStreamZeroData;
for(uint r=0;r<VertexCount;r++)
{
pdwVB[0] = FtoDW(fixer[r*3+0]);
@ -7069,9 +7069,9 @@ VOID WINAPI XTL::EmuIDirect3DDevice8_DrawVerticesUP
DWORD dwSpecular = pdwVB[4];
FLOAT tx = DWtoF(pdwVB[6]);
FLOAT ty = DWtoF(pdwVB[7]);
//D3DFVF_POSITION_MASK
printf("%.02d XYZ : {%.08f, %.08f, %.08f}\n", r, px, py, pz);
printf("%.02d RHW : %f\n", r, rhw);
printf("%.02d dwDiffuse : 0x%.08X\n", r, dwDiffuse);
@ -7088,7 +7088,7 @@ VOID WINAPI XTL::EmuIDirect3DDevice8_DrawVerticesUP
IDirect3DBaseTexture8 *pTexture = 0;
g_pD3DDevice8->GetTexture(0, &pTexture);
if(pTexture != NULL)
{
static int dwDumpTexture = 0;
@ -7299,7 +7299,7 @@ HRESULT WINAPI XTL::EmuIDirect3DDevice8_DrawIndexedVertices
VertPatch.Restore();
EmuSwapFS(); // XBox FS
EmuSwapFS(); // XBox FS
return D3D_OK;
}
@ -7449,7 +7449,7 @@ HRESULT WINAPI XTL::EmuIDirect3DDevice8_LightEnable
HRESULT hRet = g_pD3DDevice8->LightEnable(Index, bEnable);
EmuSwapFS(); // XBox FS
return hRet;
}
@ -7507,7 +7507,7 @@ HRESULT WINAPI XTL::EmuIDirect3DDevice8_SetRenderTarget
EmuWarning("SetRenderTarget Failed! (0x%.08X)", hRet);
EmuSwapFS(); // XBox FS
return hRet;
}
@ -7542,7 +7542,7 @@ XTL::X_D3DPalette * WINAPI XTL::EmuIDirect3DDevice8_CreatePalette2
GetCurrentThreadId(), Size);
X_D3DPalette *pPalette = new X_D3DPalette();
static int lk[4] =
{
256*sizeof(D3DCOLOR), // D3DPALETTE_256
@ -7556,7 +7556,7 @@ XTL::X_D3DPalette * WINAPI XTL::EmuIDirect3DDevice8_CreatePalette2
pPalette->Data = (DWORD)new uint08[lk[Size]];
EmuSwapFS(); // XBox FS
return pPalette;
}
@ -7606,7 +7606,7 @@ void WINAPI XTL::EmuIDirect3DDevice8_SetFlickerFilter
EmuWarning("Not setting flicker filter");
EmuSwapFS(); // XBox FS
return;
}
@ -7629,7 +7629,7 @@ void WINAPI XTL::EmuIDirect3DDevice8_SetSoftDisplayFilter
EmuWarning("Not setting soft display filter");
EmuSwapFS(); // XBox FS
return;
}
@ -7644,7 +7644,7 @@ HRESULT WINAPI XTL::EmuIDirect3DPalette8_Lock
)
{
*ppColors = EmuIDirect3DPalette8_Lock2(pThis, Flags);
return D3D_OK;
}
@ -7678,7 +7678,7 @@ XTL::D3DCOLOR * WINAPI XTL::EmuIDirect3DPalette8_Lock2
// ******************************************************************
VOID WINAPI XTL::EmuIDirect3DDevice8_GetVertexShaderSize
(
DWORD Handle,
DWORD Handle,
UINT* pSize
)
{
@ -7943,7 +7943,7 @@ HRESULT WINAPI XTL::EmuIDirect3DDevice8_SetVertexShaderInput
// ******************************************************************
VOID WINAPI XTL::EmuIDirect3DDevice8_RunVertexStateShader
(
DWORD Address,
DWORD Address,
CONST FLOAT *pData
)
{
@ -7967,7 +7967,7 @@ VOID WINAPI XTL::EmuIDirect3DDevice8_RunVertexStateShader
// ******************************************************************
VOID WINAPI XTL::EmuIDirect3DDevice8_LoadVertexShaderProgram
(
CONST DWORD *pFunction,
CONST DWORD *pFunction,
DWORD Address
)
{
@ -7991,7 +7991,7 @@ VOID WINAPI XTL::EmuIDirect3DDevice8_LoadVertexShaderProgram
// ******************************************************************
VOID WINAPI XTL::EmuIDirect3DDevice8_GetVertexShaderType
(
DWORD Handle,
DWORD Handle,
DWORD *pType
)
{
@ -8118,9 +8118,9 @@ PVOID WINAPI XTL::EmuIDirect3D8_AllocContiguousMemory
");\n",
GetCurrentThreadId(), dwSize,dwAllocAttributes);
//
//
// NOTE: Kludgey (but necessary) solution:
//
//
// Since this memory must be aligned on a page boundary, we must allocate an extra page
// so that we can return a valid page aligned pointer
//
@ -8166,7 +8166,7 @@ HRESULT WINAPI XTL::EmuIDirect3DTexture8_GetLevelDesc
EmuSwapFS(); // Xbox FS
return D3D_OK;
return D3D_OK;
}
// ******************************************************************
@ -8174,11 +8174,11 @@ HRESULT WINAPI XTL::EmuIDirect3DTexture8_GetLevelDesc
// ******************************************************************
HRESULT WINAPI XTL::EmuIDirect3D8_CheckDeviceMultiSampleType
(
UINT Adapter,
D3DDEVTYPE DeviceType,
D3DFORMAT SurfaceFormat,
BOOL Windowed,
D3DMULTISAMPLE_TYPE MultiSampleType
UINT Adapter,
D3DDEVTYPE DeviceType,
D3DFORMAT SurfaceFormat,
BOOL Windowed,
D3DMULTISAMPLE_TYPE MultiSampleType
)
{
EmuSwapFS(); // Win2k/XP FS
@ -8187,22 +8187,22 @@ HRESULT WINAPI XTL::EmuIDirect3D8_CheckDeviceMultiSampleType
"(\n"
" Adapter : 0x%.08X\n"
" DeviceType : 0x%.08X\n"
" SurfaceFormat : 0x%.08X\n"
" Windowed : 0x%.08X\n"
" MultiSampleType : 0x%.08X\n"
" SurfaceFormat : 0x%.08X\n"
" Windowed : 0x%.08X\n"
" MultiSampleType : 0x%.08X\n"
");\n",
GetCurrentThreadId(), Adapter, DeviceType, SurfaceFormat, Windowed, MultiSampleType);
if(Adapter != D3DADAPTER_DEFAULT)
{
EmuWarning("Adapter is not D3DADAPTER_DEFAULT, correcting!");
Adapter = D3DADAPTER_DEFAULT;
}
if(Adapter != D3DADAPTER_DEFAULT)
{
EmuWarning("Adapter is not D3DADAPTER_DEFAULT, correcting!");
Adapter = D3DADAPTER_DEFAULT;
}
if(DeviceType == D3DDEVTYPE_FORCE_DWORD)
EmuWarning("DeviceType == D3DDEVTYPE_FORCE_DWORD");
if(DeviceType == D3DDEVTYPE_FORCE_DWORD)
EmuWarning("DeviceType == D3DDEVTYPE_FORCE_DWORD");
// Convert SurfaceFormat (Xbox->PC)
// Convert SurfaceFormat (Xbox->PC)
D3DFORMAT PCSurfaceFormat = EmuXB2PC_D3DFormat(SurfaceFormat);
// TODO: HACK: Devices that don't support this should somehow emulate it!
@ -8222,28 +8222,28 @@ HRESULT WINAPI XTL::EmuIDirect3D8_CheckDeviceMultiSampleType
PCSurfaceFormat = D3DFMT_X8R8G8B8;
}
if(Windowed != FALSE)
Windowed = FALSE;
if(Windowed != FALSE)
Windowed = FALSE;
// TODO: Convert from Xbox to PC!!
if(MultiSampleType == 0x0011)
MultiSampleType = D3DMULTISAMPLE_NONE;
else
CxbxKrnlCleanup("EmuIDirect3D8_CheckDeviceMultiSampleType Unknown MultiSampleType! (%d)", MultiSampleType);
// TODO: Convert from Xbox to PC!!
if(MultiSampleType == 0x0011)
MultiSampleType = D3DMULTISAMPLE_NONE;
else
CxbxKrnlCleanup("EmuIDirect3D8_CheckDeviceMultiSampleType Unknown MultiSampleType! (%d)", MultiSampleType);
// Now call the real CheckDeviceMultiSampleType with the corrected parameters.
// Now call the real CheckDeviceMultiSampleType with the corrected parameters.
HRESULT hRet = g_pD3D8->CheckDeviceMultiSampleType
(
Adapter,
DeviceType,
SurfaceFormat,
Windowed,
MultiSampleType
Adapter,
DeviceType,
SurfaceFormat,
Windowed,
MultiSampleType
);
EmuSwapFS(); // Xbox FS
return hRet;
return hRet;
}
// ******************************************************************
@ -8251,9 +8251,9 @@ HRESULT WINAPI XTL::EmuIDirect3D8_CheckDeviceMultiSampleType
// ******************************************************************
HRESULT WINAPI XTL::EmuIDirect3D8_GetDeviceCaps
(
UINT Adapter,
D3DDEVTYPE DeviceType,
D3DCAPS8 *pCaps
UINT Adapter,
D3DDEVTYPE DeviceType,
D3DCAPS8 *pCaps
)
{
EmuSwapFS(); // Win2k/XP FS
@ -8261,8 +8261,8 @@ HRESULT WINAPI XTL::EmuIDirect3D8_GetDeviceCaps
DbgPrintf("EmuD3D8 (0x%X): EmuIDirect3D8_GetDeviceCaps\n"
"(\n"
" Adapter : 0x%.08X\n"
" DeviceType : 0x%.08X\n"
" pCaps : 0x%.08X\n"
" DeviceType : 0x%.08X\n"
" pCaps : 0x%.08X\n"
");\n",
GetCurrentThreadId(), Adapter, DeviceType, pCaps);
@ -8278,8 +8278,8 @@ HRESULT WINAPI XTL::EmuIDirect3D8_GetDeviceCaps
// ******************************************************************
HRESULT WINAPI XTL::EmuIDirect3D8_SetPushBufferSize
(
DWORD PushBufferSize,
DWORD KickOffSize
DWORD PushBufferSize,
DWORD KickOffSize
)
{
EmuSwapFS(); // Win2k/XP FS
@ -8287,11 +8287,11 @@ HRESULT WINAPI XTL::EmuIDirect3D8_SetPushBufferSize
DbgPrintf("EmuD3D8 (0x%X): EmuIDirect3D8_SetPushBufferSize\n"
"(\n"
" PushBufferSize : 0x%.08X\n"
" KickOffSize : 0x%.08X\n"
" KickOffSize : 0x%.08X\n"
");\n",
GetCurrentThreadId(), PushBufferSize, KickOffSize);
HRESULT hRet = D3D_OK;
HRESULT hRet = D3D_OK;
// This is a Xbox extension, meaning there is no pc counterpart.
@ -8309,8 +8309,8 @@ DWORD WINAPI XTL::EmuIDirect3DDevice8_InsertFence()
DbgPrintf("EmuD3D8 (0x%X): EmuIDirect3DDevice8_InsertFence()\n", GetCurrentThreadId());
// TODO: Actually implement this
DWORD dwRet = 0x8000BEEF;
// TODO: Actually implement this
DWORD dwRet = 0x8000BEEF;
EmuSwapFS(); // XBox FS
@ -8322,7 +8322,7 @@ DWORD WINAPI XTL::EmuIDirect3DDevice8_InsertFence()
// ******************************************************************
VOID WINAPI XTL::EmuIDirect3DDevice8_BlockOnFence
(
DWORD Fence
DWORD Fence
)
{
EmuSwapFS(); // Win2k/XP FS
@ -8333,7 +8333,7 @@ VOID WINAPI XTL::EmuIDirect3DDevice8_BlockOnFence
");\n",
GetCurrentThreadId(), Fence);
// TODO: Implement
// TODO: Implement
EmuSwapFS(); // XBox FS
}
@ -8343,18 +8343,18 @@ VOID WINAPI XTL::EmuIDirect3DDevice8_BlockOnFence
// ******************************************************************
VOID WINAPI XTL::EmuIDirect3DResource8_BlockUntilNotBusy
(
X_D3DResource *pThis
X_D3DResource *pThis
)
{
EmuSwapFS(); // Win2k/XP FS
DbgPrintf("EmuD3D8 (0x%X): EmuIDirect3DResource8_BlockUntilNotBusy\n"
"(\n"
" pThis : 0x%.08X\n"
" pThis : 0x%.08X\n"
");\n",
GetCurrentThreadId(), pThis);
// TODO: Implement
// TODO: Implement
EmuSwapFS(); // XBox FS
}
@ -8364,20 +8364,20 @@ VOID WINAPI XTL::EmuIDirect3DResource8_BlockUntilNotBusy
// ******************************************************************
VOID WINAPI XTL::EmuIDirect3DVertexBuffer8_GetDesc
(
X_D3DVertexBuffer *pThis,
D3DVERTEXBUFFER_DESC *pDesc
X_D3DVertexBuffer *pThis,
D3DVERTEXBUFFER_DESC *pDesc
)
{
EmuSwapFS(); // Win2k/XP FS
DbgPrintf("EmuD3D8 (0x%X): EmuIDirect3DVertexBuffer8_GetDesc\n"
"(\n"
" pThis : 0x%.08X\n"
" pDesc : 0x%.08X\n"
" pThis : 0x%.08X\n"
" pDesc : 0x%.08X\n"
");\n",
GetCurrentThreadId(), pThis, pDesc);
// TODO: Implement
// TODO: Implement
EmuSwapFS(); // XBox FS
}
@ -8387,24 +8387,24 @@ VOID WINAPI XTL::EmuIDirect3DVertexBuffer8_GetDesc
// ******************************************************************
HRESULT WINAPI XTL::EmuIDirect3DDevice8_SetScissors
(
DWORD Count,
BOOL Exclusive,
CONST D3DRECT *pRects
DWORD Count,
BOOL Exclusive,
CONST D3DRECT *pRects
)
{
EmuSwapFS(); // Win2k/XP FS
DbgPrintf("EmuD3D8 (0x%X): EmuIDirect3DDevice8_SetScissors\n"
"(\n"
" Count : 0x%.08X\n"
" Exclusive : 0x%.08X\n"
" pRects : 0x%.08X\n"
" Count : 0x%.08X\n"
" Exclusive : 0x%.08X\n"
" pRects : 0x%.08X\n"
");\n",
GetCurrentThreadId(), Count, Exclusive, pRects);
// TODO: Implement
// TODO: Implement
EmuSwapFS(); // XBox FS
return D3D_OK;
return D3D_OK;
}

48
src/CxbxKrnl/EmuD3D8.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuD3D8.h
@ -1365,7 +1365,7 @@ D3DCOLOR * WINAPI EmuIDirect3DPalette8_Lock2
// ******************************************************************
VOID WINAPI EmuIDirect3DDevice8_GetVertexShaderSize
(
DWORD Handle,
DWORD Handle,
UINT* pSize
);
@ -1456,7 +1456,7 @@ VOID WINAPI EmuIDirect3DDevice8_RunVertexStateShader
// ******************************************************************
VOID WINAPI EmuIDirect3DDevice8_LoadVertexShaderProgram
(
CONST DWORD *pFunction,
CONST DWORD *pFunction,
DWORD Address
);
@ -1465,7 +1465,7 @@ VOID WINAPI EmuIDirect3DDevice8_LoadVertexShaderProgram
// ******************************************************************
VOID WINAPI EmuIDirect3DDevice8_GetVertexShaderType
(
DWORD Handle,
DWORD Handle,
DWORD *pType
);
@ -1512,11 +1512,11 @@ HRESULT WINAPI EmuIDirect3DTexture8_GetLevelDesc
// ******************************************************************
HRESULT WINAPI EmuIDirect3D8_CheckDeviceMultiSampleType
(
UINT Adapter,
D3DDEVTYPE DeviceType,
D3DFORMAT SurfaceFormat,
BOOL Windowed,
D3DMULTISAMPLE_TYPE MultiSampleType
UINT Adapter,
D3DDEVTYPE DeviceType,
D3DFORMAT SurfaceFormat,
BOOL Windowed,
D3DMULTISAMPLE_TYPE MultiSampleType
);
// ******************************************************************
@ -1524,9 +1524,9 @@ HRESULT WINAPI EmuIDirect3D8_CheckDeviceMultiSampleType
// ******************************************************************
HRESULT WINAPI EmuIDirect3D8_GetDeviceCaps
(
UINT Adapter,
D3DDEVTYPE DeviceType,
D3DCAPS8 *pCaps
UINT Adapter,
D3DDEVTYPE DeviceType,
D3DCAPS8 *pCaps
);
// ******************************************************************
@ -1534,8 +1534,8 @@ HRESULT WINAPI EmuIDirect3D8_GetDeviceCaps
// ******************************************************************
HRESULT WINAPI EmuIDirect3D8_SetPushBufferSize
(
DWORD PushBufferSize,
DWORD KickOffSize
DWORD PushBufferSize,
DWORD KickOffSize
);
// ******************************************************************
@ -1548,7 +1548,7 @@ DWORD WINAPI EmuIDirect3DDevice8_InsertFence();
// ******************************************************************
VOID WINAPI EmuIDirect3DDevice8_BlockOnFence
(
DWORD Fence
DWORD Fence
);
// ******************************************************************
@ -1556,7 +1556,7 @@ VOID WINAPI EmuIDirect3DDevice8_BlockOnFence
// ******************************************************************
VOID WINAPI EmuIDirect3DResource8_BlockUntilNotBusy
(
X_D3DResource *pThis
X_D3DResource *pThis
);
// ******************************************************************
@ -1564,8 +1564,8 @@ VOID WINAPI EmuIDirect3DResource8_BlockUntilNotBusy
// ******************************************************************
VOID WINAPI EmuIDirect3DVertexBuffer8_GetDesc
(
X_D3DVertexBuffer *pThis,
D3DVERTEXBUFFER_DESC *pDesc
X_D3DVertexBuffer *pThis,
D3DVERTEXBUFFER_DESC *pDesc
);
// ******************************************************************
@ -1573,9 +1573,9 @@ VOID WINAPI EmuIDirect3DVertexBuffer8_GetDesc
// ******************************************************************
HRESULT WINAPI EmuIDirect3DDevice8_SetScissors
(
DWORD Count,
BOOL Exclusive,
CONST D3DRECT *pRects
DWORD Count,
BOOL Exclusive,
CONST D3DRECT *pRects
);
#endif

52
src/CxbxKrnl/EmuD3D8/Convert.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuD3D8->Convert.cpp
@ -103,7 +103,7 @@ XTL::D3DFORMAT XTL::EmuXB2PC_D3DFormat(X_D3DFORMAT Format)
case 0x16: // Linear (X_D3DFMT_LIN_R8B8)
{
EmuWarning("X_D3DFMT_LIN_R8B8 -> D3DFMT_R5G6B5");
return D3DFMT_R5G6B5; // NOTE: HACK: Totally and utterly wrong :)
return D3DFMT_R5G6B5; // NOTE: HACK: Totally and utterly wrong :)
}
case 0x3F: // Linear (X_D3DFMT_LIN_A8B8G8R8)
{
@ -193,25 +193,25 @@ XTL::X_D3DFORMAT XTL::EmuPC2XB_D3DFormat(D3DFORMAT Format)
DWORD XTL::EmuXB2PC_D3DLock(DWORD Flags)
{
DWORD NewFlags = 0;
DWORD NewFlags = 0;
// Need to convert the flags, TODO: fix the xbox extensions
if(Flags & X_D3DLOCK_NOFLUSH)
{
NewFlags ^= 0;
}
if(Flags & X_D3DLOCK_NOOVERWRITE)
{
NewFlags ^= D3DLOCK_NOOVERWRITE;
}
if(Flags & X_D3DLOCK_TILED)
{
NewFlags ^= 0;
}
if(Flags & X_D3DLOCK_READONLY)
{
NewFlags ^= D3DLOCK_READONLY;
}
// Need to convert the flags, TODO: fix the xbox extensions
if(Flags & X_D3DLOCK_NOFLUSH)
{
NewFlags ^= 0;
}
if(Flags & X_D3DLOCK_NOOVERWRITE)
{
NewFlags ^= D3DLOCK_NOOVERWRITE;
}
if(Flags & X_D3DLOCK_TILED)
{
NewFlags ^= 0;
}
if(Flags & X_D3DLOCK_READONLY)
{
NewFlags ^= D3DLOCK_READONLY;
}
return NewFlags;
}
@ -233,7 +233,7 @@ UINT XTL::EmuD3DVertexToPrimitive[11][2] =
};
// conversion table for xbox->pc primitive types
XTL::D3DPRIMITIVETYPE XTL::EmuPrimitiveTypeLookup[] =
XTL::D3DPRIMITIVETYPE XTL::EmuPrimitiveTypeLookup[] =
{
/* NULL = 0 */ (XTL::D3DPRIMITIVETYPE)0,
/* D3DPT_POINTLIST = 1, */ XTL::D3DPT_POINTLIST,
@ -258,7 +258,7 @@ CONST DWORD XTL::EmuD3DRenderStateSimpleEncoded[174] =
X_D3DRSSE_UNK, X_D3DRSSE_UNK, // 0
X_D3DRSSE_UNK, X_D3DRSSE_UNK, // 2
X_D3DRSSE_UNK, X_D3DRSSE_UNK, // 4
X_D3DRSSE_UNK, X_D3DRSSE_UNK, // 6
X_D3DRSSE_UNK, X_D3DRSSE_UNK, // 6
X_D3DRSSE_UNK, 0x0004037c, // 8 - D3DRS_SHADEMODE
X_D3DRSSE_UNK, X_D3DRSSE_UNK, // 10
X_D3DRSSE_UNK, X_D3DRSSE_UNK, // 12
@ -272,7 +272,7 @@ CONST DWORD XTL::EmuD3DRenderStateSimpleEncoded[174] =
X_D3DRSSE_UNK, X_D3DRSSE_UNK, // 28
X_D3DRSSE_UNK, X_D3DRSSE_UNK, // 30
X_D3DRSSE_UNK, X_D3DRSSE_UNK, // 32
X_D3DRSSE_UNK, X_D3DRSSE_UNK, // 34
X_D3DRSSE_UNK, X_D3DRSSE_UNK, // 34
X_D3DRSSE_UNK, X_D3DRSSE_UNK, // 36
X_D3DRSSE_UNK, X_D3DRSSE_UNK, // 38
X_D3DRSSE_UNK, X_D3DRSSE_UNK, // 40

8
src/CxbxKrnl/EmuD3D8/Convert.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuD3D8->Convert.h

14
src/CxbxKrnl/EmuD3D8/PushBuffer.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuD3D->PushBuffer.cpp
@ -523,9 +523,9 @@ extern void XTL::EmuExecutePushBufferRaw
DbgDumpMesh((WORD*)pIndexData, dwCount);
}
#endif
pdwPushData += (dwCount/2) - (bInc ? 0 : 2);
// perform rendering
{
HRESULT hRet;
@ -723,7 +723,7 @@ void DbgDumpMesh(WORD *pIndexData, DWORD dwCount)
uint max = maxIndex+1;
for(uint v=0;v<max;v++)
{
fprintf(dbgVertices, " %f;%f;%f;%s\n",
fprintf(dbgVertices, " %f;%f;%f;%s\n",
*(FLOAT*)&pVBData[v*uiStride+0],
*(FLOAT*)&pVBData[v*uiStride+4],
*(FLOAT*)&pVBData[v*uiStride+8],

8
src/CxbxKrnl/EmuD3D8/PushBuffer.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuD3D8->PushBuffer.h

42
src/CxbxKrnl/EmuD3D8/State.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuD3D->State.cpp
@ -66,7 +66,7 @@ void XTL::EmuUpdateDeferredStates()
if(XTL::EmuD3DDeferredRenderState[6] != X_D3DRS_UNK)
{
::DWORD dwConv = 0;
dwConv |= (XTL::EmuD3DDeferredRenderState[6] & 0x00000010) ? D3DWRAP_U : 0;
dwConv |= (XTL::EmuD3DDeferredRenderState[6] & 0x00001000) ? D3DWRAP_V : 0;
dwConv |= (XTL::EmuD3DDeferredRenderState[6] & 0x00100000) ? D3DWRAP_W : 0;
@ -91,14 +91,14 @@ void XTL::EmuUpdateDeferredStates()
if(XTL::EmuD3DDeferredRenderState[24] != X_D3DRS_UNK)
g_pD3DDevice8->SetRenderState(D3DRS_POINTSIZE, XTL::EmuD3DDeferredRenderState[24]);
if(XTL::EmuD3DDeferredRenderState[25] != X_D3DRS_UNK)
if(XTL::EmuD3DDeferredRenderState[25] != X_D3DRS_UNK)
g_pD3DDevice8->SetRenderState(D3DRS_POINTSIZE_MIN, XTL::EmuD3DDeferredRenderState[25]);
if(XTL::EmuD3DDeferredRenderState[26] != X_D3DRS_UNK)
if(XTL::EmuD3DDeferredRenderState[26] != X_D3DRS_UNK)
g_pD3DDevice8->SetRenderState(D3DRS_POINTSPRITEENABLE, XTL::EmuD3DDeferredRenderState[26]);
if(XTL::EmuD3DDeferredRenderState[27] != X_D3DRS_UNK)
if(XTL::EmuD3DDeferredRenderState[27] != X_D3DRS_UNK)
g_pD3DDevice8->SetRenderState(D3DRS_POINTSCALEENABLE, XTL::EmuD3DDeferredRenderState[27]);
if(XTL::EmuD3DDeferredRenderState[28] != X_D3DRS_UNK)
@ -121,7 +121,7 @@ void XTL::EmuUpdateDeferredStates()
{
if(XTL::EmuD3DDeferredRenderState[v] != X_D3DRS_UNK)
{
if(v != 0 && v != 1 && v != 2 && v != 3 && v != 6 && v != 10 && v != 11 && v != 13
if(v != 0 && v != 1 && v != 2 && v != 3 && v != 6 && v != 10 && v != 11 && v != 13
&& v != 20 && v != 23 && v != 24 && v != 25 && v != 26 && v != 27 && v != 28 && v != 29
&& v != 30 && v != 31 && v != 33)
EmuWarning("Unhandled RenderState Change @ %d (%d)", v, v + 82);
@ -226,7 +226,7 @@ void XTL::EmuUpdateDeferredStates()
if(pCur[18] != X_D3DTSS_UNK)
g_pD3DDevice8->SetTextureStageState(v, D3DTSS_ALPHAARG1, pCur[18]);
if(pCur[19] != X_D3DTSS_UNK)
g_pD3DDevice8->SetTextureStageState(v, D3DTSS_ALPHAARG2, pCur[19]);
@ -242,7 +242,7 @@ void XTL::EmuUpdateDeferredStates()
/** To check for unhandled texture stage state changes
for(int r=0;r<32;r++)
{
static const int unchecked[] =
static const int unchecked[] =
{
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 29, 30, 31
};
@ -275,17 +275,17 @@ void XTL::EmuUpdateDeferredStates()
IDirect3DBaseTexture8 *pTexture;
// set the point sprites texture
g_pD3DDevice8->GetTexture(3, &pTexture);
g_pD3DDevice8->SetTexture(0, pTexture);
// set the point sprites texture
g_pD3DDevice8->GetTexture(3, &pTexture);
g_pD3DDevice8->SetTexture(0, pTexture);
// disable all other stages
g_pD3DDevice8->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
g_pD3DDevice8->SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
// disable all other stages
g_pD3DDevice8->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
g_pD3DDevice8->SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
// in that case we have to copy over the stage by hand
for(int v=0;v<30;v++)
{
{
if(pCur[v] != X_D3DTSS_UNK)
{
::DWORD dwValue;
@ -293,7 +293,7 @@ void XTL::EmuUpdateDeferredStates()
g_pD3DDevice8->GetTextureStageState(3, (D3DTEXTURESTAGESTATETYPE)v, &dwValue);
g_pD3DDevice8->SetTextureStageState(0, (D3DTEXTURESTAGESTATETYPE)v, dwValue);
}
}
}
}
}

8
src/CxbxKrnl/EmuD3D8/State.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuD3D8->State.h

10
src/CxbxKrnl/EmuD3D8/VertexBuffer.cpp
View File

@ -84,7 +84,7 @@ static unsigned int CRC32(unsigned char *data, int len)
{
unsigned int result;
int i;;
if(len < 4) abort();
result = *data++ << 24;
@ -93,12 +93,12 @@ static unsigned int CRC32(unsigned char *data, int len)
result |= *data++;
result = ~ result;
len -=4;
for(i=0; i<len; i++)
{
result = (result << 8 | *data++) ^ crctab[result >> 24];
}
return ~result;
}
@ -1173,7 +1173,7 @@ VOID XTL::EmuFlushIVB()
IDirect3DBaseTexture8 *pTexture = 0;
g_pD3DDevice8->GetTexture(0, &pTexture);
if(pTexture != NULL)
{
static int dwDumpTexture = 0;
@ -1431,7 +1431,7 @@ VOID XTL::EmuUpdateActiveTexture()
{
XTL::EmuXGUnswizzleRect
(
pSrc + dwMipOffs, dwMipWidth, dwMipHeight, dwDepth, LockedRect.pBits,
pSrc + dwMipOffs, dwMipWidth, dwMipHeight, dwDepth, LockedRect.pBits,
LockedRect.Pitch, iRect, iPoint, dwBPP
);
}

8
src/CxbxKrnl/EmuD3D8/VertexBuffer.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuD3D8->VertexBuffer.h

22
src/CxbxKrnl/EmuD3D8/VertexShader.cpp
View File

@ -276,7 +276,7 @@ VSH_IMD_PARAMETER;
typedef struct _VSH_INTERMEDIATE_FORMAT
{
boolean IsCombined;
VSH_IMD_INSTRUCTION_TYPE InstructionType;
VSH_MAC MAC;
@ -384,7 +384,7 @@ static const VSH_OPCODE_PARAMS g_OpCodeParams[] =
{ ILU_NOP, MAC_ARL, TRUE, FALSE, FALSE }
};
static const char* MAC_OpCode[] =
static const char* MAC_OpCode[] =
{
"nop",
"mov",
@ -404,7 +404,7 @@ static const char* MAC_OpCode[] =
"???"
};
static const char* ILU_OpCode[] =
static const char* ILU_OpCode[] =
{
"nop",
"mov",
@ -448,14 +448,14 @@ static inline boolean HasMACR(VSH_SHADER_INSTRUCTION *pInstruction)
static inline boolean HasMACO(VSH_SHADER_INSTRUCTION *pInstruction)
{
return IsInUse(pInstruction->Output.OutputMask) &&
return IsInUse(pInstruction->Output.OutputMask) &&
pInstruction->Output.OutputMux == OMUX_MAC &&
pInstruction->MAC != MAC_NOP;
}
static inline boolean HasMACARL(VSH_SHADER_INSTRUCTION *pInstruction)
{
return /*!IsInUse(pInstruction->Output.OutputMask) &&
return /*!IsInUse(pInstruction->Output.OutputMask) &&
pInstruction->Output.OutputMux == OMUX_MAC &&*/
pInstruction->MAC == MAC_ARL;
}
@ -467,7 +467,7 @@ static inline boolean HasILUR(VSH_SHADER_INSTRUCTION *pInstruction)
static inline boolean HasILUO(VSH_SHADER_INSTRUCTION *pInstruction)
{
return IsInUse(pInstruction->Output.OutputMask) &&
return IsInUse(pInstruction->Output.OutputMask) &&
pInstruction->Output.OutputMux == OMUX_ILU &&
pInstruction->ILU != ILU_NOP;
}
@ -861,7 +861,7 @@ static void VshInsertIntermediate(VSH_XBOX_SHADER *pShader,
uint16 Pos)
{
VshVerifyBufferBounds(pShader);
for (int i = pShader->IntermediateCount; i >= Pos; i--)
{
pShader->Intermediate[i + 1] = pShader->Intermediate[i];
@ -1135,7 +1135,7 @@ static void VshRemoveScreenSpaceInstructions(VSH_XBOX_SHADER *pShader)
if(pIntermediate1W->InstructionType == IMD_ILU &&
pIntermediate1W->ILU == ILU_RCC &&
pIntermediate1W->Output.Type == IMD_OUTPUT_R &&
pIntermediate1W->Output.Address ==
pIntermediate1W->Output.Address ==
pIntermediate->Parameters[1].Parameter.Address)
{
DbgVshPrintf("Deleted +rcc r1.x, r12.w\n");
@ -1640,7 +1640,7 @@ static void VshConvertToken_STREAMDATA_REG(DWORD *pToken,
break;
case 0x22:
DbgVshPrintf("D3DVSDT_FLOAT2");
NewDataType = D3DVSDT_FLOAT2;
NewDataType = D3DVSDT_FLOAT2;
pPatchData->ConvertedStride += 2*sizeof(FLOAT);
break;
case 0x32:
@ -1655,7 +1655,7 @@ static void VshConvertToken_STREAMDATA_REG(DWORD *pToken,
break;
case 0x40:
DbgVshPrintf("D3DVSDT_D3DCOLOR");
NewDataType = D3DVSDT_D3DCOLOR;
NewDataType = D3DVSDT_D3DCOLOR;
pPatchData->ConvertedStride += sizeof(D3DCOLOR);
break;
case 0x25:
@ -1823,7 +1823,7 @@ static DWORD VshRecompileToken(DWORD *pToken,
DWORD XTL::EmuRecompileVshDeclaration
(
DWORD *pDeclaration,
DWORD *pDeclaration,
DWORD **ppRecompiledDeclaration,
DWORD *pDeclarationSize,
boolean IsFixedFunction,

10
src/CxbxKrnl/EmuD3D8/VertexShader.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuD3D8->VertexShader.h
@ -52,7 +52,7 @@ VSH_SHADER_HEADER;
// recompile xbox vertex shader declaration
extern DWORD EmuRecompileVshDeclaration
(
DWORD *pDeclaration,
DWORD *pDeclaration,
DWORD **ppRecompiledDeclaration,
DWORD *pDeclarationSize,
boolean IsFixedFunction,

14
src/CxbxKrnl/EmuD3D8Types.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuD3D8Types.h
@ -34,7 +34,7 @@
#ifndef EMUD3D8TYPES_H
#define EMUD3D8TYPES_H
// include direct3d 8x headers
// include direct3d 8x headers
#define DIRECT3D_VERSION 0x0800
#include <d3d8.h>
#include <d3dx8tex.h>
@ -120,7 +120,7 @@ typedef struct _X_D3DPRESENT_PARAMETERS
BOOL EnableAutoDepthStencil;
X_D3DFORMAT AutoDepthStencilFormat;
DWORD Flags;
UINT FullScreen_RefreshRateInHz;
UINT FullScreen_RefreshRateInHz;
UINT FullScreen_PresentationInterval;
IDirect3DSurface8 *BufferSurfaces[3];
IDirect3DSurface8 *DepthStencilSurface;
@ -297,7 +297,7 @@ struct X_D3DPixelContainer : public X_D3DResource
#define X_D3DFORMAT_DIMENSION_SHIFT 4
#define X_D3DFORMAT_FORMAT_MASK 0x0000FF00
#define X_D3DFORMAT_FORMAT_SHIFT 8
#define X_D3DFORMAT_MIPMAP_MASK 0x000F0000
#define X_D3DFORMAT_MIPMAP_MASK 0x000F0000
#define X_D3DFORMAT_MIPMAP_SHIFT 16
#define X_D3DFORMAT_USIZE_MASK 0x00F00000 // Log 2 of the U size of the base texture
#define X_D3DFORMAT_USIZE_SHIFT 20

8
src/CxbxKrnl/EmuDInput.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuDInput.cpp

24
src/CxbxKrnl/EmuDInput.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuDInput.h
@ -55,14 +55,14 @@ extern void EmuDInputPoll(PXINPUT_STATE Controller);
// ******************************************************************
// * offsets into analog button array
// ******************************************************************
#define XINPUT_GAMEPAD_A 0
#define XINPUT_GAMEPAD_B 1
#define XINPUT_GAMEPAD_X 2
#define XINPUT_GAMEPAD_Y 3
#define XINPUT_GAMEPAD_BLACK 4
#define XINPUT_GAMEPAD_WHITE 5
#define XINPUT_GAMEPAD_LEFT_TRIGGER 6
#define XINPUT_GAMEPAD_RIGHT_TRIGGER 7
#define XINPUT_GAMEPAD_A 0
#define XINPUT_GAMEPAD_B 1
#define XINPUT_GAMEPAD_X 2
#define XINPUT_GAMEPAD_Y 3
#define XINPUT_GAMEPAD_BLACK 4
#define XINPUT_GAMEPAD_WHITE 5
#define XINPUT_GAMEPAD_LEFT_TRIGGER 6
#define XINPUT_GAMEPAD_RIGHT_TRIGGER 7
// ******************************************************************
// * masks for digital buttons

96
src/CxbxKrnl/EmuDSound.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuDSound.cpp
@ -52,7 +52,7 @@ namespace xboxkrnl
#include <process.h>
#include <locale.h>
XTL::X_CMcpxStream::_vtbl XTL::X_CMcpxStream::vtbl =
XTL::X_CMcpxStream::_vtbl XTL::X_CMcpxStream::vtbl =
{
0xBEEFC001, // 0x00
0xBEEFC002, // 0x04
@ -61,7 +61,7 @@ XTL::X_CMcpxStream::_vtbl XTL::X_CMcpxStream::vtbl =
&XTL::EmuCMcpxStream_Dummy_0x10,// 0x10
};
XTL::X_CDirectSoundStream::_vtbl XTL::X_CDirectSoundStream::vtbl =
XTL::X_CDirectSoundStream::_vtbl XTL::X_CDirectSoundStream::vtbl =
{
&XTL::EmuCDirectSoundStream_AddRef, // 0x00
&XTL::EmuCDirectSoundStream_Release, // 0x04
@ -785,7 +785,7 @@ HRESULT WINAPI XTL::EmuDirectSoundCreateBuffer
DWORD dwEmuFlags = 0;
DSBUFFERDESC *pDSBufferDesc = (DSBUFFERDESC*)CxbxMalloc(sizeof(DSBUFFERDESC));
// convert from Xbox to PC DSound
{
DWORD dwAcceptableMask = 0x00000010 | 0x00000020 | 0x00000080 | 0x00000100 | 0x00002000 | 0x00040000 | 0x00080000;
@ -799,7 +799,7 @@ HRESULT WINAPI XTL::EmuDirectSoundCreateBuffer
if(pDSBufferDesc->dwBufferBytes < DSBSIZE_MIN)
pDSBufferDesc->dwBufferBytes = DSBSIZE_MIN;
else if(pDSBufferDesc->dwBufferBytes > DSBSIZE_MAX)
else if(pDSBufferDesc->dwBufferBytes > DSBSIZE_MAX)
pDSBufferDesc->dwBufferBytes = DSBSIZE_MAX;
pDSBufferDesc->dwReserved = 0;
@ -1010,13 +1010,13 @@ HRESULT WINAPI XTL::EmuIDirectSoundBuffer8_SetPlayRegion
HRESULT WINAPI XTL::EmuIDirectSoundBuffer8_Lock
(
X_CDirectSoundBuffer *pThis,
DWORD dwOffset,
DWORD dwBytes,
LPVOID *ppvAudioPtr1,
LPDWORD pdwAudioBytes1,
LPVOID *ppvAudioPtr2,
LPDWORD pdwAudioBytes2,
DWORD dwFlags
DWORD dwOffset,
DWORD dwBytes,
LPVOID *ppvAudioPtr1,
LPDWORD pdwAudioBytes1,
LPVOID *ppvAudioPtr2,
LPDWORD pdwAudioBytes2,
DWORD dwFlags
)
{
EmuSwapFS(); // Win2k/XP FS
@ -1334,7 +1334,7 @@ HRESULT WINAPI XTL::EmuIDirectSoundBuffer8_Play
pThis->EmuLockPtr1 = 0;
}
HRESULT hRet;
if(pThis->EmuFlags & DSB_FLAG_ADPCM)
@ -1481,9 +1481,9 @@ HRESULT WINAPI XTL::EmuDirectSoundCreateStream
// TODO: Garbage Collection
*ppStream = new X_CDirectSoundStream();
DSBUFFERDESC *pDSBufferDesc = (DSBUFFERDESC*)CxbxMalloc(sizeof(DSBUFFERDESC));
// convert from Xbox to PC DSound
{
DWORD dwAcceptableMask = 0x00000010; // TODO: Note 0x00040000 is being ignored (DSSTREAMCAPS_LOCDEFER)
@ -1509,8 +1509,8 @@ HRESULT WINAPI XTL::EmuDirectSoundCreateStream
if(pDSBufferDesc->lpwfxFormat != NULL && pDSBufferDesc->lpwfxFormat->wFormatTag != WAVE_FORMAT_PCM)
{
EmuWarning("Invalid WAVE_FORMAT!");
if(pDSBufferDesc->lpwfxFormat->wFormatTag == /*WAVE_FORMAT_XBOX_ADPCM*/0x0069)
EmuWarning("WAVE_FORMAT_XBOX_ADPCM Unsupported!");
if(pDSBufferDesc->lpwfxFormat->wFormatTag == /*WAVE_FORMAT_XBOX_ADPCM*/0x0069)
EmuWarning("WAVE_FORMAT_XBOX_ADPCM Unsupported!");
(*ppStream)->EmuDirectSoundBuffer8 = 0;
@ -2543,7 +2543,7 @@ HRESULT WINAPI XTL::EmuIDirectSoundBuffer8_SetI3DL2Source
// ******************************************************************
HRESULT WINAPI XTL::EmuIDirectSoundBuffer8_SetFormat
(
X_CDirectSoundBuffer *pBuffer,
X_CDirectSoundBuffer *pBuffer,
LPCWAVEFORMATEX pwfxFormat
)
{
@ -2573,7 +2573,7 @@ HRESULT WINAPI XTL::EmuIDirectSoundBuffer8_SetFormat
// ******************************************************************
STDAPI_(void) EmuDirectSoundUseFullHRTF
(
void
void
)
{
EmuSwapFS(); // Win2k/XP FS
@ -2590,8 +2590,8 @@ STDAPI_(void) EmuDirectSoundUseFullHRTF
// ******************************************************************
HRESULT WINAPI XTL::EmuIDirectSoundBuffer8_SetLFO
(
LPDIRECTSOUNDBUFFER pThis,
LPCDSLFODESC pLFODesc
LPDIRECTSOUNDBUFFER pThis,
LPCDSLFODESC pLFODesc
)
{
EmuSwapFS(); // Win2k/XP FS
@ -2603,7 +2603,7 @@ HRESULT WINAPI XTL::EmuIDirectSoundBuffer8_SetLFO
");\n",
GetCurrentThreadId(), pThis, pLFODesc);
// TODO: Implement
// TODO: Implement
EmuSwapFS(); // XBox FS
@ -2615,9 +2615,9 @@ HRESULT WINAPI XTL::EmuIDirectSoundBuffer8_SetLFO
// ******************************************************************
VOID WINAPI XTL::EmuXAudioCreateAdpcmFormat
(
WORD nChannels,
DWORD nSamplesPerSec,
LPXBOXADPCMWAVEFORMAT pwfx
WORD nChannels,
DWORD nSamplesPerSec,
LPXBOXADPCMWAVEFORMAT pwfx
)
{
EmuSwapFS(); // Win2k/XP FS
@ -2630,15 +2630,15 @@ VOID WINAPI XTL::EmuXAudioCreateAdpcmFormat
");\n",
GetCurrentThreadId(), nChannels, nSamplesPerSec, pwfx);
// Fill out the pwfx structure with the appropriate data
pwfx->wfx.wFormatTag = WAVE_FORMAT_XBOX_ADPCM;
pwfx->wfx.nChannels = nChannels;
pwfx->wfx.nSamplesPerSec = nSamplesPerSec;
pwfx->wfx.nAvgBytesPerSec = (nSamplesPerSec*nChannels * 36)/64;
pwfx->wfx.nBlockAlign = nChannels * 36;
pwfx->wfx.wBitsPerSample = 4;
pwfx->wfx.cbSize = 2;
pwfx->wSamplesPerBlock = 64;
// Fill out the pwfx structure with the appropriate data
pwfx->wfx.wFormatTag = WAVE_FORMAT_XBOX_ADPCM;
pwfx->wfx.nChannels = nChannels;
pwfx->wfx.nSamplesPerSec = nSamplesPerSec;
pwfx->wfx.nAvgBytesPerSec = (nSamplesPerSec*nChannels * 36)/64;
pwfx->wfx.nBlockAlign = nChannels * 36;
pwfx->wfx.wBitsPerSample = 4;
pwfx->wfx.cbSize = 2;
pwfx->wSamplesPerBlock = 64;
EmuSwapFS(); // XBox FS
}
@ -2648,10 +2648,10 @@ VOID WINAPI XTL::EmuXAudioCreateAdpcmFormat
// ******************************************************************
HRESULT WINAPI XTL::EmuIDirectSoundBuffer8_SetRolloffCurve
(
LPDIRECTSOUNDBUFFER pThis,
const FLOAT *pflPoints,
DWORD dwPointCount,
DWORD dwApply
LPDIRECTSOUNDBUFFER pThis,
const FLOAT *pflPoints,
DWORD dwPointCount,
DWORD dwApply
)
{
EmuSwapFS(); // Win2k/XP FS
@ -2661,15 +2661,15 @@ HRESULT WINAPI XTL::EmuIDirectSoundBuffer8_SetRolloffCurve
" pThis : 0x%.08X\n"
" pflPoints : 0x%.08X\n"
" dwPointCount : 0x%.08X\n"
" dwApply : 0x%.08X\n"
" dwApply : 0x%.08X\n"
");\n",
GetCurrentThreadId(), pThis, pflPoints, dwPointCount, dwApply);
// TODO: Implement
// TODO: Implement
EmuSwapFS(); // XBox FS
return DS_OK;
return DS_OK;
}
// ******************************************************************
@ -2677,8 +2677,8 @@ HRESULT WINAPI XTL::EmuIDirectSoundBuffer8_SetRolloffCurve
// ******************************************************************
HRESULT WINAPI XTL::EmuIDirectSoundStream_SetVolume
(
LPDIRECTSOUNDSTREAM pStream,
LONG lVolume
LPDIRECTSOUNDSTREAM pStream,
LONG lVolume
)
{
EmuSwapFS(); // Win2k/XP FS
@ -2690,9 +2690,9 @@ HRESULT WINAPI XTL::EmuIDirectSoundStream_SetVolume
");\n",
GetCurrentThreadId(), pStream, lVolume);
// TODO: Implement
// TODO: Implement
EmuSwapFS(); // XBox FS
return DS_OK;
return DS_OK;
}

78
src/CxbxKrnl/EmuDSound.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuDSound.h
@ -46,10 +46,10 @@
// ******************************************************************
struct X_DSBUFFERDESC
{
DWORD dwSize;
DWORD dwFlags;
DWORD dwBufferBytes;
LPWAVEFORMATEX lpwfxFormat;
DWORD dwSize;
DWORD dwFlags;
DWORD dwBufferBytes;
LPWAVEFORMATEX lpwfxFormat;
LPVOID lpMixBins; // TODO: Implement
DWORD dwInputMixBin;
};
@ -65,7 +65,7 @@ struct X_DSSTREAMDESC
PVOID lpfnCallback; // TODO: Correct Parameter
LPVOID lpvContext;
PVOID lpMixBins; // TODO: Correct Parameter
};
};
// ******************************************************************
// * REFERENCE_TIME
@ -94,19 +94,19 @@ XMEDIAPACKET, *PXMEDIAPACKET, *LPXMEDIAPACKET;
// ******************************************************************
typedef struct _DSLFODESC
{
DWORD dwLFO;
DWORD dwDelay;
DWORD dwDelta;
LONG lPitchModulation;
LONG lFilterCutOffRange;
LONG lAmplitudeModulation;
DWORD dwLFO;
DWORD dwDelay;
DWORD dwDelta;
LONG lPitchModulation;
LONG lFilterCutOffRange;
LONG lAmplitudeModulation;
}
DSLFODESC, *LPCDSLFODESC;
// ******************************************************************
// * XBOXADPCMWAVEFORMAT
// ******************************************************************
typedef struct xbox_adpcmwaveformat_tag
typedef struct xbox_adpcmwaveformat_tag
{
WAVEFORMATEX wfx; // WAVEFORMATEX data
WORD wSamplesPerBlock; // Number of samples per encoded block. It must be 64.
@ -174,7 +174,7 @@ class X_CMcpxStream
//
// TODO: Function needs X_CMcpxStream "this" pointer (ecx!)
//
VOID (WINAPI *Dummy_0x10)(DWORD dwDummy1, DWORD dwDummy2); // 0x10
}
*pVtbl;
@ -383,7 +383,7 @@ HRESULT WINAPI EmuIDirectSound8_SetMixBinHeadroom
HRESULT WINAPI EmuIDirectSoundBuffer8_SetMixBins
(
LPDIRECTSOUND8 pThis,
PVOID pMixBins // TODO: fill this out
PVOID pMixBins // TODO: fill this out
);
// ******************************************************************
@ -392,7 +392,7 @@ HRESULT WINAPI EmuIDirectSoundBuffer8_SetMixBins
HRESULT WINAPI EmuIDirectSoundBuffer8_SetMixBinVolumes
(
LPDIRECTSOUND8 pThis,
PVOID pMixBins // TODO: fill this out
PVOID pMixBins // TODO: fill this out
);
// ******************************************************************
@ -494,13 +494,13 @@ HRESULT WINAPI EmuIDirectSoundBuffer8_SetPlayRegion
HRESULT WINAPI EmuIDirectSoundBuffer8_Lock
(
X_CDirectSoundBuffer *pThis,
DWORD dwOffset,
DWORD dwBytes,
LPVOID *ppvAudioPtr1,
LPDWORD pdwAudioBytes1,
LPVOID *ppvAudioPtr2,
LPDWORD pdwAudioBytes2,
DWORD dwFlags
DWORD dwOffset,
DWORD dwBytes,
LPVOID *ppvAudioPtr1,
LPDWORD pdwAudioBytes1,
LPVOID *ppvAudioPtr2,
LPDWORD pdwAudioBytes2,
DWORD dwFlags
);
// ******************************************************************
@ -966,7 +966,7 @@ HRESULT WINAPI EmuIDirectSoundBuffer8_SetI3DL2Source
// ******************************************************************
HRESULT WINAPI EmuIDirectSoundBuffer8_SetFormat
(
X_CDirectSoundBuffer *pBuffer,
X_CDirectSoundBuffer *pBuffer,
LPCWAVEFORMATEX pwfxFormat
);
@ -975,7 +975,7 @@ HRESULT WINAPI EmuIDirectSoundBuffer8_SetFormat
// ******************************************************************
STDAPI_(void) EmuDirectSoundUseFullHRTF
(
void
void
);
// ******************************************************************
@ -983,8 +983,8 @@ STDAPI_(void) EmuDirectSoundUseFullHRTF
// ******************************************************************
HRESULT WINAPI EmuIDirectSoundBuffer8_SetLFO
(
LPDIRECTSOUNDBUFFER pThis,
LPCDSLFODESC pLFODesc
LPDIRECTSOUNDBUFFER pThis,
LPCDSLFODESC pLFODesc
);
// ******************************************************************
@ -992,9 +992,9 @@ HRESULT WINAPI EmuIDirectSoundBuffer8_SetLFO
// ******************************************************************
VOID WINAPI EmuXAudioCreateAdpcmFormat
(
WORD nChannels,
DWORD nSamplesPerSec,
LPXBOXADPCMWAVEFORMAT pwfx
WORD nChannels,
DWORD nSamplesPerSec,
LPXBOXADPCMWAVEFORMAT pwfx
);
// ******************************************************************
@ -1002,10 +1002,10 @@ VOID WINAPI EmuXAudioCreateAdpcmFormat
// ******************************************************************
HRESULT WINAPI EmuIDirectSoundBuffer8_SetRolloffCurve
(
LPDIRECTSOUNDBUFFER pThis,
const FLOAT *pflPoints,
DWORD dwPointCount,
DWORD dwApply
LPDIRECTSOUNDBUFFER pThis,
const FLOAT *pflPoints,
DWORD dwPointCount,
DWORD dwApply
);
// ******************************************************************
@ -1013,8 +1013,8 @@ HRESULT WINAPI EmuIDirectSoundBuffer8_SetRolloffCurve
// ******************************************************************
HRESULT WINAPI EmuIDirectSoundStream_SetVolume
(
LPDIRECTSOUNDSTREAM pStream,
LONG lVolume
LPDIRECTSOUNDSTREAM pStream,
LONG lVolume
);
#endif

44
src/CxbxKrnl/EmuFS.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuFS.cpp
@ -69,7 +69,7 @@ void EmuGenerateFS(Xbe::TLS *pTLS, void *pTLSData)
// copy global TLS to the current thread
{
uint32 dwCopySize = pTLS->dwDataEndAddr - pTLS->dwDataStartAddr;
uint32 dwCopySize = pTLS->dwDataEndAddr - pTLS->dwDataStartAddr;
uint32 dwZeroSize = pTLS->dwSizeofZeroFill;
pNewTLS = (uint08*)CxbxMalloc(dwCopySize + dwZeroSize + 0x100 /* + HACK: extra safety padding 0x100*/);
@ -81,29 +81,29 @@ void EmuGenerateFS(Xbe::TLS *pTLS, void *pTLSData)
// dump raw TLS data
{
#ifdef _DEBUG_TRACE
if(pNewTLS == 0)
{
DbgPrintf("EmuFS (0x%X): TLS Non-Existant (OK)\n", GetCurrentThreadId());
}
else
{
DbgPrintf("EmuFS (0x%X): TLS Data Dump...\n", GetCurrentThreadId());
if(pNewTLS == 0)
{
DbgPrintf("EmuFS (0x%X): TLS Non-Existant (OK)\n", GetCurrentThreadId());
}
else
{
DbgPrintf("EmuFS (0x%X): TLS Data Dump...\n", GetCurrentThreadId());
DbgPrintf("EmuFS (0x%X): 0x%.08X: ", GetCurrentThreadId(), pNewTLS);
uint32 stop = pTLS->dwDataEndAddr - pTLS->dwDataStartAddr + pTLS->dwSizeofZeroFill;
uint32 stop = pTLS->dwDataEndAddr - pTLS->dwDataStartAddr + pTLS->dwSizeofZeroFill;
for(uint32 v=0;v<stop;v++)
{
uint08 *bByte = (uint08*)pNewTLS + v;
for(uint32 v=0;v<stop;v++)
{
uint08 *bByte = (uint08*)pNewTLS + v;
DbgPrintf("%.01X", (uint32)*bByte);
DbgPrintf("%.01X", (uint32)*bByte);
if((v+1) % 0x10 == 0 && v+1<stop)
DbgPrintf("\nEmuFS (0x%X): 0x%.08X: ", GetCurrentThreadId(), ((uint32)pNewTLS + v));
}
if((v+1) % 0x10 == 0 && v+1<stop)
DbgPrintf("\nEmuFS (0x%X): 0x%.08X: ", GetCurrentThreadId(), ((uint32)pNewTLS + v));
}
DbgPrintf("\n");
}
DbgPrintf("\n");
}
#endif
}

12
src/CxbxKrnl/EmuFS.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuFS.h
@ -68,13 +68,13 @@ static inline bool EmuIsXboxFS()
//
// Xbox is a single process system, and because of this fact, demos
// and games are likely to suffer from Xbox-Never-Sleeps syndrome.
//
//
// Basically, there are situations where the Xbe will have no
// reason to bother yielding to other threads. One solution to this
// problem is to keep track of the number of function intercepts,
// and every so often, force a sleep. This is the rate at which
// those forced sleeps occur.
//
//
extern uint32 EmuAutoSleepRate;
//

74
src/CxbxKrnl/EmuFile.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuFile.cpp
@ -53,25 +53,25 @@ CRITICAL_SECTION EmuHandle::HandleLock;
// ******************************************************************
bool EmuHandle::Initialize()
{
size_t x;
size_t x;
// Initialize the critical section
InitializeCriticalSection(&HandleLock);
// Initialize the critical section
InitializeCriticalSection(&HandleLock);
// Mark all handles as free. We also set up the linked list of
// free handles here.
for (x = 0; x < EMU_MAX_HANDLES; x++)
{
Handles[x].m_Type = EMUHANDLE_TYPE_EMPTY;
Handles[x].m_NextFree = &Handles[x + 1];
}
// Mark all handles as free. We also set up the linked list of
// free handles here.
for (x = 0; x < EMU_MAX_HANDLES; x++)
{
Handles[x].m_Type = EMUHANDLE_TYPE_EMPTY;
Handles[x].m_NextFree = &Handles[x + 1];
}
// The last entry should have a NULL next entry
Handles[EMU_MAX_HANDLES - 1].m_NextFree = NULL;
// The last entry should have a NULL next entry
Handles[EMU_MAX_HANDLES - 1].m_NextFree = NULL;
// Set up the head and tail pointers
FirstFree = &Handles[0];
LastFree = &Handles[EMU_MAX_HANDLES];
// Set up the head and tail pointers
FirstFree = &Handles[0];
LastFree = &Handles[EMU_MAX_HANDLES];
return true;
}
@ -82,7 +82,7 @@ bool EmuHandle::Initialize()
// ******************************************************************
inline void EmuHandle::Lock(void)
{
EnterCriticalSection(&HandleLock);
EnterCriticalSection(&HandleLock);
}
// ******************************************************************
@ -91,7 +91,7 @@ inline void EmuHandle::Lock(void)
// ******************************************************************
inline void EmuHandle::Unlock(void)
{
LeaveCriticalSection(&HandleLock);
LeaveCriticalSection(&HandleLock);
}
// ******************************************************************
@ -100,27 +100,27 @@ inline void EmuHandle::Unlock(void)
// ******************************************************************
EmuHandle volatile *EmuHandle::Allocate(void)
{
volatile EmuHandle *Handle;
volatile EmuHandle *Handle;
// Lock the database
Lock();
// Lock the database
Lock();
// Get the first free entry
Handle = FirstFree;
// Get the first free entry
Handle = FirstFree;
// Remove it from the list
FirstFree = Handle->m_NextFree;
// Remove it from the list
FirstFree = Handle->m_NextFree;
// If it was the last handle, clear LastFree
if (!Handle->m_NextFree)
LastFree = NULL;
// If it was the last handle, clear LastFree
if (!Handle->m_NextFree)
LastFree = NULL;
// Initialize the handle's fields
Handle->m_Type = EMUHANDLE_TYPE_ALLOCATED;
Handle->m_Object = NULL;
// Initialize the handle's fields
Handle->m_Type = EMUHANDLE_TYPE_ALLOCATED;
Handle->m_Object = NULL;
// Unlock the database
Unlock();
// Unlock the database
Unlock();
return Handle;
return Handle;
}

104
src/CxbxKrnl/EmuFile.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuFile.h
@ -69,43 +69,43 @@ class EmuHandle
volatile enum _EmuHandleType m_Type;
// To keep the size 8 bytes, these 2 items are in a union
union
{
// Pointer to actual object (when handle is valid)
volatile class EmuNtObject *m_Object;
union
{
// Pointer to actual object (when handle is valid)
volatile class EmuNtObject *m_Object;
// Pointer to next free handle
volatile EmuHandle *m_NextFree;
};
volatile EmuHandle *m_NextFree;
};
// Close this handle
NtDll::NTSTATUS Close(void);
NtDll::NTSTATUS Close(void);
// Initialize the EmuHandle system
// Initialize the EmuHandle system
static bool Initialize();
// Close all open handles
static void CloseAll(void);
static void CloseAll(void);
// Allocate an empty handle
static volatile EmuHandle *Allocate(void);
static volatile EmuHandle *Allocate(void);
private:
// Array of EmuHandles in the system
static EmuHandle Handles[EMU_MAX_HANDLES];
// Array of EmuHandles in the system
static EmuHandle Handles[EMU_MAX_HANDLES];
// Pointer to first free handle in array, or NULL if none
volatile static EmuHandle *FirstFree;
volatile static EmuHandle *FirstFree;
// Pointer to last free handle in array, or NULL if none
volatile static EmuHandle *LastFree;
volatile static EmuHandle *LastFree;
// Lock on the handle system
static CRITICAL_SECTION HandleLock;
static CRITICAL_SECTION HandleLock;
// Quick functions to lock/unlock
inline static void Lock(void);
inline static void Unlock(void);
// Quick functions to lock/unlock
inline static void Lock(void);
inline static void Unlock(void);
};
// ******************************************************************
@ -113,17 +113,17 @@ class EmuHandle
// ******************************************************************
typedef enum _EmuHandleType
{
// Unallocated handle
EMUHANDLE_TYPE_EMPTY = 0,
// Unallocated handle
EMUHANDLE_TYPE_EMPTY = 0,
// Allocated but so far unused handle
EMUHANDLE_TYPE_ALLOCATED,
EMUHANDLE_TYPE_ALLOCATED,
// File handle with no really special features
EMUHANDLE_TYPE_FILE,
EMUHANDLE_TYPE_FILE,
// Fake file/directory/directory object/partition handle
EMUHANDLE_TYPE_OBJECT
EMUHANDLE_TYPE_OBJECT
}
EmuHandleType;
@ -133,33 +133,33 @@ EmuHandleType;
class EmuNtObject
{
public:
// Decrements the reference count of this object (never override)
void NtClose(void);
// Decrements the reference count of this object (never override)
void NtClose(void);
// These functions mimic the Nt* calls
// These functions mimic the Nt* calls
// Increments the reference count of this object
// For file handles, a whole new EmuFile structure is returned.
// For other objects (the default implementation), "this" is returned.
virtual EmuNtObject *NtDuplicateObject(void);
// Increments the reference count of this object
// For file handles, a whole new EmuFile structure is returned.
// For other objects (the default implementation), "this" is returned.
virtual EmuNtObject *NtDuplicateObject(void);
protected:
// Object name (Unicode, because we handle after-conversion strings)
const WCHAR *Name;
ULONG NameLength;
// Permanent status
bool PermanentFlag;
// Object name (Unicode, because we handle after-conversion strings)
const WCHAR *Name;
ULONG NameLength;
// Permanent status
bool PermanentFlag;
// Called by close() when the reference count reaches zero
virtual void Free(void) = 0;
// Constructor
EmuNtObject(void);
// Destructor
virtual ~EmuNtObject() = 0;
// Called by close() when the reference count reaches zero
virtual void Free(void) = 0;
// Constructor
EmuNtObject(void);
// Destructor
virtual ~EmuNtObject() = 0;
private:
// Reference count
ULONG RefCount;
// Reference count
ULONG RefCount;
};
// ******************************************************************
@ -168,13 +168,13 @@ class EmuNtObject
class EmuNtFile : public EmuNtObject
{
public:
// We need to override NtDuplicateObject in this case
// We need to override NtDuplicateObject in this case
private:
// The Windows file handle
HANDLE File;
// Pointer to the volume from which this came
//EmuNtVolume *Volume;
// The Windows file handle
HANDLE File;
// Pointer to the volume from which this came
//EmuNtVolume *Volume;
};
// ******************************************************************

270
src/CxbxKrnl/EmuKrnl.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuKrnl.cpp
@ -168,7 +168,7 @@ using namespace xboxkrnl;
// ******************************************************************
XBSYSAPI EXPORTNUM(14) xboxkrnl::PVOID NTAPI xboxkrnl::ExAllocatePool
(
IN ULONG NumberOfBytes
IN ULONG NumberOfBytes
)
{
EmuSwapFS(); // Win2k/XP FS
@ -194,20 +194,20 @@ XBSYSAPI EXPORTNUM(14) xboxkrnl::PVOID NTAPI xboxkrnl::ExAllocatePool
// ******************************************************************
XBSYSAPI EXPORTNUM(15) xboxkrnl::PVOID NTAPI xboxkrnl::ExAllocatePoolWithTag
(
IN SIZE_T NumberOfBytes,
IN ULONG Tag
IN SIZE_T NumberOfBytes,
IN ULONG Tag
)
{
EmuSwapFS(); // Win2k/XP FS
DbgPrintf("EmuKrnl (0x%X): ExAllocatePoolWithTag\n"
"(\n"
" NumberOfBytes : 0x%.08X\n"
" Tag : 0x%.08X\n"
" NumberOfBytes : 0x%.08X\n"
" Tag : 0x%.08X\n"
");\n",
GetCurrentThreadId(), NumberOfBytes, Tag);
// TODO: Actually implement this
// TODO: Actually implement this
PVOID pRet = CxbxMalloc(NumberOfBytes);
EmuSwapFS(); // Xbox FS
@ -548,7 +548,7 @@ XBSYSAPI EXPORTNUM(113) VOID NTAPI xboxkrnl::KeInitializeTimerEx
" Type : 0x%.08X\n"
");\n",
GetCurrentThreadId(), Timer, Type);
Timer->Header.Type = Type + 8;
Timer->Header.Inserted = 0;
Timer->Header.Size = sizeof(*Timer) / sizeof(ULONG);
@ -651,8 +651,8 @@ XBSYSAPI EXPORTNUM(149) xboxkrnl::BOOLEAN NTAPI xboxkrnl::KeSetTimer
");\n",
GetCurrentThreadId(), Timer, DueTime, Dpc);
// Call KeSetTimerEx
KeSetTimerEx(Timer, DueTime, 0, Dpc);
// Call KeSetTimerEx
KeSetTimerEx(Timer, DueTime, 0, Dpc);
EmuSwapFS(); // Xbox FS
@ -676,7 +676,7 @@ XBSYSAPI EXPORTNUM(150) xboxkrnl::BOOLEAN NTAPI xboxkrnl::KeSetTimerEx
"(\n"
" Timer : 0x%.08X\n"
" DueTime : 0x%I64X\n"
" Period : 0x%.08X\n"
" Period : 0x%.08X\n"
" Dpc : 0x%.08X\n"
");\n",
GetCurrentThreadId(), Timer, DueTime, Period, Dpc);
@ -711,7 +711,7 @@ LAUNCH_DATA_PAGE xLaunchDataPage =
// ******************************************************************
XBSYSAPI EXPORTNUM(160) xboxkrnl::UCHAR NTAPI xboxkrnl::KfRaiseIrql
(
IN UCHAR NewIrql
IN UCHAR NewIrql
)
{
EmuSwapFS(); // Win2k/XP FS
@ -732,7 +732,7 @@ XBSYSAPI EXPORTNUM(160) xboxkrnl::UCHAR NTAPI xboxkrnl::KfRaiseIrql
// ******************************************************************
XBSYSAPI EXPORTNUM(161) xboxkrnl::UCHAR NTAPI xboxkrnl::KfLowerIrql
(
IN UCHAR NewIrql
IN UCHAR NewIrql
)
{
EmuSwapFS(); // Win2k/XP FS
@ -758,7 +758,7 @@ XBSYSAPI EXPORTNUM(164) xboxkrnl::PLAUNCH_DATA_PAGE xboxkrnl::LaunchDataPage = &
// ******************************************************************
XBSYSAPI EXPORTNUM(165) xboxkrnl::PVOID NTAPI xboxkrnl::MmAllocateContiguousMemory
(
IN ULONG NumberOfBytes
IN ULONG NumberOfBytes
)
{
EmuSwapFS(); // Win2k/XP FS
@ -771,7 +771,7 @@ XBSYSAPI EXPORTNUM(165) xboxkrnl::PVOID NTAPI xboxkrnl::MmAllocateContiguousMemo
//
// NOTE: Kludgey (but necessary) solution:
//
//
// Since this memory must be aligned on a page boundary, we must allocate an extra page
// so that we can return a valid page aligned pointer
//
@ -801,11 +801,11 @@ XBSYSAPI EXPORTNUM(165) xboxkrnl::PVOID NTAPI xboxkrnl::MmAllocateContiguousMemo
// ******************************************************************
XBSYSAPI EXPORTNUM(166) xboxkrnl::PVOID NTAPI xboxkrnl::MmAllocateContiguousMemoryEx
(
IN ULONG NumberOfBytes,
IN PHYSICAL_ADDRESS LowestAcceptableAddress,
IN PHYSICAL_ADDRESS HighestAcceptableAddress,
IN ULONG Alignment OPTIONAL,
IN ULONG ProtectionType
IN ULONG NumberOfBytes,
IN PHYSICAL_ADDRESS LowestAcceptableAddress,
IN PHYSICAL_ADDRESS HighestAcceptableAddress,
IN ULONG Alignment OPTIONAL,
IN ULONG ProtectionType
)
{
EmuSwapFS(); // Win2k/XP FS
@ -823,13 +823,13 @@ XBSYSAPI EXPORTNUM(166) xboxkrnl::PVOID NTAPI xboxkrnl::MmAllocateContiguousMemo
//
// NOTE: Kludgey (but necessary) solution:
//
//
// Since this memory must be aligned on a page boundary, we must allocate an extra page
// so that we can return a valid page aligned pointer
//
PVOID pRet = CxbxMalloc(NumberOfBytes + 0x1000);
// align to page boundary
{
DWORD dwRet = (DWORD)pRet;
@ -884,7 +884,7 @@ XBSYSAPI EXPORTNUM(167) xboxkrnl::PVOID NTAPI xboxkrnl::MmAllocateSystemMemory
// ******************************************************************
XBSYSAPI EXPORTNUM(171) VOID NTAPI xboxkrnl::MmFreeContiguousMemory
(
IN PVOID BaseAddress
IN PVOID BaseAddress
)
{
EmuSwapFS(); // Win2k/XP FS
@ -896,7 +896,7 @@ XBSYSAPI EXPORTNUM(171) VOID NTAPI xboxkrnl::MmFreeContiguousMemory
GetCurrentThreadId(), BaseAddress);
PVOID OrigBaseAddress = BaseAddress;
if(g_AlignCache.exists(BaseAddress))
{
OrigBaseAddress = g_AlignCache.get(BaseAddress);
@ -1142,7 +1142,7 @@ XBSYSAPI EXPORTNUM(187) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtClose
GetCurrentThreadId(), Handle);
NTSTATUS ret = STATUS_SUCCESS;
// delete 'special' handles
if(IsEmuHandle(Handle))
{
@ -1224,15 +1224,15 @@ XBSYSAPI EXPORTNUM(189) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtCreateEvent
// ******************************************************************
XBSYSAPI EXPORTNUM(190) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtCreateFile
(
OUT PHANDLE FileHandle,
OUT PHANDLE FileHandle,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes,
OUT PIO_STATUS_BLOCK IoStatusBlock,
IN PLARGE_INTEGER AllocationSize OPTIONAL,
IN ULONG FileAttributes,
IN ULONG ShareAccess,
IN ULONG CreateDisposition,
IN ULONG CreateOptions
IN PLARGE_INTEGER AllocationSize OPTIONAL,
IN ULONG FileAttributes,
IN ULONG ShareAccess,
IN ULONG CreateDisposition,
IN ULONG CreateOptions
)
{
EmuSwapFS(); // Win2k/XP FS
@ -1268,46 +1268,46 @@ XBSYSAPI EXPORTNUM(190) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtCreateFile
}
// D:\ should map to current directory
if( (szBuffer[0] == 'D' || szBuffer[0] == 'd') && szBuffer[1] == ':' && szBuffer[2] == '\\')
{
szBuffer += 3;
if( (szBuffer[0] == 'D' || szBuffer[0] == 'd') && szBuffer[1] == ':' && szBuffer[2] == '\\')
{
szBuffer += 3;
ObjectAttributes->RootDirectory = g_hCurDir;
ObjectAttributes->RootDirectory = g_hCurDir;
DbgPrintf("EmuKrnl (0x%X): NtCreateFile Corrected path...\n", GetCurrentThreadId());
DbgPrintf(" Org:\"%s\"\n", ObjectAttributes->ObjectName->Buffer);
DbgPrintf(" New:\"$XbePath\\%s\"\n", szBuffer);
}
else if( (szBuffer[0] == 'T' || szBuffer[0] == 't') && szBuffer[1] == ':' && szBuffer[2] == '\\')
{
szBuffer += 3;
DbgPrintf("EmuKrnl (0x%X): NtCreateFile Corrected path...\n", GetCurrentThreadId());
DbgPrintf(" Org:\"%s\"\n", ObjectAttributes->ObjectName->Buffer);
DbgPrintf(" New:\"$XbePath\\%s\"\n", szBuffer);
}
else if( (szBuffer[0] == 'T' || szBuffer[0] == 't') && szBuffer[1] == ':' && szBuffer[2] == '\\')
{
szBuffer += 3;
ObjectAttributes->RootDirectory = g_hTDrive;
ObjectAttributes->RootDirectory = g_hTDrive;
DbgPrintf("EmuKrnl (0x%X): NtCreateFile Corrected path...\n", GetCurrentThreadId());
DbgPrintf(" Org:\"%s\"\n", ObjectAttributes->ObjectName->Buffer);
DbgPrintf(" New:\"$CxbxPath\\EmuDisk\\T\\%s\"\n", szBuffer);
}
else if( (szBuffer[0] == 'U' || szBuffer[0] == 'u') && szBuffer[1] == ':' && szBuffer[2] == '\\')
{
szBuffer += 3;
DbgPrintf("EmuKrnl (0x%X): NtCreateFile Corrected path...\n", GetCurrentThreadId());
DbgPrintf(" Org:\"%s\"\n", ObjectAttributes->ObjectName->Buffer);
DbgPrintf(" New:\"$CxbxPath\\EmuDisk\\T\\%s\"\n", szBuffer);
}
else if( (szBuffer[0] == 'U' || szBuffer[0] == 'u') && szBuffer[1] == ':' && szBuffer[2] == '\\')
{
szBuffer += 3;
ObjectAttributes->RootDirectory = g_hUDrive;
ObjectAttributes->RootDirectory = g_hUDrive;
DbgPrintf("EmuKrnl (0x%X): NtCreateFile Corrected path...\n", GetCurrentThreadId());
DbgPrintf(" Org:\"%s\"\n", ObjectAttributes->ObjectName->Buffer);
DbgPrintf(" New:\"$CxbxPath\\EmuDisk\\U\\%s\"\n", szBuffer);
}
else if( (szBuffer[0] == 'Z' || szBuffer[0] == 'z') && szBuffer[1] == ':' && szBuffer[2] == '\\')
{
szBuffer += 3;
DbgPrintf("EmuKrnl (0x%X): NtCreateFile Corrected path...\n", GetCurrentThreadId());
DbgPrintf(" Org:\"%s\"\n", ObjectAttributes->ObjectName->Buffer);
DbgPrintf(" New:\"$CxbxPath\\EmuDisk\\U\\%s\"\n", szBuffer);
}
else if( (szBuffer[0] == 'Z' || szBuffer[0] == 'z') && szBuffer[1] == ':' && szBuffer[2] == '\\')
{
szBuffer += 3;
ObjectAttributes->RootDirectory = g_hZDrive;
ObjectAttributes->RootDirectory = g_hZDrive;
DbgPrintf("EmuKrnl (0x%X): NtCreateFile Corrected path...\n", GetCurrentThreadId());
DbgPrintf(" Org:\"%s\"\n", ObjectAttributes->ObjectName->Buffer);
DbgPrintf(" New:\"$CxbxPath\\EmuDisk\\Z\\%s\"\n", szBuffer);
}
DbgPrintf("EmuKrnl (0x%X): NtCreateFile Corrected path...\n", GetCurrentThreadId());
DbgPrintf(" Org:\"%s\"\n", ObjectAttributes->ObjectName->Buffer);
DbgPrintf(" New:\"$CxbxPath\\EmuDisk\\Z\\%s\"\n", szBuffer);
}
//
// TODO: Wildcards are not allowed??
@ -1659,7 +1659,7 @@ XBSYSAPI EXPORTNUM(207) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtQueryDirectoryFile
// * 0x00D2 - NtQueryFullAttributesFile
// ******************************************************************
XBSYSAPI EXPORTNUM(210) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtQueryFullAttributesFile
(
(
IN POBJECT_ATTRIBUTES ObjectAttributes,
OUT PVOID Attributes
)
@ -1689,7 +1689,7 @@ XBSYSAPI EXPORTNUM(210) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtQueryFullAttributes
InitializeObjectAttributes(&NtObjAttr, &NtUnicodeString, ObjectAttributes->Attributes, ObjectAttributes->RootDirectory, NULL);
}
NTSTATUS ret = NtDll::NtQueryFullAttributesFile(&NtObjAttr, Attributes);
NTSTATUS ret = NtDll::NtQueryFullAttributesFile(&NtObjAttr, Attributes);
EmuSwapFS(); // Xbox FS
@ -1700,11 +1700,11 @@ XBSYSAPI EXPORTNUM(210) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtQueryFullAttributes
// * 0x00D3 - NtQueryInformationFile
// ******************************************************************
XBSYSAPI EXPORTNUM(211) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtQueryInformationFile
(
(
IN HANDLE FileHandle,
OUT PIO_STATUS_BLOCK IoStatusBlock,
OUT PVOID FileInformation,
IN ULONG Length,
OUT PVOID FileInformation,
IN ULONG Length,
IN FILE_INFORMATION_CLASS FileInfo
)
{
@ -1718,20 +1718,20 @@ XBSYSAPI EXPORTNUM(211) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtQueryInformationFil
" Length : 0x%.08X\n"
" FileInformationClass: 0x%.08X\n"
");\n",
GetCurrentThreadId(), FileHandle, IoStatusBlock, FileInformation,
GetCurrentThreadId(), FileHandle, IoStatusBlock, FileInformation,
Length, FileInfo);
if(FileInfo != FilePositionInformation && FileInfo != FileNetworkOpenInformation)
CxbxKrnlCleanup("Unknown FILE_INFORMATION_CLASS 0x%.08X", FileInfo);
if(FileInfo != FilePositionInformation && FileInfo != FileNetworkOpenInformation)
CxbxKrnlCleanup("Unknown FILE_INFORMATION_CLASS 0x%.08X", FileInfo);
NTSTATUS ret = NtDll::NtQueryInformationFile
(
FileHandle,
NTSTATUS ret = NtDll::NtQueryInformationFile
(
FileHandle,
(NtDll::PIO_STATUS_BLOCK)IoStatusBlock,
(NtDll::PFILE_FS_SIZE_INFORMATION)FileInformation,
Length,
Length,
(NtDll::FILE_INFORMATION_CLASS)FileInfo
);
);
//
// DEBUGGING!
@ -1784,7 +1784,7 @@ XBSYSAPI EXPORTNUM(218) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtQueryVolumeInformat
" Length : 0x%.08X\n"
" FileInformationClass: 0x%.08X\n"
");\n",
GetCurrentThreadId(), FileHandle, IoStatusBlock, FileInformation,
GetCurrentThreadId(), FileHandle, IoStatusBlock, FileInformation,
Length, FileInformationClass);
// Safety/Sanity Check
@ -1799,8 +1799,8 @@ XBSYSAPI EXPORTNUM(218) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtQueryVolumeInformat
(NtDll::FS_INFORMATION_CLASS)FileInformationClass
);
// NOTE: TODO: Dynamically fill in, or allow configuration?
if(FileInformationClass == FileFsSizeInformation)
// NOTE: TODO: Dynamically fill in, or allow configuration?
if(FileInformationClass == FileFsSizeInformation)
{
FILE_FS_SIZE_INFORMATION *SizeInfo = (FILE_FS_SIZE_INFORMATION*)FileInformation;
@ -1820,14 +1820,14 @@ XBSYSAPI EXPORTNUM(218) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtQueryVolumeInformat
// ******************************************************************
XBSYSAPI EXPORTNUM(219) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtReadFile
(
IN HANDLE FileHandle, // TODO: correct paramters
IN HANDLE Event OPTIONAL,
IN PVOID ApcRoutine OPTIONAL,
IN PVOID ApcContext,
OUT PVOID IoStatusBlock,
OUT PVOID Buffer,
IN ULONG Length,
IN PLARGE_INTEGER ByteOffset OPTIONAL
IN HANDLE FileHandle, // TODO: correct paramters
IN HANDLE Event OPTIONAL,
IN PVOID ApcRoutine OPTIONAL,
IN PVOID ApcContext,
OUT PVOID IoStatusBlock,
OUT PVOID Buffer,
IN ULONG Length,
IN PLARGE_INTEGER ByteOffset OPTIONAL
)
{
EmuSwapFS(); // Win2k/XP FS
@ -1843,7 +1843,7 @@ XBSYSAPI EXPORTNUM(219) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtReadFile
" Length : 0x%.08X\n"
" ByteOffset : 0x%.08X (0x%.08X)\n"
");\n",
GetCurrentThreadId(), FileHandle, Event, ApcRoutine,
GetCurrentThreadId(), FileHandle, Event, ApcRoutine,
ApcContext, IoStatusBlock, Buffer, Length, ByteOffset, ByteOffset == 0 ? 0 : ByteOffset->QuadPart);
// Halo...
@ -1949,11 +1949,11 @@ XBSYSAPI EXPORTNUM(225) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtSetEvent
// ******************************************************************
XBSYSAPI EXPORTNUM(226) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtSetInformationFile
(
IN HANDLE FileHandle, // TODO: correct paramters
OUT PVOID IoStatusBlock,
IN PVOID FileInformation,
IN ULONG Length,
IN ULONG FileInformationClass
IN HANDLE FileHandle, // TODO: correct paramters
OUT PVOID IoStatusBlock,
IN PVOID FileInformation,
IN ULONG Length,
IN ULONG FileInformationClass
)
{
EmuSwapFS(); // Win2k/XP FS
@ -1966,7 +1966,7 @@ XBSYSAPI EXPORTNUM(226) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtSetInformationFile
" Length : 0x%.08X\n"
" FileInformationClass : 0x%.08X\n"
");\n",
GetCurrentThreadId(), FileHandle, IoStatusBlock, FileInformation,
GetCurrentThreadId(), FileHandle, IoStatusBlock, FileInformation,
Length, FileInformationClass);
NTSTATUS ret = NtDll::NtSetInformationFile(FileHandle, IoStatusBlock, FileInformation, Length, FileInformationClass);
@ -2031,15 +2031,15 @@ XBSYSAPI EXPORTNUM(232) VOID NTAPI xboxkrnl::NtUserIoApcDispatcher
dwEsi = (uint32)IoStatusBlock;
if((IoStatusBlock->u1.Status & 0xC0000000) == 0xC0000000)
{
dwEcx = 0;
dwEax = NtDll::RtlNtStatusToDosError(IoStatusBlock->u1.Status);
}
else
{
dwEcx = (DWORD)IoStatusBlock->Information;
dwEax = 0;
}
{
dwEcx = 0;
dwEax = NtDll::RtlNtStatusToDosError(IoStatusBlock->u1.Status);
}
else
{
dwEcx = (DWORD)IoStatusBlock->Information;
dwEax = 0;
}
/*
// ~XDK 3911??
@ -2060,22 +2060,22 @@ XBSYSAPI EXPORTNUM(232) VOID NTAPI xboxkrnl::NtUserIoApcDispatcher
__asm
{
pushad
/*
mov esi, IoStatusBlock
/*
mov esi, IoStatusBlock
mov ecx, dwEcx
mov eax, dwEax
*/
// TODO: Figure out if/why this works!? Matches prototype, but not xboxkrnl disassembly
*/
// TODO: Figure out if/why this works!? Matches prototype, but not xboxkrnl disassembly
// Seems to be XDK/version dependand??
mov esi, dwEsi
mov ecx, dwEcx
mov eax, dwEax
mov esi, dwEsi
mov ecx, dwEcx
mov eax, dwEax
push esi
push ecx
push eax
call ApcContext
call ApcContext
popad
}
@ -2156,15 +2156,15 @@ XBSYSAPI EXPORTNUM(235) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtWaitForMultipleObje
// * 0x00EC - NtWriteFile
// ******************************************************************
XBSYSAPI EXPORTNUM(236) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtWriteFile
(
IN HANDLE FileHandle, // TODO: correct paramters
IN PVOID Event,
IN PVOID ApcRoutine,
IN PVOID ApcContext,
OUT PVOID IoStatusBlock,
IN PVOID Buffer,
IN ULONG Length,
IN PLARGE_INTEGER ByteOffset
(
IN HANDLE FileHandle, // TODO: correct paramters
IN PVOID Event,
IN PVOID ApcRoutine,
IN PVOID ApcContext,
OUT PVOID IoStatusBlock,
IN PVOID Buffer,
IN ULONG Length,
IN PLARGE_INTEGER ByteOffset
)
{
EmuSwapFS(); // Win2k/XP FS
@ -2180,7 +2180,7 @@ XBSYSAPI EXPORTNUM(236) xboxkrnl::NTSTATUS NTAPI xboxkrnl::NtWriteFile
" Length : 0x%.08X\n"
" ByteOffset : 0x%.08X (0x%.08X)\n"
");\n",
GetCurrentThreadId(), FileHandle, Event, ApcRoutine,
GetCurrentThreadId(), FileHandle, Event, ApcRoutine,
ApcContext, IoStatusBlock, Buffer, Length, ByteOffset, ByteOffset == 0 ? 0 : ByteOffset->QuadPart);
// Halo..
@ -2354,10 +2354,10 @@ XBSYSAPI EXPORTNUM(260) xboxkrnl::NTSTATUS NTAPI xboxkrnl::RtlAnsiStringToUnicod
// ******************************************************************
XBSYSAPI EXPORTNUM(264) VOID NTAPI xboxkrnl::RtlAssert
(
PVOID FailedAssertion,
PVOID FileName,
ULONG LineNumber,
PCHAR Message
PVOID FailedAssertion,
PVOID FileName,
ULONG LineNumber,
PCHAR Message
)
{
EmuSwapFS(); // Win2k/XP FS
@ -2367,11 +2367,11 @@ XBSYSAPI EXPORTNUM(264) VOID NTAPI xboxkrnl::RtlAssert
" FailedAssertion : 0x%.08X\n"
" FileName : 0x%.08X\n"
" LineNumber : 0x%.08X\n"
" Message : 0x%.08X (\"%s\")\n"
" Message : 0x%.08X (\"%s\")\n"
");\n",
GetCurrentThreadId(), FailedAssertion, FileName, Message, Message);
//TODO: Actually implement this.
//TODO: Actually implement this.
//NTSTATUS ret = NtDll::RtlAssert((NtDll::UNICODE_STRING*)DestinationString, (NtDll::STRING*)SourceString, AllocateDestinationString);
EmuSwapFS(); // Xbox FS
@ -2413,7 +2413,7 @@ XBSYSAPI EXPORTNUM(277) VOID NTAPI xboxkrnl::RtlEnterCriticalSection
// ******************************************************************
// * 0x0121 - RtlInitAnsiString
// ******************************************************************
XBSYSAPI EXPORTNUM(289) VOID NTAPI xboxkrnl::RtlInitAnsiString
XBSYSAPI EXPORTNUM(289) VOID NTAPI xboxkrnl::RtlInitAnsiString
(
IN OUT PANSI_STRING DestinationString,
IN PCSZ SourceString
@ -2556,7 +2556,7 @@ XBSYSAPI EXPORTNUM(304) xboxkrnl::BOOLEAN NTAPI xboxkrnl::RtlTimeFieldsToTime
XBSYSAPI EXPORTNUM(305) VOID NTAPI xboxkrnl::RtlTimeToTimeFields
(
IN PLARGE_INTEGER Time,
OUT PTIME_FIELDS TimeFields
OUT PTIME_FIELDS TimeFields
)
{
EmuSwapFS(); // Win2k/XP FS
@ -2628,7 +2628,7 @@ XBSYSAPI EXPORTNUM(308) xboxkrnl::NTSTATUS NTAPI xboxkrnl::RtlUnicodeStringToAns
// ******************************************************************
// * 0x0142 - XboxHardwareInfo
// ******************************************************************
XBSYSAPI EXPORTNUM(322) XBOX_HARDWARE_INFO xboxkrnl::XboxHardwareInfo =
XBSYSAPI EXPORTNUM(322) XBOX_HARDWARE_INFO xboxkrnl::XboxHardwareInfo =
{
0xC0000035,
0,0,0,0
@ -2637,7 +2637,7 @@ XBSYSAPI EXPORTNUM(322) XBOX_HARDWARE_INFO xboxkrnl::XboxHardwareInfo =
// ******************************************************************
// * 0x0143 - XboxHDKey
// ******************************************************************
XBSYSAPI EXPORTNUM(323) xboxkrnl::UCHAR xboxkrnl::XboxHDKey[16] =
XBSYSAPI EXPORTNUM(323) xboxkrnl::UCHAR xboxkrnl::XboxHDKey[16] =
{
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,

8
src/CxbxKrnl/EmuKrnl.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuKrnl.h

28
src/CxbxKrnl/EmuLDT.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuLDT.cpp
@ -95,7 +95,7 @@ uint16 EmuAllocateLDT(uint32 dwBaseAddr, uint32 dwLimit)
{
LeaveCriticalSection(&EmuLDTLock);
CxbxKrnlCleanup("Could not locate free LDT entry (too many threads?)");
CxbxKrnlCleanup("Could not locate free LDT entry (too many threads?)");
return 0;
}
@ -108,19 +108,19 @@ uint16 EmuAllocateLDT(uint32 dwBaseAddr, uint32 dwLimit)
LDTEntry.BaseLow = (WORD)(dwBaseAddr & 0xFFFF);
LDTEntry.HighWord.Bits.BaseMid = (dwBaseAddr >> 16) & 0xFF;
LDTEntry.HighWord.Bits.BaseHi = (dwBaseAddr >> 24) & 0xFF;
LDTEntry.HighWord.Bits.Type = 0x13; // RW data segment
LDTEntry.HighWord.Bits.Dpl = 3; // user segment
LDTEntry.HighWord.Bits.Pres = 1; // present
LDTEntry.HighWord.Bits.Sys = 0;
LDTEntry.HighWord.Bits.Reserved_0 = 0;
LDTEntry.HighWord.Bits.Default_Big = 1; // 386 segment
LDTEntry.HighWord.Bits.Granularity = (dwLimit >= 0x00100000) ? 1 : 0;
LDTEntry.HighWord.Bits.Type = 0x13; // RW data segment
LDTEntry.HighWord.Bits.Dpl = 3; // user segment
LDTEntry.HighWord.Bits.Pres = 1; // present
LDTEntry.HighWord.Bits.Sys = 0;
LDTEntry.HighWord.Bits.Reserved_0 = 0;
LDTEntry.HighWord.Bits.Default_Big = 1; // 386 segment
LDTEntry.HighWord.Bits.Granularity = (dwLimit >= 0x00100000) ? 1 : 0;
if(LDTEntry.HighWord.Bits.Granularity)
dwLimit >>= 12;
LDTEntry.LimitLow = (WORD)(dwLimit & 0xFFFF);
LDTEntry.HighWord.Bits.LimitHi = (dwLimit >> 16) & 0xF;
LDTEntry.HighWord.Bits.LimitHi = (dwLimit >> 16) & 0xF;
}
// ******************************************************************
@ -131,7 +131,7 @@ uint16 EmuAllocateLDT(uint32 dwBaseAddr, uint32 dwLimit)
{
LeaveCriticalSection(&EmuLDTLock);
CxbxKrnlCleanup("Could not set LDT entries");
CxbxKrnlCleanup("Could not set LDT entries");
return 0;
}

8
src/CxbxKrnl/EmuLDT.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuLDT.h

8
src/CxbxKrnl/EmuNtDll.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuNtDll.cpp

158
src/CxbxKrnl/EmuNtDll.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuNtDll.h
@ -74,9 +74,9 @@ typedef unsigned char UCHAR;
typedef unsigned char BYTE;
typedef unsigned char BOOLEAN;
typedef unsigned short USHORT;
typedef unsigned short WORD;
typedef unsigned short WORD;
typedef unsigned long ULONG;
typedef unsigned long DWORD;
typedef unsigned long DWORD;
typedef unsigned long SIZE_T, *PSIZE_T;
typedef unsigned long ACCESS_MASK;
typedef unsigned long PHYSICAL_ADDRESS;
@ -237,7 +237,7 @@ RTL_HEAP_DEFINITION, *PRTL_HEAP_DEFINITION;
typedef struct _RTL_CRITICAL_SECTION
{
DWORD Unknown[4]; // 0x00
LONG LockCount; // 0x10
LONG LockCount; // 0x10
LONG RecursionCount; // 0x14
HANDLE OwningThread; // 0x18
HANDLE LockSemaphore;
@ -292,7 +292,7 @@ OBJECT_ATTRIBUTES, *POBJECT_ATTRIBUTES;
// ******************************************************************
// * InitializeObjectAttributes
// *
// *
// * VOID
// * InitializeObjectAttributes(
// * OUT POBJECT_ATTRIBUTES p,
@ -301,7 +301,7 @@ OBJECT_ATTRIBUTES, *POBJECT_ATTRIBUTES;
// * IN HANDLE r,
// * IN PSECURITY_DESCRIPTOR s
// * )
// *
// *
// ******************************************************************
#define InitializeObjectAttributes( p, n, a, r, s ) \
{ \
@ -364,9 +364,9 @@ OBJECT_WAIT_TYPE;
// ******************************************************************
typedef enum _CREATE_FILE_TYPE
{
CreateFileTypeNone,
CreateFileTypeNamedPipe,
CreateFileTypeMailslot
CreateFileTypeNone,
CreateFileTypeNamedPipe,
CreateFileTypeMailslot
}
CREATE_FILE_TYPE;
@ -375,10 +375,10 @@ CREATE_FILE_TYPE;
// ******************************************************************
typedef struct _FILE_FS_SIZE_INFORMATION
{
LARGE_INTEGER TotalAllocationUnits;
LARGE_INTEGER AvailableAllocationUnits;
ULONG SectorsPerAllocationUnit;
ULONG BytesPerSector;
LARGE_INTEGER TotalAllocationUnits;
LARGE_INTEGER AvailableAllocationUnits;
ULONG SectorsPerAllocationUnit;
ULONG BytesPerSector;
}
FILE_FS_SIZE_INFORMATION, *PFILE_FS_SIZE_INFORMATION;
@ -451,7 +451,7 @@ FS_INFORMATION_CLASS, *PFS_INFORMATION_CLASS;
// ******************************************************************
// * FILE_DIRECTORY_INFORMATION
// ******************************************************************
typedef struct _FILE_DIRECTORY_INFORMATION
typedef struct _FILE_DIRECTORY_INFORMATION
{
ULONG NextEntryOffset;
ULONG FileIndex;
@ -590,7 +590,7 @@ typedef BOOLEAN (NTAPI *FPTR_RtlTimeFieldsToTime)
typedef VOID (NTAPI *FPTR_RtlTimeToTimeFields)
(
IN PLARGE_INTEGER Time,
OUT PTIME_FIELDS TimeFields
OUT PTIME_FIELDS TimeFields
);
// ******************************************************************
@ -791,17 +791,17 @@ typedef NTSTATUS (NTAPI *FPTR_NtReleaseMutant)
// ******************************************************************
typedef NTSTATUS (NTAPI *FPTR_NtCreateFile)
(
OUT PHANDLE FileHandle,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes,
OUT PIO_STATUS_BLOCK IoStatusBlock,
IN PLARGE_INTEGER AllocationSize OPTIONAL,
IN ULONG FileAttributes,
IN ULONG ShareAccess,
IN ULONG CreateDisposition,
IN ULONG CreateOptions,
IN PVOID EaBuffer OPTIONAL,
IN ULONG EaLength
OUT PHANDLE FileHandle,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes,
OUT PIO_STATUS_BLOCK IoStatusBlock,
IN PLARGE_INTEGER AllocationSize OPTIONAL,
IN ULONG FileAttributes,
IN ULONG ShareAccess,
IN ULONG CreateDisposition,
IN ULONG CreateOptions,
IN PVOID EaBuffer OPTIONAL,
IN ULONG EaLength
);
// ******************************************************************
@ -838,14 +838,14 @@ typedef NTSTATUS (NTAPI *FPTR_NtOpenFile)
// ******************************************************************
typedef NTSTATUS (NTAPI *FPTR_NtReadFile)
(
IN HANDLE FileHandle, // TODO: correct paramters
IN HANDLE Event OPTIONAL,
IN PVOID ApcRoutine OPTIONAL,
IN PVOID ApcContext,
OUT PVOID IoStatusBlock,
OUT PVOID Buffer,
IN ULONG Length,
IN PLARGE_INTEGER ByteOffset OPTIONAL,
IN HANDLE FileHandle, // TODO: correct paramters
IN HANDLE Event OPTIONAL,
IN PVOID ApcRoutine OPTIONAL,
IN PVOID ApcContext,
OUT PVOID IoStatusBlock,
OUT PVOID Buffer,
IN ULONG Length,
IN PLARGE_INTEGER ByteOffset OPTIONAL,
IN PULONG Key OPTIONAL
);
@ -854,14 +854,14 @@ typedef NTSTATUS (NTAPI *FPTR_NtReadFile)
// ******************************************************************
typedef NTSTATUS (NTAPI *FPTR_NtWriteFile)
(
IN HANDLE FileHandle, // TODO: correct paramters
IN HANDLE Event OPTIONAL,
IN PVOID ApcRoutine OPTIONAL,
IN PVOID ApcContext,
OUT PVOID IoStatusBlock,
OUT PVOID Buffer,
IN ULONG Length,
IN PLARGE_INTEGER ByteOffset OPTIONAL,
IN HANDLE FileHandle, // TODO: correct paramters
IN HANDLE Event OPTIONAL,
IN PVOID ApcRoutine OPTIONAL,
IN PVOID ApcContext,
OUT PVOID IoStatusBlock,
OUT PVOID Buffer,
IN ULONG Length,
IN PLARGE_INTEGER ByteOffset OPTIONAL,
IN PULONG Key OPTIONAL
);
@ -874,39 +874,39 @@ typedef VOID (NTAPI *FPTR_NtYieldExecution)();
// * NtSetInformationFile
// ******************************************************************
typedef NTSTATUS (NTAPI *FPTR_NtSetInformationFile)
(
IN HANDLE FileHandle, // TODO: correct paramters
OUT PVOID IoStatusBlock,
IN PVOID FileInformation,
IN ULONG Length,
IN ULONG FileInformationClass
(
IN HANDLE FileHandle, // TODO: correct paramters
OUT PVOID IoStatusBlock,
IN PVOID FileInformation,
IN ULONG Length,
IN ULONG FileInformationClass
);
// ******************************************************************
// * NtSuspendThread
// ******************************************************************
typedef NTSTATUS (NTAPI *FPTR_NtSuspendThread)
(
IN HANDLE ThreadHandle,
OUT PULONG PreviousSuspendCount OPTIONAL
(
IN HANDLE ThreadHandle,
OUT PULONG PreviousSuspendCount OPTIONAL
);
// ******************************************************************
// * NtResumeThread
// ******************************************************************
typedef NTSTATUS (NTAPI *FPTR_NtResumeThread)
(
IN HANDLE ThreadHandle,
OUT PULONG SuspendCount OPTIONAL
(
IN HANDLE ThreadHandle,
OUT PULONG SuspendCount OPTIONAL
);
// ******************************************************************
// * NtSetEvent
// ******************************************************************
typedef NTSTATUS (NTAPI *FPTR_NtSetEvent)
(
IN HANDLE EventHandle,
OUT PLONG PreviousState OPTIONAL
(
IN HANDLE EventHandle,
OUT PLONG PreviousState OPTIONAL
);
// ******************************************************************
@ -941,11 +941,11 @@ typedef NTSTATUS (NTAPI *FPTR_NtQueryFullAttributesFile)
// ******************************************************************
typedef NTSTATUS (NTAPI *FPTR_NtQueryInformationFile)
(
IN HANDLE FileHandle,
OUT PIO_STATUS_BLOCK IoStatusBlock,
OUT PFILE_FS_SIZE_INFORMATION FileInformation,
IN ULONG Length,
IN FILE_INFORMATION_CLASS FileInfo
IN HANDLE FileHandle,
OUT PIO_STATUS_BLOCK IoStatusBlock,
OUT PFILE_FS_SIZE_INFORMATION FileInformation,
IN ULONG Length,
IN FILE_INFORMATION_CLASS FileInfo
);
// ******************************************************************
@ -965,20 +965,20 @@ typedef NTSTATUS (NTAPI *FPTR_NtQueryVolumeInformationFile)
// ******************************************************************
typedef NTSTATUS (NTAPI *FPTR_IoCreateFile)
(
OUT PHANDLE FileHandle,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes,
OUT PIO_STATUS_BLOCK IoStatusBlock,
IN PLARGE_INTEGER AllocationSize OPTIONAL,
IN ULONG FileAttributes,
IN ULONG ShareAccess,
IN ULONG Disposition,
IN ULONG CreateOptions,
IN PVOID EaBuffer OPTIONAL,
IN ULONG EaLength,
IN CREATE_FILE_TYPE CreateFileType,
IN PVOID ExtraCreateParameters OPTIONAL,
IN ULONG Options
OUT PHANDLE FileHandle,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes,
OUT PIO_STATUS_BLOCK IoStatusBlock,
IN PLARGE_INTEGER AllocationSize OPTIONAL,
IN ULONG FileAttributes,
IN ULONG ShareAccess,
IN ULONG Disposition,
IN ULONG CreateOptions,
IN PVOID EaBuffer OPTIONAL,
IN ULONG EaLength,
IN CREATE_FILE_TYPE CreateFileType,
IN PVOID ExtraCreateParameters OPTIONAL,
IN ULONG Options
);
// ******************************************************************

8
src/CxbxKrnl/EmuShared.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuShared.h

124
src/CxbxKrnl/EmuXG.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuXG.cpp
@ -81,7 +81,7 @@ PVOID WINAPI XTL::EmuXGIsSwizzledFormat
// ******************************************************************
VOID WINAPI XTL::EmuXGSwizzleRect
(
LPCVOID pSource,
LPCVOID pSource,
DWORD Pitch,
LPCRECT pRect,
LPVOID pDest,
@ -149,7 +149,7 @@ VOID WINAPI XTL::EmuXGSwizzleRect
// ******************************************************************
VOID WINAPI XTL::EmuXGSwizzleBox
(
LPCVOID pSource,
LPCVOID pSource,
DWORD RowPitch,
DWORD SlicePitch,
CONST D3DBOX *pBox,
@ -209,93 +209,93 @@ VOID WINAPI XTL::EmuXGUnswizzleRect
DWORD dwBPP
)
{
DWORD dwOffsetU = 0, dwMaskU = 0;
DWORD dwOffsetU = 0, dwMaskU = 0;
DWORD dwOffsetV = 0, dwMaskV = 0;
DWORD dwOffsetW = 0, dwMaskW = 0;
DWORD i = 1;
DWORD j = 1;
DWORD i = 1;
DWORD j = 1;
// while( (i >= dwWidth) || (i >= dwHeight) || (i >= dwDepth) )
// while( (i >= dwWidth) || (i >= dwHeight) || (i >= dwDepth) )
while( (i <= dwWidth) || (i <= dwHeight) || (i <= dwDepth) )
{
if(i < dwWidth)
{
dwMaskU |= j;
j<<=1;
}
dwMaskU |= j;
j<<=1;
}
if(i < dwHeight)
{
dwMaskV |= j;
j<<=1;
}
dwMaskV |= j;
j<<=1;
}
if(i < dwDepth)
{
dwMaskW |= j;
j<<=1;
dwMaskW |= j;
j<<=1;
}
i<<=1;
}
}
DWORD dwSU = 0;
DWORD dwSV = 0;
DWORD dwSW = 0;
DWORD dwMaskMax=0;
DWORD dwSV = 0;
DWORD dwSW = 0;
DWORD dwMaskMax=0;
// get the biggest mask
if(dwMaskU > dwMaskV)
dwMaskMax=dwMaskU;
else
dwMaskMax=dwMaskV;
if(dwMaskW > dwMaskMax)
dwMaskMax=dwMaskW;
// get the biggest mask
if(dwMaskU > dwMaskV)
dwMaskMax=dwMaskU;
else
dwMaskMax=dwMaskV;
if(dwMaskW > dwMaskMax)
dwMaskMax=dwMaskW;
for(i = 1; i <= dwMaskMax; i<<=1)
for(i = 1; i <= dwMaskMax; i<<=1)
{
if(i<=dwMaskU)
if(i<=dwMaskU)
{
if(dwMaskU & i) dwSU |= (dwOffsetU & i);
else dwOffsetU<<=1;
}
if(dwMaskU & i) dwSU |= (dwOffsetU & i);
else dwOffsetU<<=1;
}
if(i<=dwMaskV)
{
if(dwMaskV & i) dwSV |= (dwOffsetV & i);
else dwOffsetV<<=1;
}
if(dwMaskV & i) dwSV |= (dwOffsetV & i);
else dwOffsetV<<=1;
}
if(i<=dwMaskW)
{
if(dwMaskW & i) dwSW |= (dwOffsetW & i);
else dwOffsetW<<=1;
}
}
if(dwMaskW & i) dwSW |= (dwOffsetW & i);
else dwOffsetW<<=1;
}
}
DWORD dwW = dwSW;
DWORD dwV = dwSV;
DWORD dwU = dwSU;
DWORD dwW = dwSW;
DWORD dwV = dwSV;
DWORD dwU = dwSU;
for(DWORD z=0; z<dwDepth; z++)
{
dwV = dwSV;
for(DWORD z=0; z<dwDepth; z++)
{
dwV = dwSV;
for(DWORD y=0; y<dwHeight; y++)
{
dwU = dwSU;
for(DWORD y=0; y<dwHeight; y++)
{
dwU = dwSU;
for (DWORD x=0; x<dwWidth; x++)
{
memcpy(pDstBuff, &((BYTE*)pSrcBuff)[(dwU|dwV|dwW)*dwBPP], dwBPP);
pDstBuff=(PVOID)(((DWORD)pDstBuff)+dwBPP);
for (DWORD x=0; x<dwWidth; x++)
{
memcpy(pDstBuff, &((BYTE*)pSrcBuff)[(dwU|dwV|dwW)*dwBPP], dwBPP);
pDstBuff=(PVOID)(((DWORD)pDstBuff)+dwBPP);
dwU = (dwU - dwMaskU) & dwMaskU;
}
pDstBuff=(PVOID)(((DWORD)pDstBuff)+(dwPitch-dwWidth*dwBPP));
dwV = (dwV - dwMaskV) & dwMaskV;
}
dwW = (dwW - dwMaskW) & dwMaskW;
}
dwU = (dwU - dwMaskU) & dwMaskU;
}
pDstBuff=(PVOID)(((DWORD)pDstBuff)+(dwPitch-dwWidth*dwBPP));
dwV = (dwV - dwMaskV) & dwMaskV;
}
dwW = (dwW - dwMaskW) & dwMaskW;
}
}

12
src/CxbxKrnl/EmuXG.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuXG.h
@ -55,7 +55,7 @@ PVOID WINAPI EmuXGIsSwizzledFormat
// ******************************************************************
VOID WINAPI EmuXGSwizzleRect
(
LPCVOID pSource,
LPCVOID pSource,
DWORD Pitch,
LPCRECT pRect,
LPVOID pDest,
@ -70,7 +70,7 @@ VOID WINAPI EmuXGSwizzleRect
// ******************************************************************
VOID WINAPI EmuXGSwizzleBox
(
LPCVOID pSource,
LPCVOID pSource,
DWORD RowPitch,
DWORD SlicePitch,
CONST D3DBOX *pBox,

8
src/CxbxKrnl/EmuXOnline.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuXOnline.cpp

42
src/CxbxKrnl/EmuXOnline.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuXOnline.h
@ -39,26 +39,26 @@
// ******************************************************************
class EmuThis
{
public:
// ******************************************************************
// * func: Emusocket
// ******************************************************************
SOCKET Emusocket(int af, int type, int protocol);
public:
// ******************************************************************
// * func: Emusocket
// ******************************************************************
SOCKET Emusocket(int af, int type, int protocol);
// ******************************************************************
// * func: Emubind
// ******************************************************************
int Emubind(SOCKET s, const struct sockaddr FAR *name, int namelen);
// ******************************************************************
// * func: Emubind
// ******************************************************************
int Emubind(SOCKET s, const struct sockaddr FAR *name, int namelen);
// ******************************************************************
// * func: Emulisten
// ******************************************************************
int Emulisten(SOCKET s, int backlog);
// ******************************************************************
// * func: Emulisten
// ******************************************************************
int Emulisten(SOCKET s, int backlog);
// ******************************************************************
// * func: Emuioctlsocket
// ******************************************************************
int Emuioctlsocket(SOCKET s, long cmd, u_long FAR *argp);
// ******************************************************************
// * func: Emuioctlsocket
// ******************************************************************
int Emuioctlsocket(SOCKET s, long cmd, u_long FAR *argp);
};
// ******************************************************************

8
src/CxbxKrnl/EmuXTL.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuXTL.h

68
src/CxbxKrnl/EmuXapi.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuXapi.cpp
@ -132,41 +132,41 @@ HANDLE WINAPI XTL::EmuFindFirstFileA
}
// D:\ should map to current directory
if( (szBuffer[0] == 'D' || szBuffer[0] == 'd') && szBuffer[1] == ':' && szBuffer[2] == '\\')
{
szBuffer += 3;
}
else if( (szBuffer[0] == 'T' || szBuffer[0] == 't') && szBuffer[1] == ':' && szBuffer[2] == '\\')
{
szBuffer += 3;
if( (szBuffer[0] == 'D' || szBuffer[0] == 'd') && szBuffer[1] == ':' && szBuffer[2] == '\\')
{
szBuffer += 3;
}
else if( (szBuffer[0] == 'T' || szBuffer[0] == 't') && szBuffer[1] == ':' && szBuffer[2] == '\\')
{
szBuffer += 3;
szRoot = g_strTDrive;
}
else if( (szBuffer[0] == 'U' || szBuffer[0] == 'u') && szBuffer[1] == ':' && szBuffer[2] == '\\')
{
szBuffer += 3;
}
else if( (szBuffer[0] == 'U' || szBuffer[0] == 'u') && szBuffer[1] == ':' && szBuffer[2] == '\\')
{
szBuffer += 3;
szRoot = g_strUDrive;
}
else if( (szBuffer[0] == 'Z' || szBuffer[0] == 'z') && szBuffer[1] == ':' && szBuffer[2] == '\\')
{
szBuffer += 3;
}
else if( (szBuffer[0] == 'Z' || szBuffer[0] == 'z') && szBuffer[1] == ':' && szBuffer[2] == '\\')
{
szBuffer += 3;
szRoot = g_strZDrive;
}
}
}
//printf("af1 : %s\n", szRoot);
//printf("af2 : %s\n", szBuffer);
//char szOldDir[MAX_PATH];
//GetCurrentDirectory(MAX_PATH, szOldDir);
SetCurrentDirectory(szRoot);
HANDLE hRet = FindFirstFile(szBuffer, lpFindFileData);
if(!FAILED(hRet))
{
do
@ -567,8 +567,8 @@ DWORD WINAPI XTL::EmuXGetDevices
BOOL WINAPI XTL::EmuXGetDeviceChanges
(
PXPP_DEVICE_TYPE DeviceType,
PDWORD pdwInsertions,
PDWORD pdwRemovals
PDWORD pdwInsertions,
PDWORD pdwRemovals
)
{
EmuSwapFS(); // Win2k/XP FS
@ -742,7 +742,7 @@ DWORD WINAPI XTL::EmuXInputPoll
GetCurrentThreadId(), hDevice);
POLLING_PARAMETERS_HANDLE *pph = (POLLING_PARAMETERS_HANDLE*)hDevice;
//
// Poll input
//
@ -852,7 +852,7 @@ DWORD WINAPI XTL::EmuXInputGetState
{
if(pph->pPollingParameters != NULL)
{
// 5849 XDK samples hang if this code is allowed to execute, TODO: figure out why.
// 5849 XDK samples hang if this code is allowed to execute, TODO: figure out why.
/*if(pph->pPollingParameters->fAutoPoll == FALSE)
{
//
@ -911,7 +911,7 @@ DWORD WINAPI XTL::EmuXInputSetState
//
bool found = false;
for(v=0;v<XINPUT_SETSTATE_SLOTS;v++)
{
if(g_pXInputSetStateStatus[v].hDevice == hDevice)
@ -1132,25 +1132,25 @@ VOID WINAPI XTL::EmuXapiInitProcess()
DbgPrintf("EmuXapi (0x%X): EmuXapiInitProcess();\n", GetCurrentThreadId());
// call RtlCreateHeap
{
// call RtlCreateHeap
{
RTL_HEAP_PARAMETERS HeapParameters;
ZeroMemory(&HeapParameters, sizeof(HeapParameters));
ZeroMemory(&HeapParameters, sizeof(HeapParameters));
HeapParameters.Length = sizeof(HeapParameters);
EmuSwapFS(); // XBox FS
EmuSwapFS(); // XBox FS
uint32 dwPeHeapReserve = CxbxKrnl_XbeHeader->dwPeHeapReserve;
uint32 dwPeHeapCommit = CxbxKrnl_XbeHeader->dwPeHeapCommit;
uint32 dwPeHeapReserve = CxbxKrnl_XbeHeader->dwPeHeapReserve;
uint32 dwPeHeapCommit = CxbxKrnl_XbeHeader->dwPeHeapCommit;
PVOID dwResult = 0;
#define HEAP_GROWABLE 0x00000002
*XTL::EmuXapiProcessHeap = XTL::g_pRtlCreateHeap(HEAP_GROWABLE, 0, dwPeHeapReserve, dwPeHeapCommit, NULL, &HeapParameters);
}
}
return;
}

20
src/CxbxKrnl/EmuXapi.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuXapi.h
@ -49,9 +49,9 @@ typedef unsigned char UCHAR;
typedef unsigned char BYTE;
typedef unsigned char BOOLEAN;
typedef unsigned short USHORT;
typedef unsigned short WORD;
typedef unsigned short WORD;
typedef unsigned long ULONG;
typedef unsigned long DWORD;
typedef unsigned long DWORD;
typedef unsigned long SIZE_T, *PSIZE_T;
typedef unsigned long ACCESS_MASK, *PACCESS_MASK;
typedef unsigned long PHYSICAL_ADDRESS;
@ -189,7 +189,7 @@ typedef struct _XINPUT_CAPABILITIES
BYTE SubType;
WORD Reserved;
union
union
{
XINPUT_GAMEPAD Gamepad;
}
@ -420,8 +420,8 @@ DWORD WINAPI EmuXGetDevices
BOOL WINAPI EmuXGetDeviceChanges
(
PXPP_DEVICE_TYPE DeviceType,
PDWORD pdwInsertions,
PDWORD pdwRemovals
PDWORD pdwInsertions,
PDWORD pdwRemovals
);
// ******************************************************************
@ -534,7 +534,7 @@ BOOL WINAPI EmuSetThreadPriorityBoost
HANDLE hThread,
BOOL DisablePriorityBoost
);
// ******************************************************************
// * func: EmuGetExitCodeThread
// ******************************************************************

54
src/CxbxKrnl/HLEDataBase.cpp
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->HLEDataBase.cpp
@ -274,7 +274,7 @@ extern uint32 HLEDataBaseSize = sizeof(HLEDataBase);
// ******************************************************************
// * XRefDataBase
// ******************************************************************
extern uint32 XRefDataBase[] =
extern uint32 XRefDataBase[] =
{
-1, // XREF_D3DDEVICE
-1, // XREF_DXSRSCULLMODE
@ -340,8 +340,8 @@ extern uint32 XRefDataBase[] =
-1, // XREF_DSBUFFERSETPLAYREGIONA (Buffer)
-1, // XREF_DSBUFFERLOCKA (Buffer)
-1, // XREF_DSBUFFERSETHEADROOMA (Buffer)
-1, // XREF_DSBUFFERSETFREQUENCYA (Buffer)
-1, // XREF_DSBUFFERSETFREQUENCYB
-1, // XREF_DSBUFFERSETFREQUENCYA (Buffer)
-1, // XREF_DSBUFFERSETFREQUENCYB
-1, // XREF_DSSTREAMSETMAXDISTANCE1A (Stream)
-1, // XREF_DSSTREAMSETMAXDISTANCE1B
-1, // XREF_DSSTREAMSETMAXDISTANCE1C
@ -397,26 +397,26 @@ extern uint32 XRefDataBase[] =
-1, // XREF_DSBUFFERSETI3DL2SOURCE
-1, // XREF_DirectSound_CDirectSoundVoice_SetFormat
-1, // XREF_DirectSound_CDirectSoundBuffer_SetFormat
-1, // XREF_DirectSound_CFullHRTFSource_GetCenterVolume
-1, // XREF_DirectSound_CHRTFSource_SetFullHRTF5Channel
-1, // XREF_D3D_SetFence
-1, // XREF_D3D_BlockOnResource
-1, // XREF_DirectSound_CMcpxVoiceClient_SetLFO
-1, // XREF_DirectSound_CDirectSoundVoice_SetLFO
-1, // XREF_DirectSound_CDirectSoundBuffer_SetLFO
-1, // XREF_DirectSound_CDirectSoundVoice_SetVolume
-1, // XREF_DirectSound_CDirectSoundBuffer_SetVolume
-1, // XREF_DirectSound_CDirectSoundBuffer_SetLoopRegion
-1, // XREF_DirectSound_CMcpxBuffer_Play
-1, // XREF_DirectSound_CDirectSoundBuffer_PlayEx
-1, // XREF_DirectSound_WaveFormat_CreateXboxAdpcmFormat
-1, // XREF_DirectSound_CDirectSoundVoice_SetConeAngles
-1, // XREF_DirectSound_CDirectSoundBuffer_SetConeAngles
-1, // XREF_DirectSound_CDirectSoundVoice_CommitDeferredSettings
-1, // XREF_DirectSound_CDirectSoundVoice_SetAllParameters
-1, // XREF_DirectSound_CDirectSoundBuffer_SetAllParameters
-1, // XREF_DirectSound_CDirectSoundVoice_SetRolloffCurve
-1, // XREF_DirectSound_CDirectSoundBuffer_SetRolloffCurve
-1, // XREF_DirectSound_CFullHRTFSource_GetCenterVolume
-1, // XREF_DirectSound_CHRTFSource_SetFullHRTF5Channel
-1, // XREF_D3D_SetFence
-1, // XREF_D3D_BlockOnResource
-1, // XREF_DirectSound_CMcpxVoiceClient_SetLFO
-1, // XREF_DirectSound_CDirectSoundVoice_SetLFO
-1, // XREF_DirectSound_CDirectSoundBuffer_SetLFO
-1, // XREF_DirectSound_CDirectSoundVoice_SetVolume
-1, // XREF_DirectSound_CDirectSoundBuffer_SetVolume
-1, // XREF_DirectSound_CDirectSoundBuffer_SetLoopRegion
-1, // XREF_DirectSound_CMcpxBuffer_Play
-1, // XREF_DirectSound_CDirectSoundBuffer_PlayEx
-1, // XREF_DirectSound_WaveFormat_CreateXboxAdpcmFormat
-1, // XREF_DirectSound_CDirectSoundVoice_SetConeAngles
-1, // XREF_DirectSound_CDirectSoundBuffer_SetConeAngles
-1, // XREF_DirectSound_CDirectSoundVoice_CommitDeferredSettings
-1, // XREF_DirectSound_CDirectSoundVoice_SetAllParameters
-1, // XREF_DirectSound_CDirectSoundBuffer_SetAllParameters
-1, // XREF_DirectSound_CDirectSoundVoice_SetRolloffCurve
-1, // XREF_DirectSound_CDirectSoundBuffer_SetRolloffCurve
/* not necessary?
-1, //XREF_XAPIXCALCULATESIGNATUREBEGINEX
//*/

52
src/CxbxKrnl/HLEDataBase.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->HLEDataBase.h
@ -172,8 +172,8 @@ enum XRefDataBaseOffset
XREF_DSBUFFERSETPLAYREGIONA,
XREF_DSBUFFERLOCKA,
XREF_DSBUFFERSETHEADROOMA,
XREF_DSBUFFERSETFREQUENCYA,
XREF_DSBUFFERSETFREQUENCYB,
XREF_DSBUFFERSETFREQUENCYA,
XREF_DSBUFFERSETFREQUENCYB,
XREF_DSSTREAMSETMAXDISTANCE1A,
XREF_DSSTREAMSETMAXDISTANCE1B,
XREF_DSSTREAMSETMAXDISTANCE1C,
@ -230,26 +230,26 @@ enum XRefDataBaseOffset
XREF_DSBUFFERSETI3DL2SOURCE,
XREF_DirectSound_CDirectSoundVoice_SetFormat,
XREF_DirectSound_CDirectSoundBuffer_SetFormat,
XREF_DirectSound_CFullHRTFSource_GetCenterVolume,
XREF_DirectSound_CHRTFSource_SetFullHRTF5Channel,
XREF_D3D_SetFence,
XREF_D3D_BlockOnResource,
XREF_DirectSound_CMcpxVoiceClient_SetLFO,
XREF_DirectSound_CDirectSoundVoice_SetLFO,
XREF_DirectSound_CDirectSoundBuffer_SetLFO,
XREF_DirectSound_CDirectSoundVoice_SetVolume,
XREF_DirectSound_CDirectSoundBuffer_SetVolume,
XREF_DirectSound_CDirectSoundBuffer_SetLoopRegion,
XREF_DirectSound_CMcpxBuffer_Play,
XREF_DirectSound_CDirectSoundBuffer_PlayEx,
XREF_DirectSound_WaveFormat_CreateXboxAdpcmFormat,
XREF_DirectSound_CDirectSoundVoice_SetConeAngles,
XREF_DirectSound_CDirectSoundBuffer_SetConeAngles,
XREF_DirectSound_CDirectSoundVoice_CommitDeferredSettings,
XREF_DirectSound_CDirectSoundVoice_SetAllParameters,
XREF_DirectSound_CDirectSoundBuffer_SetAllParameters,
XREF_DirectSound_CDirectSoundVoice_SetRolloffCurve,
XREF_DirectSound_CDirectSoundBuffer_SetRolloffCurve,
XREF_DirectSound_CFullHRTFSource_GetCenterVolume,
XREF_DirectSound_CHRTFSource_SetFullHRTF5Channel,
XREF_D3D_SetFence,
XREF_D3D_BlockOnResource,
XREF_DirectSound_CMcpxVoiceClient_SetLFO,
XREF_DirectSound_CDirectSoundVoice_SetLFO,
XREF_DirectSound_CDirectSoundBuffer_SetLFO,
XREF_DirectSound_CDirectSoundVoice_SetVolume,
XREF_DirectSound_CDirectSoundBuffer_SetVolume,
XREF_DirectSound_CDirectSoundBuffer_SetLoopRegion,
XREF_DirectSound_CMcpxBuffer_Play,
XREF_DirectSound_CDirectSoundBuffer_PlayEx,
XREF_DirectSound_WaveFormat_CreateXboxAdpcmFormat,
XREF_DirectSound_CDirectSoundVoice_SetConeAngles,
XREF_DirectSound_CDirectSoundBuffer_SetConeAngles,
XREF_DirectSound_CDirectSoundVoice_CommitDeferredSettings,
XREF_DirectSound_CDirectSoundVoice_SetAllParameters,
XREF_DirectSound_CDirectSoundBuffer_SetAllParameters,
XREF_DirectSound_CDirectSoundVoice_SetRolloffCurve,
XREF_DirectSound_CDirectSoundBuffer_SetRolloffCurve,
// XAPI
/* not necessary?
XREF_XAPIXCALCULATESIGNATUREBEGINEX

8
src/CxbxKrnl/HLEDataBase/D3D8.1.0.3925.h
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->D3D8.1.0.3925.h

114
src/CxbxKrnl/HLEDataBase/D3D8.1.0.3925.inl
View File

@ -1,10 +1,10 @@
// ******************************************************************
// *
// * .,-::::: .,:: .::::::::. .,:: .:
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
// * $$$ Y$$$P $$""""Y$$ Y$$$P
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->D3D8.1.0.3925.cpp
@ -325,7 +325,7 @@ SOOVPA<14> IDirect3DDevice8_BlockUntilVerticalBlank_1_0_3925 =
{ 0x09, 0x6A }, // (Offset,Value)-Pair #5
{ 0x0A, 0x01 }, // (Offset,Value)-Pair #6
// IDirect3DDevice8_BlockUntilVerticalBlank+0x0B : mov dword ptr [eax+0x24F4],
// IDirect3DDevice8_BlockUntilVerticalBlank+0x0B : mov dword ptr [eax+0x24F4],
{ 0x0B, 0xC7 }, // (Offset,Value)-Pair #7
{ 0x0C, 0x80 }, // (Offset,Value)-Pair #8
{ 0x0D, 0xF4 }, // (Offset,Value)-Pair #9
@ -743,7 +743,7 @@ SOOVPA<11> IDirect3DDevice8_SetVertexData2s_1_0_3925 =
-1, // XRef Not Saved
0, // XRef Not Used
{
{
// IDirect3DDevice8_SetVertexData2s+0x11 : lea edx, ds:abs[ecx*4]
{ 0x11, 0x8D }, // (Offset,Value)-Pair #1
{ 0x12, 0x14 }, // (Offset,Value)-Pair #2
@ -2340,7 +2340,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3D8_CreateDevice,
#ifdef _DEBUG_TRACE
"EmuIDirect3D8_CreateDevice"
"EmuIDirect3D8_CreateDevice"
#endif
},
// IDirect3DDevice8::IsBusy
@ -2360,7 +2360,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_GetDeviceCaps,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_GetDeviceCaps"
"EmuIDirect3DDevice8_GetDeviceCaps"
#endif
},
// IDirect3DDevice8::BeginVisibilityTest
@ -2370,7 +2370,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_BeginVisibilityTest,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_BeginVisibilityTest"
"EmuIDirect3DDevice8_BeginVisibilityTest"
#endif
},
// IDirect3DDevice8::EndVisibilityTest
@ -2380,7 +2380,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_EndVisibilityTest,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_EndVisibilityTest"
"EmuIDirect3DDevice8_EndVisibilityTest"
#endif
},
// IDirect3DDevice8::GetVisibilityTestResult
@ -2410,7 +2410,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_LoadVertexShader,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_LoadVertexShader"
"EmuIDirect3DDevice8_LoadVertexShader"
#endif
},
// IDirect3DDevice8::SelectVertexShader
@ -2420,7 +2420,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SelectVertexShader,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SelectVertexShader"
"EmuIDirect3DDevice8_SelectVertexShader"
#endif
},
// IDirect3DDevice8::Release
@ -2430,7 +2430,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_Release,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_Release"
"EmuIDirect3DDevice8_Release"
#endif
},
// IDirect3DDevice8::BlockUntilVerticalBlank
@ -2440,7 +2440,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_BlockUntilVerticalBlank,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_BlockUntilVerticalBlank"
"EmuIDirect3DDevice8_BlockUntilVerticalBlank"
#endif
},
// IDirect3DDevice8::SetVerticalBlankCallback
@ -2450,7 +2450,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetVerticalBlankCallback,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetVerticalBlankCallback"
"EmuIDirect3DDevice8_SetVerticalBlankCallback"
#endif
},
// IDirect3DDevice8::SetRenderTarget
@ -2460,7 +2460,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetRenderTarget,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetRenderTarget"
"EmuIDirect3DDevice8_SetRenderTarget"
#endif
},
// IDirect3DDevice8::GetTransform
@ -2470,7 +2470,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_GetTransform,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_GetTransform"
"EmuIDirect3DDevice8_GetTransform"
#endif
},
// IDirect3DDevice8::SetStreamSource
@ -2480,7 +2480,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetStreamSource,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetStreamSource"
"EmuIDirect3DDevice8_SetStreamSource"
#endif
},
// IDirect3DDevice8::SetVertexShader
@ -2490,7 +2490,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetVertexShader,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetVertexShader"
"EmuIDirect3DDevice8_SetVertexShader"
#endif
},
// IDirect3DDevice8::SetPixelShader
@ -2500,7 +2500,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetPixelShader,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetPixelShader"
"EmuIDirect3DDevice8_SetPixelShader"
#endif
},
// IDirect3DDevice8::SetIndices
@ -2510,7 +2510,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetIndices,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetIndices"
"EmuIDirect3DDevice8_SetIndices"
#endif
},
// IDirect3DDevice8::SetViewport
@ -2520,7 +2520,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetViewport,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetViewport"
"EmuIDirect3DDevice8_SetViewport"
#endif
},
// IDirect3DDevice8::SetTexture
@ -2530,7 +2530,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetTexture,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetTexture"
"EmuIDirect3DDevice8_SetTexture"
#endif
},
// IDirect3DDevice8::DrawIndexedVertices
@ -2540,7 +2540,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_DrawIndexedVertices,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_DrawIndexedVertices"
"EmuIDirect3DDevice8_DrawIndexedVertices"
#endif
},
// IDirect3DDevice8::Begin
@ -2550,7 +2550,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_Begin,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_Begin"
"EmuIDirect3DDevice8_Begin"
#endif
},
// IDirect3DDevice8::SetVertexData2f
@ -2560,7 +2560,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetVertexData2f,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetVertexData2f"
"EmuIDirect3DDevice8_SetVertexData2f"
#endif
},
// IDirect3DDevice8::SetVertexData2s
@ -2570,7 +2570,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetVertexData2s,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetVertexData2s"
"EmuIDirect3DDevice8_SetVertexData2s"
#endif
},
// IDirect3DDevice8::SetVertexData4f
@ -2580,7 +2580,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetVertexData4f,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetVertexData4f"
"EmuIDirect3DDevice8_SetVertexData4f"
#endif
},
// IDirect3DDevice8::SetVertexDataColor
@ -2590,7 +2590,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetVertexDataColor,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetVertexDataColor"
"EmuIDirect3DDevice8_SetVertexDataColor"
#endif
},
// IDirect3DDevice8::End
@ -2600,7 +2600,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_End,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_End"
"EmuIDirect3DDevice8_End"
#endif
},
// IDirect3DDevice8::Clear
@ -2610,7 +2610,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_Clear,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_Clear"
"EmuIDirect3DDevice8_Clear"
#endif
},
// IDirect3DDevice8::CreatePalette
@ -2620,7 +2620,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_CreatePalette,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_CreatePalette"
"EmuIDirect3DDevice8_CreatePalette"
#endif
},
// IDirect3DDevice8::SetPalette
@ -2630,7 +2630,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetPalette,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetPalette"
"EmuIDirect3DDevice8_SetPalette"
#endif
},
// IDirect3DDevice8::CreateTexture
@ -2690,7 +2690,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetVertexShaderConstant,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetVertexShaderConstant"
"EmuIDirect3DDevice8_SetVertexShaderConstant"
#endif
},
// IDirect3DDevice8::SetFlickerFilter
@ -2700,7 +2700,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetFlickerFilter,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetFlickerFilter"
"EmuIDirect3DDevice8_SetFlickerFilter"
#endif
},
// IDirect3DDevice8::SetSoftDisplayFilter
@ -2710,7 +2710,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetSoftDisplayFilter,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetSoftDisplayFilter"
"EmuIDirect3DDevice8_SetSoftDisplayFilter"
#endif
},
// IDirect3DDevice8::SetTextureState_TexCoordIndex
@ -2720,7 +2720,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetTextureState_TexCoordIndex,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetTextureState_TexCoordIndex"
"EmuIDirect3DDevice8_SetTextureState_TexCoordIndex"
#endif
},
// IDirect3DDevice8::SetTextureState_BorderColor
@ -2730,7 +2730,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetTextureState_BorderColor,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetTextureState_BorderColor"
"EmuIDirect3DDevice8_SetTextureState_BorderColor"
#endif
},
// IDirect3DDevice8::SetRenderState_PSTextureModes
@ -2740,7 +2740,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetRenderState_PSTextureModes,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetRenderState_PSTextureModes"
"EmuIDirect3DDevice8_SetRenderState_PSTextureModes"
#endif
},
// IDirect3DDevice8::SetRenderState_StencilFail
@ -2750,7 +2750,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetRenderState_StencilFail,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetRenderState_StencilFail"
"EmuIDirect3DDevice8_SetRenderState_StencilFail"
#endif
},
// IDirect3DDevice8::SetRenderState_CullMode
@ -2760,7 +2760,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetRenderState_CullMode,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetRenderState_CullMode"
"EmuIDirect3DDevice8_SetRenderState_CullMode"
#endif
},
// IDirect3DDevice8::SetRenderState_Simple
@ -2770,7 +2770,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetRenderState_Simple,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetRenderState_Simple"
"EmuIDirect3DDevice8_SetRenderState_Simple"
#endif
},
// IDirect3DDevice8::SetTransform
@ -2780,7 +2780,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetTransform,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetTransform"
"EmuIDirect3DDevice8_SetTransform"
#endif
},
// IDirect3DDevice8::SetRenderState_FogColor
@ -2790,7 +2790,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetRenderState_FogColor,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetRenderState_FogColor"
"EmuIDirect3DDevice8_SetRenderState_FogColor"
#endif
},
// IDirect3DDevice8::SetRenderState_FillMode
@ -2800,7 +2800,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetRenderState_FillMode,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetRenderState_FillMode"
"EmuIDirect3DDevice8_SetRenderState_FillMode"
#endif
},
// IDirect3DDevice8::SetRenderState_StencilEnable
@ -2810,7 +2810,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetRenderState_StencilEnable,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetRenderState_StencilEnable"
"EmuIDirect3DDevice8_SetRenderState_StencilEnable"
#endif
},
// IDirect3DDevice8::SetRenderState_Dxt1NoiseEnable
@ -2820,7 +2820,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetRenderState_Dxt1NoiseEnable,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetRenderState_Dxt1NoiseEnable"
"EmuIDirect3DDevice8_SetRenderState_Dxt1NoiseEnable"
#endif
},
// IDirect3DDevice8::SetRenderState_ZBias
@ -2830,7 +2830,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetRenderState_ZBias,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetRenderState_ZBias"
"EmuIDirect3DDevice8_SetRenderState_ZBias"
#endif
},
// IDirect3DDevice8::SetRenderState_ZEnable
@ -2840,7 +2840,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_SetRenderState_ZEnable,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_SetRenderState_ZEnable"
"EmuIDirect3DDevice8_SetRenderState_ZEnable"
#endif
},
// IDirect3DDevice8::Present
@ -2890,7 +2890,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DDevice8_CreateVertexBuffer,
#ifdef _DEBUG_TRACE
"EmuIDirect3DDevice8_CreateVertexBuffer"
"EmuIDirect3DDevice8_CreateVertexBuffer"
#endif
},
// IDirect3DVertexBuffer8::Lock
@ -2900,7 +2900,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DVertexBuffer8_Lock,
#ifdef _DEBUG_TRACE
"EmuIDirect3DVertexBuffer8_Lock"
"EmuIDirect3DVertexBuffer8_Lock"
#endif
},
// IDirect3DResource8::Register
@ -2960,7 +2960,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DTexture8_LockRect,
#ifdef _DEBUG_TRACE
"EmuIDirect3DTexture8_LockRect"
"EmuIDirect3DTexture8_LockRect"
#endif
},
// IDirect3DVolumeTexture8::LockBox
@ -2970,7 +2970,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DVolumeTexture8_LockBox,
#ifdef _DEBUG_TRACE
"EmuIDirect3DVolumeTexture8_LockBox"
"EmuIDirect3DVolumeTexture8_LockBox"
#endif
},
// IDirect3DCubeTexture8::LockRect
@ -2980,7 +2980,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DCubeTexture8_LockRect,
#ifdef _DEBUG_TRACE
"EmuIDirect3DCubeTexture8_LockRect"
"EmuIDirect3DCubeTexture8_LockRect"
#endif
},
// IDirect3DTexture8::GetSurfaceLevel
@ -2990,7 +2990,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuIDirect3DTexture8_GetSurfaceLevel,
#ifdef _DEBUG_TRACE
"EmuIDirect3DTexture8_GetSurfaceLevel"
"EmuIDirect3DTexture8_GetSurfaceLevel"
#endif
},
// Lock2DSurface
@ -3000,7 +3000,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuLock2DSurface,
#ifdef _DEBUG_TRACE
"EmuLock2DSurface"
"EmuLock2DSurface"
#endif
},
// Get2DSurfacDesc
@ -3010,7 +3010,7 @@ OOVPATable D3D8_1_0_3925[] =
XTL::EmuGet2DSurfaceDesc,
#ifdef _DEBUG_TRACE
"EmuGet2DSurfaceDesc"
"EmuGet2DSurfaceDesc"
#endif
},
// D3DDevice_GetVertexShaderSize

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