From c7acbf559f6f52f06d00cd1be193b5f611529925 Mon Sep 17 00:00:00 2001
From: MS <disinvite@users.noreply.github.com>
Date: Sun, 16 Jul 2023 21:37:21 -0400
Subject: [PATCH 01/21] lego1: implement MXIOINFO (#54)

* Implementation of MXIOINFO. Not a 100% match, but we are very close. I don't wanna wrangle with this one any more, so I figured I would open it up for review in case anyone else has ideas.

**Known problems:**
- The Open function uses a `movzx` instruction on the value of parameter `fdwOpen` before pushing to OpenFile from the kernel. You can force this to appear by casting to `unsigned short`, but this disturbs the instructions for the rest of the file. To get the "best" overall match I decided to leave this out.
- Flush, Advance, and Descend differ only in the order of operands on a `cmp` instruction.
- This entire file is honestly pretty ugly. The main reason is all the nested ifs; we are constrained by returning a result value from each function, but only at the very end instead of bailing out with a `return`. By far the worst offender is the do/while loop in the Descend function.

**Design considerations:**
- We are casting the file handle from MMIOINFO to `HFILE` everywhere it is used, so I decided to just change the type. While doing that, I figured I might as well just pull out the members from the struct so we don't have `m_info` all over the place.
- Without using a struct member, we have the issue of the obvious `memset` used to zero out the values in the constructor. I changed this to work on the object itself, which would not be valid in most cases, but seems fine here since we have no virtual methods.

There is a lot of repeated code here, namely the call to `_llseek` to reset `m_lDiskOffset` based on the current file position. You could move this to an inline function, but maybe that's not appropriate.

There are probably strides to be made on code clarity and comments (if needed or wanted) here. I'm open to any suggestions.

* remove casts on read, add size assert

* Use more Mx* types and param style convention

* Fixing up MXIOINFO to prepare for merge.

* Following feedback from @stravant and @itsmattkc, reverted back to using `MMIOINFO` struct as the class member instead of adding its values directly. (We actually gained a little on accuracy with this change.)
* The memset to zero out the values in the constructor now acts on `m_info` instead of `this`. Strictly speaking we don't need the size assert any more but I decided to keep it in case we change the members later for some reason.
* Casting the `hmmio` member to `HFILE` (int) or `HMMIO` (WORD) typedefs where needed.
* Squelch a signed/unsigned type comparison warning
---
 LEGO1/mxioinfo.cpp | 422 +++++++++++++++++++++++++++++++++++++++++++--
 LEGO1/mxioinfo.h   |  16 +-
 2 files changed, 419 insertions(+), 19 deletions(-)

diff --git a/LEGO1/mxioinfo.cpp b/LEGO1/mxioinfo.cpp
index 2d55ef36..c834f33d 100644
--- a/LEGO1/mxioinfo.cpp
+++ b/LEGO1/mxioinfo.cpp
@@ -1,9 +1,15 @@
 #include "mxioinfo.h"
+#include "decomp.h"
+
+// This class should be 72 bytes in size, same as the MMIOINFO struct.
+// The current implementation has MMIOINFO as the only member of the class,
+// but this assert will enforce the size if we decide to change that.
+DECOMP_SIZE_ASSERT(MXIOINFO, sizeof(MMIOINFO));
 
 // OFFSET: LEGO1 0x100cc800
 MXIOINFO::MXIOINFO()
 {
-  memset(&m_info, 0, sizeof(MMIOINFO));
+  memset(&m_info, 0, sizeof(m_info));
 }
 
 // OFFSET: LEGO1 0x100cc820
@@ -13,37 +19,427 @@ MXIOINFO::~MXIOINFO()
 }
 
 // OFFSET: LEGO1 0x100cc830
-MxU16 MXIOINFO::Open(const char *filename, DWORD fdwOpen)
+MxU16 MXIOINFO::Open(const char *p_filename, MxULong p_flags)
 {
-  return 0;
+  OFSTRUCT _unused;
+  MxU16 result = 0;
+
+  m_info.lBufOffset = 0;
+  m_info.lDiskOffset = 0;
+
+  // Cast of p_flags to u16 forces the `movzx` instruction
+  m_info.hmmio = (HMMIO)OpenFile(p_filename, &_unused, (MxU16)p_flags);
+  
+  if ((HFILE)m_info.hmmio != HFILE_ERROR) {
+    m_info.dwFlags = p_flags;
+    if (p_flags & MMIO_ALLOCBUF) {
+
+      // Default buffer length of 8k if none specified
+      int len = m_info.cchBuffer ? m_info.cchBuffer : 8192;
+      HPSTR buf = new char[len];
+
+      if (!buf) {
+        result = MMIOERR_OUTOFMEMORY;
+        m_info.cchBuffer = 0;
+        m_info.dwFlags &= ~MMIO_ALLOCBUF;
+        m_info.pchBuffer = 0;
+      } else {
+        m_info.pchBuffer = buf;
+        m_info.cchBuffer = len;
+      }
+
+      m_info.pchEndRead = m_info.pchBuffer;
+      m_info.pchNext = m_info.pchBuffer;
+      m_info.pchEndWrite = m_info.pchBuffer + m_info.cchBuffer;
+    }
+  } else {
+    result = MMIOERR_CANNOTOPEN;
+  }
+
+  return result;
 }
 
 // OFFSET: LEGO1 0x100cc8e0
-void MXIOINFO::Close(MxLong arg)
+MxU16 MXIOINFO::Close(MxLong p_unused)
 {
-  
+  MxU16 result = 0;
+
+  if (m_info.hmmio) {
+    result = Flush(0);
+    _lclose((HFILE)m_info.hmmio);
+    m_info.hmmio = 0;
+
+    if (m_info.dwFlags & MMIO_ALLOCBUF)
+      delete[] m_info.pchBuffer;
+
+    m_info.pchEndWrite = 0;
+    m_info.pchEndRead = 0;
+    m_info.pchBuffer = 0;
+    m_info.dwFlags = 0;
+  }
+
+  return result;
 }
 
 // OFFSET: LEGO1 0x100cc930
-MxULong MXIOINFO::Read(HPSTR pch, LONG cch)
+MxLong MXIOINFO::Read(void *p_buf, MxLong p_len)
 {
-  return 0;
+  MxLong bytes_read = 0;
+
+  if (m_info.pchBuffer) {
+
+    int bytes_left = m_info.pchEndRead - m_info.pchNext;
+    while (p_len > 0) {
+
+      if (bytes_left > 0) {
+        if (p_len < bytes_left)
+          bytes_left = p_len;
+        
+        memcpy(p_buf, m_info.pchNext, bytes_left);
+        p_len -= bytes_left;
+        
+        m_info.pchNext += bytes_left;
+        bytes_read += bytes_left;
+      }
+
+      if (p_len <= 0 || Advance(0))
+        break;
+
+      bytes_left = m_info.pchEndRead - m_info.pchNext;
+      if (bytes_left <= 0)
+        break;
+    }
+  } else if (m_info.hmmio && p_len > 0) {
+    bytes_read = _hread((HFILE)m_info.hmmio, p_buf, p_len);
+
+    if (bytes_read == -1) {
+      bytes_read = 0;
+      m_info.lDiskOffset = _llseek((HFILE)m_info.hmmio, 0, SEEK_CUR);
+    } else {
+      m_info.lDiskOffset += bytes_read;
+    }
+  }
+
+  return bytes_read;
 }
 
 // OFFSET: LEGO1 0x100cca00
-LONG MXIOINFO::Seek(LONG lOffset, int iOrigin)
+MxLong MXIOINFO::Seek(MxLong p_offset, int p_origin)
 {
-  return 0;
+  MxLong result = -1;
+
+  // If buffered I/O
+  if (m_info.pchBuffer) {
+    if (p_origin == SEEK_CUR) {
+      if (!p_offset) {
+        // don't seek at all and just return where we are.
+        return m_info.lBufOffset + (m_info.pchNext - m_info.pchBuffer);
+      } else {
+        // With SEEK_CUR, p_offset is a relative offset.
+        // Get the absolute position instead and use SEEK_SET.
+        p_offset += m_info.lBufOffset + (m_info.pchNext - m_info.pchBuffer);
+        p_origin = SEEK_SET;
+      }
+    } else if (p_origin == SEEK_END) {
+      // not possible with buffered I/O
+      return -1;
+    }
+    
+    // else p_origin == SEEK_SET.
+
+    // is p_offset between the start and end of the buffer?
+    // i.e. can we do the seek without reading more from disk?
+    if (p_offset >= m_info.lBufOffset && p_offset < m_info.lBufOffset + m_info.cchBuffer) {
+      m_info.pchNext = m_info.pchBuffer + (p_offset - m_info.lBufOffset);
+      result = p_offset;
+    } else {
+      // we have to read another chunk from disk.
+      if (m_info.hmmio && !Flush(0)) {
+        m_info.lDiskOffset = _llseek((HFILE)m_info.hmmio, p_offset, p_origin);
+
+        if (m_info.lDiskOffset == -1) {
+          m_info.lDiskOffset = _llseek((HFILE)m_info.hmmio, 0, SEEK_CUR);
+        } else {
+
+          // align offset to buffer size
+          int new_offset = p_offset - (p_offset % m_info.cchBuffer);
+          m_info.lBufOffset = new_offset;
+
+          // do we need to seek again?
+          // (i.e. are we already aligned to buffer size?)
+          if (p_offset != new_offset) {
+            m_info.lDiskOffset = _llseek((HFILE)m_info.hmmio, new_offset, SEEK_SET);
+
+            if (m_info.lDiskOffset == -1) {
+              m_info.lDiskOffset = _llseek((HFILE)m_info.hmmio, 0, SEEK_CUR);
+            }
+          }
+
+          if (m_info.lBufOffset == m_info.lDiskOffset) {
+            // is the file open for writing only?
+            if ((m_info.dwFlags & MMIO_RWMODE) &&
+                ((m_info.dwFlags & MMIO_RWMODE) != MMIO_READWRITE)) {
+
+              m_info.pchNext = m_info.pchBuffer - m_info.lBufOffset + p_offset;
+              
+              result = p_offset;
+            } else {
+              // We can read from the file. Fill the buffer.
+              int bytes_read = _hread((HFILE)m_info.hmmio, m_info.pchBuffer, m_info.cchBuffer);
+              
+              if (bytes_read == -1) {
+                m_info.lDiskOffset = _llseek((HFILE)m_info.hmmio, 0, SEEK_CUR);
+              } else {
+                m_info.lDiskOffset += bytes_read;
+                m_info.pchNext = p_offset - m_info.lBufOffset + m_info.pchBuffer;
+                m_info.pchEndRead = m_info.pchBuffer + bytes_read;
+
+                if (m_info.pchNext < m_info.pchEndRead) {
+                  result = p_offset;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  } else {
+    // No buffer so just seek the file directly (if we have a valid handle)
+    if (m_info.hmmio) {
+      // i.e. if we just want to get the current file position
+      if (p_origin == SEEK_CUR && p_offset == 0) {
+        return m_info.lDiskOffset;
+      } else {
+        m_info.lDiskOffset = _llseek((HFILE)m_info.hmmio, p_offset, p_origin);
+
+        result = m_info.lDiskOffset;
+
+        if (result == -1) {
+          m_info.lDiskOffset = _llseek((HFILE)m_info.hmmio, 0, SEEK_CUR);
+        }
+      }
+    }
+  }
+
+  return result;
 }
 
 // OFFSET: LEGO1 0x100ccbc0
-void MXIOINFO::SetBuffer(LPSTR pchBuffer, LONG cchBuffer, LONG unk)
+MxU16 MXIOINFO::SetBuffer(char *p_buf, MxLong p_len, MxLong p_unused)
 {
-  
+  MxU16 result = Flush(0);
+
+  if (m_info.dwFlags & MMIO_ALLOCBUF) {
+    m_info.dwFlags &= ~MMIO_ALLOCBUF;
+    delete[] m_info.pchBuffer;
+  }
+
+  m_info.pchBuffer = p_buf;
+  m_info.cchBuffer = p_len;
+  m_info.pchEndWrite = m_info.pchBuffer + m_info.cchBuffer;
+  m_info.pchEndRead = m_info.pchBuffer;
+
+  return result;
+}
+
+// OFFSET: LEGO1 0x100ccc10
+MxU16 MXIOINFO::Flush(MxU16 p_unused)
+{
+  MxU16 result = 0;
+
+  // if buffer is dirty
+  if (m_info.dwFlags & MMIO_DIRTY) {
+    // if we have allocated an IO buffer
+    if (m_info.pchBuffer) {
+      // if we have a file open for writing
+      if (m_info.hmmio && (m_info.dwFlags & MMIO_RWMODE)) {
+        // (pulling this value out into a variable forces it into EBX)
+        MxLong cchBuffer = m_info.cchBuffer;
+        if (cchBuffer > 0) {
+          if (m_info.lBufOffset != m_info.lDiskOffset) {
+            m_info.lDiskOffset = _llseek((HFILE)m_info.hmmio, m_info.lBufOffset, SEEK_SET);
+          }
+
+          // Was the previous seek (if required) successful?
+          if (m_info.lBufOffset != m_info.lDiskOffset) {
+            result = MMIOERR_CANNOTSEEK;
+            m_info.lDiskOffset = _llseek((HFILE)m_info.hmmio, 0, SEEK_CUR);
+          } else {
+            MxLong bytes_written = _hwrite((HFILE)m_info.hmmio, m_info.pchBuffer, cchBuffer);
+
+            if (bytes_written != -1 && bytes_written == cchBuffer) {
+              m_info.lDiskOffset += bytes_written;
+              m_info.pchNext = m_info.pchBuffer;
+              m_info.dwFlags &= ~MMIO_DIRTY;
+            } else {
+              result = MMIOERR_CANNOTWRITE;
+              m_info.lDiskOffset = _llseek((HFILE)m_info.hmmio, 0, SEEK_CUR);
+            }
+          }
+        }
+      } else {
+        result = MMIOERR_CANNOTWRITE;
+      }
+    } else {
+      result = MMIOERR_UNBUFFERED;
+    }
+  }
+
+  return result;
+}
+
+// OFFSET: LEGO1 0x100ccd00
+MxU16 MXIOINFO::Advance(MxU16 p_option)
+{
+  MxU16 result = 0;
+  MxULong rwmode = m_info.dwFlags & MMIO_RWMODE;
+
+  if (m_info.pchBuffer) {
+    MxLong cch = m_info.cchBuffer;
+
+    // If we can and should write to the file,
+    // if we are being asked to write to the file,
+    // and if there is a buffer *to* write:
+    if ((rwmode == MMIO_WRITE || rwmode == MMIO_READWRITE) &&
+        (m_info.dwFlags & MMIO_DIRTY) && 
+        ((p_option & MMIO_WRITE) || (rwmode == MMIO_READWRITE)) &&
+        cch > 0) {
+
+      if (m_info.lBufOffset != m_info.lDiskOffset) {
+        m_info.lDiskOffset = _llseek((HFILE)m_info.hmmio, m_info.lBufOffset, SEEK_SET);
+      }
+
+      if (m_info.lBufOffset != m_info.lDiskOffset) {
+        result = MMIOERR_CANNOTSEEK;
+      } else {
+        MxLong bytes_written = _hwrite((HFILE)m_info.hmmio, m_info.pchBuffer, cch);
+
+        if (bytes_written != -1 && bytes_written == cch) {
+          m_info.lDiskOffset += bytes_written;
+          m_info.pchNext = m_info.pchBuffer;
+          m_info.pchEndRead = m_info.pchBuffer;
+          m_info.dwFlags &= ~MMIO_DIRTY;
+        } else {
+          result = MMIOERR_CANNOTWRITE;
+        }
+      }  
+
+      m_info.lDiskOffset = _llseek((HFILE)m_info.hmmio, 0, SEEK_CUR);
+
+    }
+
+    m_info.lBufOffset += cch;
+    if ((!rwmode || rwmode == MMIO_READWRITE) && cch > 0) {
+      if (m_info.lBufOffset != m_info.lDiskOffset) {
+        m_info.lDiskOffset = _llseek((HFILE)m_info.hmmio, m_info.lBufOffset, SEEK_SET);
+      }
+
+      // if previous seek failed
+      if (m_info.lBufOffset != m_info.lDiskOffset) {
+        result = MMIOERR_CANNOTSEEK;
+        m_info.lDiskOffset = _llseek((HFILE)m_info.hmmio, 0, SEEK_CUR);
+      } else {
+        int bytes_read = _hread((HFILE)m_info.hmmio, m_info.pchBuffer, cch);
+
+        if (bytes_read == -1) {
+          result = MMIOERR_CANNOTREAD;
+          m_info.lDiskOffset = _llseek((HFILE)m_info.hmmio, 0, SEEK_CUR);
+        } else {
+          m_info.lDiskOffset += bytes_read;
+          m_info.pchNext = m_info.pchBuffer;
+          m_info.pchEndRead = m_info.pchBuffer + bytes_read;
+        }
+      }
+    }
+  } else {
+    result = MMIOERR_UNBUFFERED;
+  }
+
+  return result;
 }
 
 // OFFSET: LEGO1 0x100cce60
-MxU16 MXIOINFO::Descend(LPMMCKINFO pmmcki, const MMCKINFO *pmmckiParent, UINT fuDescend)
+MxU16 MXIOINFO::Descend(MMCKINFO *p_chunkInfo, const MMCKINFO *p_parentInfo, MxU16 p_descend)
 {
-  return 0;
+  MxU16 result = 0;
+  
+  if (!p_chunkInfo) 
+    return MMIOERR_BASE; // ?
+
+  if (!p_descend) {
+    p_chunkInfo->dwFlags = 0;
+    if (Read(p_chunkInfo, 8) != 8) {
+      result = MMIOERR_CANNOTREAD;
+    } else {
+      if (m_info.pchBuffer) {
+        p_chunkInfo->dwDataOffset = m_info.pchNext - m_info.pchBuffer + m_info.lBufOffset;
+      } else {
+        p_chunkInfo->dwDataOffset = m_info.lDiskOffset;
+      }
+
+      if (p_chunkInfo->ckid == FOURCC_RIFF || p_chunkInfo->ckid == FOURCC_LIST) {
+        if (Read(&p_chunkInfo->fccType, 4) != 4) {
+          result = MMIOERR_CANNOTREAD;
+        }
+      }
+    }
+  } else {
+    MxULong ofs = MAXLONG;
+
+    if (p_parentInfo)
+      ofs = p_parentInfo->cksize + p_parentInfo->dwDataOffset;
+
+    BOOL running = TRUE;
+    BOOL read_ok = FALSE;
+    MMCKINFO tmp;
+    tmp.dwFlags = 0;
+
+    // This loop is... something
+    do {
+      if (Read(&tmp, 8) != 8) {
+        // If the first read fails, report read error. Else EOF.
+        result = read_ok ? MMIOERR_CHUNKNOTFOUND : MMIOERR_CANNOTREAD;
+        running = FALSE;
+      } else {
+        read_ok = TRUE;
+        if (m_info.pchBuffer) {
+          tmp.dwDataOffset = m_info.pchNext - m_info.pchBuffer + m_info.lBufOffset;
+        } else {
+          tmp.dwDataOffset = m_info.lDiskOffset;
+        }
+
+        if (ofs < tmp.dwDataOffset) {
+          result = MMIOERR_CHUNKNOTFOUND;
+          running = FALSE;
+        } else {
+          if ((p_descend == MMIO_FINDLIST && tmp.ckid == FOURCC_LIST) ||
+              (p_descend == MMIO_FINDRIFF && tmp.ckid == FOURCC_RIFF)) {
+            if (Read(&tmp.fccType, 4) != 4) {
+              result = MMIOERR_CANNOTREAD;
+            } else {
+              if (p_chunkInfo->fccType != tmp.fccType)
+                continue;
+            }
+            running = FALSE;
+          } else {
+            if (p_chunkInfo->ckid != tmp.ckid) {
+              if (Seek((tmp.cksize&1)+tmp.cksize, SEEK_CUR) != -1) {
+                continue;
+              } else {
+                result = MMIOERR_CANNOTSEEK;
+              }
+            }
+            running = FALSE;
+          }
+        }
+      }
+
+    } while (running);
+
+    if (!result)
+      memcpy(p_chunkInfo, &tmp, sizeof(MMCKINFO));
+
+  }
+
+  return result;
 }
diff --git a/LEGO1/mxioinfo.h b/LEGO1/mxioinfo.h
index 5ce0947a..83da930a 100644
--- a/LEGO1/mxioinfo.h
+++ b/LEGO1/mxioinfo.h
@@ -12,13 +12,17 @@ class MXIOINFO
   MXIOINFO();
   __declspec(dllexport) ~MXIOINFO();
 
-  MxU16 Open(const char *filename, DWORD fdwOpen);
-  void Close(MxLong arg);
-  LONG Seek(LONG lOffset, int iOrigin);
-  MxULong Read(HPSTR pch, LONG cch);
-  void SetBuffer(LPSTR pchBuffer, LONG cchBuffer, LONG unk);
-  MxU16 Descend(LPMMCKINFO pmmcki, const MMCKINFO *pmmckiParent, UINT fuDescend);
+  MxU16 Open(const char *, MxULong);
+  MxU16 Close(MxLong);
+  MxLong Read(void *, MxLong);
+  MxLong Seek(MxLong, int);
+  MxU16 SetBuffer(char *, MxLong, MxLong);
+  MxU16 Flush(MxU16);
+  MxU16 Advance(MxU16);
+  MxU16 Descend(MMCKINFO *, const MMCKINFO *, MxU16);
 
+  // NOTE: In MXIOINFO, the `hmmio` member of MMIOINFO is used like
+  // an HFILE (int) instead of an HMMIO (WORD).
   MMIOINFO m_info;
 };
 

From 9fa08b101701e2a91f023180d9d847e532fc3818 Mon Sep 17 00:00:00 2001
From: pewpew <brandougherty1@gmail.com>
Date: Sun, 16 Jul 2023 20:38:37 -0500
Subject: [PATCH 02/21] Pretty much match MxNotificationManager::FlushPending.
 (#91)

---
 LEGO1/mxnotificationmanager.cpp | 46 +++++++++++++++++++++++++++++++--
 1 file changed, 44 insertions(+), 2 deletions(-)

diff --git a/LEGO1/mxnotificationmanager.cpp b/LEGO1/mxnotificationmanager.cpp
index 593572bb..b7d001aa 100644
--- a/LEGO1/mxnotificationmanager.cpp
+++ b/LEGO1/mxnotificationmanager.cpp
@@ -111,10 +111,52 @@ void MxNotificationManager::Unregister(MxCore *p_listener)
   }
 }
 
-// OFFSET: LEGO1 0x100ac990 STUB
+// OFFSET: LEGO1 0x100ac990
 void MxNotificationManager::FlushPending(MxCore *p_listener)
 {
-  // TODO
+  MxNotificationPtrList pending;
+  MxNotification *notif;
+
+  {
+    MxAutoLocker lock(&m_lock);
+
+    // Find all notifications from, and addressed to, p_listener.
+    if (m_sendList != NULL) {
+      MxNotificationPtrList::iterator it = m_sendList->begin();
+      while (it != m_sendList->end()) {
+        notif = *it;
+        if ((notif->GetTarget()->GetId() == p_listener->GetId()) ||
+            (notif->GetParam()->GetSender()) && (notif->GetParam()->GetSender()->GetId() == p_listener->GetId())) {
+          m_sendList->erase(it++);
+          pending.push_back(notif);
+        }
+        else {
+          it++;
+        }
+      }
+    }
+
+    MxNotificationPtrList::iterator it = m_queue->begin();
+    while (it != m_queue->end()) {
+      notif = *it;
+      if ((notif->GetTarget()->GetId() == p_listener->GetId()) ||
+          (notif->GetParam()->GetSender()) && (notif->GetParam()->GetSender()->GetId() == p_listener->GetId())) {
+        m_queue->erase(it++);
+        pending.push_back(notif);
+      }
+      else {
+        it++;
+      }
+    }
+  }
+
+  // Deliver those notifications.
+  while (pending.size() != 0) {
+    notif = pending.front();
+    pending.pop_front();
+    notif->GetTarget()->Notify(*notif->GetParam());
+    delete notif;
+  }
 }
 
 // OFFSET: LEGO1 0x100ac6c0

From fa5417f58ab3488f3c7d77b0633110b9fceee8b8 Mon Sep 17 00:00:00 2001
From: Christian Semmler <mail@csemmler.com>
Date: Fri, 21 Jul 2023 21:28:13 -0400
Subject: [PATCH 03/21] lego1: match MxVideoManager::RealizePalette (#92)

* Match MxVideoManager::RealizePalette

* Rename class

* Name some functions
---
 LEGO1/mxdisplaysurface.h | 34 ++++++++++++++++++++++++++++++++++
 LEGO1/mxvideomanager.cpp |  8 ++++----
 LEGO1/mxvideomanager.h   |  3 ++-
 3 files changed, 40 insertions(+), 5 deletions(-)
 create mode 100644 LEGO1/mxdisplaysurface.h

diff --git a/LEGO1/mxdisplaysurface.h b/LEGO1/mxdisplaysurface.h
new file mode 100644
index 00000000..9da02fda
--- /dev/null
+++ b/LEGO1/mxdisplaysurface.h
@@ -0,0 +1,34 @@
+#ifndef MXDISPLAYSURFACE_H
+#define MXDISPLAYSURFACE_H
+
+#include <ddraw.h>
+
+#include "mxcore.h"
+#include "mxpalette.h"
+#include "mxvideoparam.h"
+
+#include "decomp.h"
+
+// VTABLE 0x100dc768
+class MxDisplaySurface : public MxCore
+{
+public:
+  MxDisplaySurface();
+  virtual ~MxDisplaySurface() override;
+
+  virtual MxResult Init(MxVideoParam *p_videoParam, LPDIRECTDRAWSURFACE p_surface1, LPDIRECTDRAWSURFACE p_surface2, LPDIRECTDRAWCLIPPER p_clipper);
+  virtual MxResult Create(MxVideoParam *p_videoParam);
+  virtual void Clear();
+  virtual void SetPalette(MxPalette *p_palette);
+  virtual void vtable24(undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4);
+  virtual MxBool vtable28(undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4);
+  virtual MxBool vtable2c(undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, MxBool);
+  virtual MxBool vtable30(undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, MxBool);
+  virtual undefined4 vtable34(undefined4, undefined4, undefined4, undefined4, undefined4, undefined4);
+  virtual void Display(undefined4, undefined4, undefined4, undefined4, undefined4, undefined4);
+  virtual undefined4 vtable3c(undefined4*);
+  virtual undefined4 vtable40(undefined4);
+  virtual undefined4 vtable44(undefined4, undefined4*, undefined4, undefined4);
+};
+
+#endif // MXDISPLAYSURFACE_H
diff --git a/LEGO1/mxvideomanager.cpp b/LEGO1/mxvideomanager.cpp
index af4995ae..7663743d 100644
--- a/LEGO1/mxvideomanager.cpp
+++ b/LEGO1/mxvideomanager.cpp
@@ -25,7 +25,7 @@ int MxVideoManager::Init()
 {
   this->m_pDirectDraw = NULL;
   this->m_unk54 = NULL;
-  this->m_unk58 = NULL;
+  this->m_displaySurface = NULL;
   this->m_unk5c = 0;
   this->m_videoParam.SetPalette(NULL);
   this->m_unk60 = FALSE;
@@ -45,10 +45,10 @@ MxLong MxVideoManager::RealizePalette(MxPalette *p_palette)
 
   this->m_criticalSection.Enter();
 
-  if (p_palette && this->m_videoParam.GetPalette())
-  {
+  if (p_palette && this->m_videoParam.GetPalette()) {
     p_palette->GetEntries(paletteEntries);
-    // TODO
+    this->m_videoParam.GetPalette()->SetEntries(paletteEntries);
+    this->m_displaySurface->SetPalette(this->m_videoParam.GetPalette());
   }
 
   this->m_criticalSection.Leave();
diff --git a/LEGO1/mxvideomanager.h b/LEGO1/mxvideomanager.h
index 2061ec6b..34511885 100644
--- a/LEGO1/mxvideomanager.h
+++ b/LEGO1/mxvideomanager.h
@@ -2,6 +2,7 @@
 #define MXVIDEOMANAGER_H
 
 #include "mxunknown100dc6b0.h"
+#include "mxdisplaysurface.h"
 #include "mxvideoparam.h"
 
 // VTABLE 0x100dc810
@@ -26,7 +27,7 @@ class MxVideoManager : public MxUnknown100dc6b0
   MxVideoParam m_videoParam;
   LPDIRECTDRAW m_pDirectDraw;
   LPDIRECTDRAWSURFACE m_unk54;
-  void* m_unk58;
+  MxDisplaySurface *m_displaySurface;
   int m_unk5c;
   MxBool m_unk60;
 };

From ac89815663a89f59e26989b711f2bc98e19b71a7 Mon Sep 17 00:00:00 2001
From: Joshua Peisach <itzswirlz2020@outlook.com>
Date: Thu, 3 Aug 2023 12:54:08 -0400
Subject: [PATCH 04/21] =?UTF-8?q?=20=F0=9F=8D=95=20=20(#79)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* start pizza

* Add some pizza vtable functions (they are stubs at the moment)

Unknown parameter types, likely either Pizzeria or PizzaMissionState.

* Pizza: Add/update functions as according to MxCore inheritance

IsleActor::Notify needs to be stubbed
---------

Co-authored-by: Kai Kaufman <ktkaufman@wpi.edu>

* match pizza destructor

* Update pizza members

* add size asserts

---------

Co-authored-by: Kai Kaufman <ktkaufman@wpi.edu>
Co-authored-by: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
---
 CMakeLists.txt      |  1 +
 LEGO1/isleactor.cpp |  3 +++
 LEGO1/legoactor.cpp |  3 +++
 LEGO1/legoactor.h   |  5 +++++
 LEGO1/pizza.cpp     | 25 +++++++++++++++++++++----
 LEGO1/pizza.h       | 28 ++++++++++++++++++++++++++++
 6 files changed, 61 insertions(+), 4 deletions(-)
 create mode 100644 LEGO1/legoactor.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index fa4de1e5..8f0980d0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -46,6 +46,7 @@ add_library(lego1 SHARED
   LEGO1/jukeboxstate.cpp
   LEGO1/legoact2state.cpp
   LEGO1/legoactioncontrolpresenter.cpp
+  LEGO1/legoactor.cpp
   LEGO1/legoanimactor.cpp
   LEGO1/legoanimationmanager.cpp
   LEGO1/legoanimmmpresenter.cpp
diff --git a/LEGO1/isleactor.cpp b/LEGO1/isleactor.cpp
index ca286e37..a28afc6b 100644
--- a/LEGO1/isleactor.cpp
+++ b/LEGO1/isleactor.cpp
@@ -1 +1,4 @@
 #include "isleactor.h"
+
+// NOTE: This is copied from base class LegoActor. IsleActor may in fact be larger but we don't know yet.
+DECOMP_SIZE_ASSERT(IsleActor, 0x78)
diff --git a/LEGO1/legoactor.cpp b/LEGO1/legoactor.cpp
new file mode 100644
index 00000000..c26cc1fc
--- /dev/null
+++ b/LEGO1/legoactor.cpp
@@ -0,0 +1,3 @@
+#include "legoactor.h"
+
+DECOMP_SIZE_ASSERT(LegoActor, 0x78)
diff --git a/LEGO1/legoactor.h b/LEGO1/legoactor.h
index 9b23e943..828f48ad 100644
--- a/LEGO1/legoactor.h
+++ b/LEGO1/legoactor.h
@@ -1,6 +1,7 @@
 #ifndef LEGOACTOR_H
 #define LEGOACTOR_H
 
+#include "decomp.h"
 #include "legoentity.h"
 
 // VTABLE 0x100d6d68
@@ -20,6 +21,10 @@ class LegoActor : public LegoEntity
   {
     return !strcmp(name, LegoActor::ClassName()) || LegoEntity::IsA(name);
   }
+
+private:
+  undefined unk04_[0x68];
+
 };
 
 #endif // LEGOACTOR_H
diff --git a/LEGO1/pizza.cpp b/LEGO1/pizza.cpp
index e7e9c552..93f67aaa 100644
--- a/LEGO1/pizza.cpp
+++ b/LEGO1/pizza.cpp
@@ -1,13 +1,30 @@
 #include "pizza.h"
 
-// OFFSET: LEGO1 0x10037ef0 STUB
+#include "decomp.h"
+
+DECOMP_SIZE_ASSERT(Pizza, 0x9c);
+
+// OFFSET: LEGO1 0x10037ef0
 Pizza::Pizza()
 {
-  // TODO
+  // FIXME: This inherits from LegoActor, probably why this isn't matching
+  this->m_unk80 = 0;
+  this->m_unk84 = 0;
+  this->m_unk88 = 0;
+  this->m_unk8c = -1;
+  this->m_unk98 = 0;
+  this->m_unk90 = 0x80000000;
 }
 
-// OFFSET: LEGO1 0x10038100 STUB
+// OFFSET: LEGO1 0x10038100
 Pizza::~Pizza()
 {
-  // TODO
+  TickleManager()->Unregister(this);
+}
+
+// OFFSET: LEGO1 0x100388a0
+MxResult Pizza::Tickle()
+{
+  // TODO
+  return SUCCESS;
 }
diff --git a/LEGO1/pizza.h b/LEGO1/pizza.h
index c47ef40e..34d781c9 100644
--- a/LEGO1/pizza.h
+++ b/LEGO1/pizza.h
@@ -2,6 +2,10 @@
 #define PIZZA_H
 
 #include "isleactor.h"
+#include "mxcore.h"
+#include "mxomni.h"
+#include "mxticklemanager.h"
+#include "mxtypes.h"
 
 // VTABLE 0x100d7380
 // SIZE 0x9c
@@ -11,6 +15,30 @@ class Pizza : public IsleActor
   Pizza();
   virtual ~Pizza() override;
 
+  virtual MxResult Tickle() override; // vtable+08
+
+  // OFFSET: LEGO1 0x10037f90
+  inline const char *ClassName() const //vtable+0c
+  {
+    // 0x100f038c
+    return "Pizza";
+  }
+
+  // OFFSET: LEGO1 0x10037fa0
+  inline MxBool Pizza::IsA(const char *name) const override //vtable+10
+  {
+    return !strcmp(name, Pizza::ClassName()) || IsleActor::IsA(name);
+  }
+private:
+  MxS32 m_unk78;
+  MxS32 m_unk7c;
+  MxS32 m_unk80;
+  MxS32 m_unk84;
+  MxS32 m_unk88;
+  MxS32 m_unk8c;
+  MxU32 m_unk90;
+  MxS32 m_unk94;
+  MxS32 m_unk98;
 };
 
 #endif // PIZZA_H

From db2b98c248a97d22dacca38dc5382095e288cbc5 Mon Sep 17 00:00:00 2001
From: Roman Masanin <52833910+theR4K@users.noreply.github.com>
Date: Thu, 3 Aug 2023 19:09:22 +0200
Subject: [PATCH 05/21] MxDirectDraw functions and structures (#33)

* MxDirectDraw functions and structures

* fix indents, and globals

* fix build, add mxdirectdraw build configuration

* add new files to cmake

* MxDirectDraw: Add code from my PR #19 on main repo

Merging in the missing functions from my pull request for MxDirectDraw on the main repo. Credit to @foxtacles for the GetPrimaryBitDepth function. All match 100% on reccmp except ErrorToString, but the problem there is with the jump table at the end.

Co-authored-by: Christian Semmler <mail@csemmler.com>

* improve match

* improve accuracy

* improve accuracy

* move _countof, impove up to 96.90%

* Update LEGO1/mxdirectdraw.h

Co-authored-by: MattKC <34096995+itsmattkc@users.noreply.github.com>

* Update LEGO1/mxdirectdraw.cpp

Co-authored-by: MattKC <34096995+itsmattkc@users.noreply.github.com>

* Update LEGO1/mxdirectdraw.cpp

Co-authored-by: MattKC <34096995+itsmattkc@users.noreply.github.com>

* Update LEGO1/mxdirectdraw.cpp

Co-authored-by: MattKC <34096995+itsmattkc@users.noreply.github.com>

* Update LEGO1/mxdirectdraw.cpp

* Update LEGO1/mxdirectdraw.cpp

---------

Co-authored-by: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Co-authored-by: disinvite <disinvite@users.noreply.github.com>
Co-authored-by: Christian Semmler <mail@csemmler.com>
---
 .gitignore             |    1 +
 LEGO1/decomp.h         |    4 +
 LEGO1/mxdirect3d.cpp   |    0
 LEGO1/mxdirect3d.h     |    0
 LEGO1/mxdirectdraw.cpp | 1221 +++++++++++++++++++++++++++++++++++++++-
 LEGO1/mxdirectdraw.h   |  118 ++++
 6 files changed, 1334 insertions(+), 10 deletions(-)
 create mode 100644 LEGO1/mxdirect3d.cpp
 create mode 100644 LEGO1/mxdirect3d.h

diff --git a/.gitignore b/.gitignore
index 402fb660..8768f944 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,7 @@
 Debug/
 Release/
 *.ncb
+/.vs
 ISLE.EXE
 LEGO1.DLL
 build/
diff --git a/LEGO1/decomp.h b/LEGO1/decomp.h
index 5466e6d8..cd179ae6 100644
--- a/LEGO1/decomp.h
+++ b/LEGO1/decomp.h
@@ -4,6 +4,10 @@
 #define DECOMP_STATIC_ASSERT(V) namespace { typedef int foo[(V)?1:-1]; }
 #define DECOMP_SIZE_ASSERT(T, S) DECOMP_STATIC_ASSERT(sizeof(T) == S)
 
+#ifndef _countof
+#define _countof(arr) sizeof(arr) / sizeof(arr[0])
+#endif
+
 typedef unsigned char undefined;
 typedef unsigned short undefined2;
 typedef unsigned int undefined4;
diff --git a/LEGO1/mxdirect3d.cpp b/LEGO1/mxdirect3d.cpp
new file mode 100644
index 00000000..e69de29b
diff --git a/LEGO1/mxdirect3d.h b/LEGO1/mxdirect3d.h
new file mode 100644
index 00000000..e69de29b
diff --git a/LEGO1/mxdirectdraw.cpp b/LEGO1/mxdirectdraw.cpp
index dde59ba0..dbe07d12 100644
--- a/LEGO1/mxdirectdraw.cpp
+++ b/LEGO1/mxdirectdraw.cpp
@@ -1,22 +1,1223 @@
-#include "mxdirectdraw.h"
 
-// OFFSET: LEGO1 0x1009e7f0
-int MxDirectDraw::FlipToGDISurface()
+#include "mxdirectdraw.h"
+#include "decomp.h"
+
+
+#ifndef DDSCAPS_3DDEVICE
+#define DDSCAPS_3DDEVICE 0x00002000l
+#endif
+
+// GLOBAL OFFSET: LEGO1 0x10100C68
+extern BOOL g_is_PALETTEINDEXED8 = 0;
+
+// OFFSET: LEGO1 0x1009DA20
+void EnableResizing(HWND hwnd, BOOL flag)
 {
-  // TODO
-  return 0;
+  static DWORD dwStyle;
+
+  if (!flag)
+  {
+    dwStyle = GetWindowLong(hwnd, GWL_STYLE);
+    if (dwStyle & WS_THICKFRAME)
+    {
+      SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) ^ WS_THICKFRAME);
+    }
+  }
+  else
+  {
+    SetWindowLong(hwnd, GWL_STYLE, dwStyle);
+  }
+}
+
+// OFFSET: LEGO1 0x1009EFD0
+MxDirectDraw::DeviceModesInfo::~DeviceModesInfo()
+{
+  if (p_guid != NULL)
+  {
+    delete p_guid;
+  }
+
+  if (m_mode_ARRAY != NULL)
+  {
+    delete m_mode_ARRAY;
+  }
+}
+
+// OFFSET: LEGO1 0x1009D490
+MxDirectDraw::MxDirectDraw()
+{
+  m_pFrontBuffer = NULL;
+  m_pBackBuffer = NULL;
+  m_pZBuffer = NULL;
+  m_pClipper = NULL;
+  m_pPalette = NULL;
+  m_pDirectDraw = NULL;
+  m_pText1Surface = NULL;
+  m_pText2Surface = NULL;
+  m_hWndMain = NULL;
+  m_bIgnoreWM_SIZE = FALSE;
+  m_bPrimaryPalettized = FALSE;
+  m_bOnlySystemMemory = FALSE;
+  m_bFullScreen = FALSE;
+  m_bOnlySoftRender = FALSE;
+  m_pauseCount = 0;
+  m_pErrorHandler = NULL;
+  m_pFatalErrorHandler = NULL;
+  m_pErrorHandlerArg = NULL;
+  m_pFatalErrorHandlerArg = NULL;
+  m_pCurrentDeviceModesList = NULL;
+  m_bIsOnPrimaryDevice = TRUE;
+  m_hFont = NULL;
+}
+
+// OFFSET: LEGO1 0x1009D530
+MxDirectDraw::~MxDirectDraw()
+{
+  Destroy();
+
+  if (m_pCurrentDeviceModesList != NULL)
+  {
+    delete m_pCurrentDeviceModesList;
+    m_pCurrentDeviceModesList = NULL;
+  }
 }
 
 // OFFSET: LEGO1 0x1009d570
 int MxDirectDraw::GetPrimaryBitDepth()
 {
-  // TODO
-  return 0;
+  DWORD dwRGBBitCount;
+  LPDIRECTDRAW pDDraw;
+  DDSURFACEDESC ddsd;
+
+  HRESULT result = DirectDrawCreate(NULL, &pDDraw, NULL);
+  dwRGBBitCount = 8;
+  if (!result)
+  {
+    memset(&ddsd, 0, sizeof(ddsd));
+    ddsd.dwSize = sizeof(ddsd);
+
+    pDDraw->GetDisplayMode(&ddsd);
+    dwRGBBitCount = ddsd.ddpfPixelFormat.dwRGBBitCount;
+    g_is_PALETTEINDEXED8 = (ddsd.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) != 0;
+    pDDraw->Release();
+}
+
+  return dwRGBBitCount;
+}
+
+// OFFSET: LEGO1 0x1009D5E0
+BOOL MxDirectDraw::Create(
+  HWND hWnd,
+  BOOL fullscreen_1,
+  BOOL surface_fullscreen,
+  BOOL onlySystemMemory,
+  int width,
+  int height,
+  int bpp,
+  const PALETTEENTRY* pPaletteEntries,
+  int paletteEntryCount)
+{
+  m_hWndMain = hWnd;
+
+  CacheOriginalPaletteEntries();
+
+  if (!RecreateDirectDraw(&m_pCurrentDeviceModesList->p_guid))
+  {
+    return FALSE;
+  }
+
+  m_bFlipSurfaces = surface_fullscreen;
+  m_bOnlySystemMemory = onlySystemMemory;
+  m_bIsOnPrimaryDevice = !m_pCurrentDeviceModesList->p_guid;
+  BOOL fullscreen = 1;
+  
+  if (m_bIsOnPrimaryDevice)
+  {
+    fullscreen = fullscreen_1;
+  }
+
+  if (!SetPaletteEntries(pPaletteEntries, paletteEntryCount, fullscreen))
+  {
+    return FALSE;
+  }
+
+  if (!DDInit(fullscreen))
+  {
+    return FALSE;
+  }
+
+  if (!DDSetMode(width, height, bpp))
+  {
+    return FALSE;
+  }
+
+  return TRUE;
+}
+
+// OFFSET: LEGO1 0x1009D800
+void MxDirectDraw::Destroy()
+{
+  DestroyButNotDirectDraw();
+
+  FUN_1009D920();
+
+  if (m_pDirectDraw != NULL)
+  {
+    m_pDirectDraw->Release();
+    m_pDirectDraw = NULL;
+  }
+
+  m_bIsOnPrimaryDevice = TRUE;
+
+  if (m_pCurrentDeviceModesList != NULL)
+  {
+    delete m_pCurrentDeviceModesList;
+    m_pCurrentDeviceModesList = NULL;
+  }
+}
+
+// OFFSET: LEGO1 0x1009D860
+void MxDirectDraw::DestroyButNotDirectDraw()
+{
+  RestoreOriginalPaletteEntries();
+  if (m_bFullScreen)
+  {
+    if (m_pDirectDraw != NULL)
+    {
+      m_bIgnoreWM_SIZE = TRUE;
+      m_pDirectDraw->RestoreDisplayMode();
+      m_bIgnoreWM_SIZE = FALSE;
+    }
+  }
+
+  if (m_pPalette)
+  {
+    m_pPalette->Release();
+    m_pPalette = NULL;
+  }
+
+  if (m_pClipper)
+  {
+    m_pClipper->Release();
+    m_pClipper = NULL;
+  }
+
+  if (m_pText1Surface)
+  {
+    m_pText1Surface->Release();
+    m_pText1Surface = NULL;
+  }
+
+  if (m_pText2Surface)
+  {
+    m_pText2Surface->Release();
+    m_pText2Surface = NULL;
+  }
+
+  if (m_pZBuffer)
+  {
+    m_pZBuffer->Release();
+    m_pZBuffer = NULL;
+  }
+
+  if (m_pBackBuffer)
+  {
+    m_pBackBuffer->Release();
+    m_pBackBuffer = NULL;
+  }
+
+  if (m_pFrontBuffer)
+  {
+    m_pFrontBuffer->Release();
+    m_pFrontBuffer = NULL;
+  }
 }
 
 // OFFSET: LEGO1 0x1009e6a0
-int MxDirectDraw::Pause(int)
+int MxDirectDraw::Pause(int p_increment)
 {
-  // TODO
-  return 0;
+  if (p_increment)
+  {
+    m_pauseCount++;
+
+    if (m_pauseCount > 1)
+    {
+      return TRUE;
+    }
+
+    if (!RestoreOriginalPaletteEntries())
+    {
+      return FALSE;
+    }
+
+    if (m_bFullScreen)
+    {
+      if (!FlipToGDISurface())
+      {
+        return FALSE;
+      }
+
+      DrawMenuBar(m_hWndMain);
+      RedrawWindow(m_hWndMain, NULL, NULL, RDW_FRAME);
+    }
+  }
+  else
+  {
+    m_pauseCount--;
+    if (m_pauseCount > 0)
+    {
+      return TRUE;
+    }
+    else if (m_pauseCount < 0)
+    {
+      m_pauseCount = 0;
+    }
+
+    if (!RestorePaletteEntries())
+    {
+      return FALSE;
+    }
+  }
+
+  return TRUE;
 }
+
+// OFFSET: LEGO1 0x1009E880
+const char* MxDirectDraw::ErrorToString(HRESULT error)
+{
+  switch(error) {
+    case DD_OK:
+      return "No error.\0";
+    case DDERR_ALREADYINITIALIZED:
+      return "This object is already initialized.\0";
+    case DDERR_BLTFASTCANTCLIP:
+      return "Return if a clipper object is attached to the source surface passed into a BltFast call.\0";
+    case DDERR_CANNOTATTACHSURFACE:
+      return "This surface can not be attached to the requested surface.\0";
+    case DDERR_CANNOTDETACHSURFACE:
+      return "This surface can not be detached from the requested surface.\0";
+    case DDERR_CANTCREATEDC:
+      return "Windows can not create any more DCs.\0";
+    case DDERR_CANTDUPLICATE:
+      return "Can't duplicate primary & 3D surfaces, or surfaces that are implicitly created.\0";
+    case DDERR_CLIPPERISUSINGHWND:
+      return "An attempt was made to set a cliplist for a clipper object that is already monitoring an hwnd.\0";
+    case DDERR_COLORKEYNOTSET:
+      return "No src color key specified for this operation.\0";
+    case DDERR_CURRENTLYNOTAVAIL:
+      return "Support is currently not available.\0";
+    case DDERR_DIRECTDRAWALREADYCREATED:
+      return "A DirectDraw object representing this driver has already been created for this process.\0";
+    case DDERR_EXCEPTION:
+      return "An exception was encountered while performing the requested operation.\0";
+    case DDERR_EXCLUSIVEMODEALREADYSET:
+      return "An attempt was made to set the cooperative level when it was already set to exclusive.\0";
+    case DDERR_GENERIC:
+      return "Generic failure.\0";
+    case DDERR_HEIGHTALIGN:
+      return "Height of rectangle provided is not a multiple of reqd alignment.\0";
+    case DDERR_HWNDALREADYSET:
+      return "The CooperativeLevel HWND has already been set. It can not be reset while the process has surfaces or palettes created.\0";
+    case DDERR_HWNDSUBCLASSED:
+      return "HWND used by DirectDraw CooperativeLevel has been subclassed, this prevents DirectDraw from restoring state.\0";
+    case DDERR_IMPLICITLYCREATED:
+      return "This surface can not be restored because it is an implicitly created surface.\0";
+    case DDERR_INCOMPATIBLEPRIMARY:
+      return "Unable to match primary surface creation request with existing primary surface.\0";
+    case DDERR_INVALIDCAPS:
+      return "One or more of the caps bits passed to the callback are incorrect.\0";
+    case DDERR_INVALIDCLIPLIST:
+      return "DirectDraw does not support the provided cliplist.\0";
+    case DDERR_INVALIDDIRECTDRAWGUID:
+      return "The GUID passed to DirectDrawCreate is not a valid DirectDraw driver identifier.\0";
+    case DDERR_INVALIDMODE:
+      return "DirectDraw does not support the requested mode.\0";
+    case DDERR_INVALIDOBJECT:
+      return "DirectDraw received a pointer that was an invalid DIRECTDRAW object.\0";
+    case DDERR_INVALIDPARAMS:
+      return "One or more of the parameters passed to the function are incorrect.\0";
+    case DDERR_INVALIDPIXELFORMAT:
+      return "The pixel format was invalid as specified.\0";
+    case DDERR_INVALIDPOSITION:
+      return "Returned when the position of the overlay on the destination is no longer legal for that destination.\0";
+    case DDERR_INVALIDRECT:
+      return "Rectangle provided was invalid.\0";
+    case DDERR_LOCKEDSURFACES:
+      return "Operation could not be carried out because one or more surfaces are locked.\0";
+    case DDERR_NO3D:
+      return "There is no 3D present.\0";
+    case DDERR_NOALPHAHW:
+      return "Operation could not be carried out because there is no alpha accleration hardware present or available.\0";
+    case DDERR_NOBLTHW:
+      return "No blitter hardware present.\0";
+    case DDERR_NOCLIPLIST:
+      return "No cliplist available.\0";
+    case DDERR_NOCLIPPERATTACHED:
+      return "No clipper object attached to surface object.\0";
+    case DDERR_NOCOLORCONVHW:
+      return "Operation could not be carried out because there is no color conversion hardware present or available.\0";
+    case DDERR_NOCOLORKEY:
+      return "Surface doesn't currently have a color key\0";
+    case DDERR_NOCOLORKEYHW:
+      return "Operation could not be carried out because there is no hardware support of the destination color key.\0";
+    case DDERR_NOCOOPERATIVELEVELSET:
+      return "Create function called without DirectDraw object method SetCooperativeLevel being called.\0";
+    case DDERR_NODC:
+      return "No DC was ever created for this surface.\0";
+    case DDERR_NODDROPSHW:
+      return "No DirectDraw ROP hardware.\0";
+    case DDERR_NODIRECTDRAWHW:
+      return "A hardware-only DirectDraw object creation was attempted but the driver did not support any hardware.\0";
+    case DDERR_NOEMULATION:
+      return "Software emulation not available.\0";
+    case DDERR_NOEXCLUSIVEMODE:
+      return "Operation requires the application to have exclusive mode but the application does not have exclusive mode.\0";
+    case DDERR_NOFLIPHW:
+      return "Flipping visible surfaces is not supported.\0";
+    case DDERR_NOGDI:
+      return "There is no GDI present.\0";
+    case DDERR_NOHWND:
+      return "Clipper notification requires an HWND or no HWND has previously been set as the CooperativeLevel HWND.\0";
+    case DDERR_NOMIRRORHW:
+      return "Operation could not be carried out because there is no hardware present or available.\0";
+    case DDERR_NOOVERLAYDEST:
+      return "Returned when GetOverlayPosition is called on an overlay that UpdateOverlay has never been called on to establish a destination.\0";
+    case DDERR_NOOVERLAYHW:
+      return "Operation could not be carried out because there is no overlay hardware present or available.\0";
+    case DDERR_NOPALETTEATTACHED:
+      return "No palette object attached to this surface.\0";
+    case DDERR_NOPALETTEHW:
+      return "No hardware support for 16 or 256 color palettes.\0";
+    case DDERR_NORASTEROPHW:
+      return "Operation could not be carried out because there is no appropriate raster op hardware present or available.\0";
+    case DDERR_NOROTATIONHW:
+      return "Operation could not be carried out because there is no rotation hardware present or available.\0";
+    case DDERR_NOSTRETCHHW:
+      return "Operation could not be carried out because there is no hardware support for stretching.\0";
+    case DDERR_NOT4BITCOLOR:
+      return "DirectDrawSurface is not in 4 bit color palette and the requested operation requires 4 bit color palette.\0";
+    case DDERR_NOT4BITCOLORINDEX:
+      return "DirectDrawSurface is not in 4 bit color index palette and the requested operation requires 4 bit color index palette.\0";
+    case DDERR_NOT8BITCOLOR:
+      return "DirectDrawSurface is not in 8 bit color mode and the requested operation requires 8 bit color.\0";
+    case DDERR_NOTAOVERLAYSURFACE:
+      return "Returned when an overlay member is called for a non-overlay surface.\0";
+    case DDERR_NOTEXTUREHW:
+      return "Operation could not be carried out because there is no texture mapping hardware present or available.\0";
+    case DDERR_NOTFLIPPABLE:
+      return "An attempt has been made to flip a surface that is not flippable.\0";
+    case DDERR_NOTFOUND:
+      return "Requested item was not found.\0";
+    case DDERR_NOTLOCKED:
+      return "Surface was not locked.  An attempt to unlock a surface that was not locked at all, or by this process, has been attempted.\0";
+    case DDERR_NOTPALETTIZED:
+      return "The surface being used is not a palette-based surface.\0";
+    case DDERR_NOVSYNCHW:
+      return "Operation could not be carried out because there is no hardware support for vertical blank synchronized operations.\0";
+    case DDERR_NOZBUFFERHW:
+      return "Operation could not be carried out because there is no hardware support for zbuffer blitting.\0";
+    case DDERR_NOZOVERLAYHW:
+      return "Overlay surfaces could not be z layered based on their BltOrder because the hardware does not support z layering of overlays.\0";
+    case DDERR_OUTOFCAPS:
+      return "The hardware needed for the requested operation has already been allocated.\0";
+    case DDERR_OUTOFMEMORY:
+      return "DirectDraw does not have enough memory to perform the operation.\0";
+    case DDERR_OUTOFVIDEOMEMORY:
+      return "DirectDraw does not have enough memory to perform the operation.\0";
+    case DDERR_OVERLAYCANTCLIP:
+      return "The hardware does not support clipped overlays.\0";
+    case DDERR_OVERLAYCOLORKEYONLYONEACTIVE:
+      return "Can only have ony color key active at one time for overlays.\0";
+    case DDERR_OVERLAYNOTVISIBLE:
+      return "Returned when GetOverlayPosition is called on a hidden overlay.\0";
+    case DDERR_PALETTEBUSY:
+      return "Access to this palette is being refused because the palette is already locked by another thread.\0";
+    case DDERR_PRIMARYSURFACEALREADYEXISTS:
+      return "This process already has created a primary surface.\0";
+    case DDERR_REGIONTOOSMALL:
+      return "Region passed to Clipper::GetClipList is too small.\0";
+    case DDERR_SURFACEALREADYATTACHED:
+      return "This surface is already attached to the surface it is being attached to.\0";
+    case DDERR_SURFACEALREADYDEPENDENT:
+      return "This surface is already a dependency of the surface it is being made a dependency of.\0";
+    case DDERR_SURFACEBUSY:
+      return "Access to this surface is being refused because the surface is already locked by another thread.\0";
+    case DDERR_SURFACEISOBSCURED:
+      return "Access to surface refused because the surface is obscured.\0";
+    case DDERR_SURFACELOST:
+      return "Access to this surface is being refused because the surface memory is gone. The DirectDrawSurface object representing this surface should have Restore called on it.\0";
+    case DDERR_SURFACENOTATTACHED:
+      return "The requested surface is not attached.\0";
+    case DDERR_TOOBIGHEIGHT:
+      return "Height requested by DirectDraw is too large.\0";
+    case DDERR_TOOBIGSIZE:
+      return "Size requested by DirectDraw is too large, but the individual height and width are OK.\0";
+    case DDERR_TOOBIGWIDTH:
+      return "Width requested by DirectDraw is too large.\0";
+    case DDERR_UNSUPPORTED:
+      return "Action not supported.\0";
+    case DDERR_UNSUPPORTEDFORMAT:
+      return "FOURCC format requested is unsupported by DirectDraw.\0";
+    case DDERR_UNSUPPORTEDMASK:
+      return "Bitmask in the pixel format requested is unsupported by DirectDraw.\0";
+    case DDERR_VERTICALBLANKINPROGRESS:
+      return "Vertical blank is in progress.\0";
+    case DDERR_WASSTILLDRAWING:
+      return "Informs DirectDraw that the previous Blt which is transfering information to or from this Surface is incomplete.\0";
+    case DDERR_WRONGMODE:
+      return "This surface can not be restored because it was created in a different mode.\0";
+    case DDERR_XALIGN:
+      return "Rectangle provided was not horizontally aligned on required boundary.\0";
+    default:
+      return "Unrecognized error value.\0";
+  }
+}
+
+
+// OFFSET: LEGO1 0x1009D6C0
+BOOL MxDirectDraw::CacheOriginalPaletteEntries()
+{
+  HDC DC;
+
+  if (g_is_PALETTEINDEXED8)
+  {
+    DC = GetDC(0);
+    GetSystemPaletteEntries(DC, 0, _countof(m_originalPaletteEntries), m_originalPaletteEntries);
+    ReleaseDC(0, DC);
+  }
+  return TRUE;
+}
+
+
+// OFFSET: LEGO1 0x1009DD80
+HRESULT MxDirectDraw::CreateDDSurface(
+  LPDDSURFACEDESC a2,
+  LPDIRECTDRAWSURFACE* a3,
+  IUnknown* a4)
+{
+  return m_pDirectDraw->CreateSurface(a2, a3, a4);
+}
+
+// OFFSET: LEGO1 0x1009E250
+BOOL MxDirectDraw::CreateTextSurfaces()
+{
+  HRESULT result;
+  DDCOLORKEY ddck;
+  DDSURFACEDESC ddsd;
+  HDC DC;
+  char dummyinfo[] = "000x000x00 (RAMP) 0000";
+  char dummyfps[] = "000.00 fps (000.00 fps (000.00 fps) 00000 tps)";
+
+  if (m_hFont != NULL)
+  {
+    DeleteObject(m_hFont);
+  }
+
+  m_hFont = CreateFontA(m_currentMode.width <= 600 ? 12 : 24,
+    0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE,
+    ANSI_CHARSET,
+    OUT_DEFAULT_PRECIS,
+    CLIP_DEFAULT_PRECIS,
+    DEFAULT_QUALITY,
+    VARIABLE_PITCH,
+    "Arial");
+
+  DC = GetDC(NULL);
+  SelectObject(DC, m_hFont);
+  GetTextExtentPointA(DC, dummyfps, strlen(dummyfps), &m_text1SizeOnSurface);
+  GetTextExtentPointA(DC, dummyinfo, strlen(dummyinfo), &m_text2SizeOnSurface);
+  ReleaseDC(NULL, DC);
+
+  memset(&ddsd, 0, sizeof(ddsd));
+  ddsd.dwSize = sizeof(ddsd);
+  ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
+  ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
+  if (m_bOnlySystemMemory)
+    ddsd.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY | DDSCAPS_OFFSCREENPLAIN;
+  ddsd.dwHeight = m_text1SizeOnSurface.cy;
+  ddsd.dwWidth = m_text1SizeOnSurface.cx;
+
+  result = CreateDDSurface(&ddsd, &m_pText1Surface, 0);
+  if (result != DD_OK)
+  {
+    Error("CreateSurface for text surface 1 failed", result);
+    return FALSE;
+  }
+
+  memset(&ddck, 0, sizeof(ddck));
+  m_pText1Surface->SetColorKey(DDCKEY_SRCBLT, &ddck);
+  if (!TextToTextSurface1(dummyfps))
+  {
+    return FALSE;
+  }
+
+  memset(&ddsd, 0, sizeof(ddsd));
+  ddsd.dwSize = sizeof(ddsd);
+  ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
+  ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
+  if (m_bOnlySystemMemory)
+    ddsd.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY | DDSCAPS_OFFSCREENPLAIN;
+  ddsd.dwHeight = m_text2SizeOnSurface.cy;
+  ddsd.dwWidth = m_text2SizeOnSurface.cx;
+
+  result = CreateDDSurface(&ddsd, &m_pText2Surface, 0);
+  if (result != DD_OK)
+  {
+    Error("CreateSurface for text surface 2 failed", result);
+    return FALSE;
+  }
+
+  memset(&ddck, 0, sizeof(ddck));
+  m_pText2Surface->SetColorKey(DDCKEY_SRCBLT, &ddck);
+  if (!TextToTextSurface2(dummyinfo))
+  {
+    return FALSE;
+  }
+
+  return TRUE;
+}
+
+// OFFSET: LEGO1 0x1009E5E0
+BOOL MxDirectDraw::CreateZBuffer(DWORD memorytype, DWORD depth)
+{
+  HRESULT result; // eax
+  LPDIRECTDRAWSURFACE lpZBuffer; // [esp+8h] [ebp-70h] BYREF
+  DDSURFACEDESC ddsd;
+
+  memset(&ddsd, 0, sizeof(ddsd));
+  ddsd.dwSize = sizeof(ddsd);
+  ddsd.dwHeight = m_currentMode.height;
+  ddsd.dwWidth = m_currentMode.width;
+  ddsd.dwZBufferBitDepth = depth;
+  ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_ZBUFFERBITDEPTH;
+  ddsd.ddsCaps.dwCaps = DDSCAPS_ZBUFFER | memorytype;
+
+  result = CreateDDSurface(&ddsd, &lpZBuffer, 0);
+  if (result != DD_OK)
+  {
+    Error("CreateSurface for fullScreen Z-buffer failed", result);
+    return FALSE;
+  }
+
+  result = m_pBackBuffer->AddAttachedSurface(lpZBuffer);
+  if (result != DD_OK)
+  {
+    Error("AddAttachedBuffer failed for Z-Buffer", result);
+    return FALSE;
+  }
+
+  m_pZBuffer = lpZBuffer;
+  return TRUE;
+}
+
+// OFFSET: LEGO1 0x1009DDF0
+BOOL MxDirectDraw::DDCreateSurfaces()
+{
+  HRESULT result;
+  DDSCAPS ddscaps;
+  DDSURFACEDESC ddsd;
+
+  if (m_bFlipSurfaces)
+  {
+    memset(&ddsd, 0, sizeof(ddsd));
+    ddsd.dwSize = sizeof(ddsd);
+    ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
+    ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_3DDEVICE | DDSCAPS_COMPLEX;
+    if (m_bOnlySystemMemory)
+    {
+      ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_3DDEVICE | DDSCAPS_COMPLEX | DDSCAPS_SYSTEMMEMORY;
+    }
+    ddsd.dwBackBufferCount = 1;
+    result = CreateDDSurface(&ddsd, &m_pFrontBuffer, 0);
+    if (result != DD_OK)
+    {
+      Error("CreateSurface for front/back fullScreen buffer failed", result);
+      return FALSE;
+    }
+
+    ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
+    result = m_pFrontBuffer->GetAttachedSurface(&ddscaps, &m_pBackBuffer);
+    if (result != DD_OK)
+    {
+      Error("GetAttachedSurface failed to get back buffer", result);
+      return FALSE;
+    }
+    if (!GetDDSurfaceDesc(&ddsd, m_pBackBuffer))
+    {
+      return FALSE;
+    }
+  }
+  else
+  {
+    memset(&ddsd, 0, sizeof(ddsd));
+    ddsd.dwSize = sizeof(ddsd);
+    ddsd.dwFlags = DDSD_CAPS;
+    ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
+    result = CreateDDSurface(&ddsd, &m_pFrontBuffer, NULL);
+    if (result != DD_OK)
+    {
+      Error("CreateSurface for window front buffer failed", result);
+      return FALSE;
+    }
+    ddsd.dwHeight = m_currentMode.height;
+    ddsd.dwWidth = m_currentMode.width;
+    ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS;
+    ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE;
+    if (m_bOnlySystemMemory)
+      ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE | DDSCAPS_SYSTEMMEMORY;
+    result = CreateDDSurface(&ddsd, &m_pBackBuffer, NULL);
+    if (result != DD_OK)
+    {
+      Error("CreateSurface for window back buffer failed", result);
+      return FALSE;
+    }
+
+    if (!GetDDSurfaceDesc(&ddsd, m_pBackBuffer))
+    {
+      return FALSE;
+    }
+
+    result = m_pDirectDraw->CreateClipper(0, &m_pClipper, NULL);
+    if (result != DD_OK)
+    {
+      Error("CreateClipper failed", result);
+      return FALSE;
+    }
+    result = m_pClipper->SetHWnd(0, m_hWndMain);
+    if (result != DD_OK)
+    {
+      Error("Clipper SetHWnd failed", result);
+      return FALSE;
+    }
+    result = m_pFrontBuffer->SetClipper(m_pClipper);
+    if (result != DD_OK)
+    {
+      Error("SetClipper failed", result);
+      return FALSE;
+    }
+  }
+
+  return TRUE;
+}
+
+// OFFSET: LEGO1 0x1009D960
+BOOL MxDirectDraw::DDInit(BOOL fullscreen)
+{
+  HRESULT result;
+
+  if (fullscreen)
+  {
+    m_bIgnoreWM_SIZE = 1;
+    result = m_pDirectDraw->SetCooperativeLevel(m_hWndMain, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
+    m_bIgnoreWM_SIZE = 0;
+  }
+  else
+  {
+    result = m_pDirectDraw->SetCooperativeLevel(m_hWndMain, DDSCL_NORMAL);
+  }
+
+  if (result != DD_OK)
+  {
+    Error("SetCooperativeLevel failed", result);
+    return FALSE;
+  }
+
+  m_bFullScreen = fullscreen;
+
+  return TRUE;
+}
+
+// OFFSET: LEGO1 0x1009DA80
+BOOL MxDirectDraw::DDSetMode(int width, int height, int bpp)
+{
+  HRESULT result;
+
+  if (m_bFullScreen)
+  {
+    LPDIRECTDRAW lpDD;
+
+    EnableResizing(m_hWndMain, FALSE);
+
+	if (!m_bIsOnPrimaryDevice)
+    {
+      lpDD = NULL;
+      result = DirectDrawCreate(0, &lpDD, 0);
+      if (result == DD_OK)
+      {
+        result = lpDD->SetCooperativeLevel(m_hWndMain, DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT);
+        if (result == DD_OK)
+        {
+          lpDD->SetDisplayMode(width, height, 8);
+        }
+      }
+    }
+
+    if (!IsSupportedMode(width, height, bpp))
+    {
+      width = m_pCurrentDeviceModesList->m_mode_ARRAY[0].width;
+      height = m_pCurrentDeviceModesList->m_mode_ARRAY[0].height;
+      bpp = m_pCurrentDeviceModesList->m_mode_ARRAY[0].bitsPerPixel;
+    }
+
+    m_bIgnoreWM_SIZE = TRUE;
+    result = m_pDirectDraw->SetDisplayMode(width, height, bpp);
+    m_bIgnoreWM_SIZE = FALSE;
+    if (result != DD_OK)
+    {
+      Error("SetDisplayMode failed", result);
+      return FALSE;
+    }
+  }
+  else
+  {
+    RECT rc;
+    DWORD dwStyle;
+
+    if (!m_bIsOnPrimaryDevice)
+    {
+      Error("Attempt made enter a windowed mode on a DirectDraw device that is not the primary display", E_FAIL);
+      return FALSE;
+    }
+
+    m_bIgnoreWM_SIZE = TRUE;
+    dwStyle = GetWindowLong(m_hWndMain, GWL_STYLE);
+    dwStyle &= ~(WS_POPUP | WS_CAPTION | WS_THICKFRAME | WS_OVERLAPPED);
+    dwStyle |= WS_CAPTION | WS_THICKFRAME | WS_OVERLAPPED;
+    SetWindowLong(m_hWndMain, GWL_STYLE, dwStyle);
+
+    SetRect(&rc, 0, 0, width - 1, height - 1);
+    AdjustWindowRectEx(
+      &rc,
+      GetWindowLong(m_hWndMain, GWL_STYLE),
+      GetMenu(m_hWndMain) != NULL,
+      GetWindowLong(m_hWndMain, GWL_EXSTYLE)
+    );
+    SetWindowPos(m_hWndMain, NULL, 0, 0, rc.right - rc.left + 1, rc.bottom - rc.top + 1, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
+    SetWindowPos(m_hWndMain, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
+    m_bIgnoreWM_SIZE = FALSE;
+  }
+
+  m_currentMode.width = width;
+  m_currentMode.height = height;
+  m_currentMode.bitsPerPixel = bpp;
+
+  if (!DDCreateSurfaces())
+  {
+    return FALSE;
+  }
+
+  DDSURFACEDESC ddsd;
+
+  FUN_1009E020();
+
+  if (!GetDDSurfaceDesc(&ddsd, m_pBackBuffer))
+  {
+    return FALSE;
+  }
+
+  if (ddsd.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8)
+  {
+    m_bPrimaryPalettized = TRUE;
+  }
+  else
+  {
+    m_bPrimaryPalettized = FALSE;
+  }
+
+  if (m_bPrimaryPalettized)
+  {
+    result = m_pDirectDraw->CreatePalette(
+      DDPCAPS_8BIT | DDPCAPS_ALLOW256 | DDPCAPS_INITIALIZE, //0x4c
+      m_paletteEntries,
+      &m_pPalette,
+      NULL);
+    if (result != DD_OK)
+    {
+      Error("CreatePalette failed", result);
+      return 0;
+    }
+    result = m_pBackBuffer->SetPalette(m_pPalette); // TODO: add FIX_BUGS define and fix this
+    result = m_pFrontBuffer->SetPalette(m_pPalette);
+    if (result != DD_OK)
+    {
+      Error("SetPalette failed", result);
+      return FALSE;
+    }
+  }
+
+  // create debug text only in windowed mode?
+  return m_bFullScreen || CreateTextSurfaces();
+}
+
+// OFFSET: LEGO1 0x1009E830
+void MxDirectDraw::Error(const char* message, int error)
+{
+  // OFFSET: LEGO1 0x10100C70
+  static BOOL isInsideError = FALSE;
+  if (!isInsideError)
+  {
+    isInsideError = TRUE;
+    Destroy();
+    if (m_pErrorHandler)
+    {
+      m_pErrorHandler(message, error, m_pErrorHandlerArg);
+    }
+    isInsideError = FALSE;
+  }
+}
+
+// OFFSET: LEGO1 0x1009DDA0
+BOOL MxDirectDraw::GetDDSurfaceDesc(LPDDSURFACEDESC lpDDSurfDesc, LPDIRECTDRAWSURFACE lpDDSurf)
+{
+  HRESULT result;
+
+  memset(lpDDSurfDesc, 0, sizeof(*lpDDSurfDesc));
+  lpDDSurfDesc->dwSize = sizeof(*lpDDSurfDesc);
+  result = lpDDSurf->GetSurfaceDesc(lpDDSurfDesc);
+  if (result != DD_OK)
+  {
+    Error("Error getting a surface description", result);
+  }
+
+  return (result == DD_OK);
+}
+
+// OFFSET: LEGO1 0x1009D9D0
+BOOL MxDirectDraw::IsSupportedMode(int width, int height, int bpp)
+{
+  Mode mode = { width, height, bpp };
+
+  for (int i = 0; i < m_pCurrentDeviceModesList->count; i++)
+  {
+    if (m_pCurrentDeviceModesList->m_mode_ARRAY[i] == mode)
+    {
+      return TRUE;
+    }
+  }
+
+  return FALSE;
+}
+
+// OFFSET: LEGO1 0x1009D690
+BOOL MxDirectDraw::RecreateDirectDraw(GUID** ppGUID)
+{
+  if (m_pDirectDraw)
+  {
+    m_pDirectDraw->Release();
+    m_pDirectDraw = NULL;
+  }
+
+  return (DirectDrawCreate(*ppGUID, &m_pDirectDraw, 0) == DD_OK);
+}
+
+// OFFSET: LEGO1 0x1009E7A0
+BOOL MxDirectDraw::RestoreOriginalPaletteEntries()
+{
+  HRESULT result;
+
+  if (m_bPrimaryPalettized)
+  {
+    if (m_pPalette)
+    {
+      result = m_pPalette->SetEntries(0, 0, 256, m_originalPaletteEntries);
+      if (result != DD_OK)
+      {
+        Error("SetEntries failed", result);
+        return FALSE;
+      }
+    }
+  }
+
+  return TRUE;
+}
+
+// OFFSET: LEGO1 0x1009E750
+BOOL MxDirectDraw::RestorePaletteEntries()
+{
+  HRESULT result;
+
+  if (m_bFullScreen && m_bPrimaryPalettized)
+  {
+    if (m_pPalette)
+    {
+      result = m_pPalette->SetEntries(0, 0, _countof(m_paletteEntries), m_paletteEntries);
+      if (result != DD_OK)
+      {
+        Error("SetEntries failed", result);
+        return FALSE;
+      }
+    }
+  }
+
+  return TRUE;
+}
+
+// OFFSET: LEGO1 0x1009e7f0
+int MxDirectDraw::FlipToGDISurface()
+{
+  HRESULT ret;
+
+  if (m_pDirectDraw)
+  {
+    ret = m_pDirectDraw->FlipToGDISurface();
+    if (ret != DD_OK)
+    {
+      Error("FlipToGDISurface failed", ret);
+    }
+    return !ret;
+  }
+
+  return 1;
+}
+
+// OFFSET: LEGO1 0x1009E4D0
+BOOL MxDirectDraw::RestoreSurfaces()
+{
+  HRESULT result;
+
+  if (m_pFrontBuffer != NULL)
+  {
+    if (m_pFrontBuffer->IsLost() == DDERR_SURFACELOST)
+    {
+      result = m_pFrontBuffer->Restore();
+      if (result != DD_OK)
+      {
+        Error("Restore of front buffer failed", result);
+        return FALSE;
+      }
+    }
+  }
+
+  if (m_pBackBuffer != NULL)
+  {
+    if (m_pBackBuffer->IsLost() == DDERR_SURFACELOST)
+    {
+      result = m_pBackBuffer->Restore();
+      if (result != DD_OK)
+      {
+        Error("Restore of back buffer failed", result);
+        return FALSE;
+      }
+    }
+  }
+
+  if (m_pZBuffer != NULL)
+  {
+    if (m_pZBuffer->IsLost() == DDERR_SURFACELOST)
+    {
+      result = m_pZBuffer->Restore();
+      if (result != DD_OK)
+      {
+        Error("Restore of Z-buffer failed", result);
+        return FALSE;
+      }
+    }
+  }
+
+  if (m_pText1Surface != NULL)
+  {
+    if (m_pText1Surface->IsLost() == DDERR_SURFACELOST)
+    {
+      result = m_pText1Surface->Restore();
+      if (result != DD_OK)
+      {
+        Error("Restore of text surface 1 failed", result);
+        return FALSE;
+      }
+    }
+  }
+
+  if (m_pText2Surface != NULL)
+  {
+    if (m_pText2Surface->IsLost() == DDERR_SURFACELOST)
+    {
+      result = m_pText2Surface->Restore();
+      if (result != DD_OK)
+      {
+        Error("Restore of text surface 2 failed", result);
+        return FALSE;
+      }
+    }
+  }
+
+  return TRUE;
+}
+
+// OFFSET: LEGO1 0x1009D700
+BOOL MxDirectDraw::SetPaletteEntries(
+  const PALETTEENTRY* pPaletteEntries,
+  int paletteEntryCount,
+  BOOL fullscreen)
+{
+  int reservedLowEntryCount = 10;
+  int reservedHighEntryCount = 10;
+  int arraySize = _countof(m_paletteEntries);
+  HDC hdc;
+  int i;
+
+  if (g_is_PALETTEINDEXED8)
+  {
+    hdc = GetDC(NULL);
+    GetSystemPaletteEntries(hdc, 0, arraySize, m_paletteEntries);
+    ReleaseDC(NULL, hdc);
+  }
+
+  for (i = 0; i < reservedLowEntryCount; i++)
+  {
+    m_paletteEntries[i].peFlags = 0x80;
+  }
+
+  for (i = reservedLowEntryCount; i < 142; i++)
+  {
+    m_paletteEntries[i].peFlags = 0x44;
+  }
+
+  for (i = 142; i < arraySize - reservedHighEntryCount; i++)
+  {
+    m_paletteEntries[i].peFlags = 0x84;
+  }
+
+  for (i = arraySize - reservedHighEntryCount; i < arraySize; i++)
+  {
+    m_paletteEntries[i].peFlags = 0x80;
+  }
+
+  if (paletteEntryCount != 0)
+  {
+    for (i = reservedLowEntryCount; 
+	(i < paletteEntryCount) && (i < arraySize - reservedHighEntryCount); 
+	i++)
+    {
+      m_paletteEntries[i].peRed   = pPaletteEntries[i].peRed;
+      m_paletteEntries[i].peGreen = pPaletteEntries[i].peGreen;
+      m_paletteEntries[i].peBlue  = pPaletteEntries[i].peBlue;
+    }
+  }
+  
+  if (m_pPalette != NULL)
+  {
+	HRESULT result;
+    result = m_pPalette->SetEntries(0, 0, _countof(m_paletteEntries), m_paletteEntries);
+    if (result != DD_OK)
+    {
+      Error("SetEntries failed", result);
+      return FALSE;
+    }
+  }
+
+  return TRUE;
+}
+
+// OFFSET: LEGO1 0x1009E110
+BOOL MxDirectDraw::TextToTextSurface(
+  const char* text,
+  IDirectDrawSurface* pSurface,
+  SIZE& textSizeOnSurface)
+{
+  HRESULT result;
+  HDC hdc;
+  RECT rc;
+  size_t  textLength;
+
+  if (pSurface == NULL)
+  {
+    return FALSE;
+  }
+
+  result = pSurface->GetDC(&hdc);
+  if (result != DD_OK)
+  {
+    Error("GetDC for text surface failed", result);
+    return FALSE;
+  }
+
+  textLength = strlen(text);
+  
+  SelectObject(hdc, m_hFont);
+  SetTextColor(hdc, RGB(255, 255, 0));
+  SetBkColor(hdc, RGB(0, 0, 0));
+  SetBkMode(hdc, OPAQUE);
+  GetTextExtentPoint32(hdc, text, textLength, &textSizeOnSurface);
+  SetRect(&rc, 0, 0, textSizeOnSurface.cx, textSizeOnSurface.cy);
+  ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &rc, text, textLength, NULL);
+  pSurface->ReleaseDC(hdc);
+
+  return TRUE;
+}
+
+// OFFSET: LEGO1 0x1009E210
+BOOL MxDirectDraw::TextToTextSurface1(const char* text)
+{
+  return TextToTextSurface(
+    text,
+    m_pText1Surface,
+    m_text1SizeOnSurface);
+}
+
+// OFFSET: LEGO1 0x1009E230
+BOOL MxDirectDraw::TextToTextSurface2(const char* text)
+{
+  return TextToTextSurface(
+    text,
+    m_pText2Surface,
+    m_text2SizeOnSurface);
+}
+
+// OFFSET: LEGO1 0x1009E020
+void MxDirectDraw::FUN_1009E020()
+{
+  HRESULT result;
+  byte* line;
+  DDSURFACEDESC ddsd;
+  int j;
+  int count = m_bFlipSurfaces ? 2 : 1;
+
+  for (int i = 0; i < count; i++)
+  {
+    memset(&ddsd, 0, sizeof(ddsd));
+    ddsd.dwSize = sizeof(ddsd);
+
+    result = m_pBackBuffer->Lock(NULL, &ddsd, 1, NULL);
+    if (result == DDERR_SURFACELOST)
+    {
+      m_pBackBuffer->Restore();
+      result = m_pBackBuffer->Lock(NULL, &ddsd, 1, NULL);
+    }
+
+    if (result != DD_OK)
+    {
+      // lock failed
+      return;
+    }
+
+    // clear backBuffer
+    line = (byte*)ddsd.lpSurface;
+    for (j = ddsd.dwHeight; j-- ;)
+    {
+	  memset(line, 0, ddsd.dwWidth);
+	  line += ddsd.lPitch;
+    }
+
+    m_pBackBuffer->Unlock(ddsd.lpSurface);
+
+
+    if (m_bFlipSurfaces)
+    {
+      m_pFrontBuffer->Flip(NULL, DDFLIP_WAIT);
+    }
+  }
+}
+
+// OFFSET: LEGO1 0x1009D920
+void MxDirectDraw::FUN_1009D920()
+{
+  RestoreOriginalPaletteEntries();
+  if (m_pDirectDraw != NULL)
+  {
+    m_bIgnoreWM_SIZE = TRUE;
+    m_pDirectDraw->RestoreDisplayMode();
+    m_pDirectDraw->SetCooperativeLevel(NULL, DDSCL_NORMAL);
+    m_bIgnoreWM_SIZE = FALSE;
+  }
+}
+
diff --git a/LEGO1/mxdirectdraw.h b/LEGO1/mxdirectdraw.h
index 04f73dde..2024a3ac 100644
--- a/LEGO1/mxdirectdraw.h
+++ b/LEGO1/mxdirectdraw.h
@@ -1,12 +1,130 @@
+
 #ifndef MXDIRECTDRAW_H
 #define MXDIRECTDRAW_H
 
+#include <ddraw.h>
+#include <Windows.h>
+
+extern BOOL g_is_PALETTEINDEXED8;
+
+//size 0x880
 class MxDirectDraw
 {
+public:
+  typedef void (*ErrorHandler)(const char*, HRESULT, void*);
+
+  //size 0x0c
+  struct Mode
+  {
+    int width;
+    int height;
+    int bitsPerPixel;
+
+    int operator==(const Mode& rMode) const
+    {
+      return ((width == rMode.width) &&
+        (height == rMode.height) &&
+        (bitsPerPixel == rMode.bitsPerPixel));
+    }
+  };
+
+  //size 0x17c
+  struct DeviceModesInfo
+  {
+    GUID* p_guid;
+    Mode* m_mode_ARRAY;
+    int count;
+    DDCAPS m_ddcaps;
+    void* a_178;
+
+    ~DeviceModesInfo();
+  };
+
+
+private:
+  BOOL m_bOnlySoftRender;
+  BOOL m_bFlipSurfaces;
+  IDirectDraw* m_pDirectDraw;
+  IDirectDrawSurface* m_pFrontBuffer;
+  IDirectDrawSurface* m_pBackBuffer;
+  IDirectDrawSurface* m_pZBuffer;
+  IDirectDrawSurface* m_pText1Surface;
+  IDirectDrawSurface* m_pText2Surface;
+  IDirectDrawClipper* m_pClipper;
+  IDirectDrawPalette* m_pPalette;
+  PALETTEENTRY m_paletteEntries[256];
+  PALETTEENTRY m_originalPaletteEntries[256];
+  SIZE m_text1SizeOnSurface;
+  SIZE m_text2SizeOnSurface;
+  HWND m_hWndMain;
+  HFONT m_hFont;
+  BOOL m_bIgnoreWM_SIZE;
+  BOOL m_bPrimaryPalettized;
+  BOOL m_bFullScreen;
+  void* a_850;
+  BOOL m_bOnlySystemMemory;
+  BOOL m_bIsOnPrimaryDevice;
+  ErrorHandler m_pErrorHandler;
+  ErrorHandler m_pFatalErrorHandler;
+  void* m_pErrorHandlerArg;
+  void* m_pFatalErrorHandlerArg;
+  int m_pauseCount;
+  DeviceModesInfo* m_pCurrentDeviceModesList;
+  Mode m_currentMode;
+
 public:
   __declspec(dllexport) int FlipToGDISurface();
   __declspec(dllexport) static int GetPrimaryBitDepth();
   __declspec(dllexport) int Pause(int);
+
+  MxDirectDraw();
+
+  virtual ~MxDirectDraw();
+  virtual BOOL Create(
+    HWND hWnd,
+    BOOL fullscreen_1,
+    BOOL surface_fullscreen,
+    BOOL onlySystemMemory,
+    int width,
+    int height,
+    int bpp,
+    const PALETTEENTRY* pPaletteEntries,
+    int paletteEntryCount);
+  virtual void Destroy();
+  virtual void DestroyButNotDirectDraw();
+  virtual const char* ErrorToString(HRESULT error);
+
+private:
+  BOOL CacheOriginalPaletteEntries();
+  HRESULT CreateDDSurface(
+    LPDDSURFACEDESC a2,
+    LPDIRECTDRAWSURFACE* a3,
+    IUnknown* a4);
+  BOOL CreateTextSurfaces();
+  BOOL CreateZBuffer(DWORD memorytype, DWORD depth);
+  BOOL DDCreateSurfaces();
+  BOOL DDInit(BOOL fullscreen);
+  BOOL DDSetMode(int width, int height, int bpp);
+  void Error(const char* message, int error);
+
+  BOOL GetDDSurfaceDesc(LPDDSURFACEDESC lpDDSurfDesc, LPDIRECTDRAWSURFACE lpDDSurf);
+  BOOL IsSupportedMode(int width, int height, int bpp);
+  BOOL RecreateDirectDraw(GUID** a2);
+  BOOL RestoreOriginalPaletteEntries();
+  BOOL RestorePaletteEntries();
+  BOOL RestoreSurfaces();
+  BOOL SetPaletteEntries(
+    const PALETTEENTRY* pPaletteEntries,
+    int paletteEntryCount,
+    BOOL fullscreen);
+  BOOL TextToTextSurface(
+    const char* text,
+    IDirectDrawSurface* pSurface,
+    SIZE& textSizeOnSurface);
+  BOOL TextToTextSurface1(const char* text);
+  BOOL TextToTextSurface2(const char* lpString);
+  void FUN_1009E020();
+  void FUN_1009D920();
 };
 
 #endif // MXDIRECTDRAW_H

From ff13dc691c207b233bf87c8841bf8a96baf9752f Mon Sep 17 00:00:00 2001
From: Joshua Peisach <itzswirlz2020@outlook.com>
Date: Thu, 3 Aug 2023 14:10:54 -0400
Subject: [PATCH 06/21] Start IslePathActor (#93)

* Start IslePathActor

* Update types/add needed type in LegoPathActor for Pizza

Yes, this is a recommit because last time I pushed my cmake dir

* Fix types in  islepathactor

* Adjust variables

* add size asserts

---------

Co-authored-by: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
---
 CMakeLists.txt          |  1 +
 LEGO1/islepathactor.cpp | 16 ++++++++++++++++
 LEGO1/islepathactor.h   | 14 ++++++++++++--
 LEGO1/legoactor.h       |  2 +-
 LEGO1/legoentity.cpp    |  2 ++
 LEGO1/legoentity.h      |  1 +
 LEGO1/legopathactor.cpp |  2 ++
 LEGO1/legopathactor.h   |  5 +++++
 LEGO1/mxentity.cpp      |  4 +++-
 LEGO1/mxentity.h        |  3 +++
 10 files changed, 46 insertions(+), 4 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8f0980d0..96c84036 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -45,6 +45,7 @@ add_library(lego1 SHARED
   LEGO1/jukeboxentity.cpp
   LEGO1/jukeboxstate.cpp
   LEGO1/legoact2state.cpp
+  LEGO1/legoactor.cpp
   LEGO1/legoactioncontrolpresenter.cpp
   LEGO1/legoactor.cpp
   LEGO1/legoanimactor.cpp
diff --git a/LEGO1/islepathactor.cpp b/LEGO1/islepathactor.cpp
index 72ed76d8..0024b4bc 100644
--- a/LEGO1/islepathactor.cpp
+++ b/LEGO1/islepathactor.cpp
@@ -1 +1,17 @@
 #include "islepathactor.h"
+
+DECOMP_SIZE_ASSERT(IslePathActor, 0x160)
+
+// OFFSET: LEGO1 0x1001a200
+IslePathActor::IslePathActor()
+{
+  this->m_pLegoWorld = NULL;
+  this->m_unk13c = 6.0;
+  this->m_unk15c = 1.0;
+  this->m_unk158 = 0;
+}
+
+// OFFSET: LEGO1 0x10002e10
+IslePathActor::~IslePathActor()
+{
+}
diff --git a/LEGO1/islepathactor.h b/LEGO1/islepathactor.h
index fce450ac..f4574355 100644
--- a/LEGO1/islepathactor.h
+++ b/LEGO1/islepathactor.h
@@ -2,12 +2,17 @@
 #define ISLEPATHACTOR_H
 
 #include "legopathactor.h"
+#include "legoworld.h"
+#include "mxtypes.h"
 
 // VTABLE 0x100d4398
-// SIZE >= 0x230
+// SIZE 0x160
 class IslePathActor : public LegoPathActor
 {
-public:
+public: 
+  IslePathActor();
+  ~IslePathActor();
+
   // OFFSET: LEGO1 0x10002ea0
   inline virtual const char *ClassName() const override // vtable+0x0c
   {
@@ -20,6 +25,11 @@ class IslePathActor : public LegoPathActor
   {
     return !strcmp(name, IslePathActor::ClassName()) || LegoPathActor::IsA(name);
   }
+
+private:
+  LegoWorld* m_pLegoWorld; // 0x154
+  MxFloat m_unk158;
+  MxFloat m_unk15c;
 };
 
 #endif // ISLEPATHACTOR_H
diff --git a/LEGO1/legoactor.h b/LEGO1/legoactor.h
index 828f48ad..cc8778db 100644
--- a/LEGO1/legoactor.h
+++ b/LEGO1/legoactor.h
@@ -23,7 +23,7 @@ class LegoActor : public LegoEntity
   }
 
 private:
-  undefined unk04_[0x68];
+  undefined unk68[0x10];
 
 };
 
diff --git a/LEGO1/legoentity.cpp b/LEGO1/legoentity.cpp
index b79bc587..b8ed69f9 100644
--- a/LEGO1/legoentity.cpp
+++ b/LEGO1/legoentity.cpp
@@ -1,5 +1,7 @@
 #include "legoentity.h"
 
+DECOMP_SIZE_ASSERT(LegoEntity, 0x68)
+
 // OFFSET: LEGO1 0x1000c290
 LegoEntity::~LegoEntity()
 {
diff --git a/LEGO1/legoentity.h b/LEGO1/legoentity.h
index 46aea940..fdfe997f 100644
--- a/LEGO1/legoentity.h
+++ b/LEGO1/legoentity.h
@@ -4,6 +4,7 @@
 #include "mxentity.h"
 
 // VTABLE 0x100d4858
+// SIZE 0x68 (probably)
 class LegoEntity : public MxEntity
 {
 public:
diff --git a/LEGO1/legopathactor.cpp b/LEGO1/legopathactor.cpp
index 336cdc13..f1c39b82 100644
--- a/LEGO1/legopathactor.cpp
+++ b/LEGO1/legopathactor.cpp
@@ -1,5 +1,7 @@
 #include "legopathactor.h"
 
+DECOMP_SIZE_ASSERT(LegoPathActor, 0x154)
+
 // OFFSET: LEGO1 0x1002d700 STUB
 LegoPathActor::LegoPathActor()
 {
diff --git a/LEGO1/legopathactor.h b/LEGO1/legopathactor.h
index e6f643c2..7e524b08 100644
--- a/LEGO1/legopathactor.h
+++ b/LEGO1/legopathactor.h
@@ -2,6 +2,7 @@
 #define LEGOPATHACTOR_H
 
 #include "legoactor.h"
+#include "mxtypes.h"
 
 // VTABLE 0x100d6e28
 // SIZE 0x154 (from inlined construction at 0x1000a346)
@@ -25,6 +26,10 @@ class LegoPathActor : public LegoActor
     return !strcmp(name, LegoPathActor::ClassName()) || LegoActor::IsA(name);
   }
 
+  // TODO: the types. Pizza needs this as public:
+  undefined unk78[0xc4];
+  MxS32 m_unk13c;
+  undefined unk140[0x14];
 };
 
 #endif // LEGOPATHACTOR_H
diff --git a/LEGO1/mxentity.cpp b/LEGO1/mxentity.cpp
index 1b5ea84f..da536504 100644
--- a/LEGO1/mxentity.cpp
+++ b/LEGO1/mxentity.cpp
@@ -1,5 +1,7 @@
 #include "mxentity.h"
 
+DECOMP_SIZE_ASSERT(MxEntity, 0x68)
+
 // OFFSET: LEGO1 0x1001d190
 MxEntity::MxEntity()
 {
@@ -9,4 +11,4 @@ MxEntity::MxEntity()
 // OFFSET: LEGO1 0x1000c110
 MxEntity::~MxEntity()
 {
-}
\ No newline at end of file
+}
diff --git a/LEGO1/mxentity.h b/LEGO1/mxentity.h
index a7e26e37..dc959c35 100644
--- a/LEGO1/mxentity.h
+++ b/LEGO1/mxentity.h
@@ -1,11 +1,13 @@
 #ifndef MXENTITY_H
 #define MXENTITY_H
 
+#include "decomp.h"
 #include "mxatomid.h"
 #include "mxcore.h"
 #include "mxtypes.h"
 
 // VTABLE 0x100d5390
+// SIZE 0x68 or less
 class MxEntity : public MxCore
 {
 public:
@@ -27,6 +29,7 @@ class MxEntity : public MxCore
 private:
   MxS32 m_mxEntityId; // 0x8
   MxAtomId m_atom; // 0xc
+  undefined m_unk10[0x58];
 };
 
 #endif // MXENTITY_H

From 932baa2a87862f14e204b53a7755bbe4066fb7f7 Mon Sep 17 00:00:00 2001
From: Christian Semmler <mail@csemmler.com>
Date: Thu, 3 Aug 2023 14:13:27 -0400
Subject: [PATCH 07/21] lego1: Add MxDisplaySurface class members and some
 functions (#95)

* Add MxDisplaySurface class members and some functions

* Add size assert

* style
---
 CMakeLists.txt             |   1 +
 LEGO1/mxdisplaysurface.cpp | 136 +++++++++++++++++++++++++++++++++++++
 LEGO1/mxdisplaysurface.h   |  18 ++++-
 3 files changed, 152 insertions(+), 3 deletions(-)
 create mode 100644 LEGO1/mxdisplaysurface.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 96c84036..2229ea1e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -103,6 +103,7 @@ add_library(lego1 SHARED
   LEGO1/mxdirectdraw.cpp
   LEGO1/mxdiskstreamcontroller.cpp
   LEGO1/mxdiskstreamprovider.cpp
+  LEGO1/mxdisplaysurface.cpp
   LEGO1/mxdsaction.cpp
   LEGO1/mxdsanim.cpp
   LEGO1/mxdschunk.cpp
diff --git a/LEGO1/mxdisplaysurface.cpp b/LEGO1/mxdisplaysurface.cpp
new file mode 100644
index 00000000..edf1cb1a
--- /dev/null
+++ b/LEGO1/mxdisplaysurface.cpp
@@ -0,0 +1,136 @@
+#include "mxdisplaysurface.h"
+
+DECOMP_SIZE_ASSERT(MxDisplaySurface, 0xac);
+
+// OFFSET: LEGO1 0x100ba500
+MxDisplaySurface::MxDisplaySurface()
+{
+  this->Reset();
+}
+
+// OFFSET: LEGO1 0x100ba5a0
+MxDisplaySurface::~MxDisplaySurface()
+{
+  this->Clear();
+}
+
+// OFFSET: LEGO1 0x100ba610
+void MxDisplaySurface::Reset()
+{
+  this->m_ddSurface1 = NULL;
+  this->m_ddSurface2 = NULL;
+  this->m_ddClipper = NULL;
+  this->m_16bitPal = NULL;
+  this->m_initialized = FALSE;
+  memset(&this->m_surfaceDesc, 0, sizeof(this->m_surfaceDesc));
+}
+
+// OFFSET: LEGO1 0x100ba790
+MxResult MxDisplaySurface::Init(MxVideoParam &p_videoParam, LPDIRECTDRAWSURFACE p_ddSurface1, LPDIRECTDRAWSURFACE p_ddSurface2, LPDIRECTDRAWCLIPPER p_ddClipper)
+{
+  MxResult result = SUCCESS;
+
+  this->m_videoParam = p_videoParam;
+  this->m_ddSurface1 = p_ddSurface1;
+  this->m_ddSurface2 = p_ddSurface2;
+  this->m_ddClipper = p_ddClipper;
+  this->m_initialized = FALSE;
+
+  memset(&this->m_surfaceDesc, 0, sizeof(this->m_surfaceDesc));
+  this->m_surfaceDesc.dwSize = sizeof(this->m_surfaceDesc);
+
+  if (this->m_ddSurface2->GetSurfaceDesc(&this->m_surfaceDesc))
+    result = FAILURE;
+
+  return result;
+}
+
+// OFFSET: LEGO1 0x100ba7f0 STUB
+MxResult MxDisplaySurface::Create(MxVideoParam *p_videoParam)
+{
+  return 0;
+}
+
+// OFFSET: LEGO1 0x100baa90
+void MxDisplaySurface::Clear()
+{
+  if (this->m_initialized) {
+    if (this->m_ddSurface2)
+      this->m_ddSurface2->Release();
+
+    if (this->m_ddSurface1)
+      this->m_ddSurface1->Release();
+
+    if (this->m_ddClipper)
+      this->m_ddClipper->Release();
+  }
+
+  if (this->m_16bitPal)
+    delete this->m_16bitPal;
+
+  this->Reset();
+}
+
+// OFFSET: LEGO1 0x100baae0 STUB
+void MxDisplaySurface::SetPalette(MxPalette *p_palette)
+{
+
+}
+
+// OFFSET: LEGO1 0x100bc200 STUB
+void MxDisplaySurface::vtable24(undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4)
+{
+
+}
+
+// OFFSET: LEGO1 0x100bacc0 STUB
+MxBool MxDisplaySurface::vtable28(undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4)
+{
+  return 0;
+}
+
+// OFFSET: LEGO1 0x100bc630 STUB
+MxBool MxDisplaySurface::vtable2c(undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, MxBool)
+{
+  return 0;
+}
+
+// OFFSET: LEGO1 0x100bb1d0 STUB
+MxBool MxDisplaySurface::vtable30(undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, MxBool)
+{
+  return 0;
+}
+
+// OFFSET: LEGO1 0x100bb850 STUB
+undefined4 MxDisplaySurface::vtable34(undefined4, undefined4, undefined4, undefined4, undefined4, undefined4)
+{
+  return 0;
+}
+
+// OFFSET: LEGO1 0x100bba50 STUB
+void MxDisplaySurface::Display(undefined4, undefined4, undefined4, undefined4, undefined4, undefined4)
+{
+
+}
+
+// OFFSET: LEGO1 0x100bbc10
+void MxDisplaySurface::GetDC(HDC *p_hdc)
+{
+  if (this->m_ddSurface2 && !this->m_ddSurface2->GetDC(p_hdc))
+    return;
+ 
+  *p_hdc = NULL;
+}
+
+// OFFSET: LEGO1 0x100bbc40
+void MxDisplaySurface::ReleaseDC(HDC p_hdc)
+{
+  if (this->m_ddSurface2 && p_hdc)
+    this->m_ddSurface2->ReleaseDC(p_hdc);
+}
+
+// OFFSET: LEGO1 0x100bbc60 STUB
+undefined4 MxDisplaySurface::vtable44(undefined4, undefined4*, undefined4, undefined4)
+{
+  return 0;
+}
diff --git a/LEGO1/mxdisplaysurface.h b/LEGO1/mxdisplaysurface.h
index 9da02fda..aef3d5d5 100644
--- a/LEGO1/mxdisplaysurface.h
+++ b/LEGO1/mxdisplaysurface.h
@@ -10,13 +10,16 @@
 #include "decomp.h"
 
 // VTABLE 0x100dc768
+// SIZE 0xac
 class MxDisplaySurface : public MxCore
 {
 public:
   MxDisplaySurface();
   virtual ~MxDisplaySurface() override;
 
-  virtual MxResult Init(MxVideoParam *p_videoParam, LPDIRECTDRAWSURFACE p_surface1, LPDIRECTDRAWSURFACE p_surface2, LPDIRECTDRAWCLIPPER p_clipper);
+  void Reset();
+
+  virtual MxResult Init(MxVideoParam &p_videoParam, LPDIRECTDRAWSURFACE p_ddSurface1, LPDIRECTDRAWSURFACE p_ddSurface2, LPDIRECTDRAWCLIPPER p_ddClipper);
   virtual MxResult Create(MxVideoParam *p_videoParam);
   virtual void Clear();
   virtual void SetPalette(MxPalette *p_palette);
@@ -26,9 +29,18 @@ class MxDisplaySurface : public MxCore
   virtual MxBool vtable30(undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, MxBool);
   virtual undefined4 vtable34(undefined4, undefined4, undefined4, undefined4, undefined4, undefined4);
   virtual void Display(undefined4, undefined4, undefined4, undefined4, undefined4, undefined4);
-  virtual undefined4 vtable3c(undefined4*);
-  virtual undefined4 vtable40(undefined4);
+  virtual void GetDC(HDC *p_hdc);
+  virtual void ReleaseDC(HDC p_hdc);
   virtual undefined4 vtable44(undefined4, undefined4*, undefined4, undefined4);
+
+private:
+  MxVideoParam m_videoParam;
+  LPDIRECTDRAWSURFACE m_ddSurface1;
+  LPDIRECTDRAWSURFACE m_ddSurface2;
+  LPDIRECTDRAWCLIPPER m_ddClipper;
+  MxBool m_initialized;
+  DDSURFACEDESC m_surfaceDesc;
+  MxU16 *m_16bitPal;
 };
 
 #endif // MXDISPLAYSURFACE_H

From 0f92e345b3738b505ac76778313310c907612c7c Mon Sep 17 00:00:00 2001
From: pewpew <brandougherty1@gmail.com>
Date: Thu, 3 Aug 2023 13:19:05 -0500
Subject: [PATCH 08/21] MxTickleManager mostly done (#94)

* Checkpoint to show MxTickleManager::SetClientTickleInterval match.

* Match MxTickleManager::~MxTickleManager, obliterate MxTickleManager::SetClientTickleInterval.

* Make conditional more realistic, move MxTime to mxtypes.h, add TODO for MxTickleManager::Tickle.
---
 CMakeLists.txt                  |   1 +
 ISLE/isleapp.cpp                |   2 +-
 LEGO1/mxnotificationmanager.cpp |   4 +-
 LEGO1/mxticklemanager.cpp       | 113 ++++++++++++++++++++++++++++++++
 LEGO1/mxticklemanager.h         |  73 ++++++++++++++++++---
 LEGO1/mxtypes.h                 |   2 +
 6 files changed, 184 insertions(+), 11 deletions(-)
 create mode 100644 LEGO1/mxticklemanager.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2229ea1e..e6678b8a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -150,6 +150,7 @@ add_library(lego1 SHARED
   LEGO1/mxstring.cpp
   LEGO1/mxstringvariable.cpp
   LEGO1/mxthread.cpp
+  LEGO1/mxticklemanager.cpp
   LEGO1/mxtimer.cpp
   LEGO1/mxtransitionmanager.cpp
   LEGO1/mxunknown100dc6b0.cpp
diff --git a/ISLE/isleapp.cpp b/ISLE/isleapp.cpp
index a1836e8c..8d175dfa 100644
--- a/ISLE/isleapp.cpp
+++ b/ISLE/isleapp.cpp
@@ -121,7 +121,7 @@ BOOL IsleApp::SetupLegoOmni()
   BOOL failure = Lego()->Create(MxOmniCreateParam(mediaPath, (struct HWND__ *) m_windowHandle, m_videoParam, MxOmniCreateFlags())) == FAILURE;
   if (!failure) {
     VariableTable()->SetVariable("ACTOR_01", "");
-    TickleManager()->vtable1c(VideoManager(), 10);
+    TickleManager()->SetClientTickleInterval(VideoManager(), 10);
     result = TRUE;
   }
 
diff --git a/LEGO1/mxnotificationmanager.cpp b/LEGO1/mxnotificationmanager.cpp
index b7d001aa..fe48c7c2 100644
--- a/LEGO1/mxnotificationmanager.cpp
+++ b/LEGO1/mxnotificationmanager.cpp
@@ -41,7 +41,7 @@ MxNotificationManager::~MxNotificationManager()
   delete m_queue;
   m_queue = NULL;
 
-  TickleManager()->Unregister(this);
+  TickleManager()->UnregisterClient(this);
 }
 
 // OFFSET: LEGO1 0x100ac800
@@ -80,7 +80,7 @@ MxResult MxNotificationManager::Create(MxS32 p_unk1, MxS32 p_unk2)
     result = FAILURE;
   }
   else {
-    TickleManager()->Register(this, 10);
+    TickleManager()->RegisterClient(this, 10);
   }
 
   return result;
diff --git a/LEGO1/mxticklemanager.cpp b/LEGO1/mxticklemanager.cpp
new file mode 100644
index 00000000..38cdd37f
--- /dev/null
+++ b/LEGO1/mxticklemanager.cpp
@@ -0,0 +1,113 @@
+#include "mxomni.h"
+#include "mxticklemanager.h"
+#include "mxtimer.h"
+#include "mxtypes.h"
+
+#include "decomp.h"
+
+#define TICKLE_MANAGER_FLAG_DESTROY 0x1
+
+DECOMP_SIZE_ASSERT(MxTickleClient, 0x10);
+DECOMP_SIZE_ASSERT(MxTickleManager, 0x14);
+
+// OFFSET: LEGO1 0x100bdd10
+MxTickleClient::MxTickleClient(MxCore *p_client, MxTime p_interval)
+{
+  m_flags = 0;
+  m_client = p_client;
+  m_interval = p_interval;
+  m_lastUpdateTime = -m_interval;
+}
+
+// OFFSET: LEGO1 0x100bdd30
+MxTickleManager::~MxTickleManager()
+{
+  while (m_clients.size() != 0) {
+    MxTickleClient *client = m_clients.front();
+    m_clients.pop_front();
+    delete client;
+  }
+}
+
+// TODO: Match.
+// OFFSET: LEGO1 0x100bdde0
+MxResult MxTickleManager::Tickle()
+{
+  MxTime time = Timer()->GetTime();
+
+  MxTickleClientPtrList::iterator it = m_clients.begin();
+
+  while (it != m_clients.end()) {
+    MxTickleClient *client = *it;
+    if ((client->GetFlags() & TICKLE_MANAGER_FLAG_DESTROY) == 0) {
+      if (client->GetLastUpdateTime() >= time)
+        client->SetLastUpdateTime(-client->GetTickleInterval());
+
+      if ((client->GetTickleInterval() + client->GetLastUpdateTime()) < time) {
+        client->GetClient()->Tickle();
+        client->SetLastUpdateTime(time);
+      }
+
+      it++;
+    }
+    else {
+      m_clients.erase(it++);
+      delete client;
+    }
+  }
+
+  return SUCCESS;
+}
+
+// OFFSET: LEGO1 0x100bde80
+void MxTickleManager::RegisterClient(MxCore *p_client, MxTime p_interval)
+{
+  MxTime interval = GetClientTickleInterval(p_client);
+  if (interval == TICKLE_MANAGER_NOT_FOUND) {
+    MxTickleClient *client = new MxTickleClient(p_client, p_interval);
+    if (client != NULL)
+      m_clients.push_back(client);
+  }
+}
+
+// OFFSET: LEGO1 0x100bdf60
+void MxTickleManager::UnregisterClient(MxCore *p_client)
+{
+  MxTickleClientPtrList::iterator it = m_clients.begin();
+  while (it != m_clients.end()) {
+    MxTickleClient *client = *it;
+    if (client->GetClient() == p_client) {
+      client->SetFlags(client->GetFlags() | TICKLE_MANAGER_FLAG_DESTROY);
+      return;
+    }
+
+    it++;
+  }
+}
+
+// OFFSET: LEGO1 0x100bdfa0
+void MxTickleManager::SetClientTickleInterval(MxCore *p_client, MxTime p_interval)
+{
+  for (MxTickleClientPtrList::iterator it = m_clients.begin(); it != m_clients.end(); it++) {
+    MxTickleClient *client = *it;
+    if ((client->GetClient() == p_client) && ((client->GetFlags() & TICKLE_MANAGER_FLAG_DESTROY) == 0)) {
+      client->SetTickleInterval(p_interval);
+      return;
+    }
+  }
+}
+
+// OFFSET: LEGO1 0x100be000
+MxTime MxTickleManager::GetClientTickleInterval(MxCore *p_client)
+{
+  MxTickleClientPtrList::iterator it = m_clients.begin();
+  while (it != m_clients.end()) {
+    MxTickleClient *client = *it;
+    if ((client->GetClient() == p_client) && ((client->GetFlags() & TICKLE_MANAGER_FLAG_DESTROY) == 0))
+      return client->GetTickleInterval();
+
+    it++;
+  }
+
+  return TICKLE_MANAGER_NOT_FOUND;
+}
diff --git a/LEGO1/mxticklemanager.h b/LEGO1/mxticklemanager.h
index 3d976d5a..103d3721 100644
--- a/LEGO1/mxticklemanager.h
+++ b/LEGO1/mxticklemanager.h
@@ -2,20 +2,77 @@
 #define MXTICKLEMANAGER_H
 
 #include "mxcore.h"
+#include "mxtypes.h"
+
+#include "compat.h"
+
+class MxTickleClient
+{
+public:
+  MxTickleClient(MxCore *p_client, MxTime p_interval);
+
+  inline MxCore *GetClient() const
+  {
+    return m_client;
+  }
+
+  inline MxTime GetTickleInterval() const
+  {
+    return m_interval;
+  }
+
+  inline MxTime GetLastUpdateTime() const
+  {
+    return m_lastUpdateTime;
+  }
+
+  inline MxU16 GetFlags() const
+  {
+    return m_flags;
+  }
+
+  inline void SetTickleInterval(MxTime p_interval)
+  {
+    m_interval = p_interval;
+  }
+
+  inline void SetLastUpdateTime(MxTime p_lastUpdateTime)
+  {
+    m_lastUpdateTime = p_lastUpdateTime;
+  }
+
+  inline void SetFlags(MxU16 flags)
+  {
+    m_flags = flags;
+  }
+
+private:
+  MxCore *m_client; // 0x0
+  MxTime m_interval; // 0x4
+  MxTime m_lastUpdateTime; // 0x8
+  MxU16 m_flags; // 0xc
+};
+
+class MxTickleClientPtrList : public List<MxTickleClient *>
+{};
 
 // VTABLE 0x100d86d8
 class MxTickleManager : public MxCore
 {
 public:
-  virtual ~MxTickleManager();
+  inline MxTickleManager() : MxCore(), m_clients() {}
+  virtual ~MxTickleManager(); // vtable+0x0 (scalar deleting destructor)
 
-  virtual MxLong Tickle();
-  virtual const char *ClassName() const;
-  virtual MxBool IsA(const char *name) const;
-  virtual void Register(MxCore *p_listener, int p_milliseconds);
-  virtual void Unregister(MxCore *p_listener);
-  virtual void vtable1c(void *v, int p);
-  virtual void vtable20();
+  virtual MxResult Tickle(); // vtable+0x8
+  virtual void RegisterClient(MxCore *p_client, MxTime p_interval); // vtable+0x14
+  virtual void UnregisterClient(MxCore *p_client); // vtable+0x18
+  virtual void SetClientTickleInterval(MxCore *p_client, MxTime p_interval); // vtable+0x1c
+  virtual MxTime GetClientTickleInterval(MxCore *p_client); // vtable+0x20
+
+private:
+  MxTickleClientPtrList m_clients; // 0x8
 };
 
+#define TICKLE_MANAGER_NOT_FOUND 0x80000000
+
 #endif // MXTICKLEMANAGER_H
diff --git a/LEGO1/mxtypes.h b/LEGO1/mxtypes.h
index d17ac09a..1f0aaac7 100644
--- a/LEGO1/mxtypes.h
+++ b/LEGO1/mxtypes.h
@@ -25,6 +25,8 @@ typedef int MxLong;
 typedef unsigned int MxULong;
 #endif
 
+typedef MxS32 MxTime;
+
 typedef MxLong MxResult;
 const MxResult SUCCESS = 0;
 const MxResult FAILURE = -1;

From ee7c419be8999fa4db43c9607ccf68032ce90ea6 Mon Sep 17 00:00:00 2001
From: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date: Thu, 3 Aug 2023 11:21:05 -0700
Subject: [PATCH 09/21] fix the pizza conflict

Sounds like an episode of a neo-noir TV show
---
 LEGO1/pizza.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/LEGO1/pizza.cpp b/LEGO1/pizza.cpp
index 93f67aaa..7e153b26 100644
--- a/LEGO1/pizza.cpp
+++ b/LEGO1/pizza.cpp
@@ -19,7 +19,7 @@ Pizza::Pizza()
 // OFFSET: LEGO1 0x10038100
 Pizza::~Pizza()
 {
-  TickleManager()->Unregister(this);
+  TickleManager()->UnregisterClient(this);
 }
 
 // OFFSET: LEGO1 0x100388a0

From 694045abd89740a6d2371462c3143139afa2e07e Mon Sep 17 00:00:00 2001
From: Mark Langen <stravant@gmail.com>
Date: Thu, 3 Aug 2023 11:25:29 -0700
Subject: [PATCH 10/21] Implement MxVector2/3/4 and MxMatrix (#100)

* All of the MxVectors share an inheritance chain. MxVector4 inherits
  from MxVector3 which inherits from MxVector2.

* They all operate on a shared `float*` data member which points to the
  underlying storage.

* There are also MxVector3/4Data classes, which inherit from Vector3/4,
  but add concrete storage for the Vector data rather than just an
  abstract data pointer.

* The same is true for MxMatrix, with there being an abstract and a
  concrete variant of it.

* Also improve reccmp.py register matching algorithm. It previously
  could not recognize an effective match when a swap had to take place
  between two registers used on the same line. It turns out this happens
  a lot in floating point math code so I adjusted the implementation to
  break the disassembly lines on spaces rather than just linebreaks
  allowing the existing effective match code to handle that case too.
---
 CMakeLists.txt         |   2 +
 LEGO1/mxmatrix.cpp     | 188 +++++++++++++++++
 LEGO1/mxmatrix.h       |  70 +++++++
 LEGO1/mxvector.cpp     | 466 +++++++++++++++++++++++++++++++++++++++++
 LEGO1/mxvector.h       | 150 +++++++++++++
 tools/reccmp/reccmp.py |   9 +-
 6 files changed, 881 insertions(+), 4 deletions(-)
 create mode 100644 LEGO1/mxmatrix.cpp
 create mode 100644 LEGO1/mxmatrix.h
 create mode 100644 LEGO1/mxvector.cpp
 create mode 100644 LEGO1/mxvector.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index e6678b8a..df71ccf0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -128,6 +128,7 @@ add_library(lego1 SHARED
   LEGO1/mxloopingflcpresenter.cpp
   LEGO1/mxloopingmidipresenter.cpp
   LEGO1/mxloopingsmkpresenter.cpp
+  LEGO1/mxmatrix.cpp
   LEGO1/mxmediapresenter.cpp
   LEGO1/mxmidipresenter.cpp
   LEGO1/mxmusicpresenter.cpp
@@ -156,6 +157,7 @@ add_library(lego1 SHARED
   LEGO1/mxunknown100dc6b0.cpp
   LEGO1/mxunknown100dc6e0.cpp
   LEGO1/mxvariabletable.cpp
+  LEGO1/mxvector.cpp
   LEGO1/mxvideomanager.cpp
   LEGO1/mxvideoparam.cpp
   LEGO1/mxvideoparamflags.cpp
diff --git a/LEGO1/mxmatrix.cpp b/LEGO1/mxmatrix.cpp
new file mode 100644
index 00000000..534db6a9
--- /dev/null
+++ b/LEGO1/mxmatrix.cpp
@@ -0,0 +1,188 @@
+
+#include "mxmatrix.h"
+
+#include <memory.h>
+#include "math.h"
+
+#include "decomp.h"
+
+DECOMP_SIZE_ASSERT(MxMatrix, 0x8);
+DECOMP_SIZE_ASSERT(MxMatrixData, 0x48);
+
+// OFFSET: LEGO1 0x10002340
+void MxMatrix::EqualsMxMatrix(const MxMatrix *p_other)
+{
+  memcpy(m_data, p_other->m_data, 16 * sizeof(float));
+}
+
+// OFFSET: LEGO1 0x10002320
+void MxMatrix::EqualsMatrixData(const float *p_matrix)
+{
+  memcpy(m_data, p_matrix, 16 * sizeof(float));
+}
+
+// OFFSET: LEGO1 0x10002370
+void MxMatrix::SetData(float *p_data)
+{
+  m_data = p_data;
+}
+
+// OFFSET: LEGO1 0x10002360
+void MxMatrix::AnotherSetData(float *p_data)
+{
+  m_data = p_data;
+}
+
+// OFFSET: LEGO1 0x10002390
+float *MxMatrix::GetData()
+{
+  return m_data;
+}
+
+// OFFSET: LEGO1 0x10002380
+const float *MxMatrix::GetData() const
+{
+  return m_data;
+}
+
+// OFFSET: LEGO1 0x100023c0
+float *MxMatrix::Element(int p_row, int p_col)
+{
+  return &m_data[p_row * 4 + p_col];
+}
+
+// OFFSET: LEGO1 0x100023a0
+const float *MxMatrix::Element(int p_row, int p_col) const
+{
+  return &m_data[p_row * 4 + p_col];
+}
+
+// OFFSET: LEGO1 0x100023e0
+void MxMatrix::Clear()
+{
+  memset(m_data, 0, 16 * sizeof(float));
+}
+
+// OFFSET: LEGO1 0x100023f0
+void MxMatrix::SetIdentity()
+{
+  Clear();
+  m_data[0] = 1.0f;
+  m_data[5] = 1.0f;
+  m_data[10] = 1.0f;
+  m_data[15] = 1.0f;
+}
+
+// OFFSET: LEGO1 0x10002850
+void MxMatrix::operator=(const MxMatrix& p_other)
+{
+  EqualsMxMatrix(&p_other);
+}
+
+// OFFSET: LEGO1 0x10002430
+MxMatrix* MxMatrix::operator+=(const float *p_matrix)
+{
+  for (int i = 0; i < 16; ++i)
+    m_data[i] += p_matrix[i];
+  return this;
+}
+
+// Matches but instructions are significantly out of order. Probably not wrong
+// code given that the very similar SetTranslation does match.
+// OFFSET: LEGO1 0x10002460
+void MxMatrix::TranslateBy(const float *p_x, const float *p_y, const float *p_z)
+{
+  m_data[12] += *p_x;
+  m_data[13] += *p_y;
+  m_data[14] += *p_z;
+}
+
+// OFFSET: LEGO1 0x100024a0
+void MxMatrix::SetTranslation(const float *p_x, const float *p_y, const float *p_z)
+{
+  m_data[12] = *p_x;
+  m_data[13] = *p_y;
+  m_data[14] = *p_z;
+}
+
+// OFFSET: LEGO1 0x10002530
+void MxMatrix::EqualsMxProduct(const MxMatrix *p_a, const MxMatrix *p_b)
+{
+  EqualsDataProduct(p_a->m_data, p_b->m_data);
+}
+
+// Just a placeholder matrix multiply implementation. I think the decomp will
+// look roughly like this but it's not close to matching and won't be until
+// an exact match is found given it's all loop and float crunching.
+// OFFSET: LEGO1 0x100024d0 STUB
+void MxMatrix::EqualsDataProduct(const float *p_a, const float *p_b)
+{
+  for (int row = 0; row < 4; ++row)
+  {
+    for (int col = 0; col < 4; ++col)
+    {
+      m_data[row * 4 + col] = 0.0f;
+      for (int k = 0; k < 4; ++k)
+      {
+        m_data[row * 4 + col] += p_a[row * 4 + k] * p_b[k * 4 + col];
+      }
+    }
+  }
+}
+
+// Not close, Ghidra struggles understinging this method so it will have to
+// be manually worked out. Included since I at least figured out what it was
+// doing with rotateIndex and what overall operation it's trying to do.
+// OFFSET: LEGO1 0x10002550 STUB
+void MxMatrix::ToQuaternion(MxVector4 *p_outQuat)
+{
+  float trace = m_data[0] + m_data[5] + m_data[10];
+  if (trace > 0)
+  {
+    trace = sqrt(trace + 1.0);
+    p_outQuat->GetData()[3] = trace * 0.5f;
+    p_outQuat->GetData()[0] = (m_data[9] - m_data[6]) * trace;
+    p_outQuat->GetData()[1] = (m_data[2] - m_data[8]) * trace;
+    p_outQuat->GetData()[2] = (m_data[4] - m_data[1]) * trace;
+    return;
+  }
+
+  // OFFSET: LEGO1 0x100d4090
+  static int rotateIndex[] = {1, 2, 0};
+
+  // Largest element along the trace
+  int largest = m_data[0] < m_data[5];
+  if (*Element(largest, largest) < m_data[10])
+    largest = 2;
+
+  int next = rotateIndex[largest];
+  int nextNext = rotateIndex[next];
+  float valueA = *Element(nextNext, nextNext);
+  float valueB = *Element(next, next);
+  float valueC = *Element(largest, largest);
+
+  // Above is somewhat decomped, below is pure speculation since the automatic
+  // decomp becomes very garbled.
+  float traceValue = sqrt(valueA - valueB - valueC + 1.0);
+
+  p_outQuat->GetData()[largest] = traceValue * 0.5f;
+  traceValue = 0.5f / traceValue;
+
+  p_outQuat->GetData()[3] = (m_data[next + 4 * nextNext] - m_data[nextNext + 4 * next]) * traceValue;
+  p_outQuat->GetData()[next] = (m_data[next + 4 * largest] + m_data[largest + 4 * next]) * traceValue;
+  p_outQuat->GetData()[nextNext] = (m_data[nextNext + 4 * largest] + m_data[largest + 4 * nextNext]) * traceValue;
+}
+
+// No idea what this function is doing and it will be hard to tell until
+// we have a confirmed usage site.
+// OFFSET: LEGO1 0x10002710 STUB
+MxResult MxMatrix::DoSomethingWithLength(const MxVector3 *p_vec)
+{
+  return FAILURE;
+}
+
+// OFFSET: LEGO1 0x10002860
+void MxMatrixData::operator=(const MxMatrixData& p_other)
+{
+  EqualsMxMatrix(&p_other);
+}
diff --git a/LEGO1/mxmatrix.h b/LEGO1/mxmatrix.h
new file mode 100644
index 00000000..0dcb20cb
--- /dev/null
+++ b/LEGO1/mxmatrix.h
@@ -0,0 +1,70 @@
+#ifndef MXMATRIX_H
+#define MXMATRIX_H
+
+#include "mxvector.h"
+
+// VTABLE 0x100d4350
+// SIZE 0x8
+class MxMatrix
+{
+public:
+  inline MxMatrix(float *p_data) : m_data(p_data) {}
+
+  // vtable + 0x00
+  virtual void EqualsMxMatrix(const MxMatrix *p_other);
+  virtual void EqualsMatrixData(const float *p_matrix);
+  virtual void SetData(float *p_data);
+  virtual void AnotherSetData(float *p_data);
+
+  // vtable + 0x10
+  virtual float *GetData();
+  virtual const float *GetData() const;
+  virtual float *Element(int p_row, int p_col);
+  virtual const float *Element(int p_row, int p_col) const;
+
+  // vtable + 0x20
+  virtual void Clear();
+  virtual void SetIdentity();
+  virtual void operator=(const MxMatrix& p_other);
+  virtual MxMatrix *operator+=(const float *p_matrix);
+
+  // vtable + 0x30
+  virtual void TranslateBy(const float *p_x, const float *p_y, const float *p_z);
+  virtual void SetTranslation(const float *p_x, const float *p_y, const float *p_z);
+  virtual void EqualsMxProduct(const MxMatrix *p_a, const MxMatrix *p_b);
+  virtual void EqualsDataProduct(const float *p_a, const float *p_b);
+
+  // vtable + 0x40
+  virtual void ToQuaternion(MxVector4 *p_resultQuat);
+  virtual MxResult DoSomethingWithLength(const MxVector3 *p_vec);
+
+private:
+  float *m_data;
+};
+
+// VTABLE 0x100d4300
+// SIZE 0x48
+class MxMatrixData : public MxMatrix
+{
+public:
+  inline MxMatrixData() : MxMatrix(e) {}
+
+  // No idea why there's another equals. Maybe to some other type like the
+  // DirectX Retained Mode Matrix type which is also a float* alias?
+  // vtable + 0x44
+  virtual void operator=(const MxMatrixData& p_other);
+
+  // Alias an easy way to access the translation part of the matrix, because
+  // various members / other functions benefit from the clarity.
+  union
+  {
+    float e[16];
+    struct
+    {
+      float _[12];
+      float x, y, z, w;
+    };
+  };
+};
+
+#endif // MXMATRIX_H
\ No newline at end of file
diff --git a/LEGO1/mxvector.cpp b/LEGO1/mxvector.cpp
new file mode 100644
index 00000000..80ca1a17
--- /dev/null
+++ b/LEGO1/mxvector.cpp
@@ -0,0 +1,466 @@
+
+#include "mxvector.h"
+
+#include <math.h>
+#include <memory.h>
+
+#include "decomp.h"
+
+DECOMP_SIZE_ASSERT(MxVector2, 0x8);
+DECOMP_SIZE_ASSERT(MxVector3, 0x8);
+DECOMP_SIZE_ASSERT(MxVector4, 0x8);
+DECOMP_SIZE_ASSERT(MxVector3Data, 0x14);
+DECOMP_SIZE_ASSERT(MxVector4Data, 0x18);
+
+// OFFSET: LEGO1 0x10002060
+void MxVector2::SetData(float *p_data)
+{
+  m_data = p_data;
+}
+
+// OFFSET: LEGO1 0x100020a0
+const float *MxVector2::GetData() const
+{
+  return m_data;
+}
+
+// OFFSET: LEGO1 0x10002090
+float *MxVector2::GetData()
+{
+  return m_data;
+}
+
+// OFFSET: LEGO1 0x10002130
+float MxVector2::Dot(MxVector2 *p_a, float *p_b) const
+{
+  return DotImpl(p_a->m_data, p_b);
+}
+
+// OFFSET: LEGO1 0x10002110
+float MxVector2::Dot(float *p_a, MxVector2 *p_b) const
+{
+  return DotImpl(p_a, p_b->m_data);
+}
+
+// OFFSET: LEGO1 0x100020f0
+float MxVector2::Dot(MxVector2 *p_a, MxVector2 *p_b) const
+{
+  return DotImpl(p_a->m_data, p_b->m_data);
+}
+
+// OFFSET: LEGO1 0x100020d0
+float MxVector2::Dot(float *p_a, float *p_b) const
+{
+  return DotImpl(p_a, p_b);
+}
+
+// OFFSET: LEGO1 0x10002160
+MxResult MxVector2::Unitize()
+{
+  float sq = LenSquared();
+  if (sq > 0.0f)
+  {
+    float root = sqrt(sq);
+    if (root > 0)
+    {
+      DivScalarImpl(&root);
+      return SUCCESS;
+    }
+  }
+  return FAILURE;
+}
+
+// OFFSET: LEGO1 0x100021e0
+void MxVector2::AddVector(MxVector2 *p_other)
+{
+  AddVectorImpl(p_other->m_data);
+}
+
+// OFFSET: LEGO1 0x100021d0
+void MxVector2::AddVector(float *p_other)
+{
+  AddVectorImpl(p_other);
+}
+
+// OFFSET: LEGO1 0x100021c0
+void MxVector2::AddScalar(float p_value)
+{
+  AddScalarImpl(p_value);
+}
+
+// OFFSET: LEGO1 0x10002200
+void MxVector2::SubVector(MxVector2 *p_other)
+{
+  SubVectorImpl(p_other->m_data);
+}
+
+// OFFSET: LEGO1 0x100021f0
+void MxVector2::SubVector(float *p_other)
+{
+  SubVectorImpl(p_other);
+}
+
+// OFFSET: LEGO1 0x10002230
+void MxVector2::MullScalar(float *p_value)
+{
+  MullScalarImpl(p_value);
+}
+
+// OFFSET: LEGO1 0x10002220
+void MxVector2::MullVector(MxVector2 *p_other)
+{
+  MullVectorImpl(p_other->m_data);
+}
+
+// OFFSET: LEGO1 0x10002210
+void MxVector2::MullVector(float *p_other)
+{
+  MullVectorImpl(p_other);
+}
+
+// OFFSET: LEGO1 0x10002240
+void MxVector2::DivScalar(float *p_value)
+{
+  DivScalarImpl(p_value);
+}
+
+// OFFSET: LEGO1 0x10002260
+void MxVector2::SetVector(MxVector2 *p_other)
+{
+  EqualsImpl(p_other->m_data);
+}
+
+// OFFSET: LEGO1 0x10002250
+void MxVector2::SetVector(float *p_other)
+{
+  EqualsImpl(p_other);
+}
+
+// OFFSET: LEGO1 0x10001fa0
+void MxVector2::AddScalarImpl(float p_value)
+{
+  m_data[0] += p_value;
+  m_data[1] += p_value;
+}
+
+// OFFSET: LEGO1 0x10001f80
+void MxVector2::AddVectorImpl(float *p_value)
+{
+  m_data[0] += p_value[0];
+  m_data[1] += p_value[1];
+}
+
+// OFFSET: LEGO1 0x10001fc0
+void MxVector2::SubVectorImpl(float *p_value)
+{
+  m_data[0] -= p_value[0];
+  m_data[1] -= p_value[1];
+}
+
+// OFFSET: LEGO1 0x10002000
+void MxVector2::MullScalarImpl(float *p_value)
+{
+  m_data[0] *= *p_value;
+  m_data[1] *= *p_value;
+}
+
+// OFFSET: LEGO1 0x10001fe0
+void MxVector2::MullVectorImpl(float *p_value)
+{
+  m_data[0] *= p_value[0];
+  m_data[1] *= p_value[1];
+}
+
+// OFFSET: LEGO1 0x10002020
+void MxVector2::DivScalarImpl(float *p_value)
+{
+  m_data[0] /= *p_value;
+  m_data[1] /= *p_value;
+}
+
+// OFFSET: LEGO1 0x10002040
+float MxVector2::DotImpl(float *p_a, float *p_b) const
+{
+  return p_b[0] * p_a[0] + p_b[1] * p_a[1];
+}
+
+// OFFSET: LEGO1 0x10002070
+void MxVector2::EqualsImpl(float *p_data)
+{
+  float *vec = m_data;
+  vec[0] = p_data[0];
+  vec[1] = p_data[1];
+}
+
+// OFFSET: LEGO1 0x100020b0
+void MxVector2::Clear()
+{
+  float *vec = m_data;
+  vec[0] = 0.0f;
+  vec[1] = 0.0f;
+}
+
+// OFFSET: LEGO1 0x10002150
+float MxVector2::LenSquared() const
+{
+  return m_data[0] * m_data[0] + m_data[1] * m_data[1];
+}
+
+// OFFSET: LEGO1 0x10003a90
+void MxVector3::AddScalarImpl(float p_value)
+{
+  m_data[0] += p_value;
+  m_data[1] += p_value;
+  m_data[2] += p_value;
+}
+
+// OFFSET: LEGO1 0x10003a60
+void MxVector3::AddVectorImpl(float *p_value)
+{
+  m_data[0] += p_value[0];
+  m_data[1] += p_value[1];
+  m_data[2] += p_value[2];
+}
+
+// OFFSET: LEGO1 0x10003ac0
+void MxVector3::SubVectorImpl(float *p_value)
+{
+  m_data[0] -= p_value[0];
+  m_data[1] -= p_value[1];
+  m_data[2] -= p_value[2];
+}
+
+// OFFSET: LEGO1 0x10003b20
+void MxVector3::MullScalarImpl(float *p_value)
+{
+  m_data[0] *= *p_value;
+  m_data[1] *= *p_value;
+  m_data[2] *= *p_value;
+}
+
+// OFFSET: LEGO1 0x10003af0
+void MxVector3::MullVectorImpl(float *p_value)
+{
+  m_data[0] *= p_value[0];
+  m_data[1] *= p_value[1];
+  m_data[2] *= p_value[2];
+}
+
+// OFFSET: LEGO1 0x10003b50
+void MxVector3::DivScalarImpl(float *p_value)
+{
+  m_data[0] /= *p_value;
+  m_data[1] /= *p_value;
+  m_data[2] /= *p_value;
+}
+
+// OFFSET: LEGO1 0x10003b80
+float MxVector3::DotImpl(float *p_a, float *p_b) const
+{
+  return p_a[0] * p_b[0] + p_a[2] * p_b[2] + p_a[1] * p_b[1];
+}
+
+// OFFSET: LEGO1 0x10003ba0
+void MxVector3::EqualsImpl(float *p_data)
+{
+  float *vec = m_data;
+  vec[0] = p_data[0];
+  vec[1] = p_data[1];
+  vec[2] = p_data[2];
+}
+
+// OFFSET: LEGO1 0x10003bc0
+void MxVector3::Clear()
+{
+  float *vec = m_data;
+  vec[0] = 0.0f;
+  vec[1] = 0.0f;
+  vec[2] = 0.0f;
+}
+
+// OFFSET: LEGO1 0x10003bd0
+float MxVector3::LenSquared() const
+{
+  return m_data[1] * m_data[1] + m_data[0] * m_data[0] + m_data[2] * m_data[2];
+}
+
+// OFFSET: LEGO1 0x10002270
+void MxVector3::EqualsCrossImpl(float* p_a, float* p_b)
+{
+  m_data[0] = p_a[1] * p_b[2] - p_a[2] * p_b[1];
+  m_data[1] = p_a[2] * p_b[0] - p_a[0] * p_b[2];
+  m_data[2] = p_a[0] * p_b[1] - p_a[1] * p_b[0];
+}
+
+// OFFSET: LEGO1 0x10002300
+void MxVector3::EqualsCross(float *p_a, MxVector3 *p_b)
+{
+  EqualsCrossImpl(p_a, p_b->m_data);
+}
+
+// OFFSET: LEGO1 0x100022e0
+void MxVector3::EqualsCross(MxVector3 *p_a, float *p_b)
+{
+  EqualsCrossImpl(p_a->m_data, p_b);
+}
+
+// OFFSET: LEGO1 0x100022c0
+void MxVector3::EqualsCross(MxVector3 *p_a, MxVector3 *p_b)
+{
+  EqualsCrossImpl(p_a->m_data, p_b->m_data);
+}
+
+// OFFSET: LEGO1 0x10003bf0
+void MxVector3::EqualsScalar(float *p_value)
+{
+  m_data[0] = *p_value;
+  m_data[1] = *p_value;
+  m_data[2] = *p_value;
+}
+
+// OFFSET: LEGO1 0x100028b0
+void MxVector4::AddScalarImpl(float p_value)
+{
+  m_data[0] += p_value;
+  m_data[1] += p_value;
+  m_data[2] += p_value;
+  m_data[3] += p_value;
+}
+
+// OFFSET: LEGO1 0x10002870
+void MxVector4::AddVectorImpl(float *p_value)
+{
+  m_data[0] += p_value[0];
+  m_data[1] += p_value[1];
+  m_data[2] += p_value[2];
+  m_data[3] += p_value[3];
+}
+
+// OFFSET: LEGO1 0x100028f0
+void MxVector4::SubVectorImpl(float *p_value)
+{
+  m_data[0] -= p_value[0];
+  m_data[1] -= p_value[1];
+  m_data[2] -= p_value[2];
+  m_data[3] -= p_value[3];
+}
+
+// OFFSET: LEGO1 0x10002970
+void MxVector4::MullScalarImpl(float *p_value)
+{
+  m_data[0] *= *p_value;
+  m_data[1] *= *p_value;
+  m_data[2] *= *p_value;
+  m_data[3] *= *p_value;
+}
+
+// OFFSET: LEGO1 0x10002930
+void MxVector4::MullVectorImpl(float *p_value)
+{
+  m_data[0] *= p_value[0];
+  m_data[1] *= p_value[1];
+  m_data[2] *= p_value[2];
+  m_data[3] *= p_value[3];
+}
+
+// OFFSET: LEGO1 0x100029b0
+void MxVector4::DivScalarImpl(float *p_value)
+{
+  m_data[0] /= *p_value;
+  m_data[1] /= *p_value;
+  m_data[2] /= *p_value;
+  m_data[3] /= *p_value;
+}
+
+// OFFSET: LEGO1 0x100029f0
+float MxVector4::DotImpl(float *p_a, float *p_b) const
+{
+  return
+    p_a[0] * p_b[0] + p_a[2] * p_b[2] +
+    p_a[1] * p_b[1] + p_a[3] * p_b[3];
+}
+
+// OFFSET: LEGO1 0x10002a20
+void MxVector4::EqualsImpl(float *p_data)
+{
+  float *vec = m_data;
+  vec[0] = p_data[0];
+  vec[1] = p_data[1];
+  vec[2] = p_data[2];
+  vec[3] = p_data[3];
+}
+
+// OFFSET: LEGO1 0x10002b00
+void MxVector4::Clear()
+{
+  float *vec = m_data;
+  vec[0] = 0.0f;
+  vec[1] = 0.0f;
+  vec[2] = 0.0f;
+  vec[3] = 0.0f;
+}
+
+// OFFSET: LEGO1 0x10002b20
+float MxVector4::LenSquared() const
+{
+  return m_data[1] * m_data[1] + m_data[0] * m_data[0] + 
+    m_data[2] * m_data[2] + m_data[3] * m_data[3];
+}
+
+// OFFSET: LEGO1 0x10002b40
+void MxVector4::EqualsScalar(float *p_value)
+{
+  m_data[0] = *p_value;
+  m_data[1] = *p_value;
+  m_data[2] = *p_value;
+  m_data[3] = *p_value;
+}
+
+// OFFSET: LEGO1 0x10002ae0 STUB
+void MxVector4::unk1(MxVector4 *p_a, float *p_b)
+{
+}
+
+// OFFSET: LEGO1 0x10002a40
+void MxVector4::SetMatrixProduct(float *p_vec, float *p_mat)
+{
+  m_data[0] =
+      p_vec[0] * p_mat[0] + p_vec[1] * p_mat[4] +
+      p_vec[2] * p_mat[8] + p_vec[3] * p_mat[12];
+  m_data[1] =
+      p_vec[0] * p_mat[1] + p_vec[1] * p_mat[5] +
+      p_vec[2] * p_mat[9] + p_vec[4] * p_mat[13];
+  m_data[2] =
+      p_vec[0] * p_mat[2] + p_vec[1] * p_mat[6] +
+      p_vec[2] * p_mat[10] + p_vec[4] * p_mat[14];
+  m_data[3] =
+      p_vec[0] * p_mat[3] + p_vec[1] * p_mat[7] +
+      p_vec[2] * p_mat[11] + p_vec[4] * p_mat[15];
+}
+
+// Note close yet, included because I'm at least confident I know what operation
+// it's trying to do.
+// OFFSET: LEGO1 0x10002b70 STUB
+MxResult MxVector4::NormalizeQuaternion()
+{
+  float *v = m_data;
+  float magnitude = v[1] * v[1] + v[2] * v[2] + v[0] * v[0];
+  if (magnitude > 0.0f)
+  {
+    float theta = v[3] * 0.5f;
+    v[3] = cos(theta);
+    float frac = sin(theta);
+    magnitude = frac / sqrt(magnitude);
+    v[0] *= magnitude;
+    v[1] *= magnitude;
+    v[2] *= magnitude;
+    return SUCCESS;
+  }
+  return FAILURE;
+}
+
+// OFFSET: LEGO1 0x10002bf0 STUB
+void MxVector4::UnknownQuaternionOp(MxVector4 *p_a, MxVector4 *p_b)
+{
+
+}
\ No newline at end of file
diff --git a/LEGO1/mxvector.h b/LEGO1/mxvector.h
new file mode 100644
index 00000000..0b766348
--- /dev/null
+++ b/LEGO1/mxvector.h
@@ -0,0 +1,150 @@
+#ifndef MXVECTOR_H
+#define MXVECTOR_H
+
+#include "mxtypes.h"
+
+// VTABLE 0x100d4288
+// SIZE 0x8
+class MxVector2
+{
+public:
+  // OFFSET: LEGO1 0x1000c0f0
+  inline MxVector2(float* p_data) : m_data(p_data) {}
+
+  // vtable + 0x00 (no virtual destructor)
+  virtual void AddScalarImpl(float p_value) = 0;
+  virtual void AddVectorImpl(float *p_value) = 0;
+  virtual void SubVectorImpl(float *p_value) = 0;
+  virtual void MullScalarImpl(float *p_value) = 0;
+
+  // vtable + 0x10
+  virtual void MullVectorImpl(float *p_value) = 0;
+  virtual void DivScalarImpl(float *p_value) = 0;
+  virtual float DotImpl(float *p_a, float *p_b) const = 0;
+  virtual void SetData(float *p_data);
+
+  // vtable + 0x20
+  virtual void EqualsImpl(float *p_data) = 0;
+  virtual const float *GetData() const;
+  virtual float *GetData();
+  virtual void Clear() = 0;
+
+  // vtable + 0x30
+  virtual float Dot(MxVector2 *p_a, float *p_b) const;
+  virtual float Dot(float *p_a, MxVector2 *p_b) const;
+  virtual float Dot(MxVector2 *p_a, MxVector2 *p_b) const;
+  virtual float Dot(float *p_a, float *p_b) const;
+
+  // vtable + 0x40
+  virtual float LenSquared() const = 0;
+  virtual MxResult Unitize();
+
+  // vtable + 0x48
+  virtual void AddVector(MxVector2 *p_other);
+  virtual void AddVector(float *p_other);
+  virtual void AddScalar(float p_value);
+
+  // vtable + 0x54
+  virtual void SubVector(MxVector2 *p_other);
+  virtual void SubVector(float *p_other);
+
+  // vtable + 0x5C
+  virtual void MullScalar(float *p_value);
+  virtual void MullVector(MxVector2 *p_other);
+  virtual void MullVector(float *p_other);
+  virtual void DivScalar(float *p_value);
+
+  // vtable + 0x6C
+  virtual void SetVector(MxVector2 *other);
+  virtual void SetVector(float *other);
+
+protected:
+  float *m_data;
+};
+
+// VTABLE 0x100d4518
+// SIZE 0x8
+class MxVector3 : public MxVector2
+{
+public:
+  inline MxVector3(float* p_data) : MxVector2(p_data) {}
+
+  void AddScalarImpl(float p_value);
+
+  void AddVectorImpl(float *p_value);
+
+  void SubVectorImpl(float *p_value);
+  void MullScalarImpl(float *p_value);
+  void MullVectorImpl(float *p_value);
+  void DivScalarImpl(float *p_value);
+  float DotImpl(float *p_a, float *p_b) const;
+
+  void EqualsImpl(float *p_data);
+
+  void Clear();
+
+  float LenSquared() const;
+
+  // vtable + 0x74
+  virtual void EqualsCrossImpl(float* p_a, float* p_b);
+  virtual void EqualsCross(float *p_a, MxVector3 *p_b);
+  virtual void EqualsCross(MxVector3 *p_a, float *p_b);
+  virtual void EqualsCross(MxVector3 *p_a, MxVector3 *p_b);
+  virtual void EqualsScalar(float *p_value);
+};
+
+// VTABLE 0x100d45a0
+// SIZE 0x8
+class MxVector4 : public MxVector3
+{
+public:
+  inline MxVector4(float* p_data) : MxVector3(p_data) {}
+
+  void AddScalarImpl(float p_value);
+
+  void AddVectorImpl(float *p_value);
+
+  void SubVectorImpl(float *p_value);
+  void MullScalarImpl(float *p_value);
+  void MullVectorImpl(float *p_value);
+  void DivScalarImpl(float *p_value);
+  float DotImpl(float *p_a, float *p_b) const;
+
+  void EqualsImpl(float *p_data);
+
+  void Clear();
+
+  float LenSquared() const;
+
+  void EqualsScalar(float *p_value);
+
+  // vtable + 0x84
+  virtual void unk1(MxVector4 *p_a, float *p_b);
+  virtual void SetMatrixProduct(float *p_vec, float *p_mat);
+  virtual MxResult NormalizeQuaternion();
+  virtual void UnknownQuaternionOp(MxVector4 *p_a, MxVector4 *p_b);
+};
+
+// VTABLE 0x100d4488
+// SIZE 0x14
+class MxVector3Data : public MxVector3
+{
+public:
+  inline MxVector3Data() : MxVector3(&x) {}
+  inline MxVector3Data(float p_x, float p_y, float p_z)
+    : MxVector3(&x)
+    , x(p_x), y(p_y), z(p_z)
+    {}
+  float x, y, z;
+};
+
+// VTABLE 0x100d41e8
+// SIZE 0x18
+class MxVector4Data : public MxVector4
+{
+public:
+  inline MxVector4Data() : MxVector4(&x) {}
+  float x, y, z, w;
+};
+
+#endif // MXVECTOR_H
\ No newline at end of file
diff --git a/tools/reccmp/reccmp.py b/tools/reccmp/reccmp.py
index 69779872..1beec5dd 100755
--- a/tools/reccmp/reccmp.py
+++ b/tools/reccmp/reccmp.py
@@ -343,14 +343,15 @@ def replace_register(lines: list[str], start_line: int, reg: str, replacement: s
 
 # Is it possible to make new_asm the same as original_asm by swapping registers?
 def can_resolve_register_differences(original_asm, new_asm):
+  # Split the ASM on spaces to get more granularity, and so
+  # that we don't modify the original arrays passed in.
+  original_asm = [part for line in original_asm for part in line.split()]
+  new_asm = [part for line in new_asm for part in line.split()]
+
   # Swapping ain't gonna help if the lengths are different
   if len(original_asm) != len(new_asm):
     return False
 
-  # Make copies so we don't modify the original
-  original_asm = original_asm.copy()
-  new_asm = new_asm.copy()
-
   # Look for the mismatching lines
   for i in range(len(original_asm)):
     new_line = new_asm[i]

From dc585c7f613066afc05b4340a8bfe00ffccdee09 Mon Sep 17 00:00:00 2001
From: Joshua Peisach <itzswirlz2020@outlook.com>
Date: Thu, 3 Aug 2023 14:42:12 -0400
Subject: [PATCH 11/21] MxBackgroundAudioManager (#97)

* Start MxBackgroundAudioManager

* Match MxBackgroundAudioManager constructor. This took WAY too much time.

* add size assert

* improve readability of MxBackgroundAudioManager::Enable

While the previous iteration wasn't incorrect, it definitely reads like pseudocode (i.e. it's very unlikely any actual developers would have written that). This is much more readable/likely to have been written and still results in the same asm.

---------

Co-authored-by: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
---
 LEGO1/mxbackgroundaudiomanager.cpp | 32 ++++++++++++++++++++++++++++--
 LEGO1/mxbackgroundaudiomanager.h   | 17 ++++++++++++++++
 2 files changed, 47 insertions(+), 2 deletions(-)

diff --git a/LEGO1/mxbackgroundaudiomanager.cpp b/LEGO1/mxbackgroundaudiomanager.cpp
index 6f001303..a24286ad 100644
--- a/LEGO1/mxbackgroundaudiomanager.cpp
+++ b/LEGO1/mxbackgroundaudiomanager.cpp
@@ -1,13 +1,29 @@
 #include "mxbackgroundaudiomanager.h"
 
+DECOMP_SIZE_ASSERT(MxBackgroundAudioManager, 0x150)
+
 // OFFSET: LEGO1 0x1007ea90
 MxBackgroundAudioManager::MxBackgroundAudioManager()
 {
-  // TODO
+  NotificationManager()->Register(this);
+  m_unka0 = 0;
+  m_unk138 = 0;
+  m_unk13c = 0;
+  m_unk140 = 0;
+  m_unk144 = 0;
+  m_unk148 = 0;
+  m_musicEnabled = FALSE;
 }
 
 // OFFSET: LEGO1 0x1007ec20
 MxBackgroundAudioManager::~MxBackgroundAudioManager()
+{
+  // TODO
+  NotificationManager()->Unregister(this);
+}
+
+// OFFSET: LEGO1 0x1007f470
+void MxBackgroundAudioManager::Stop()
 {
   // TODO
 }
@@ -15,5 +31,17 @@ MxBackgroundAudioManager::~MxBackgroundAudioManager()
 // OFFSET: LEGO1 0x1007f5f0
 void MxBackgroundAudioManager::Enable(MxBool p)
 {
-  // TODO
+  if (this->m_musicEnabled != p) {
+    this->m_musicEnabled = p;
+    if (!p) {
+      Stop();
+    }
+  }
+}
+
+// OFFSET: LEGO1 0x1007f650
+void MxBackgroundAudioManager::Init()
+{
+  this->m_unka0 = 0;
+  this->m_unk13c = 0;
 }
diff --git a/LEGO1/mxbackgroundaudiomanager.h b/LEGO1/mxbackgroundaudiomanager.h
index 9a23a671..c6f2f1e7 100644
--- a/LEGO1/mxbackgroundaudiomanager.h
+++ b/LEGO1/mxbackgroundaudiomanager.h
@@ -2,6 +2,9 @@
 #define MXBACKGROUNDAUDIOMANAGER_H
 
 #include "mxcore.h"
+#include "mxdsaction.h"
+#include "mxtypes.h"
+#include "mxnotificationmanager.h"
 
 // VTABLE 0x100d9fe8
 // SIZE 0x150
@@ -25,6 +28,20 @@ class MxBackgroundAudioManager : public MxCore
   }
 
   __declspec(dllexport) void Enable(unsigned char p);
+private:
+  void Stop();
+  void Init();
+
+  MxBool m_musicEnabled; // 0x8
+  MxDSAction m_action1; // 0xc
+  MxS32 m_unka0;
+  MxDSAction m_action2; // 0xa4
+  MxS32 m_unk138;
+  MxS32 m_unk13c;
+  MxS32 m_unk140;
+  MxS32 m_unk144;
+  MxS16 m_unk148;
+  MxAtomId m_unk14c;
 };
 
 #endif // MXBACKGROUNDAUDIOMANAGER_H

From b6ada8f46cb7a9ed44e7e5e2e1daf8aa7899587c Mon Sep 17 00:00:00 2001
From: Joshua Peisach <itzswirlz2020@outlook.com>
Date: Thu, 3 Aug 2023 19:43:36 -0400
Subject: [PATCH 12/21] Small implementations in MxEntity/MxEventManager (#96)

* Small implementations in MxEntity/MxEventManager

* Cleanup

* Update LEGO1/mxentity.cpp

---------

Co-authored-by: MattKC <34096995+itsmattkc@users.noreply.github.com>
---
 LEGO1/mxentity.cpp       |  8 ++++++++
 LEGO1/mxentity.h         |  2 ++
 LEGO1/mxeventmanager.cpp | 13 +++++++++----
 LEGO1/mxeventmanager.h   |  2 ++
 4 files changed, 21 insertions(+), 4 deletions(-)

diff --git a/LEGO1/mxentity.cpp b/LEGO1/mxentity.cpp
index da536504..65adad67 100644
--- a/LEGO1/mxentity.cpp
+++ b/LEGO1/mxentity.cpp
@@ -12,3 +12,11 @@ MxEntity::MxEntity()
 MxEntity::~MxEntity()
 {
 }
+
+// OFFSET: LEGO1 0x10001070
+MxResult MxEntity::SetEntityId(MxS32 p_id, const MxAtomId &p_atom)
+{
+  this->m_mxEntityId = p_id;
+  this->m_atom = p_atom;
+  return SUCCESS;
+}
diff --git a/LEGO1/mxentity.h b/LEGO1/mxentity.h
index dc959c35..25e74d1b 100644
--- a/LEGO1/mxentity.h
+++ b/LEGO1/mxentity.h
@@ -26,6 +26,8 @@ class MxEntity : public MxCore
   {
     return !strcmp(name, MxEntity::ClassName()) || MxCore::IsA(name);
   }
+
+  virtual MxResult SetEntityId(MxS32 p_id, const MxAtomId &p_atom); // vtable+0x14
 private:
   MxS32 m_mxEntityId; // 0x8
   MxAtomId m_atom; // 0xc
diff --git a/LEGO1/mxeventmanager.cpp b/LEGO1/mxeventmanager.cpp
index 786420bc..5383c25a 100644
--- a/LEGO1/mxeventmanager.cpp
+++ b/LEGO1/mxeventmanager.cpp
@@ -1,13 +1,18 @@
 #include "mxeventmanager.h"
 
-// OFFSET: LEGO1 0x100c0360 STUB
+// OFFSET: LEGO1 0x100c0360
 MxEventManager::MxEventManager()
 {
-  // TODO
+  Init();
 }
 
-// OFFSET: LEGO1 0x100c03f0 STUB
+// OFFSET: LEGO1 0x100c03f0
 MxEventManager::~MxEventManager()
 {
-  // TODO
+  // TODO: MxMediaManager::TerminateThread call
 }
+
+// OFFSET: LEGO1 0x100c0450
+void MxEventManager::Init()
+{
+}
\ No newline at end of file
diff --git a/LEGO1/mxeventmanager.h b/LEGO1/mxeventmanager.h
index be5a796c..1fe7daeb 100644
--- a/LEGO1/mxeventmanager.h
+++ b/LEGO1/mxeventmanager.h
@@ -11,6 +11,8 @@ class MxEventManager : public MxUnknown100dc6b0
   MxEventManager();
   virtual ~MxEventManager() override;
 
+private:
+  void Init();
 };
 
 #endif // MXEVENTMANAGER_H

From 71950cd40ac32ed0e788af12a3e3d5eeecf58c73 Mon Sep 17 00:00:00 2001
From: MS <disinvite@users.noreply.github.com>
Date: Thu, 3 Aug 2023 20:13:41 -0400
Subject: [PATCH 13/21] lego1: MxVariableTable (#87)

* MxStringVariable -> MxVariable

* cursor test

* GetVariable to 100

* meh

* node insert inline

* move to header file

* use reference to match available code

* variable table init in mxomni, some reshuffling
---
 CMakeLists.txt                |   2 +-
 LEGO1/legobackgroundcolor.cpp |  14 +-
 LEGO1/legobackgroundcolor.h   |   8 +-
 LEGO1/mxhashtable.h           | 241 ++++++++++++++++++++++++++++++++++
 LEGO1/mxomni.cpp              |   9 ++
 LEGO1/mxstringvariable.cpp    |  22 ----
 LEGO1/mxstringvariable.h      |  20 ---
 LEGO1/mxvariable.cpp          |  20 +++
 LEGO1/mxvariable.h            |  34 +++++
 LEGO1/mxvariabletable.cpp     |  60 ++++++++-
 LEGO1/mxvariabletable.h       |  20 ++-
 11 files changed, 385 insertions(+), 65 deletions(-)
 create mode 100644 LEGO1/mxhashtable.h
 delete mode 100644 LEGO1/mxstringvariable.cpp
 delete mode 100644 LEGO1/mxstringvariable.h
 create mode 100644 LEGO1/mxvariable.cpp
 create mode 100644 LEGO1/mxvariable.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index df71ccf0..3d1d0a1e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -149,13 +149,13 @@ add_library(lego1 SHARED
   LEGO1/mxstillpresenter.cpp
   LEGO1/mxstreamer.cpp
   LEGO1/mxstring.cpp
-  LEGO1/mxstringvariable.cpp
   LEGO1/mxthread.cpp
   LEGO1/mxticklemanager.cpp
   LEGO1/mxtimer.cpp
   LEGO1/mxtransitionmanager.cpp
   LEGO1/mxunknown100dc6b0.cpp
   LEGO1/mxunknown100dc6e0.cpp
+  LEGO1/mxvariable.cpp
   LEGO1/mxvariabletable.cpp
   LEGO1/mxvector.cpp
   LEGO1/mxvideomanager.cpp
diff --git a/LEGO1/legobackgroundcolor.cpp b/LEGO1/legobackgroundcolor.cpp
index 2d8c5348..e1d6beca 100644
--- a/LEGO1/legobackgroundcolor.cpp
+++ b/LEGO1/legobackgroundcolor.cpp
@@ -9,18 +9,18 @@ const char *g_set = "set";
 const char *g_reset = "reset";
 
 // OFFSET: LEGO1 0x1003bfb0
-LegoBackgroundColor::LegoBackgroundColor(const char *p_name, const char *p_colorString)
+LegoBackgroundColor::LegoBackgroundColor(const char *p_key, const char *p_value)
 {
-  m_name = p_name;
-  m_name.ToUpperCase();
-  SetColorString(p_colorString);
+  m_key = p_key;
+  m_key.ToUpperCase();
+  SetValue(p_value);
 }
 
 // OFFSET: LEGO1 0x1003c070
-void LegoBackgroundColor::SetColorString(const char *p_colorString)
+void LegoBackgroundColor::SetValue(const char *p_colorString)
 {
-  m_string = p_colorString;
-  m_string.ToLowerCase();
+  m_value = p_colorString;
+  m_value.ToLowerCase();
 
   LegoVideoManager *videomanager = VideoManager();
   if (!videomanager || !p_colorString)
diff --git a/LEGO1/legobackgroundcolor.h b/LEGO1/legobackgroundcolor.h
index 9345c394..aff62fe8 100644
--- a/LEGO1/legobackgroundcolor.h
+++ b/LEGO1/legobackgroundcolor.h
@@ -1,13 +1,13 @@
 #ifndef LEGOBACKGROUNDCOLOR_H
 #define LEGOBACKGROUNDCOLOR_H
 
-#include "mxstringvariable.h"
+#include "mxvariable.h"
 
-class LegoBackgroundColor : public MxStringVariable
+class LegoBackgroundColor : public MxVariable
 {
 public:
-  __declspec(dllexport) LegoBackgroundColor(const char *p_name, const char *p_colorString);
-  void SetColorString(const char *p_colorString);
+  __declspec(dllexport) LegoBackgroundColor(const char *p_key, const char *p_value);
+  void SetValue(const char *p_colorString);
 
 private:
   float h;
diff --git a/LEGO1/mxhashtable.h b/LEGO1/mxhashtable.h
new file mode 100644
index 00000000..f9505bb5
--- /dev/null
+++ b/LEGO1/mxhashtable.h
@@ -0,0 +1,241 @@
+#ifndef MXHASHTABLE_H
+#define MXHASHTABLE_H
+
+#include "mxtypes.h"
+#include "mxcore.h"
+
+#define HASH_TABLE_INIT_SIZE              128
+#define HASH_TABLE_OPT_NO_EXPAND          0
+#define HASH_TABLE_OPT_EXPAND_ADD         1
+#define HASH_TABLE_OPT_EXPAND_MULTIPLY    2
+
+template <class T>
+class MxHashTableNode
+{
+public:
+  MxHashTableNode<T>() {}
+  MxHashTableNode<T>(T *p_obj, MxU32 p_hash)
+  {
+    m_obj = p_obj;
+    m_hash = p_hash;
+    m_prev = NULL;
+    m_next = NULL;
+  }
+
+//private:
+  T* m_obj;
+  MxU32 m_hash;
+  MxHashTableNode *m_prev;
+  MxHashTableNode *m_next;
+};
+
+// See MxOmni::Create
+// VTABLE 0x100dc1b0
+template <class T>
+class HashTableParent : public MxCore
+{
+public:
+  HashTableParent() {
+    m_numKeys = 0;
+    m_customDestructor = Destroy;
+  }
+
+  // OFFSET: LEGO1 0x100afd30
+  static void Destroy(T*) {};
+
+  // OFFSET: LEGO1 0x100afcd0
+  virtual MxS8 Compare(T*, T*) = 0;
+
+protected:
+  MxU32 m_numKeys; // +0x8
+  void (*m_customDestructor)(T*); // +0xc
+};
+
+// VTABLE 0x100dc1e8
+template <class T>
+class MxHashTable : protected HashTableParent<T>
+{
+public:
+  MxHashTable()
+  {
+    m_numSlots = HASH_TABLE_INIT_SIZE;
+    m_slots = new MxHashTableNode<T>*[HASH_TABLE_INIT_SIZE];
+    memset(m_slots, 0, sizeof(MxHashTableNode<T> *) * m_numSlots);
+    m_resizeOption = HASH_TABLE_OPT_NO_EXPAND;
+  }
+
+  virtual ~MxHashTable();
+
+  void Resize();
+  void MxHashTable::Add(T* );
+
+  virtual MxS8 Compare(T*, T*) = 0;
+
+  // OFFSET: LEGO1 0x100afdc0
+  virtual MxU32 Hash(T*) = 0;
+
+  // FIXME: use of friend here?
+  friend class MxHashTableCursor<T>;
+
+protected:
+  void _NodeInsert(MxHashTableNode<T> *);
+
+  MxHashTableNode<T> **m_slots; // +0x10
+  MxU32 m_numSlots; // +0x14
+  MxU32 m_autoResizeRatio;
+  int m_resizeOption; // +0x1c
+  // FIXME: or FIXME? This qword is used as an integer or double depending
+  // on the value of m_resizeOption. Hard to say whether this is how the devs
+  // did it, but a simple cast in either direction doesn't match.
+  union {
+    MxU32 m_increaseAmount;
+    double m_increaseFactor;
+  };
+};
+
+template <class T>
+class MxHashTableCursor : public MxCore
+{
+public:
+  MxHashTableCursor(MxHashTable<T> *p_hashTable)
+  {
+    m_table = p_hashTable;
+    m_match = NULL;
+  }
+
+  MxBool Find(T *p_obj)
+  {
+    MxU32 hash = m_table->Hash(p_obj);
+    int bucket = hash % m_table->m_numSlots;
+
+    MxHashTableNode<T> *t = m_table->m_slots[bucket];
+
+    while (t) {
+      if (t->m_hash == hash && !m_table->Compare(t->m_obj, p_obj))
+        m_match = t;
+      t = t->m_next;
+    }
+
+    return m_match != NULL;
+  }
+
+  void GetMatch(T*& p_obj)
+  {
+    if (m_match) {
+      p_obj = m_match->m_obj;
+    }
+  }
+
+  void DeleteMatch()
+  {
+    // Cut the matching node out of the linked list
+    // by updating pointer references.
+
+    if (m_match->m_prev) {
+      m_match->m_prev->m_next = m_match->m_next;
+    } else {
+      // No "prev" node, so move "next" to the head of the list.
+      int bucket = m_match->m_hash % m_table->m_numSlots;
+      m_table->m_slots[bucket] = m_match->m_next;
+    }
+
+    if (m_match->m_next)
+      m_match->m_next->m_prev = m_match->m_prev;
+
+    m_table->m_customDestructor(m_match->m_obj);
+    delete m_match;
+    m_table->m_numKeys--;
+  }
+
+private:
+  MxHashTable<T> *m_table;
+  MxHashTableNode<T> *m_match;
+};
+
+
+template <class T>
+// OFFSET: LEGO1 0x100b0bd0
+MxHashTable<T>::~MxHashTable()
+{
+  for (int i = 0; i < m_numSlots; i++) {
+    MxHashTableNode<T> *t = m_slots[i];
+    
+    while (t) {
+      MxHashTableNode<T> *next = t->m_next;
+      m_customDestructor(t->m_obj);
+      delete t;
+      t = next;
+    }
+  }
+
+  m_numKeys = 0;
+  memset(m_slots, 0, sizeof(MxHashTableNode<T> *) * m_numSlots);
+
+  delete[] m_slots;
+}
+
+template <class T>
+// OFFSET: LEGO1 0x100b7ab0
+inline void MxHashTable<T>::Resize()
+{
+  // Save a reference to the current table
+  // so we can walk nodes and re-insert
+  MxU32 old_size = m_numSlots;
+  MxHashTableNode<T> **old_table = m_slots;
+
+  switch (m_resizeOption) {
+    case HASH_TABLE_OPT_EXPAND_ADD:
+      m_numSlots = old_size + m_increaseAmount;
+      break;
+    case HASH_TABLE_OPT_EXPAND_MULTIPLY:
+      m_numSlots = old_size * m_increaseFactor;
+      break;
+  }
+
+  MxHashTableNode<T> **new_table = new MxHashTableNode<T>*[m_numSlots];
+  // FIXME: order? m_numKeys set after `rep stosd`
+  m_slots = new_table;
+  memset(m_slots, 0, sizeof(MxHashTableNode<T> *) * m_numSlots);
+  m_numKeys = 0;
+
+  for (int i = 0; i != old_size; i++) {
+    MxHashTableNode<T> *t = old_table[i];
+    
+    while (t) {
+      MxHashTableNode<T> *next = t->m_next;
+      _NodeInsert(t);
+      t = next;
+    }
+  }
+
+  delete[] old_table;
+}
+
+template <class T>
+// OFFSET: LEGO1 0x100b7b80
+inline void MxHashTable<T>::_NodeInsert(MxHashTableNode<T> *p_node)
+{
+  int bucket = p_node->m_hash % m_numSlots;
+  
+  p_node->m_next = m_slots[bucket];
+  
+  if (m_slots[bucket])
+    m_slots[bucket]->m_prev = p_node;
+
+  m_slots[bucket] = p_node;
+  m_numKeys++;
+}
+
+template <class T>
+inline void MxHashTable<T>::Add(T* p_newobj)
+{
+  if (m_resizeOption && ((m_numKeys + 1) / m_numSlots) > m_autoResizeRatio)
+    MxHashTable<T>::Resize();
+
+  MxU32 hash = Hash(p_newobj);
+  MxHashTableNode<T> *node = new MxHashTableNode<T>(p_newobj, hash);
+
+  MxHashTable<T>::_NodeInsert(node);
+}
+
+#endif // MXHASHTABLE_H
\ No newline at end of file
diff --git a/LEGO1/mxomni.cpp b/LEGO1/mxomni.cpp
index 10e8eccb..f5022b30 100644
--- a/LEGO1/mxomni.cpp
+++ b/LEGO1/mxomni.cpp
@@ -104,6 +104,15 @@ void MxOmni::SetInstance(MxOmni *instance)
 // OFFSET: LEGO1 0x100af0c0
 MxResult MxOmni::Create(MxOmniCreateParam &p)
 {
+  if (p.CreateFlags().CreateVariableTable())
+  {
+    MxVariableTable *variableTable = new MxVariableTable();
+    this->m_variableTable = variableTable;
+
+    if (variableTable == NULL)
+      return FAILURE;
+  }
+
   if (p.CreateFlags().CreateTimer())
   {
     MxTimer *timer = new MxTimer();
diff --git a/LEGO1/mxstringvariable.cpp b/LEGO1/mxstringvariable.cpp
deleted file mode 100644
index e63329c1..00000000
--- a/LEGO1/mxstringvariable.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "mxstringvariable.h"
-#include "mxstring.h"
-
-
-// OFFSET: LEGO1 0x1003bea0
-MxString *MxStringVariable::GetString()
-{
-  return &m_string;
-}
-
-// OFFSET: LEGO1 0x1003beb0
-void MxStringVariable::SetString(const char *colorString)
-{
-  m_string = colorString;
-}
-
-//FIXME: Figure out what exactly this class is used for. It is used in LegoGameState::LegoGameState when loading the background color, and for loading the "fsmovie" variable
-// OFFSET: LEGO1 0x1003bec0
-void MxStringVariable::Destroy()
-{
-  delete this;
-}
diff --git a/LEGO1/mxstringvariable.h b/LEGO1/mxstringvariable.h
deleted file mode 100644
index dd623dfb..00000000
--- a/LEGO1/mxstringvariable.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#ifndef MXSTRINGVARIABLE_H
-#define MXSTRINGVARIABLE_H
-#include "mxstring.h"
-#include "mxcore.h"
-//VTABLE: 0x100d74a8
-class MxStringVariable
-{
-public:
-  __declspec(dllexport) MxStringVariable(const char *, const char *);
-  MxStringVariable() {}
-  virtual MxString *GetString();
-  virtual void SetString(const char *colorString);
-  virtual void Destroy();
-
-protected:
-  MxString m_name;
-  MxString m_string;
-};
-
-#endif // MXSTRINGVARIABLE_H
diff --git a/LEGO1/mxvariable.cpp b/LEGO1/mxvariable.cpp
new file mode 100644
index 00000000..f18e6a94
--- /dev/null
+++ b/LEGO1/mxvariable.cpp
@@ -0,0 +1,20 @@
+#include "mxvariable.h"
+#include "mxstring.h"
+
+// OFFSET: LEGO1 0x1003bea0
+MxString *MxVariable::GetValue()
+{
+  return &m_value;
+}
+
+// OFFSET: LEGO1 0x1003beb0
+void MxVariable::SetValue(const char *value)
+{
+  m_value = value;
+}
+
+// OFFSET: LEGO1 0x1003bec0
+void MxVariable::Destroy()
+{
+  delete this;
+}
diff --git a/LEGO1/mxvariable.h b/LEGO1/mxvariable.h
new file mode 100644
index 00000000..6899dfac
--- /dev/null
+++ b/LEGO1/mxvariable.h
@@ -0,0 +1,34 @@
+#ifndef MXVARIABLE_H
+#define MXVARIABLE_H
+
+#include "mxstring.h"
+#include "mxcore.h"
+
+//VTABLE: 0x100d74a8
+class MxVariable
+{
+public:
+  MxVariable() {}
+  MxVariable(const char *p_key)
+  {
+    m_key = p_key;
+    m_key.ToUpperCase();    
+  }
+  MxVariable(const char *p_key, const char *p_value)
+  {
+    m_key = p_key;
+    m_key.ToUpperCase();
+    m_value = p_value;
+  }
+  virtual MxString *GetValue();
+  virtual void SetValue(const char *);
+  virtual void Destroy();
+
+  inline const MxString *GetKey() const { return &m_key; }
+
+protected:
+  MxString m_key;
+  MxString m_value;
+};
+
+#endif // MXVARIABLE_H
diff --git a/LEGO1/mxvariabletable.cpp b/LEGO1/mxvariabletable.cpp
index 8927bc32..81628993 100644
--- a/LEGO1/mxvariabletable.cpp
+++ b/LEGO1/mxvariabletable.cpp
@@ -1,20 +1,66 @@
 #include "mxvariabletable.h"
 
-// OFFSET: LEGO1 0x100b73a0
-void MxVariableTable::SetVariable(const char *key, const char *value)
+// OFFSET: LEGO1 0x100b7330
+MxS8 MxVariableTable::Compare(MxVariable *p_var0, MxVariable *p_var1)
 {
-  // TODO
+  return strcmp(p_var0->GetKey()->GetData(),
+                p_var1->GetKey()->GetData());
+}
+
+// OFFSET: LEGO1 0x100b7370
+MxU32 MxVariableTable::Hash(MxVariable *p_var)
+{
+  const char *str = p_var->GetKey()->GetData();
+  MxU32 value = 0;
+  
+  for (int i = 0; str[i]; i++) {
+    value += str[i];
+  }
+
+  return value;
+}
+
+// OFFSET: LEGO1 0x100b73a0
+void MxVariableTable::SetVariable(const char *p_key, const char *p_value)
+{
+  MxHashTableCursor<MxVariable> cursor(this);
+  MxVariable *var = new MxVariable(p_key, p_value);
+
+  if (cursor.Find(var)) {
+    delete var;
+    cursor.GetMatch(var);
+    var->SetValue(p_value);
+  } else {
+    MxHashTable<MxVariable>::Add(var);
+  }
 }
 
 // OFFSET: LEGO1 0x100b7740
 void MxVariableTable::SetVariable(MxVariable *var)
 {
-  // TODO
+  MxHashTableCursor<MxVariable> cursor(this);
+  MxBool found = cursor.Find(var);
+
+  if (found)
+    cursor.DeleteMatch();
+
+  MxHashTable<MxVariable>::Add(var);
 }
 
 // OFFSET: LEGO1 0x100b78f0
-const char *MxVariableTable::GetVariable(const char *key)
+const char *MxVariableTable::GetVariable(const char *p_key)
 {
-  // TODO
-  return 0;
+  const char *value = "";
+  MxHashTableCursor<MxVariable> cursor(this);
+  MxVariable *var = new MxVariable(p_key);
+  
+  MxBool found = cursor.Find(var);
+  delete var;
+  
+  if (found) {
+    cursor.GetMatch(var);
+    value = var->GetValue()->GetData();
+  }
+
+  return value;
 }
diff --git a/LEGO1/mxvariabletable.h b/LEGO1/mxvariabletable.h
index 13c70658..b9ecf174 100644
--- a/LEGO1/mxvariabletable.h
+++ b/LEGO1/mxvariabletable.h
@@ -1,16 +1,28 @@
 #ifndef MXVARIABLETABLE_H
 #define MXVARIABLETABLE_H
 
-class MxVariable;
+#include "mxtypes.h"
+#include "mxhashtable.h"
+#include "mxvariable.h"
+
 
 // VTABLE 0x100dc1c8
 // SIZE 0x28
-class MxVariableTable
+class MxVariableTable : public MxHashTable<MxVariable>
 {
 public:
-  __declspec(dllexport) const char * GetVariable(const char *key);
-  __declspec(dllexport) void SetVariable(MxVariable *var);
+  MxVariableTable() {
+    m_customDestructor = Destroy;
+  }
   __declspec(dllexport) void SetVariable(const char *key, const char *value);
+  __declspec(dllexport) void SetVariable(MxVariable *var);
+  __declspec(dllexport) const char * GetVariable(const char *key);
+
+  // OFFSET: LEGO1 0x100afdb0
+  static void Destroy(MxVariable *p_obj) { p_obj->Destroy(); }
+
+  virtual MxS8 Compare(MxVariable *, MxVariable *); // +0x14
+  virtual MxU32 Hash(MxVariable *); // +0x18
 };
 
 #endif // MXVARIABLETABLE_H

From c48fc69cf37d117ddcbc770bd6823fea23070e5e Mon Sep 17 00:00:00 2001
From: Christian Semmler <mail@csemmler.com>
Date: Sun, 6 Aug 2023 13:39:22 -0400
Subject: [PATCH 14/21] Implement/match MxDSAction constructor (#101)

* Implement MxDSAction constructor

* Update mxdsaction.cpp
---
 LEGO1/mxdsaction.cpp | 33 ++++++++++++++++++++++++++++++---
 LEGO1/mxdsaction.h   | 37 +++++++++++++------------------------
 LEGO1/mxvector.cpp   |  6 ------
 LEGO1/mxvector.h     |  6 ++++--
 4 files changed, 47 insertions(+), 35 deletions(-)

diff --git a/LEGO1/mxdsaction.cpp b/LEGO1/mxdsaction.cpp
index b5cf6e75..d6e1fdb5 100644
--- a/LEGO1/mxdsaction.cpp
+++ b/LEGO1/mxdsaction.cpp
@@ -1,16 +1,43 @@
 #include "mxdsaction.h"
 
+#include <float.h>
+#include <limits.h>
+
 // OFFSET: LEGO1 0x100ad810
 MxDSAction::MxDSAction()
 {
-  // TODO
+  this->m_flags = 32;
+  this->m_startTime = INT_MIN;
+  this->m_unk7c = NULL;
+  this->m_unk80 = 0;
+  this->m_duration = INT_MIN;
+  this->m_loopCount = -1;
+
   this->SetType(MxDSType_Action);
+
+  {
+    float value = FLT_MAX;
+    this->m_location.EqualsScalar(&value);
+  }
+
+  {
+    float value = FLT_MAX;
+    this->m_direction.EqualsScalar(&value);
+  }
+
+  {
+    float value = FLT_MAX;
+    this->m_up.EqualsScalar(&value);
+  }
+
+  this->m_unk84 = 0;
+  this->m_unk88 = 0;
   this->m_omni = NULL;
-  this->m_someTimingField = -0x80000000;
+  this->m_someTimingField = INT_MIN;
 }
 
 // OFFSET: LEGO1 0x100ada80
 MxDSAction::~MxDSAction()
 {
   delete this->m_unk7c;
-}
\ No newline at end of file
+}
diff --git a/LEGO1/mxdsaction.h b/LEGO1/mxdsaction.h
index 155d7cc2..10a14365 100644
--- a/LEGO1/mxdsaction.h
+++ b/LEGO1/mxdsaction.h
@@ -2,6 +2,7 @@
 #define MXDSACTION_H
 
 #include "mxdsobject.h"
+#include "mxvector.h"
 #include "mxomni.h"
 
 // VTABLE 0x100dc098
@@ -25,30 +26,18 @@ class MxDSAction : public MxDSObject
     return !strcmp(name, MxDSAction::ClassName()) || MxDSObject::IsA(name);
   }
 private:
-  MxLong m_unk2c;
-  MxLong m_unk30;
-  MxLong m_unk34;
-  MxLong* m_unk38;
-  MxLong m_unk3c;
-  MxLong m_unk40;
-  MxLong m_unk44;
-  MxLong m_unk48;
-  MxLong m_unk4c;
-  MxLong m_unk50;
-  MxLong m_unk54;
-  MxLong m_unk58;
-  MxLong m_unk5c;
-  MxLong m_unk60;
-  MxLong m_unk64;
-  MxLong m_unk68;
-  MxLong m_unk6c;
-  MxLong m_unk70;
-  MxLong m_unk74;
-  MxLong m_unk78;
-  MxLong* m_unk7c;
-  MxLong m_unk80;
-  MxLong m_unk84;
-  MxLong m_unk88;
+  undefined4 m_unk2c;
+  DWORD m_flags;
+  DWORD m_startTime;
+  LONG m_duration;
+  MxS32 m_loopCount;
+  MxVector3Data m_location;
+  MxVector3Data m_direction;
+  MxVector3Data m_up;
+  undefined4 *m_unk7c;
+  undefined2 m_unk80;
+  undefined4 m_unk84;
+  undefined4 m_unk88;
   MxOmni* m_omni; // 0x8c
   MxS32 m_someTimingField; // 0x90
 };
diff --git a/LEGO1/mxvector.cpp b/LEGO1/mxvector.cpp
index 80ca1a17..a4053105 100644
--- a/LEGO1/mxvector.cpp
+++ b/LEGO1/mxvector.cpp
@@ -12,12 +12,6 @@ DECOMP_SIZE_ASSERT(MxVector4, 0x8);
 DECOMP_SIZE_ASSERT(MxVector3Data, 0x14);
 DECOMP_SIZE_ASSERT(MxVector4Data, 0x18);
 
-// OFFSET: LEGO1 0x10002060
-void MxVector2::SetData(float *p_data)
-{
-  m_data = p_data;
-}
-
 // OFFSET: LEGO1 0x100020a0
 const float *MxVector2::GetData() const
 {
diff --git a/LEGO1/mxvector.h b/LEGO1/mxvector.h
index 0b766348..f5b8e686 100644
--- a/LEGO1/mxvector.h
+++ b/LEGO1/mxvector.h
@@ -9,7 +9,7 @@ class MxVector2
 {
 public:
   // OFFSET: LEGO1 0x1000c0f0
-  inline MxVector2(float* p_data) : m_data(p_data) {}
+  inline MxVector2(float* p_data) { this->SetData(p_data); }
 
   // vtable + 0x00 (no virtual destructor)
   virtual void AddScalarImpl(float p_value) = 0;
@@ -21,7 +21,9 @@ class MxVector2
   virtual void MullVectorImpl(float *p_value) = 0;
   virtual void DivScalarImpl(float *p_value) = 0;
   virtual float DotImpl(float *p_a, float *p_b) const = 0;
-  virtual void SetData(float *p_data);
+
+  // OFFSET: LEGO1 0x10002060
+  virtual void SetData(float *p_data) { this->m_data = p_data; }
 
   // vtable + 0x20
   virtual void EqualsImpl(float *p_data) = 0;

From 67816d52133354210430447ecfa02989b2dc38a8 Mon Sep 17 00:00:00 2001
From: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date: Sun, 6 Aug 2023 10:52:37 -0700
Subject: [PATCH 15/21] disable "nonstandard extension used 'bool'" warning
 spam

In newer versions of MSVC, this could have been achieved with /wd4237, however 4.2 doesn't have this option, it only seems to have the pragma. Ah well.
---
 LEGO1/compat.h | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/LEGO1/compat.h b/LEGO1/compat.h
index 6248259b..c682dc0e 100644
--- a/LEGO1/compat.h
+++ b/LEGO1/compat.h
@@ -11,6 +11,9 @@
 #define COMPAT_CONST
 #endif
 
+// DIsable "nonstandard extension used : 'bool'" warning spam
+#pragma warning( disable : 4237 )
+
 #define MSVC420_VERSION 1020
 
 // STL compatibility.

From b59d8ef5cfbb90720f64e029cef8fc090f56beb0 Mon Sep 17 00:00:00 2001
From: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date: Sun, 6 Aug 2023 12:47:16 -0700
Subject: [PATCH 16/21] include directx 5 sdk

This is almost certainly abandonware, fairly small (<1MB), and is going to save us a lot of dev environment headaches
---
 .github/workflows/build.yml   |   28 -
 3rdparty/dx5/inc/d3d.h        |  896 ++++++++
 3rdparty/dx5/inc/d3dcaps.h    |  313 +++
 3rdparty/dx5/inc/d3drm.h      |  229 ++
 3rdparty/dx5/inc/d3drmdef.h   |  472 ++++
 3rdparty/dx5/inc/d3drmobj.h   | 1100 ++++++++++
 3rdparty/dx5/inc/d3drmwin.h   |   48 +
 3rdparty/dx5/inc/d3dtypes.h   | 1201 +++++++++++
 3rdparty/dx5/inc/d3dvec.inl   |  240 +++
 3rdparty/dx5/inc/ddraw.h      | 3791 +++++++++++++++++++++++++++++++++
 3rdparty/dx5/inc/dinput.h     | 1849 ++++++++++++++++
 3rdparty/dx5/inc/dplay.h      | 1710 +++++++++++++++
 3rdparty/dx5/inc/dplobby.h    |  627 ++++++
 3rdparty/dx5/inc/dsetup.h     |  267 +++
 3rdparty/dx5/inc/dsound.h     |  863 ++++++++
 3rdparty/dx5/inc/dvp.h        |  831 ++++++++
 3rdparty/dx5/inc/fastfile.h   |   24 +
 3rdparty/dx5/lib/d3drm.lib    |  Bin 0 -> 15804 bytes
 3rdparty/dx5/lib/ddraw.lbw    |  Bin 0 -> 1024 bytes
 3rdparty/dx5/lib/ddraw.lib    |  Bin 0 -> 15336 bytes
 3rdparty/dx5/lib/dinput.lib   |  Bin 0 -> 15336 bytes
 3rdparty/dx5/lib/dplayx.lib   |  Bin 0 -> 5328 bytes
 3rdparty/dx5/lib/dsetup.lib   |  Bin 0 -> 9534 bytes
 3rdparty/dx5/lib/dsound.lbw   |  Bin 0 -> 1024 bytes
 3rdparty/dx5/lib/dsound.lib   |  Bin 0 -> 5646 bytes
 3rdparty/dx5/lib/dxguid.lib   |  Bin 0 -> 56332 bytes
 3rdparty/dx5/lib/fastfile.lbw |  Bin 0 -> 6144 bytes
 3rdparty/dx5/lib/fastfile.lib |  Bin 0 -> 5270 bytes
 CMakeLists.txt                |   13 +
 README.md                     |    4 +-
 dx5sdk/cdrom/setup.iss        |   34 -
 31 files changed, 14476 insertions(+), 64 deletions(-)
 create mode 100644 3rdparty/dx5/inc/d3d.h
 create mode 100644 3rdparty/dx5/inc/d3dcaps.h
 create mode 100644 3rdparty/dx5/inc/d3drm.h
 create mode 100644 3rdparty/dx5/inc/d3drmdef.h
 create mode 100644 3rdparty/dx5/inc/d3drmobj.h
 create mode 100644 3rdparty/dx5/inc/d3drmwin.h
 create mode 100644 3rdparty/dx5/inc/d3dtypes.h
 create mode 100644 3rdparty/dx5/inc/d3dvec.inl
 create mode 100644 3rdparty/dx5/inc/ddraw.h
 create mode 100644 3rdparty/dx5/inc/dinput.h
 create mode 100644 3rdparty/dx5/inc/dplay.h
 create mode 100644 3rdparty/dx5/inc/dplobby.h
 create mode 100644 3rdparty/dx5/inc/dsetup.h
 create mode 100644 3rdparty/dx5/inc/dsound.h
 create mode 100644 3rdparty/dx5/inc/dvp.h
 create mode 100644 3rdparty/dx5/inc/fastfile.h
 create mode 100644 3rdparty/dx5/lib/d3drm.lib
 create mode 100644 3rdparty/dx5/lib/ddraw.lbw
 create mode 100644 3rdparty/dx5/lib/ddraw.lib
 create mode 100644 3rdparty/dx5/lib/dinput.lib
 create mode 100644 3rdparty/dx5/lib/dplayx.lib
 create mode 100644 3rdparty/dx5/lib/dsetup.lib
 create mode 100644 3rdparty/dx5/lib/dsound.lbw
 create mode 100644 3rdparty/dx5/lib/dsound.lib
 create mode 100644 3rdparty/dx5/lib/dxguid.lib
 create mode 100644 3rdparty/dx5/lib/fastfile.lbw
 create mode 100644 3rdparty/dx5/lib/fastfile.lib
 delete mode 100644 dx5sdk/cdrom/setup.iss

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index c846a9f9..1ac80152 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -14,34 +14,6 @@ jobs:
         repository: 'itsmattkc/msvc420'
         path: msvc420
 
-    - name: Restore cached DX5 SDK
-      id: cache-dx5
-      uses: actions/cache/restore@v3
-      with:
-        path: dx5sdk
-        key: dx5sdk
-
-    - name: Download DX5 SDK
-      if: ${{ !steps.cache-dx5.outputs.cache-hit }}
-      run: |
-        cd dx5sdk
-        curl -fLOSs https://archive.org/download/idx5sdk/idx5sdk.exe
-        7z x .\idx5sdk.exe
-        7z x .\DX5SDK.EXE
-
-    - name: Cache DX5 SDK
-      if: ${{ !steps.cache-dx5.outputs.cache-hit }}
-      uses: actions/cache/save@v3
-      with:
-        path: dx5sdk
-        key: dx5sdk
-
-    - name: Setup DX5 SDK
-      run: |
-        cd dx5sdk
-        cd cdrom
-        .\SETUP.EXE /s
-
     - name: Setup cmake
       uses: jwlawson/actions-setup-cmake@v1.13
       with:
diff --git a/3rdparty/dx5/inc/d3d.h b/3rdparty/dx5/inc/d3d.h
new file mode 100644
index 00000000..b50fe404
--- /dev/null
+++ b/3rdparty/dx5/inc/d3d.h
@@ -0,0 +1,896 @@
+/*==========================================================================;
+ *
+ *  Copyright (C) 1995-1997 Microsoft Corporation.  All Rights Reserved.
+ *
+ *  File:	d3d.h
+ *  Content:	Direct3D include file
+ *
+ ***************************************************************************/
+
+#ifndef _D3D_H_
+#define _D3D_H_
+
+#include <stdlib.h>
+
+#ifdef _WIN32
+#define COM_NO_WINDOWS_H
+#include <objbase.h>
+#else
+#include "d3dcom.h"
+#endif
+
+#ifdef _WIN32
+#define D3DAPI WINAPI
+#else
+#define D3DAPI
+#endif
+
+/*
+ * Interface IID's
+ */
+#if defined( _WIN32 ) && !defined( _NO_COM)
+DEFINE_GUID( IID_IDirect3D,             0x3BBA0080,0x2421,0x11CF,0xA3,0x1A,0x00,0xAA,0x00,0xB9,0x33,0x56 );
+DEFINE_GUID( IID_IDirect3D2,            0x6aae1ec1,0x662a,0x11d0,0x88,0x9d,0x00,0xaa,0x00,0xbb,0xb7,0x6a);
+
+DEFINE_GUID( IID_IDirect3DRampDevice,   0xF2086B20,0x259F,0x11CF,0xA3,0x1A,0x00,0xAA,0x00,0xB9,0x33,0x56 );
+DEFINE_GUID( IID_IDirect3DRGBDevice,    0xA4665C60,0x2673,0x11CF,0xA3,0x1A,0x00,0xAA,0x00,0xB9,0x33,0x56 );
+DEFINE_GUID( IID_IDirect3DHALDevice,    0x84E63dE0,0x46AA,0x11CF,0x81,0x6F,0x00,0x00,0xC0,0x20,0x15,0x6E );
+DEFINE_GUID( IID_IDirect3DMMXDevice,    0x881949a1,0xd6f3,0x11d0,0x89,0xab,0x00,0xa0,0xc9,0x05,0x41,0x29 );
+
+DEFINE_GUID( IID_IDirect3DDevice,		0x64108800,0x957d,0X11d0,0x89,0xab,0x00,0xa0,0xc9,0x05,0x41,0x29 );
+DEFINE_GUID( IID_IDirect3DDevice2,	0x93281501, 0x8cf8, 0x11d0, 0x89, 0xab, 0x0, 0xa0, 0xc9, 0x5, 0x41, 0x29);
+DEFINE_GUID( IID_IDirect3DTexture,      0x2CDCD9E0,0x25A0,0x11CF,0xA3,0x1A,0x00,0xAA,0x00,0xB9,0x33,0x56 );
+DEFINE_GUID( IID_IDirect3DTexture2,	0x93281502, 0x8cf8, 0x11d0, 0x89, 0xab, 0x0, 0xa0, 0xc9, 0x5, 0x41, 0x29);
+DEFINE_GUID( IID_IDirect3DLight,        0x4417C142,0x33AD,0x11CF,0x81,0x6F,0x00,0x00,0xC0,0x20,0x15,0x6E );
+DEFINE_GUID( IID_IDirect3DMaterial,     0x4417C144,0x33AD,0x11CF,0x81,0x6F,0x00,0x00,0xC0,0x20,0x15,0x6E );
+DEFINE_GUID( IID_IDirect3DMaterial2,	0x93281503, 0x8cf8, 0x11d0, 0x89, 0xab, 0x0, 0xa0, 0xc9, 0x5, 0x41, 0x29);
+DEFINE_GUID( IID_IDirect3DExecuteBuffer,0x4417C145,0x33AD,0x11CF,0x81,0x6F,0x00,0x00,0xC0,0x20,0x15,0x6E );
+DEFINE_GUID( IID_IDirect3DViewport,     0x4417C146,0x33AD,0x11CF,0x81,0x6F,0x00,0x00,0xC0,0x20,0x15,0x6E );
+DEFINE_GUID( IID_IDirect3DViewport2,	0x93281500, 0x8cf8, 0x11d0, 0x89, 0xab, 0x0, 0xa0, 0xc9, 0x5, 0x41, 0x29);
+#endif
+
+/*
+ * Data structures
+ */
+#ifdef __cplusplus
+
+/* 'struct' not 'class' per the way DECLARE_INTERFACE_ is defined */
+struct IDirect3D;
+struct IDirect3D2;
+struct IDirect3DDevice;
+struct IDirect3DDevice2;
+struct IDirect3DExecuteBuffer;
+struct IDirect3DLight;
+struct IDirect3DMaterial;
+struct IDirect3DMaterial2;
+struct IDirect3DTexture;
+struct IDirect3DTexture2;
+struct IDirect3DViewport;
+struct IDirect3DViewport2;
+typedef struct IDirect3D		*LPDIRECT3D;
+typedef struct IDirect3D2		*LPDIRECT3D2;
+typedef struct IDirect3DDevice		*LPDIRECT3DDEVICE;
+typedef struct IDirect3DDevice2		*LPDIRECT3DDEVICE2;
+typedef struct IDirect3DExecuteBuffer	*LPDIRECT3DEXECUTEBUFFER;
+typedef struct IDirect3DLight		*LPDIRECT3DLIGHT;
+typedef struct IDirect3DMaterial	*LPDIRECT3DMATERIAL;
+typedef struct IDirect3DMaterial2	*LPDIRECT3DMATERIAL2;
+typedef struct IDirect3DTexture		*LPDIRECT3DTEXTURE;
+typedef struct IDirect3DTexture2		*LPDIRECT3DTEXTURE2;
+typedef struct IDirect3DViewport	*LPDIRECT3DVIEWPORT;
+typedef struct IDirect3DViewport2	*LPDIRECT3DVIEWPORT2;
+
+#else
+
+typedef struct IDirect3D		*LPDIRECT3D;
+typedef struct IDirect3D2       *LPDIRECT3D2;
+typedef struct IDirect3DDevice		*LPDIRECT3DDEVICE;
+typedef struct IDirect3DDevice2		*LPDIRECT3DDEVICE2;
+typedef struct IDirect3DExecuteBuffer	*LPDIRECT3DEXECUTEBUFFER;
+typedef struct IDirect3DLight		*LPDIRECT3DLIGHT;
+typedef struct IDirect3DMaterial	*LPDIRECT3DMATERIAL;
+typedef struct IDirect3DMaterial2	*LPDIRECT3DMATERIAL2;
+typedef struct IDirect3DTexture		*LPDIRECT3DTEXTURE;
+typedef struct IDirect3DTexture2		*LPDIRECT3DTEXTURE2;
+typedef struct IDirect3DViewport	*LPDIRECT3DVIEWPORT;
+typedef struct IDirect3DViewport2	*LPDIRECT3DVIEWPORT2;
+
+#endif
+
+#include "d3dtypes.h"
+#include "d3dcaps.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * IDirect3D
+ */
+#undef INTERFACE
+#define INTERFACE IDirect3D
+DECLARE_INTERFACE_(IDirect3D, IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID* ppvObj) PURE;
+    STDMETHOD_(ULONG, AddRef) (THIS) PURE;
+    STDMETHOD_(ULONG, Release) (THIS) PURE;
+    /*** IDirect3D methods ***/
+    STDMETHOD(Initialize) (THIS_ REFIID) PURE;
+    STDMETHOD(EnumDevices)(THIS_ LPD3DENUMDEVICESCALLBACK, LPVOID) PURE;
+    STDMETHOD(CreateLight) (THIS_ LPDIRECT3DLIGHT*, IUnknown*) PURE;
+    STDMETHOD(CreateMaterial) (THIS_ LPDIRECT3DMATERIAL*, IUnknown*) PURE;
+    STDMETHOD(CreateViewport) (THIS_ LPDIRECT3DVIEWPORT*, IUnknown*) PURE;
+    STDMETHOD(FindDevice)(THIS_ LPD3DFINDDEVICESEARCH, LPD3DFINDDEVICERESULT) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirect3D_QueryInterface(p, a, b)         (p)->lpVtbl->QueryInterface(p, a, b)
+#define IDirect3D_AddRef(p)                       (p)->lpVtbl->AddRef(p)
+#define IDirect3D_Release(p)                      (p)->lpVtbl->Release(p)
+#define IDirect3D_Initialize(p, a)                (p)->lpVtbl->Initialize(p, a)
+#define IDirect3D_EnumDevices(p, a, b)            (p)->lpVtbl->EnumDevices(p, a, b)
+#define IDirect3D_CreateLight(p, a, b)            (p)->lpVtbl->CreateLight(p, a, b)
+#define IDirect3D_CreateMaterial(p, a, b)         (p)->lpVtbl->CreateMaterial(p, a, b)
+#define IDirect3D_CreateViewport(p, a, b)         (p)->lpVtbl->CreateViewport(p, a, b)
+#define IDirect3D_FindDevice(p, a, b)             (p)->lpVtbl->FindDevice(p, a, b)
+#else
+#define IDirect3D_QueryInterface(p, a, b)         (p)->QueryInterface(a, b)
+#define IDirect3D_AddRef(p)                       (p)->AddRef()
+#define IDirect3D_Release(p)                      (p)->Release()
+#define IDirect3D_Initialize(p, a)                (p)->Initialize(a)
+#define IDirect3D_EnumDevices(p, a, b)            (p)->EnumDevices(a, b)
+#define IDirect3D_CreateLight(p, a, b)            (p)->CreateLight(a, b)
+#define IDirect3D_CreateMaterial(p, a, b)         (p)->CreateMaterial(a, b)
+#define IDirect3D_CreateViewport(p, a, b)         (p)->CreateViewport(a, b)
+#define IDirect3D_FindDevice(p, a, b)             (p)->FindDevice(a, b)
+#endif
+
+/*
+ * IDirect3D2
+ */
+#undef INTERFACE
+#define INTERFACE IDirect3D2
+DECLARE_INTERFACE_(IDirect3D2, IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID* ppvObj) PURE;
+    STDMETHOD_(ULONG, AddRef) (THIS) PURE;
+    STDMETHOD_(ULONG, Release) (THIS) PURE;
+    /*** IDirect3D methods ***/
+    STDMETHOD(EnumDevices)(THIS_ LPD3DENUMDEVICESCALLBACK, LPVOID) PURE;
+    STDMETHOD(CreateLight) (THIS_ LPDIRECT3DLIGHT*, IUnknown*) PURE;
+    STDMETHOD(CreateMaterial) (THIS_ LPDIRECT3DMATERIAL2*, IUnknown*) PURE;
+    STDMETHOD(CreateViewport) (THIS_ LPDIRECT3DVIEWPORT2*, IUnknown*) PURE;
+    STDMETHOD(FindDevice)(THIS_ LPD3DFINDDEVICESEARCH, LPD3DFINDDEVICERESULT) PURE;
+
+    STDMETHOD(CreateDevice)(THIS_ REFCLSID, LPDIRECTDRAWSURFACE, LPDIRECT3DDEVICE2 *) PURE;
+ 
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirect3D2_QueryInterface(p, a, b)         (p)->lpVtbl->QueryInterface(p, a, b)
+#define IDirect3D2_AddRef(p)                       (p)->lpVtbl->AddRef(p)
+#define IDirect3D2_Release(p)                      (p)->lpVtbl->Release(p)
+#define IDirect3D2_EnumDevices(p, a, b)            (p)->lpVtbl->EnumDevices(p, a, b)
+#define IDirect3D2_CreateLight(p, a, b)            (p)->lpVtbl->CreateLight(p, a, b)
+#define IDirect3D2_CreateMaterial(p, a, b)         (p)->lpVtbl->CreateMaterial(p, a, b)
+#define IDirect3D2_CreateViewport(p, a, b)         (p)->lpVtbl->CreateViewport(p, a, b)
+#define IDirect3D2_FindDevice(p, a, b)             (p)->lpVtbl->FindDevice(p, a, b)
+#define IDirect3D2_CreateDevice(p, a, b, c)		   (p)->lpVtbl->CreateDevice(p, a, b, c)
+#else
+#define IDirect3D2_QueryInterface(p, a, b)         (p)->QueryInterface(a, b)
+#define IDirect3D2_AddRef(p)                       (p)->AddRef()
+#define IDirect3D2_Release(p)                      (p)->Release()
+#define IDirect3D2_EnumDevices(p, a, b)            (p)->EnumDevices(a, b)
+#define IDirect3D2_CreateLight(p, a, b)            (p)->CreateLight(a, b)
+#define IDirect3D2_CreateMaterial(p, a, b)         (p)->CreateMaterial(a, b)
+#define IDirect3D2_CreateViewport(p, a, b)         (p)->CreateViewport(a, b)
+#define IDirect3D2_FindDevice(p, a, b)             (p)->FindDevice(a, b)
+#define IDirect3D2_CreateDevice(p, a, b, c)        (p)->CreateDevice(a, b, c)
+#endif
+
+/*
+ * IDirect3DDevice
+ */
+#undef INTERFACE
+#define INTERFACE IDirect3DDevice
+DECLARE_INTERFACE_(IDirect3DDevice, IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID* ppvObj) PURE;
+    STDMETHOD_(ULONG, AddRef) (THIS) PURE;
+    STDMETHOD_(ULONG, Release) (THIS) PURE;
+    /*** IDirect3DDevice methods ***/
+    STDMETHOD(Initialize) (THIS_ LPDIRECT3D, LPGUID, LPD3DDEVICEDESC) PURE;
+    STDMETHOD(GetCaps) (THIS_ LPD3DDEVICEDESC, LPD3DDEVICEDESC) PURE;
+    STDMETHOD(SwapTextureHandles) (THIS_ LPDIRECT3DTEXTURE, LPDIRECT3DTEXTURE) PURE;
+    STDMETHOD(CreateExecuteBuffer) (THIS_ LPD3DEXECUTEBUFFERDESC, LPDIRECT3DEXECUTEBUFFER*, IUnknown*) PURE;
+    STDMETHOD(GetStats) (THIS_ LPD3DSTATS) PURE;
+    STDMETHOD(Execute) (THIS_ LPDIRECT3DEXECUTEBUFFER, LPDIRECT3DVIEWPORT, DWORD) PURE;
+    STDMETHOD(AddViewport) (THIS_ LPDIRECT3DVIEWPORT) PURE;
+    STDMETHOD(DeleteViewport) (THIS_ LPDIRECT3DVIEWPORT) PURE;
+    STDMETHOD(NextViewport) (THIS_ LPDIRECT3DVIEWPORT, LPDIRECT3DVIEWPORT*, DWORD) PURE;
+    STDMETHOD(Pick) (THIS_ LPDIRECT3DEXECUTEBUFFER, LPDIRECT3DVIEWPORT, DWORD, LPD3DRECT) PURE;
+    STDMETHOD(GetPickRecords)(THIS_ LPDWORD, LPD3DPICKRECORD) PURE;
+    STDMETHOD(EnumTextureFormats) (THIS_ LPD3DENUMTEXTUREFORMATSCALLBACK, LPVOID) PURE;
+    STDMETHOD(CreateMatrix) (THIS_ LPD3DMATRIXHANDLE) PURE;
+    STDMETHOD(SetMatrix) (THIS_ D3DMATRIXHANDLE, const LPD3DMATRIX) PURE;
+    STDMETHOD(GetMatrix) (THIS_ D3DMATRIXHANDLE, LPD3DMATRIX) PURE;
+    STDMETHOD(DeleteMatrix) (THIS_ D3DMATRIXHANDLE) PURE;
+    STDMETHOD_(HRESULT, BeginScene) (THIS) PURE;
+    STDMETHOD_(HRESULT, EndScene) (THIS) PURE;
+    STDMETHOD(GetDirect3D) (THIS_ LPDIRECT3D*) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirect3DDevice_QueryInterface(p, a, b)         (p)->lpVtbl->QueryInterface(p, a, b)
+#define IDirect3DDevice_AddRef(p)                       (p)->lpVtbl->AddRef(p)
+#define IDirect3DDevice_Release(p)                      (p)->lpVtbl->Release(p)
+#define IDirect3DDevice_Initialize(p, a, b, c)          (p)->lpVtbl->Initialize(p, a, b, c)
+#define IDirect3DDevice_GetCaps(p, a, b)                (p)->lpVtbl->GetCaps(p, a, b)
+#define IDirect3DDevice_SwapTextureHandles(p, a, b)     (p)->lpVtbl->SwapTextureHandles(p, a, b)
+#define IDirect3DDevice_CreateExecuteBuffer(p, a, b, c) (p)->lpVtbl->CreateExecuteBuffer(p, a, b, c)
+#define IDirect3DDevice_GetStats(p, a)                  (p)->lpVtbl->GetStats(p, a)
+#define IDirect3DDevice_Execute(p, a, b, c)             (p)->lpVtbl->Execute(p, a, b, c)
+#define IDirect3DDevice_AddViewport(p, a)               (p)->lpVtbl->AddViewport(p, a)
+#define IDirect3DDevice_DeleteViewport(p, a)            (p)->lpVtbl->DeleteViewport(p, a)
+#define IDirect3DDevice_NextViewport(p, a, b)           (p)->lpVtbl->NextViewport(p, a, b)
+#define IDirect3DDevice_Pick(p, a, b, c, d)             (p)->lpVtbl->Pick(p, a, b, c, d)
+#define IDirect3DDevice_GetPickRecords(p, a, b)         (p)->lpVtbl->GetPickRecords(p, a, b)
+#define IDirect3DDevice_EnumTextureFormats(p, a, b)     (p)->lpVtbl->EnumTextureFormats(p, a, b)
+#define IDirect3DDevice_CreateMatrix(p, a)              (p)->lpVtbl->CreateMatrix(p, a)
+#define IDirect3DDevice_SetMatrix(p, a, b)              (p)->lpVtbl->SetMatrix(p, a, b)
+#define IDirect3DDevice_GetMatrix(p, a, b)              (p)->lpVtbl->GetMatrix(p, a, b)
+#define IDirect3DDevice_DeleteMatrix(p, a)              (p)->lpVtbl->DeleteMatrix(p, a)
+#define IDirect3DDevice_BeginScene(p)                   (p)->lpVtbl->BeginScene(p)
+#define IDirect3DDevice_EndScene(p)                     (p)->lpVtbl->EndScene(p)
+#define IDirect3DDevice_GetDirect3D(p, a)               (p)->lpVtbl->GetDirect3D(p, a)
+#else
+#define IDirect3DDevice_QueryInterface(p, a, b)         (p)->QueryInterface(a, b)
+#define IDirect3DDevice_AddRef(p)                       (p)->AddRef()
+#define IDirect3DDevice_Release(p)                      (p)->Release()
+#define IDirect3DDevice_Initialize(p, a, b, c)          (p)->Initialize(a, b, c)
+#define IDirect3DDevice_GetCaps(p, a, b)                (p)->GetCaps(a, b)
+#define IDirect3DDevice_SwapTextureHandles(p, a, b)     (p)->SwapTextureHandles(a, b)
+#define IDirect3DDevice_CreateExecuteBuffer(p, a, b, c) (p)->CreateExecuteBuffer(a, b, c)
+#define IDirect3DDevice_GetStats(p, a)                  (p)->GetStats(a)
+#define IDirect3DDevice_Execute(p, a, b, c)             (p)->Execute(a, b, c)
+#define IDirect3DDevice_AddViewport(p, a)               (p)->AddViewport(a)
+#define IDirect3DDevice_DeleteViewport(p, a)            (p)->DeleteViewport(a)
+#define IDirect3DDevice_NextViewport(p, a, b)           (p)->NextViewport(a, b)
+#define IDirect3DDevice_Pick(p, a, b, c, d)             (p)->Pick(a, b, c, d)
+#define IDirect3DDevice_GetPickRecords(p, a, b)         (p)->GetPickRecords(a, b)
+#define IDirect3DDevice_EnumTextureFormats(p, a, b)     (p)->EnumTextureFormats(a, b)
+#define IDirect3DDevice_CreateMatrix(p, a)              (p)->CreateMatrix(a)
+#define IDirect3DDevice_SetMatrix(p, a, b)              (p)->SetMatrix(a, b)
+#define IDirect3DDevice_GetMatrix(p, a, b)              (p)->GetMatrix(a, b)
+#define IDirect3DDevice_DeleteMatrix(p, a)              (p)->DeleteMatrix(a)
+#define IDirect3DDevice_BeginScene(p)                   (p)->BeginScene()
+#define IDirect3DDevice_EndScene(p)                     (p)->EndScene()
+#define IDirect3DDevice_GetDirect3D(p, a)               (p)->GetDirect3D(a)
+#endif
+
+/*
+ * IDirect3DDevice2
+ */
+#undef INTERFACE
+#define INTERFACE IDirect3DDevice2
+DECLARE_INTERFACE_(IDirect3DDevice2, IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID* ppvObj) PURE;
+    STDMETHOD_(ULONG, AddRef) (THIS) PURE;
+    STDMETHOD_(ULONG, Release) (THIS) PURE;
+    /*** IDirect3DDevice2 methods ***/
+    STDMETHOD(GetCaps) (THIS_ LPD3DDEVICEDESC, LPD3DDEVICEDESC) PURE;
+    STDMETHOD(SwapTextureHandles) (THIS_ LPDIRECT3DTEXTURE2, LPDIRECT3DTEXTURE2) PURE;
+    STDMETHOD(GetStats) (THIS_ LPD3DSTATS) PURE;
+    STDMETHOD(AddViewport) (THIS_ LPDIRECT3DVIEWPORT2) PURE;
+    STDMETHOD(DeleteViewport) (THIS_ LPDIRECT3DVIEWPORT2) PURE;
+    STDMETHOD(NextViewport) (THIS_ LPDIRECT3DVIEWPORT2, LPDIRECT3DVIEWPORT2*, DWORD) PURE;
+    STDMETHOD(EnumTextureFormats) (THIS_ LPD3DENUMTEXTUREFORMATSCALLBACK, LPVOID) PURE;
+    STDMETHOD_(HRESULT, BeginScene) (THIS) PURE;
+    STDMETHOD_(HRESULT, EndScene) (THIS) PURE;
+    STDMETHOD(GetDirect3D) (THIS_ LPDIRECT3D2*) PURE;
+
+    /*** DrawPrimitive API ***/
+    STDMETHOD(SetCurrentViewport) (THIS_ LPDIRECT3DVIEWPORT2) PURE;
+    STDMETHOD(GetCurrentViewport) (THIS_ LPDIRECT3DVIEWPORT2 *) PURE;
+
+    STDMETHOD(SetRenderTarget) (THIS_ LPDIRECTDRAWSURFACE, DWORD) PURE;
+    STDMETHOD(GetRenderTarget) (THIS_ LPDIRECTDRAWSURFACE *) PURE;
+
+    STDMETHOD(Begin) (THIS_ D3DPRIMITIVETYPE, D3DVERTEXTYPE, DWORD) PURE;
+    STDMETHOD(BeginIndexed) (THIS_ D3DPRIMITIVETYPE, D3DVERTEXTYPE, LPVOID, DWORD, DWORD) PURE;
+    STDMETHOD(Vertex) (THIS_ LPVOID) PURE;
+    STDMETHOD(Index) (THIS_ WORD) PURE;
+    STDMETHOD(End) (THIS_ DWORD) PURE;
+
+    STDMETHOD(GetRenderState) (THIS_ D3DRENDERSTATETYPE, LPDWORD) PURE;
+    STDMETHOD(SetRenderState) (THIS_ D3DRENDERSTATETYPE, DWORD) PURE;
+    STDMETHOD(GetLightState) (THIS_ D3DLIGHTSTATETYPE, LPDWORD) PURE;
+    STDMETHOD(SetLightState) (THIS_ D3DLIGHTSTATETYPE, DWORD) PURE;
+    STDMETHOD(SetTransform) (THIS_ D3DTRANSFORMSTATETYPE, LPD3DMATRIX) PURE;
+    STDMETHOD(GetTransform) (THIS_ D3DTRANSFORMSTATETYPE, LPD3DMATRIX) PURE;
+    STDMETHOD(MultiplyTransform) (THIS_ D3DTRANSFORMSTATETYPE, LPD3DMATRIX) PURE;
+
+    STDMETHOD(DrawPrimitive) (THIS_ D3DPRIMITIVETYPE, D3DVERTEXTYPE, LPVOID, DWORD, DWORD) PURE;
+    STDMETHOD(DrawIndexedPrimitive) (THIS_ D3DPRIMITIVETYPE, D3DVERTEXTYPE, LPVOID, DWORD, LPWORD, DWORD, DWORD) PURE;
+
+    STDMETHOD(SetClipStatus) (THIS_ LPD3DCLIPSTATUS) PURE;
+    STDMETHOD(GetClipStatus) (THIS_ LPD3DCLIPSTATUS) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirect3DDevice2_QueryInterface(p, a, b)         (p)->lpVtbl->QueryInterface(p, a, b)
+#define IDirect3DDevice2_AddRef(p)                       (p)->lpVtbl->AddRef(p)
+#define IDirect3DDevice2_Release(p)                      (p)->lpVtbl->Release(p)
+#define IDirect3DDevice2_GetCaps(p, a, b)                (p)->lpVtbl->GetCaps(p, a, b)
+#define IDirect3DDevice2_SwapTextureHandles(p, a, b)     (p)->lpVtbl->SwapTextureHandles(p, a, b)
+#define IDirect3DDevice2_GetStats(p, a)                  (p)->lpVtbl->CreateViewport(p, a)
+#define IDirect3DDevice2_AddViewport(p, a)               (p)->lpVtbl->AddViewport(p, a)
+#define IDirect3DDevice2_DeleteViewport(p, a)            (p)->lpVtbl->DeleteViewport(p, a)
+#define IDirect3DDevice2_NextViewport(p, a, b)           (p)->lpVtbl->NextViewport(p, a, b)
+#define IDirect3DDevice2_EnumTextureFormats(p, a, b)     (p)->lpVtbl->EnumTextureFormats(p, a, b)
+#define IDirect3DDevice2_BeginScene(p)                   (p)->lpVtbl->BeginScene(p)
+#define IDirect3DDevice2_EndScene(p)                     (p)->lpVtbl->EndScene(p)
+#define IDirect3DDevice2_GetDirect3D(p, a)               (p)->lpVtbl->GetDirect3D(p, a)
+
+#define IDirect3DDevice2_SetCurrentViewport(p, a)        (p)->lpVtbl->SetCurrentViewport(p, a)
+#define IDirect3DDevice2_GetCurrentViewport(p, a)        (p)->lpVtbl->GetCurrentViewport(p, a)
+
+#define IDirect3DDevice2_SetRenderTarget(p, a, b)        (p)->lpVtbl->SetRenderTarget(p, a, b)
+#define IDirect3DDevice2_GetRenderTarget(p, a)			 (p)->lpVtbl->GetRenderTarget(p, a)
+
+#define IDirect3DDevice2_Begin(p, a, b, c)               (p)->lpVtbl->Begin(p, a, b, c)
+#define IDirect3DDevice2_BeginIndexed(p, a, b, c, d, e)  (p)->lpVtbl->Begin(p, a, b, c, d, e)
+#define IDirect3DDevice2_Vertex(p, a)                    (p)->lpVtbl->Vertex(p, a)
+#define IDirect3DDevice2_Index(p, a)                     (p)->lpVtbl->Index(p, a)
+#define IDirect3DDevice2_End(p, a)                       (p)->lpVtbl->End(p, a)
+
+#define IDirect3DDevice2_GetRenderState(p, a, b)         (p)->lpVtbl->GetRenderState(p, a, b)
+#define IDirect3DDevice2_SetRenderState(p, a, b)         (p)->lpVtbl->SetRenderState(p, a, b)
+#define IDirect3DDevice2_GetLightState(p, a, b)          (p)->lpVtbl->GetLightState(p, a, b)
+#define IDirect3DDevice2_SetLightState(p, a, b)          (p)->lpVtbl->SetLightState(p, a, b)
+#define IDirect3DDevice2_SetTransform(p, a, b)           (p)->lpVtbl->SetTransform(p, a, b)
+#define IDirect3DDevice2_GetTransform(p, a, b)           (p)->lpVtbl->GetTransform(p, a, b)
+#define IDirect3DDevice2_MultiplyTransform(p, a, b)      (p)->lpVtbl->MultiplyTransform(p, a, b)
+
+#define IDirect3DDevice2_DrawPrimitive(p, a, b, c, d, e) (p)->lpVtbl->DrawPrimitive(p, a, b, c, d, e)
+#define IDirect3DDevice2_DrawIndexedPrimitive(p, a, b, c, d, e, f, g) \
+                                                         (p)->lpVtbl->DrawIndexedPrimitive(p, a, b, c, d, e, f, g)
+#define IDirect3DDevice2_SetClipStatus(p, a)				 (p)->lpVtbl->SetClipStatus(p, a)
+#define IDirect3DDevice2_GetClipStatus(p, a)				 (p)->lpVtbl->GetClipStatus(p, a)
+#else
+#define IDirect3DDevice2_QueryInterface(p, a, b)         (p)->QueryInterface(a, b)
+#define IDirect3DDevice2_AddRef(p)                       (p)->AddRef()
+#define IDirect3DDevice2_Release(p)                      (p)->Release()
+#define IDirect3DDevice2_GetCaps(p, a, b)                (p)->GetCaps(a, b)
+#define IDirect3DDevice2_SwapTextureHandles(p, a, b)     (p)->SwapTextureHandles(a, b)
+#define IDirect3DDevice2_GetStats(p, a)                  (p)->CreateViewport(a)
+#define IDirect3DDevice2_AddViewport(p, a)               (p)->AddViewport(a)
+#define IDirect3DDevice2_DeleteViewport(p, a)            (p)->DeleteViewport(a)
+#define IDirect3DDevice2_NextViewport(p, a, b)           (p)->NextViewport(a, b)
+#define IDirect3DDevice2_EnumTextureFormats(p, a, b)     (p)->EnumTextureFormats(a, b)
+#define IDirect3DDevice2_BeginScene(p)                   (p)->BeginScene()
+#define IDirect3DDevice2_EndScene(p)                     (p)->EndScene()
+#define IDirect3DDevice2_GetDirect3D(p, a)               (p)->GetDirect3D(a)
+
+#define IDirect3DDevice2_SetCurrentViewport(p, a)        (p)->SetCurrentViewport(a)
+#define IDirect3DDevice2_GetCurrentViewport(p, a)        (p)->GetCurrentViewport(a)
+
+#define IDirect3DDevice2_SetRenderTarget(p, a, b)        (p)->SetRenderTarget(a, b)
+#define IDirect3DDevice2_GetRenderTarget(p, a)           (p)->GetRenderTarget(a)
+
+#define IDirect3DDevice2_Begin(p, a, b, c)               (p)->Begin(a, b, c)
+#define IDirect3DDevice2_BeginIndexed(p, a, b, c, d, e)  (p)->Begin(a, b, c, d, e)
+#define IDirect3DDevice2_Vertex(p, a)                    (p)->Vertex(a)
+#define IDirect3DDevice2_Index(p, a)                     (p)->Index(a)
+#define IDirect3DDevice2_End(p, a)                       (p)->End(a)
+
+#define IDirect3DDevice2_GetRenderState(p, a, b)         (p)->GetRenderState(a, b)
+#define IDirect3DDevice2_SetRenderState(p, a, b)         (p)->SetRenderState(a, b)
+#define IDirect3DDevice2_GetLightState(p, a, b)          (p)->GetLightState(a, b)
+#define IDirect3DDevice2_SetLightState(p, a, b)          (p)->SetLightState(a, b)
+#define IDirect3DDevice2_SetTransform(p, a, b)           (p)->SetTransform(a, b)
+#define IDirect3DDevice2_GetTransform(p, a, b)           (p)->GetTransform(a, b)
+#define IDirect3DDevice2_MultiplyTransform(p, a, b)      (p)->MultiplyTransform(a, b)
+
+#define IDirect3DDevice2_DrawPrimitive(p, a, b, c, d, e) (p)->DrawPrimitive(a, b, c, d, e)
+#define IDirect3DDevice2_DrawIndexedPrimitive(p, a, b, c, d, e, f, g) \
+                                                         (p)->DrawIndexedPrimitive(a, b, c, d, e, f, g)
+#define IDirect3DDevice2_SetClipStatus(p, a)                             (p)->SetClipStatus(a)
+#define IDirect3DDevice2_GetClipStatus(p, a)                             (p)->GetClipStatus(a)
+
+#endif
+
+/*
+ * IDirect3DExecuteBuffer
+ */
+#undef INTERFACE
+#define INTERFACE IDirect3DExecuteBuffer
+DECLARE_INTERFACE_(IDirect3DExecuteBuffer, IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID* ppvObj) PURE;
+    STDMETHOD_(ULONG, AddRef) (THIS) PURE;
+    STDMETHOD_(ULONG, Release) (THIS) PURE;
+    /*** IDirect3DExecuteBuffer methods ***/
+    STDMETHOD(Initialize) (THIS_ LPDIRECT3DDEVICE, LPD3DEXECUTEBUFFERDESC) PURE;
+    STDMETHOD(Lock) (THIS_ LPD3DEXECUTEBUFFERDESC) PURE;
+    STDMETHOD_(HRESULT, Unlock) (THIS) PURE;
+    STDMETHOD(SetExecuteData) (THIS_ LPD3DEXECUTEDATA) PURE;
+    STDMETHOD(GetExecuteData) (THIS_ LPD3DEXECUTEDATA) PURE;
+    STDMETHOD(Validate) (THIS_ LPDWORD, LPD3DVALIDATECALLBACK, LPVOID, DWORD) PURE;
+    STDMETHOD(Optimize) (THIS_ DWORD) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirect3DExecuteBuffer_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b)
+#define IDirect3DExecuteBuffer_AddRef(p)               (p)->lpVtbl->AddRef(p)
+#define IDirect3DExecuteBuffer_Release(p)              (p)->lpVtbl->Release(p)
+#define IDirect3DExecuteBuffer_Initialize(p, a, b)     (p)->lpVtbl->Initialize(p, a, b)
+#define IDirect3DExecuteBuffer_Lock(p, a)              (p)->lpVtbl->Lock(p, a)
+#define IDirect3DExecuteBuffer_Unlock(p)               (p)->lpVtbl->Unlock(p)
+#define IDirect3DExecuteBuffer_SetExecuteData(p, a)    (p)->lpVtbl->SetExecuteData(p, a)
+#define IDirect3DExecuteBuffer_GetExecuteData(p, a)    (p)->lpVtbl->GetExecuteData(p, a)
+#define IDirect3DExecuteBuffer_Validate(p, a, b, c, d) (p)->lpVtbl->Validate(p, a, b, c, d)
+#define IDirect3DExecuteBuffer_Optimize(p, a)          (p)->lpVtbl->Optimize(p, a)
+#else
+#define IDirect3DExecuteBuffer_QueryInterface(p, a, b) (p)->QueryInterface(a, b)
+#define IDirect3DExecuteBuffer_AddRef(p)               (p)->AddRef()
+#define IDirect3DExecuteBuffer_Release(p)              (p)->Release()
+#define IDirect3DExecuteBuffer_Initialize(p, a, b)     (p)->Initialize(a, b)
+#define IDirect3DExecuteBuffer_Lock(p, a)              (p)->Lock(a)
+#define IDirect3DExecuteBuffer_Unlock(p)               (p)->Unlock()
+#define IDirect3DExecuteBuffer_SetExecuteData(p, a)    (p)->SetExecuteData(a)
+#define IDirect3DExecuteBuffer_GetExecuteData(p, a)    (p)->GetExecuteData(a)
+#define IDirect3DExecuteBuffer_Validate(p, a, b, c, d) (p)->Validate(a, b, c, d)
+#define IDirect3DExecuteBuffer_Optimize(p, a)          (p)->Optimize(a)
+#endif
+
+/*
+ * IDirect3DLight
+ */
+#undef INTERFACE
+#define INTERFACE IDirect3DLight
+DECLARE_INTERFACE_(IDirect3DLight, IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID* ppvObj) PURE;
+    STDMETHOD_(ULONG, AddRef) (THIS) PURE;
+    STDMETHOD_(ULONG, Release) (THIS) PURE;
+    /*** IDirect3DLight methods ***/
+    STDMETHOD(Initialize) (THIS_ LPDIRECT3D) PURE;
+    STDMETHOD(SetLight) (THIS_ LPD3DLIGHT) PURE;
+    STDMETHOD(GetLight) (THIS_ LPD3DLIGHT) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirect3DLight_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b)
+#define IDirect3DLight_AddRef(p)               (p)->lpVtbl->AddRef(p)
+#define IDirect3DLight_Release(p)              (p)->lpVtbl->Release(p)
+#define IDirect3DLight_Initialize(p, a)        (p)->lpVtbl->Initialize(p, a)
+#define IDirect3DLight_SetLight(p, a)          (p)->lpVtbl->SetLight(p, a)
+#define IDirect3DLight_GetLight(p, a)          (p)->lpVtbl->GetLight(p, a)
+#else
+#define IDirect3DLight_QueryInterface(p, a, b) (p)->QueryInterface(a, b)
+#define IDirect3DLight_AddRef(p)               (p)->AddRef()
+#define IDirect3DLight_Release(p)              (p)->Release()
+#define IDirect3DLight_Initialize(p, a)        (p)->Initialize(a)
+#define IDirect3DLight_SetLight(p, a)          (p)->SetLight(a)
+#define IDirect3DLight_GetLight(p, a)          (p)->GetLight(a)
+#endif
+
+/*
+ * IDirect3DMaterial
+ */
+#undef INTERFACE
+#define INTERFACE IDirect3DMaterial
+DECLARE_INTERFACE_(IDirect3DMaterial, IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID* ppvObj) PURE;
+    STDMETHOD_(ULONG, AddRef) (THIS) PURE;
+    STDMETHOD_(ULONG, Release) (THIS) PURE;
+    /*** IDirect3DMaterial methods ***/
+    STDMETHOD(Initialize) (THIS_ LPDIRECT3D) PURE;
+    STDMETHOD(SetMaterial) (THIS_ LPD3DMATERIAL) PURE;
+    STDMETHOD(GetMaterial) (THIS_ LPD3DMATERIAL) PURE;
+    STDMETHOD(GetHandle) (THIS_ LPDIRECT3DDEVICE, LPD3DMATERIALHANDLE) PURE;
+    STDMETHOD_(HRESULT, Reserve) (THIS) PURE;
+    STDMETHOD_(HRESULT, Unreserve) (THIS) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirect3DMaterial_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b)
+#define IDirect3DMaterial_AddRef(p)               (p)->lpVtbl->AddRef(p)
+#define IDirect3DMaterial_Release(p)              (p)->lpVtbl->Release(p)
+#define IDirect3DMaterial_Initialize(p, a)        (p)->lpVtbl->Initialize(p, a)
+#define IDirect3DMaterial_SetMaterial(p, a)       (p)->lpVtbl->SetMaterial(p, a)
+#define IDirect3DMaterial_GetMaterial(p, a)       (p)->lpVtbl->GetMaterial(p, a)
+#define IDirect3DMaterial_GetHandle(p, a, b)      (p)->lpVtbl->GetHandle(p, a, b)
+#define IDirect3DMaterial_Reserve(p)              (p)->lpVtbl->Reserve(p)
+#define IDirect3DMaterial_Unreserve(p)            (p)->lpVtbl->Unreserve(p)
+#else
+#define IDirect3DMaterial_QueryInterface(p, a, b) (p)->QueryInterface(a, b)
+#define IDirect3DMaterial_AddRef(p)               (p)->AddRef()
+#define IDirect3DMaterial_Release(p)              (p)->Release()
+#define IDirect3DMaterial_Initialize(p, a)        (p)->Initialize(a)
+#define IDirect3DMaterial_SetMaterial(p, a)       (p)->SetMaterial(a)
+#define IDirect3DMaterial_GetMaterial(p, a)       (p)->GetMaterial(a)
+#define IDirect3DMaterial_GetHandle(p, a, b)      (p)->GetHandle(a, b)
+#define IDirect3DMaterial_Reserve(p)              (p)->Reserve()
+#define IDirect3DMaterial_Unreserve(p)            (p)->Unreserve()
+#endif
+
+/*
+ * IDirect3DMaterial2
+ */
+#undef INTERFACE
+#define INTERFACE IDirect3DMaterial2
+DECLARE_INTERFACE_(IDirect3DMaterial2, IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID* ppvObj) PURE;
+    STDMETHOD_(ULONG, AddRef) (THIS) PURE;
+    STDMETHOD_(ULONG, Release) (THIS) PURE;
+    /*** IDirect3DMaterial2 methods ***/
+    STDMETHOD(SetMaterial) (THIS_ LPD3DMATERIAL) PURE;
+    STDMETHOD(GetMaterial) (THIS_ LPD3DMATERIAL) PURE;
+    STDMETHOD(GetHandle) (THIS_ LPDIRECT3DDEVICE2, LPD3DMATERIALHANDLE) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirect3DMaterial2_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b)
+#define IDirect3DMaterial2_AddRef(p)               (p)->lpVtbl->AddRef(p)
+#define IDirect3DMaterial2_Release(p)              (p)->lpVtbl->Release(p)
+#define IDirect3DMaterial2_SetMaterial(p, a)       (p)->lpVtbl->SetMaterial(p, a)
+#define IDirect3DMaterial2_GetMaterial(p, a)       (p)->lpVtbl->GetMaterial(p, a)
+#define IDirect3DMaterial2_GetHandle(p, a, b)      (p)->lpVtbl->GetHandle(p, a, b)
+#else
+#define IDirect3DMaterial2_QueryInterface(p, a, b) (p)->QueryInterface(a, b)
+#define IDirect3DMaterial2_AddRef(p)               (p)->AddRef()
+#define IDirect3DMaterial2_Release(p)              (p)->Release()
+#define IDirect3DMaterial2_SetMaterial(p, a)       (p)->SetMaterial(a)
+#define IDirect3DMaterial2_GetMaterial(p, a)       (p)->GetMaterial(a)
+#define IDirect3DMaterial2_GetHandle(p, a, b)      (p)->GetHandle(a, b)
+#endif
+
+/*
+ * IDirect3DTexture
+ */
+#undef INTERFACE
+#define INTERFACE IDirect3DTexture
+DECLARE_INTERFACE_(IDirect3DTexture, IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID* ppvObj) PURE;
+    STDMETHOD_(ULONG, AddRef) (THIS) PURE;
+    STDMETHOD_(ULONG, Release) (THIS) PURE;
+    /*** IDirect3DTexture methods ***/
+    STDMETHOD(Initialize) (THIS_ LPDIRECT3DDEVICE, LPDIRECTDRAWSURFACE) PURE;
+    STDMETHOD(GetHandle) (THIS_ LPDIRECT3DDEVICE, LPD3DTEXTUREHANDLE) PURE;
+    STDMETHOD(PaletteChanged) (THIS_ DWORD, DWORD) PURE;
+    STDMETHOD(Load) (THIS_ LPDIRECT3DTEXTURE) PURE;
+    STDMETHOD_(HRESULT, Unload) (THIS) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirect3DTexture_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b)
+#define IDirect3DTexture_AddRef(p)               (p)->lpVtbl->AddRef(p)
+#define IDirect3DTexture_Release(p)              (p)->lpVtbl->Release(p)
+#define IDirect3DTexture_Initialize(p, a, b)     (p)->lpVtbl->Initialize(p, a, b)
+#define IDirect3DTexture_GetHandle(p, a, b)      (p)->lpVtbl->GetHandle(p, a, b)
+#define IDirect3DTexture_PaletteChanged(p, a, b) (p)->lpVtbl->PaletteChanged(p, a, b)
+#define IDirect3DTexture_Load(p, a)              (p)->lpVtbl->Load(p, a)
+#define IDirect3DTexture_Unload(p)               (p)->lpVtbl->Unload(p)
+#else
+#define IDirect3DTexture_QueryInterface(p, a, b) (p)->QueryInterface(a, b)
+#define IDirect3DTexture_AddRef(p)               (p)->AddRef()
+#define IDirect3DTexture_Release(p)              (p)->Release()
+#define IDirect3DTexture_Initialize(p, a, b)     (p)->Initialize(a, b)
+#define IDirect3DTexture_GetHandle(p, a, b)      (p)->GetHandle(a, b)
+#define IDirect3DTexture_PaletteChanged(p, a, b) (p)->PaletteChanged(a, b)
+#define IDirect3DTexture_Load(p, a)              (p)->Load(a)
+#define IDirect3DTexture_Unload(p)               (p)->Unload()
+#endif
+
+/*
+ * IDirect3DTexture2
+ */
+#undef INTERFACE
+#define INTERFACE IDirect3DTexture2
+DECLARE_INTERFACE_(IDirect3DTexture2, IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID* ppvObj) PURE;
+    STDMETHOD_(ULONG, AddRef) (THIS) PURE;
+    STDMETHOD_(ULONG, Release) (THIS) PURE;
+    /*** IDirect3DTexture2 methods ***/
+    STDMETHOD(GetHandle) (THIS_ LPDIRECT3DDEVICE2, LPD3DTEXTUREHANDLE) PURE;
+    STDMETHOD(PaletteChanged) (THIS_ DWORD, DWORD) PURE;
+    STDMETHOD(Load) (THIS_ LPDIRECT3DTEXTURE2) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirect3DTexture2_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b)
+#define IDirect3DTexture2_AddRef(p)               (p)->lpVtbl->AddRef(p)
+#define IDirect3DTexture2_Release(p)              (p)->lpVtbl->Release(p)
+#define IDirect3DTexture2_GetHandle(p, a, b)      (p)->lpVtbl->GetHandle(p, a, b)
+#define IDirect3DTexture2_PaletteChanged(p, a, b) (p)->lpVtbl->PaletteChanged(p, a, b)
+#define IDirect3DTexture2_Load(p, a)              (p)->lpVtbl->Load(p, a)
+#else
+#define IDirect3DTexture2_QueryInterface(p, a, b) (p)->QueryInterface(a, b)
+#define IDirect3DTexture2_AddRef(p)               (p)->AddRef()
+#define IDirect3DTexture2_Release(p)              (p)->Release()
+#define IDirect3DTexture2_GetHandle(p, a, b)      (p)->GetHandle(a, b)
+#define IDirect3DTexture2_PaletteChanged(p, a, b) (p)->PaletteChanged(a, b)
+#define IDirect3DTexture2_Load(p, a)              (p)->Load(a)
+#endif
+
+/* 
+ * IDirect3DViewport
+ */
+#undef INTERFACE
+#define INTERFACE IDirect3DViewport
+DECLARE_INTERFACE_(IDirect3DViewport, IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID* ppvObj) PURE;
+    STDMETHOD_(ULONG, AddRef) (THIS) PURE;
+    STDMETHOD_(ULONG, Release) (THIS) PURE;
+    /*** IDirect3DViewport methods ***/
+    STDMETHOD(Initialize) (THIS_ LPDIRECT3D) PURE;
+    STDMETHOD(GetViewport) (THIS_ LPD3DVIEWPORT) PURE;
+    STDMETHOD(SetViewport) (THIS_ LPD3DVIEWPORT) PURE;
+    STDMETHOD(TransformVertices) (THIS_ DWORD, LPD3DTRANSFORMDATA, DWORD, LPDWORD) PURE;
+    STDMETHOD(LightElements) (THIS_ DWORD, LPD3DLIGHTDATA) PURE;
+    STDMETHOD(SetBackground) (THIS_ D3DMATERIALHANDLE) PURE;
+    STDMETHOD(GetBackground) (THIS_ LPD3DMATERIALHANDLE, LPBOOL) PURE;
+    STDMETHOD(SetBackgroundDepth) (THIS_ LPDIRECTDRAWSURFACE) PURE;
+    STDMETHOD(GetBackgroundDepth) (THIS_ LPDIRECTDRAWSURFACE*, LPBOOL) PURE;
+    STDMETHOD(Clear) (THIS_ DWORD, LPD3DRECT, DWORD) PURE;
+    STDMETHOD(AddLight) (THIS_ LPDIRECT3DLIGHT) PURE;
+    STDMETHOD(DeleteLight) (THIS_ LPDIRECT3DLIGHT) PURE;
+    STDMETHOD(NextLight) (THIS_ LPDIRECT3DLIGHT, LPDIRECT3DLIGHT*, DWORD) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirect3DViewport_QueryInterface(p, a, b)          (p)->lpVtbl->QueryInterface(p, a, b)
+#define IDirect3DViewport_AddRef(p)                        (p)->lpVtbl->AddRef(p)
+#define IDirect3DViewport_Release(p)                       (p)->lpVtbl->Release(p)
+#define IDirect3DViewport_Initialize(p, a)                 (p)->lpVtbl->Initialize(p, a)
+#define IDirect3DViewport_GetViewport(p, a)                (p)->lpVtbl->GetViewport(p, a)
+#define IDirect3DViewport_SetViewport(p, a)                (p)->lpVtbl->SetViewport(p, a)
+#define IDirect3DViewport_TransformVertices(p, a, b, c, d) (p)->lpVtbl->TransformVertices(p, a, b, c, d)
+#define IDirect3DViewport_LightElements(p, a, b)           (p)->lpVtbl->LightElements(p, a, b)
+#define IDirect3DViewport_SetBackground(p, a)              (p)->lpVtbl->SetBackground(p, a)
+#define IDirect3DViewport_GetBackground(p, a, b)           (p)->lpVtbl->GetBackground(p, a, b)
+#define IDirect3DViewport_SetBackgroundDepth(p, a)         (p)->lpVtbl->SetBackgroundDepth(p, a)
+#define IDirect3DViewport_GetBackgroundDepth(p, a, b)      (p)->lpVtbl->GetBackgroundDepth(p, a, b)
+#define IDirect3DViewport_Clear(p, a, b, c)                (p)->lpVtbl->Clear(p, a, b, c)
+#define IDirect3DViewport_AddLight(p, a)                   (p)->lpVtbl->AddLight(p, a)
+#define IDirect3DViewport_DeleteLight(p, a)                (p)->lpVtbl->DeleteLight(p, a)
+#define IDirect3DViewport_NextLight(p, a, b, c)            (p)->lpVtbl->NextLight(p, a, b, c)
+#else
+#define IDirect3DViewport_QueryInterface(p, a, b)          (p)->QueryInterface(a, b)
+#define IDirect3DViewport_AddRef(p)                        (p)->AddRef()
+#define IDirect3DViewport_Release(p)                       (p)->Release()
+#define IDirect3DViewport_Initialize(p, a)                 (p)->Initialize(a)
+#define IDirect3DViewport_GetViewport(p, a)                (p)->GetViewport(a)
+#define IDirect3DViewport_SetViewport(p, a)                (p)->SetViewport(a)
+#define IDirect3DViewport_TransformVertices(p, a, b, c, d) (p)->TransformVertices(a, b, c, d)
+#define IDirect3DViewport_LightElements(p, a, b)           (p)->LightElements(a, b)
+#define IDirect3DViewport_SetBackground(p, a)              (p)->SetBackground(a)
+#define IDirect3DViewport_GetBackground(p, a, b)           (p)->GetBackground(a, b)
+#define IDirect3DViewport_SetBackgroundDepth(p, a)         (p)->SetBackgroundDepth(a)
+#define IDirect3DViewport_GetBackgroundDepth(p, a, b)      (p)->GetBackgroundDepth(a, b)
+#define IDirect3DViewport_Clear(p, a, b, c)                (p)->Clear(a, b, c)
+#define IDirect3DViewport_AddLight(p, a)                   (p)->AddLight(a)
+#define IDirect3DViewport_DeleteLight(p, a)                (p)->DeleteLight(a)
+#define IDirect3DViewport_NextLight(p, a, b, c)            (p)->NextLight(a, b, c)
+#endif
+
+/*
+ * IDirect3DViewport2
+ */
+#undef INTERFACE
+#define INTERFACE IDirect3DViewport2
+DECLARE_INTERFACE_(IDirect3DViewport2, IDirect3DViewport)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID* ppvObj) PURE;
+    STDMETHOD_(ULONG, AddRef) (THIS) PURE;
+    STDMETHOD_(ULONG, Release) (THIS) PURE;
+    /*** IDirect3DViewport methods ***/
+    STDMETHOD(Initialize) (THIS_ LPDIRECT3D) PURE;
+    STDMETHOD(GetViewport) (THIS_ LPD3DVIEWPORT) PURE;
+    STDMETHOD(SetViewport) (THIS_ LPD3DVIEWPORT) PURE;
+    STDMETHOD(TransformVertices) (THIS_ DWORD, LPD3DTRANSFORMDATA, DWORD, LPDWORD) PURE;
+    STDMETHOD(LightElements) (THIS_ DWORD, LPD3DLIGHTDATA) PURE;
+    STDMETHOD(SetBackground) (THIS_ D3DMATERIALHANDLE) PURE;
+    STDMETHOD(GetBackground) (THIS_ LPD3DMATERIALHANDLE, LPBOOL) PURE;
+    STDMETHOD(SetBackgroundDepth) (THIS_ LPDIRECTDRAWSURFACE) PURE;
+    STDMETHOD(GetBackgroundDepth) (THIS_ LPDIRECTDRAWSURFACE*, LPBOOL) PURE;
+    STDMETHOD(Clear) (THIS_ DWORD, LPD3DRECT, DWORD) PURE;
+    STDMETHOD(AddLight) (THIS_ LPDIRECT3DLIGHT) PURE;
+    STDMETHOD(DeleteLight) (THIS_ LPDIRECT3DLIGHT) PURE;
+    STDMETHOD(NextLight) (THIS_ LPDIRECT3DLIGHT, LPDIRECT3DLIGHT*, DWORD) PURE;
+    /*** IDirect3DViewport2 methods ***/
+    STDMETHOD(GetViewport2) (THIS_ LPD3DVIEWPORT2) PURE;
+    STDMETHOD(SetViewport2) (THIS_ LPD3DVIEWPORT2) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirect3DViewport2_QueryInterface(p, a, b)          (p)->lpVtbl->QueryInterface(p, a, b)
+#define IDirect3DViewport2_AddRef(p)                        (p)->lpVtbl->AddRef(p)
+#define IDirect3DViewport2_Release(p)                       (p)->lpVtbl->Release(p)
+#define IDirect3DViewport2_Initialize(p, a)                 (p)->lpVtbl->Initialize(p, a)
+#define IDirect3DViewport2_GetViewport(p, a)                (p)->lpVtbl->GetViewport(p, a)
+#define IDirect3DViewport2_SetViewport(p, a)                (p)->lpVtbl->SetViewport(p, a)
+#define IDirect3DViewport2_TransformVertices(p, a, b, c, d) (p)->lpVtbl->TransformVertices(p, a, b, c, d)
+#define IDirect3DViewport2_LightElements(p, a, b)           (p)->lpVtbl->LightElements(p, a, b)
+#define IDirect3DViewport2_SetBackground(p, a)              (p)->lpVtbl->SetBackground(p, a)
+#define IDirect3DViewport2_GetBackground(p, a, b)           (p)->lpVtbl->GetBackground(p, a, b)
+#define IDirect3DViewport2_SetBackgroundDepth(p, a)         (p)->lpVtbl->SetBackgroundDepth(p, a)
+#define IDirect3DViewport2_GetBackgroundDepth(p, a, b)      (p)->lpVtbl->GetBackgroundDepth(p, a, b)
+#define IDirect3DViewport2_Clear(p, a, b, c)                (p)->lpVtbl->Clear(p, a, b, c)
+#define IDirect3DViewport2_AddLight(p, a)                   (p)->lpVtbl->AddLight(p, a)
+#define IDirect3DViewport2_DeleteLight(p, a)                (p)->lpVtbl->DeleteLight(p, a)
+#define IDirect3DViewport2_NextLight(p, a, b, c)            (p)->lpVtbl->NextLight(p, a, b, c)
+#define IDirect3DViewport2_GetViewport2(p, a)                (p)->lpVtbl->GetViewport2(p, a)
+#define IDirect3DViewport2_SetViewport2(p, a)                (p)->lpVtbl->SetViewport2(p, a)
+#else
+#define IDirect3DViewport2_QueryInterface(p, a, b)          (p)->QueryInterface(a, b)
+#define IDirect3DViewport2_AddRef(p)                        (p)->AddRef()
+#define IDirect3DViewport2_Release(p)                       (p)->Release()
+#define IDirect3DViewport2_Initialize(p, a)                 (p)->Initialize(a)
+#define IDirect3DViewport2_GetViewport(p, a)                (p)->GetViewport(a)
+#define IDirect3DViewport2_SetViewport(p, a)                (p)->SetViewport(a)
+#define IDirect3DViewport2_TransformVertices(p, a, b, c, d) (p)->TransformVertices(a, b, c, d)
+#define IDirect3DViewport2_LightElements(p, a, b)           (p)->LightElements(a, b)
+#define IDirect3DViewport2_SetBackground(p, a)              (p)->SetBackground(a)
+#define IDirect3DViewport2_GetBackground(p, a, b)           (p)->GetBackground(a, b)
+#define IDirect3DViewport2_SetBackgroundDepth(p, a)         (p)->SetBackgroundDepth(a)
+#define IDirect3DViewport2_GetBackgroundDepth(p, a, b)      (p)->GetBackgroundDepth(a, b)
+#define IDirect3DViewport2_Clear(p, a, b, c)                (p)->Clear(a, b, c)
+#define IDirect3DViewport2_AddLight(p, a)                   (p)->AddLight(a)
+#define IDirect3DViewport2_DeleteLight(p, a)                (p)->DeleteLight(a)
+#define IDirect3DViewport2_NextLight(p, a, b, c)            (p)->NextLight(a, b, c)
+#define IDirect3DViewport2_GetViewport2(p, a)                (p)->GetViewport2(a)
+#define IDirect3DViewport2_SetViewport2(p, a)                (p)->SetViewport2(a)
+#endif
+
+
+/****************************************************************************
+ *
+ * Flags for IDirect3DDevice::NextViewport
+ *
+ ****************************************************************************/
+
+/*
+ * Return the next viewport
+ */
+#define D3DNEXT_NEXT	0x00000001l
+
+/*
+ * Return the first viewport
+ */
+#define D3DNEXT_HEAD	0x00000002l
+
+/*
+ * Return the last viewport
+ */
+#define D3DNEXT_TAIL	0x00000004l
+
+
+/****************************************************************************
+ *
+ * Flags for DrawPrimitive/DrawIndexedPrimitive
+ *   Also valid for Begin/BeginIndexed
+ *
+ ****************************************************************************/
+
+/*
+ * Wait until the device is ready to draw the primitive
+ * This will cause DP to not return DDERR_WASSTILLDRAWING
+ */
+#define D3DDP_WAIT					0x00000001l
+
+
+/*
+ * Hint that the primitives have been clipped by the application.
+ */
+#define D3DDP_DONOTCLIP				0x00000004l
+
+/*
+ * Hint that the extents need not be updated.
+ */
+#define D3DDP_DONOTUPDATEEXTENTS	0x00000008l
+
+/*
+ * Direct3D Errors
+ * DirectDraw error codes are used when errors not specified here.
+ */
+#define D3D_OK				DD_OK
+#define D3DERR_BADMAJORVERSION		MAKE_DDHRESULT(700)
+#define D3DERR_BADMINORVERSION		MAKE_DDHRESULT(701)
+
+/*
+ * An invalid device was requested by the application.
+ */
+#define D3DERR_INVALID_DEVICE   MAKE_DDHRESULT(705)
+#define D3DERR_INITFAILED       MAKE_DDHRESULT(706)
+
+/*
+ * SetRenderTarget attempted on a device that was
+ * QI'd off the render target.
+ */
+#define D3DERR_DEVICEAGGREGATED MAKE_DDHRESULT(707)
+
+#define D3DERR_EXECUTE_CREATE_FAILED	MAKE_DDHRESULT(710)
+#define D3DERR_EXECUTE_DESTROY_FAILED	MAKE_DDHRESULT(711)
+#define D3DERR_EXECUTE_LOCK_FAILED	MAKE_DDHRESULT(712)
+#define D3DERR_EXECUTE_UNLOCK_FAILED	MAKE_DDHRESULT(713)
+#define D3DERR_EXECUTE_LOCKED		MAKE_DDHRESULT(714)
+#define D3DERR_EXECUTE_NOT_LOCKED	MAKE_DDHRESULT(715)
+
+#define D3DERR_EXECUTE_FAILED		MAKE_DDHRESULT(716)
+#define D3DERR_EXECUTE_CLIPPED_FAILED	MAKE_DDHRESULT(717)
+
+#define D3DERR_TEXTURE_NO_SUPPORT	MAKE_DDHRESULT(720)
+#define D3DERR_TEXTURE_CREATE_FAILED	MAKE_DDHRESULT(721)
+#define D3DERR_TEXTURE_DESTROY_FAILED	MAKE_DDHRESULT(722)
+#define D3DERR_TEXTURE_LOCK_FAILED	MAKE_DDHRESULT(723)
+#define D3DERR_TEXTURE_UNLOCK_FAILED	MAKE_DDHRESULT(724)
+#define D3DERR_TEXTURE_LOAD_FAILED	MAKE_DDHRESULT(725)
+#define D3DERR_TEXTURE_SWAP_FAILED	MAKE_DDHRESULT(726)
+#define D3DERR_TEXTURE_LOCKED		MAKE_DDHRESULT(727)
+#define D3DERR_TEXTURE_NOT_LOCKED	MAKE_DDHRESULT(728)
+#define D3DERR_TEXTURE_GETSURF_FAILED	MAKE_DDHRESULT(729)
+
+#define D3DERR_MATRIX_CREATE_FAILED	MAKE_DDHRESULT(730)
+#define D3DERR_MATRIX_DESTROY_FAILED	MAKE_DDHRESULT(731)
+#define D3DERR_MATRIX_SETDATA_FAILED	MAKE_DDHRESULT(732)
+#define D3DERR_MATRIX_GETDATA_FAILED	MAKE_DDHRESULT(733)
+#define D3DERR_SETVIEWPORTDATA_FAILED	MAKE_DDHRESULT(734)
+
+#define D3DERR_INVALIDCURRENTVIEWPORT   MAKE_DDHRESULT(735)
+#define D3DERR_INVALIDPRIMITIVETYPE     MAKE_DDHRESULT(736)
+#define D3DERR_INVALIDVERTEXTYPE        MAKE_DDHRESULT(737)
+#define D3DERR_TEXTURE_BADSIZE          MAKE_DDHRESULT(738)
+#define D3DERR_INVALIDRAMPTEXTURE		MAKE_DDHRESULT(739)
+
+#define D3DERR_MATERIAL_CREATE_FAILED	MAKE_DDHRESULT(740)
+#define D3DERR_MATERIAL_DESTROY_FAILED	MAKE_DDHRESULT(741)
+#define D3DERR_MATERIAL_SETDATA_FAILED	MAKE_DDHRESULT(742)
+#define D3DERR_MATERIAL_GETDATA_FAILED	MAKE_DDHRESULT(743)
+#define D3DERR_INVALIDPALETTE	        MAKE_DDHRESULT(744)
+
+#define D3DERR_ZBUFF_NEEDS_SYSTEMMEMORY MAKE_DDHRESULT(745)
+#define D3DERR_ZBUFF_NEEDS_VIDEOMEMORY  MAKE_DDHRESULT(746)
+#define D3DERR_SURFACENOTINVIDMEM       MAKE_DDHRESULT(747)
+
+#define D3DERR_LIGHT_SET_FAILED		MAKE_DDHRESULT(750)
+#define D3DERR_LIGHTHASVIEWPORT		MAKE_DDHRESULT(751)
+#define D3DERR_LIGHTNOTINTHISVIEWPORT           MAKE_DDHRESULT(752)
+
+#define D3DERR_SCENE_IN_SCENE		MAKE_DDHRESULT(760)
+#define D3DERR_SCENE_NOT_IN_SCENE	MAKE_DDHRESULT(761)
+#define D3DERR_SCENE_BEGIN_FAILED	MAKE_DDHRESULT(762)
+#define D3DERR_SCENE_END_FAILED		MAKE_DDHRESULT(763)
+
+#define D3DERR_INBEGIN                  MAKE_DDHRESULT(770)
+#define D3DERR_NOTINBEGIN               MAKE_DDHRESULT(771)
+#define D3DERR_NOVIEWPORTS              MAKE_DDHRESULT(772)
+#define D3DERR_VIEWPORTDATANOTSET       MAKE_DDHRESULT(773)
+#define D3DERR_VIEWPORTHASNODEVICE      MAKE_DDHRESULT(774)
+#define D3DERR_NOCURRENTVIEWPORT		MAKE_DDHRESULT(775)
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif /* _D3D_H_ */
diff --git a/3rdparty/dx5/inc/d3dcaps.h b/3rdparty/dx5/inc/d3dcaps.h
new file mode 100644
index 00000000..c688eb25
--- /dev/null
+++ b/3rdparty/dx5/inc/d3dcaps.h
@@ -0,0 +1,313 @@
+/*==========================================================================;
+ *
+ *  Copyright (C) 1995-1997 Microsoft Corporation.  All Rights Reserved.
+ *
+ *  File:	d3dcaps.h
+ *  Content:	Direct3D capabilities include file
+ *
+ ***************************************************************************/
+
+#ifndef _D3DCAPS_H
+#define _D3DCAPS_H
+
+/* 
+ *  Pull in DirectDraw include file automatically:
+ */
+#include <ddraw.h>
+
+#pragma pack(4)
+
+/* Description of capabilities of transform */
+
+typedef struct _D3DTRANSFORMCAPS {
+    DWORD dwSize;
+    DWORD dwCaps;
+} D3DTRANSFORMCAPS, *LPD3DTRANSFORMCAPS;
+
+#define D3DTRANSFORMCAPS_CLIP		0x00000001L /* Will clip whilst transforming */
+
+/* Description of capabilities of lighting */
+
+typedef struct _D3DLIGHTINGCAPS {
+    DWORD dwSize;
+    DWORD dwCaps;                   /* Lighting caps */
+    DWORD dwLightingModel;          /* Lighting model - RGB or mono */
+    DWORD dwNumLights;              /* Number of lights that can be handled */
+} D3DLIGHTINGCAPS, *LPD3DLIGHTINGCAPS;
+
+#define D3DLIGHTINGMODEL_RGB		0x00000001L
+#define D3DLIGHTINGMODEL_MONO		0x00000002L
+
+#define D3DLIGHTCAPS_POINT		0x00000001L /* Point lights supported */
+#define D3DLIGHTCAPS_SPOT		0x00000002L /* Spot lights supported */
+#define D3DLIGHTCAPS_DIRECTIONAL	0x00000004L /* Directional lights supported */
+#define D3DLIGHTCAPS_PARALLELPOINT	0x00000008L /* Parallel point lights supported */
+
+/* Description of capabilities for each primitive type */
+
+typedef struct _D3DPrimCaps {
+    DWORD dwSize;
+    DWORD dwMiscCaps;                 /* Capability flags */
+    DWORD dwRasterCaps;
+    DWORD dwZCmpCaps;
+    DWORD dwSrcBlendCaps;
+    DWORD dwDestBlendCaps;
+    DWORD dwAlphaCmpCaps;
+    DWORD dwShadeCaps;
+    DWORD dwTextureCaps;
+    DWORD dwTextureFilterCaps;
+    DWORD dwTextureBlendCaps;
+    DWORD dwTextureAddressCaps;
+    DWORD dwStippleWidth;             /* maximum width and height of */
+    DWORD dwStippleHeight;            /* of supported stipple (up to 32x32) */
+} D3DPRIMCAPS, *LPD3DPRIMCAPS;
+
+/* D3DPRIMCAPS dwMiscCaps */
+
+#define D3DPMISCCAPS_MASKPLANES		0x00000001L
+#define D3DPMISCCAPS_MASKZ		0x00000002L
+#define D3DPMISCCAPS_LINEPATTERNREP	0x00000004L
+#define D3DPMISCCAPS_CONFORMANT		0x00000008L
+#define D3DPMISCCAPS_CULLNONE		0x00000010L
+#define D3DPMISCCAPS_CULLCW		0x00000020L
+#define D3DPMISCCAPS_CULLCCW		0x00000040L
+
+/* D3DPRIMCAPS dwRasterCaps */
+
+#define D3DPRASTERCAPS_DITHER                   0x00000001L
+#define D3DPRASTERCAPS_ROP2                     0x00000002L
+#define D3DPRASTERCAPS_XOR                      0x00000004L
+#define D3DPRASTERCAPS_PAT                      0x00000008L
+#define D3DPRASTERCAPS_ZTEST                    0x00000010L
+#define D3DPRASTERCAPS_SUBPIXEL                 0x00000020L
+#define D3DPRASTERCAPS_SUBPIXELX                0x00000040L
+#define D3DPRASTERCAPS_FOGVERTEX                0x00000080L
+#define D3DPRASTERCAPS_FOGTABLE                 0x00000100L
+#define D3DPRASTERCAPS_STIPPLE                  0x00000200L
+#define D3DPRASTERCAPS_ANTIALIASSORTDEPENDENT   0x00000400L
+#define D3DPRASTERCAPS_ANTIALIASSORTINDEPENDENT 0x00000800L
+#define D3DPRASTERCAPS_ANTIALIASEDGES           0x00001000L
+#define D3DPRASTERCAPS_MIPMAPLODBIAS            0x00002000L
+#define D3DPRASTERCAPS_ZBIAS                    0x00004000L
+#define D3DPRASTERCAPS_ZBUFFERLESSHSR           0x00008000L
+#define D3DPRASTERCAPS_FOGRANGE                 0x00010000L
+#define D3DPRASTERCAPS_ANISOTROPY               0x00020000L
+
+/* D3DPRIMCAPS dwZCmpCaps, dwAlphaCmpCaps */
+
+#define D3DPCMPCAPS_NEVER		0x00000001L
+#define D3DPCMPCAPS_LESS         	0x00000002L
+#define D3DPCMPCAPS_EQUAL        	0x00000004L
+#define D3DPCMPCAPS_LESSEQUAL    	0x00000008L
+#define D3DPCMPCAPS_GREATER      	0x00000010L
+#define D3DPCMPCAPS_NOTEQUAL     	0x00000020L
+#define D3DPCMPCAPS_GREATEREQUAL 	0x00000040L
+#define D3DPCMPCAPS_ALWAYS       	0x00000080L
+
+/* D3DPRIMCAPS dwSourceBlendCaps, dwDestBlendCaps */
+
+#define D3DPBLENDCAPS_ZERO              0x00000001L
+#define D3DPBLENDCAPS_ONE               0x00000002L
+#define D3DPBLENDCAPS_SRCCOLOR          0x00000004L
+#define D3DPBLENDCAPS_INVSRCCOLOR       0x00000008L
+#define D3DPBLENDCAPS_SRCALPHA          0x00000010L
+#define D3DPBLENDCAPS_INVSRCALPHA       0x00000020L
+#define D3DPBLENDCAPS_DESTALPHA         0x00000040L
+#define D3DPBLENDCAPS_INVDESTALPHA      0x00000080L
+#define D3DPBLENDCAPS_DESTCOLOR         0x00000100L
+#define D3DPBLENDCAPS_INVDESTCOLOR      0x00000200L
+#define D3DPBLENDCAPS_SRCALPHASAT       0x00000400L
+#define D3DPBLENDCAPS_BOTHSRCALPHA      0x00000800L
+#define D3DPBLENDCAPS_BOTHINVSRCALPHA   0x00001000L
+
+/* D3DPRIMCAPS dwShadeCaps */
+
+#define D3DPSHADECAPS_COLORFLATMONO		0x00000001L
+#define D3DPSHADECAPS_COLORFLATRGB		0x00000002L
+#define D3DPSHADECAPS_COLORGOURAUDMONO		0x00000004L
+#define D3DPSHADECAPS_COLORGOURAUDRGB		0x00000008L
+#define D3DPSHADECAPS_COLORPHONGMONO		0x00000010L
+#define D3DPSHADECAPS_COLORPHONGRGB		0x00000020L
+
+#define D3DPSHADECAPS_SPECULARFLATMONO		0x00000040L
+#define D3DPSHADECAPS_SPECULARFLATRGB		0x00000080L
+#define D3DPSHADECAPS_SPECULARGOURAUDMONO	0x00000100L
+#define D3DPSHADECAPS_SPECULARGOURAUDRGB	0x00000200L
+#define D3DPSHADECAPS_SPECULARPHONGMONO		0x00000400L
+#define D3DPSHADECAPS_SPECULARPHONGRGB		0x00000800L
+
+#define D3DPSHADECAPS_ALPHAFLATBLEND		0x00001000L
+#define D3DPSHADECAPS_ALPHAFLATSTIPPLED		0x00002000L
+#define D3DPSHADECAPS_ALPHAGOURAUDBLEND		0x00004000L
+#define D3DPSHADECAPS_ALPHAGOURAUDSTIPPLED	0x00008000L
+#define D3DPSHADECAPS_ALPHAPHONGBLEND		0x00010000L
+#define D3DPSHADECAPS_ALPHAPHONGSTIPPLED	0x00020000L
+
+#define D3DPSHADECAPS_FOGFLAT			0x00040000L
+#define D3DPSHADECAPS_FOGGOURAUD		0x00080000L
+#define D3DPSHADECAPS_FOGPHONG			0x00100000L
+
+/* D3DPRIMCAPS dwTextureCaps */
+
+#define D3DPTEXTURECAPS_PERSPECTIVE	0x00000001L
+#define D3DPTEXTURECAPS_POW2		0x00000002L
+#define D3DPTEXTURECAPS_ALPHA		0x00000004L
+#define D3DPTEXTURECAPS_TRANSPARENCY	0x00000008L
+#define D3DPTEXTURECAPS_BORDER		0x00000010L
+#define D3DPTEXTURECAPS_SQUAREONLY	0x00000020L
+
+/* D3DPRIMCAPS dwTextureFilterCaps */
+
+#define D3DPTFILTERCAPS_NEAREST		0x00000001L
+#define D3DPTFILTERCAPS_LINEAR		0x00000002L
+#define D3DPTFILTERCAPS_MIPNEAREST	0x00000004L
+#define D3DPTFILTERCAPS_MIPLINEAR	0x00000008L
+#define D3DPTFILTERCAPS_LINEARMIPNEAREST 0x00000010L
+#define D3DPTFILTERCAPS_LINEARMIPLINEAR	0x00000020L
+
+/* D3DPRIMCAPS dwTextureBlendCaps */
+
+#define D3DPTBLENDCAPS_DECAL		0x00000001L
+#define D3DPTBLENDCAPS_MODULATE		0x00000002L
+#define D3DPTBLENDCAPS_DECALALPHA	0x00000004L
+#define D3DPTBLENDCAPS_MODULATEALPHA	0x00000008L
+#define D3DPTBLENDCAPS_DECALMASK	0x00000010L
+#define D3DPTBLENDCAPS_MODULATEMASK	0x00000020L
+#define D3DPTBLENDCAPS_COPY		0x00000040L
+#define D3DPTBLENDCAPS_ADD		0x00000080L
+
+/* D3DPRIMCAPS dwTextureAddressCaps */
+#define D3DPTADDRESSCAPS_WRAP		0x00000001L
+#define D3DPTADDRESSCAPS_MIRROR		0x00000002L
+#define D3DPTADDRESSCAPS_CLAMP		0x00000004L
+#define D3DPTADDRESSCAPS_BORDER     0x00000008L
+#define D3DPTADDRESSCAPS_INDEPENDENTUV 0x00000010L
+
+/*
+ * Description for a device.
+ * This is used to describe a device that is to be created or to query
+ * the current device.
+ */
+typedef struct _D3DDeviceDesc {
+    DWORD	     dwSize;		     /* Size of D3DDEVICEDESC structure */
+    DWORD	     dwFlags;	             /* Indicates which fields have valid data */
+    D3DCOLORMODEL    dcmColorModel;	     /* Color model of device */
+    DWORD	     dwDevCaps;	             /* Capabilities of device */
+    D3DTRANSFORMCAPS dtcTransformCaps;       /* Capabilities of transform */
+    BOOL	     bClipping;	             /* Device can do 3D clipping */
+    D3DLIGHTINGCAPS  dlcLightingCaps;        /* Capabilities of lighting */
+    D3DPRIMCAPS      dpcLineCaps;
+    D3DPRIMCAPS      dpcTriCaps;
+    DWORD	     dwDeviceRenderBitDepth; /* One of DDBB_8, 16, etc.. */
+    DWORD	     dwDeviceZBufferBitDepth;/* One of DDBD_16, 32, etc.. */
+    DWORD	     dwMaxBufferSize;        /* Maximum execute buffer size */
+    DWORD	     dwMaxVertexCount;       /* Maximum vertex count */
+    // *** New fields for DX5 *** //
+
+    // Width and height caps are 0 for legacy HALs.
+    DWORD        dwMinTextureWidth, dwMinTextureHeight;
+    DWORD        dwMaxTextureWidth, dwMaxTextureHeight;
+    DWORD        dwMinStippleWidth, dwMaxStippleWidth;
+    DWORD        dwMinStippleHeight, dwMaxStippleHeight;
+} D3DDEVICEDESC, *LPD3DDEVICEDESC;
+
+#define D3DDEVICEDESCSIZE (sizeof(D3DDEVICEDESC))
+
+typedef HRESULT (FAR PASCAL * LPD3DENUMDEVICESCALLBACK)(LPGUID lpGuid, LPSTR lpDeviceDescription, LPSTR lpDeviceName, LPD3DDEVICEDESC, LPD3DDEVICEDESC, LPVOID);
+
+/* D3DDEVICEDESC dwFlags indicating valid fields */
+
+#define D3DDD_COLORMODEL	    0x00000001L /* dcmColorModel is valid */
+#define D3DDD_DEVCAPS		    0x00000002L /* dwDevCaps is valid */
+#define D3DDD_TRANSFORMCAPS         0x00000004L /* dtcTransformCaps is valid */
+#define D3DDD_LIGHTINGCAPS          0x00000008L /* dlcLightingCaps is valid */
+#define D3DDD_BCLIPPING             0x00000010L /* bClipping is valid */
+#define D3DDD_LINECAPS              0x00000020L /* dpcLineCaps is valid */
+#define D3DDD_TRICAPS               0x00000040L /* dpcTriCaps is valid */
+#define D3DDD_DEVICERENDERBITDEPTH  0x00000080L	/* dwDeviceRenderBitDepth is valid */
+#define D3DDD_DEVICEZBUFFERBITDEPTH 0x00000100L	/* dwDeviceZBufferBitDepth is valid */
+#define D3DDD_MAXBUFFERSIZE         0x00000200L /* dwMaxBufferSize is valid */
+#define D3DDD_MAXVERTEXCOUNT        0x00000400L /* dwMaxVertexCount is valid */
+
+/* D3DDEVICEDESC dwDevCaps flags */
+
+#define D3DDEVCAPS_FLOATTLVERTEX        0x00000001L /* Device accepts floating point */
+                                                    /* for post-transform vertex data */
+#define D3DDEVCAPS_SORTINCREASINGZ      0x00000002L /* Device needs data sorted for increasing Z*/
+#define D3DDEVCAPS_SORTDECREASINGZ      0X00000004L /* Device needs data sorted for decreasing Z*/
+#define D3DDEVCAPS_SORTEXACT	        0x00000008L /* Device needs data sorted exactly */
+
+#define D3DDEVCAPS_EXECUTESYSTEMMEMORY  0x00000010L /* Device can use execute buffers from system memory */
+#define D3DDEVCAPS_EXECUTEVIDEOMEMORY   0x00000020L /* Device can use execute buffers from video memory */
+#define D3DDEVCAPS_TLVERTEXSYSTEMMEMORY 0x00000040L /* Device can use TL buffers from system memory */
+#define D3DDEVCAPS_TLVERTEXVIDEOMEMORY  0x00000080L /* Device can use TL buffers from video memory */
+#define D3DDEVCAPS_TEXTURESYSTEMMEMORY  0x00000100L /* Device can texture from system memory */
+#define D3DDEVCAPS_TEXTUREVIDEOMEMORY	0x00000200L /* Device can texture from device memory */
+#define D3DDEVCAPS_DRAWPRIMTLVERTEX     0x00000400L /* Device can draw TLVERTEX primitives */
+#define D3DDEVCAPS_CANRENDERAFTERFLIP	0x00000800L /* Device can render without waiting for flip to complete */
+#define D3DDEVCAPS_TEXTURENONLOCALVIDMEM 0x00001000L /* Device can texture from nonlocal video memory */
+
+#define D3DFDS_COLORMODEL	 0x00000001L /* Match color model */
+#define D3DFDS_GUID		 0x00000002L /* Match guid */
+#define D3DFDS_HARDWARE		 0x00000004L /* Match hardware/software */
+#define D3DFDS_TRIANGLES	 0x00000008L /* Match in triCaps */
+#define D3DFDS_LINES		 0x00000010L /* Match in lineCaps  */
+#define D3DFDS_MISCCAPS		 0x00000020L /* Match primCaps.dwMiscCaps */
+#define D3DFDS_RASTERCAPS	 0x00000040L /* Match primCaps.dwRasterCaps */
+#define D3DFDS_ZCMPCAPS		 0x00000080L /* Match primCaps.dwZCmpCaps */
+#define D3DFDS_ALPHACMPCAPS	 0x00000100L /* Match primCaps.dwAlphaCmpCaps */
+#define D3DFDS_SRCBLENDCAPS	 0x00000200L /* Match primCaps.dwSourceBlendCaps */
+#define D3DFDS_DSTBLENDCAPS	 0x00000400L /* Match primCaps.dwDestBlendCaps */
+#define D3DFDS_SHADECAPS	 0x00000800L /* Match primCaps.dwShadeCaps */
+#define D3DFDS_TEXTURECAPS	 0x00001000L /* Match primCaps.dwTextureCaps */
+#define D3DFDS_TEXTUREFILTERCAPS 0x00002000L /* Match primCaps.dwTextureFilterCaps */
+#define D3DFDS_TEXTUREBLENDCAPS  0x00004000L /* Match primCaps.dwTextureBlendCaps */
+#define D3DFDS_TEXTUREADDRESSCAPS  0x00008000L /* Match primCaps.dwTextureBlendCaps */
+
+/*
+ * FindDevice arguments
+ */
+typedef struct _D3DFINDDEVICESEARCH {
+    DWORD		dwSize;
+    DWORD		dwFlags;
+    BOOL		bHardware;
+    D3DCOLORMODEL	dcmColorModel;
+    GUID		guid;
+    DWORD		dwCaps;
+    D3DPRIMCAPS		dpcPrimCaps;
+} D3DFINDDEVICESEARCH, *LPD3DFINDDEVICESEARCH;
+
+typedef struct _D3DFINDDEVICERESULT {
+    DWORD		dwSize;
+    GUID		guid;		/* guid which matched */
+    D3DDEVICEDESC       ddHwDesc;       /* hardware D3DDEVICEDESC */
+    D3DDEVICEDESC       ddSwDesc;       /* software D3DDEVICEDESC */
+} D3DFINDDEVICERESULT, *LPD3DFINDDEVICERESULT;
+
+
+/*
+ * Description of execute buffer.
+ */
+typedef struct _D3DExecuteBufferDesc {
+    DWORD		dwSize;		/* size of this structure */
+    DWORD		dwFlags;	/* flags indicating which fields are valid */
+    DWORD		dwCaps;		/* capabilities of execute buffer */
+    DWORD		dwBufferSize;	/* size of execute buffer data */
+    LPVOID		lpData;		/* pointer to actual data */
+} D3DEXECUTEBUFFERDESC, *LPD3DEXECUTEBUFFERDESC;
+
+/* D3DEXECUTEBUFFER dwFlags indicating valid fields */
+
+#define D3DDEB_BUFSIZE		0x00000001l     /* buffer size valid */
+#define D3DDEB_CAPS		0x00000002l     /* caps valid */
+#define D3DDEB_LPDATA		0x00000004l     /* lpData valid */
+
+/* D3DEXECUTEBUFFER dwCaps */
+
+#define D3DDEBCAPS_SYSTEMMEMORY	0x00000001l     /* buffer in system memory */
+#define D3DDEBCAPS_VIDEOMEMORY	0x00000002l     /* buffer in device memory */
+#define D3DDEBCAPS_MEM (D3DDEBCAPS_SYSTEMMEMORY|D3DDEBCAPS_VIDEOMEMORY)
+
+#pragma pack()
+
+#endif /* _D3DCAPS_H_ */
diff --git a/3rdparty/dx5/inc/d3drm.h b/3rdparty/dx5/inc/d3drm.h
new file mode 100644
index 00000000..f653c0b9
--- /dev/null
+++ b/3rdparty/dx5/inc/d3drm.h
@@ -0,0 +1,229 @@
+/*==========================================================================;
+ *
+ *  Copyright (C) 1995-1997 Microsoft Corporation.  All Rights Reserved.
+ *
+ *  File:	d3drm.h
+ *  Content:	Direct3DRM include file
+ *
+ ***************************************************************************/
+
+#ifndef __D3DRM_H__
+#define __D3DRM_H__
+
+#include "ddraw.h"
+#include "d3drmobj.h"
+
+#ifdef __cplusplus
+extern "C" {
+struct IDirect3DRM;
+#endif
+
+
+DEFINE_GUID(IID_IDirect3DRM,	0x2bc49361, 0x8327, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(IID_IDirect3DRM2,	0x4516ecc8, 0x8f20, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3);
+WIN_TYPES(IDirect3DRM, DIRECT3DRM);
+WIN_TYPES(IDirect3DRM2, DIRECT3DRM2);
+
+
+/* Create a Direct3DRM API */
+STDAPI Direct3DRMCreate(LPDIRECT3DRM FAR *lplpDirect3DRM);
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRM
+
+DECLARE_INTERFACE_(IDirect3DRM, IUnknown)
+{
+    IUNKNOWN_METHODS(PURE);
+
+    STDMETHOD(CreateObject)
+	(THIS_ REFCLSID rclsid, LPUNKNOWN pUnkOuter, REFIID riid, LPVOID FAR* ppv) PURE;
+    STDMETHOD(CreateFrame)	(THIS_ LPDIRECT3DRMFRAME, LPDIRECT3DRMFRAME *) PURE;
+    STDMETHOD(CreateMesh)	(THIS_ LPDIRECT3DRMMESH *) PURE;
+    STDMETHOD(CreateMeshBuilder)(THIS_ LPDIRECT3DRMMESHBUILDER *) PURE;
+    STDMETHOD(CreateFace)	(THIS_ LPDIRECT3DRMFACE *) PURE;
+    STDMETHOD(CreateAnimation)	(THIS_ LPDIRECT3DRMANIMATION *) PURE;
+    STDMETHOD(CreateAnimationSet)(THIS_ LPDIRECT3DRMANIMATIONSET *) PURE;
+    STDMETHOD(CreateTexture)	(THIS_ LPD3DRMIMAGE, LPDIRECT3DRMTEXTURE *) PURE;
+    STDMETHOD(CreateLight)	(THIS_ D3DRMLIGHTTYPE, D3DCOLOR, LPDIRECT3DRMLIGHT *) PURE;
+    STDMETHOD(CreateLightRGB)
+	(THIS_ D3DRMLIGHTTYPE, D3DVALUE, D3DVALUE, D3DVALUE, LPDIRECT3DRMLIGHT *) PURE;
+    STDMETHOD(CreateMaterial)	(THIS_ D3DVALUE, LPDIRECT3DRMMATERIAL *) PURE;
+    STDMETHOD(CreateDevice)	(THIS_ DWORD, DWORD, LPDIRECT3DRMDEVICE *) PURE;
+
+    /* Create a Windows Device using DirectDraw surfaces */
+    STDMETHOD(CreateDeviceFromSurface)
+    (	THIS_ LPGUID lpGUID, LPDIRECTDRAW lpDD,
+	LPDIRECTDRAWSURFACE lpDDSBack, LPDIRECT3DRMDEVICE *
+    ) PURE;
+
+    /* Create a Windows Device using D3D objects */
+    STDMETHOD(CreateDeviceFromD3D)
+    (	THIS_ LPDIRECT3D lpD3D, LPDIRECT3DDEVICE lpD3DDev,
+	LPDIRECT3DRMDEVICE *
+    ) PURE;
+
+    STDMETHOD(CreateDeviceFromClipper)
+    (	THIS_ LPDIRECTDRAWCLIPPER lpDDClipper, LPGUID lpGUID,
+	int width, int height, LPDIRECT3DRMDEVICE *) PURE;
+
+    STDMETHOD(CreateTextureFromSurface)(THIS_ LPDIRECTDRAWSURFACE lpDDS, LPDIRECT3DRMTEXTURE *) PURE;
+   
+    STDMETHOD(CreateShadow)
+    (	THIS_ LPDIRECT3DRMVISUAL, LPDIRECT3DRMLIGHT,
+	D3DVALUE px, D3DVALUE py, D3DVALUE pz,
+	D3DVALUE nx, D3DVALUE ny, D3DVALUE nz,
+	LPDIRECT3DRMVISUAL *
+    ) PURE;
+    STDMETHOD(CreateViewport)
+    (	THIS_ LPDIRECT3DRMDEVICE, LPDIRECT3DRMFRAME, DWORD, DWORD,
+	DWORD, DWORD, LPDIRECT3DRMVIEWPORT *
+    ) PURE;
+    STDMETHOD(CreateWrap)
+    (	THIS_ D3DRMWRAPTYPE, LPDIRECT3DRMFRAME,
+	D3DVALUE ox, D3DVALUE oy, D3DVALUE oz,
+	D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
+	D3DVALUE ux, D3DVALUE uy, D3DVALUE uz,
+	D3DVALUE ou, D3DVALUE ov,
+	D3DVALUE su, D3DVALUE sv,
+	LPDIRECT3DRMWRAP *
+    ) PURE;
+    STDMETHOD(CreateUserVisual) (THIS_ D3DRMUSERVISUALCALLBACK, LPVOID lPArg, LPDIRECT3DRMUSERVISUAL *) PURE;
+    STDMETHOD(LoadTexture)	(THIS_ const char *, LPDIRECT3DRMTEXTURE *) PURE;
+    STDMETHOD(LoadTextureFromResource)	(THIS_ HRSRC rs, LPDIRECT3DRMTEXTURE *) PURE;
+   
+    STDMETHOD(SetSearchPath)	(THIS_ LPCSTR) PURE;
+    STDMETHOD(AddSearchPath)	(THIS_ LPCSTR) PURE;
+    STDMETHOD(GetSearchPath)	(THIS_ DWORD *size_return, LPSTR path_return) PURE;
+    STDMETHOD(SetDefaultTextureColors)(THIS_ DWORD) PURE;
+    STDMETHOD(SetDefaultTextureShades)(THIS_ DWORD) PURE;
+   
+    STDMETHOD(GetDevices)	(THIS_ LPDIRECT3DRMDEVICEARRAY *) PURE;
+    STDMETHOD(GetNamedObject)	(THIS_ const char *, LPDIRECT3DRMOBJECT *) PURE;
+   
+    STDMETHOD(EnumerateObjects)	(THIS_ D3DRMOBJECTCALLBACK, LPVOID) PURE;
+   
+    STDMETHOD(Load)		
+    (   THIS_ LPVOID, LPVOID, LPIID *, DWORD, D3DRMLOADOPTIONS,
+    	D3DRMLOADCALLBACK, LPVOID, D3DRMLOADTEXTURECALLBACK, LPVOID,
+	LPDIRECT3DRMFRAME
+    ) PURE;
+    STDMETHOD(Tick)		(THIS_ D3DVALUE) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRM2
+
+DECLARE_INTERFACE_(IDirect3DRM2, IUnknown)
+{
+    IUNKNOWN_METHODS(PURE);
+
+    STDMETHOD(CreateObject)
+	(THIS_ REFCLSID rclsid, LPUNKNOWN pUnkOuter, REFIID riid, LPVOID FAR* ppv) PURE;
+    STDMETHOD(CreateFrame)	(THIS_ LPDIRECT3DRMFRAME, LPDIRECT3DRMFRAME2 *) PURE;
+    STDMETHOD(CreateMesh)	(THIS_ LPDIRECT3DRMMESH *) PURE;
+    STDMETHOD(CreateMeshBuilder)(THIS_ LPDIRECT3DRMMESHBUILDER2 *) PURE;
+    STDMETHOD(CreateFace)	(THIS_ LPDIRECT3DRMFACE *) PURE;
+    STDMETHOD(CreateAnimation)	(THIS_ LPDIRECT3DRMANIMATION *) PURE;
+    STDMETHOD(CreateAnimationSet)(THIS_ LPDIRECT3DRMANIMATIONSET *) PURE;
+    STDMETHOD(CreateTexture)	(THIS_ LPD3DRMIMAGE, LPDIRECT3DRMTEXTURE2 *) PURE;
+    STDMETHOD(CreateLight)	(THIS_ D3DRMLIGHTTYPE, D3DCOLOR, LPDIRECT3DRMLIGHT *) PURE;
+    STDMETHOD(CreateLightRGB)
+	(THIS_ D3DRMLIGHTTYPE, D3DVALUE, D3DVALUE, D3DVALUE, LPDIRECT3DRMLIGHT *) PURE;
+    STDMETHOD(CreateMaterial)	(THIS_ D3DVALUE, LPDIRECT3DRMMATERIAL *) PURE;
+    STDMETHOD(CreateDevice)	(THIS_ DWORD, DWORD, LPDIRECT3DRMDEVICE2 *) PURE;
+
+    /* Create a Windows Device using DirectDraw surfaces */
+    STDMETHOD(CreateDeviceFromSurface)
+    (	THIS_ LPGUID lpGUID, LPDIRECTDRAW lpDD,
+	LPDIRECTDRAWSURFACE lpDDSBack, LPDIRECT3DRMDEVICE2 *
+    ) PURE;
+
+    /* Create a Windows Device using D3D objects */
+    STDMETHOD(CreateDeviceFromD3D)
+    (	THIS_ LPDIRECT3D2 lpD3D, LPDIRECT3DDEVICE2 lpD3DDev,
+	LPDIRECT3DRMDEVICE2 *
+    ) PURE;
+
+    STDMETHOD(CreateDeviceFromClipper)
+    (	THIS_ LPDIRECTDRAWCLIPPER lpDDClipper, LPGUID lpGUID,
+	int width, int height, LPDIRECT3DRMDEVICE2 *) PURE;
+
+    STDMETHOD(CreateTextureFromSurface)(THIS_ LPDIRECTDRAWSURFACE lpDDS, LPDIRECT3DRMTEXTURE2 *) PURE;
+   
+    STDMETHOD(CreateShadow)
+    (	THIS_ LPDIRECT3DRMVISUAL, LPDIRECT3DRMLIGHT,
+	D3DVALUE px, D3DVALUE py, D3DVALUE pz,
+	D3DVALUE nx, D3DVALUE ny, D3DVALUE nz,
+	LPDIRECT3DRMVISUAL *
+    ) PURE;
+    STDMETHOD(CreateViewport)
+    (	THIS_ LPDIRECT3DRMDEVICE, LPDIRECT3DRMFRAME, DWORD, DWORD,
+	DWORD, DWORD, LPDIRECT3DRMVIEWPORT *
+    ) PURE;
+    STDMETHOD(CreateWrap)
+    (	THIS_ D3DRMWRAPTYPE, LPDIRECT3DRMFRAME,
+	D3DVALUE ox, D3DVALUE oy, D3DVALUE oz,
+	D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
+	D3DVALUE ux, D3DVALUE uy, D3DVALUE uz,
+	D3DVALUE ou, D3DVALUE ov,
+	D3DVALUE su, D3DVALUE sv,
+	LPDIRECT3DRMWRAP *
+    ) PURE;
+    STDMETHOD(CreateUserVisual) (THIS_ D3DRMUSERVISUALCALLBACK, LPVOID lPArg, LPDIRECT3DRMUSERVISUAL *) PURE;
+    STDMETHOD(LoadTexture)	(THIS_ const char *, LPDIRECT3DRMTEXTURE2 *) PURE;
+    STDMETHOD(LoadTextureFromResource)	(THIS_ HMODULE hModule, LPCTSTR strName, LPCTSTR strType, LPDIRECT3DRMTEXTURE2 *) PURE;
+   
+    STDMETHOD(SetSearchPath)	(THIS_ LPCSTR) PURE;
+    STDMETHOD(AddSearchPath)	(THIS_ LPCSTR) PURE;
+    STDMETHOD(GetSearchPath)	(THIS_ DWORD *size_return, LPSTR path_return) PURE;
+    STDMETHOD(SetDefaultTextureColors)(THIS_ DWORD) PURE;
+    STDMETHOD(SetDefaultTextureShades)(THIS_ DWORD) PURE;
+   
+    STDMETHOD(GetDevices)	(THIS_ LPDIRECT3DRMDEVICEARRAY *) PURE;
+    STDMETHOD(GetNamedObject)	(THIS_ const char *, LPDIRECT3DRMOBJECT *) PURE;
+   
+    STDMETHOD(EnumerateObjects)	(THIS_ D3DRMOBJECTCALLBACK, LPVOID) PURE;
+   
+    STDMETHOD(Load)		
+    (   THIS_ LPVOID, LPVOID, LPIID *, DWORD, D3DRMLOADOPTIONS,
+    	D3DRMLOADCALLBACK, LPVOID, D3DRMLOADTEXTURECALLBACK, LPVOID,
+	LPDIRECT3DRMFRAME
+    ) PURE;
+    STDMETHOD(Tick)		(THIS_ D3DVALUE) PURE;
+
+    STDMETHOD(CreateProgressiveMesh)(THIS_ LPDIRECT3DRMPROGRESSIVEMESH *) PURE;
+};
+
+#define D3DRM_OK			DD_OK
+#define D3DRMERR_BADOBJECT		MAKE_DDHRESULT(781)
+#define D3DRMERR_BADTYPE		MAKE_DDHRESULT(782)
+#define D3DRMERR_BADALLOC		MAKE_DDHRESULT(783)
+#define D3DRMERR_FACEUSED		MAKE_DDHRESULT(784)
+#define D3DRMERR_NOTFOUND		MAKE_DDHRESULT(785)
+#define D3DRMERR_NOTDONEYET		MAKE_DDHRESULT(786)
+#define D3DRMERR_FILENOTFOUND		MAKE_DDHRESULT(787)
+#define D3DRMERR_BADFILE		MAKE_DDHRESULT(788)
+#define D3DRMERR_BADDEVICE		MAKE_DDHRESULT(789)
+#define D3DRMERR_BADVALUE		MAKE_DDHRESULT(790)
+#define D3DRMERR_BADMAJORVERSION	MAKE_DDHRESULT(791)
+#define D3DRMERR_BADMINORVERSION	MAKE_DDHRESULT(792)
+#define D3DRMERR_UNABLETOEXECUTE	MAKE_DDHRESULT(793)
+#define D3DRMERR_LIBRARYNOTFOUND        MAKE_DDHRESULT(794)
+#define D3DRMERR_INVALIDLIBRARY         MAKE_DDHRESULT(795)
+#define D3DRMERR_PENDING                MAKE_DDHRESULT(796)
+#define D3DRMERR_NOTENOUGHDATA          MAKE_DDHRESULT(797)
+#define D3DRMERR_REQUESTTOOLARGE        MAKE_DDHRESULT(798)
+#define D3DRMERR_REQUESTTOOSMALL        MAKE_DDHRESULT(799)
+#define D3DRMERR_CONNECTIONLOST         MAKE_DDHRESULT(800)
+#define D3DRMERR_LOADABORTED            MAKE_DDHRESULT(801)
+#define D3DRMERR_NOINTERNET             MAKE_DDHRESULT(802)
+#define D3DRMERR_BADCACHEFILE           MAKE_DDHRESULT(803)
+#define D3DRMERR_BOXNOTSET		MAKE_DDHRESULT(804)
+#define D3DRMERR_BADPMDATA              MAKE_DDHRESULT(805)
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif /* _D3DRMAPI_H_ */
+
diff --git a/3rdparty/dx5/inc/d3drmdef.h b/3rdparty/dx5/inc/d3drmdef.h
new file mode 100644
index 00000000..aadf2644
--- /dev/null
+++ b/3rdparty/dx5/inc/d3drmdef.h
@@ -0,0 +1,472 @@
+/*==========================================================================;
+ *
+ *  Copyright (C) 1995-1997 Microsoft Corporation.  All Rights Reserved.
+ *
+ *  File:	d3drm.h
+ *  Content:	Direct3DRM include file
+ *
+ ***************************************************************************/
+
+#ifndef __D3DRMDEFS_H__
+#define __D3DRMDEFS_H__
+
+#include <stddef.h>
+#include "d3dtypes.h"
+
+#ifdef WIN32
+#define D3DRMAPI  __stdcall
+#else
+#define D3DRMAPI
+#endif
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#ifndef TRUE
+#define FALSE 0
+#define TRUE 1
+#endif
+
+typedef struct _D3DRMVECTOR4D
+{   D3DVALUE x, y, z, w;
+} D3DRMVECTOR4D, *LPD3DRMVECTOR4D;
+
+typedef D3DVALUE D3DRMMATRIX4D[4][4];
+
+typedef struct _D3DRMQUATERNION
+{   D3DVALUE s;
+    D3DVECTOR v;
+} D3DRMQUATERNION, *LPD3DRMQUATERNION;
+
+typedef struct _D3DRMRAY
+{   D3DVECTOR dvDir;
+    D3DVECTOR dvPos;
+} D3DRMRAY, *LPD3DRMRAY;
+
+typedef struct _D3DRMBOX
+{   D3DVECTOR min, max;
+} D3DRMBOX, *LPD3DRMBOX;
+
+typedef void (*D3DRMWRAPCALLBACK)
+    (LPD3DVECTOR, int* u, int* v, LPD3DVECTOR a, LPD3DVECTOR b, LPVOID);
+
+typedef enum _D3DRMLIGHTTYPE
+{   D3DRMLIGHT_AMBIENT,
+    D3DRMLIGHT_POINT,
+    D3DRMLIGHT_SPOT,
+    D3DRMLIGHT_DIRECTIONAL,
+    D3DRMLIGHT_PARALLELPOINT
+} D3DRMLIGHTTYPE, *LPD3DRMLIGHTTYPE;
+
+typedef enum _D3DRMSHADEMODE {
+    D3DRMSHADE_FLAT	= 0,
+    D3DRMSHADE_GOURAUD	= 1,
+    D3DRMSHADE_PHONG	= 2,
+
+    D3DRMSHADE_MASK	= 7,
+    D3DRMSHADE_MAX	= 8
+} D3DRMSHADEMODE, *LPD3DRMSHADEMODE;
+
+typedef enum _D3DRMLIGHTMODE {
+    D3DRMLIGHT_OFF	= 0 * D3DRMSHADE_MAX,
+    D3DRMLIGHT_ON	= 1 * D3DRMSHADE_MAX,
+
+    D3DRMLIGHT_MASK	= 7 * D3DRMSHADE_MAX,
+    D3DRMLIGHT_MAX	= 8 * D3DRMSHADE_MAX
+} D3DRMLIGHTMODE, *LPD3DRMLIGHTMODE;
+
+typedef enum _D3DRMFILLMODE {
+    D3DRMFILL_POINTS	= 0 * D3DRMLIGHT_MAX,
+    D3DRMFILL_WIREFRAME	= 1 * D3DRMLIGHT_MAX,
+    D3DRMFILL_SOLID	= 2 * D3DRMLIGHT_MAX,
+
+    D3DRMFILL_MASK	= 7 * D3DRMLIGHT_MAX,
+    D3DRMFILL_MAX	= 8 * D3DRMLIGHT_MAX
+} D3DRMFILLMODE, *LPD3DRMFILLMODE;
+
+typedef DWORD D3DRMRENDERQUALITY, *LPD3DRMRENDERQUALITY;
+
+#define D3DRMRENDER_WIREFRAME	(D3DRMSHADE_FLAT+D3DRMLIGHT_OFF+D3DRMFILL_WIREFRAME)
+#define D3DRMRENDER_UNLITFLAT	(D3DRMSHADE_FLAT+D3DRMLIGHT_OFF+D3DRMFILL_SOLID)
+#define D3DRMRENDER_FLAT	(D3DRMSHADE_FLAT+D3DRMLIGHT_ON+D3DRMFILL_SOLID)
+#define D3DRMRENDER_GOURAUD	(D3DRMSHADE_GOURAUD+D3DRMLIGHT_ON+D3DRMFILL_SOLID)
+#define D3DRMRENDER_PHONG	(D3DRMSHADE_PHONG+D3DRMLIGHT_ON+D3DRMFILL_SOLID)
+
+#define D3DRMRENDERMODE_BLENDEDTRANSPARENCY	1
+#define D3DRMRENDERMODE_SORTEDTRANSPARENCY	2
+
+typedef enum _D3DRMTEXTUREQUALITY
+{   D3DRMTEXTURE_NEAREST,		/* choose nearest texel */
+    D3DRMTEXTURE_LINEAR,		/* interpolate 4 texels */
+    D3DRMTEXTURE_MIPNEAREST,		/* nearest texel in nearest mipmap  */
+    D3DRMTEXTURE_MIPLINEAR,		/* interpolate 2 texels from 2 mipmaps */
+    D3DRMTEXTURE_LINEARMIPNEAREST,	/* interpolate 4 texels in nearest mipmap */
+    D3DRMTEXTURE_LINEARMIPLINEAR	/* interpolate 8 texels from 2 mipmaps */
+} D3DRMTEXTUREQUALITY, *LPD3DRMTEXTUREQUALITY;
+
+typedef enum _D3DRMCOMBINETYPE
+{   D3DRMCOMBINE_REPLACE,
+    D3DRMCOMBINE_BEFORE,
+    D3DRMCOMBINE_AFTER
+} D3DRMCOMBINETYPE, *LPD3DRMCOMBINETYPE;
+
+typedef D3DCOLORMODEL D3DRMCOLORMODEL, *LPD3DRMCOLORMODEL;
+
+typedef enum _D3DRMPALETTEFLAGS
+{   D3DRMPALETTE_FREE,			/* renderer may use this entry freely */
+    D3DRMPALETTE_READONLY,		/* fixed but may be used by renderer */
+    D3DRMPALETTE_RESERVED		/* may not be used by renderer */
+} D3DRMPALETTEFLAGS, *LPD3DRMPALETTEFLAGS;
+
+typedef struct _D3DRMPALETTEENTRY
+{   unsigned char red;		/* 0 .. 255 */
+    unsigned char green;	/* 0 .. 255 */
+    unsigned char blue;		/* 0 .. 255 */
+    unsigned char flags;	/* one of D3DRMPALETTEFLAGS */
+} D3DRMPALETTEENTRY, *LPD3DRMPALETTEENTRY;
+
+typedef struct _D3DRMIMAGE
+{   int width, height;		/* width and height in pixels */
+    int aspectx, aspecty;	/* aspect ratio for non-square pixels */
+    int depth;			/* bits per pixel */
+    int rgb;			/* if false, pixels are indices into a
+				   palette otherwise, pixels encode
+				   RGB values. */
+    int bytes_per_line;		/* number of bytes of memory for a
+				   scanline. This must be a multiple
+				   of 4. */
+    void* buffer1;		/* memory to render into (first buffer). */
+    void* buffer2;		/* second rendering buffer for double
+				   buffering, set to NULL for single
+				   buffering. */
+    unsigned long red_mask;
+    unsigned long green_mask;
+    unsigned long blue_mask;
+    unsigned long alpha_mask;	/* if rgb is true, these are masks for
+				   the red, green and blue parts of a
+				   pixel.  Otherwise, these are masks
+				   for the significant bits of the
+				   red, green and blue elements in the
+				   palette.  For instance, most SVGA
+				   displays use 64 intensities of red,
+				   green and blue, so the masks should
+				   all be set to 0xfc. */
+    int palette_size;           /* number of entries in palette */
+    D3DRMPALETTEENTRY* palette;	/* description of the palette (only if
+				   rgb is false).  Must be (1<<depth)
+				   elements. */
+} D3DRMIMAGE, *LPD3DRMIMAGE;
+
+typedef enum _D3DRMWRAPTYPE
+{   D3DRMWRAP_FLAT,
+    D3DRMWRAP_CYLINDER,
+    D3DRMWRAP_SPHERE,
+    D3DRMWRAP_CHROME
+} D3DRMWRAPTYPE, *LPD3DRMWRAPTYPE;
+
+#define D3DRMWIREFRAME_CULL		1 /* cull backfaces */
+#define D3DRMWIREFRAME_HIDDENLINE	2 /* lines are obscured by closer objects */
+
+typedef enum _D3DRMPROJECTIONTYPE
+{   D3DRMPROJECT_PERSPECTIVE,
+    D3DRMPROJECT_ORTHOGRAPHIC,
+    D3DRMPROJECT_RIGHTHANDPERSPECTIVE,
+    D3DRMPROJECT_RIGHTHANDORTHOGRAPHIC
+} D3DRMPROJECTIONTYPE, *LPD3DRMPROJECTIONTYPE;
+
+typedef enum _D3DRMXOFFORMAT
+{   D3DRMXOF_BINARY,
+    D3DRMXOF_COMPRESSED,
+    D3DRMXOF_TEXT
+} D3DRMXOFFORMAT, *LPD3DRMXOFFORMAT;
+
+typedef DWORD D3DRMSAVEOPTIONS;
+#define D3DRMXOFSAVE_NORMALS 1
+#define D3DRMXOFSAVE_TEXTURECOORDINATES 2
+#define D3DRMXOFSAVE_MATERIALS 4
+#define D3DRMXOFSAVE_TEXTURENAMES 8
+#define D3DRMXOFSAVE_ALL 15
+#define D3DRMXOFSAVE_TEMPLATES 16
+#define D3DRMXOFSAVE_TEXTURETOPOLOGY 32
+
+typedef enum _D3DRMCOLORSOURCE
+{   D3DRMCOLOR_FROMFACE,
+    D3DRMCOLOR_FROMVERTEX
+} D3DRMCOLORSOURCE, *LPD3DRMCOLORSOURCE;
+
+typedef enum _D3DRMFRAMECONSTRAINT
+{   D3DRMCONSTRAIN_Z,		/* use only X and Y rotations */
+    D3DRMCONSTRAIN_Y,		/* use only X and Z rotations */
+    D3DRMCONSTRAIN_X		/* use only Y and Z rotations */
+} D3DRMFRAMECONSTRAINT, *LPD3DRMFRAMECONSTRAINT;
+
+typedef enum _D3DRMMATERIALMODE
+{   D3DRMMATERIAL_FROMMESH,
+    D3DRMMATERIAL_FROMPARENT,
+    D3DRMMATERIAL_FROMFRAME
+} D3DRMMATERIALMODE, *LPD3DRMMATERIALMODE;
+
+typedef enum _D3DRMFOGMODE
+{   D3DRMFOG_LINEAR,		/* linear between start and end */
+    D3DRMFOG_EXPONENTIAL,	/* density * exp(-distance) */
+    D3DRMFOG_EXPONENTIALSQUARED	/* density * exp(-distance*distance) */
+} D3DRMFOGMODE, *LPD3DRMFOGMODE;
+
+typedef enum _D3DRMZBUFFERMODE {
+    D3DRMZBUFFER_FROMPARENT,	/* default */
+    D3DRMZBUFFER_ENABLE,	/* enable zbuffering */
+    D3DRMZBUFFER_DISABLE	/* disable zbuffering */
+} D3DRMZBUFFERMODE, *LPD3DRMZBUFFERMODE;
+
+typedef enum _D3DRMSORTMODE {
+    D3DRMSORT_FROMPARENT,	/* default */
+    D3DRMSORT_NONE,		/* don't sort child frames */
+    D3DRMSORT_FRONTTOBACK,	/* sort child frames front-to-back */
+    D3DRMSORT_BACKTOFRONT	/* sort child frames back-to-front */
+} D3DRMSORTMODE, *LPD3DRMSORTMODE;
+
+/*
+ * Values for flags in Frame2::AddMoveCallback.
+ */
+#define D3DRMCALLBACK_PREORDER		0
+#define D3DRMCALLBACK_POSTORDER		1
+
+/*
+ * Values for flags in MeshBuilder2::RayPick.
+ */
+#define D3DRMRAYPICK_ONLYBOUNDINGBOXES		1
+#define D3DRMRAYPICK_IGNOREFURTHERPRIMITIVES	2
+#define D3DRMRAYPICK_INTERPOLATEUV		4
+#define D3DRMRAYPICK_INTERPOLATECOLOR		8
+#define D3DRMRAYPICK_INTERPOLATENORMAL		0x10	
+
+/*
+ * Values for flags in MeshBuilder2::GenerateNormals.
+ */
+#define D3DRMGENERATENORMALS_PRECOMPACT		1
+#define D3DRMGENERATENORMALS_USECREASEANGLE	2
+
+typedef DWORD D3DRMANIMATIONOPTIONS;
+#define D3DRMANIMATION_OPEN 0x01L
+#define D3DRMANIMATION_CLOSED 0x02L
+#define D3DRMANIMATION_LINEARPOSITION 0x04L
+#define D3DRMANIMATION_SPLINEPOSITION 0x08L
+#define D3DRMANIMATION_SCALEANDROTATION 0x00000010L
+#define D3DRMANIMATION_POSITION 0x00000020L
+
+typedef DWORD D3DRMINTERPOLATIONOPTIONS;
+#define D3DRMINTERPOLATION_OPEN 0x01L
+#define D3DRMINTERPOLATION_CLOSED 0x02L
+#define D3DRMINTERPOLATION_NEAREST 0x0100L
+#define D3DRMINTERPOLATION_LINEAR 0x04L
+#define D3DRMINTERPOLATION_SPLINE 0x08L
+#define D3DRMINTERPOLATION_VERTEXCOLOR 0x40L
+#define D3DRMINTERPOLATION_SLERPNORMALS 0x80L
+
+typedef DWORD D3DRMLOADOPTIONS;
+
+#define D3DRMLOAD_FROMFILE  0x00L
+#define D3DRMLOAD_FROMRESOURCE 0x01L
+#define D3DRMLOAD_FROMMEMORY 0x02L
+#define D3DRMLOAD_FROMSTREAM 0x04L
+#define D3DRMLOAD_FROMURL 0x08L
+
+#define D3DRMLOAD_BYNAME 0x10L
+#define D3DRMLOAD_BYPOSITION 0x20L
+#define D3DRMLOAD_BYGUID 0x40L
+#define D3DRMLOAD_FIRST 0x80L
+
+#define D3DRMLOAD_INSTANCEBYREFERENCE 0x100L
+#define D3DRMLOAD_INSTANCEBYCOPYING 0x200L
+
+#define D3DRMLOAD_ASYNCHRONOUS 0x400L
+
+typedef struct _D3DRMLOADRESOURCE {
+  HMODULE hModule;
+  LPCTSTR lpName;
+  LPCTSTR lpType;
+} D3DRMLOADRESOURCE, *LPD3DRMLOADRESOURCE;
+
+typedef struct _D3DRMLOADMEMORY {
+  LPVOID lpMemory;
+  DWORD dSize;
+} D3DRMLOADMEMORY, *LPD3DRMLOADMEMORY;
+
+#define D3DRMPMESHSTATUS_VALID 0x01L
+#define D3DRMPMESHSTATUS_INTERRUPTED 0x02L
+#define D3DRMPMESHSTATUS_BASEMESHCOMPLETE 0x04L
+#define D3DRMPMESHSTATUS_COMPLETE 0x08L
+#define D3DRMPMESHSTATUS_RENDERABLE 0x10L
+
+#define D3DRMPMESHEVENT_BASEMESH 0x01L
+#define D3DRMPMESHEVENT_COMPLETE 0x02L
+
+typedef struct _D3DRMPMESHLOADSTATUS {
+  DWORD dwSize;            // Size of this structure
+  DWORD dwPMeshSize;       // Total Size (bytes)
+  DWORD dwBaseMeshSize;    // Total Size of the Base Mesh
+  DWORD dwBytesLoaded;     // Total bytes loaded
+  DWORD dwVerticesLoaded;  // Number of vertices loaded
+  DWORD dwFacesLoaded;     // Number of faces loaded
+  HRESULT dwLoadResult;    // Result of the load operation
+  DWORD dwFlags;
+} D3DRMPMESHLOADSTATUS, *LPD3DRMPMESHLOADSTATUS;
+
+typedef enum _D3DRMUSERVISUALREASON {
+    D3DRMUSERVISUAL_CANSEE,
+    D3DRMUSERVISUAL_RENDER
+} D3DRMUSERVISUALREASON, *LPD3DRMUSERVISUALREASON;
+
+
+typedef DWORD D3DRMMAPPING, D3DRMMAPPINGFLAG, *LPD3DRMMAPPING;
+static const D3DRMMAPPINGFLAG D3DRMMAP_WRAPU = 1;
+static const D3DRMMAPPINGFLAG D3DRMMAP_WRAPV = 2;
+static const D3DRMMAPPINGFLAG D3DRMMAP_PERSPCORRECT = 4;
+
+typedef struct _D3DRMVERTEX
+{   D3DVECTOR	    position;
+    D3DVECTOR	    normal;
+    D3DVALUE	    tu, tv;
+    D3DCOLOR	    color;
+} D3DRMVERTEX, *LPD3DRMVERTEX;
+
+typedef LONG D3DRMGROUPINDEX; /* group indexes begin a 0 */
+static const D3DRMGROUPINDEX D3DRMGROUP_ALLGROUPS = -1;
+
+/*
+ * Create a color from three components in the range 0-1 inclusive.
+ */
+extern D3DCOLOR D3DRMAPI	D3DRMCreateColorRGB(D3DVALUE red,
+					  D3DVALUE green,
+					  D3DVALUE blue);
+
+/*
+ * Create a color from four components in the range 0-1 inclusive.
+ */
+extern D3DCOLOR D3DRMAPI	D3DRMCreateColorRGBA(D3DVALUE red,
+						 D3DVALUE green,
+						 D3DVALUE blue,
+						 D3DVALUE alpha);
+
+/*
+ * Get the red component of a color.
+ */
+extern D3DVALUE 		D3DRMAPI D3DRMColorGetRed(D3DCOLOR);
+
+/*
+ * Get the green component of a color.
+ */
+extern D3DVALUE 		D3DRMAPI D3DRMColorGetGreen(D3DCOLOR);
+
+/*
+ * Get the blue component of a color.
+ */
+extern D3DVALUE 		D3DRMAPI D3DRMColorGetBlue(D3DCOLOR);
+
+/*
+ * Get the alpha component of a color.
+ */
+extern D3DVALUE 		D3DRMAPI D3DRMColorGetAlpha(D3DCOLOR);
+
+/*
+ * Add two vectors.  Returns its first argument.
+ */
+extern LPD3DVECTOR 	D3DRMAPI D3DRMVectorAdd(LPD3DVECTOR d,
+					  LPD3DVECTOR s1,
+					  LPD3DVECTOR s2);
+
+/*
+ * Subtract two vectors.  Returns its first argument.
+ */
+extern LPD3DVECTOR 	D3DRMAPI D3DRMVectorSubtract(LPD3DVECTOR d,
+					       LPD3DVECTOR s1,
+					       LPD3DVECTOR s2);
+/*
+ * Reflect a ray about a given normal.  Returns its first argument.
+ */
+extern LPD3DVECTOR 	D3DRMAPI D3DRMVectorReflect(LPD3DVECTOR d,
+					      LPD3DVECTOR ray,
+					      LPD3DVECTOR norm);
+
+/*
+ * Calculate the vector cross product.  Returns its first argument.
+ */
+extern LPD3DVECTOR 	D3DRMAPI D3DRMVectorCrossProduct(LPD3DVECTOR d,
+						   LPD3DVECTOR s1,
+						   LPD3DVECTOR s2);
+/*
+ * Return the vector dot product.
+ */
+extern D3DVALUE 		D3DRMAPI D3DRMVectorDotProduct(LPD3DVECTOR s1,
+						 LPD3DVECTOR s2);
+
+/*
+ * Scale a vector so that its modulus is 1.  Returns its argument or
+ * NULL if there was an error (e.g. a zero vector was passed).
+ */
+extern LPD3DVECTOR 	D3DRMAPI D3DRMVectorNormalize(LPD3DVECTOR);
+#define D3DRMVectorNormalise D3DRMVectorNormalize
+
+/*
+ * Return the length of a vector (e.g. sqrt(x*x + y*y + z*z)).
+ */
+extern D3DVALUE 		D3DRMAPI D3DRMVectorModulus(LPD3DVECTOR v);
+
+/*
+ * Set the rotation part of a matrix to be a rotation of theta radians
+ * around the given axis.
+ */
+
+extern LPD3DVECTOR 	D3DRMAPI D3DRMVectorRotate(LPD3DVECTOR r, LPD3DVECTOR v, LPD3DVECTOR axis, D3DVALUE theta);
+
+/*
+ * Scale a vector uniformly in all three axes
+ */
+extern LPD3DVECTOR	D3DRMAPI D3DRMVectorScale(LPD3DVECTOR d, LPD3DVECTOR s, D3DVALUE factor);
+
+/*
+ * Return a random unit vector
+ */
+extern LPD3DVECTOR	D3DRMAPI D3DRMVectorRandom(LPD3DVECTOR d);
+
+/*
+ * Returns a unit quaternion that represents a rotation of theta radians
+ * around the given axis.
+ */
+
+extern LPD3DRMQUATERNION D3DRMAPI D3DRMQuaternionFromRotation(LPD3DRMQUATERNION quat,
+							      LPD3DVECTOR v,
+							      D3DVALUE theta);
+
+/*
+ * Calculate the product of two quaternions
+ */
+extern LPD3DRMQUATERNION D3DRMAPI D3DRMQuaternionMultiply(LPD3DRMQUATERNION q,
+						    	  LPD3DRMQUATERNION a,
+						   	  LPD3DRMQUATERNION b);
+
+/*
+ * Interpolate between two quaternions
+ */
+extern LPD3DRMQUATERNION D3DRMAPI D3DRMQuaternionSlerp(LPD3DRMQUATERNION q,
+						       LPD3DRMQUATERNION a,
+						       LPD3DRMQUATERNION b,
+						       D3DVALUE alpha);
+
+/*
+ * Calculate the matrix for the rotation that a unit quaternion represents
+ */
+extern void 		D3DRMAPI D3DRMMatrixFromQuaternion(D3DRMMATRIX4D dmMat, LPD3DRMQUATERNION lpDqQuat);
+
+/*
+ * Calculate the quaternion that corresponds to a rotation matrix
+ */
+extern LPD3DRMQUATERNION D3DRMAPI D3DRMQuaternionFromMatrix(LPD3DRMQUATERNION, D3DRMMATRIX4D);
+
+
+#if defined(__cplusplus)
+};
+#endif
+
+#endif
diff --git a/3rdparty/dx5/inc/d3drmobj.h b/3rdparty/dx5/inc/d3drmobj.h
new file mode 100644
index 00000000..4ac858fb
--- /dev/null
+++ b/3rdparty/dx5/inc/d3drmobj.h
@@ -0,0 +1,1100 @@
+/*==========================================================================;
+ *
+ *  Copyright (C) 1995-1997 Microsoft Corporation.  All Rights Reserved.
+ *
+ *  File:	d3drm.h
+ *  Content:	Direct3DRM include file
+ *
+ ***************************************************************************/
+
+#ifndef _D3DRMOBJ_H_
+#define _D3DRMOBJ_H_
+
+#include <objbase.h> /* Use Windows header files */
+#define VIRTUAL
+
+#include "d3drmdef.h"
+#include "d3d.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * The methods for IUnknown
+ */
+#define IUNKNOWN_METHODS(kind) \
+    STDMETHOD(QueryInterface)	   	(THIS_ REFIID riid, LPVOID *ppvObj) kind; \
+    STDMETHOD_(ULONG, AddRef)	   	(THIS) kind; \
+    STDMETHOD_(ULONG, Release)	   	(THIS) kind
+
+/*
+ * The methods for IDirect3DRMObject
+ */
+#define IDIRECT3DRMOBJECT_METHODS(kind) \
+    STDMETHOD(Clone)			(THIS_ LPUNKNOWN pUnkOuter, REFIID riid, LPVOID *ppvObj) kind; \
+    STDMETHOD(AddDestroyCallback)  	(THIS_ D3DRMOBJECTCALLBACK, LPVOID argument) kind; \
+    STDMETHOD(DeleteDestroyCallback)	(THIS_ D3DRMOBJECTCALLBACK, LPVOID argument) kind; \
+    STDMETHOD(SetAppData)	   	(THIS_ DWORD data) kind; \
+    STDMETHOD_(DWORD, GetAppData)  	(THIS) kind; \
+    STDMETHOD(SetName)		   	(THIS_ LPCSTR) kind; \
+    STDMETHOD(GetName)			(THIS_ LPDWORD lpdwSize, LPSTR lpName) kind; \
+    STDMETHOD(GetClassName)		(THIS_ LPDWORD lpdwSize, LPSTR lpName) kind
+
+
+#define WIN_TYPES(itype, ptype) \
+    typedef interface itype FAR *LP##ptype, FAR **LPLP##ptype
+
+WIN_TYPES(IDirect3DRMObject, DIRECT3DRMOBJECT);
+WIN_TYPES(IDirect3DRMDevice, DIRECT3DRMDEVICE);
+WIN_TYPES(IDirect3DRMDevice2, DIRECT3DRMDEVICE2);
+WIN_TYPES(IDirect3DRMViewport, DIRECT3DRMVIEWPORT);
+WIN_TYPES(IDirect3DRMFrame, DIRECT3DRMFRAME);
+WIN_TYPES(IDirect3DRMFrame2, DIRECT3DRMFRAME2);
+WIN_TYPES(IDirect3DRMVisual, DIRECT3DRMVISUAL);
+WIN_TYPES(IDirect3DRMMesh, DIRECT3DRMMESH);
+WIN_TYPES(IDirect3DRMMeshBuilder, DIRECT3DRMMESHBUILDER);
+WIN_TYPES(IDirect3DRMMeshBuilder2, DIRECT3DRMMESHBUILDER2);
+WIN_TYPES(IDirect3DRMFace, DIRECT3DRMFACE);
+WIN_TYPES(IDirect3DRMLight, DIRECT3DRMLIGHT);
+WIN_TYPES(IDirect3DRMTexture, DIRECT3DRMTEXTURE);
+WIN_TYPES(IDirect3DRMTexture2, DIRECT3DRMTEXTURE2);
+WIN_TYPES(IDirect3DRMWrap, DIRECT3DRMWRAP);
+WIN_TYPES(IDirect3DRMMaterial, DIRECT3DRMMATERIAL);
+WIN_TYPES(IDirect3DRMInterpolator, DIRECT3DRMINTERPOLATOR);
+WIN_TYPES(IDirect3DRMAnimation, DIRECT3DRMANIMATION);
+WIN_TYPES(IDirect3DRMAnimationSet, DIRECT3DRMANIMATIONSET);
+WIN_TYPES(IDirect3DRMUserVisual, DIRECT3DRMUSERVISUAL);
+WIN_TYPES(IDirect3DRMShadow, DIRECT3DRMSHADOW);
+WIN_TYPES(IDirect3DRMArray, DIRECT3DRMARRAY);
+WIN_TYPES(IDirect3DRMObjectArray, DIRECT3DRMOBJECTARRAY);
+WIN_TYPES(IDirect3DRMDeviceArray, DIRECT3DRMDEVICEARRAY);
+WIN_TYPES(IDirect3DRMFaceArray, DIRECT3DRMFACEARRAY);
+WIN_TYPES(IDirect3DRMViewportArray, DIRECT3DRMVIEWPORTARRAY);
+WIN_TYPES(IDirect3DRMFrameArray, DIRECT3DRMFRAMEARRAY);
+WIN_TYPES(IDirect3DRMVisualArray, DIRECT3DRMVISUALARRAY);
+WIN_TYPES(IDirect3DRMPickedArray, DIRECT3DRMPICKEDARRAY);
+WIN_TYPES(IDirect3DRMPicked2Array, DIRECT3DRMPICKED2ARRAY);
+WIN_TYPES(IDirect3DRMLightArray, DIRECT3DRMLIGHTARRAY);
+WIN_TYPES(IDirect3DRMProgressiveMesh, DIRECT3DRMPROGRESSIVEMESH);
+
+/*
+ * Direct3DRM Object classes
+ */
+DEFINE_GUID(CLSID_CDirect3DRMDevice,	    0x4fa3568e, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(CLSID_CDirect3DRMViewport,	    0x4fa3568f, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(CLSID_CDirect3DRMFrame,	    0x4fa35690, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(CLSID_CDirect3DRMMesh,	    0x4fa35691, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(CLSID_CDirect3DRMMeshBuilder,   0x4fa35692, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(CLSID_CDirect3DRMFace,	    0x4fa35693, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(CLSID_CDirect3DRMLight,	    0x4fa35694, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(CLSID_CDirect3DRMTexture,	    0x4fa35695, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(CLSID_CDirect3DRMWrap,	    0x4fa35696, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(CLSID_CDirect3DRMMaterial,	    0x4fa35697, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(CLSID_CDirect3DRMAnimation,	    0x4fa35698, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(CLSID_CDirect3DRMAnimationSet,  0x4fa35699, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(CLSID_CDirect3DRMUserVisual,    0x4fa3569a, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(CLSID_CDirect3DRMShadow,	    0x4fa3569b, 0x623f, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(CLSID_CDirect3DRMViewportInterpolator, 
+0xde9eaa1, 0x3b84, 0x11d0, 0x9b, 0x6d, 0x0, 0x0, 0xc0, 0x78, 0x1b, 0xc3);
+DEFINE_GUID(CLSID_CDirect3DRMFrameInterpolator, 
+0xde9eaa2, 0x3b84, 0x11d0, 0x9b, 0x6d, 0x0, 0x0, 0xc0, 0x78, 0x1b, 0xc3);
+DEFINE_GUID(CLSID_CDirect3DRMMeshInterpolator, 
+0xde9eaa3, 0x3b84, 0x11d0, 0x9b, 0x6d, 0x0, 0x0, 0xc0, 0x78, 0x1b, 0xc3);
+DEFINE_GUID(CLSID_CDirect3DRMLightInterpolator, 
+0xde9eaa6, 0x3b84, 0x11d0, 0x9b, 0x6d, 0x0, 0x0, 0xc0, 0x78, 0x1b, 0xc3);
+DEFINE_GUID(CLSID_CDirect3DRMMaterialInterpolator, 
+0xde9eaa7, 0x3b84, 0x11d0, 0x9b, 0x6d, 0x0, 0x0, 0xc0, 0x78, 0x1b, 0xc3);
+DEFINE_GUID(CLSID_CDirect3DRMTextureInterpolator, 
+0xde9eaa8, 0x3b84, 0x11d0, 0x9b, 0x6d, 0x0, 0x0, 0xc0, 0x78, 0x1b, 0xc3);
+DEFINE_GUID(CLSID_CDirect3DRMProgressiveMesh, 0x4516ec40, 0x8f20, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3);
+
+
+/*
+ * Direct3DRM Object interfaces
+ */
+DEFINE_GUID(IID_IDirect3DRMObject, 	    0xeb16cb00, 0xd271, 0x11ce, 0xac, 0x48, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(IID_IDirect3DRMDevice, 	    0xe9e19280, 0x6e05, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(IID_IDirect3DRMDevice2,	    0x4516ec78, 0x8f20, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3);
+DEFINE_GUID(IID_IDirect3DRMViewport, 	    0xeb16cb02, 0xd271, 0x11ce, 0xac, 0x48, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(IID_IDirect3DRMFrame, 	    0xeb16cb03, 0xd271, 0x11ce, 0xac, 0x48, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(IID_IDirect3DRMFrame2,	    0xc3dfbd60, 0x3988, 0x11d0, 0x9e, 0xc2, 0x0, 0x0, 0xc0, 0x29, 0x1a, 0xc3);
+DEFINE_GUID(IID_IDirect3DRMVisual, 	    0xeb16cb04, 0xd271, 0x11ce, 0xac, 0x48, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(IID_IDirect3DRMMesh, 	    0xa3a80d01, 0x6e12, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(IID_IDirect3DRMMeshBuilder,	    0xa3a80d02, 0x6e12, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(IID_IDirect3DRMMeshBuilder2,    0x4516ec77, 0x8f20, 0x11d0, 0x9b, 0x6d, 0x0, 0x0, 0xc0, 0x78, 0x1b, 0xc3);
+DEFINE_GUID(IID_IDirect3DRMFace, 	    0xeb16cb07, 0xd271, 0x11ce, 0xac, 0x48, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(IID_IDirect3DRMLight, 	    0xeb16cb08, 0xd271, 0x11ce, 0xac, 0x48, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(IID_IDirect3DRMTexture, 	    0xeb16cb09, 0xd271, 0x11ce, 0xac, 0x48, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(IID_IDirect3DRMTexture2,        0x120f30c0, 0x1629, 0x11d0, 0x94, 0x1c, 0x0, 0x80, 0xc8, 0xc, 0xfa, 0x7b);
+DEFINE_GUID(IID_IDirect3DRMWrap, 	    0xeb16cb0a, 0xd271, 0x11ce, 0xac, 0x48, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(IID_IDirect3DRMMaterial, 	    0xeb16cb0b, 0xd271, 0x11ce, 0xac, 0x48, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(IID_IDirect3DRMAnimation, 	    0xeb16cb0d, 0xd271, 0x11ce, 0xac, 0x48, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(IID_IDirect3DRMAnimationSet,    0xeb16cb0e, 0xd271, 0x11ce, 0xac, 0x48, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(IID_IDirect3DRMObjectArray,	    0x242f6bc2, 0x3849, 0x11d0, 0x9b, 0x6d, 0x0, 0x0, 0xc0, 0x78, 0x1b, 0xc3);
+DEFINE_GUID(IID_IDirect3DRMDeviceArray,	    0xeb16cb10, 0xd271, 0x11ce, 0xac, 0x48, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(IID_IDirect3DRMViewportArray,   0xeb16cb11, 0xd271, 0x11ce, 0xac, 0x48, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(IID_IDirect3DRMFrameArray, 	    0xeb16cb12, 0xd271, 0x11ce, 0xac, 0x48, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(IID_IDirect3DRMVisualArray,	    0xeb16cb13, 0xd271, 0x11ce, 0xac, 0x48, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(IID_IDirect3DRMLightArray, 	    0xeb16cb14, 0xd271, 0x11ce, 0xac, 0x48, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(IID_IDirect3DRMPickedArray,	    0xeb16cb16, 0xd271, 0x11ce, 0xac, 0x48, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(IID_IDirect3DRMFaceArray,	    0xeb16cb17, 0xd271, 0x11ce, 0xac, 0x48, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(IID_IDirect3DRMUserVisual,	    0x59163de0, 0x6d43, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(IID_IDirect3DRMShadow,	    0xaf359780, 0x6ba3, 0x11cf, 0xac, 0x4a, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+DEFINE_GUID(IID_IDirect3DRMInterpolator,    0x242f6bc1, 0x3849, 0x11d0, 0x9b, 0x6d, 0x0, 0x0, 0xc0, 0x78, 0x1b, 0xc3);
+DEFINE_GUID(IID_IDirect3DRMProgressiveMesh, 0x4516ec79, 0x8f20, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3);
+DEFINE_GUID(IID_IDirect3DRMPicked2Array,    0x4516ec7b, 0x8f20, 0x11d0, 0x9b, 0x6d, 0x00, 0x00, 0xc0, 0x78, 0x1b, 0xc3);
+
+
+typedef void (CDECL *D3DRMOBJECTCALLBACK)(LPDIRECT3DRMOBJECT obj, LPVOID arg);
+typedef void (CDECL *D3DRMFRAMEMOVECALLBACK)(LPDIRECT3DRMFRAME obj, LPVOID arg, D3DVALUE delta);
+typedef void (CDECL *D3DRMUPDATECALLBACK)(LPDIRECT3DRMDEVICE obj, LPVOID arg, int, LPD3DRECT);
+typedef int (CDECL *D3DRMUSERVISUALCALLBACK)
+    (   LPDIRECT3DRMUSERVISUAL obj, LPVOID arg,	D3DRMUSERVISUALREASON reason,
+        LPDIRECT3DRMDEVICE dev, LPDIRECT3DRMVIEWPORT view
+    );
+typedef HRESULT (CDECL *D3DRMLOADTEXTURECALLBACK)
+    (char *tex_name, void *arg, LPDIRECT3DRMTEXTURE *);
+typedef void (CDECL *D3DRMLOADCALLBACK)
+    (LPDIRECT3DRMOBJECT object, REFIID objectguid, LPVOID arg);
+
+
+typedef struct _D3DRMPICKDESC
+{
+    ULONG	ulFaceIdx;
+    LONG	lGroupIdx;
+    D3DVECTOR	vPosition;
+
+} D3DRMPICKDESC, *LPD3DRMPICKDESC;
+
+typedef struct _D3DRMPICKDESC2
+{
+    ULONG	ulFaceIdx;
+    LONG	lGroupIdx;
+    D3DVECTOR	dvPosition;
+    D3DVALUE	tu;
+    D3DVALUE	tv;
+    D3DVECTOR	dvNormal;
+    D3DCOLOR	dcColor;
+
+} D3DRMPICKDESC2, *LPD3DRMPICKDESC2;
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMObject
+
+/*
+ * Base class
+ */
+DECLARE_INTERFACE_(IDirect3DRMObject, IUnknown)
+{
+    IUNKNOWN_METHODS(PURE);
+    IDIRECT3DRMOBJECT_METHODS(PURE);
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMVisual
+
+DECLARE_INTERFACE_(IDirect3DRMVisual, IDirect3DRMObject)
+{
+    IUNKNOWN_METHODS(PURE);
+    IDIRECT3DRMOBJECT_METHODS(PURE);
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMDevice
+
+DECLARE_INTERFACE_(IDirect3DRMDevice, IDirect3DRMObject)
+{
+    IUNKNOWN_METHODS(PURE);
+    IDIRECT3DRMOBJECT_METHODS(PURE);
+
+    /*
+     * IDirect3DRMDevice methods
+     */
+    STDMETHOD(Init)(THIS_ ULONG width, ULONG height) PURE;
+    STDMETHOD(InitFromD3D)(THIS_ LPDIRECT3D lpD3D, LPDIRECT3DDEVICE lpD3DDev) PURE;
+    STDMETHOD(InitFromClipper)(THIS_ LPDIRECTDRAWCLIPPER lpDDClipper, LPGUID lpGUID, int width, int height) PURE;
+
+    STDMETHOD(Update)(THIS) PURE;
+    STDMETHOD(AddUpdateCallback)(THIS_ D3DRMUPDATECALLBACK, LPVOID arg) PURE;
+    STDMETHOD(DeleteUpdateCallback)(THIS_ D3DRMUPDATECALLBACK, LPVOID arg) PURE;
+    STDMETHOD(SetBufferCount)(THIS_ DWORD) PURE;
+    STDMETHOD_(DWORD, GetBufferCount)(THIS) PURE;
+
+    STDMETHOD(SetDither)(THIS_ BOOL) PURE;
+    STDMETHOD(SetShades)(THIS_ DWORD) PURE;
+    STDMETHOD(SetQuality)(THIS_ D3DRMRENDERQUALITY) PURE;
+    STDMETHOD(SetTextureQuality)(THIS_ D3DRMTEXTUREQUALITY) PURE;
+
+    STDMETHOD(GetViewports)(THIS_ LPDIRECT3DRMVIEWPORTARRAY *return_views) PURE;
+
+    STDMETHOD_(BOOL, GetDither)(THIS) PURE;
+    STDMETHOD_(DWORD, GetShades)(THIS) PURE;
+    STDMETHOD_(DWORD, GetHeight)(THIS) PURE;
+    STDMETHOD_(DWORD, GetWidth)(THIS) PURE;
+    STDMETHOD_(DWORD, GetTrianglesDrawn)(THIS) PURE;
+    STDMETHOD_(DWORD, GetWireframeOptions)(THIS) PURE;
+    STDMETHOD_(D3DRMRENDERQUALITY, GetQuality)(THIS) PURE;
+    STDMETHOD_(D3DCOLORMODEL, GetColorModel)(THIS) PURE;
+    STDMETHOD_(D3DRMTEXTUREQUALITY, GetTextureQuality)(THIS) PURE;
+    STDMETHOD(GetDirect3DDevice)(THIS_ LPDIRECT3DDEVICE *) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMDevice2
+
+DECLARE_INTERFACE_(IDirect3DRMDevice2, IDirect3DRMDevice)
+{
+    IUNKNOWN_METHODS(PURE);
+    IDIRECT3DRMOBJECT_METHODS(PURE);
+
+    /*
+     * IDirect3DRMDevice methods
+     */
+    STDMETHOD(Init)(THIS_ ULONG width, ULONG height) PURE;
+    STDMETHOD(InitFromD3D)(THIS_ LPDIRECT3D lpD3D, LPDIRECT3DDEVICE lpD3DDev) PURE;
+    STDMETHOD(InitFromClipper)(THIS_ LPDIRECTDRAWCLIPPER lpDDClipper, LPGUID lpGUID, int width, int height) PURE;
+
+    STDMETHOD(Update)(THIS) PURE;
+    STDMETHOD(AddUpdateCallback)(THIS_ D3DRMUPDATECALLBACK, LPVOID arg) PURE;
+    STDMETHOD(DeleteUpdateCallback)(THIS_ D3DRMUPDATECALLBACK, LPVOID arg) PURE;
+    STDMETHOD(SetBufferCount)(THIS_ DWORD) PURE;
+    STDMETHOD_(DWORD, GetBufferCount)(THIS) PURE;
+
+    STDMETHOD(SetDither)(THIS_ BOOL) PURE;
+    STDMETHOD(SetShades)(THIS_ DWORD) PURE;
+    STDMETHOD(SetQuality)(THIS_ D3DRMRENDERQUALITY) PURE;
+    STDMETHOD(SetTextureQuality)(THIS_ D3DRMTEXTUREQUALITY) PURE;
+
+    STDMETHOD(GetViewports)(THIS_ LPDIRECT3DRMVIEWPORTARRAY *return_views) PURE;
+
+    STDMETHOD_(BOOL, GetDither)(THIS) PURE;
+    STDMETHOD_(DWORD, GetShades)(THIS) PURE;
+    STDMETHOD_(DWORD, GetHeight)(THIS) PURE;
+    STDMETHOD_(DWORD, GetWidth)(THIS) PURE;
+    STDMETHOD_(DWORD, GetTrianglesDrawn)(THIS) PURE;
+    STDMETHOD_(DWORD, GetWireframeOptions)(THIS) PURE;
+    STDMETHOD_(D3DRMRENDERQUALITY, GetQuality)(THIS) PURE;
+    STDMETHOD_(D3DCOLORMODEL, GetColorModel)(THIS) PURE;
+    STDMETHOD_(D3DRMTEXTUREQUALITY, GetTextureQuality)(THIS) PURE;
+    STDMETHOD(GetDirect3DDevice)(THIS_ LPDIRECT3DDEVICE *) PURE;
+
+    /*
+     * IDirect3DRMDevice2 methods
+     */
+    STDMETHOD(InitFromD3D2)(THIS_ LPDIRECT3D2 lpD3D, LPDIRECT3DDEVICE2 lpD3DDev) PURE;
+    STDMETHOD(InitFromSurface)(THIS_ LPGUID lpGUID, LPDIRECTDRAW lpDD, LPDIRECTDRAWSURFACE lpDDSBack) PURE;
+    STDMETHOD(SetRenderMode)(THIS_ DWORD dwFlags) PURE;
+    STDMETHOD_(DWORD, GetRenderMode)(THIS) PURE;
+    STDMETHOD(GetDirect3DDevice2)(THIS_ LPDIRECT3DDEVICE2 *) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMViewport
+
+DECLARE_INTERFACE_(IDirect3DRMViewport, IDirect3DRMObject)
+{
+    IUNKNOWN_METHODS(PURE);
+    IDIRECT3DRMOBJECT_METHODS(PURE);
+
+    /*
+     * IDirect3DRMViewport methods
+     */
+    STDMETHOD(Init)
+    (	THIS_ LPDIRECT3DRMDEVICE dev, LPDIRECT3DRMFRAME camera,
+	DWORD xpos, DWORD ypos, DWORD width, DWORD height
+    ) PURE;
+    STDMETHOD(Clear)(THIS) PURE;
+    STDMETHOD(Render)(THIS_ LPDIRECT3DRMFRAME) PURE;
+
+    STDMETHOD(SetFront)(THIS_ D3DVALUE) PURE;
+    STDMETHOD(SetBack)(THIS_ D3DVALUE) PURE;
+    STDMETHOD(SetField)(THIS_ D3DVALUE) PURE;
+    STDMETHOD(SetUniformScaling)(THIS_ BOOL) PURE;
+    STDMETHOD(SetCamera)(THIS_ LPDIRECT3DRMFRAME) PURE;
+    STDMETHOD(SetProjection)(THIS_ D3DRMPROJECTIONTYPE) PURE;
+    STDMETHOD(Transform)(THIS_ D3DRMVECTOR4D *d, D3DVECTOR *s) PURE;
+    STDMETHOD(InverseTransform)(THIS_ D3DVECTOR *d, D3DRMVECTOR4D *s) PURE;
+    STDMETHOD(Configure)(THIS_ LONG x, LONG y, DWORD width, DWORD height) PURE;
+    STDMETHOD(ForceUpdate)(THIS_ DWORD x1, DWORD y1, DWORD x2, DWORD y2) PURE;
+    STDMETHOD(SetPlane)(THIS_ D3DVALUE left, D3DVALUE right, D3DVALUE bottom, D3DVALUE top) PURE;
+
+    STDMETHOD(GetCamera)(THIS_ LPDIRECT3DRMFRAME *) PURE;
+    STDMETHOD(GetDevice)(THIS_ LPDIRECT3DRMDEVICE *) PURE;
+    STDMETHOD(GetPlane)(THIS_ D3DVALUE *left, D3DVALUE *right, D3DVALUE *bottom, D3DVALUE *top) PURE;
+    STDMETHOD(Pick)(THIS_ LONG x, LONG y, LPDIRECT3DRMPICKEDARRAY *return_visuals) PURE;
+
+    STDMETHOD_(BOOL, GetUniformScaling)(THIS) PURE;
+    STDMETHOD_(LONG, GetX)(THIS) PURE;
+    STDMETHOD_(LONG, GetY)(THIS) PURE;
+    STDMETHOD_(DWORD, GetWidth)(THIS) PURE;
+    STDMETHOD_(DWORD, GetHeight)(THIS) PURE;
+    STDMETHOD_(D3DVALUE, GetField)(THIS) PURE;
+    STDMETHOD_(D3DVALUE, GetBack)(THIS) PURE;
+    STDMETHOD_(D3DVALUE, GetFront)(THIS) PURE;
+    STDMETHOD_(D3DRMPROJECTIONTYPE, GetProjection)(THIS) PURE;
+    STDMETHOD(GetDirect3DViewport)(THIS_ LPDIRECT3DVIEWPORT *) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMFrame
+
+DECLARE_INTERFACE_(IDirect3DRMFrame, IDirect3DRMVisual)
+{
+    IUNKNOWN_METHODS(PURE);
+    IDIRECT3DRMOBJECT_METHODS(PURE);
+
+    /*
+     * IDirect3DRMFrame methods
+     */
+    STDMETHOD(AddChild)(THIS_ LPDIRECT3DRMFRAME child) PURE;
+    STDMETHOD(AddLight)(THIS_ LPDIRECT3DRMLIGHT) PURE;
+    STDMETHOD(AddMoveCallback)(THIS_ D3DRMFRAMEMOVECALLBACK, VOID *arg) PURE;
+    STDMETHOD(AddTransform)(THIS_ D3DRMCOMBINETYPE, D3DRMMATRIX4D) PURE;
+    STDMETHOD(AddTranslation)(THIS_ D3DRMCOMBINETYPE, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE;
+    STDMETHOD(AddScale)(THIS_ D3DRMCOMBINETYPE, D3DVALUE sx, D3DVALUE sy, D3DVALUE sz) PURE;
+    STDMETHOD(AddRotation)(THIS_ D3DRMCOMBINETYPE, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta) PURE;
+    STDMETHOD(AddVisual)(THIS_ LPDIRECT3DRMVISUAL) PURE;
+    STDMETHOD(GetChildren)(THIS_ LPDIRECT3DRMFRAMEARRAY *children) PURE;
+    STDMETHOD_(D3DCOLOR, GetColor)(THIS) PURE;
+    STDMETHOD(GetLights)(THIS_ LPDIRECT3DRMLIGHTARRAY *lights) PURE;
+    STDMETHOD_(D3DRMMATERIALMODE, GetMaterialMode)(THIS) PURE;
+    STDMETHOD(GetParent)(THIS_ LPDIRECT3DRMFRAME *) PURE;
+    STDMETHOD(GetPosition)(THIS_ LPDIRECT3DRMFRAME reference, LPD3DVECTOR return_position) PURE;
+    STDMETHOD(GetRotation)(THIS_ LPDIRECT3DRMFRAME reference, LPD3DVECTOR axis, LPD3DVALUE return_theta) PURE;
+    STDMETHOD(GetScene)(THIS_ LPDIRECT3DRMFRAME *) PURE;
+    STDMETHOD_(D3DRMSORTMODE, GetSortMode)(THIS) PURE;
+    STDMETHOD(GetTexture)(THIS_ LPDIRECT3DRMTEXTURE *) PURE;
+    STDMETHOD(GetTransform)(THIS_ D3DRMMATRIX4D return_matrix) PURE;
+    STDMETHOD(GetVelocity)(THIS_ LPDIRECT3DRMFRAME reference, LPD3DVECTOR return_velocity, BOOL with_rotation) PURE;
+    STDMETHOD(GetOrientation)(THIS_ LPDIRECT3DRMFRAME reference, LPD3DVECTOR dir, LPD3DVECTOR up) PURE;
+    STDMETHOD(GetVisuals)(THIS_ LPDIRECT3DRMVISUALARRAY *visuals) PURE;
+    STDMETHOD(GetTextureTopology)(THIS_ BOOL *wrap_u, BOOL *wrap_v) PURE;
+    STDMETHOD(InverseTransform)(THIS_ D3DVECTOR *d, D3DVECTOR *s) PURE;
+    STDMETHOD(Load)(THIS_ LPVOID filename, LPVOID name, D3DRMLOADOPTIONS loadflags, D3DRMLOADTEXTURECALLBACK, LPVOID lpArg)PURE;
+    STDMETHOD(LookAt)(THIS_ LPDIRECT3DRMFRAME target, LPDIRECT3DRMFRAME reference, D3DRMFRAMECONSTRAINT) PURE;
+    STDMETHOD(Move)(THIS_ D3DVALUE delta) PURE;
+    STDMETHOD(DeleteChild)(THIS_ LPDIRECT3DRMFRAME) PURE;
+    STDMETHOD(DeleteLight)(THIS_ LPDIRECT3DRMLIGHT) PURE;
+    STDMETHOD(DeleteMoveCallback)(THIS_ D3DRMFRAMEMOVECALLBACK, VOID *arg) PURE;
+    STDMETHOD(DeleteVisual)(THIS_ LPDIRECT3DRMVISUAL) PURE;
+    STDMETHOD_(D3DCOLOR, GetSceneBackground)(THIS) PURE;
+    STDMETHOD(GetSceneBackgroundDepth)(THIS_ LPDIRECTDRAWSURFACE *) PURE;
+    STDMETHOD_(D3DCOLOR, GetSceneFogColor)(THIS) PURE;
+    STDMETHOD_(BOOL, GetSceneFogEnable)(THIS) PURE;
+    STDMETHOD_(D3DRMFOGMODE, GetSceneFogMode)(THIS) PURE;
+    STDMETHOD(GetSceneFogParams)(THIS_ D3DVALUE *return_start, D3DVALUE *return_end, D3DVALUE *return_density) PURE;
+    STDMETHOD(SetSceneBackground)(THIS_ D3DCOLOR) PURE;
+    STDMETHOD(SetSceneBackgroundRGB)(THIS_ D3DVALUE red, D3DVALUE green, D3DVALUE blue) PURE;
+    STDMETHOD(SetSceneBackgroundDepth)(THIS_ LPDIRECTDRAWSURFACE) PURE;
+    STDMETHOD(SetSceneBackgroundImage)(THIS_ LPDIRECT3DRMTEXTURE) PURE;
+    STDMETHOD(SetSceneFogEnable)(THIS_ BOOL) PURE;
+    STDMETHOD(SetSceneFogColor)(THIS_ D3DCOLOR) PURE;
+    STDMETHOD(SetSceneFogMode)(THIS_ D3DRMFOGMODE) PURE;
+    STDMETHOD(SetSceneFogParams)(THIS_ D3DVALUE start, D3DVALUE end, D3DVALUE density) PURE;
+    STDMETHOD(SetColor)(THIS_ D3DCOLOR) PURE;
+    STDMETHOD(SetColorRGB)(THIS_ D3DVALUE red, D3DVALUE green, D3DVALUE blue) PURE;
+    STDMETHOD_(D3DRMZBUFFERMODE, GetZbufferMode)(THIS) PURE;
+    STDMETHOD(SetMaterialMode)(THIS_ D3DRMMATERIALMODE) PURE;
+    STDMETHOD(SetOrientation)
+    (	THIS_ LPDIRECT3DRMFRAME reference,
+	D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
+	D3DVALUE ux, D3DVALUE uy, D3DVALUE uz
+    ) PURE;
+    STDMETHOD(SetPosition)(THIS_ LPDIRECT3DRMFRAME reference, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE;
+    STDMETHOD(SetRotation)(THIS_ LPDIRECT3DRMFRAME reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta) PURE;
+    STDMETHOD(SetSortMode)(THIS_ D3DRMSORTMODE) PURE;
+    STDMETHOD(SetTexture)(THIS_ LPDIRECT3DRMTEXTURE) PURE;
+    STDMETHOD(SetTextureTopology)(THIS_ BOOL wrap_u, BOOL wrap_v) PURE;
+    STDMETHOD(SetVelocity)(THIS_ LPDIRECT3DRMFRAME reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, BOOL with_rotation) PURE;
+    STDMETHOD(SetZbufferMode)(THIS_ D3DRMZBUFFERMODE) PURE;
+    STDMETHOD(Transform)(THIS_ D3DVECTOR *d, D3DVECTOR *s) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMFrame2
+
+DECLARE_INTERFACE_(IDirect3DRMFrame2, IDirect3DRMFrame)
+{
+    IUNKNOWN_METHODS(PURE);
+    IDIRECT3DRMOBJECT_METHODS(PURE);
+
+    /*
+     * IDirect3DRMFrame methods
+     */
+    STDMETHOD(AddChild)(THIS_ LPDIRECT3DRMFRAME child) PURE;
+    STDMETHOD(AddLight)(THIS_ LPDIRECT3DRMLIGHT) PURE;
+    STDMETHOD(AddMoveCallback)(THIS_ D3DRMFRAMEMOVECALLBACK, VOID *arg) PURE;
+    STDMETHOD(AddTransform)(THIS_ D3DRMCOMBINETYPE, D3DRMMATRIX4D) PURE;
+    STDMETHOD(AddTranslation)(THIS_ D3DRMCOMBINETYPE, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE;
+    STDMETHOD(AddScale)(THIS_ D3DRMCOMBINETYPE, D3DVALUE sx, D3DVALUE sy, D3DVALUE sz) PURE;
+    STDMETHOD(AddRotation)(THIS_ D3DRMCOMBINETYPE, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta) PURE;
+    STDMETHOD(AddVisual)(THIS_ LPDIRECT3DRMVISUAL) PURE;
+    STDMETHOD(GetChildren)(THIS_ LPDIRECT3DRMFRAMEARRAY *children) PURE;
+    STDMETHOD_(D3DCOLOR, GetColor)(THIS) PURE;
+    STDMETHOD(GetLights)(THIS_ LPDIRECT3DRMLIGHTARRAY *lights) PURE;
+    STDMETHOD_(D3DRMMATERIALMODE, GetMaterialMode)(THIS) PURE;
+    STDMETHOD(GetParent)(THIS_ LPDIRECT3DRMFRAME *) PURE;
+    STDMETHOD(GetPosition)(THIS_ LPDIRECT3DRMFRAME reference, LPD3DVECTOR return_position) PURE;
+    STDMETHOD(GetRotation)(THIS_ LPDIRECT3DRMFRAME reference, LPD3DVECTOR axis, LPD3DVALUE return_theta) PURE;
+    STDMETHOD(GetScene)(THIS_ LPDIRECT3DRMFRAME *) PURE;
+    STDMETHOD_(D3DRMSORTMODE, GetSortMode)(THIS) PURE;
+    STDMETHOD(GetTexture)(THIS_ LPDIRECT3DRMTEXTURE *) PURE;
+    STDMETHOD(GetTransform)(THIS_ D3DRMMATRIX4D return_matrix) PURE;
+    STDMETHOD(GetVelocity)(THIS_ LPDIRECT3DRMFRAME reference, LPD3DVECTOR return_velocity, BOOL with_rotation) PURE;
+    STDMETHOD(GetOrientation)(THIS_ LPDIRECT3DRMFRAME reference, LPD3DVECTOR dir, LPD3DVECTOR up) PURE;
+    STDMETHOD(GetVisuals)(THIS_ LPDIRECT3DRMVISUALARRAY *visuals) PURE;
+    STDMETHOD(GetTextureTopology)(THIS_ BOOL *wrap_u, BOOL *wrap_v) PURE;
+    STDMETHOD(InverseTransform)(THIS_ D3DVECTOR *d, D3DVECTOR *s) PURE;
+    STDMETHOD(Load)(THIS_ LPVOID filename, LPVOID name, D3DRMLOADOPTIONS loadflags, D3DRMLOADTEXTURECALLBACK, LPVOID lpArg)PURE;
+    STDMETHOD(LookAt)(THIS_ LPDIRECT3DRMFRAME target, LPDIRECT3DRMFRAME reference, D3DRMFRAMECONSTRAINT) PURE;
+    STDMETHOD(Move)(THIS_ D3DVALUE delta) PURE;
+    STDMETHOD(DeleteChild)(THIS_ LPDIRECT3DRMFRAME) PURE;
+    STDMETHOD(DeleteLight)(THIS_ LPDIRECT3DRMLIGHT) PURE;
+    STDMETHOD(DeleteMoveCallback)(THIS_ D3DRMFRAMEMOVECALLBACK, VOID *arg) PURE;
+    STDMETHOD(DeleteVisual)(THIS_ LPDIRECT3DRMVISUAL) PURE;
+    STDMETHOD_(D3DCOLOR, GetSceneBackground)(THIS) PURE;
+    STDMETHOD(GetSceneBackgroundDepth)(THIS_ LPDIRECTDRAWSURFACE *) PURE;
+    STDMETHOD_(D3DCOLOR, GetSceneFogColor)(THIS) PURE;
+    STDMETHOD_(BOOL, GetSceneFogEnable)(THIS) PURE;
+    STDMETHOD_(D3DRMFOGMODE, GetSceneFogMode)(THIS) PURE;
+    STDMETHOD(GetSceneFogParams)(THIS_ D3DVALUE *return_start, D3DVALUE *return_end, D3DVALUE *return_density) PURE;
+    STDMETHOD(SetSceneBackground)(THIS_ D3DCOLOR) PURE;
+    STDMETHOD(SetSceneBackgroundRGB)(THIS_ D3DVALUE red, D3DVALUE green, D3DVALUE blue) PURE;
+    STDMETHOD(SetSceneBackgroundDepth)(THIS_ LPDIRECTDRAWSURFACE) PURE;
+    STDMETHOD(SetSceneBackgroundImage)(THIS_ LPDIRECT3DRMTEXTURE) PURE;
+    STDMETHOD(SetSceneFogEnable)(THIS_ BOOL) PURE;
+    STDMETHOD(SetSceneFogColor)(THIS_ D3DCOLOR) PURE;
+    STDMETHOD(SetSceneFogMode)(THIS_ D3DRMFOGMODE) PURE;
+    STDMETHOD(SetSceneFogParams)(THIS_ D3DVALUE start, D3DVALUE end, D3DVALUE density) PURE;
+    STDMETHOD(SetColor)(THIS_ D3DCOLOR) PURE;
+    STDMETHOD(SetColorRGB)(THIS_ D3DVALUE red, D3DVALUE green, D3DVALUE blue) PURE;
+    STDMETHOD_(D3DRMZBUFFERMODE, GetZbufferMode)(THIS) PURE;
+    STDMETHOD(SetMaterialMode)(THIS_ D3DRMMATERIALMODE) PURE;
+    STDMETHOD(SetOrientation)
+    (	THIS_ LPDIRECT3DRMFRAME reference,
+	D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
+	D3DVALUE ux, D3DVALUE uy, D3DVALUE uz
+    ) PURE;
+    STDMETHOD(SetPosition)(THIS_ LPDIRECT3DRMFRAME reference, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE;
+    STDMETHOD(SetRotation)(THIS_ LPDIRECT3DRMFRAME reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta) PURE;
+    STDMETHOD(SetSortMode)(THIS_ D3DRMSORTMODE) PURE;
+    STDMETHOD(SetTexture)(THIS_ LPDIRECT3DRMTEXTURE) PURE;
+    STDMETHOD(SetTextureTopology)(THIS_ BOOL wrap_u, BOOL wrap_v) PURE;
+    STDMETHOD(SetVelocity)(THIS_ LPDIRECT3DRMFRAME reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, BOOL with_rotation) PURE;
+    STDMETHOD(SetZbufferMode)(THIS_ D3DRMZBUFFERMODE) PURE;
+    STDMETHOD(Transform)(THIS_ D3DVECTOR *d, D3DVECTOR *s) PURE;
+
+    /*
+     * IDirect3DRMFrame2 methods
+     */
+    STDMETHOD(AddMoveCallback2)(THIS_ D3DRMFRAMEMOVECALLBACK, VOID *arg, DWORD dwFlags) PURE;
+    STDMETHOD(GetBox)(THIS_ LPD3DRMBOX) PURE;
+    STDMETHOD_(BOOL, GetBoxEnable)(THIS) PURE;
+    STDMETHOD(GetAxes)(THIS_ LPD3DVECTOR dir, LPD3DVECTOR up);
+    STDMETHOD(GetMaterial)(THIS_ LPDIRECT3DRMMATERIAL *) PURE;
+    STDMETHOD_(BOOL, GetInheritAxes)(THIS);
+    STDMETHOD(GetHierarchyBox)(THIS_ LPD3DRMBOX) PURE;
+
+    STDMETHOD(SetBox)(THIS_ LPD3DRMBOX) PURE;
+    STDMETHOD(SetBoxEnable)(THIS_ BOOL) PURE;
+    STDMETHOD(SetAxes)(THIS_ D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
+		       D3DVALUE ux, D3DVALUE uy, D3DVALUE uz);
+    STDMETHOD(SetInheritAxes)(THIS_ BOOL inherit_from_parent);
+    STDMETHOD(SetMaterial)(THIS_ LPDIRECT3DRMMATERIAL) PURE;
+    STDMETHOD(SetQuaternion)(THIS_ LPDIRECT3DRMFRAME reference, D3DRMQUATERNION *q) PURE;
+
+    STDMETHOD(RayPick)(THIS_ LPDIRECT3DRMFRAME reference, LPD3DRMRAY ray, DWORD dwFlags, LPDIRECT3DRMPICKED2ARRAY *return_visuals) PURE;
+    STDMETHOD(Save)(THIS_ LPCSTR filename, D3DRMXOFFORMAT d3dFormat, 
+		    D3DRMSAVEOPTIONS d3dSaveFlags);
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMMesh
+
+DECLARE_INTERFACE_(IDirect3DRMMesh, IDirect3DRMVisual)
+{
+    IUNKNOWN_METHODS(PURE);
+    IDIRECT3DRMOBJECT_METHODS(PURE);
+
+    /*
+     * IDirect3DRMMesh methods
+     */
+    STDMETHOD(Scale)(THIS_ D3DVALUE sx, D3DVALUE sy, D3DVALUE sz) PURE;
+    STDMETHOD(Translate)(THIS_ D3DVALUE tx, D3DVALUE ty, D3DVALUE tz) PURE;
+    STDMETHOD(GetBox)(THIS_ D3DRMBOX *) PURE;
+    STDMETHOD(AddGroup)(THIS_ unsigned vCount, unsigned fCount, unsigned vPerFace, unsigned *fData, D3DRMGROUPINDEX *returnId) PURE;
+    STDMETHOD(SetVertices)(THIS_ D3DRMGROUPINDEX id, unsigned index, unsigned count, D3DRMVERTEX *values) PURE;
+    STDMETHOD(SetGroupColor)(THIS_ D3DRMGROUPINDEX id, D3DCOLOR value) PURE;
+    STDMETHOD(SetGroupColorRGB)(THIS_ D3DRMGROUPINDEX id, D3DVALUE red, D3DVALUE green, D3DVALUE blue) PURE;
+    STDMETHOD(SetGroupMapping)(THIS_ D3DRMGROUPINDEX id, D3DRMMAPPING value) PURE;
+    STDMETHOD(SetGroupQuality)(THIS_ D3DRMGROUPINDEX id, D3DRMRENDERQUALITY value) PURE;
+    STDMETHOD(SetGroupMaterial)(THIS_ D3DRMGROUPINDEX id, LPDIRECT3DRMMATERIAL value) PURE;
+    STDMETHOD(SetGroupTexture)(THIS_ D3DRMGROUPINDEX id, LPDIRECT3DRMTEXTURE value) PURE;
+
+    STDMETHOD_(unsigned, GetGroupCount)(THIS) PURE;
+    STDMETHOD(GetGroup)(THIS_ D3DRMGROUPINDEX id, unsigned *vCount, unsigned *fCount, unsigned *vPerFace, DWORD *fDataSize, unsigned *fData) PURE;
+    STDMETHOD(GetVertices)(THIS_ D3DRMGROUPINDEX id, DWORD index, DWORD count, D3DRMVERTEX *returnPtr) PURE;
+    STDMETHOD_(D3DCOLOR, GetGroupColor)(THIS_ D3DRMGROUPINDEX id) PURE;
+    STDMETHOD_(D3DRMMAPPING, GetGroupMapping)(THIS_ D3DRMGROUPINDEX id) PURE;
+    STDMETHOD_(D3DRMRENDERQUALITY, GetGroupQuality)(THIS_ D3DRMGROUPINDEX id) PURE;
+    STDMETHOD(GetGroupMaterial)(THIS_ D3DRMGROUPINDEX id, LPDIRECT3DRMMATERIAL *returnPtr) PURE;
+    STDMETHOD(GetGroupTexture)(THIS_ D3DRMGROUPINDEX id, LPDIRECT3DRMTEXTURE *returnPtr) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMProgressiveMesh
+
+DECLARE_INTERFACE_(IDirect3DRMProgressiveMesh, IDirect3DRMVisual)
+{
+    IUNKNOWN_METHODS(PURE);
+    IDIRECT3DRMOBJECT_METHODS(PURE);
+
+    /*
+     * IDirect3DRMProgressiveMesh methods
+     */
+    STDMETHOD(Load) (THIS_ LPVOID lpObjLocation, LPVOID lpObjId, 
+		     D3DRMLOADOPTIONS dloLoadflags, D3DRMLOADTEXTURECALLBACK lpCallback,
+		     LPVOID lpArg) PURE;
+    STDMETHOD(GetLoadStatus) (THIS_ LPD3DRMPMESHLOADSTATUS lpStatus) PURE;
+    STDMETHOD(SetMinRenderDetail) (THIS_ D3DVALUE d3dVal) PURE;
+    STDMETHOD(Abort) (THIS_ DWORD dwFlags) PURE;
+    
+    STDMETHOD(GetFaceDetail) (THIS_ LPDWORD lpdwCount) PURE;
+    STDMETHOD(GetVertexDetail) (THIS_ LPDWORD lpdwCount) PURE;
+    STDMETHOD(SetFaceDetail) (THIS_ DWORD dwCount) PURE;
+    STDMETHOD(SetVertexDetail) (THIS_ DWORD dwCount) PURE;
+    STDMETHOD(GetFaceDetailRange) (THIS_ LPDWORD lpdwMin, LPDWORD lpdwMax) PURE;
+    STDMETHOD(GetVertexDetailRange) (THIS_ LPDWORD lpdwMin, LPDWORD lpdwMax) PURE;
+    STDMETHOD(GetDetail) (THIS_ D3DVALUE *lpdvVal) PURE;
+    STDMETHOD(SetDetail) (THIS_ D3DVALUE d3dVal) PURE;
+
+    STDMETHOD(RegisterEvents) (THIS_ HANDLE hEvent, DWORD dwFlags, DWORD dwReserved) PURE;
+    STDMETHOD(CreateMesh) (THIS_ LPDIRECT3DRMMESH *lplpD3DRMMesh) PURE;
+    STDMETHOD(Duplicate) (THIS_ LPDIRECT3DRMPROGRESSIVEMESH *lplpD3DRMPMesh) PURE;
+    STDMETHOD(GetBox) (THIS_ LPD3DRMBOX lpBBox) PURE;
+    STDMETHOD(SetQuality) (THIS_ D3DRMRENDERQUALITY) PURE;
+    STDMETHOD(GetQuality) (THIS_ LPD3DRMRENDERQUALITY lpdwquality) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMShadow
+
+DECLARE_INTERFACE_(IDirect3DRMShadow, IDirect3DRMVisual)
+{
+    IUNKNOWN_METHODS(PURE);
+    IDIRECT3DRMOBJECT_METHODS(PURE);
+
+    /*
+     * IDirect3DRMShadow methods
+     */
+    STDMETHOD(Init)
+    (	THIS_ LPDIRECT3DRMVISUAL visual, LPDIRECT3DRMLIGHT light,
+	D3DVALUE px, D3DVALUE py, D3DVALUE pz,
+	D3DVALUE nx, D3DVALUE ny, D3DVALUE nz
+    ) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMFace
+
+DECLARE_INTERFACE_(IDirect3DRMFace, IDirect3DRMObject)
+{
+    IUNKNOWN_METHODS(PURE);
+    IDIRECT3DRMOBJECT_METHODS(PURE);
+
+    /*
+     * IDirect3DRMFace methods
+     */
+     STDMETHOD(AddVertex)(THIS_ D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE;
+     STDMETHOD(AddVertexAndNormalIndexed)(THIS_ DWORD vertex, DWORD normal) PURE;
+     STDMETHOD(SetColorRGB)(THIS_ D3DVALUE, D3DVALUE, D3DVALUE) PURE;
+     STDMETHOD(SetColor)(THIS_ D3DCOLOR) PURE;
+     STDMETHOD(SetTexture)(THIS_ LPDIRECT3DRMTEXTURE) PURE;
+     STDMETHOD(SetTextureCoordinates)(THIS_ DWORD vertex, D3DVALUE u, D3DVALUE v) PURE;
+     STDMETHOD(SetMaterial)(THIS_ LPDIRECT3DRMMATERIAL) PURE;
+     STDMETHOD(SetTextureTopology)(THIS_ BOOL wrap_u, BOOL wrap_v) PURE;
+
+     STDMETHOD(GetVertex)(THIS_ DWORD index, D3DVECTOR *vertex, D3DVECTOR *normal) PURE;
+     STDMETHOD(GetVertices)(THIS_ DWORD *vertex_count, D3DVECTOR *coords, D3DVECTOR *normals);
+     STDMETHOD(GetTextureCoordinates)(THIS_ DWORD vertex, D3DVALUE *u, D3DVALUE *v) PURE;
+     STDMETHOD(GetTextureTopology)(THIS_ BOOL *wrap_u, BOOL *wrap_v) PURE;
+     STDMETHOD(GetNormal)(THIS_ D3DVECTOR *) PURE;
+     STDMETHOD(GetTexture)(THIS_ LPDIRECT3DRMTEXTURE *) PURE;
+     STDMETHOD(GetMaterial)(THIS_ LPDIRECT3DRMMATERIAL *) PURE;
+
+     STDMETHOD_(int, GetVertexCount)(THIS) PURE;
+     STDMETHOD_(int, GetVertexIndex)(THIS_ DWORD which) PURE;
+     STDMETHOD_(int, GetTextureCoordinateIndex)(THIS_ DWORD which) PURE;
+     STDMETHOD_(D3DCOLOR, GetColor)(THIS) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMMeshBuilder
+
+DECLARE_INTERFACE_(IDirect3DRMMeshBuilder, IDirect3DRMVisual)
+{
+    IUNKNOWN_METHODS(PURE);
+    IDIRECT3DRMOBJECT_METHODS(PURE);
+
+    /*
+     * IDirect3DRMMeshBuilder methods
+     */
+    STDMETHOD(Load)(THIS_ LPVOID filename, LPVOID name, D3DRMLOADOPTIONS loadflags, D3DRMLOADTEXTURECALLBACK, LPVOID lpArg) PURE;
+    STDMETHOD(Save)(THIS_ const char *filename, D3DRMXOFFORMAT, D3DRMSAVEOPTIONS save) PURE;
+    STDMETHOD(Scale)(THIS_ D3DVALUE sx, D3DVALUE sy, D3DVALUE sz) PURE;
+    STDMETHOD(Translate)(THIS_ D3DVALUE tx, D3DVALUE ty, D3DVALUE tz) PURE;
+    STDMETHOD(SetColorSource)(THIS_ D3DRMCOLORSOURCE) PURE;
+    STDMETHOD(GetBox)(THIS_ D3DRMBOX *) PURE;
+    STDMETHOD(GenerateNormals)(THIS) PURE;
+    STDMETHOD_(D3DRMCOLORSOURCE, GetColorSource)(THIS) PURE;
+
+    STDMETHOD(AddMesh)(THIS_ LPDIRECT3DRMMESH) PURE;
+    STDMETHOD(AddMeshBuilder)(THIS_ LPDIRECT3DRMMESHBUILDER) PURE;
+    STDMETHOD(AddFrame)(THIS_ LPDIRECT3DRMFRAME) PURE;
+    STDMETHOD(AddFace)(THIS_ LPDIRECT3DRMFACE) PURE;
+    STDMETHOD(AddFaces)
+    (	THIS_ DWORD vcount, D3DVECTOR *vertices, DWORD ncount, D3DVECTOR *normals,
+	DWORD *data, LPDIRECT3DRMFACEARRAY*
+    ) PURE;
+    STDMETHOD(ReserveSpace)(THIS_ DWORD vertex_Count, DWORD normal_count, DWORD face_count) PURE;
+    STDMETHOD(SetColorRGB)(THIS_ D3DVALUE red, D3DVALUE green, D3DVALUE blue) PURE;
+    STDMETHOD(SetColor)(THIS_ D3DCOLOR) PURE;
+    STDMETHOD(SetTexture)(THIS_ LPDIRECT3DRMTEXTURE) PURE;
+    STDMETHOD(SetMaterial)(THIS_ LPDIRECT3DRMMATERIAL) PURE;
+    STDMETHOD(SetTextureTopology)(THIS_ BOOL wrap_u, BOOL wrap_v) PURE;
+    STDMETHOD(SetQuality)(THIS_ D3DRMRENDERQUALITY) PURE;
+    STDMETHOD(SetPerspective)(THIS_ BOOL) PURE;
+    STDMETHOD(SetVertex)(THIS_ DWORD index, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE;
+    STDMETHOD(SetNormal)(THIS_ DWORD index, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE;
+    STDMETHOD(SetTextureCoordinates)(THIS_ DWORD index, D3DVALUE u, D3DVALUE v) PURE;
+    STDMETHOD(SetVertexColor)(THIS_ DWORD index, D3DCOLOR) PURE;
+    STDMETHOD(SetVertexColorRGB)(THIS_ DWORD index, D3DVALUE red, D3DVALUE green, D3DVALUE blue) PURE;
+
+    STDMETHOD(GetFaces)(THIS_ LPDIRECT3DRMFACEARRAY*) PURE;
+    STDMETHOD(GetVertices)
+    (	THIS_ DWORD *vcount, D3DVECTOR *vertices, DWORD *ncount, D3DVECTOR *normals, DWORD *face_data_size, DWORD *face_data
+    ) PURE;
+    STDMETHOD(GetTextureCoordinates)(THIS_ DWORD index, D3DVALUE *u, D3DVALUE *v) PURE;
+
+    STDMETHOD_(int, AddVertex)(THIS_ D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE;
+    STDMETHOD_(int, AddNormal)(THIS_ D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE;
+    STDMETHOD(CreateFace)(THIS_ LPDIRECT3DRMFACE*) PURE;
+    STDMETHOD_(D3DRMRENDERQUALITY, GetQuality)(THIS) PURE;
+    STDMETHOD_(BOOL, GetPerspective)(THIS) PURE;
+    STDMETHOD_(int, GetFaceCount)(THIS) PURE;
+    STDMETHOD_(int, GetVertexCount)(THIS) PURE;
+    STDMETHOD_(D3DCOLOR, GetVertexColor)(THIS_ DWORD index) PURE;
+
+    STDMETHOD(CreateMesh)(THIS_ LPDIRECT3DRMMESH*) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMMeshBuilder2
+
+DECLARE_INTERFACE_(IDirect3DRMMeshBuilder2, IDirect3DRMMeshBuilder)
+{
+    IUNKNOWN_METHODS(PURE);
+    IDIRECT3DRMOBJECT_METHODS(PURE);
+
+    /*
+     * IDirect3DRMMeshBuilder methods
+     */
+    STDMETHOD(Load)(THIS_ LPVOID filename, LPVOID name, D3DRMLOADOPTIONS loadflags, D3DRMLOADTEXTURECALLBACK, LPVOID lpArg) PURE;
+    STDMETHOD(Save)(THIS_ const char *filename, D3DRMXOFFORMAT, D3DRMSAVEOPTIONS save) PURE;
+    STDMETHOD(Scale)(THIS_ D3DVALUE sx, D3DVALUE sy, D3DVALUE sz) PURE;
+    STDMETHOD(Translate)(THIS_ D3DVALUE tx, D3DVALUE ty, D3DVALUE tz) PURE;
+    STDMETHOD(SetColorSource)(THIS_ D3DRMCOLORSOURCE) PURE;
+    STDMETHOD(GetBox)(THIS_ D3DRMBOX *) PURE;
+    STDMETHOD(GenerateNormals)(THIS) PURE;
+    STDMETHOD_(D3DRMCOLORSOURCE, GetColorSource)(THIS) PURE;
+
+    STDMETHOD(AddMesh)(THIS_ LPDIRECT3DRMMESH) PURE;
+    STDMETHOD(AddMeshBuilder)(THIS_ LPDIRECT3DRMMESHBUILDER) PURE;
+    STDMETHOD(AddFrame)(THIS_ LPDIRECT3DRMFRAME) PURE;
+    STDMETHOD(AddFace)(THIS_ LPDIRECT3DRMFACE) PURE;
+    STDMETHOD(AddFaces)
+    (	THIS_ DWORD vcount, D3DVECTOR *vertices, DWORD ncount, D3DVECTOR *normals,
+	DWORD *data, LPDIRECT3DRMFACEARRAY*
+    ) PURE;
+    STDMETHOD(ReserveSpace)(THIS_ DWORD vertex_Count, DWORD normal_count, DWORD face_count) PURE;
+    STDMETHOD(SetColorRGB)(THIS_ D3DVALUE red, D3DVALUE green, D3DVALUE blue) PURE;
+    STDMETHOD(SetColor)(THIS_ D3DCOLOR) PURE;
+    STDMETHOD(SetTexture)(THIS_ LPDIRECT3DRMTEXTURE) PURE;
+    STDMETHOD(SetMaterial)(THIS_ LPDIRECT3DRMMATERIAL) PURE;
+    STDMETHOD(SetTextureTopology)(THIS_ BOOL wrap_u, BOOL wrap_v) PURE;
+    STDMETHOD(SetQuality)(THIS_ D3DRMRENDERQUALITY) PURE;
+    STDMETHOD(SetPerspective)(THIS_ BOOL) PURE;
+    STDMETHOD(SetVertex)(THIS_ DWORD index, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE;
+    STDMETHOD(SetNormal)(THIS_ DWORD index, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE;
+    STDMETHOD(SetTextureCoordinates)(THIS_ DWORD index, D3DVALUE u, D3DVALUE v) PURE;
+    STDMETHOD(SetVertexColor)(THIS_ DWORD index, D3DCOLOR) PURE;
+    STDMETHOD(SetVertexColorRGB)(THIS_ DWORD index, D3DVALUE red, D3DVALUE green, D3DVALUE blue) PURE;
+
+    STDMETHOD(GetFaces)(THIS_ LPDIRECT3DRMFACEARRAY*) PURE;
+    STDMETHOD(GetVertices)
+    (	THIS_ DWORD *vcount, D3DVECTOR *vertices, DWORD *ncount, D3DVECTOR *normals, DWORD *face_data_size, DWORD *face_data
+    ) PURE;
+    STDMETHOD(GetTextureCoordinates)(THIS_ DWORD index, D3DVALUE *u, D3DVALUE *v) PURE;
+
+    STDMETHOD_(int, AddVertex)(THIS_ D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE;
+    STDMETHOD_(int, AddNormal)(THIS_ D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE;
+    STDMETHOD(CreateFace)(THIS_ LPDIRECT3DRMFACE*) PURE;
+    STDMETHOD_(D3DRMRENDERQUALITY, GetQuality)(THIS) PURE;
+    STDMETHOD_(BOOL, GetPerspective)(THIS) PURE;
+    STDMETHOD_(int, GetFaceCount)(THIS) PURE;
+    STDMETHOD_(int, GetVertexCount)(THIS) PURE;
+    STDMETHOD_(D3DCOLOR, GetVertexColor)(THIS_ DWORD index) PURE;
+
+    STDMETHOD(CreateMesh)(THIS_ LPDIRECT3DRMMESH*) PURE;
+
+    /*
+     * IDirect3DRMMeshBuilder2 methods
+     */
+    STDMETHOD(GenerateNormals2)(THIS_ D3DVALUE crease, DWORD dwFlags) PURE;
+    STDMETHOD(GetFace)(THIS_ DWORD index, LPDIRECT3DRMFACE*) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMLight
+
+DECLARE_INTERFACE_(IDirect3DRMLight, IDirect3DRMObject)
+{
+    IUNKNOWN_METHODS(PURE);
+    IDIRECT3DRMOBJECT_METHODS(PURE);
+
+    /*
+     * IDirect3DRMLight methods
+     */
+    STDMETHOD(SetType)(THIS_ D3DRMLIGHTTYPE) PURE;
+    STDMETHOD(SetColor)(THIS_ D3DCOLOR) PURE;
+    STDMETHOD(SetColorRGB)(THIS_ D3DVALUE red, D3DVALUE green, D3DVALUE blue) PURE;
+    STDMETHOD(SetRange)(THIS_ D3DVALUE) PURE;
+    STDMETHOD(SetUmbra)(THIS_ D3DVALUE) PURE;
+    STDMETHOD(SetPenumbra)(THIS_ D3DVALUE) PURE;
+    STDMETHOD(SetConstantAttenuation)(THIS_ D3DVALUE) PURE;
+    STDMETHOD(SetLinearAttenuation)(THIS_ D3DVALUE) PURE;
+    STDMETHOD(SetQuadraticAttenuation)(THIS_ D3DVALUE) PURE;
+
+    STDMETHOD_(D3DVALUE, GetRange)(THIS) PURE;
+    STDMETHOD_(D3DVALUE, GetUmbra)(THIS) PURE;
+    STDMETHOD_(D3DVALUE, GetPenumbra)(THIS) PURE;
+    STDMETHOD_(D3DVALUE, GetConstantAttenuation)(THIS) PURE;
+    STDMETHOD_(D3DVALUE, GetLinearAttenuation)(THIS) PURE;
+    STDMETHOD_(D3DVALUE, GetQuadraticAttenuation)(THIS) PURE;
+    STDMETHOD_(D3DCOLOR, GetColor)(THIS) PURE;
+    STDMETHOD_(D3DRMLIGHTTYPE, GetType)(THIS) PURE;
+
+    STDMETHOD(SetEnableFrame)(THIS_ LPDIRECT3DRMFRAME) PURE;
+    STDMETHOD(GetEnableFrame)(THIS_ LPDIRECT3DRMFRAME*) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMTexture
+
+DECLARE_INTERFACE_(IDirect3DRMTexture, IDirect3DRMVisual)
+{
+    IUNKNOWN_METHODS(PURE);
+    IDIRECT3DRMOBJECT_METHODS(PURE);
+
+    /*
+     * IDirect3DRMTexture methods
+     */
+    STDMETHOD(InitFromFile)(THIS_ const char *filename) PURE;
+    STDMETHOD(InitFromSurface)(THIS_ LPDIRECTDRAWSURFACE lpDDS) PURE;
+    STDMETHOD(InitFromResource)(THIS_ HRSRC) PURE;
+    STDMETHOD(Changed)(THIS_ BOOL pixels, BOOL palette) PURE;
+
+    STDMETHOD(SetColors)(THIS_ DWORD) PURE;
+    STDMETHOD(SetShades)(THIS_ DWORD) PURE;
+    STDMETHOD(SetDecalSize)(THIS_ D3DVALUE width, D3DVALUE height) PURE;
+    STDMETHOD(SetDecalOrigin)(THIS_ LONG x, LONG y) PURE;
+    STDMETHOD(SetDecalScale)(THIS_ DWORD) PURE;
+    STDMETHOD(SetDecalTransparency)(THIS_ BOOL) PURE;
+    STDMETHOD(SetDecalTransparentColor)(THIS_ D3DCOLOR) PURE;
+
+    STDMETHOD(GetDecalSize)(THIS_ D3DVALUE *width_return, D3DVALUE *height_return) PURE;
+    STDMETHOD(GetDecalOrigin)(THIS_ LONG *x_return, LONG *y_return) PURE;
+
+    STDMETHOD_(D3DRMIMAGE *, GetImage)(THIS) PURE;
+    STDMETHOD_(DWORD, GetShades)(THIS) PURE;
+    STDMETHOD_(DWORD, GetColors)(THIS) PURE;
+    STDMETHOD_(DWORD, GetDecalScale)(THIS) PURE;
+    STDMETHOD_(BOOL, GetDecalTransparency)(THIS) PURE;
+    STDMETHOD_(D3DCOLOR, GetDecalTransparentColor)(THIS) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMTexture2
+
+DECLARE_INTERFACE_(IDirect3DRMTexture2, IDirect3DRMTexture)
+{
+    IUNKNOWN_METHODS(PURE);
+    IDIRECT3DRMOBJECT_METHODS(PURE);
+
+    /*
+     * IDirect3DRMTexture methods
+     */
+    STDMETHOD(InitFromFile)(THIS_ const char *filename) PURE;
+    STDMETHOD(InitFromSurface)(THIS_ LPDIRECTDRAWSURFACE lpDDS) PURE;
+    STDMETHOD(InitFromResource)(THIS_ HRSRC) PURE;
+    STDMETHOD(Changed)(THIS_ BOOL pixels, BOOL palette) PURE;
+
+    STDMETHOD(SetColors)(THIS_ DWORD) PURE;
+    STDMETHOD(SetShades)(THIS_ DWORD) PURE;
+    STDMETHOD(SetDecalSize)(THIS_ D3DVALUE width, D3DVALUE height) PURE;
+    STDMETHOD(SetDecalOrigin)(THIS_ LONG x, LONG y) PURE;
+    STDMETHOD(SetDecalScale)(THIS_ DWORD) PURE;
+    STDMETHOD(SetDecalTransparency)(THIS_ BOOL) PURE;
+    STDMETHOD(SetDecalTransparentColor)(THIS_ D3DCOLOR) PURE;
+
+    STDMETHOD(GetDecalSize)(THIS_ D3DVALUE *width_return, D3DVALUE *height_return) PURE;
+    STDMETHOD(GetDecalOrigin)(THIS_ LONG *x_return, LONG *y_return) PURE;
+
+    STDMETHOD_(D3DRMIMAGE *, GetImage)(THIS) PURE;
+    STDMETHOD_(DWORD, GetShades)(THIS) PURE;
+    STDMETHOD_(DWORD, GetColors)(THIS) PURE;
+    STDMETHOD_(DWORD, GetDecalScale)(THIS) PURE;
+    STDMETHOD_(BOOL, GetDecalTransparency)(THIS) PURE;
+    STDMETHOD_(D3DCOLOR, GetDecalTransparentColor)(THIS) PURE;
+
+    /*
+     * IDirect3DRMTexture2 methods
+     */
+    STDMETHOD(InitFromImage)(THIS_ LPD3DRMIMAGE) PURE;
+    STDMETHOD(InitFromResource2)(THIS_ HMODULE hModule, LPCTSTR strName, LPCTSTR strType) PURE;
+    STDMETHOD(GenerateMIPMap)(THIS_ DWORD) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMWrap
+
+DECLARE_INTERFACE_(IDirect3DRMWrap, IDirect3DRMObject)
+{
+    IUNKNOWN_METHODS(PURE);
+    IDIRECT3DRMOBJECT_METHODS(PURE);
+
+    /*
+     * IDirect3DRMWrap methods
+     */
+    STDMETHOD(Init)
+    (	THIS_ D3DRMWRAPTYPE, LPDIRECT3DRMFRAME ref,
+	D3DVALUE ox, D3DVALUE oy, D3DVALUE oz,
+	D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
+	D3DVALUE ux, D3DVALUE uy, D3DVALUE uz,
+	D3DVALUE ou, D3DVALUE ov,
+	D3DVALUE su, D3DVALUE sv
+    ) PURE;
+    STDMETHOD(Apply)(THIS_ LPDIRECT3DRMOBJECT) PURE;
+    STDMETHOD(ApplyRelative)(THIS_ LPDIRECT3DRMFRAME frame, LPDIRECT3DRMOBJECT) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMMaterial
+
+DECLARE_INTERFACE_(IDirect3DRMMaterial, IDirect3DRMObject)
+{
+    IUNKNOWN_METHODS(PURE);
+    IDIRECT3DRMOBJECT_METHODS(PURE);
+
+    /*
+     * IDirect3DRMMaterial methods
+     */
+    STDMETHOD(SetPower)(THIS_ D3DVALUE power) PURE;
+    STDMETHOD(SetSpecular)(THIS_ D3DVALUE r, D3DVALUE g, D3DVALUE b) PURE;
+    STDMETHOD(SetEmissive)(THIS_ D3DVALUE r, D3DVALUE g, D3DVALUE b) PURE;
+
+    STDMETHOD_(D3DVALUE, GetPower)(THIS) PURE;
+    STDMETHOD(GetSpecular)(THIS_ D3DVALUE* r, D3DVALUE* g, D3DVALUE* b) PURE;
+    STDMETHOD(GetEmissive)(THIS_ D3DVALUE* r, D3DVALUE* g, D3DVALUE* b) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMAnimation
+
+DECLARE_INTERFACE_(IDirect3DRMAnimation, IDirect3DRMObject)
+{
+    IUNKNOWN_METHODS(PURE);
+    IDIRECT3DRMOBJECT_METHODS(PURE);
+
+    /*
+     * IDirect3DRMAnimation methods
+     */
+    STDMETHOD(SetOptions)(THIS_ D3DRMANIMATIONOPTIONS flags) PURE;
+    STDMETHOD(AddRotateKey)(THIS_ D3DVALUE time, D3DRMQUATERNION *q) PURE;
+    STDMETHOD(AddPositionKey)(THIS_ D3DVALUE time, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE;
+    STDMETHOD(AddScaleKey)(THIS_ D3DVALUE time, D3DVALUE x, D3DVALUE y, D3DVALUE z) PURE;
+    STDMETHOD(DeleteKey)(THIS_ D3DVALUE time) PURE;
+    STDMETHOD(SetFrame)(THIS_ LPDIRECT3DRMFRAME frame) PURE;
+    STDMETHOD(SetTime)(THIS_ D3DVALUE time) PURE;
+
+    STDMETHOD_(D3DRMANIMATIONOPTIONS, GetOptions)(THIS) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMAnimationSet
+
+DECLARE_INTERFACE_(IDirect3DRMAnimationSet, IDirect3DRMObject)
+{
+    IUNKNOWN_METHODS(PURE);
+    IDIRECT3DRMOBJECT_METHODS(PURE);
+
+    /*
+     * IDirect3DRMAnimationSet methods
+     */
+    STDMETHOD(AddAnimation)(THIS_ LPDIRECT3DRMANIMATION aid) PURE;
+    STDMETHOD(Load)(THIS_ LPVOID filename, LPVOID name, D3DRMLOADOPTIONS loadflags, D3DRMLOADTEXTURECALLBACK, LPVOID lpArg, LPDIRECT3DRMFRAME parent)PURE;
+    STDMETHOD(DeleteAnimation)(THIS_ LPDIRECT3DRMANIMATION aid) PURE;
+    STDMETHOD(SetTime)(THIS_ D3DVALUE time) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMUserVisual
+
+DECLARE_INTERFACE_(IDirect3DRMUserVisual, IDirect3DRMVisual)
+{
+    IUNKNOWN_METHODS(PURE);
+    IDIRECT3DRMOBJECT_METHODS(PURE);
+
+    /*
+     * IDirect3DRMUserVisual methods
+     */
+    STDMETHOD(Init)(THIS_ D3DRMUSERVISUALCALLBACK fn, void *arg) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMArray
+
+DECLARE_INTERFACE_(IDirect3DRMArray, IUnknown)
+{
+    IUNKNOWN_METHODS(PURE);
+
+    STDMETHOD_(DWORD, GetSize)(THIS) PURE;
+    /* No GetElement method as it would get overloaded
+     * in derived classes, and overloading is
+     * a no-no in COM
+     */
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMObjectArray
+
+DECLARE_INTERFACE_(IDirect3DRMObjectArray, IDirect3DRMArray)
+{
+    IUNKNOWN_METHODS(PURE);
+
+    STDMETHOD_(DWORD, GetSize)(THIS) PURE;
+    STDMETHOD(GetElement)(THIS_ DWORD index, LPDIRECT3DRMOBJECT *) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMDeviceArray
+
+DECLARE_INTERFACE_(IDirect3DRMDeviceArray, IDirect3DRMArray)
+{
+    IUNKNOWN_METHODS(PURE);
+
+    STDMETHOD_(DWORD, GetSize)(THIS) PURE;
+    STDMETHOD(GetElement)(THIS_ DWORD index, LPDIRECT3DRMDEVICE *) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMFrameArray
+
+DECLARE_INTERFACE_(IDirect3DRMFrameArray, IDirect3DRMArray)
+{
+    IUNKNOWN_METHODS(PURE);
+
+    STDMETHOD_(DWORD, GetSize)(THIS) PURE;
+    STDMETHOD(GetElement)(THIS_ DWORD index, LPDIRECT3DRMFRAME *) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMViewportArray
+
+DECLARE_INTERFACE_(IDirect3DRMViewportArray, IDirect3DRMArray)
+{
+    IUNKNOWN_METHODS(PURE);
+
+    STDMETHOD_(DWORD, GetSize)(THIS) PURE;
+    STDMETHOD(GetElement)(THIS_ DWORD index, LPDIRECT3DRMVIEWPORT *) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMVisualArray
+
+DECLARE_INTERFACE_(IDirect3DRMVisualArray, IDirect3DRMArray)
+{
+    IUNKNOWN_METHODS(PURE);
+
+    STDMETHOD_(DWORD, GetSize)(THIS) PURE;
+    STDMETHOD(GetElement)(THIS_ DWORD index, LPDIRECT3DRMVISUAL *) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMPickedArray
+
+DECLARE_INTERFACE_(IDirect3DRMPickedArray, IDirect3DRMArray)
+{
+    IUNKNOWN_METHODS(PURE);
+
+    STDMETHOD_(DWORD, GetSize)(THIS) PURE;
+    STDMETHOD(GetPick)(THIS_ DWORD index, LPDIRECT3DRMVISUAL *, LPDIRECT3DRMFRAMEARRAY *, LPD3DRMPICKDESC) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMLightArray
+
+DECLARE_INTERFACE_(IDirect3DRMLightArray, IDirect3DRMArray)
+{
+    IUNKNOWN_METHODS(PURE);
+
+    STDMETHOD_(DWORD, GetSize)(THIS) PURE;
+    STDMETHOD(GetElement)(THIS_ DWORD index, LPDIRECT3DRMLIGHT *) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMFaceArray
+
+DECLARE_INTERFACE_(IDirect3DRMFaceArray, IDirect3DRMArray)
+{
+    IUNKNOWN_METHODS(PURE);
+
+    STDMETHOD_(DWORD, GetSize)(THIS) PURE;
+    STDMETHOD(GetElement)(THIS_ DWORD index, LPDIRECT3DRMFACE *) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMPicked2Array
+
+DECLARE_INTERFACE_(IDirect3DRMPicked2Array, IDirect3DRMArray)
+{
+    IUNKNOWN_METHODS(PURE);
+
+    STDMETHOD_(DWORD, GetSize)(THIS) PURE;
+    STDMETHOD(GetPick)(THIS_ DWORD index, LPDIRECT3DRMVISUAL *, LPDIRECT3DRMFRAMEARRAY *, LPD3DRMPICKDESC2) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMInterpolator
+
+DECLARE_INTERFACE_(IDirect3DRMInterpolator, IDirect3DRMObject)
+{
+    IUNKNOWN_METHODS(PURE);
+    IDIRECT3DRMOBJECT_METHODS(PURE);
+
+    /*
+     * IDirect3DRMInterpolator methods
+     */
+    STDMETHOD(AttachObject)(THIS_ LPDIRECT3DRMOBJECT) PURE;
+    STDMETHOD(GetAttachedObjects)(THIS_ LPDIRECT3DRMOBJECTARRAY *) PURE;
+    STDMETHOD(DetachObject)(THIS_ LPDIRECT3DRMOBJECT) PURE;
+    STDMETHOD(SetIndex)(THIS_ D3DVALUE) PURE;
+    STDMETHOD_(D3DVALUE, GetIndex)(THIS) PURE;
+    STDMETHOD(Interpolate)(THIS_ D3DVALUE, LPDIRECT3DRMOBJECT, D3DRMINTERPOLATIONOPTIONS) PURE;
+};
+
+#ifdef __cplusplus
+};
+#endif
+#endif /* _D3DRMOBJ_H_ */
diff --git a/3rdparty/dx5/inc/d3drmwin.h b/3rdparty/dx5/inc/d3drmwin.h
new file mode 100644
index 00000000..bf26d7a0
--- /dev/null
+++ b/3rdparty/dx5/inc/d3drmwin.h
@@ -0,0 +1,48 @@
+/*==========================================================================;
+ *
+ *  Copyright (C) 1995-1997 Microsoft Corporation.  All Rights Reserved.
+ *
+ *  File:	d3drm.h
+ *  Content:	Direct3DRM include file
+ *
+ ***************************************************************************/
+
+#ifndef __D3DRMWIN_H__
+#define __D3DRMWIN_H__
+
+#ifndef WIN32
+#define WIN32
+#endif
+
+#include "d3drm.h"
+#include "ddraw.h"
+#include "d3d.h"
+
+/*
+ * GUIDS used by Direct3DRM Windows interface
+ */
+DEFINE_GUID(IID_IDirect3DRMWinDevice,	0xc5016cc0, 0xd273, 0x11ce, 0xac, 0x48, 0x0, 0x0, 0xc0, 0x38, 0x25, 0xa1);
+
+WIN_TYPES(IDirect3DRMWinDevice, DIRECT3DRMWINDEVICE);
+
+#undef INTERFACE
+#define INTERFACE IDirect3DRMWinDevice
+
+DECLARE_INTERFACE_(IDirect3DRMWinDevice, IDirect3DRMObject)
+{
+    IUNKNOWN_METHODS(PURE);
+    IDIRECT3DRMOBJECT_METHODS(PURE);
+
+    /*
+     * IDirect3DRMWinDevice methods
+     */
+
+    /* Repaint the window with the last frame which was rendered. */
+    STDMETHOD(HandlePaint)(THIS_ HDC hdc) PURE;
+
+    /* Respond to a WM_ACTIVATE message. */
+    STDMETHOD(HandleActivate)(THIS_ WORD wparam) PURE;
+};
+
+
+#endif
diff --git a/3rdparty/dx5/inc/d3dtypes.h b/3rdparty/dx5/inc/d3dtypes.h
new file mode 100644
index 00000000..c1046639
--- /dev/null
+++ b/3rdparty/dx5/inc/d3dtypes.h
@@ -0,0 +1,1201 @@
+/*==========================================================================;
+ *
+ *  Copyright (C) 1995-1997 Microsoft Corporation.  All Rights Reserved.
+ *
+ *  File:	d3dtypes.h
+ *  Content:	Direct3D types include file
+ *
+ ***************************************************************************/
+
+#ifndef _D3DTYPES_H_
+#define _D3DTYPES_H_
+
+#if (! defined WIN32) && (! defined WIN95)
+#include "subwtype.h"
+#else
+#include <windows.h>
+#endif
+
+#include <float.h>
+#include <ddraw.h>
+
+#pragma pack(4)
+
+/* D3DVALUE is the fundamental Direct3D fractional data type */
+
+#define D3DVALP(val, prec) ((float)(val))
+#define D3DVAL(val) ((float)(val))
+typedef float D3DVALUE, *LPD3DVALUE;
+#define D3DDivide(a, b)    (float)((double) (a) / (double) (b))
+#define D3DMultiply(a, b)    ((a) * (b))
+
+typedef LONG D3DFIXED;
+
+#ifndef RGB_MAKE
+/*
+ * Format of CI colors is
+ *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *  |    alpha      |         color index           |   fraction    |
+ *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ */
+#define CI_GETALPHA(ci)    ((ci) >> 24)
+#define CI_GETINDEX(ci)    (((ci) >> 8) & 0xffff)
+#define CI_GETFRACTION(ci) ((ci) & 0xff)
+#define CI_ROUNDINDEX(ci)  CI_GETINDEX((ci) + 0x80)
+#define CI_MASKALPHA(ci)   ((ci) & 0xffffff)
+#define CI_MAKE(a, i, f)    (((a) << 24) | ((i) << 8) | (f))
+
+/*
+ * Format of RGBA colors is
+ *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *  |    alpha      |      red      |     green     |     blue      |
+ *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ */
+#define RGBA_GETALPHA(rgb)      ((rgb) >> 24)
+#define RGBA_GETRED(rgb)        (((rgb) >> 16) & 0xff)
+#define RGBA_GETGREEN(rgb)      (((rgb) >> 8) & 0xff)
+#define RGBA_GETBLUE(rgb)       ((rgb) & 0xff)
+#define RGBA_MAKE(r, g, b, a)   ((D3DCOLOR) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b)))
+
+/* D3DRGB and D3DRGBA may be used as initialisers for D3DCOLORs
+ * The float values must be in the range 0..1
+ */
+#define D3DRGB(r, g, b) \
+    (0xff000000L | ( ((long)((r) * 255)) << 16) | (((long)((g) * 255)) << 8) | (long)((b) * 255))
+#define D3DRGBA(r, g, b, a) \
+    (	(((long)((a) * 255)) << 24) | (((long)((r) * 255)) << 16) \
+    |	(((long)((g) * 255)) << 8) | (long)((b) * 255) \
+    )
+
+/*
+ * Format of RGB colors is
+ *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *  |    ignored    |      red      |     green     |     blue      |
+ *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ */
+#define RGB_GETRED(rgb)         (((rgb) >> 16) & 0xff)
+#define RGB_GETGREEN(rgb)       (((rgb) >> 8) & 0xff)
+#define RGB_GETBLUE(rgb)        ((rgb) & 0xff)
+#define RGBA_SETALPHA(rgba, x) (((x) << 24) | ((rgba) & 0x00ffffff))
+#define RGB_MAKE(r, g, b)       ((D3DCOLOR) (((r) << 16) | ((g) << 8) | (b)))
+#define RGBA_TORGB(rgba)       ((D3DCOLOR) ((rgba) & 0xffffff))
+#define RGB_TORGBA(rgb)        ((D3DCOLOR) ((rgb) | 0xff000000))
+
+#endif
+
+/*
+ * Flags for Enumerate functions
+ */
+
+/*
+ * Stop the enumeration
+ */
+#define D3DENUMRET_CANCEL                        DDENUMRET_CANCEL
+
+/*
+ * Continue the enumeration
+ */
+#define D3DENUMRET_OK                            DDENUMRET_OK
+
+typedef HRESULT (WINAPI* LPD3DVALIDATECALLBACK)(LPVOID lpUserArg, DWORD dwOffset);
+typedef HRESULT (WINAPI* LPD3DENUMTEXTUREFORMATSCALLBACK)(LPDDSURFACEDESC lpDdsd, LPVOID lpContext);
+
+typedef DWORD D3DCOLOR, *LPD3DCOLOR;
+
+typedef DWORD D3DMATERIALHANDLE, *LPD3DMATERIALHANDLE;
+typedef DWORD D3DTEXTUREHANDLE, *LPD3DTEXTUREHANDLE;
+typedef DWORD D3DMATRIXHANDLE, *LPD3DMATRIXHANDLE;
+
+typedef struct _D3DCOLORVALUE {
+    union {
+	D3DVALUE r;
+	D3DVALUE dvR;
+    };
+    union {
+	D3DVALUE g;
+	D3DVALUE dvG;
+    };
+    union {
+	D3DVALUE b;
+	D3DVALUE dvB;
+    };
+    union {
+	D3DVALUE a;
+	D3DVALUE dvA;
+    };
+} D3DCOLORVALUE, *LPD3DCOLORVALUE;
+
+typedef struct _D3DRECT {
+    union {
+	LONG x1;
+	LONG lX1;
+    };
+    union {
+	LONG y1;
+	LONG lY1;
+    };
+    union {
+	LONG x2;
+	LONG lX2;
+    };
+    union {
+	LONG y2;
+	LONG lY2;
+    };
+} D3DRECT, *LPD3DRECT;
+
+typedef struct _D3DVECTOR {
+    union {
+	D3DVALUE x;
+	D3DVALUE dvX;
+    };
+    union {
+	D3DVALUE y;
+	D3DVALUE dvY;
+    };
+    union {
+	D3DVALUE z;
+	D3DVALUE dvZ;
+    };
+#if (defined __cplusplus) && (defined D3D_OVERLOADS)
+
+public:
+
+    // =====================================
+    // Constructors
+    // =====================================
+
+    _D3DVECTOR() { }
+    _D3DVECTOR(D3DVALUE f);
+    _D3DVECTOR(D3DVALUE _x, D3DVALUE _y, D3DVALUE _z);
+    _D3DVECTOR(const D3DVALUE f[3]);
+
+    // =====================================
+    // Access grants
+    // =====================================
+
+    const D3DVALUE&operator[](int i) const;
+    D3DVALUE&operator[](int i);
+
+    // =====================================
+    // Assignment operators
+    // =====================================
+
+    _D3DVECTOR& operator += (const _D3DVECTOR& v);
+    _D3DVECTOR& operator -= (const _D3DVECTOR& v);
+    _D3DVECTOR& operator *= (const _D3DVECTOR& v);
+    _D3DVECTOR& operator /= (const _D3DVECTOR& v);
+    _D3DVECTOR& operator *= (D3DVALUE s);
+    _D3DVECTOR& operator /= (D3DVALUE s);
+
+    // =====================================
+    // Unary operators
+    // =====================================
+
+    friend _D3DVECTOR operator + (const _D3DVECTOR& v);
+    friend _D3DVECTOR operator - (const _D3DVECTOR& v);
+
+
+    // =====================================
+    // Binary operators
+    // =====================================
+
+    // Addition and subtraction
+        friend _D3DVECTOR operator + (const _D3DVECTOR& v1, const _D3DVECTOR& v2);
+        friend _D3DVECTOR operator - (const _D3DVECTOR& v1, const _D3DVECTOR& v2);
+    // Scalar multiplication and division
+        friend _D3DVECTOR operator * (const _D3DVECTOR& v, D3DVALUE s);
+        friend _D3DVECTOR operator * (D3DVALUE s, const _D3DVECTOR& v);
+        friend _D3DVECTOR operator / (const _D3DVECTOR& v, D3DVALUE s);
+    // Memberwise multiplication and division
+        friend _D3DVECTOR operator * (const _D3DVECTOR& v1, const _D3DVECTOR& v2);
+        friend _D3DVECTOR operator / (const _D3DVECTOR& v1, const _D3DVECTOR& v2);
+
+    // Vector dominance
+        friend int operator < (const _D3DVECTOR& v1, const _D3DVECTOR& v2);
+        friend int operator <= (const _D3DVECTOR& v1, const _D3DVECTOR& v2);
+
+    // Bitwise equality
+        friend int operator == (const _D3DVECTOR& v1, const _D3DVECTOR& v2);
+
+    // Length-related functions
+        friend D3DVALUE SquareMagnitude (const _D3DVECTOR& v);
+        friend D3DVALUE Magnitude (const _D3DVECTOR& v);
+
+    // Returns vector with same direction and unit length
+        friend _D3DVECTOR Normalize (const _D3DVECTOR& v);
+
+    // Return min/max component of the input vector
+        friend D3DVALUE Min (const _D3DVECTOR& v);
+        friend D3DVALUE Max (const _D3DVECTOR& v);
+
+    // Return memberwise min/max of input vectors
+        friend _D3DVECTOR Minimize (const _D3DVECTOR& v1, const _D3DVECTOR& v2);
+        friend _D3DVECTOR Maximize (const _D3DVECTOR& v1, const _D3DVECTOR& v2);
+
+    // Dot and cross product
+        friend D3DVALUE DotProduct (const _D3DVECTOR& v1, const _D3DVECTOR& v2);
+        friend _D3DVECTOR CrossProduct (const _D3DVECTOR& v1, const _D3DVECTOR& v2);
+
+#endif
+
+} D3DVECTOR, *LPD3DVECTOR;
+
+#if (defined __cplusplus) && (defined D3D_OVERLOADS)
+#include "d3dvec.inl"
+#endif
+
+/*
+ * Vertex data types supported in an ExecuteBuffer.
+ */
+
+/*
+ * Homogeneous vertices
+ */
+
+typedef struct _D3DHVERTEX {
+    DWORD           dwFlags;        /* Homogeneous clipping flags */
+    union {
+	D3DVALUE    hx;
+	D3DVALUE    dvHX;
+    };
+    union {
+	D3DVALUE    hy;
+	D3DVALUE    dvHY;
+    };
+    union {
+	D3DVALUE    hz;
+	D3DVALUE    dvHZ;
+    };
+} D3DHVERTEX, *LPD3DHVERTEX;
+
+/*
+ * Transformed/lit vertices
+ */
+typedef struct _D3DTLVERTEX {
+    union {
+	D3DVALUE    sx;             /* Screen coordinates */
+	D3DVALUE    dvSX;
+    };
+    union {
+	D3DVALUE    sy;
+	D3DVALUE    dvSY;
+    };
+    union {
+	D3DVALUE    sz;
+	D3DVALUE    dvSZ;
+    };
+    union {
+	D3DVALUE    rhw;	    /* Reciprocal of homogeneous w */
+	D3DVALUE    dvRHW;
+    };
+    union {
+	D3DCOLOR    color;          /* Vertex color */
+	D3DCOLOR    dcColor;
+    };
+    union {
+	D3DCOLOR    specular;       /* Specular component of vertex */
+	D3DCOLOR    dcSpecular;
+    };
+    union {
+	D3DVALUE    tu;             /* Texture coordinates */
+	D3DVALUE    dvTU;
+    };
+    union {
+	D3DVALUE    tv;
+	D3DVALUE    dvTV;
+    };
+#if (defined __cplusplus) && (defined D3D_OVERLOADS)
+    _D3DTLVERTEX() { }
+    _D3DTLVERTEX(const D3DVECTOR& v, float _rhw,
+                 D3DCOLOR _color, D3DCOLOR _specular,
+                 float _tu, float _tv)
+        { sx = v.x; sy = v.y; sz = v.z; rhw = _rhw;
+          color = _color; specular = _specular;
+          tu = _tu; tv = _tv;
+        }
+#endif
+} D3DTLVERTEX, *LPD3DTLVERTEX;
+
+/*
+ * Untransformed/lit vertices
+ */
+typedef struct _D3DLVERTEX {
+    union {
+	D3DVALUE     x;             /* Homogeneous coordinates */
+	D3DVALUE     dvX;
+    };
+    union {
+	D3DVALUE     y;
+	D3DVALUE     dvY;
+    };
+    union {
+	D3DVALUE     z;
+	D3DVALUE     dvZ;
+    };
+    DWORD            dwReserved;
+    union {
+	D3DCOLOR     color;         /* Vertex color */
+	D3DCOLOR     dcColor;
+    };
+    union {
+	D3DCOLOR     specular;      /* Specular component of vertex */
+	D3DCOLOR     dcSpecular;
+    };
+    union {
+	D3DVALUE     tu;            /* Texture coordinates */
+	D3DVALUE     dvTU;
+    };
+    union {
+	D3DVALUE     tv;
+	D3DVALUE     dvTV;
+    };
+#if (defined __cplusplus) && (defined D3D_OVERLOADS)
+    _D3DLVERTEX() { }
+    _D3DLVERTEX(const D3DVECTOR& v,
+                D3DCOLOR _color, D3DCOLOR _specular,
+                float _tu, float _tv)
+        { x = v.x; y = v.y; z = v.z; dwReserved = 0;
+          color = _color; specular = _specular;
+          tu = _tu; tv = _tv;
+        }
+#endif
+} D3DLVERTEX, *LPD3DLVERTEX;
+
+/*
+ * Untransformed/unlit vertices
+ */
+
+typedef struct _D3DVERTEX {
+    union {
+	D3DVALUE     x;             /* Homogeneous coordinates */
+	D3DVALUE     dvX;
+    };
+    union {
+	D3DVALUE     y;
+	D3DVALUE     dvY;
+    };
+    union {
+	D3DVALUE     z;
+	D3DVALUE     dvZ;
+    };
+    union {
+	D3DVALUE     nx;            /* Normal */
+	D3DVALUE     dvNX;
+    };
+    union {
+	D3DVALUE     ny;
+	D3DVALUE     dvNY;
+    };
+    union {
+	D3DVALUE     nz;
+	D3DVALUE     dvNZ;
+    };
+    union {
+	D3DVALUE     tu;            /* Texture coordinates */
+	D3DVALUE     dvTU;
+    };
+    union {
+	D3DVALUE     tv;
+	D3DVALUE     dvTV;
+    };
+#if (defined __cplusplus) && (defined D3D_OVERLOADS)
+    _D3DVERTEX() { }
+    _D3DVERTEX(const D3DVECTOR& v, const D3DVECTOR& n, float _tu, float _tv)
+        { x = v.x; y = v.y; z = v.z;
+          nx = n.x; ny = n.y; nz = n.z;
+          tu = _tu; tv = _tv;
+        }
+#endif
+} D3DVERTEX, *LPD3DVERTEX;
+
+/*
+ * Matrix, viewport, and tranformation structures and definitions.
+ */
+
+typedef struct _D3DMATRIX {
+#if (defined __cplusplus) && (defined D3D_OVERLOADS)
+    union {
+        struct {
+#endif
+
+            D3DVALUE        _11, _12, _13, _14;
+            D3DVALUE        _21, _22, _23, _24;
+            D3DVALUE        _31, _32, _33, _34;
+            D3DVALUE        _41, _42, _43, _44;
+
+#if (defined __cplusplus) && (defined D3D_OVERLOADS)
+        };
+        D3DVALUE m[4][4];
+    };
+    _D3DMATRIX() { }
+    _D3DMATRIX( D3DVALUE _m00, D3DVALUE _m01, D3DVALUE _m02, D3DVALUE _m03,
+                D3DVALUE _m10, D3DVALUE _m11, D3DVALUE _m12, D3DVALUE _m13,
+                D3DVALUE _m20, D3DVALUE _m21, D3DVALUE _m22, D3DVALUE _m23,
+                D3DVALUE _m30, D3DVALUE _m31, D3DVALUE _m32, D3DVALUE _m33
+        ) 
+        {
+                m[0][0] = _m00; m[0][1] = _m01; m[0][2] = _m02; m[0][3] = _m03;
+                m[1][0] = _m10; m[1][1] = _m11; m[1][2] = _m12; m[1][3] = _m13;
+                m[2][0] = _m20; m[2][1] = _m21; m[2][2] = _m22; m[2][3] = _m23;
+                m[3][0] = _m30; m[3][1] = _m31; m[3][2] = _m32; m[3][3] = _m33;
+        }
+
+    D3DVALUE& operator()(int iRow, int iColumn) { return m[iRow][iColumn]; }
+    const D3DVALUE& operator()(int iRow, int iColumn) const { return m[iRow][iColumn]; }
+#endif
+} D3DMATRIX, *LPD3DMATRIX;
+
+typedef struct _D3DVIEWPORT {
+    DWORD       dwSize;
+    DWORD       dwX;
+    DWORD       dwY;		/* Top left */
+    DWORD       dwWidth;
+    DWORD       dwHeight;	/* Dimensions */
+    D3DVALUE    dvScaleX;	/* Scale homogeneous to screen */
+    D3DVALUE    dvScaleY;	/* Scale homogeneous to screen */
+    D3DVALUE    dvMaxX;		/* Min/max homogeneous x coord */
+    D3DVALUE    dvMaxY;		/* Min/max homogeneous y coord */
+    D3DVALUE    dvMinZ;
+    D3DVALUE    dvMaxZ;		/* Min/max homogeneous z coord */
+} D3DVIEWPORT, *LPD3DVIEWPORT;
+
+typedef struct _D3DVIEWPORT2 {
+    DWORD       dwSize;
+    DWORD       dwX;
+    DWORD       dwY;		/* Viewport Top left */
+    DWORD       dwWidth;
+    DWORD       dwHeight;	/* Viewport Dimensions */
+    D3DVALUE    dvClipX;		/* Top left of clip volume */
+    D3DVALUE    dvClipY;	
+    D3DVALUE    dvClipWidth;	/* Clip Volume Dimensions */
+    D3DVALUE    dvClipHeight;
+    D3DVALUE    dvMinZ;			/* Min/max of clip Volume */
+    D3DVALUE    dvMaxZ;		
+} D3DVIEWPORT2, *LPD3DVIEWPORT2;
+
+/*
+ * Values for clip fields.
+ */
+#define D3DCLIP_LEFT				0x00000001L
+#define D3DCLIP_RIGHT				0x00000002L
+#define D3DCLIP_TOP				0x00000004L
+#define D3DCLIP_BOTTOM				0x00000008L
+#define D3DCLIP_FRONT				0x00000010L
+#define D3DCLIP_BACK				0x00000020L
+#define D3DCLIP_GEN0				0x00000040L
+#define D3DCLIP_GEN1				0x00000080L
+#define D3DCLIP_GEN2				0x00000100L
+#define D3DCLIP_GEN3				0x00000200L
+#define D3DCLIP_GEN4				0x00000400L
+#define D3DCLIP_GEN5				0x00000800L
+
+/*
+ * Values for d3d status.
+ */
+#define D3DSTATUS_CLIPUNIONLEFT			D3DCLIP_LEFT
+#define D3DSTATUS_CLIPUNIONRIGHT		D3DCLIP_RIGHT
+#define D3DSTATUS_CLIPUNIONTOP			D3DCLIP_TOP
+#define D3DSTATUS_CLIPUNIONBOTTOM		D3DCLIP_BOTTOM
+#define D3DSTATUS_CLIPUNIONFRONT		D3DCLIP_FRONT
+#define D3DSTATUS_CLIPUNIONBACK			D3DCLIP_BACK
+#define D3DSTATUS_CLIPUNIONGEN0			D3DCLIP_GEN0
+#define D3DSTATUS_CLIPUNIONGEN1			D3DCLIP_GEN1
+#define D3DSTATUS_CLIPUNIONGEN2			D3DCLIP_GEN2
+#define D3DSTATUS_CLIPUNIONGEN3			D3DCLIP_GEN3
+#define D3DSTATUS_CLIPUNIONGEN4			D3DCLIP_GEN4
+#define D3DSTATUS_CLIPUNIONGEN5			D3DCLIP_GEN5
+
+#define D3DSTATUS_CLIPINTERSECTIONLEFT		0x00001000L
+#define D3DSTATUS_CLIPINTERSECTIONRIGHT		0x00002000L
+#define D3DSTATUS_CLIPINTERSECTIONTOP		0x00004000L
+#define D3DSTATUS_CLIPINTERSECTIONBOTTOM	0x00008000L
+#define D3DSTATUS_CLIPINTERSECTIONFRONT		0x00010000L
+#define D3DSTATUS_CLIPINTERSECTIONBACK		0x00020000L
+#define D3DSTATUS_CLIPINTERSECTIONGEN0		0x00040000L
+#define D3DSTATUS_CLIPINTERSECTIONGEN1		0x00080000L
+#define D3DSTATUS_CLIPINTERSECTIONGEN2		0x00100000L
+#define D3DSTATUS_CLIPINTERSECTIONGEN3		0x00200000L
+#define D3DSTATUS_CLIPINTERSECTIONGEN4		0x00400000L
+#define D3DSTATUS_CLIPINTERSECTIONGEN5		0x00800000L
+#define D3DSTATUS_ZNOTVISIBLE				0x01000000L
+/* Do not use 0x80000000 for any status flags in future as it is reserved */
+
+#define D3DSTATUS_CLIPUNIONALL	(		\
+	    D3DSTATUS_CLIPUNIONLEFT	|	\
+	    D3DSTATUS_CLIPUNIONRIGHT	|	\
+	    D3DSTATUS_CLIPUNIONTOP	|	\
+	    D3DSTATUS_CLIPUNIONBOTTOM	|	\
+	    D3DSTATUS_CLIPUNIONFRONT	|	\
+	    D3DSTATUS_CLIPUNIONBACK	|	\
+	    D3DSTATUS_CLIPUNIONGEN0	|	\
+	    D3DSTATUS_CLIPUNIONGEN1	|	\
+	    D3DSTATUS_CLIPUNIONGEN2	|	\
+	    D3DSTATUS_CLIPUNIONGEN3	|	\
+	    D3DSTATUS_CLIPUNIONGEN4	|	\
+	    D3DSTATUS_CLIPUNIONGEN5		\
+	    )
+
+#define D3DSTATUS_CLIPINTERSECTIONALL	(		\
+	    D3DSTATUS_CLIPINTERSECTIONLEFT	|	\
+	    D3DSTATUS_CLIPINTERSECTIONRIGHT	|	\
+	    D3DSTATUS_CLIPINTERSECTIONTOP	|	\
+	    D3DSTATUS_CLIPINTERSECTIONBOTTOM	|	\
+	    D3DSTATUS_CLIPINTERSECTIONFRONT	|	\
+	    D3DSTATUS_CLIPINTERSECTIONBACK	|	\
+	    D3DSTATUS_CLIPINTERSECTIONGEN0	|	\
+	    D3DSTATUS_CLIPINTERSECTIONGEN1	|	\
+	    D3DSTATUS_CLIPINTERSECTIONGEN2	|	\
+	    D3DSTATUS_CLIPINTERSECTIONGEN3	|	\
+	    D3DSTATUS_CLIPINTERSECTIONGEN4	|	\
+	    D3DSTATUS_CLIPINTERSECTIONGEN5		\
+	    )
+
+#define D3DSTATUS_DEFAULT	(			\
+	    D3DSTATUS_CLIPINTERSECTIONALL	|	\
+	    D3DSTATUS_ZNOTVISIBLE)
+
+
+/*
+ * Options for direct transform calls
+ */
+#define D3DTRANSFORM_CLIPPED       0x00000001l
+#define D3DTRANSFORM_UNCLIPPED     0x00000002l
+
+typedef struct _D3DTRANSFORMDATA {
+    DWORD           dwSize;
+    LPVOID	    lpIn;           /* Input vertices */
+    DWORD           dwInSize;       /* Stride of input vertices */
+    LPVOID	    lpOut;          /* Output vertices */
+    DWORD           dwOutSize;      /* Stride of output vertices */
+    LPD3DHVERTEX    lpHOut;         /* Output homogeneous vertices */
+    DWORD           dwClip;         /* Clipping hint */
+    DWORD           dwClipIntersection;
+    DWORD           dwClipUnion;    /* Union of all clip flags */
+    D3DRECT         drExtent;       /* Extent of transformed vertices */
+} D3DTRANSFORMDATA, *LPD3DTRANSFORMDATA;
+
+/*
+ * Structure defining position and direction properties for lighting.
+ */
+typedef struct _D3DLIGHTINGELEMENT {
+    D3DVECTOR dvPosition;     	    /* Lightable point in model space */
+    D3DVECTOR dvNormal;             /* Normalised unit vector */
+} D3DLIGHTINGELEMENT, *LPD3DLIGHTINGELEMENT;
+
+/*
+ * Structure defining material properties for lighting.
+ */
+typedef struct _D3DMATERIAL {
+    DWORD       	dwSize;
+    union {
+	D3DCOLORVALUE   diffuse;        /* Diffuse color RGBA */
+	D3DCOLORVALUE   dcvDiffuse;
+    };
+    union {
+	D3DCOLORVALUE   ambient;        /* Ambient color RGB */
+	D3DCOLORVALUE   dcvAmbient;
+    };
+    union {
+	D3DCOLORVALUE   specular;       /* Specular 'shininess' */
+	D3DCOLORVALUE   dcvSpecular;
+    };
+    union {
+	D3DCOLORVALUE	emissive;       /* Emissive color RGB */
+	D3DCOLORVALUE	dcvEmissive;
+    };
+    union {
+	D3DVALUE    	power;          /* Sharpness if specular highlight */
+	D3DVALUE    	dvPower;
+    };
+    D3DTEXTUREHANDLE    hTexture;   	/* Handle to texture map */
+    DWORD       	dwRampSize;
+} D3DMATERIAL, *LPD3DMATERIAL;
+
+typedef enum _D3DLIGHTTYPE {
+    D3DLIGHT_POINT          = 1,
+    D3DLIGHT_SPOT           = 2,
+    D3DLIGHT_DIRECTIONAL    = 3,
+    D3DLIGHT_PARALLELPOINT  = 4,
+    D3DLIGHT_FORCE_DWORD    = 0x7fffffff, /* force 32-bit size enum */
+} D3DLIGHTTYPE;
+
+/*
+ * Structure defining a light source and its properties.
+ */
+typedef struct _D3DLIGHT {
+    DWORD           dwSize;
+    D3DLIGHTTYPE    dltType;           	/* Type of light source */
+    D3DCOLORVALUE   dcvColor;		/* Color of light */
+    D3DVECTOR       dvPosition;		/* Position in world space */
+    D3DVECTOR       dvDirection;        /* Direction in world space */
+    D3DVALUE        dvRange;            /* Cutoff range */
+    D3DVALUE        dvFalloff;          /* Falloff */
+    D3DVALUE        dvAttenuation0;     /* Constant attenuation */
+    D3DVALUE        dvAttenuation1;     /* Linear attenuation */
+    D3DVALUE        dvAttenuation2;     /* Quadratic attenuation */
+    D3DVALUE        dvTheta;            /* Inner angle of spotlight cone */
+    D3DVALUE        dvPhi;              /* Outer angle of spotlight cone */
+} D3DLIGHT, *LPD3DLIGHT;
+
+/*
+ * Structure defining a light source and its properties.
+ */
+
+/* flags bits */
+#define D3DLIGHT_ACTIVE			0x00000001
+#define D3DLIGHT_NO_SPECULAR	0x00000002
+
+/* maximum valid light range */
+#define D3DLIGHT_RANGE_MAX		((float)sqrt(FLT_MAX))
+
+typedef struct _D3DLIGHT2 {
+    DWORD           dwSize;
+    D3DLIGHTTYPE    dltType;		/* Type of light source */
+    D3DCOLORVALUE   dcvColor;		/* Color of light */
+    D3DVECTOR       dvPosition;		/* Position in world space */
+    D3DVECTOR       dvDirection;	/* Direction in world space */
+    D3DVALUE        dvRange;		/* Cutoff range */
+    D3DVALUE        dvFalloff;		/* Falloff */
+    D3DVALUE        dvAttenuation0;	/* Constant attenuation */
+    D3DVALUE        dvAttenuation1;	/* Linear attenuation */
+    D3DVALUE        dvAttenuation2;	/* Quadratic attenuation */
+    D3DVALUE        dvTheta;		/* Inner angle of spotlight cone */
+    D3DVALUE        dvPhi;			/* Outer angle of spotlight cone */
+	DWORD			dwFlags;
+} D3DLIGHT2, *LPD3DLIGHT2;
+
+typedef struct _D3DLIGHTDATA {
+    DWORD                dwSize;
+    LPD3DLIGHTINGELEMENT lpIn;		/* Input positions and normals */
+    DWORD                dwInSize;	/* Stride of input elements */
+    LPD3DTLVERTEX        lpOut;		/* Output colors */
+    DWORD                dwOutSize;	/* Stride of output colors */
+} D3DLIGHTDATA, *LPD3DLIGHTDATA;
+
+/*
+ * Before DX5, these values were in an enum called
+ * D3DCOLORMODEL. This was not correct, since they are
+ * bit flags. A driver can surface either or both flags
+ * in the dcmColorModel member of D3DDEVICEDESC.
+ */
+#define D3DCOLOR_MONO   1
+#define D3DCOLOR_RGB    2
+
+typedef DWORD D3DCOLORMODEL;
+
+/*
+ * Options for clearing
+ */
+#define D3DCLEAR_TARGET            0x00000001l /* Clear target surface */
+#define D3DCLEAR_ZBUFFER           0x00000002l /* Clear target z buffer */
+
+/*
+ * Execute buffers are allocated via Direct3D.  These buffers may then
+ * be filled by the application with instructions to execute along with
+ * vertex data.
+ */
+
+/*
+ * Supported op codes for execute instructions.
+ */
+typedef enum _D3DOPCODE {
+    D3DOP_POINT             	= 1,
+    D3DOP_LINE              	= 2,
+    D3DOP_TRIANGLE		= 3,
+    D3DOP_MATRIXLOAD       	= 4,
+    D3DOP_MATRIXMULTIPLY   	= 5,
+    D3DOP_STATETRANSFORM      	= 6,
+    D3DOP_STATELIGHT      	= 7,
+    D3DOP_STATERENDER      	= 8,
+    D3DOP_PROCESSVERTICES    	= 9,
+    D3DOP_TEXTURELOAD      	= 10,
+    D3DOP_EXIT              	= 11,
+    D3DOP_BRANCHFORWARD		= 12,
+    D3DOP_SPAN			= 13,
+    D3DOP_SETSTATUS		= 14,
+    D3DOP_FORCE_DWORD           = 0x7fffffff, /* force 32-bit size enum */
+} D3DOPCODE;
+
+typedef struct _D3DINSTRUCTION {
+    BYTE bOpcode;   /* Instruction opcode */
+    BYTE bSize;     /* Size of each instruction data unit */
+    WORD wCount;    /* Count of instruction data units to follow */
+} D3DINSTRUCTION, *LPD3DINSTRUCTION;
+
+/*
+ * Structure for texture loads
+ */
+typedef struct _D3DTEXTURELOAD {
+    D3DTEXTUREHANDLE hDestTexture;
+    D3DTEXTUREHANDLE hSrcTexture;
+} D3DTEXTURELOAD, *LPD3DTEXTURELOAD;
+
+/*
+ * Structure for picking
+ */
+typedef struct _D3DPICKRECORD {
+    BYTE     bOpcode;
+    BYTE     bPad;
+    DWORD    dwOffset;
+    D3DVALUE dvZ;
+} D3DPICKRECORD, *LPD3DPICKRECORD;
+
+/*
+ * The following defines the rendering states which can be set in the
+ * execute buffer.
+ */
+
+typedef enum _D3DSHADEMODE {
+    D3DSHADE_FLAT              = 1,
+    D3DSHADE_GOURAUD           = 2,
+    D3DSHADE_PHONG             = 3,
+    D3DSHADE_FORCE_DWORD       = 0x7fffffff, /* force 32-bit size enum */
+} D3DSHADEMODE;
+
+typedef enum _D3DFILLMODE {
+    D3DFILL_POINT	       = 1,
+    D3DFILL_WIREFRAME	       = 2,
+    D3DFILL_SOLID	       = 3,
+    D3DFILL_FORCE_DWORD        = 0x7fffffff, /* force 32-bit size enum */
+} D3DFILLMODE;
+
+typedef struct _D3DLINEPATTERN {
+    WORD	wRepeatFactor;
+    WORD	wLinePattern;
+} D3DLINEPATTERN;
+
+typedef enum _D3DTEXTUREFILTER {
+    D3DFILTER_NEAREST          = 1,
+    D3DFILTER_LINEAR           = 2,
+    D3DFILTER_MIPNEAREST       = 3,
+    D3DFILTER_MIPLINEAR        = 4,
+    D3DFILTER_LINEARMIPNEAREST = 5,
+    D3DFILTER_LINEARMIPLINEAR  = 6,
+    D3DFILTER_FORCE_DWORD      = 0x7fffffff, /* force 32-bit size enum */
+} D3DTEXTUREFILTER;
+
+typedef enum _D3DBLEND {
+    D3DBLEND_ZERO              = 1,
+    D3DBLEND_ONE               = 2,
+    D3DBLEND_SRCCOLOR          = 3,
+    D3DBLEND_INVSRCCOLOR       = 4,
+    D3DBLEND_SRCALPHA          = 5,
+    D3DBLEND_INVSRCALPHA       = 6,
+    D3DBLEND_DESTALPHA         = 7,
+    D3DBLEND_INVDESTALPHA      = 8,
+    D3DBLEND_DESTCOLOR         = 9,
+    D3DBLEND_INVDESTCOLOR      = 10,
+    D3DBLEND_SRCALPHASAT       = 11,
+    D3DBLEND_BOTHSRCALPHA      = 12,
+    D3DBLEND_BOTHINVSRCALPHA   = 13,
+    D3DBLEND_FORCE_DWORD       = 0x7fffffff, /* force 32-bit size enum */
+} D3DBLEND;
+
+typedef enum _D3DTEXTUREBLEND {
+    D3DTBLEND_DECAL            = 1,
+    D3DTBLEND_MODULATE         = 2,
+    D3DTBLEND_DECALALPHA       = 3,
+    D3DTBLEND_MODULATEALPHA    = 4,
+    D3DTBLEND_DECALMASK        = 5,
+    D3DTBLEND_MODULATEMASK     = 6,
+    D3DTBLEND_COPY             = 7,
+    D3DTBLEND_ADD              = 8,
+    D3DTBLEND_FORCE_DWORD      = 0x7fffffff, /* force 32-bit size enum */
+} D3DTEXTUREBLEND;
+
+typedef enum _D3DTEXTUREADDRESS {
+    D3DTADDRESS_WRAP	       = 1,
+    D3DTADDRESS_MIRROR	       = 2,
+    D3DTADDRESS_CLAMP	       = 3,
+    D3DTADDRESS_BORDER         = 4,
+    D3DTADDRESS_FORCE_DWORD    = 0x7fffffff, /* force 32-bit size enum */
+} D3DTEXTUREADDRESS;
+
+typedef enum _D3DCULL {
+    D3DCULL_NONE               = 1,
+    D3DCULL_CW                 = 2,
+    D3DCULL_CCW                = 3,
+    D3DCULL_FORCE_DWORD        = 0x7fffffff, /* force 32-bit size enum */
+} D3DCULL;
+
+typedef enum _D3DCMPFUNC {
+    D3DCMP_NEVER               = 1,
+    D3DCMP_LESS                = 2,
+    D3DCMP_EQUAL               = 3,
+    D3DCMP_LESSEQUAL           = 4,
+    D3DCMP_GREATER             = 5,
+    D3DCMP_NOTEQUAL            = 6,
+    D3DCMP_GREATEREQUAL        = 7,
+    D3DCMP_ALWAYS              = 8,
+    D3DCMP_FORCE_DWORD         = 0x7fffffff, /* force 32-bit size enum */
+} D3DCMPFUNC;
+
+typedef enum _D3DFOGMODE {
+    D3DFOG_NONE                = 0,
+    D3DFOG_EXP                 = 1,
+    D3DFOG_EXP2                = 2,
+    D3DFOG_LINEAR              = 3,
+    D3DFOG_FORCE_DWORD         = 0x7fffffff, /* force 32-bit size enum */
+} D3DFOGMODE;
+
+typedef enum _D3DANTIALIASMODE {
+    D3DANTIALIAS_NONE          = 0,
+    D3DANTIALIAS_SORTDEPENDENT = 1,
+    D3DANTIALIAS_SORTINDEPENDENT = 2,
+    D3DANTIALIAS_FORCE_DWORD   = 0x7fffffff, /* force 32-bit size enum */
+} D3DANTIALIASMODE;
+
+// Vertex types supported by Direct3D
+typedef enum _D3DVERTEXTYPE {
+    D3DVT_VERTEX        = 1,
+    D3DVT_LVERTEX       = 2,
+    D3DVT_TLVERTEX      = 3,
+    D3DVT_FORCE_DWORD   = 0x7fffffff, /* force 32-bit size enum */
+} D3DVERTEXTYPE;
+
+// Primitives supported by draw-primitive API
+typedef enum _D3DPRIMITIVETYPE {
+    D3DPT_POINTLIST     = 1,
+    D3DPT_LINELIST      = 2,
+    D3DPT_LINESTRIP     = 3,
+    D3DPT_TRIANGLELIST  = 4,
+    D3DPT_TRIANGLESTRIP = 5,
+    D3DPT_TRIANGLEFAN   = 6,
+    D3DPT_FORCE_DWORD   = 0x7fffffff, /* force 32-bit size enum */
+} D3DPRIMITIVETYPE;
+
+/*
+ * Amount to add to a state to generate the override for that state.
+ */
+#define D3DSTATE_OVERRIDE_BIAS		256
+
+/*
+ * A state which sets the override flag for the specified state type.
+ */
+#define D3DSTATE_OVERRIDE(type) ((DWORD) (type) + D3DSTATE_OVERRIDE_BIAS)
+
+typedef enum _D3DTRANSFORMSTATETYPE {
+    D3DTRANSFORMSTATE_WORLD           = 1,
+    D3DTRANSFORMSTATE_VIEW            = 2,
+    D3DTRANSFORMSTATE_PROJECTION      = 3,
+    D3DTRANSFORMSTATE_FORCE_DWORD     = 0x7fffffff, /* force 32-bit size enum */
+} D3DTRANSFORMSTATETYPE;
+
+typedef enum _D3DLIGHTSTATETYPE {
+    D3DLIGHTSTATE_MATERIAL	      = 1,
+    D3DLIGHTSTATE_AMBIENT	      = 2,
+    D3DLIGHTSTATE_COLORMODEL	      = 3,
+    D3DLIGHTSTATE_FOGMODE	      = 4,
+    D3DLIGHTSTATE_FOGSTART	      = 5,
+    D3DLIGHTSTATE_FOGEND	      = 6,
+    D3DLIGHTSTATE_FOGDENSITY          = 7,
+    D3DLIGHTSTATE_FORCE_DWORD         = 0x7fffffff, /* force 32-bit size enum */
+} D3DLIGHTSTATETYPE;
+
+typedef enum _D3DRENDERSTATETYPE {
+    D3DRENDERSTATE_TEXTUREHANDLE      = 1,    /* Texture handle */
+    D3DRENDERSTATE_ANTIALIAS          = 2,    /* D3DANTIALIASMODE */
+    D3DRENDERSTATE_TEXTUREADDRESS     = 3,    /* D3DTEXTUREADDRESS	*/
+    D3DRENDERSTATE_TEXTUREPERSPECTIVE = 4,    /* TRUE for perspective correction */
+    D3DRENDERSTATE_WRAPU	      = 5,    /* TRUE for wrapping in u */
+    D3DRENDERSTATE_WRAPV	      = 6,    /* TRUE for wrapping in v */
+    D3DRENDERSTATE_ZENABLE            = 7,    /* TRUE to enable z test */
+    D3DRENDERSTATE_FILLMODE           = 8,    /* D3DFILL_MODE		 */
+    D3DRENDERSTATE_SHADEMODE          = 9,    /* D3DSHADEMODE */
+    D3DRENDERSTATE_LINEPATTERN        = 10,   /* D3DLINEPATTERN */
+    D3DRENDERSTATE_MONOENABLE         = 11,   /* TRUE to enable mono rasterization */
+    D3DRENDERSTATE_ROP2               = 12,   /* ROP2 */
+    D3DRENDERSTATE_PLANEMASK          = 13,   /* DWORD physical plane mask */
+    D3DRENDERSTATE_ZWRITEENABLE       = 14,   /* TRUE to enable z writes */
+    D3DRENDERSTATE_ALPHATESTENABLE    = 15,   /* TRUE to enable alpha tests */
+    D3DRENDERSTATE_LASTPIXEL          = 16,   /* TRUE for last-pixel on lines */
+    D3DRENDERSTATE_TEXTUREMAG         = 17,   /* D3DTEXTUREFILTER */
+    D3DRENDERSTATE_TEXTUREMIN         = 18,   /* D3DTEXTUREFILTER */
+    D3DRENDERSTATE_SRCBLEND           = 19,   /* D3DBLEND */
+    D3DRENDERSTATE_DESTBLEND          = 20,   /* D3DBLEND */
+    D3DRENDERSTATE_TEXTUREMAPBLEND    = 21,   /* D3DTEXTUREBLEND */
+    D3DRENDERSTATE_CULLMODE           = 22,   /* D3DCULL */
+    D3DRENDERSTATE_ZFUNC              = 23,   /* D3DCMPFUNC */
+    D3DRENDERSTATE_ALPHAREF           = 24,   /* D3DFIXED */
+    D3DRENDERSTATE_ALPHAFUNC          = 25,   /* D3DCMPFUNC */
+    D3DRENDERSTATE_DITHERENABLE       = 26,   /* TRUE to enable dithering */
+    D3DRENDERSTATE_ALPHABLENDENABLE   = 27,   /* TRUE to enable alpha blending */
+    D3DRENDERSTATE_FOGENABLE          = 28,   /* TRUE to enable fog */
+    D3DRENDERSTATE_SPECULARENABLE     = 29,   /* TRUE to enable specular */
+    D3DRENDERSTATE_ZVISIBLE           = 30,   /* TRUE to enable z checking */
+    D3DRENDERSTATE_SUBPIXEL	      = 31,   /* TRUE to enable subpixel correction */
+    D3DRENDERSTATE_SUBPIXELX          = 32,   /* TRUE to enable correction in X only */
+    D3DRENDERSTATE_STIPPLEDALPHA      = 33,   /* TRUE to enable stippled alpha */
+    D3DRENDERSTATE_FOGCOLOR           = 34,   /* D3DCOLOR */
+    D3DRENDERSTATE_FOGTABLEMODE       = 35,   /* D3DFOGMODE */
+    D3DRENDERSTATE_FOGTABLESTART      = 36,   /* Fog table start	*/
+    D3DRENDERSTATE_FOGTABLEEND        = 37,   /* Fog table end		*/
+    D3DRENDERSTATE_FOGTABLEDENSITY    = 38,   /* Fog table density	*/
+    D3DRENDERSTATE_STIPPLEENABLE      = 39,   /* TRUE to enable stippling */
+    D3DRENDERSTATE_EDGEANTIALIAS      = 40,   /* TRUE to enable edge antialiasing */
+    D3DRENDERSTATE_COLORKEYENABLE     = 41,   /* TRUE to enable source colorkeyed textures */
+    D3DRENDERSTATE_BORDERCOLOR        = 43,   /* Border color for texturing w/border */
+    D3DRENDERSTATE_TEXTUREADDRESSU    = 44,   /* Texture addressing mode for U coordinate */
+    D3DRENDERSTATE_TEXTUREADDRESSV    = 45,   /* Texture addressing mode for V coordinate */
+    D3DRENDERSTATE_MIPMAPLODBIAS      = 46,   /* D3DVALUE Mipmap LOD bias */
+    D3DRENDERSTATE_ZBIAS              = 47,   /* LONG Z bias */
+    D3DRENDERSTATE_RANGEFOGENABLE     = 48,   /* Enables range-based fog */
+    D3DRENDERSTATE_ANISOTROPY         = 49,   /* Max. anisotropy. 1 = no anisotropy */
+	D3DRENDERSTATE_FLUSHBATCH		  = 50,   /* Explicit flush for DP batching (DX5 Only) */
+    D3DRENDERSTATE_STIPPLEPATTERN00   = 64,   /* Stipple pattern 01...	*/
+    D3DRENDERSTATE_STIPPLEPATTERN01   = 65,
+    D3DRENDERSTATE_STIPPLEPATTERN02   = 66,
+    D3DRENDERSTATE_STIPPLEPATTERN03   = 67,
+    D3DRENDERSTATE_STIPPLEPATTERN04   = 68,
+    D3DRENDERSTATE_STIPPLEPATTERN05   = 69,
+    D3DRENDERSTATE_STIPPLEPATTERN06   = 70,
+    D3DRENDERSTATE_STIPPLEPATTERN07   = 71,
+    D3DRENDERSTATE_STIPPLEPATTERN08   = 72,
+    D3DRENDERSTATE_STIPPLEPATTERN09   = 73,
+    D3DRENDERSTATE_STIPPLEPATTERN10   = 74,
+    D3DRENDERSTATE_STIPPLEPATTERN11   = 75,
+    D3DRENDERSTATE_STIPPLEPATTERN12   = 76,
+    D3DRENDERSTATE_STIPPLEPATTERN13   = 77,
+    D3DRENDERSTATE_STIPPLEPATTERN14   = 78,
+    D3DRENDERSTATE_STIPPLEPATTERN15   = 79,
+    D3DRENDERSTATE_STIPPLEPATTERN16   = 80,
+    D3DRENDERSTATE_STIPPLEPATTERN17   = 81,
+    D3DRENDERSTATE_STIPPLEPATTERN18   = 82,
+    D3DRENDERSTATE_STIPPLEPATTERN19   = 83,
+    D3DRENDERSTATE_STIPPLEPATTERN20   = 84,
+    D3DRENDERSTATE_STIPPLEPATTERN21   = 85,
+    D3DRENDERSTATE_STIPPLEPATTERN22   = 86,
+    D3DRENDERSTATE_STIPPLEPATTERN23   = 87,
+    D3DRENDERSTATE_STIPPLEPATTERN24   = 88,
+    D3DRENDERSTATE_STIPPLEPATTERN25   = 89,
+    D3DRENDERSTATE_STIPPLEPATTERN26   = 90,
+    D3DRENDERSTATE_STIPPLEPATTERN27   = 91,
+    D3DRENDERSTATE_STIPPLEPATTERN28   = 92,
+    D3DRENDERSTATE_STIPPLEPATTERN29   = 93,
+    D3DRENDERSTATE_STIPPLEPATTERN30   = 94,
+    D3DRENDERSTATE_STIPPLEPATTERN31   = 95,
+    D3DRENDERSTATE_FORCE_DWORD        = 0x7fffffff, /* force 32-bit size enum */
+} D3DRENDERSTATETYPE;
+
+// For back-compatibility with legacy compilations
+#define D3DRENDERSTATE_BLENDENABLE      D3DRENDERSTATE_ALPHABLENDENABLE
+
+#define D3DRENDERSTATE_STIPPLEPATTERN(y) (D3DRENDERSTATE_STIPPLEPATTERN00 + (y))
+
+typedef struct _D3DSTATE {
+    union {
+	D3DTRANSFORMSTATETYPE	dtstTransformStateType;
+	D3DLIGHTSTATETYPE	dlstLightStateType;
+	D3DRENDERSTATETYPE	drstRenderStateType;
+    };
+    union {
+	DWORD			dwArg[1];
+	D3DVALUE		dvArg[1];
+    };
+} D3DSTATE, *LPD3DSTATE;
+
+/*
+ * Operation used to load matrices
+ * hDstMat = hSrcMat
+ */
+typedef struct _D3DMATRIXLOAD {
+    D3DMATRIXHANDLE hDestMatrix;   /* Destination matrix */
+    D3DMATRIXHANDLE hSrcMatrix;   /* Source matrix */
+} D3DMATRIXLOAD, *LPD3DMATRIXLOAD;
+
+/*
+ * Operation used to multiply matrices
+ * hDstMat = hSrcMat1 * hSrcMat2
+ */
+typedef struct _D3DMATRIXMULTIPLY {
+    D3DMATRIXHANDLE hDestMatrix;   /* Destination matrix */
+    D3DMATRIXHANDLE hSrcMatrix1;  /* First source matrix */
+    D3DMATRIXHANDLE hSrcMatrix2;  /* Second source matrix */
+} D3DMATRIXMULTIPLY, *LPD3DMATRIXMULTIPLY;
+
+/*
+ * Operation used to transform and light vertices.
+ */
+typedef struct _D3DPROCESSVERTICES {
+    DWORD        dwFlags;    /* Do we transform or light or just copy? */
+    WORD         wStart;     /* Index to first vertex in source	*/
+    WORD         wDest;      /* Index to first vertex in local buffer */
+    DWORD        dwCount;    /* Number of vertices to be processed */
+    DWORD	 dwReserved; /* Must be zero */
+} D3DPROCESSVERTICES, *LPD3DPROCESSVERTICES;
+
+#define D3DPROCESSVERTICES_TRANSFORMLIGHT	0x00000000L
+#define D3DPROCESSVERTICES_TRANSFORM		0x00000001L
+#define D3DPROCESSVERTICES_COPY			0x00000002L
+#define D3DPROCESSVERTICES_OPMASK		0x00000007L
+
+#define D3DPROCESSVERTICES_UPDATEEXTENTS	0x00000008L
+#define D3DPROCESSVERTICES_NOCOLOR		0x00000010L
+
+
+/*
+ * Triangle flags
+ */
+ 
+/*
+ * Tri strip and fan flags.
+ * START loads all three vertices
+ * EVEN and ODD load just v3 with even or odd culling
+ * START_FLAT contains a count from 0 to 29 that allows the
+ * whole strip or fan to be culled in one hit.
+ * e.g. for a quad len = 1
+ */
+#define D3DTRIFLAG_START			0x00000000L
+#define D3DTRIFLAG_STARTFLAT(len) (len)		/* 0 < len < 30 */
+#define D3DTRIFLAG_ODD				0x0000001eL
+#define D3DTRIFLAG_EVEN				0x0000001fL
+
+/*
+ * Triangle edge flags
+ * enable edges for wireframe or antialiasing
+ */
+#define D3DTRIFLAG_EDGEENABLE1 			0x00000100L /* v0-v1 edge */
+#define D3DTRIFLAG_EDGEENABLE2 			0x00000200L /* v1-v2 edge */
+#define D3DTRIFLAG_EDGEENABLE3 			0x00000400L /* v2-v0 edge */
+#define D3DTRIFLAG_EDGEENABLETRIANGLE \
+        (D3DTRIFLAG_EDGEENABLE1 | D3DTRIFLAG_EDGEENABLE2 | D3DTRIFLAG_EDGEENABLE3)
+	
+/*
+ * Primitive structures and related defines.  Vertex offsets are to types
+ * D3DVERTEX, D3DLVERTEX, or D3DTLVERTEX.
+ */
+
+/*
+ * Triangle list primitive structure
+ */
+typedef struct _D3DTRIANGLE {
+    union {
+	WORD    v1;            /* Vertex indices */
+	WORD    wV1;
+    };
+    union {
+	WORD    v2;
+	WORD    wV2;
+    };
+    union {
+	WORD    v3;
+	WORD    wV3;
+    };
+    WORD    	wFlags;       /* Edge (and other) flags */
+} D3DTRIANGLE, *LPD3DTRIANGLE;
+
+/*
+ * Line list structure.
+ * The instruction count defines the number of line segments.
+ */
+typedef struct _D3DLINE {
+    union {
+	WORD    v1;            /* Vertex indices */
+	WORD    wV1;
+    };
+    union {
+	WORD    v2;
+	WORD    wV2;
+    };
+} D3DLINE, *LPD3DLINE;
+
+/*
+ * Span structure
+ * Spans join a list of points with the same y value.
+ * If the y value changes, a new span is started.
+ */
+typedef struct _D3DSPAN {
+    WORD	wCount;	/* Number of spans */
+    WORD	wFirst;	/* Index to first vertex */
+} D3DSPAN, *LPD3DSPAN;
+
+/*
+ * Point structure
+ */
+typedef struct _D3DPOINT {
+    WORD	wCount;		/* number of points	    */
+    WORD	wFirst;		/* index to first vertex    */
+} D3DPOINT, *LPD3DPOINT;
+
+
+/*
+ * Forward branch structure.
+ * Mask is logically anded with the driver status mask
+ * if the result equals 'value', the branch is taken.
+ */
+typedef struct _D3DBRANCH {
+    DWORD	dwMask;		/* Bitmask against D3D status */
+    DWORD	dwValue;
+    BOOL	bNegate;    	/* TRUE to negate comparison */
+    DWORD	dwOffset;	/* How far to branch forward (0 for exit)*/
+} D3DBRANCH, *LPD3DBRANCH;
+
+/*
+ * Status used for set status instruction.
+ * The D3D status is initialised on device creation
+ * and is modified by all execute calls.
+ */
+typedef struct _D3DSTATUS {
+    DWORD       dwFlags;	/* Do we set extents or status */
+    DWORD	dwStatus;	/* D3D status */
+    D3DRECT	drExtent;
+} D3DSTATUS, *LPD3DSTATUS;
+
+#define D3DSETSTATUS_STATUS		0x00000001L
+#define D3DSETSTATUS_EXTENTS		0x00000002L
+#define D3DSETSTATUS_ALL	(D3DSETSTATUS_STATUS | D3DSETSTATUS_EXTENTS)
+
+typedef struct _D3DCLIPSTATUS {
+	DWORD dwFlags; /* Do we set 2d extents, 3D extents or status */
+	DWORD dwStatus; /* Clip status */
+	float minx, maxx; /* X extents */
+	float miny, maxy; /* Y extents */
+	float minz, maxz; /* Z extents */
+} D3DCLIPSTATUS, *LPD3DCLIPSTATUS;
+
+#define D3DCLIPSTATUS_STATUS        0x00000001L
+#define D3DCLIPSTATUS_EXTENTS2      0x00000002L
+#define D3DCLIPSTATUS_EXTENTS3      0x00000004L
+
+/*
+ * Statistics structure
+ */
+typedef struct _D3DSTATS {
+    DWORD        dwSize;
+    DWORD        dwTrianglesDrawn;
+    DWORD        dwLinesDrawn;
+    DWORD        dwPointsDrawn;
+    DWORD        dwSpansDrawn;
+    DWORD        dwVerticesProcessed;
+} D3DSTATS, *LPD3DSTATS;
+
+/*
+ * Execute options.
+ * When calling using D3DEXECUTE_UNCLIPPED all the primitives 
+ * inside the buffer must be contained within the viewport.
+ */
+#define D3DEXECUTE_CLIPPED       0x00000001l
+#define D3DEXECUTE_UNCLIPPED     0x00000002l
+
+typedef struct _D3DEXECUTEDATA {
+    DWORD       dwSize;
+    DWORD       dwVertexOffset;
+    DWORD       dwVertexCount;
+    DWORD       dwInstructionOffset;
+    DWORD       dwInstructionLength;
+    DWORD       dwHVertexOffset;
+    D3DSTATUS   dsStatus;	/* Status after execute */
+} D3DEXECUTEDATA, *LPD3DEXECUTEDATA;
+
+/*
+ * Palette flags.
+ * This are or'ed with the peFlags in the PALETTEENTRYs passed to DirectDraw.
+ */
+#define D3DPAL_FREE	0x00	/* Renderer may use this entry freely */
+#define D3DPAL_READONLY	0x40	/* Renderer may not set this entry */
+#define D3DPAL_RESERVED 0x80	/* Renderer may not use this entry */
+
+#pragma pack()
+
+#endif /* _D3DTYPES_H_ */
diff --git a/3rdparty/dx5/inc/d3dvec.inl b/3rdparty/dx5/inc/d3dvec.inl
new file mode 100644
index 00000000..39c27c4f
--- /dev/null
+++ b/3rdparty/dx5/inc/d3dvec.inl
@@ -0,0 +1,240 @@
+
+/****************************************************************** 
+ *                                                                *
+ *   D3DVec.inl                                                   *
+ *                                                                *
+ *   Float-valued 3D vector class for Direct3D.                   *
+ *                                                                *
+ *   Copyright (c) 1996-1997 Microsoft Corp. All rights reserved. *
+ *                                                                *
+ ******************************************************************/
+
+#include <math.h>
+
+// =====================================
+// Constructors
+// =====================================
+
+inline
+_D3DVECTOR::_D3DVECTOR(D3DVALUE f)
+{
+    x = y = z = f;
+}
+
+inline
+_D3DVECTOR::_D3DVECTOR(D3DVALUE _x, D3DVALUE _y, D3DVALUE _z)
+{
+    x = _x; y = _y; z = _z;
+}
+
+inline
+_D3DVECTOR::_D3DVECTOR(const D3DVALUE f[3])
+{
+    x = f[0]; y = f[1]; z = f[2];
+}
+
+// =====================================
+// Access grants
+// =====================================
+
+inline const D3DVALUE&
+_D3DVECTOR::operator[](int i) const
+{
+    return (&x)[i];
+}
+
+inline D3DVALUE&
+_D3DVECTOR::operator[](int i)
+{
+    return (&x)[i];
+}
+
+
+// =====================================
+// Assignment operators
+// =====================================
+
+inline _D3DVECTOR&
+_D3DVECTOR::operator += (const _D3DVECTOR& v)
+{
+   x += v.x;   y += v.y;   z += v.z;
+   return *this;
+}
+
+inline _D3DVECTOR&
+_D3DVECTOR::operator -= (const _D3DVECTOR& v)
+{
+   x -= v.x;   y -= v.y;   z -= v.z;
+   return *this;
+}
+
+inline _D3DVECTOR&
+_D3DVECTOR::operator *= (const _D3DVECTOR& v)
+{
+   x *= v.x;   y *= v.y;   z *= v.z;
+   return *this;
+}
+
+inline _D3DVECTOR&
+_D3DVECTOR::operator /= (const _D3DVECTOR& v)
+{
+   x /= v.x;   y /= v.y;   z /= v.z;
+   return *this;
+}
+
+inline _D3DVECTOR&
+_D3DVECTOR::operator *= (D3DVALUE s)
+{
+   x *= s;   y *= s;   z *= s;
+   return *this;
+}
+
+inline _D3DVECTOR&
+_D3DVECTOR::operator /= (D3DVALUE s)
+{
+   x /= s;   y /= s;   z /= s;
+   return *this;
+}
+
+inline _D3DVECTOR
+operator + (const _D3DVECTOR& v)
+{
+   return v;
+}
+
+inline _D3DVECTOR
+operator - (const _D3DVECTOR& v)
+{
+   return _D3DVECTOR(-v.x, -v.y, -v.z);
+}
+
+inline _D3DVECTOR
+operator + (const _D3DVECTOR& v1, const _D3DVECTOR& v2)
+{
+   return _D3DVECTOR(v1.x+v2.x, v1.y+v2.y, v1.z+v2.z);
+}
+
+inline _D3DVECTOR
+operator - (const _D3DVECTOR& v1, const _D3DVECTOR& v2)
+{
+   return _D3DVECTOR(v1.x-v2.x, v1.y-v2.y, v1.z-v2.z);
+}
+
+inline _D3DVECTOR
+operator * (const _D3DVECTOR& v1, const _D3DVECTOR& v2)
+{
+   return _D3DVECTOR(v1.x*v2.x, v1.y*v2.y, v1.z*v2.z);
+}
+
+inline _D3DVECTOR
+operator / (const _D3DVECTOR& v1, const _D3DVECTOR& v2)
+{
+   return _D3DVECTOR(v1.x/v2.x, v1.y/v2.y, v1.z/v2.z);
+}
+
+inline int
+operator < (const _D3DVECTOR& v1, const _D3DVECTOR& v2)
+{
+   return v1[0] < v2[0] && v1[1] < v2[1] && v1[2] < v2[2];
+}
+
+inline int
+operator <= (const _D3DVECTOR& v1, const _D3DVECTOR& v2)
+{
+   return v1[0] <= v2[0] && v1[1] <= v2[1] && v1[2] <= v2[2];
+}
+
+inline _D3DVECTOR
+operator * (const _D3DVECTOR& v, D3DVALUE s)
+{
+   return _D3DVECTOR(s*v.x, s*v.y, s*v.z);
+}
+
+inline _D3DVECTOR
+operator * (D3DVALUE s, const _D3DVECTOR& v)
+{
+   return _D3DVECTOR(s*v.x, s*v.y, s*v.z);
+}
+
+inline _D3DVECTOR
+operator / (const _D3DVECTOR& v, D3DVALUE s)
+{
+   return _D3DVECTOR(v.x/s, v.y/s, v.z/s);
+}
+
+inline int
+operator == (const _D3DVECTOR& v1, const _D3DVECTOR& v2)
+{
+   return v1.x==v2.x && v1.y==v2.y && v1.z == v2.z;
+}
+
+inline D3DVALUE
+Magnitude (const _D3DVECTOR& v)
+{
+   return (D3DVALUE) sqrt(SquareMagnitude(v));
+}
+
+inline D3DVALUE
+SquareMagnitude (const _D3DVECTOR& v)
+{
+   return v.x*v.x + v.y*v.y + v.z*v.z;
+}
+
+inline _D3DVECTOR
+Normalize (const _D3DVECTOR& v)
+{
+   return v / Magnitude(v);
+}
+
+inline D3DVALUE
+Min (const _D3DVECTOR& v)
+{
+   D3DVALUE ret = v.x;
+   if (v.y < ret) ret = v.y;
+   if (v.z < ret) ret = v.z;
+   return ret;
+}
+
+inline D3DVALUE
+Max (const _D3DVECTOR& v)
+{
+   D3DVALUE ret = v.x;
+   if (ret < v.y) ret = v.y;
+   if (ret < v.z) ret = v.z;
+   return ret;
+}
+
+inline _D3DVECTOR
+Minimize (const _D3DVECTOR& v1, const _D3DVECTOR& v2)
+{
+   return _D3DVECTOR( v1[0] < v2[0] ? v1[0] : v2[0],
+                   v1[1] < v2[1] ? v1[1] : v2[1],
+                   v1[2] < v2[2] ? v1[2] : v2[2]);
+}
+
+inline _D3DVECTOR
+Maximize (const _D3DVECTOR& v1, const _D3DVECTOR& v2)
+{
+   return _D3DVECTOR( v1[0] > v2[0] ? v1[0] : v2[0],
+                   v1[1] > v2[1] ? v1[1] : v2[1],
+                   v1[2] > v2[2] ? v1[2] : v2[2]);
+}
+
+inline D3DVALUE
+DotProduct (const _D3DVECTOR& v1, const _D3DVECTOR& v2)
+{
+   return v1.x*v2.x + v1.y * v2.y + v1.z*v2.z;
+}
+
+inline _D3DVECTOR
+CrossProduct (const _D3DVECTOR& v1, const _D3DVECTOR& v2)
+{
+	_D3DVECTOR result;
+
+	result[0] = v1[1] * v2[2] - v1[2] * v2[1];
+	result[1] = v1[2] * v2[0] - v1[0] * v2[2];
+	result[2] = v1[0] * v2[1] - v1[1] * v2[0];
+
+	return result;
+}
+
diff --git a/3rdparty/dx5/inc/ddraw.h b/3rdparty/dx5/inc/ddraw.h
new file mode 100644
index 00000000..7923059c
--- /dev/null
+++ b/3rdparty/dx5/inc/ddraw.h
@@ -0,0 +1,3791 @@
+/*==========================================================================;
+ *
+ *  Copyright (C) 1994-1997 Microsoft Corporation.  All Rights Reserved.
+ *
+ *  File:	ddraw.h
+ *  Content:	DirectDraw include file
+ *
+ ***************************************************************************/
+
+#ifndef __DDRAW_INCLUDED__
+#define __DDRAW_INCLUDED__
+
+/*
+ * If you wish an application built against the newest version of DirectDraw
+ * to run against an older DirectDraw run time then define DIRECTDRAW_VERSION
+ * to be the earlies version of DirectDraw you wish to run against. For,
+ * example if you wish an application to run against a DX 3 runtime define
+ * DIRECTDRAW_VERSION to be 0x0300.
+ */
+#ifndef   DIRECTDRAW_VERSION
+#define   DIRECTDRAW_VERSION 0x0500
+#endif /* DIRECTDRAW_VERSION */
+
+#if defined( _WIN32 )  && !defined( _NO_COM )
+#define COM_NO_WINDOWS_H
+#include <objbase.h>
+#else
+#define IUnknown	    void
+#if !defined( NT_BUILD_ENVIRONMENT ) && !defined(WINNT)
+	#define CO_E_NOTINITIALIZED 0x800401F0L
+#endif
+#endif
+
+#define _FACDD	0x876
+#define MAKE_DDHRESULT( code )	MAKE_HRESULT( 1, _FACDD, code )
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * GUIDS used by DirectDraw objects
+ */
+#if defined( _WIN32 ) && !defined( _NO_COM )
+DEFINE_GUID( CLSID_DirectDraw,			0xD7B70EE0,0x4340,0x11CF,0xB0,0x63,0x00,0x20,0xAF,0xC2,0xCD,0x35 );
+DEFINE_GUID( CLSID_DirectDrawClipper,           0x593817A0,0x7DB3,0x11CF,0xA2,0xDE,0x00,0xAA,0x00,0xb9,0x33,0x56 );
+DEFINE_GUID( IID_IDirectDraw,			0x6C14DB80,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 );
+DEFINE_GUID( IID_IDirectDraw2,                  0xB3A6F3E0,0x2B43,0x11CF,0xA2,0xDE,0x00,0xAA,0x00,0xB9,0x33,0x56 );
+DEFINE_GUID( IID_IDirectDrawSurface,		0x6C14DB81,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 );
+DEFINE_GUID( IID_IDirectDrawSurface2,		0x57805885,0x6eec,0x11cf,0x94,0x41,0xa8,0x23,0x03,0xc1,0x0e,0x27 );
+DEFINE_GUID( IID_IDirectDrawSurface3,           0xDA044E00,0x69B2,0x11D0,0xA1,0xD5,0x00,0xAA,0x00,0xB8,0xDF,0xBB );
+
+DEFINE_GUID( IID_IDirectDrawPalette,		0x6C14DB84,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 );
+DEFINE_GUID( IID_IDirectDrawClipper,		0x6C14DB85,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 );
+DEFINE_GUID( IID_IDirectDrawColorControl, 	0x4B9F0EE0,0x0D7E,0x11D0,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8 );
+
+#endif
+
+/*============================================================================
+ *
+ * DirectDraw Structures
+ *
+ * Various structures used to invoke DirectDraw.
+ *
+ *==========================================================================*/
+
+struct IDirectDraw;
+struct IDirectDrawSurface;
+struct IDirectDrawPalette;
+struct IDirectDrawClipper;
+
+typedef struct IDirectDraw			FAR *LPDIRECTDRAW;
+typedef struct IDirectDraw2			FAR *LPDIRECTDRAW2;
+typedef struct IDirectDrawSurface		FAR *LPDIRECTDRAWSURFACE;
+typedef struct IDirectDrawSurface2		FAR *LPDIRECTDRAWSURFACE2;
+typedef struct IDirectDrawSurface3		FAR *LPDIRECTDRAWSURFACE3;
+
+typedef struct IDirectDrawPalette		FAR *LPDIRECTDRAWPALETTE;
+typedef struct IDirectDrawClipper		FAR *LPDIRECTDRAWCLIPPER;
+typedef struct IDirectDrawColorControl		FAR *LPDIRECTDRAWCOLORCONTROL;
+
+typedef struct _DDFXROP			FAR *LPDDFXROP;
+typedef struct _DDSURFACEDESC		FAR *LPDDSURFACEDESC;
+typedef struct _DDCOLORCONTROL 		FAR *LPDDCOLORCONTROL;
+
+/*
+ * API's
+ */
+#if (defined (WIN32) || defined( _WIN32 ) ) && !defined( _NO_COM )
+//#if defined( _WIN32 ) && !defined( _NO_ENUM )
+    typedef BOOL (FAR PASCAL * LPDDENUMCALLBACKA)(GUID FAR *, LPSTR, LPSTR, LPVOID);
+    typedef BOOL (FAR PASCAL * LPDDENUMCALLBACKW)(GUID FAR *, LPWSTR, LPWSTR, LPVOID);
+    extern HRESULT WINAPI DirectDrawEnumerateW( LPDDENUMCALLBACKW lpCallback, LPVOID lpContext );
+    extern HRESULT WINAPI DirectDrawEnumerateA( LPDDENUMCALLBACKA lpCallback, LPVOID lpContext );
+    #ifdef UNICODE
+	typedef LPDDENUMCALLBACKW 	LPDDENUMCALLBACK;
+	#define DirectDrawEnumerate	DirectDrawEnumerateW
+    #else
+	typedef LPDDENUMCALLBACKA 	LPDDENUMCALLBACK;
+	#define DirectDrawEnumerate	DirectDrawEnumerateA
+    #endif
+    extern HRESULT WINAPI DirectDrawCreate( GUID FAR *lpGUID, LPDIRECTDRAW FAR *lplpDD, IUnknown FAR *pUnkOuter );
+    extern HRESULT WINAPI DirectDrawCreateClipper( DWORD dwFlags, LPDIRECTDRAWCLIPPER FAR *lplpDDClipper, IUnknown FAR *pUnkOuter );
+#endif
+
+
+#define REGSTR_KEY_DDHW_DESCRIPTION	"Description"
+#define REGSTR_KEY_DDHW_DRIVERNAME	"DriverName"
+#define REGSTR_PATH_DDHW		"Hardware\\DirectDrawDrivers"
+
+#define DDCREATE_HARDWAREONLY		0x00000001l
+#define DDCREATE_EMULATIONONLY		0x00000002l
+
+#if defined(WINNT) || !defined(WIN32)
+typedef long HRESULT;
+#endif
+
+//#ifndef WINNT
+typedef HRESULT (FAR PASCAL * LPDDENUMMODESCALLBACK)(LPDDSURFACEDESC, LPVOID);
+typedef HRESULT (FAR PASCAL * LPDDENUMSURFACESCALLBACK)(LPDIRECTDRAWSURFACE, LPDDSURFACEDESC, LPVOID);
+//#endif
+/*
+ * DDCOLORKEY
+ */
+typedef struct _DDCOLORKEY
+{
+    DWORD	dwColorSpaceLowValue;	// low boundary of color space that is to
+					// be treated as Color Key, inclusive
+    DWORD	dwColorSpaceHighValue;	// high boundary of color space that is
+					// to be treated as Color Key, inclusive
+} DDCOLORKEY;
+
+typedef DDCOLORKEY FAR* LPDDCOLORKEY;
+
+/*
+ * DDBLTFX
+ * Used to pass override information to the DIRECTDRAWSURFACE callback Blt.
+ */
+typedef struct _DDBLTFX
+{
+    DWORD	dwSize;				// size of structure
+    DWORD	dwDDFX;				// FX operations
+    DWORD	dwROP;				// Win32 raster operations
+    DWORD	dwDDROP;			// Raster operations new for DirectDraw
+    DWORD	dwRotationAngle;		// Rotation angle for blt
+    DWORD	dwZBufferOpCode;		// ZBuffer compares
+    DWORD	dwZBufferLow;			// Low limit of Z buffer
+    DWORD	dwZBufferHigh;			// High limit of Z buffer
+    DWORD	dwZBufferBaseDest;		// Destination base value
+    DWORD	dwZDestConstBitDepth;		// Bit depth used to specify Z constant for destination
+    union
+    {
+	DWORD	dwZDestConst;			// Constant to use as Z buffer for dest
+	LPDIRECTDRAWSURFACE lpDDSZBufferDest;	// Surface to use as Z buffer for dest
+    };
+    DWORD	dwZSrcConstBitDepth;		// Bit depth used to specify Z constant for source
+    union
+    {
+	DWORD	dwZSrcConst;			// Constant to use as Z buffer for src
+	LPDIRECTDRAWSURFACE lpDDSZBufferSrc;	// Surface to use as Z buffer for src
+    };
+    DWORD	dwAlphaEdgeBlendBitDepth;	// Bit depth used to specify constant for alpha edge blend
+    DWORD	dwAlphaEdgeBlend;		// Alpha for edge blending
+    DWORD	dwReserved;
+    DWORD	dwAlphaDestConstBitDepth;	// Bit depth used to specify alpha constant for destination
+    union
+    {
+	DWORD	dwAlphaDestConst;		// Constant to use as Alpha Channel
+	LPDIRECTDRAWSURFACE lpDDSAlphaDest;	// Surface to use as Alpha Channel
+    };
+    DWORD	dwAlphaSrcConstBitDepth;	// Bit depth used to specify alpha constant for source
+    union
+    {
+	DWORD	dwAlphaSrcConst;		// Constant to use as Alpha Channel
+	LPDIRECTDRAWSURFACE lpDDSAlphaSrc;	// Surface to use as Alpha Channel
+    };
+    union
+    {
+	DWORD	dwFillColor;			// color in RGB or Palettized
+	DWORD   dwFillDepth;                    // depth value for z-buffer
+	DWORD	dwFillPixel;			// pixel value for RGBA or RGBZ
+	LPDIRECTDRAWSURFACE lpDDSPattern;	// Surface to use as pattern
+    };
+    DDCOLORKEY	ddckDestColorkey;		// DestColorkey override
+    DDCOLORKEY	ddckSrcColorkey;		// SrcColorkey override
+} DDBLTFX;
+
+typedef DDBLTFX FAR* LPDDBLTFX;
+
+
+/*
+ * DDSCAPS
+ */
+typedef struct _DDSCAPS
+{
+    DWORD	dwCaps;		// capabilities of surface wanted
+} DDSCAPS;
+
+typedef DDSCAPS FAR* LPDDSCAPS;
+
+/*
+ * DDCAPS
+ */
+#define DD_ROP_SPACE		(256/32)	// space required to store ROP array
+
+#if DIRECTDRAW_VERSION >= 0x0500
+/*
+ * This structure is the DDCAPS structure as it was in version 2 and 3 of Direct X.
+ * It is present for back compatability.
+ */
+typedef struct _DDCAPS_DX3
+{
+    DWORD	dwSize;			// size of the DDDRIVERCAPS structure
+    DWORD	dwCaps;			// driver specific capabilities
+    DWORD	dwCaps2;		// more driver specific capabilites
+    DWORD	dwCKeyCaps;		// color key capabilities of the surface
+    DWORD	dwFXCaps;		// driver specific stretching and effects capabilites
+    DWORD	dwFXAlphaCaps;		// alpha driver specific capabilities
+    DWORD	dwPalCaps;		// palette capabilities
+    DWORD	dwSVCaps;		// stereo vision capabilities
+    DWORD	dwAlphaBltConstBitDepths;	// DDBD_2,4,8
+    DWORD	dwAlphaBltPixelBitDepths;	// DDBD_1,2,4,8
+    DWORD	dwAlphaBltSurfaceBitDepths;	// DDBD_1,2,4,8
+    DWORD	dwAlphaOverlayConstBitDepths;	// DDBD_2,4,8
+    DWORD	dwAlphaOverlayPixelBitDepths;	// DDBD_1,2,4,8
+    DWORD	dwAlphaOverlaySurfaceBitDepths; // DDBD_1,2,4,8
+    DWORD	dwZBufferBitDepths;		// DDBD_8,16,24,32
+    DWORD	dwVidMemTotal;		// total amount of video memory
+    DWORD	dwVidMemFree;		// amount of free video memory
+    DWORD	dwMaxVisibleOverlays;	// maximum number of visible overlays
+    DWORD	dwCurrVisibleOverlays;	// current number of visible overlays
+    DWORD	dwNumFourCCCodes;	// number of four cc codes
+    DWORD	dwAlignBoundarySrc;	// source rectangle alignment
+    DWORD	dwAlignSizeSrc;		// source rectangle byte size
+    DWORD	dwAlignBoundaryDest;	// dest rectangle alignment
+    DWORD	dwAlignSizeDest;	// dest rectangle byte size
+    DWORD	dwAlignStrideAlign;	// stride alignment
+    DWORD	dwRops[DD_ROP_SPACE];	// ROPS supported
+    DDSCAPS	ddsCaps;		// DDSCAPS structure has all the general capabilities
+    DWORD	dwMinOverlayStretch;	// minimum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
+    DWORD	dwMaxOverlayStretch;	// maximum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
+    DWORD	dwMinLiveVideoStretch;	// minimum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
+    DWORD	dwMaxLiveVideoStretch;	// maximum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
+    DWORD	dwMinHwCodecStretch;	// minimum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
+    DWORD	dwMaxHwCodecStretch;	// maximum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
+    DWORD	dwReserved1;		// reserved
+    DWORD	dwReserved2;		// reserved
+    DWORD	dwReserved3;		// reserved
+    DWORD	dwSVBCaps;		// driver specific capabilities for System->Vmem blts
+    DWORD	dwSVBCKeyCaps;		// driver color key capabilities for System->Vmem blts
+    DWORD	dwSVBFXCaps;		// driver FX capabilities for System->Vmem blts
+    DWORD	dwSVBRops[DD_ROP_SPACE];// ROPS supported for System->Vmem blts
+    DWORD	dwVSBCaps;		// driver specific capabilities for Vmem->System blts
+    DWORD	dwVSBCKeyCaps;		// driver color key capabilities for Vmem->System blts
+    DWORD	dwVSBFXCaps;		// driver FX capabilities for Vmem->System blts
+    DWORD	dwVSBRops[DD_ROP_SPACE];// ROPS supported for Vmem->System blts
+    DWORD	dwSSBCaps;		// driver specific capabilities for System->System blts
+    DWORD	dwSSBCKeyCaps;		// driver color key capabilities for System->System blts
+    DWORD	dwSSBFXCaps;		// driver FX capabilities for System->System blts
+    DWORD	dwSSBRops[DD_ROP_SPACE];// ROPS supported for System->System blts
+    DWORD	dwReserved4;		// reserved
+    DWORD	dwReserved5;		// reserved
+    DWORD	dwReserved6;		// reserved
+} DDCAPS_DX3;
+typedef DDCAPS_DX3 FAR* LPDDCAPS_DX3;
+#endif /* DIRECTDRAW_VERSION >= 0x0500 */
+
+typedef struct _DDCAPS
+{
+/*  0*/ DWORD	dwSize;			// size of the DDDRIVERCAPS structure
+/*  4*/ DWORD	dwCaps;			// driver specific capabilities
+/*  8*/ DWORD	dwCaps2;		// more driver specific capabilites
+/*  c*/ DWORD	dwCKeyCaps;		// color key capabilities of the surface
+/* 10*/ DWORD	dwFXCaps;		// driver specific stretching and effects capabilites
+/* 14*/ DWORD	dwFXAlphaCaps;		// alpha driver specific capabilities
+/* 18*/ DWORD	dwPalCaps;		// palette capabilities
+/* 1c*/ DWORD	dwSVCaps;		// stereo vision capabilities
+/* 20*/ DWORD	dwAlphaBltConstBitDepths;	// DDBD_2,4,8
+/* 24*/ DWORD	dwAlphaBltPixelBitDepths;	// DDBD_1,2,4,8
+/* 28*/ DWORD	dwAlphaBltSurfaceBitDepths;	// DDBD_1,2,4,8
+/* 2c*/ DWORD	dwAlphaOverlayConstBitDepths;	// DDBD_2,4,8
+/* 30*/ DWORD	dwAlphaOverlayPixelBitDepths;	// DDBD_1,2,4,8
+/* 34*/ DWORD	dwAlphaOverlaySurfaceBitDepths; // DDBD_1,2,4,8
+/* 38*/ DWORD	dwZBufferBitDepths;		// DDBD_8,16,24,32
+/* 3c*/ DWORD	dwVidMemTotal;		// total amount of video memory
+/* 40*/ DWORD	dwVidMemFree;		// amount of free video memory
+/* 44*/ DWORD	dwMaxVisibleOverlays;	// maximum number of visible overlays
+/* 48*/ DWORD	dwCurrVisibleOverlays;	// current number of visible overlays
+/* 4c*/ DWORD	dwNumFourCCCodes;	// number of four cc codes
+/* 50*/ DWORD	dwAlignBoundarySrc;	// source rectangle alignment
+/* 54*/ DWORD	dwAlignSizeSrc;		// source rectangle byte size
+/* 58*/ DWORD	dwAlignBoundaryDest;	// dest rectangle alignment
+/* 5c*/ DWORD	dwAlignSizeDest;	// dest rectangle byte size
+/* 60*/ DWORD	dwAlignStrideAlign;	// stride alignment
+/* 64*/ DWORD	dwRops[DD_ROP_SPACE];	// ROPS supported
+/* 84*/ DDSCAPS	ddsCaps;		// DDSCAPS structure has all the general capabilities
+/* 88*/ DWORD	dwMinOverlayStretch;	// minimum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
+/* 8c*/ DWORD	dwMaxOverlayStretch;	// maximum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
+/* 90*/ DWORD	dwMinLiveVideoStretch;	// minimum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
+/* 94*/ DWORD	dwMaxLiveVideoStretch;	// maximum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
+/* 98*/ DWORD	dwMinHwCodecStretch;	// minimum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
+/* 9c*/ DWORD	dwMaxHwCodecStretch;	// maximum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
+/* a0*/ DWORD	dwReserved1;		// reserved
+/* a4*/ DWORD	dwReserved2;		// reserved
+/* a8*/ DWORD	dwReserved3;		// reserved
+/* ac*/ DWORD	dwSVBCaps;		// driver specific capabilities for System->Vmem blts
+/* b0*/ DWORD	dwSVBCKeyCaps;		// driver color key capabilities for System->Vmem blts
+/* b4*/ DWORD	dwSVBFXCaps;		// driver FX capabilities for System->Vmem blts
+/* b8*/ DWORD	dwSVBRops[DD_ROP_SPACE];// ROPS supported for System->Vmem blts
+/* d8*/ DWORD	dwVSBCaps;		// driver specific capabilities for Vmem->System blts
+/* dc*/ DWORD	dwVSBCKeyCaps;		// driver color key capabilities for Vmem->System blts
+/* e0*/ DWORD	dwVSBFXCaps;		// driver FX capabilities for Vmem->System blts
+/* e4*/ DWORD	dwVSBRops[DD_ROP_SPACE];// ROPS supported for Vmem->System blts
+/*104*/ DWORD	dwSSBCaps;		// driver specific capabilities for System->System blts
+/*108*/ DWORD	dwSSBCKeyCaps;		// driver color key capabilities for System->System blts
+/*10c*/ DWORD	dwSSBFXCaps;		// driver FX capabilities for System->System blts
+/*110*/ DWORD	dwSSBRops[DD_ROP_SPACE];// ROPS supported for System->System blts
+#if       DIRECTDRAW_VERSION >= 0x0500
+/*130*/ DWORD	dwMaxVideoPorts;	// maximum number of usable video ports
+/*134*/ DWORD	dwCurrVideoPorts;	// current number of video ports used
+/*138*/ DWORD	dwSVBCaps2;		// more driver specific capabilities for System->Vmem blts
+/*13c*/ DWORD	dwNLVBCaps;		  // driver specific capabilities for non-local->local vidmem blts
+/*140*/ DWORD	dwNLVBCaps2;		  // more driver specific capabilities non-local->local vidmem blts
+/*144*/ DWORD	dwNLVBCKeyCaps;		  // driver color key capabilities for non-local->local vidmem blts
+/*148*/ DWORD	dwNLVBFXCaps;		  // driver FX capabilities for non-local->local blts
+/*14c*/ DWORD	dwNLVBRops[DD_ROP_SPACE]; // ROPS supported for non-local->local blts
+#else  /* DIRECTDRAW_VERSION >= 0x0500 */
+/*130*/ DWORD	dwReserved4;		// reserved
+/*134*/ DWORD	dwReserved5;		// reserved
+/*138*/ DWORD	dwReserved6;		// reserved
+#endif /* DIRECTDRAW_VERSION >= 0x0500 */
+} DDCAPS;
+
+typedef DDCAPS FAR* LPDDCAPS;
+
+
+
+/*
+ * DDPIXELFORMAT
+ */
+typedef struct _DDPIXELFORMAT
+{
+    DWORD	dwSize;			// size of structure
+    DWORD	dwFlags;		// pixel format flags
+    DWORD	dwFourCC;		// (FOURCC code)
+    union
+    {
+	DWORD	dwRGBBitCount;		// how many bits per pixel
+	DWORD	dwYUVBitCount;		// how many bits per pixel
+	DWORD	dwZBufferBitDepth;	// how many bits for z buffers
+	DWORD	dwAlphaBitDepth;	// how many bits for alpha channels
+    };
+    union
+    {
+	DWORD	dwRBitMask;		// mask for red bit
+	DWORD	dwYBitMask;		// mask for Y bits
+    };
+    union
+    {
+	DWORD	dwGBitMask;		// mask for green bits
+	DWORD	dwUBitMask;		// mask for U bits
+    };
+    union
+    {
+	DWORD	dwBBitMask;		// mask for blue bits
+	DWORD	dwVBitMask;		// mask for V bits
+    };
+    union
+    {
+	DWORD	dwRGBAlphaBitMask;	// mask for alpha channel
+	DWORD	dwYUVAlphaBitMask;	// mask for alpha channel
+	DWORD	dwRGBZBitMask;		// mask for Z channel
+	DWORD	dwYUVZBitMask;		// mask for Z channel
+    };
+} DDPIXELFORMAT;
+
+typedef DDPIXELFORMAT FAR* LPDDPIXELFORMAT;
+
+/*
+ * DDOVERLAYFX
+ */
+typedef struct _DDOVERLAYFX
+{
+    DWORD	dwSize;				// size of structure
+    DWORD	dwAlphaEdgeBlendBitDepth;	// Bit depth used to specify constant for alpha edge blend
+    DWORD	dwAlphaEdgeBlend;		// Constant to use as alpha for edge blend
+    DWORD	dwReserved;
+    DWORD	dwAlphaDestConstBitDepth;	// Bit depth used to specify alpha constant for destination
+    union
+    {
+	DWORD	dwAlphaDestConst;		// Constant to use as alpha channel for dest
+	LPDIRECTDRAWSURFACE lpDDSAlphaDest;	// Surface to use as alpha channel for dest
+    };
+    DWORD	dwAlphaSrcConstBitDepth;	// Bit depth used to specify alpha constant for source
+    union
+    {
+	DWORD	dwAlphaSrcConst;		// Constant to use as alpha channel for src
+	LPDIRECTDRAWSURFACE lpDDSAlphaSrc;	// Surface to use as alpha channel for src
+    };
+    DDCOLORKEY	dckDestColorkey;		// DestColorkey override
+    DDCOLORKEY	dckSrcColorkey;			// DestColorkey override
+    DWORD       dwDDFX;                         // Overlay FX
+    DWORD	dwFlags;			// flags
+} DDOVERLAYFX;
+
+typedef DDOVERLAYFX FAR *LPDDOVERLAYFX;
+
+/*
+ * DDBLTBATCH: BltBatch entry structure
+ */
+typedef struct _DDBLTBATCH
+{
+    LPRECT		lprDest;
+    LPDIRECTDRAWSURFACE	lpDDSSrc;
+    LPRECT		lprSrc;
+    DWORD		dwFlags;
+    LPDDBLTFX		lpDDBltFx;
+} DDBLTBATCH;
+
+typedef DDBLTBATCH FAR * LPDDBLTBATCH;
+
+/*
+ * callbacks
+ */
+typedef DWORD	(FAR PASCAL *LPCLIPPERCALLBACK)(LPDIRECTDRAWCLIPPER lpDDClipper, HWND hWnd, DWORD code, LPVOID lpContext );
+#ifdef STREAMING
+typedef DWORD	(FAR PASCAL *LPSURFACESTREAMINGCALLBACK)(DWORD);
+#endif
+
+
+/*
+ * INTERACES FOLLOW:
+ *	IDirectDraw
+ *	IDirectDrawClipper
+ *	IDirectDrawPalette
+ *	IDirectDrawSurface
+ */
+
+/*
+ * IDirectDraw
+ */
+#if defined( _WIN32 ) && !defined( _NO_COM )
+#undef INTERFACE
+#define INTERFACE IDirectDraw
+DECLARE_INTERFACE_( IDirectDraw, IUnknown )
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
+    STDMETHOD_(ULONG,Release) (THIS) PURE;
+    /*** IDirectDraw methods ***/
+    STDMETHOD(Compact)(THIS) PURE;
+    STDMETHOD(CreateClipper)(THIS_ DWORD, LPDIRECTDRAWCLIPPER FAR*, IUnknown FAR * ) PURE;
+    STDMETHOD(CreatePalette)(THIS_ DWORD, LPPALETTEENTRY, LPDIRECTDRAWPALETTE FAR*, IUnknown FAR * ) PURE;
+    STDMETHOD(CreateSurface)(THIS_  LPDDSURFACEDESC, LPDIRECTDRAWSURFACE FAR *, IUnknown FAR *) PURE;
+    STDMETHOD(DuplicateSurface)( THIS_ LPDIRECTDRAWSURFACE, LPDIRECTDRAWSURFACE FAR * ) PURE;
+    STDMETHOD(EnumDisplayModes)( THIS_ DWORD, LPDDSURFACEDESC, LPVOID, LPDDENUMMODESCALLBACK ) PURE;
+    STDMETHOD(EnumSurfaces)(THIS_ DWORD, LPDDSURFACEDESC, LPVOID,LPDDENUMSURFACESCALLBACK ) PURE;
+    STDMETHOD(FlipToGDISurface)(THIS) PURE;
+    STDMETHOD(GetCaps)( THIS_ LPDDCAPS, LPDDCAPS) PURE;
+    STDMETHOD(GetDisplayMode)( THIS_ LPDDSURFACEDESC) PURE;
+    STDMETHOD(GetFourCCCodes)(THIS_  LPDWORD, LPDWORD ) PURE;
+    STDMETHOD(GetGDISurface)(THIS_ LPDIRECTDRAWSURFACE FAR *) PURE;
+    STDMETHOD(GetMonitorFrequency)(THIS_ LPDWORD) PURE;
+    STDMETHOD(GetScanLine)(THIS_ LPDWORD) PURE;
+    STDMETHOD(GetVerticalBlankStatus)(THIS_ LPBOOL ) PURE;
+    STDMETHOD(Initialize)(THIS_ GUID FAR *) PURE;
+    STDMETHOD(RestoreDisplayMode)(THIS) PURE;
+    STDMETHOD(SetCooperativeLevel)(THIS_ HWND, DWORD) PURE;
+    STDMETHOD(SetDisplayMode)(THIS_ DWORD, DWORD,DWORD) PURE;
+    STDMETHOD(WaitForVerticalBlank)(THIS_ DWORD, HANDLE ) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectDraw_QueryInterface(p, a, b)         (p)->lpVtbl->QueryInterface(p, a, b)
+#define IDirectDraw_AddRef(p)                       (p)->lpVtbl->AddRef(p)
+#define IDirectDraw_Release(p)                      (p)->lpVtbl->Release(p)
+#define IDirectDraw_Compact(p)                      (p)->lpVtbl->Compact(p)
+#define IDirectDraw_CreateClipper(p, a, b, c)       (p)->lpVtbl->CreateClipper(p, a, b, c)
+#define IDirectDraw_CreatePalette(p, a, b, c, d)    (p)->lpVtbl->CreatePalette(p, a, b, c, d)
+#define IDirectDraw_CreateSurface(p, a, b, c)       (p)->lpVtbl->CreateSurface(p, a, b, c)
+#define IDirectDraw_DuplicateSurface(p, a, b)       (p)->lpVtbl->DuplicateSurface(p, a, b)
+#define IDirectDraw_EnumDisplayModes(p, a, b, c, d) (p)->lpVtbl->EnumDisplayModes(p, a, b, c, d)
+#define IDirectDraw_EnumSurfaces(p, a, b, c, d)     (p)->lpVtbl->EnumSurfaces(p, a, b, c, d)
+#define IDirectDraw_FlipToGDISurface(p)             (p)->lpVtbl->FlipToGDISurface(p)
+#define IDirectDraw_GetCaps(p, a, b)                (p)->lpVtbl->GetCaps(p, a, b)
+#define IDirectDraw_GetDisplayMode(p, a)            (p)->lpVtbl->GetDisplayMode(p, a)
+#define IDirectDraw_GetFourCCCodes(p, a, b)         (p)->lpVtbl->GetFourCCCodes(p, a, b)
+#define IDirectDraw_GetGDISurface(p, a)             (p)->lpVtbl->GetGDISurface(p, a)
+#define IDirectDraw_GetMonitorFrequency(p, a)       (p)->lpVtbl->GetMonitorFrequency(p, a)
+#define IDirectDraw_GetScanLine(p, a)               (p)->lpVtbl->GetScanLine(p, a)
+#define IDirectDraw_GetVerticalBlankStatus(p, a)    (p)->lpVtbl->GetVerticalBlankStatus(p, a)
+#define IDirectDraw_Initialize(p, a)                (p)->lpVtbl->Initialize(p, a)
+#define IDirectDraw_RestoreDisplayMode(p)           (p)->lpVtbl->RestoreDisplayMode(p)
+#define IDirectDraw_SetCooperativeLevel(p, a, b)    (p)->lpVtbl->SetCooperativeLevel(p, a, b)
+#define IDirectDraw_SetDisplayMode(p, a, b, c)      (p)->lpVtbl->SetDisplayMode(p, a, b, c)
+#define IDirectDraw_WaitForVerticalBlank(p, a, b)   (p)->lpVtbl->WaitForVerticalBlank(p, a, b)
+#else
+#define IDirectDraw_QueryInterface(p, a, b)         (p)->QueryInterface(a, b)
+#define IDirectDraw_AddRef(p)                       (p)->AddRef()
+#define IDirectDraw_Release(p)                      (p)->Release()
+#define IDirectDraw_Compact(p)                      (p)->Compact()
+#define IDirectDraw_CreateClipper(p, a, b, c)       (p)->CreateClipper(a, b, c)
+#define IDirectDraw_CreatePalette(p, a, b, c, d)    (p)->CreatePalette(a, b, c, d)
+#define IDirectDraw_CreateSurface(p, a, b, c)       (p)->CreateSurface(a, b, c)
+#define IDirectDraw_DuplicateSurface(p, a, b)       (p)->DuplicateSurface(a, b)
+#define IDirectDraw_EnumDisplayModes(p, a, b, c, d) (p)->EnumDisplayModes(a, b, c, d)
+#define IDirectDraw_EnumSurfaces(p, a, b, c, d)     (p)->EnumSurfaces(a, b, c, d)
+#define IDirectDraw_FlipToGDISurface(p)             (p)->FlipToGDISurface()
+#define IDirectDraw_GetCaps(p, a, b)                (p)->GetCaps(a, b)
+#define IDirectDraw_GetDisplayMode(p, a)            (p)->GetDisplayMode(a)
+#define IDirectDraw_GetFourCCCodes(p, a, b)         (p)->GetFourCCCodes(a, b)
+#define IDirectDraw_GetGDISurface(p, a)             (p)->GetGDISurface(a)
+#define IDirectDraw_GetMonitorFrequency(p, a)       (p)->GetMonitorFrequency(a)
+#define IDirectDraw_GetScanLine(p, a)               (p)->GetScanLine(a)
+#define IDirectDraw_GetVerticalBlankStatus(p, a)    (p)->GetVerticalBlankStatus(a)
+#define IDirectDraw_Initialize(p, a)                (p)->Initialize(a)
+#define IDirectDraw_RestoreDisplayMode(p)           (p)->RestoreDisplayMode()
+#define IDirectDraw_SetCooperativeLevel(p, a, b)    (p)->SetCooperativeLevel(a, b)
+#define IDirectDraw_SetDisplayMode(p, a, b, c)      (p)->SetDisplayMode(a, b, c)
+#define IDirectDraw_WaitForVerticalBlank(p, a, b)   (p)->WaitForVerticalBlank(a, b)
+#endif
+
+#endif
+
+#if defined( _WIN32 ) && !defined( _NO_COM )
+#undef INTERFACE
+#define INTERFACE IDirectDraw2
+DECLARE_INTERFACE_( IDirectDraw2, IUnknown )
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
+    STDMETHOD_(ULONG,Release) (THIS) PURE;
+    /*** IDirectDraw methods ***/
+    STDMETHOD(Compact)(THIS) PURE;
+    STDMETHOD(CreateClipper)(THIS_ DWORD, LPDIRECTDRAWCLIPPER FAR*, IUnknown FAR * ) PURE;
+    STDMETHOD(CreatePalette)(THIS_ DWORD, LPPALETTEENTRY, LPDIRECTDRAWPALETTE FAR*, IUnknown FAR * ) PURE;
+    STDMETHOD(CreateSurface)(THIS_  LPDDSURFACEDESC, LPDIRECTDRAWSURFACE FAR *, IUnknown FAR *) PURE;
+    STDMETHOD(DuplicateSurface)( THIS_ LPDIRECTDRAWSURFACE, LPDIRECTDRAWSURFACE FAR * ) PURE;
+    STDMETHOD(EnumDisplayModes)( THIS_ DWORD, LPDDSURFACEDESC, LPVOID, LPDDENUMMODESCALLBACK ) PURE;
+    STDMETHOD(EnumSurfaces)(THIS_ DWORD, LPDDSURFACEDESC, LPVOID,LPDDENUMSURFACESCALLBACK ) PURE;
+    STDMETHOD(FlipToGDISurface)(THIS) PURE;
+    STDMETHOD(GetCaps)( THIS_ LPDDCAPS, LPDDCAPS) PURE;
+    STDMETHOD(GetDisplayMode)( THIS_ LPDDSURFACEDESC) PURE;
+    STDMETHOD(GetFourCCCodes)(THIS_  LPDWORD, LPDWORD ) PURE;
+    STDMETHOD(GetGDISurface)(THIS_ LPDIRECTDRAWSURFACE FAR *) PURE;
+    STDMETHOD(GetMonitorFrequency)(THIS_ LPDWORD) PURE;
+    STDMETHOD(GetScanLine)(THIS_ LPDWORD) PURE;
+    STDMETHOD(GetVerticalBlankStatus)(THIS_ LPBOOL ) PURE;
+    STDMETHOD(Initialize)(THIS_ GUID FAR *) PURE;
+    STDMETHOD(RestoreDisplayMode)(THIS) PURE;
+    STDMETHOD(SetCooperativeLevel)(THIS_ HWND, DWORD) PURE;
+    STDMETHOD(SetDisplayMode)(THIS_ DWORD, DWORD,DWORD, DWORD, DWORD) PURE;
+    STDMETHOD(WaitForVerticalBlank)(THIS_ DWORD, HANDLE ) PURE;
+    /*** Added in the v2 interface ***/
+    STDMETHOD(GetAvailableVidMem)(THIS_ LPDDSCAPS, LPDWORD, LPDWORD) PURE;
+};
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectDraw2_QueryInterface(p, a, b)         (p)->lpVtbl->QueryInterface(p, a, b)
+#define IDirectDraw2_AddRef(p)                       (p)->lpVtbl->AddRef(p)
+#define IDirectDraw2_Release(p)                      (p)->lpVtbl->Release(p)
+#define IDirectDraw2_Compact(p)                      (p)->lpVtbl->Compact(p)
+#define IDirectDraw2_CreateClipper(p, a, b, c)       (p)->lpVtbl->CreateClipper(p, a, b, c)
+#define IDirectDraw2_CreatePalette(p, a, b, c, d)    (p)->lpVtbl->CreatePalette(p, a, b, c, d)
+#define IDirectDraw2_CreateSurface(p, a, b, c)       (p)->lpVtbl->CreateSurface(p, a, b, c)
+#define IDirectDraw2_DuplicateSurface(p, a, b)       (p)->lpVtbl->DuplicateSurface(p, a, b)
+#define IDirectDraw2_EnumDisplayModes(p, a, b, c, d) (p)->lpVtbl->EnumDisplayModes(p, a, b, c, d)
+#define IDirectDraw2_EnumSurfaces(p, a, b, c, d)     (p)->lpVtbl->EnumSurfaces(p, a, b, c, d)
+#define IDirectDraw2_FlipToGDISurface(p)             (p)->lpVtbl->FlipToGDISurface(p)
+#define IDirectDraw2_GetCaps(p, a, b)                (p)->lpVtbl->GetCaps(p, a, b)
+#define IDirectDraw2_GetDisplayMode(p, a)            (p)->lpVtbl->GetDisplayMode(p, a)
+#define IDirectDraw2_GetFourCCCodes(p, a, b)         (p)->lpVtbl->GetFourCCCodes(p, a, b)
+#define IDirectDraw2_GetGDISurface(p, a)             (p)->lpVtbl->GetGDISurface(p, a)
+#define IDirectDraw2_GetMonitorFrequency(p, a)       (p)->lpVtbl->GetMonitorFrequency(p, a)
+#define IDirectDraw2_GetScanLine(p, a)               (p)->lpVtbl->GetScanLine(p, a)
+#define IDirectDraw2_GetVerticalBlankStatus(p, a)    (p)->lpVtbl->GetVerticalBlankStatus(p, a)
+#define IDirectDraw2_Initialize(p, a)                (p)->lpVtbl->Initialize(p, a)
+#define IDirectDraw2_RestoreDisplayMode(p)           (p)->lpVtbl->RestoreDisplayMode(p)
+#define IDirectDraw2_SetCooperativeLevel(p, a, b)    (p)->lpVtbl->SetCooperativeLevel(p, a, b)
+#define IDirectDraw2_SetDisplayMode(p, a, b, c, d, e) (p)->lpVtbl->SetDisplayMode(p, a, b, c, d, e)
+#define IDirectDraw2_WaitForVerticalBlank(p, a, b)   (p)->lpVtbl->WaitForVerticalBlank(p, a, b)
+#define IDirectDraw2_GetAvailableVidMem(p, a, b, c)  (p)->lpVtbl->GetAvailableVidMem(p, a, b, c)
+#else
+#define IDirectDraw2_QueryInterface(p, a, b)         (p)->QueryInterface(a, b)
+#define IDirectDraw2_AddRef(p)                       (p)->AddRef()
+#define IDirectDraw2_Release(p)                      (p)->Release()
+#define IDirectDraw2_Compact(p)                      (p)->Compact()
+#define IDirectDraw2_CreateClipper(p, a, b, c)       (p)->CreateClipper(a, b, c)
+#define IDirectDraw2_CreatePalette(p, a, b, c, d)    (p)->CreatePalette(a, b, c, d)
+#define IDirectDraw2_CreateSurface(p, a, b, c)       (p)->CreateSurface(a, b, c)
+#define IDirectDraw2_DuplicateSurface(p, a, b)       (p)->DuplicateSurface(a, b)
+#define IDirectDraw2_EnumDisplayModes(p, a, b, c, d) (p)->EnumDisplayModes(a, b, c, d)
+#define IDirectDraw2_EnumSurfaces(p, a, b, c, d)     (p)->EnumSurfaces(a, b, c, d)
+#define IDirectDraw2_FlipToGDISurface(p)             (p)->FlipToGDISurface()
+#define IDirectDraw2_GetCaps(p, a, b)                (p)->GetCaps(a, b)
+#define IDirectDraw2_GetDisplayMode(p, a)            (p)->GetDisplayMode(a)
+#define IDirectDraw2_GetFourCCCodes(p, a, b)         (p)->GetFourCCCodes(a, b)
+#define IDirectDraw2_GetGDISurface(p, a)             (p)->GetGDISurface(a)
+#define IDirectDraw2_GetMonitorFrequency(p, a)       (p)->GetMonitorFrequency(a)
+#define IDirectDraw2_GetScanLine(p, a)               (p)->GetScanLine(a)
+#define IDirectDraw2_GetVerticalBlankStatus(p, a)    (p)->GetVerticalBlankStatus(a)
+#define IDirectDraw2_Initialize(p, a)                (p)->Initialize(a)
+#define IDirectDraw2_RestoreDisplayMode(p)           (p)->RestoreDisplayMode()
+#define IDirectDraw2_SetCooperativeLevel(p, a, b)    (p)->SetCooperativeLevel(a, b)
+#define IDirectDraw2_SetDisplayMode(p, a, b, c, d, e) (p)->SetDisplayMode(a, b, c, d, e)
+#define IDirectDraw2_WaitForVerticalBlank(p, a, b)   (p)->WaitForVerticalBlank(a, b)
+#define IDirectDraw2_GetAvailableVidMem(p, a, b, c)  (p)->GetAvailableVidMem(a, b, c)
+#endif
+
+#endif
+
+/*
+ * IDirectDrawPalette
+ */
+#if defined( _WIN32 ) && !defined( _NO_COM )
+#undef INTERFACE
+#define INTERFACE IDirectDrawPalette
+DECLARE_INTERFACE_( IDirectDrawPalette, IUnknown )
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
+    STDMETHOD_(ULONG,Release) (THIS) PURE;
+    /*** IDirectDrawPalette methods ***/
+    STDMETHOD(GetCaps)(THIS_ LPDWORD) PURE;
+    STDMETHOD(GetEntries)(THIS_ DWORD,DWORD,DWORD,LPPALETTEENTRY) PURE;
+    STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, DWORD, LPPALETTEENTRY) PURE;
+    STDMETHOD(SetEntries)(THIS_ DWORD,DWORD,DWORD,LPPALETTEENTRY) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectDrawPalette_QueryInterface(p, a, b)      (p)->lpVtbl->QueryInterface(p, a, b)
+#define IDirectDrawPalette_AddRef(p)                    (p)->lpVtbl->AddRef(p)
+#define IDirectDrawPalette_Release(p)                   (p)->lpVtbl->Release(p)
+#define IDirectDrawPalette_GetCaps(p, a)                (p)->lpVtbl->GetCaps(p, a)
+#define IDirectDrawPalette_GetEntries(p, a, b, c, d)    (p)->lpVtbl->GetEntries(p, a, b, c, d)
+#define IDirectDrawPalette_Initialize(p, a, b, c)       (p)->lpVtbl->Initialize(p, a, b, c)
+#define IDirectDrawPalette_SetEntries(p, a, b, c, d)    (p)->lpVtbl->SetEntries(p, a, b, c, d)
+#else
+#define IDirectDrawPalette_QueryInterface(p, a, b)      (p)->QueryInterface(a, b)
+#define IDirectDrawPalette_AddRef(p)                    (p)->AddRef()
+#define IDirectDrawPalette_Release(p)                   (p)->Release()
+#define IDirectDrawPalette_GetCaps(p, a)                (p)->GetCaps(a)
+#define IDirectDrawPalette_GetEntries(p, a, b, c, d)    (p)->GetEntries(a, b, c, d)
+#define IDirectDrawPalette_Initialize(p, a, b, c)       (p)->Initialize(a, b, c)
+#define IDirectDrawPalette_SetEntries(p, a, b, c, d)    (p)->SetEntries(a, b, c, d)
+#endif
+
+#endif
+
+/*
+ * IDirectDrawClipper
+ */
+#if defined( _WIN32 ) && !defined( _NO_COM )
+#undef INTERFACE
+#define INTERFACE IDirectDrawClipper
+DECLARE_INTERFACE_( IDirectDrawClipper, IUnknown )
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
+    STDMETHOD_(ULONG,Release) (THIS) PURE;
+    /*** IDirectDrawClipper methods ***/
+    STDMETHOD(GetClipList)(THIS_ LPRECT, LPRGNDATA, LPDWORD) PURE;
+    STDMETHOD(GetHWnd)(THIS_ HWND FAR *) PURE;
+    STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, DWORD) PURE;
+    STDMETHOD(IsClipListChanged)(THIS_ BOOL FAR *) PURE;
+    STDMETHOD(SetClipList)(THIS_ LPRGNDATA,DWORD) PURE;
+    STDMETHOD(SetHWnd)(THIS_ DWORD, HWND ) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectDrawClipper_QueryInterface(p, a, b)  (p)->lpVtbl->QueryInterface(p, a, b)
+#define IDirectDrawClipper_AddRef(p)                (p)->lpVtbl->AddRef(p)
+#define IDirectDrawClipper_Release(p)               (p)->lpVtbl->Release(p)
+#define IDirectDrawClipper_GetClipList(p, a, b, c)  (p)->lpVtbl->GetClipList(p, a, b, c)
+#define IDirectDrawClipper_GetHWnd(p, a)            (p)->lpVtbl->GetHWnd(p, a)
+#define IDirectDrawClipper_Initialize(p, a, b)      (p)->lpVtbl->Initialize(p, a, b)
+#define IDirectDrawClipper_IsClipListChanged(p, a)  (p)->lpVtbl->IsClipListChanged(p, a)
+#define IDirectDrawClipper_SetClipList(p, a, b)     (p)->lpVtbl->SetClipList(p, a, b)
+#define IDirectDrawClipper_SetHWnd(p, a, b)         (p)->lpVtbl->SetHWnd(p, a, b)
+#else
+#define IDirectDrawClipper_QueryInterface(p, a, b)  (p)->QueryInterface(a, b)
+#define IDirectDrawClipper_AddRef(p)                (p)->AddRef()
+#define IDirectDrawClipper_Release(p)               (p)->Release()
+#define IDirectDrawClipper_GetClipList(p, a, b, c)  (p)->GetClipList(a, b, c)
+#define IDirectDrawClipper_GetHWnd(p, a)            (p)->GetHWnd(a)
+#define IDirectDrawClipper_Initialize(p, a, b)      (p)->Initialize(a, b)
+#define IDirectDrawClipper_IsClipListChanged(p, a)  (p)->IsClipListChanged(a)
+#define IDirectDrawClipper_SetClipList(p, a, b)     (p)->SetClipList(a, b)
+#define IDirectDrawClipper_SetHWnd(p, a, b)         (p)->SetHWnd(a, b)
+#endif
+
+#endif
+
+/*
+ * IDirectDrawSurface and related interfaces
+ */
+#if defined( _WIN32 ) && !defined( _NO_COM )
+#undef INTERFACE
+#define INTERFACE IDirectDrawSurface
+DECLARE_INTERFACE_( IDirectDrawSurface, IUnknown )
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
+    STDMETHOD_(ULONG,Release) (THIS) PURE;
+    /*** IDirectDrawSurface methods ***/
+    STDMETHOD(AddAttachedSurface)(THIS_ LPDIRECTDRAWSURFACE) PURE;
+    STDMETHOD(AddOverlayDirtyRect)(THIS_ LPRECT) PURE;
+    STDMETHOD(Blt)(THIS_ LPRECT,LPDIRECTDRAWSURFACE, LPRECT,DWORD, LPDDBLTFX) PURE;
+    STDMETHOD(BltBatch)(THIS_ LPDDBLTBATCH, DWORD, DWORD ) PURE;
+    STDMETHOD(BltFast)(THIS_ DWORD,DWORD,LPDIRECTDRAWSURFACE, LPRECT,DWORD) PURE;
+    STDMETHOD(DeleteAttachedSurface)(THIS_ DWORD,LPDIRECTDRAWSURFACE) PURE;
+    STDMETHOD(EnumAttachedSurfaces)(THIS_ LPVOID,LPDDENUMSURFACESCALLBACK) PURE;
+    STDMETHOD(EnumOverlayZOrders)(THIS_ DWORD,LPVOID,LPDDENUMSURFACESCALLBACK) PURE;
+    STDMETHOD(Flip)(THIS_ LPDIRECTDRAWSURFACE, DWORD) PURE;
+    STDMETHOD(GetAttachedSurface)(THIS_ LPDDSCAPS, LPDIRECTDRAWSURFACE FAR *) PURE;
+    STDMETHOD(GetBltStatus)(THIS_ DWORD) PURE;
+    STDMETHOD(GetCaps)(THIS_ LPDDSCAPS) PURE;
+    STDMETHOD(GetClipper)(THIS_ LPDIRECTDRAWCLIPPER FAR*) PURE;
+    STDMETHOD(GetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;
+    STDMETHOD(GetDC)(THIS_ HDC FAR *) PURE;
+    STDMETHOD(GetFlipStatus)(THIS_ DWORD) PURE;
+    STDMETHOD(GetOverlayPosition)(THIS_ LPLONG, LPLONG ) PURE;
+    STDMETHOD(GetPalette)(THIS_ LPDIRECTDRAWPALETTE FAR*) PURE;
+    STDMETHOD(GetPixelFormat)(THIS_ LPDDPIXELFORMAT) PURE;
+    STDMETHOD(GetSurfaceDesc)(THIS_ LPDDSURFACEDESC) PURE;
+    STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, LPDDSURFACEDESC) PURE;
+    STDMETHOD(IsLost)(THIS) PURE;
+    STDMETHOD(Lock)(THIS_ LPRECT,LPDDSURFACEDESC,DWORD,HANDLE) PURE;
+    STDMETHOD(ReleaseDC)(THIS_ HDC) PURE;
+    STDMETHOD(Restore)(THIS) PURE;
+    STDMETHOD(SetClipper)(THIS_ LPDIRECTDRAWCLIPPER) PURE;
+    STDMETHOD(SetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;
+    STDMETHOD(SetOverlayPosition)(THIS_ LONG, LONG ) PURE;
+    STDMETHOD(SetPalette)(THIS_ LPDIRECTDRAWPALETTE) PURE;
+    STDMETHOD(Unlock)(THIS_ LPVOID) PURE;
+    STDMETHOD(UpdateOverlay)(THIS_ LPRECT, LPDIRECTDRAWSURFACE,LPRECT,DWORD, LPDDOVERLAYFX) PURE;
+    STDMETHOD(UpdateOverlayDisplay)(THIS_ DWORD) PURE;
+    STDMETHOD(UpdateOverlayZOrder)(THIS_ DWORD, LPDIRECTDRAWSURFACE) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectDrawSurface_QueryInterface(p,a,b)        (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirectDrawSurface_AddRef(p)                    (p)->lpVtbl->AddRef(p)
+#define IDirectDrawSurface_Release(p)                   (p)->lpVtbl->Release(p)
+#define IDirectDrawSurface_AddAttachedSurface(p,a)      (p)->lpVtbl->AddAttachedSurface(p,a)
+#define IDirectDrawSurface_AddOverlayDirtyRect(p,a)     (p)->lpVtbl->AddOverlayDirtyRect(p,a)
+#define IDirectDrawSurface_Blt(p,a,b,c,d,e)             (p)->lpVtbl->Blt(p,a,b,c,d,e)
+#define IDirectDrawSurface_BltBatch(p,a,b,c)            (p)->lpVtbl->BltBatch(p,a,b,c)
+#define IDirectDrawSurface_BltFast(p,a,b,c,d,e)         (p)->lpVtbl->BltFast(p,a,b,c,d,e)
+#define IDirectDrawSurface_DeleteAttachedSurface(p,a,b) (p)->lpVtbl->DeleteAttachedSurface(p,a,b)
+#define IDirectDrawSurface_EnumAttachedSurfaces(p,a,b)  (p)->lpVtbl->EnumAttachedSurfaces(p,a,b)
+#define IDirectDrawSurface_EnumOverlayZOrders(p,a,b,c)  (p)->lpVtbl->EnumOverlayZOrders(p,a,b,c)
+#define IDirectDrawSurface_Flip(p,a,b)                  (p)->lpVtbl->Flip(p,a,b)
+#define IDirectDrawSurface_GetAttachedSurface(p,a,b)    (p)->lpVtbl->GetAttachedSurface(p,a,b)
+#define IDirectDrawSurface_GetBltStatus(p,a)            (p)->lpVtbl->GetBltStatus(p,a)
+#define IDirectDrawSurface_GetCaps(p,b)                 (p)->lpVtbl->GetCaps(p,b)
+#define IDirectDrawSurface_GetClipper(p,a)              (p)->lpVtbl->GetClipper(p,a)
+#define IDirectDrawSurface_GetColorKey(p,a,b)           (p)->lpVtbl->GetColorKey(p,a,b)
+#define IDirectDrawSurface_GetDC(p,a)                   (p)->lpVtbl->GetDC(p,a)
+#define IDirectDrawSurface_GetFlipStatus(p,a)           (p)->lpVtbl->GetFlipStatus(p,a)
+#define IDirectDrawSurface_GetOverlayPosition(p,a,b)    (p)->lpVtbl->GetOverlayPosition(p,a,b)
+#define IDirectDrawSurface_GetPalette(p,a)              (p)->lpVtbl->GetPalette(p,a)
+#define IDirectDrawSurface_GetPixelFormat(p,a)          (p)->lpVtbl->GetPixelFormat(p,a)
+#define IDirectDrawSurface_GetSurfaceDesc(p,a)          (p)->lpVtbl->GetSurfaceDesc(p,a)
+#define IDirectDrawSurface_Initialize(p,a,b)            (p)->lpVtbl->Initialize(p,a,b)
+#define IDirectDrawSurface_IsLost(p)                    (p)->lpVtbl->IsLost(p)
+#define IDirectDrawSurface_Lock(p,a,b,c,d)              (p)->lpVtbl->Lock(p,a,b,c,d)
+#define IDirectDrawSurface_ReleaseDC(p,a)               (p)->lpVtbl->ReleaseDC(p,a)
+#define IDirectDrawSurface_Restore(p)                   (p)->lpVtbl->Restore(p)
+#define IDirectDrawSurface_SetClipper(p,a)              (p)->lpVtbl->SetClipper(p,a)
+#define IDirectDrawSurface_SetColorKey(p,a,b)           (p)->lpVtbl->SetColorKey(p,a,b)
+#define IDirectDrawSurface_SetOverlayPosition(p,a,b)    (p)->lpVtbl->SetOverlayPosition(p,a,b)
+#define IDirectDrawSurface_SetPalette(p,a)              (p)->lpVtbl->SetPalette(p,a)
+#define IDirectDrawSurface_Unlock(p,b)                  (p)->lpVtbl->Unlock(p,b)
+#define IDirectDrawSurface_UpdateOverlay(p,a,b,c,d,e)   (p)->lpVtbl->UpdateOverlay(p,a,b,c,d,e)
+#define IDirectDrawSurface_UpdateOverlayDisplay(p,a)    (p)->lpVtbl->UpdateOverlayDisplay(p,a)
+#define IDirectDrawSurface_UpdateOverlayZOrder(p,a,b)   (p)->lpVtbl->UpdateOverlayZOrder(p,a,b)
+#else
+#define IDirectDrawSurface_QueryInterface(p,a,b)        (p)->QueryInterface(a,b)
+#define IDirectDrawSurface_AddRef(p)                    (p)->AddRef()
+#define IDirectDrawSurface_Release(p)                   (p)->Release()
+#define IDirectDrawSurface_AddAttachedSurface(p,a)      (p)->AddAttachedSurface(a)
+#define IDirectDrawSurface_AddOverlayDirtyRect(p,a)     (p)->AddOverlayDirtyRect(a)
+#define IDirectDrawSurface_Blt(p,a,b,c,d,e)             (p)->Blt(a,b,c,d,e)
+#define IDirectDrawSurface_BltBatch(p,a,b,c)            (p)->BltBatch(a,b,c)
+#define IDirectDrawSurface_BltFast(p,a,b,c,d,e)         (p)->BltFast(a,b,c,d,e)
+#define IDirectDrawSurface_DeleteAttachedSurface(p,a,b) (p)->DeleteAttachedSurface(a,b)
+#define IDirectDrawSurface_EnumAttachedSurfaces(p,a,b)  (p)->EnumAttachedSurfaces(a,b)
+#define IDirectDrawSurface_EnumOverlayZOrders(p,a,b,c)  (p)->EnumOverlayZOrders(a,b,c)
+#define IDirectDrawSurface_Flip(p,a,b)                  (p)->Flip(a,b)
+#define IDirectDrawSurface_GetAttachedSurface(p,a,b)    (p)->GetAttachedSurface(a,b)
+#define IDirectDrawSurface_GetBltStatus(p,a)            (p)->GetBltStatus(a)
+#define IDirectDrawSurface_GetCaps(p,b)                 (p)->GetCaps(b)
+#define IDirectDrawSurface_GetClipper(p,a)              (p)->GetClipper(a)
+#define IDirectDrawSurface_GetColorKey(p,a,b)           (p)->GetColorKey(a,b)
+#define IDirectDrawSurface_GetDC(p,a)                   (p)->GetDC(a)
+#define IDirectDrawSurface_GetFlipStatus(p,a)           (p)->GetFlipStatus(a)
+#define IDirectDrawSurface_GetOverlayPosition(p,a,b)    (p)->GetOverlayPosition(a,b)
+#define IDirectDrawSurface_GetPalette(p,a)              (p)->GetPalette(a)
+#define IDirectDrawSurface_GetPixelFormat(p,a)          (p)->GetPixelFormat(a)
+#define IDirectDrawSurface_GetSurfaceDesc(p,a)          (p)->GetSurfaceDesc(a)
+#define IDirectDrawSurface_Initialize(p,a,b)            (p)->Initialize(a,b)
+#define IDirectDrawSurface_IsLost(p)                    (p)->IsLost()
+#define IDirectDrawSurface_Lock(p,a,b,c,d)              (p)->Lock(a,b,c,d)
+#define IDirectDrawSurface_ReleaseDC(p,a)               (p)->ReleaseDC(a)
+#define IDirectDrawSurface_Restore(p)                   (p)->Restore()
+#define IDirectDrawSurface_SetClipper(p,a)              (p)->SetClipper(a)
+#define IDirectDrawSurface_SetColorKey(p,a,b)           (p)->SetColorKey(a,b)
+#define IDirectDrawSurface_SetOverlayPosition(p,a,b)    (p)->SetOverlayPosition(a,b)
+#define IDirectDrawSurface_SetPalette(p,a)              (p)->SetPalette(a)
+#define IDirectDrawSurface_Unlock(p,b)                  (p)->Unlock(b)
+#define IDirectDrawSurface_UpdateOverlay(p,a,b,c,d,e)   (p)->UpdateOverlay(a,b,c,d,e)
+#define IDirectDrawSurface_UpdateOverlayDisplay(p,a)    (p)->UpdateOverlayDisplay(a)
+#define IDirectDrawSurface_UpdateOverlayZOrder(p,a,b)   (p)->UpdateOverlayZOrder(a,b)
+#endif
+
+/*
+ * IDirectDrawSurface2 and related interfaces
+ */
+#undef INTERFACE
+#define INTERFACE IDirectDrawSurface2
+DECLARE_INTERFACE_( IDirectDrawSurface2, IUnknown )
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
+    STDMETHOD_(ULONG,Release) (THIS) PURE;
+    /*** IDirectDrawSurface methods ***/
+    STDMETHOD(AddAttachedSurface)(THIS_ LPDIRECTDRAWSURFACE2) PURE;
+    STDMETHOD(AddOverlayDirtyRect)(THIS_ LPRECT) PURE;
+    STDMETHOD(Blt)(THIS_ LPRECT,LPDIRECTDRAWSURFACE2, LPRECT,DWORD, LPDDBLTFX) PURE;
+    STDMETHOD(BltBatch)(THIS_ LPDDBLTBATCH, DWORD, DWORD ) PURE;
+    STDMETHOD(BltFast)(THIS_ DWORD,DWORD,LPDIRECTDRAWSURFACE2, LPRECT,DWORD) PURE;
+    STDMETHOD(DeleteAttachedSurface)(THIS_ DWORD,LPDIRECTDRAWSURFACE2) PURE;
+    STDMETHOD(EnumAttachedSurfaces)(THIS_ LPVOID,LPDDENUMSURFACESCALLBACK) PURE;
+    STDMETHOD(EnumOverlayZOrders)(THIS_ DWORD,LPVOID,LPDDENUMSURFACESCALLBACK) PURE;
+    STDMETHOD(Flip)(THIS_ LPDIRECTDRAWSURFACE2, DWORD) PURE;
+    STDMETHOD(GetAttachedSurface)(THIS_ LPDDSCAPS, LPDIRECTDRAWSURFACE2 FAR *) PURE;
+    STDMETHOD(GetBltStatus)(THIS_ DWORD) PURE;
+    STDMETHOD(GetCaps)(THIS_ LPDDSCAPS) PURE;
+    STDMETHOD(GetClipper)(THIS_ LPDIRECTDRAWCLIPPER FAR*) PURE;
+    STDMETHOD(GetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;
+    STDMETHOD(GetDC)(THIS_ HDC FAR *) PURE;
+    STDMETHOD(GetFlipStatus)(THIS_ DWORD) PURE;
+    STDMETHOD(GetOverlayPosition)(THIS_ LPLONG, LPLONG ) PURE;
+    STDMETHOD(GetPalette)(THIS_ LPDIRECTDRAWPALETTE FAR*) PURE;
+    STDMETHOD(GetPixelFormat)(THIS_ LPDDPIXELFORMAT) PURE;
+    STDMETHOD(GetSurfaceDesc)(THIS_ LPDDSURFACEDESC) PURE;
+    STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, LPDDSURFACEDESC) PURE;
+    STDMETHOD(IsLost)(THIS) PURE;
+    STDMETHOD(Lock)(THIS_ LPRECT,LPDDSURFACEDESC,DWORD,HANDLE) PURE;
+    STDMETHOD(ReleaseDC)(THIS_ HDC) PURE;
+    STDMETHOD(Restore)(THIS) PURE;
+    STDMETHOD(SetClipper)(THIS_ LPDIRECTDRAWCLIPPER) PURE;
+    STDMETHOD(SetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;
+    STDMETHOD(SetOverlayPosition)(THIS_ LONG, LONG ) PURE;
+    STDMETHOD(SetPalette)(THIS_ LPDIRECTDRAWPALETTE) PURE;
+    STDMETHOD(Unlock)(THIS_ LPVOID) PURE;
+    STDMETHOD(UpdateOverlay)(THIS_ LPRECT, LPDIRECTDRAWSURFACE2,LPRECT,DWORD, LPDDOVERLAYFX) PURE;
+    STDMETHOD(UpdateOverlayDisplay)(THIS_ DWORD) PURE;
+    STDMETHOD(UpdateOverlayZOrder)(THIS_ DWORD, LPDIRECTDRAWSURFACE2) PURE;
+    /*** Added in the v2 interface ***/
+    STDMETHOD(GetDDInterface)(THIS_ LPVOID FAR *) PURE;
+    STDMETHOD(PageLock)(THIS_ DWORD) PURE;
+    STDMETHOD(PageUnlock)(THIS_ DWORD) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectDrawSurface2_QueryInterface(p,a,b)        (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirectDrawSurface2_AddRef(p)                    (p)->lpVtbl->AddRef(p)
+#define IDirectDrawSurface2_Release(p)                   (p)->lpVtbl->Release(p)
+#define IDirectDrawSurface2_AddAttachedSurface(p,a)      (p)->lpVtbl->AddAttachedSurface(p,a)
+#define IDirectDrawSurface2_AddOverlayDirtyRect(p,a)     (p)->lpVtbl->AddOverlayDirtyRect(p,a)
+#define IDirectDrawSurface2_Blt(p,a,b,c,d,e)             (p)->lpVtbl->Blt(p,a,b,c,d,e)
+#define IDirectDrawSurface2_BltBatch(p,a,b,c)            (p)->lpVtbl->BltBatch(p,a,b,c)
+#define IDirectDrawSurface2_BltFast(p,a,b,c,d,e)         (p)->lpVtbl->BltFast(p,a,b,c,d,e)
+#define IDirectDrawSurface2_DeleteAttachedSurface(p,a,b) (p)->lpVtbl->DeleteAttachedSurface(p,a,b)
+#define IDirectDrawSurface2_EnumAttachedSurfaces(p,a,b)  (p)->lpVtbl->EnumAttachedSurfaces(p,a,b)
+#define IDirectDrawSurface2_EnumOverlayZOrders(p,a,b,c)  (p)->lpVtbl->EnumOverlayZOrders(p,a,b,c)
+#define IDirectDrawSurface2_Flip(p,a,b)                  (p)->lpVtbl->Flip(p,a,b)
+#define IDirectDrawSurface2_GetAttachedSurface(p,a,b)    (p)->lpVtbl->GetAttachedSurface(p,a,b)
+#define IDirectDrawSurface2_GetBltStatus(p,a)            (p)->lpVtbl->GetBltStatus(p,a)
+#define IDirectDrawSurface2_GetCaps(p,b)                 (p)->lpVtbl->GetCaps(p,b)
+#define IDirectDrawSurface2_GetClipper(p,a)              (p)->lpVtbl->GetClipper(p,a)
+#define IDirectDrawSurface2_GetColorKey(p,a,b)           (p)->lpVtbl->GetColorKey(p,a,b)
+#define IDirectDrawSurface2_GetDC(p,a)                   (p)->lpVtbl->GetDC(p,a)
+#define IDirectDrawSurface2_GetFlipStatus(p,a)           (p)->lpVtbl->GetFlipStatus(p,a)
+#define IDirectDrawSurface2_GetOverlayPosition(p,a,b)    (p)->lpVtbl->GetOverlayPosition(p,a,b)
+#define IDirectDrawSurface2_GetPalette(p,a)              (p)->lpVtbl->GetPalette(p,a)
+#define IDirectDrawSurface2_GetPixelFormat(p,a)          (p)->lpVtbl->GetPixelFormat(p,a)
+#define IDirectDrawSurface2_GetSurfaceDesc(p,a)          (p)->lpVtbl->GetSurfaceDesc(p,a)
+#define IDirectDrawSurface2_Initialize(p,a,b)            (p)->lpVtbl->Initialize(p,a,b)
+#define IDirectDrawSurface2_IsLost(p)                    (p)->lpVtbl->IsLost(p)
+#define IDirectDrawSurface2_Lock(p,a,b,c,d)              (p)->lpVtbl->Lock(p,a,b,c,d)
+#define IDirectDrawSurface2_ReleaseDC(p,a)               (p)->lpVtbl->ReleaseDC(p,a)
+#define IDirectDrawSurface2_Restore(p)                   (p)->lpVtbl->Restore(p)
+#define IDirectDrawSurface2_SetClipper(p,a)              (p)->lpVtbl->SetClipper(p,a)
+#define IDirectDrawSurface2_SetColorKey(p,a,b)           (p)->lpVtbl->SetColorKey(p,a,b)
+#define IDirectDrawSurface2_SetOverlayPosition(p,a,b)    (p)->lpVtbl->SetOverlayPosition(p,a,b)
+#define IDirectDrawSurface2_SetPalette(p,a)              (p)->lpVtbl->SetPalette(p,a)
+#define IDirectDrawSurface2_Unlock(p,b)                  (p)->lpVtbl->Unlock(p,b)
+#define IDirectDrawSurface2_UpdateOverlay(p,a,b,c,d,e)   (p)->lpVtbl->UpdateOverlay(p,a,b,c,d,e)
+#define IDirectDrawSurface2_UpdateOverlayDisplay(p,a)    (p)->lpVtbl->UpdateOverlayDisplay(p,a)
+#define IDirectDrawSurface2_UpdateOverlayZOrder(p,a,b)   (p)->lpVtbl->UpdateOverlayZOrder(p,a,b)
+#define IDirectDrawSurface2_GetDDInterface(p,a)		 (p)->lpVtbl->GetDDInterface(p,a)
+#define IDirectDrawSurface2_PageLock(p,a)		 (p)->lpVtbl->PageLock(p,a)
+#define IDirectDrawSurface2_PageUnlock(p,a)		 (p)->lpVtbl->PageUnlock(p,a)
+#else
+#define IDirectDrawSurface2_QueryInterface(p,a,b)        (p)->QueryInterface(a,b)
+#define IDirectDrawSurface2_AddRef(p)                    (p)->AddRef()
+#define IDirectDrawSurface2_Release(p)                   (p)->Release()
+#define IDirectDrawSurface2_AddAttachedSurface(p,a)      (p)->AddAttachedSurface(a)
+#define IDirectDrawSurface2_AddOverlayDirtyRect(p,a)     (p)->AddOverlayDirtyRect(a)
+#define IDirectDrawSurface2_Blt(p,a,b,c,d,e)             (p)->Blt(a,b,c,d,e)
+#define IDirectDrawSurface2_BltBatch(p,a,b,c)            (p)->BltBatch(a,b,c)
+#define IDirectDrawSurface2_BltFast(p,a,b,c,d,e)         (p)->BltFast(a,b,c,d,e)
+#define IDirectDrawSurface2_DeleteAttachedSurface(p,a,b) (p)->DeleteAttachedSurface(a,b)
+#define IDirectDrawSurface2_EnumAttachedSurfaces(p,a,b)  (p)->EnumAttachedSurfaces(a,b)
+#define IDirectDrawSurface2_EnumOverlayZOrders(p,a,b,c)  (p)->EnumOverlayZOrders(a,b,c)
+#define IDirectDrawSurface2_Flip(p,a,b)                  (p)->Flip(a,b)
+#define IDirectDrawSurface2_GetAttachedSurface(p,a,b)    (p)->GetAttachedSurface(a,b)
+#define IDirectDrawSurface2_GetBltStatus(p,a)            (p)->GetBltStatus(a)
+#define IDirectDrawSurface2_GetCaps(p,b)                 (p)->GetCaps(b)
+#define IDirectDrawSurface2_GetClipper(p,a)              (p)->GetClipper(a)
+#define IDirectDrawSurface2_GetColorKey(p,a,b)           (p)->GetColorKey(a,b)
+#define IDirectDrawSurface2_GetDC(p,a)                   (p)->GetDC(a)
+#define IDirectDrawSurface2_GetFlipStatus(p,a)           (p)->GetFlipStatus(a)
+#define IDirectDrawSurface2_GetOverlayPosition(p,a,b)    (p)->GetOverlayPosition(a,b)
+#define IDirectDrawSurface2_GetPalette(p,a)              (p)->GetPalette(a)
+#define IDirectDrawSurface2_GetPixelFormat(p,a)          (p)->GetPixelFormat(a)
+#define IDirectDrawSurface2_GetSurfaceDesc(p,a)          (p)->GetSurfaceDesc(a)
+#define IDirectDrawSurface2_Initialize(p,a,b)            (p)->Initialize(a,b)
+#define IDirectDrawSurface2_IsLost(p)                    (p)->IsLost()
+#define IDirectDrawSurface2_Lock(p,a,b,c,d)              (p)->Lock(a,b,c,d)
+#define IDirectDrawSurface2_ReleaseDC(p,a)               (p)->ReleaseDC(a)
+#define IDirectDrawSurface2_Restore(p)                   (p)->Restore()
+#define IDirectDrawSurface2_SetClipper(p,a)              (p)->SetClipper(a)
+#define IDirectDrawSurface2_SetColorKey(p,a,b)           (p)->SetColorKey(a,b)
+#define IDirectDrawSurface2_SetOverlayPosition(p,a,b)    (p)->SetOverlayPosition(a,b)
+#define IDirectDrawSurface2_SetPalette(p,a)              (p)->SetPalette(a)
+#define IDirectDrawSurface2_Unlock(p,b)                  (p)->Unlock(b)
+#define IDirectDrawSurface2_UpdateOverlay(p,a,b,c,d,e)   (p)->UpdateOverlay(a,b,c,d,e)
+#define IDirectDrawSurface2_UpdateOverlayDisplay(p,a)    (p)->UpdateOverlayDisplay(a)
+#define IDirectDrawSurface2_UpdateOverlayZOrder(p,a,b)   (p)->UpdateOverlayZOrder(a,b)
+#define IDirectDrawSurface2_GetDDInterface(p,a)		 (p)->GetDDInterface(a)
+#define IDirectDrawSurface2_PageLock(p,a)		 (p)->PageLock(a)
+#define IDirectDrawSurface2_PageUnlock(p,a)		 (p)->PageUnlock(a)
+#endif
+
+/*
+ * IDirectDrawSurface3 and related interfaces
+ */
+#undef INTERFACE
+#define INTERFACE IDirectDrawSurface3
+DECLARE_INTERFACE_( IDirectDrawSurface3, IUnknown )
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
+    STDMETHOD_(ULONG,Release) (THIS) PURE;
+    /*** IDirectDrawSurface methods ***/
+    STDMETHOD(AddAttachedSurface)(THIS_ LPDIRECTDRAWSURFACE3) PURE;
+    STDMETHOD(AddOverlayDirtyRect)(THIS_ LPRECT) PURE;
+    STDMETHOD(Blt)(THIS_ LPRECT,LPDIRECTDRAWSURFACE3, LPRECT,DWORD, LPDDBLTFX) PURE;
+    STDMETHOD(BltBatch)(THIS_ LPDDBLTBATCH, DWORD, DWORD ) PURE;
+    STDMETHOD(BltFast)(THIS_ DWORD,DWORD,LPDIRECTDRAWSURFACE3, LPRECT,DWORD) PURE;
+    STDMETHOD(DeleteAttachedSurface)(THIS_ DWORD,LPDIRECTDRAWSURFACE3) PURE;
+    STDMETHOD(EnumAttachedSurfaces)(THIS_ LPVOID,LPDDENUMSURFACESCALLBACK) PURE;
+    STDMETHOD(EnumOverlayZOrders)(THIS_ DWORD,LPVOID,LPDDENUMSURFACESCALLBACK) PURE;
+    STDMETHOD(Flip)(THIS_ LPDIRECTDRAWSURFACE3, DWORD) PURE;
+    STDMETHOD(GetAttachedSurface)(THIS_ LPDDSCAPS, LPDIRECTDRAWSURFACE3 FAR *) PURE;
+    STDMETHOD(GetBltStatus)(THIS_ DWORD) PURE;
+    STDMETHOD(GetCaps)(THIS_ LPDDSCAPS) PURE;
+    STDMETHOD(GetClipper)(THIS_ LPDIRECTDRAWCLIPPER FAR*) PURE;
+    STDMETHOD(GetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;
+    STDMETHOD(GetDC)(THIS_ HDC FAR *) PURE;
+    STDMETHOD(GetFlipStatus)(THIS_ DWORD) PURE;
+    STDMETHOD(GetOverlayPosition)(THIS_ LPLONG, LPLONG ) PURE;
+    STDMETHOD(GetPalette)(THIS_ LPDIRECTDRAWPALETTE FAR*) PURE;
+    STDMETHOD(GetPixelFormat)(THIS_ LPDDPIXELFORMAT) PURE;
+    STDMETHOD(GetSurfaceDesc)(THIS_ LPDDSURFACEDESC) PURE;
+    STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, LPDDSURFACEDESC) PURE;
+    STDMETHOD(IsLost)(THIS) PURE;
+    STDMETHOD(Lock)(THIS_ LPRECT,LPDDSURFACEDESC,DWORD,HANDLE) PURE;
+    STDMETHOD(ReleaseDC)(THIS_ HDC) PURE;
+    STDMETHOD(Restore)(THIS) PURE;
+    STDMETHOD(SetClipper)(THIS_ LPDIRECTDRAWCLIPPER) PURE;
+    STDMETHOD(SetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;
+    STDMETHOD(SetOverlayPosition)(THIS_ LONG, LONG ) PURE;
+    STDMETHOD(SetPalette)(THIS_ LPDIRECTDRAWPALETTE) PURE;
+    STDMETHOD(Unlock)(THIS_ LPVOID) PURE;
+    STDMETHOD(UpdateOverlay)(THIS_ LPRECT, LPDIRECTDRAWSURFACE3,LPRECT,DWORD, LPDDOVERLAYFX) PURE;
+    STDMETHOD(UpdateOverlayDisplay)(THIS_ DWORD) PURE;
+    STDMETHOD(UpdateOverlayZOrder)(THIS_ DWORD, LPDIRECTDRAWSURFACE3) PURE;
+    /*** Added in the v2 interface ***/
+    STDMETHOD(GetDDInterface)(THIS_ LPVOID FAR *) PURE;
+    STDMETHOD(PageLock)(THIS_ DWORD) PURE;
+    STDMETHOD(PageUnlock)(THIS_ DWORD) PURE;
+    /*** Added in the V3 interface ***/
+    STDMETHOD(SetSurfaceDesc)(THIS_ LPDDSURFACEDESC, DWORD) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectDrawSurface3_QueryInterface(p,a,b)        (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirectDrawSurface3_AddRef(p)                    (p)->lpVtbl->AddRef(p)
+#define IDirectDrawSurface3_Release(p)                   (p)->lpVtbl->Release(p)
+#define IDirectDrawSurface3_AddAttachedSurface(p,a)      (p)->lpVtbl->AddAttachedSurface(p,a)
+#define IDirectDrawSurface3_AddOverlayDirtyRect(p,a)     (p)->lpVtbl->AddOverlayDirtyRect(p,a)
+#define IDirectDrawSurface3_Blt(p,a,b,c,d,e)             (p)->lpVtbl->Blt(p,a,b,c,d,e)
+#define IDirectDrawSurface3_BltBatch(p,a,b,c)            (p)->lpVtbl->BltBatch(p,a,b,c)
+#define IDirectDrawSurface3_BltFast(p,a,b,c,d,e)         (p)->lpVtbl->BltFast(p,a,b,c,d,e)
+#define IDirectDrawSurface3_DeleteAttachedSurface(p,a,b) (p)->lpVtbl->DeleteAttachedSurface(p,a,b)
+#define IDirectDrawSurface3_EnumAttachedSurfaces(p,a,b)  (p)->lpVtbl->EnumAttachedSurfaces(p,a,b)
+#define IDirectDrawSurface3_EnumOverlayZOrders(p,a,b,c)  (p)->lpVtbl->EnumOverlayZOrders(p,a,b,c)
+#define IDirectDrawSurface3_Flip(p,a,b)                  (p)->lpVtbl->Flip(p,a,b)
+#define IDirectDrawSurface3_GetAttachedSurface(p,a,b)    (p)->lpVtbl->GetAttachedSurface(p,a,b)
+#define IDirectDrawSurface3_GetBltStatus(p,a)            (p)->lpVtbl->GetBltStatus(p,a)
+#define IDirectDrawSurface3_GetCaps(p,b)                 (p)->lpVtbl->GetCaps(p,b)
+#define IDirectDrawSurface3_GetClipper(p,a)              (p)->lpVtbl->GetClipper(p,a)
+#define IDirectDrawSurface3_GetColorKey(p,a,b)           (p)->lpVtbl->GetColorKey(p,a,b)
+#define IDirectDrawSurface3_GetDC(p,a)                   (p)->lpVtbl->GetDC(p,a)
+#define IDirectDrawSurface3_GetFlipStatus(p,a)           (p)->lpVtbl->GetFlipStatus(p,a)
+#define IDirectDrawSurface3_GetOverlayPosition(p,a,b)    (p)->lpVtbl->GetOverlayPosition(p,a,b)
+#define IDirectDrawSurface3_GetPalette(p,a)              (p)->lpVtbl->GetPalette(p,a)
+#define IDirectDrawSurface3_GetPixelFormat(p,a)          (p)->lpVtbl->GetPixelFormat(p,a)
+#define IDirectDrawSurface3_GetSurfaceDesc(p,a)          (p)->lpVtbl->GetSurfaceDesc(p,a)
+#define IDirectDrawSurface3_Initialize(p,a,b)            (p)->lpVtbl->Initialize(p,a,b)
+#define IDirectDrawSurface3_IsLost(p)                    (p)->lpVtbl->IsLost(p)
+#define IDirectDrawSurface3_Lock(p,a,b,c,d)              (p)->lpVtbl->Lock(p,a,b,c,d)
+#define IDirectDrawSurface3_ReleaseDC(p,a)               (p)->lpVtbl->ReleaseDC(p,a)
+#define IDirectDrawSurface3_Restore(p)                   (p)->lpVtbl->Restore(p)
+#define IDirectDrawSurface3_SetClipper(p,a)              (p)->lpVtbl->SetClipper(p,a)
+#define IDirectDrawSurface3_SetColorKey(p,a,b)           (p)->lpVtbl->SetColorKey(p,a,b)
+#define IDirectDrawSurface3_SetOverlayPosition(p,a,b)    (p)->lpVtbl->SetOverlayPosition(p,a,b)
+#define IDirectDrawSurface3_SetPalette(p,a)              (p)->lpVtbl->SetPalette(p,a)
+#define IDirectDrawSurface3_Unlock(p,b)                  (p)->lpVtbl->Unlock(p,b)
+#define IDirectDrawSurface3_UpdateOverlay(p,a,b,c,d,e)   (p)->lpVtbl->UpdateOverlay(p,a,b,c,d,e)
+#define IDirectDrawSurface3_UpdateOverlayDisplay(p,a)    (p)->lpVtbl->UpdateOverlayDisplay(p,a)
+#define IDirectDrawSurface3_UpdateOverlayZOrder(p,a,b)   (p)->lpVtbl->UpdateOverlayZOrder(p,a,b)
+#define IDirectDrawSurface3_GetDDInterface(p,a)		 (p)->lpVtbl->GetDDInterface(p,a)
+#define IDirectDrawSurface3_PageLock(p,a)		 (p)->lpVtbl->PageLock(p,a)
+#define IDirectDrawSurface3_PageUnlock(p,a)		 (p)->lpVtbl->PageUnlock(p,a)
+#define IDirectDrawSurface3_SetSurfaceDesc(p,a,b)	 (p)->lpVtbl->SetSurfaceDesc(p,a,b)
+#else
+#define IDirectDrawSurface3_QueryInterface(p,a,b)        (p)->QueryInterface(a,b)
+#define IDirectDrawSurface3_AddRef(p)                    (p)->AddRef()
+#define IDirectDrawSurface3_Release(p)                   (p)->Release()
+#define IDirectDrawSurface3_AddAttachedSurface(p,a)      (p)->AddAttachedSurface(a)
+#define IDirectDrawSurface3_AddOverlayDirtyRect(p,a)     (p)->AddOverlayDirtyRect(a)
+#define IDirectDrawSurface3_Blt(p,a,b,c,d,e)             (p)->Blt(a,b,c,d,e)
+#define IDirectDrawSurface3_BltBatch(p,a,b,c)            (p)->BltBatch(a,b,c)
+#define IDirectDrawSurface3_BltFast(p,a,b,c,d,e)         (p)->BltFast(a,b,c,d,e)
+#define IDirectDrawSurface3_DeleteAttachedSurface(p,a,b) (p)->DeleteAttachedSurface(a,b)
+#define IDirectDrawSurface3_EnumAttachedSurfaces(p,a,b)  (p)->EnumAttachedSurfaces(a,b)
+#define IDirectDrawSurface3_EnumOverlayZOrders(p,a,b,c)  (p)->EnumOverlayZOrders(a,b,c)
+#define IDirectDrawSurface3_Flip(p,a,b)                  (p)->Flip(a,b)
+#define IDirectDrawSurface3_GetAttachedSurface(p,a,b)    (p)->GetAttachedSurface(a,b)
+#define IDirectDrawSurface3_GetBltStatus(p,a)            (p)->GetBltStatus(a)
+#define IDirectDrawSurface3_GetCaps(p,b)                 (p)->GetCaps(b)
+#define IDirectDrawSurface3_GetClipper(p,a)              (p)->GetClipper(a)
+#define IDirectDrawSurface3_GetColorKey(p,a,b)           (p)->GetColorKey(a,b)
+#define IDirectDrawSurface3_GetDC(p,a)                   (p)->GetDC(a)
+#define IDirectDrawSurface3_GetFlipStatus(p,a)           (p)->GetFlipStatus(a)
+#define IDirectDrawSurface3_GetOverlayPosition(p,a,b)    (p)->GetOverlayPosition(a,b)
+#define IDirectDrawSurface3_GetPalette(p,a)              (p)->GetPalette(a)
+#define IDirectDrawSurface3_GetPixelFormat(p,a)          (p)->GetPixelFormat(a)
+#define IDirectDrawSurface3_GetSurfaceDesc(p,a)          (p)->GetSurfaceDesc(a)
+#define IDirectDrawSurface3_Initialize(p,a,b)            (p)->Initialize(a,b)
+#define IDirectDrawSurface3_IsLost(p)                    (p)->IsLost()
+#define IDirectDrawSurface3_Lock(p,a,b,c,d)              (p)->Lock(a,b,c,d)
+#define IDirectDrawSurface3_ReleaseDC(p,a)               (p)->ReleaseDC(a)
+#define IDirectDrawSurface3_Restore(p)                   (p)->Restore()
+#define IDirectDrawSurface3_SetClipper(p,a)              (p)->SetClipper(a)
+#define IDirectDrawSurface3_SetColorKey(p,a,b)           (p)->SetColorKey(a,b)
+#define IDirectDrawSurface3_SetOverlayPosition(p,a,b)    (p)->SetOverlayPosition(a,b)
+#define IDirectDrawSurface3_SetPalette(p,a)              (p)->SetPalette(a)
+#define IDirectDrawSurface3_Unlock(p,b)                  (p)->Unlock(b)
+#define IDirectDrawSurface3_UpdateOverlay(p,a,b,c,d,e)   (p)->UpdateOverlay(a,b,c,d,e)
+#define IDirectDrawSurface3_UpdateOverlayDisplay(p,a)    (p)->UpdateOverlayDisplay(a)
+#define IDirectDrawSurface3_UpdateOverlayZOrder(p,a,b)   (p)->UpdateOverlayZOrder(a,b)
+#define IDirectDrawSurface3_GetDDInterface(p,a)		 (p)->GetDDInterface(a)
+#define IDirectDrawSurface3_PageLock(p,a)		 (p)->PageLock(a)
+#define IDirectDrawSurface3_PageUnlock(p,a)		 (p)->PageUnlock(a)
+#define IDirectDrawSurface3_SetSurfaceDesc(p,a,b)	 (p)->SetSurfaceDesc(a,b)
+#endif
+
+/*
+ * IDirectDrawColorControl
+ */
+#if defined( _WIN32 ) && !defined( _NO_COM )
+#undef INTERFACE
+#define INTERFACE IDirectDrawColorControl
+DECLARE_INTERFACE_( IDirectDrawColorControl, IUnknown )
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
+    STDMETHOD_(ULONG,Release) (THIS) PURE;
+    /*** IDirectDrawColorControl methods ***/
+    STDMETHOD(GetColorControls)(THIS_ LPDDCOLORCONTROL) PURE;
+    STDMETHOD(SetColorControls)(THIS_ LPDDCOLORCONTROL) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectDrawColorControl_QueryInterface(p, a, b)  (p)->lpVtbl->QueryInterface(p, a, b)
+#define IDirectDrawColorControl_AddRef(p)                (p)->lpVtbl->AddRef(p)
+#define IDirectDrawColorControl_Release(p)               (p)->lpVtbl->Release(p)
+#define IDirectDrawColorControl_GetColorControls(p, a)   (p)->lpVtbl->GetColorControls(p, a)
+#define IDirectDrawColorControl_SetColorControls(p, a)   (p)->lpVtbl->SetColorControls(p, a)
+#else
+#define IDirectDrawColorControl_QueryInterface(p, a, b)  (p)->QueryInterface(a, b)
+#define IDirectDrawColorControl_AddRef(p)                (p)->AddRef()
+#define IDirectDrawColorControl_Release(p)               (p)->Release()
+#define IDirectDrawColorControl_GetColorControls(p, a)   (p)->GetColorControls(a)
+#define IDirectDrawColorControl_SetColorControls(p, a)   (p)->SetColorControls(a)
+#endif
+
+#endif
+
+
+
+#endif
+
+
+/*
+ * DDSURFACEDESC
+ */
+typedef struct _DDSURFACEDESC
+{
+    DWORD		dwSize;			// size of the DDSURFACEDESC structure
+    DWORD		dwFlags;		// determines what fields are valid
+    DWORD		dwHeight;		// height of surface to be created
+    DWORD		dwWidth;		// width of input surface
+    union
+    {
+        LONG		lPitch;			// distance to start of next line (return value only)
+        DWORD           dwLinearSize;           // Formless late-allocated optimized surface size
+    };
+    DWORD		dwBackBufferCount;	// number of back buffers requested
+    union
+    {
+        DWORD           dwMipMapCount;          // number of mip-map levels requested
+	DWORD		dwZBufferBitDepth;	// depth of Z buffer requested
+	DWORD		dwRefreshRate;		// refresh rate (used when display mode is described)
+    };
+    DWORD		dwAlphaBitDepth;	// depth of alpha buffer requested
+    DWORD		dwReserved;		// reserved
+    LPVOID		lpSurface;		// pointer to the associated surface memory
+    DDCOLORKEY		ddckCKDestOverlay;	// color key for destination overlay use
+    DDCOLORKEY		ddckCKDestBlt;		// color key for destination blt use
+    DDCOLORKEY		ddckCKSrcOverlay;	// color key for source overlay use
+    DDCOLORKEY		ddckCKSrcBlt;		// color key for source blt use
+    DDPIXELFORMAT	ddpfPixelFormat;	// pixel format description of the surface
+    DDSCAPS		ddsCaps;		// direct draw surface capabilities
+} DDSURFACEDESC;
+
+/*
+ * ddsCaps field is valid.
+ */
+#define DDSD_CAPS		0x00000001l	// default
+
+/*
+ * dwHeight field is valid.
+ */
+#define DDSD_HEIGHT		0x00000002l
+
+/*
+ * dwWidth field is valid.
+ */
+#define DDSD_WIDTH		0x00000004l
+
+/*
+ * lPitch is valid.
+ */
+#define DDSD_PITCH		0x00000008l
+
+/*
+ * dwBackBufferCount is valid.
+ */
+#define DDSD_BACKBUFFERCOUNT	0x00000020l
+
+/*
+ * dwZBufferBitDepth is valid.
+ */
+#define DDSD_ZBUFFERBITDEPTH	0x00000040l
+
+/*
+ * dwAlphaBitDepth is valid.
+ */
+#define DDSD_ALPHABITDEPTH	0x00000080l
+
+
+/*
+ * lpSurface is valid.
+ */
+#define DDSD_LPSURFACE		0x00000800l
+
+/*
+ * ddpfPixelFormat is valid.
+ */
+#define DDSD_PIXELFORMAT	0x00001000l
+
+/*
+ * ddckCKDestOverlay is valid.
+ */
+#define DDSD_CKDESTOVERLAY	0x00002000l
+
+/*
+ * ddckCKDestBlt is valid.
+ */
+#define DDSD_CKDESTBLT		0x00004000l
+
+/*
+ * ddckCKSrcOverlay is valid.
+ */
+#define DDSD_CKSRCOVERLAY	0x00008000l
+
+/*
+ * ddckCKSrcBlt is valid.
+ */
+#define DDSD_CKSRCBLT		0x00010000l
+
+/*
+ * dwMipMapCount is valid.
+ */
+#define DDSD_MIPMAPCOUNT        0x00020000l
+
+ /*
+  * dwRefreshRate is valid
+  */
+#define DDSD_REFRESHRATE	0x00040000l
+
+/*
+ * dwLinearSize is valid
+ */
+#define DDSD_LINEARSIZE		0x00080000l
+
+/*
+ * All input fields are valid.
+ */
+#define DDSD_ALL		0x000ff9eel
+
+
+/*
+ * DDCOLORCONTROL
+ */
+typedef struct _DDCOLORCONTROL
+{
+    DWORD 		dwSize;
+    DWORD		dwFlags;
+    LONG		lBrightness;
+    LONG		lContrast;
+    LONG		lHue;
+    LONG 		lSaturation;
+    LONG		lSharpness;
+    LONG		lGamma;
+    LONG		lColorEnable;
+    DWORD		dwReserved1;
+} DDCOLORCONTROL;
+
+
+/*
+ * lBrightness field is valid.
+ */
+#define DDCOLOR_BRIGHTNESS		0x00000001l
+
+/*
+ * lContrast field is valid.
+ */
+#define DDCOLOR_CONTRAST		0x00000002l
+
+/*
+ * lHue field is valid.
+ */
+#define DDCOLOR_HUE			0x00000004l
+
+/*
+ * lSaturation field is valid.
+ */
+#define DDCOLOR_SATURATION		0x00000008l
+
+/*
+ * lSharpness field is valid.
+ */
+#define DDCOLOR_SHARPNESS		0x00000010l
+
+/*
+ * lGamma field is valid.
+ */
+#define DDCOLOR_GAMMA			0x00000020l
+
+/*
+ * lColorEnable field is valid.
+ */
+#define DDCOLOR_COLORENABLE		0x00000040l
+
+
+
+/*============================================================================
+ *
+ * Direct Draw Capability Flags
+ *
+ * These flags are used to describe the capabilities of a given Surface.
+ * All flags are bit flags.
+ *
+ *==========================================================================*/
+
+/****************************************************************************
+ *
+ * DIRECTDRAWSURFACE CAPABILITY FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * This bit is reserved. It should not be specified.
+ */
+#define DDSCAPS_RESERVED1			0x00000001l
+
+/*
+ * Indicates that this surface contains alpha-only information.
+ * (To determine if a surface is RGBA/YUVA, the pixel format must be
+ * interrogated.)
+ */
+#define DDSCAPS_ALPHA				0x00000002l
+
+/*
+ * Indicates that this surface is a backbuffer.	 It is generally
+ * set by CreateSurface when the DDSCAPS_FLIP capability bit is set.
+ * It indicates that this surface is THE back buffer of a surface
+ * flipping structure.	DirectDraw supports N surfaces in a
+ * surface flipping structure.	Only the surface that immediately
+ * precedeces the DDSCAPS_FRONTBUFFER has this capability bit set.
+ * The other surfaces are identified as back buffers by the presence
+ * of the DDSCAPS_FLIP capability, their attachment order, and the
+ * absence of the DDSCAPS_FRONTBUFFER and DDSCAPS_BACKBUFFER
+ * capabilities.  The bit is sent to CreateSurface when a standalone
+ * back buffer is being created.  This surface could be attached to
+ * a front buffer and/or back buffers to form a flipping surface
+ * structure after the CreateSurface call.  See AddAttachments for
+ * a detailed description of the behaviors in this case.
+ */
+#define DDSCAPS_BACKBUFFER			0x00000004l
+
+/*
+ * Indicates a complex surface structure is being described.  A
+ * complex surface structure results in the creation of more than
+ * one surface.	 The additional surfaces are attached to the root
+ * surface.  The complex structure can only be destroyed by
+ * destroying the root.
+ */
+#define DDSCAPS_COMPLEX				0x00000008l
+
+/*
+ * Indicates that this surface is a part of a surface flipping structure.
+ * When it is passed to CreateSurface the DDSCAPS_FRONTBUFFER and
+ * DDSCAP_BACKBUFFER bits are not set.	They are set by CreateSurface
+ * on the resulting creations.	The dwBackBufferCount field in the
+ * DDSURFACEDESC structure must be set to at least 1 in order for
+ * the CreateSurface call to succeed.  The DDSCAPS_COMPLEX capability
+ * must always be set with creating multiple surfaces through CreateSurface.
+ */
+#define DDSCAPS_FLIP				0x00000010l
+
+/*
+ * Indicates that this surface is THE front buffer of a surface flipping
+ * structure.  It is generally set by CreateSurface when the DDSCAPS_FLIP
+ * capability bit is set.
+ * If this capability is sent to CreateSurface then a standalonw front buffer
+ * is created.	This surface will not have the DDSCAPS_FLIP capability.
+ * It can be attached to other back buffers to form a flipping structure.
+ * See AddAttachments for a detailed description of the behaviors in this
+ * case.
+ */
+#define DDSCAPS_FRONTBUFFER			0x00000020l
+
+/*
+ * Indicates that this surface is any offscreen surface that is not an overlay,
+ * texture, zbuffer, front buffer, back buffer, or alpha surface.  It is used
+ * to identify plain vanilla surfaces.
+ */
+#define DDSCAPS_OFFSCREENPLAIN			0x00000040l
+
+/*
+ * Indicates that this surface is an overlay.  It may or may not be directly visible
+ * depending on whether or not it is currently being overlayed onto the primary
+ * surface.  DDSCAPS_VISIBLE can be used to determine whether or not it is being
+ * overlayed at the moment.
+ */
+#define DDSCAPS_OVERLAY				0x00000080l
+
+/*
+ * Indicates that unique DirectDrawPalette objects can be created and
+ * attached to this surface.
+ */
+#define DDSCAPS_PALETTE				0x00000100l
+
+/*
+ * Indicates that this surface is the primary surface.	The primary
+ * surface represents what the user is seeing at the moment.
+ */
+#define DDSCAPS_PRIMARYSURFACE			0x00000200l
+
+/*
+ * Indicates that this surface is the primary surface for the left eye.
+ * The primary surface for the left eye represents what the user is seeing
+ * at the moment with the users left eye.  When this surface is created the
+ * DDSCAPS_PRIMARYSURFACE represents what the user is seeing with the users
+ * right eye.
+ */
+#define DDSCAPS_PRIMARYSURFACELEFT		0x00000400l
+
+/*
+ * Indicates that this surface memory was allocated in system memory
+ */
+#define DDSCAPS_SYSTEMMEMORY			0x00000800l
+
+/*
+ * Indicates that this surface can be used as a 3D texture.  It does not
+ * indicate whether or not the surface is being used for that purpose.
+ */
+#define DDSCAPS_TEXTURE			        0x00001000l
+
+/*
+ * Indicates that a surface may be a destination for 3D rendering.  This
+ * bit must be set in order to query for a Direct3D Device Interface
+ * from this surface.
+ */
+#define DDSCAPS_3DDEVICE                        0x00002000l
+
+/*
+ * Indicates that this surface exists in video memory.
+ */
+#define DDSCAPS_VIDEOMEMORY			0x00004000l
+
+/*
+ * Indicates that changes made to this surface are immediately visible.
+ * It is always set for the primary surface and is set for overlays while
+ * they are being overlayed and texture maps while they are being textured.
+ */
+#define DDSCAPS_VISIBLE				0x00008000l
+
+/*
+ * Indicates that only writes are permitted to the surface.  Read accesses
+ * from the surface may or may not generate a protection fault, but the
+ * results of a read from this surface will not be meaningful.	READ ONLY.
+ */
+#define DDSCAPS_WRITEONLY			0x00010000l
+
+/*
+ * Indicates that this surface is a z buffer. A z buffer does not contain
+ * displayable information.  Instead it contains bit depth information that is
+ * used to determine which pixels are visible and which are obscured.
+ */
+#define DDSCAPS_ZBUFFER				0x00020000l
+
+/*
+ * Indicates surface will have a DC associated long term
+ */
+#define DDSCAPS_OWNDC				0x00040000l
+
+/*
+ * Indicates surface should be able to receive live video
+ */
+#define DDSCAPS_LIVEVIDEO			0x00080000l
+
+/*
+ * Indicates surface should be able to have a stream decompressed
+ * to it by the hardware.
+ */
+#define DDSCAPS_HWCODEC				0x00100000l
+
+/*
+ * Surface is a ModeX surface.
+ *
+ */
+#define DDSCAPS_MODEX				0x00200000l
+
+/*
+ * Indicates surface is one level of a mip-map. This surface will
+ * be attached to other DDSCAPS_MIPMAP surfaces to form the mip-map.
+ * This can be done explicitly, by creating a number of surfaces and
+ * attaching them with AddAttachedSurface or by implicitly by CreateSurface.
+ * If this bit is set then DDSCAPS_TEXTURE must also be set.
+ */
+#define DDSCAPS_MIPMAP                          0x00400000l
+
+/*
+ * This bit is reserved. It should not be specified.
+ */
+#define DDSCAPS_RESERVED2                       0x00800000l
+
+
+/*
+ * Indicates that memory for the surface is not allocated until the surface
+ * is loaded (via the Direct3D texture Load() function).
+ */
+#define DDSCAPS_ALLOCONLOAD                     0x04000000l
+
+/*
+ * Indicates that the surface will recieve data from a video port.
+ */
+#define DDSCAPS_VIDEOPORT			0x08000000l
+
+/*
+ * Indicates that a video memory surface is resident in true, local video
+ * memory rather than non-local video memory. If this flag is specified then
+ * so must DDSCAPS_VIDEOMEMORY. This flag is mutually exclusive with
+ * DDSCAPS_NONLOCALVIDMEM.
+ */
+#define DDSCAPS_LOCALVIDMEM                     0x10000000l
+
+/*
+ * Indicates that a video memory surface is resident in non-local video
+ * memory rather than true, local video memory. If this flag is specified
+ * then so must DDSCAPS_VIDEOMEMORY. This flag is mutually exclusive with
+ * DDSCAPS_LOCALVIDMEM.
+ */
+#define DDSCAPS_NONLOCALVIDMEM                  0x20000000l
+
+/*
+ * Indicates that this surface is a standard VGA mode surface, and not a
+ * ModeX surface. (This flag will never be set in combination with the
+ * DDSCAPS_MODEX flag).
+ */
+#define DDSCAPS_STANDARDVGAMODE                 0x40000000l
+
+/*
+ * Indicates that this surface will be an optimized surface. This flag is
+ * currently only valid in conjunction with the DDSCAPS_TEXTURE flag. The surface
+ * will be created without any underlying video memory until loaded.
+ */
+#define DDSCAPS_OPTIMIZED                       0x80000000l
+
+
+
+ /****************************************************************************
+ *
+ * DIRECTDRAW DRIVER CAPABILITY FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * Display hardware has 3D acceleration.
+ */
+#define DDCAPS_3D			0x00000001l
+
+/*
+ * Indicates that DirectDraw will support only dest rectangles that are aligned
+ * on DIRECTDRAWCAPS.dwAlignBoundaryDest boundaries of the surface, respectively.
+ * READ ONLY.
+ */
+#define DDCAPS_ALIGNBOUNDARYDEST	0x00000002l
+
+/*
+ * Indicates that DirectDraw will support only source rectangles  whose sizes in
+ * BYTEs are DIRECTDRAWCAPS.dwAlignSizeDest multiples, respectively.  READ ONLY.
+ */
+#define DDCAPS_ALIGNSIZEDEST		0x00000004l
+/*
+ * Indicates that DirectDraw will support only source rectangles that are aligned
+ * on DIRECTDRAWCAPS.dwAlignBoundarySrc boundaries of the surface, respectively.
+ * READ ONLY.
+ */
+#define DDCAPS_ALIGNBOUNDARYSRC		0x00000008l
+
+/*
+ * Indicates that DirectDraw will support only source rectangles  whose sizes in
+ * BYTEs are DIRECTDRAWCAPS.dwAlignSizeSrc multiples, respectively.  READ ONLY.
+ */
+#define DDCAPS_ALIGNSIZESRC		0x00000010l
+
+/*
+ * Indicates that DirectDraw will create video memory surfaces that have a stride
+ * alignment equal to DIRECTDRAWCAPS.dwAlignStride.  READ ONLY.
+ */
+#define DDCAPS_ALIGNSTRIDE		0x00000020l
+
+/*
+ * Display hardware is capable of blt operations.
+ */
+#define DDCAPS_BLT			0x00000040l
+
+/*
+ * Display hardware is capable of asynchronous blt operations.
+ */
+#define DDCAPS_BLTQUEUE			0x00000080l
+
+/*
+ * Display hardware is capable of color space conversions during the blt operation.
+ */
+#define DDCAPS_BLTFOURCC		0x00000100l
+
+/*
+ * Display hardware is capable of stretching during blt operations.
+ */
+#define DDCAPS_BLTSTRETCH		0x00000200l
+
+/*
+ * Display hardware is shared with GDI.
+ */
+#define DDCAPS_GDI			0x00000400l
+
+/*
+ * Display hardware can overlay.
+ */
+#define DDCAPS_OVERLAY			0x00000800l
+
+/*
+ * Set if display hardware supports overlays but can not clip them.
+ */
+#define DDCAPS_OVERLAYCANTCLIP		0x00001000l
+
+/*
+ * Indicates that overlay hardware is capable of color space conversions during
+ * the overlay operation.
+ */
+#define DDCAPS_OVERLAYFOURCC		0x00002000l
+
+/*
+ * Indicates that stretching can be done by the overlay hardware.
+ */
+#define DDCAPS_OVERLAYSTRETCH		0x00004000l
+
+/*
+ * Indicates that unique DirectDrawPalettes can be created for DirectDrawSurfaces
+ * other than the primary surface.
+ */
+#define DDCAPS_PALETTE			0x00008000l
+
+/*
+ * Indicates that palette changes can be syncd with the veritcal refresh.
+ */
+#define DDCAPS_PALETTEVSYNC		0x00010000l
+
+/*
+ * Display hardware can return the current scan line.
+ */
+#define DDCAPS_READSCANLINE		0x00020000l
+
+/*
+ * Display hardware has stereo vision capabilities.  DDSCAPS_PRIMARYSURFACELEFT
+ * can be created.
+ */
+#define DDCAPS_STEREOVIEW		0x00040000l
+
+/*
+ * Display hardware is capable of generating a vertical blank interrupt.
+ */
+#define DDCAPS_VBI			0x00080000l
+
+/*
+ * Supports the use of z buffers with blt operations.
+ */
+#define DDCAPS_ZBLTS			0x00100000l
+
+/*
+ * Supports Z Ordering of overlays.
+ */
+#define DDCAPS_ZOVERLAYS		0x00200000l
+
+/*
+ * Supports color key
+ */
+#define DDCAPS_COLORKEY			0x00400000l
+
+/*
+ * Supports alpha surfaces
+ */
+#define DDCAPS_ALPHA			0x00800000l
+
+/*
+ * colorkey is hardware assisted(DDCAPS_COLORKEY will also be set)
+ */
+#define DDCAPS_COLORKEYHWASSIST		0x01000000l
+
+/*
+ * no hardware support at all
+ */
+#define DDCAPS_NOHARDWARE		0x02000000l
+
+/*
+ * Display hardware is capable of color fill with bltter
+ */
+#define DDCAPS_BLTCOLORFILL		0x04000000l
+
+/*
+ * Display hardware is bank switched, and potentially very slow at
+ * random access to VRAM.
+ */
+#define DDCAPS_BANKSWITCHED		0x08000000l
+
+/*
+ * Display hardware is capable of depth filling Z-buffers with bltter
+ */
+#define DDCAPS_BLTDEPTHFILL		0x10000000l
+
+/*
+ * Display hardware is capable of clipping while bltting.
+ */
+#define DDCAPS_CANCLIP			0x20000000l
+
+/*
+ * Display hardware is capable of clipping while stretch bltting.
+ */
+#define DDCAPS_CANCLIPSTRETCHED		0x40000000l
+
+/*
+ * Display hardware is capable of bltting to or from system memory
+ */
+#define DDCAPS_CANBLTSYSMEM		0x80000000l
+
+
+ /****************************************************************************
+ *
+ * MORE DIRECTDRAW DRIVER CAPABILITY FLAGS (dwCaps2)
+ *
+ ****************************************************************************/
+
+/*
+ * Display hardware is certified
+ */
+#define DDCAPS2_CERTIFIED		0x00000001l
+
+/*
+ * Driver cannot interleave 2D operations (lock and blt) to surfaces with
+ * Direct3D rendering operations between calls to BeginScene() and EndScene()
+ */
+#define DDCAPS2_NO2DDURING3DSCENE       0x00000002l
+
+/*
+ * Display hardware contains a video port
+ */
+#define DDCAPS2_VIDEOPORT		0x00000004l
+
+/*
+ * The overlay can be automatically flipped according to the video port
+ * VSYNCs, providing automatic doubled buffered display of video port
+ * data using an overlay
+ */
+#define DDCAPS2_AUTOFLIPOVERLAY		0x00000008l
+
+/*
+ * Overlay can display each field of interlaced data individually while
+ * it is interleaved in memory without causing jittery artifacts.
+ */
+#define DDCAPS2_CANBOBINTERLEAVED	0x00000010l
+
+/*
+ * Overlay can display each field of interlaced data individually while
+ * it is not interleaved in memory without causing jittery artifacts.
+ */
+#define DDCAPS2_CANBOBNONINTERLEAVED	0x00000020l
+
+/*
+ * The overlay surface contains color controls (brightness, sharpness, etc.)
+ */
+#define DDCAPS2_COLORCONTROLOVERLAY	0x00000040l
+
+/*
+ * The primary surface contains color controls (gamma, etc.)
+ */
+#define DDCAPS2_COLORCONTROLPRIMARY	0x00000080l
+
+/*
+ * RGBZ -> RGB supported for 16:16 RGB:Z
+ */
+#define DDCAPS2_CANDROPZ16BIT		0x00000100l
+
+/*
+ * Driver supports non-local video memory.
+ */
+#define DDCAPS2_NONLOCALVIDMEM          0x00000200l
+
+/*
+ * Dirver supports non-local video memory but has different capabilities for
+ * non-local video memory surfaces. If this bit is set then so must
+ * DDCAPS2_NONLOCALVIDMEM.
+ */
+#define DDCAPS2_NONLOCALVIDMEMCAPS      0x00000400l
+
+/*
+ * Driver neither requires nor prefers surfaces to be pagelocked when performing
+ * blts involving system memory surfaces
+ */
+#define DDCAPS2_NOPAGELOCKREQUIRED      0x00000800l
+
+/*
+ * Driver can create surfaces which are wider than the primary surface
+ */
+#define DDCAPS2_WIDESURFACES            0x00001000l
+
+/*
+ * Driver supports bob using software without using a video port
+ */
+#define DDCAPS2_CANFLIPODDEVEN          0x00002000l
+
+/****************************************************************************
+ *
+ * DIRECTDRAW FX ALPHA CAPABILITY FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * Supports alpha blending around the edge of a source color keyed surface.
+ * For Blt.
+ */
+#define DDFXALPHACAPS_BLTALPHAEDGEBLEND		0x00000001l
+
+/*
+ * Supports alpha information in the pixel format.  The bit depth of alpha
+ * information in the pixel format can be 1,2,4, or 8.	The alpha value becomes
+ * more opaque as the alpha value increases.  (0 is transparent.)
+ * For Blt.
+ */
+#define DDFXALPHACAPS_BLTALPHAPIXELS		0x00000002l
+
+/*
+ * Supports alpha information in the pixel format.  The bit depth of alpha
+ * information in the pixel format can be 1,2,4, or 8.	The alpha value
+ * becomes more transparent as the alpha value increases.  (0 is opaque.)
+ * This flag can only be set if DDCAPS_ALPHA is set.
+ * For Blt.
+ */
+#define DDFXALPHACAPS_BLTALPHAPIXELSNEG		0x00000004l
+
+/*
+ * Supports alpha only surfaces.  The bit depth of an alpha only surface can be
+ * 1,2,4, or 8.	 The alpha value becomes more opaque as the alpha value increases.
+ * (0 is transparent.)
+ * For Blt.
+ */
+#define DDFXALPHACAPS_BLTALPHASURFACES		0x00000008l
+
+/*
+ * The depth of the alpha channel data can range can be 1,2,4, or 8.
+ * The NEG suffix indicates that this alpha channel becomes more transparent
+ * as the alpha value increases. (0 is opaque.)	 This flag can only be set if
+ * DDCAPS_ALPHA is set.
+ * For Blt.
+ */
+#define DDFXALPHACAPS_BLTALPHASURFACESNEG	0x00000010l
+
+/*
+ * Supports alpha blending around the edge of a source color keyed surface.
+ * For Overlays.
+ */
+#define DDFXALPHACAPS_OVERLAYALPHAEDGEBLEND	0x00000020l
+
+/*
+ * Supports alpha information in the pixel format.  The bit depth of alpha
+ * information in the pixel format can be 1,2,4, or 8.	The alpha value becomes
+ * more opaque as the alpha value increases.  (0 is transparent.)
+ * For Overlays.
+ */
+#define DDFXALPHACAPS_OVERLAYALPHAPIXELS	0x00000040l
+
+/*
+ * Supports alpha information in the pixel format.  The bit depth of alpha
+ * information in the pixel format can be 1,2,4, or 8.	The alpha value
+ * becomes more transparent as the alpha value increases.  (0 is opaque.)
+ * This flag can only be set if DDCAPS_ALPHA is set.
+ * For Overlays.
+ */
+#define DDFXALPHACAPS_OVERLAYALPHAPIXELSNEG	0x00000080l
+
+/*
+ * Supports alpha only surfaces.  The bit depth of an alpha only surface can be
+ * 1,2,4, or 8.	 The alpha value becomes more opaque as the alpha value increases.
+ * (0 is transparent.)
+ * For Overlays.
+ */
+#define DDFXALPHACAPS_OVERLAYALPHASURFACES	0x00000100l
+
+/*
+ * The depth of the alpha channel data can range can be 1,2,4, or 8.
+ * The NEG suffix indicates that this alpha channel becomes more transparent
+ * as the alpha value increases. (0 is opaque.)	 This flag can only be set if
+ * DDCAPS_ALPHA is set.
+ * For Overlays.
+ */
+#define DDFXALPHACAPS_OVERLAYALPHASURFACESNEG	0x00000200l
+
+/****************************************************************************
+ *
+ * DIRECTDRAW FX CAPABILITY FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * Uses arithmetic operations to stretch and shrink surfaces during blt
+ * rather than pixel doubling techniques.  Along the Y axis.
+ */
+#define DDFXCAPS_BLTARITHSTRETCHY	0x00000020l
+
+/*
+ * Uses arithmetic operations to stretch during blt
+ * rather than pixel doubling techniques.  Along the Y axis. Only
+ * works for x1, x2, etc.
+ */
+#define DDFXCAPS_BLTARITHSTRETCHYN	0x00000010l
+
+/*
+ * Supports mirroring left to right in blt.
+ */
+#define DDFXCAPS_BLTMIRRORLEFTRIGHT	0x00000040l
+
+/*
+ * Supports mirroring top to bottom in blt.
+ */
+#define DDFXCAPS_BLTMIRRORUPDOWN	0x00000080l
+
+/*
+ * Supports arbitrary rotation for blts.
+ */
+#define DDFXCAPS_BLTROTATION		0x00000100l
+
+/*
+ * Supports 90 degree rotations for blts.
+ */
+#define DDFXCAPS_BLTROTATION90		0x00000200l
+
+/*
+ * DirectDraw supports arbitrary shrinking of a surface along the
+ * x axis (horizontal direction) for blts.
+ */
+#define DDFXCAPS_BLTSHRINKX		0x00000400l
+
+/*
+ * DirectDraw supports integer shrinking (1x,2x,) of a surface
+ * along the x axis (horizontal direction) for blts.
+ */
+#define DDFXCAPS_BLTSHRINKXN		0x00000800l
+
+/*
+ * DirectDraw supports arbitrary shrinking of a surface along the
+ * y axis (horizontal direction) for blts.
+ */
+#define DDFXCAPS_BLTSHRINKY		0x00001000l
+
+/*
+ * DirectDraw supports integer shrinking (1x,2x,) of a surface
+ * along the y axis (vertical direction) for blts.
+ */
+#define DDFXCAPS_BLTSHRINKYN		0x00002000l
+
+/*
+ * DirectDraw supports arbitrary stretching of a surface along the
+ * x axis (horizontal direction) for blts.
+ */
+#define DDFXCAPS_BLTSTRETCHX		0x00004000l
+
+/*
+ * DirectDraw supports integer stretching (1x,2x,) of a surface
+ * along the x axis (horizontal direction) for blts.
+ */
+#define DDFXCAPS_BLTSTRETCHXN		0x00008000l
+
+/*
+ * DirectDraw supports arbitrary stretching of a surface along the
+ * y axis (horizontal direction) for blts.
+ */
+#define DDFXCAPS_BLTSTRETCHY		0x00010000l
+
+/*
+ * DirectDraw supports integer stretching (1x,2x,) of a surface
+ * along the y axis (vertical direction) for blts.
+ */
+#define DDFXCAPS_BLTSTRETCHYN		0x00020000l
+
+/*
+ * Uses arithmetic operations to stretch and shrink surfaces during
+ * overlay rather than pixel doubling techniques.  Along the Y axis
+ * for overlays.
+ */
+#define DDFXCAPS_OVERLAYARITHSTRETCHY	0x00040000l
+
+/*
+ * Uses arithmetic operations to stretch surfaces during
+ * overlay rather than pixel doubling techniques.  Along the Y axis
+ * for overlays. Only works for x1, x2, etc.
+ */
+#define DDFXCAPS_OVERLAYARITHSTRETCHYN	0x00000008l
+
+/*
+ * DirectDraw supports arbitrary shrinking of a surface along the
+ * x axis (horizontal direction) for overlays.
+ */
+#define DDFXCAPS_OVERLAYSHRINKX		0x00080000l
+
+/*
+ * DirectDraw supports integer shrinking (1x,2x,) of a surface
+ * along the x axis (horizontal direction) for overlays.
+ */
+#define DDFXCAPS_OVERLAYSHRINKXN	0x00100000l
+
+/*
+ * DirectDraw supports arbitrary shrinking of a surface along the
+ * y axis (horizontal direction) for overlays.
+ */
+#define DDFXCAPS_OVERLAYSHRINKY		0x00200000l
+
+/*
+ * DirectDraw supports integer shrinking (1x,2x,) of a surface
+ * along the y axis (vertical direction) for overlays.
+ */
+#define DDFXCAPS_OVERLAYSHRINKYN	0x00400000l
+
+/*
+ * DirectDraw supports arbitrary stretching of a surface along the
+ * x axis (horizontal direction) for overlays.
+ */
+#define DDFXCAPS_OVERLAYSTRETCHX	0x00800000l
+
+/*
+ * DirectDraw supports integer stretching (1x,2x,) of a surface
+ * along the x axis (horizontal direction) for overlays.
+ */
+#define DDFXCAPS_OVERLAYSTRETCHXN	0x01000000l
+
+/*
+ * DirectDraw supports arbitrary stretching of a surface along the
+ * y axis (horizontal direction) for overlays.
+ */
+#define DDFXCAPS_OVERLAYSTRETCHY	0x02000000l
+
+/*
+ * DirectDraw supports integer stretching (1x,2x,) of a surface
+ * along the y axis (vertical direction) for overlays.
+ */
+#define DDFXCAPS_OVERLAYSTRETCHYN	0x04000000l
+
+/*
+ * DirectDraw supports mirroring of overlays across the vertical axis
+ */
+#define DDFXCAPS_OVERLAYMIRRORLEFTRIGHT	0x08000000l
+
+/*
+ * DirectDraw supports mirroring of overlays across the horizontal axis
+ */
+#define DDFXCAPS_OVERLAYMIRRORUPDOWN	0x10000000l
+
+/****************************************************************************
+ *
+ * DIRECTDRAW STEREO VIEW CAPABILITIES
+ *
+ ****************************************************************************/
+
+/*
+ * The stereo view is accomplished via enigma encoding.
+ */
+#define DDSVCAPS_ENIGMA			0x00000001l
+
+/*
+ * The stereo view is accomplished via high frequency flickering.
+ */
+#define DDSVCAPS_FLICKER		0x00000002l
+
+/*
+ * The stereo view is accomplished via red and blue filters applied
+ * to the left and right eyes.	All images must adapt their colorspaces
+ * for this process.
+ */
+#define DDSVCAPS_REDBLUE		0x00000004l
+
+/*
+ * The stereo view is accomplished with split screen technology.
+ */
+#define DDSVCAPS_SPLIT			0x00000008l
+
+/****************************************************************************
+ *
+ * DIRECTDRAWPALETTE CAPABILITIES
+ *
+ ****************************************************************************/
+
+/*
+ * Index is 4 bits.  There are sixteen color entries in the palette table.
+ */
+#define DDPCAPS_4BIT			0x00000001l
+
+/*
+ * Index is onto a 8 bit color index.  This field is only valid with the
+ * DDPCAPS_1BIT, DDPCAPS_2BIT or DDPCAPS_4BIT capability and the target
+ * surface is in 8bpp. Each color entry is one byte long and is an index
+ * into destination surface's 8bpp palette.
+ */
+#define DDPCAPS_8BITENTRIES		0x00000002l
+
+/*
+ * Index is 8 bits.  There are 256 color entries in the palette table.
+ */
+#define DDPCAPS_8BIT			0x00000004l
+
+/*
+ * Indicates that this DIRECTDRAWPALETTE should use the palette color array
+ * passed into the lpDDColorArray parameter to initialize the DIRECTDRAWPALETTE
+ * object.
+ */
+#define DDPCAPS_INITIALIZE		0x00000008l
+
+/*
+ * This palette is the one attached to the primary surface.  Changing this
+ * table has immediate effect on the display unless DDPSETPAL_VSYNC is specified
+ * and supported.
+ */
+#define DDPCAPS_PRIMARYSURFACE		0x00000010l
+
+/*
+ * This palette is the one attached to the primary surface left.  Changing
+ * this table has immediate effect on the display for the left eye unless
+ * DDPSETPAL_VSYNC is specified and supported.
+ */
+#define DDPCAPS_PRIMARYSURFACELEFT	0x00000020l
+
+/*
+ * This palette can have all 256 entries defined
+ */
+#define DDPCAPS_ALLOW256		0x00000040l
+
+/*
+ * This palette can have modifications to it synced with the monitors
+ * refresh rate.
+ */
+#define DDPCAPS_VSYNC			0x00000080l
+
+/*
+ * Index is 1 bit.  There are two color entries in the palette table.
+ */
+#define DDPCAPS_1BIT			0x00000100l
+
+/*
+ * Index is 2 bit.  There are four color entries in the palette table.
+ */
+#define DDPCAPS_2BIT			0x00000200l
+
+
+/****************************************************************************
+ *
+ * DIRECTDRAWPALETTE SETENTRY CONSTANTS
+ *
+ ****************************************************************************/
+
+
+/****************************************************************************
+ *
+ * DIRECTDRAWPALETTE GETENTRY CONSTANTS
+ *
+ ****************************************************************************/
+
+/* 0 is the only legal value */
+
+/****************************************************************************
+ *
+ * DIRECTDRAWSURFACE SETPALETTE CONSTANTS
+ *
+ ****************************************************************************/
+
+
+/****************************************************************************
+ *
+ * DIRECTDRAW BITDEPTH CONSTANTS
+ *
+ * NOTE:  These are only used to indicate supported bit depths.   These
+ * are flags only, they are not to be used as an actual bit depth.   The
+ * absolute numbers 1, 2, 4, 8, 16, 24 and 32 are used to indicate actual
+ * bit depths in a surface or for changing the display mode.
+ *
+ ****************************************************************************/
+
+/*
+ * 1 bit per pixel.
+ */
+#define DDBD_1			0x00004000l
+
+/*
+ * 2 bits per pixel.
+ */
+#define DDBD_2			0x00002000l
+
+/*
+ * 4 bits per pixel.
+ */
+#define DDBD_4			0x00001000l
+
+/*
+ * 8 bits per pixel.
+ */
+#define DDBD_8			0x00000800l
+
+/*
+ * 16 bits per pixel.
+ */
+#define DDBD_16			0x00000400l
+
+/*
+ * 24 bits per pixel.
+ */
+#define DDBD_24			0X00000200l
+
+/*
+ * 32 bits per pixel.
+ */
+#define DDBD_32			0x00000100l
+
+/****************************************************************************
+ *
+ * DIRECTDRAWSURFACE SET/GET COLOR KEY FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * Set if the structure contains a color space.	 Not set if the structure
+ * contains a single color key.
+ */
+#define DDCKEY_COLORSPACE	0x00000001l
+
+/*
+ * Set if the structure specifies a color key or color space which is to be
+ * used as a destination color key for blt operations.
+ */
+#define DDCKEY_DESTBLT		0x00000002l
+
+/*
+ * Set if the structure specifies a color key or color space which is to be
+ * used as a destination color key for overlay operations.
+ */
+#define DDCKEY_DESTOVERLAY	0x00000004l
+
+/*
+ * Set if the structure specifies a color key or color space which is to be
+ * used as a source color key for blt operations.
+ */
+#define DDCKEY_SRCBLT		0x00000008l
+
+/*
+ * Set if the structure specifies a color key or color space which is to be
+ * used as a source color key for overlay operations.
+ */
+#define DDCKEY_SRCOVERLAY	0x00000010l
+
+
+/****************************************************************************
+ *
+ * DIRECTDRAW COLOR KEY CAPABILITY FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * Supports transparent blting using a color key to identify the replaceable
+ * bits of the destination surface for RGB colors.
+ */
+#define DDCKEYCAPS_DESTBLT			0x00000001l
+
+/*
+ * Supports transparent blting using a color space to identify the replaceable
+ * bits of the destination surface for RGB colors.
+ */
+#define DDCKEYCAPS_DESTBLTCLRSPACE		0x00000002l
+
+/*
+ * Supports transparent blting using a color space to identify the replaceable
+ * bits of the destination surface for YUV colors.
+ */
+#define DDCKEYCAPS_DESTBLTCLRSPACEYUV		0x00000004l
+
+/*
+ * Supports transparent blting using a color key to identify the replaceable
+ * bits of the destination surface for YUV colors.
+ */
+#define DDCKEYCAPS_DESTBLTYUV			0x00000008l
+
+/*
+ * Supports overlaying using colorkeying of the replaceable bits of the surface
+ * being overlayed for RGB colors.
+ */
+#define DDCKEYCAPS_DESTOVERLAY			0x00000010l
+
+/*
+ * Supports a color space as the color key for the destination for RGB colors.
+ */
+#define DDCKEYCAPS_DESTOVERLAYCLRSPACE		0x00000020l
+
+/*
+ * Supports a color space as the color key for the destination for YUV colors.
+ */
+#define DDCKEYCAPS_DESTOVERLAYCLRSPACEYUV	0x00000040l
+
+/*
+ * Supports only one active destination color key value for visible overlay
+ * surfaces.
+ */
+#define DDCKEYCAPS_DESTOVERLAYONEACTIVE		0x00000080l
+
+/*
+ * Supports overlaying using colorkeying of the replaceable bits of the
+ * surface being overlayed for YUV colors.
+ */
+#define DDCKEYCAPS_DESTOVERLAYYUV		0x00000100l
+
+/*
+ * Supports transparent blting using the color key for the source with
+ * this surface for RGB colors.
+ */
+#define DDCKEYCAPS_SRCBLT			0x00000200l
+
+/*
+ * Supports transparent blting using a color space for the source with
+ * this surface for RGB colors.
+ */
+#define DDCKEYCAPS_SRCBLTCLRSPACE		0x00000400l
+
+/*
+ * Supports transparent blting using a color space for the source with
+ * this surface for YUV colors.
+ */
+#define DDCKEYCAPS_SRCBLTCLRSPACEYUV		0x00000800l
+
+/*
+ * Supports transparent blting using the color key for the source with
+ * this surface for YUV colors.
+ */
+#define DDCKEYCAPS_SRCBLTYUV			0x00001000l
+
+/*
+ * Supports overlays using the color key for the source with this
+ * overlay surface for RGB colors.
+ */
+#define DDCKEYCAPS_SRCOVERLAY			0x00002000l
+
+/*
+ * Supports overlays using a color space as the source color key for
+ * the overlay surface for RGB colors.
+ */
+#define DDCKEYCAPS_SRCOVERLAYCLRSPACE		0x00004000l
+
+/*
+ * Supports overlays using a color space as the source color key for
+ * the overlay surface for YUV colors.
+ */
+#define DDCKEYCAPS_SRCOVERLAYCLRSPACEYUV	0x00008000l
+
+/*
+ * Supports only one active source color key value for visible
+ * overlay surfaces.
+ */
+#define DDCKEYCAPS_SRCOVERLAYONEACTIVE		0x00010000l
+
+/*
+ * Supports overlays using the color key for the source with this
+ * overlay surface for YUV colors.
+ */
+#define DDCKEYCAPS_SRCOVERLAYYUV		0x00020000l
+
+/*
+ * there are no bandwidth trade-offs for using colorkey with an overlay
+ */
+#define DDCKEYCAPS_NOCOSTOVERLAY		0x00040000l
+
+
+/****************************************************************************
+ *
+ * DIRECTDRAW PIXELFORMAT FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * The surface has alpha channel information in the pixel format.
+ */
+#define DDPF_ALPHAPIXELS			0x00000001l
+
+/*
+ * The pixel format contains alpha only information
+ */
+#define DDPF_ALPHA				0x00000002l
+
+/*
+ * The FourCC code is valid.
+ */
+#define DDPF_FOURCC				0x00000004l
+
+/*
+ * The surface is 4-bit color indexed.
+ */
+#define DDPF_PALETTEINDEXED4			0x00000008l
+
+/*
+ * The surface is indexed into a palette which stores indices
+ * into the destination surface's 8-bit palette.
+ */
+#define DDPF_PALETTEINDEXEDTO8			0x00000010l
+
+/*
+ * The surface is 8-bit color indexed.
+ */
+#define DDPF_PALETTEINDEXED8			0x00000020l
+
+/*
+ * The RGB data in the pixel format structure is valid.
+ */
+#define DDPF_RGB				0x00000040l
+
+/*
+ * The surface will accept pixel data in the format specified
+ * and compress it during the write.
+ */
+#define DDPF_COMPRESSED				0x00000080l
+
+/*
+ * The surface will accept RGB data and translate it during
+ * the write to YUV data.  The format of the data to be written
+ * will be contained in the pixel format structure.  The DDPF_RGB
+ * flag will be set.
+ */
+#define DDPF_RGBTOYUV				0x00000100l
+
+/*
+ * pixel format is YUV - YUV data in pixel format struct is valid
+ */
+#define DDPF_YUV				0x00000200l
+
+/*
+ * pixel format is a z buffer only surface
+ */
+#define DDPF_ZBUFFER				0x00000400l
+
+/*
+ * The surface is 1-bit color indexed.
+ */
+#define DDPF_PALETTEINDEXED1			0x00000800l
+
+/*
+ * The surface is 2-bit color indexed.
+ */
+#define DDPF_PALETTEINDEXED2			0x00001000l
+
+/*
+ * The surface contains Z information in the pixels
+ */
+#define DDPF_ZPIXELS				0x00002000l
+
+/*===========================================================================
+ *
+ *
+ * DIRECTDRAW CALLBACK FLAGS
+ *
+ *
+ *==========================================================================*/
+
+/****************************************************************************
+ *
+ * DIRECTDRAW ENUMSURFACES FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * Enumerate all of the surfaces that meet the search criterion.
+ */
+#define DDENUMSURFACES_ALL			0x00000001l
+
+/*
+ * A search hit is a surface that matches the surface description.
+ */
+#define DDENUMSURFACES_MATCH			0x00000002l
+
+/*
+ * A search hit is a surface that does not match the surface description.
+ */
+#define DDENUMSURFACES_NOMATCH			0x00000004l
+
+/*
+ * Enumerate the first surface that can be created which meets the search criterion.
+ */
+#define DDENUMSURFACES_CANBECREATED		0x00000008l
+
+/*
+ * Enumerate the surfaces that already exist that meet the search criterion.
+ */
+#define DDENUMSURFACES_DOESEXIST		0x00000010l
+
+
+/****************************************************************************
+ *
+ * DIRECTDRAW SETDISPLAYMODE FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * The desired mode is a standard VGA mode
+ */
+#define DDSDM_STANDARDVGAMODE                   0x00000001l
+
+
+
+/****************************************************************************
+ *
+ * DIRECTDRAW ENUMDISPLAYMODES FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * Enumerate Modes with different refresh rates.  EnumDisplayModes guarantees
+ * that a particular mode will be enumerated only once.  This flag specifies whether
+ * the refresh rate is taken into account when determining if a mode is unique.
+ */
+#define DDEDM_REFRESHRATES			0x00000001l
+
+/*
+ * Enumerate VGA modes. Specify this flag if you wish to enumerate supported VGA
+ * modes such as mode 0x13 in addition to the usual ModeX modes (which are always
+ * enumerated if the application has previously called SetCooperativeLevel with the
+ * DDSCL_ALLOWMODEX flag set).
+ */
+#define DDEDM_STANDARDVGAMODES                  0x00000002L
+
+
+/****************************************************************************
+ *
+ * DIRECTDRAW SETCOOPERATIVELEVEL FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * Exclusive mode owner will be responsible for the entire primary surface.
+ * GDI can be ignored. used with DD
+ */
+#define DDSCL_FULLSCREEN			0x00000001l
+
+/*
+ * allow CTRL_ALT_DEL to work while in fullscreen exclusive mode
+ */
+#define DDSCL_ALLOWREBOOT			0x00000002l
+
+/*
+ * prevents DDRAW from modifying the application window.
+ * prevents DDRAW from minimize/restore the application window on activation.
+ */
+#define DDSCL_NOWINDOWCHANGES			0x00000004l
+
+/*
+ * app wants to work as a regular Windows application
+ */
+#define DDSCL_NORMAL				0x00000008l
+
+/*
+ * app wants exclusive access
+ */
+#define DDSCL_EXCLUSIVE                         0x00000010l
+
+
+/*
+ * app can deal with non-windows display modes
+ */
+#define DDSCL_ALLOWMODEX                        0x00000040l
+
+
+/****************************************************************************
+ *
+ * DIRECTDRAW BLT FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * Use the alpha information in the pixel format or the alpha channel surface
+ * attached to the destination surface as the alpha channel for this blt.
+ */
+#define DDBLT_ALPHADEST				0x00000001l
+
+/*
+ * Use the dwConstAlphaDest field in the DDBLTFX structure as the alpha channel
+ * for the destination surface for this blt.
+ */
+#define DDBLT_ALPHADESTCONSTOVERRIDE		0x00000002l
+
+/*
+ * The NEG suffix indicates that the destination surface becomes more
+ * transparent as the alpha value increases. (0 is opaque)
+ */
+#define DDBLT_ALPHADESTNEG			0x00000004l
+
+/*
+ * Use the lpDDSAlphaDest field in the DDBLTFX structure as the alpha
+ * channel for the destination for this blt.
+ */
+#define DDBLT_ALPHADESTSURFACEOVERRIDE		0x00000008l
+
+/*
+ * Use the dwAlphaEdgeBlend field in the DDBLTFX structure as the alpha channel
+ * for the edges of the image that border the color key colors.
+ */
+#define DDBLT_ALPHAEDGEBLEND			0x00000010l
+
+/*
+ * Use the alpha information in the pixel format or the alpha channel surface
+ * attached to the source surface as the alpha channel for this blt.
+ */
+#define DDBLT_ALPHASRC				0x00000020l
+
+/*
+ * Use the dwConstAlphaSrc field in the DDBLTFX structure as the alpha channel
+ * for the source for this blt.
+ */
+#define DDBLT_ALPHASRCCONSTOVERRIDE		0x00000040l
+
+/*
+ * The NEG suffix indicates that the source surface becomes more transparent
+ * as the alpha value increases. (0 is opaque)
+ */
+#define DDBLT_ALPHASRCNEG			0x00000080l
+
+/*
+ * Use the lpDDSAlphaSrc field in the DDBLTFX structure as the alpha channel
+ * for the source for this blt.
+ */
+#define DDBLT_ALPHASRCSURFACEOVERRIDE		0x00000100l
+
+/*
+ * Do this blt asynchronously through the FIFO in the order received.  If
+ * there is no room in the hardware FIFO fail the call.
+ */
+#define DDBLT_ASYNC				0x00000200l
+
+/*
+ * Uses the dwFillColor field in the DDBLTFX structure as the RGB color
+ * to fill the destination rectangle on the destination surface with.
+ */
+#define DDBLT_COLORFILL				0x00000400l
+
+/*
+ * Uses the dwDDFX field in the DDBLTFX structure to specify the effects
+ * to use for the blt.
+ */
+#define DDBLT_DDFX				0x00000800l
+
+/*
+ * Uses the dwDDROPS field in the DDBLTFX structure to specify the ROPS
+ * that are not part of the Win32 API.
+ */
+#define DDBLT_DDROPS				0x00001000l
+
+/*
+ * Use the color key associated with the destination surface.
+ */
+#define DDBLT_KEYDEST				0x00002000l
+
+/*
+ * Use the dckDestColorkey field in the DDBLTFX structure as the color key
+ * for the destination surface.
+ */
+#define DDBLT_KEYDESTOVERRIDE			0x00004000l
+
+/*
+ * Use the color key associated with the source surface.
+ */
+#define DDBLT_KEYSRC				0x00008000l
+
+/*
+ * Use the dckSrcColorkey field in the DDBLTFX structure as the color key
+ * for the source surface.
+ */
+#define DDBLT_KEYSRCOVERRIDE			0x00010000l
+
+/*
+ * Use the dwROP field in the DDBLTFX structure for the raster operation
+ * for this blt.  These ROPs are the same as the ones defined in the Win32 API.
+ */
+#define DDBLT_ROP				0x00020000l
+
+/*
+ * Use the dwRotationAngle field in the DDBLTFX structure as the angle
+ * (specified in 1/100th of a degree) to rotate the surface.
+ */
+#define DDBLT_ROTATIONANGLE			0x00040000l
+
+/*
+ * Z-buffered blt using the z-buffers attached to the source and destination
+ * surfaces and the dwZBufferOpCode field in the DDBLTFX structure as the
+ * z-buffer opcode.
+ */
+#define DDBLT_ZBUFFER				0x00080000l
+
+/*
+ * Z-buffered blt using the dwConstDest Zfield and the dwZBufferOpCode field
+ * in the DDBLTFX structure as the z-buffer and z-buffer opcode respectively
+ * for the destination.
+ */
+#define DDBLT_ZBUFFERDESTCONSTOVERRIDE		0x00100000l
+
+/*
+ * Z-buffered blt using the lpDDSDestZBuffer field and the dwZBufferOpCode
+ * field in the DDBLTFX structure as the z-buffer and z-buffer opcode
+ * respectively for the destination.
+ */
+#define DDBLT_ZBUFFERDESTOVERRIDE		0x00200000l
+
+/*
+ * Z-buffered blt using the dwConstSrcZ field and the dwZBufferOpCode field
+ * in the DDBLTFX structure as the z-buffer and z-buffer opcode respectively
+ * for the source.
+ */
+#define DDBLT_ZBUFFERSRCCONSTOVERRIDE		0x00400000l
+
+/*
+ * Z-buffered blt using the lpDDSSrcZBuffer field and the dwZBufferOpCode
+ * field in the DDBLTFX structure as the z-buffer and z-buffer opcode
+ * respectively for the source.
+ */
+#define DDBLT_ZBUFFERSRCOVERRIDE                0x00800000l
+
+/*
+ * wait until the device is ready to handle the blt
+ * this will cause blt to not return DDERR_WASSTILLDRAWING
+ */
+#define DDBLT_WAIT                              0x01000000l
+
+/*
+ * Uses the dwFillDepth field in the DDBLTFX structure as the depth value
+ * to fill the destination rectangle on the destination Z-buffer surface
+ * with.
+ */
+#define DDBLT_DEPTHFILL				0x02000000l
+
+
+
+/****************************************************************************
+ *
+ * BLTFAST FLAGS
+ *
+ ****************************************************************************/
+
+#define DDBLTFAST_NOCOLORKEY                    0x00000000
+#define DDBLTFAST_SRCCOLORKEY                   0x00000001
+#define DDBLTFAST_DESTCOLORKEY                  0x00000002
+#define DDBLTFAST_WAIT                          0x00000010
+
+/****************************************************************************
+ *
+ * FLIP FLAGS
+ *
+ ****************************************************************************/
+
+#define DDFLIP_WAIT                          0x00000001l
+
+/*
+ * Indicates that the target surface contains the even field of video data.
+ * This flag is only valid with an overlay surface.
+ */
+#define DDFLIP_EVEN                          0x00000002l
+
+/*
+ * Indicates that the target surface contains the odd field of video data.
+ * This flag is only valid with an overlay surface.
+ */
+#define DDFLIP_ODD                           0x00000004l
+
+
+
+/****************************************************************************
+ *
+ * DIRECTDRAW SURFACE OVERLAY FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * Use the alpha information in the pixel format or the alpha channel surface
+ * attached to the destination surface as the alpha channel for the
+ * destination overlay.
+ */
+#define DDOVER_ALPHADEST			0x00000001l
+
+/*
+ * Use the dwConstAlphaDest field in the DDOVERLAYFX structure as the
+ * destination alpha channel for this overlay.
+ */
+#define DDOVER_ALPHADESTCONSTOVERRIDE		0x00000002l
+
+/*
+ * The NEG suffix indicates that the destination surface becomes more
+ * transparent as the alpha value increases.
+ */
+#define DDOVER_ALPHADESTNEG			0x00000004l
+
+/*
+ * Use the lpDDSAlphaDest field in the DDOVERLAYFX structure as the alpha
+ * channel destination for this overlay.
+ */
+#define DDOVER_ALPHADESTSURFACEOVERRIDE		0x00000008l
+
+/*
+ * Use the dwAlphaEdgeBlend field in the DDOVERLAYFX structure as the alpha
+ * channel for the edges of the image that border the color key colors.
+ */
+#define DDOVER_ALPHAEDGEBLEND			0x00000010l
+
+/*
+ * Use the alpha information in the pixel format or the alpha channel surface
+ * attached to the source surface as the source alpha channel for this overlay.
+ */
+#define DDOVER_ALPHASRC				0x00000020l
+
+/*
+ * Use the dwConstAlphaSrc field in the DDOVERLAYFX structure as the source
+ * alpha channel for this overlay.
+ */
+#define DDOVER_ALPHASRCCONSTOVERRIDE		0x00000040l
+
+/*
+ * The NEG suffix indicates that the source surface becomes more transparent
+ * as the alpha value increases.
+ */
+#define DDOVER_ALPHASRCNEG			0x00000080l
+
+/*
+ * Use the lpDDSAlphaSrc field in the DDOVERLAYFX structure as the alpha channel
+ * source for this overlay.
+ */
+#define DDOVER_ALPHASRCSURFACEOVERRIDE		0x00000100l
+
+/*
+ * Turn this overlay off.
+ */
+#define DDOVER_HIDE				0x00000200l
+
+/*
+ * Use the color key associated with the destination surface.
+ */
+#define DDOVER_KEYDEST				0x00000400l
+
+/*
+ * Use the dckDestColorkey field in the DDOVERLAYFX structure as the color key
+ * for the destination surface
+ */
+#define DDOVER_KEYDESTOVERRIDE			0x00000800l
+
+/*
+ * Use the color key associated with the source surface.
+ */
+#define DDOVER_KEYSRC				0x00001000l
+
+/*
+ * Use the dckSrcColorkey field in the DDOVERLAYFX structure as the color key
+ * for the source surface.
+ */
+#define DDOVER_KEYSRCOVERRIDE			0x00002000l
+
+/*
+ * Turn this overlay on.
+ */
+#define DDOVER_SHOW				0x00004000l
+
+/*
+ * Add a dirty rect to an emulated overlayed surface.
+ */
+#define DDOVER_ADDDIRTYRECT                     0x00008000l
+
+/*
+ * Redraw all dirty rects on an emulated overlayed surface.
+ */
+#define DDOVER_REFRESHDIRTYRECTS		0x00010000l
+
+/*
+ * Redraw the entire surface on an emulated overlayed surface.
+ */
+#define DDOVER_REFRESHALL                      0x00020000l
+
+
+/*
+ * Use the overlay FX flags to define special overlay FX
+ */
+#define DDOVER_DDFX                       	0x00080000l
+
+/*
+ * Autoflip the overlay when ever the video port autoflips
+ */
+#define DDOVER_AUTOFLIP                       	0x00100000l
+
+/*
+ * Display each field of video port data individually without
+ * causing any jittery artifacts
+ */
+#define DDOVER_BOB                       	0x00200000l
+
+/*
+ * Indicates that bob/weave decisions should not be overridden by other
+ * interfaces.
+ */
+#define DDOVER_OVERRIDEBOBWEAVE			0x00400000l
+
+/*
+ * Indicates that the surface memory is composed of interleaved fields.
+ */
+#define DDOVER_INTERLEAVED			0x00800000l
+
+
+/****************************************************************************
+ *
+ * DIRECTDRAWSURFACE LOCK FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * The default.	 Set to indicate that Lock should return a valid memory pointer
+ * to the top of the specified rectangle.  If no rectangle is specified then a
+ * pointer to the top of the surface is returned.
+ */
+#define DDLOCK_SURFACEMEMORYPTR			0x00000000L	// default
+
+/*
+ * Set to indicate that Lock should wait until it can obtain a valid memory
+ * pointer before returning.  If this bit is set, Lock will never return
+ * DDERR_WASSTILLDRAWING.
+ */
+#define DDLOCK_WAIT				0x00000001L
+
+/*
+ * Set if an event handle is being passed to Lock.  Lock will trigger the event
+ * when it can return the surface memory pointer requested.
+ */
+#define DDLOCK_EVENT				0x00000002L
+
+/*
+ * Indicates that the surface being locked will only be read from.
+ */
+#define DDLOCK_READONLY				0x00000010L
+
+/*
+ * Indicates that the surface being locked will only be written to
+ */
+#define DDLOCK_WRITEONLY			0x00000020L
+
+
+/*
+ * Indicates that a system wide lock should not be taken when this surface
+ * is locked. This has several advantages (cursor responsiveness, ability
+ * to call more Windows functions, easier debugging) when locking video
+ * memory surfaces. However, an application specifying this flag must
+ * comply with a number of conditions documented in the help file.
+ * Furthermore, this flag cannot be specified when locking the primary.
+ */
+#define DDLOCK_NOSYSLOCK                        0x00000800L
+
+
+/****************************************************************************
+ *
+ * DIRECTDRAWSURFACE PAGELOCK FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * No flags defined at present
+ */
+
+
+/****************************************************************************
+ *
+ * DIRECTDRAWSURFACE PAGEUNLOCK FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * No flags defined at present
+ */
+
+
+/****************************************************************************
+ *
+ * DIRECTDRAWSURFACE BLT FX FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * If stretching, use arithmetic stretching along the Y axis for this blt.
+ */
+#define DDBLTFX_ARITHSTRETCHY			0x00000001l
+
+/*
+ * Do this blt mirroring the surface left to right.  Spin the
+ * surface around its y-axis.
+ */
+#define DDBLTFX_MIRRORLEFTRIGHT			0x00000002l
+
+/*
+ * Do this blt mirroring the surface up and down.  Spin the surface
+ * around its x-axis.
+ */
+#define DDBLTFX_MIRRORUPDOWN			0x00000004l
+
+/*
+ * Schedule this blt to avoid tearing.
+ */
+#define DDBLTFX_NOTEARING			0x00000008l
+
+/*
+ * Do this blt rotating the surface one hundred and eighty degrees.
+ */
+#define DDBLTFX_ROTATE180			0x00000010l
+
+/*
+ * Do this blt rotating the surface two hundred and seventy degrees.
+ */
+#define DDBLTFX_ROTATE270			0x00000020l
+
+/*
+ * Do this blt rotating the surface ninety degrees.
+ */
+#define DDBLTFX_ROTATE90			0x00000040l
+
+/*
+ * Do this z blt using dwZBufferLow and dwZBufferHigh as  range values
+ * specified to limit the bits copied from the source surface.
+ */
+#define DDBLTFX_ZBUFFERRANGE			0x00000080l
+
+/*
+ * Do this z blt adding the dwZBufferBaseDest to each of the sources z values
+ * before comparing it with the desting z values.
+ */
+#define DDBLTFX_ZBUFFERBASEDEST			0x00000100l
+
+/****************************************************************************
+ *
+ * DIRECTDRAWSURFACE OVERLAY FX FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * If stretching, use arithmetic stretching along the Y axis for this overlay.
+ */
+#define DDOVERFX_ARITHSTRETCHY			0x00000001l
+
+/*
+ * Mirror the overlay across the vertical axis
+ */
+#define DDOVERFX_MIRRORLEFTRIGHT		0x00000002l
+
+/*
+ * Mirror the overlay across the horizontal axis
+ */
+#define DDOVERFX_MIRRORUPDOWN			0x00000004l
+
+/****************************************************************************
+ *
+ * DIRECTDRAW WAITFORVERTICALBLANK FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * return when the vertical blank interval begins
+ */
+#define DDWAITVB_BLOCKBEGIN			0x00000001l
+
+/*
+ * set up an event to trigger when the vertical blank begins
+ */
+#define DDWAITVB_BLOCKBEGINEVENT		0x00000002l
+
+/*
+ * return when the vertical blank interval ends and display begins
+ */
+#define DDWAITVB_BLOCKEND			0x00000004l
+
+/****************************************************************************
+ *
+ * DIRECTDRAW GETFLIPSTATUS FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * is it OK to flip now?
+ */
+#define DDGFS_CANFLIP			0x00000001l
+
+/*
+ * is the last flip finished?
+ */
+#define DDGFS_ISFLIPDONE		0x00000002l
+
+/****************************************************************************
+ *
+ * DIRECTDRAW GETBLTSTATUS FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * is it OK to blt now?
+ */
+#define DDGBS_CANBLT			0x00000001l
+
+/*
+ * is the blt to the surface finished?
+ */
+#define DDGBS_ISBLTDONE			0x00000002l
+
+
+/****************************************************************************
+ *
+ * DIRECTDRAW ENUMOVERLAYZORDER FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * Enumerate overlays back to front.
+ */
+#define DDENUMOVERLAYZ_BACKTOFRONT	0x00000000l
+
+/*
+ * Enumerate overlays front to back
+ */
+#define DDENUMOVERLAYZ_FRONTTOBACK	0x00000001l
+
+/****************************************************************************
+ *
+ * DIRECTDRAW UPDATEOVERLAYZORDER FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * Send overlay to front
+ */
+#define DDOVERZ_SENDTOFRONT		0x00000000l
+
+/*
+ * Send overlay to back
+ */
+#define DDOVERZ_SENDTOBACK		0x00000001l
+
+/*
+ * Move Overlay forward
+ */
+#define DDOVERZ_MOVEFORWARD		0x00000002l
+
+/*
+ * Move Overlay backward
+ */
+#define DDOVERZ_MOVEBACKWARD		0x00000003l
+
+/*
+ * Move Overlay in front of relative surface
+ */
+#define DDOVERZ_INSERTINFRONTOF		0x00000004l
+
+/*
+ * Move Overlay in back of relative surface
+ */
+#define DDOVERZ_INSERTINBACKOF		0x00000005l
+
+/*===========================================================================
+ *
+ *
+ * DIRECTDRAW RETURN CODES
+ *
+ * The return values from DirectDraw Commands and Surface that return an HRESULT
+ * are codes from DirectDraw concerning the results of the action
+ * requested by DirectDraw.
+ *
+ *==========================================================================*/
+
+/*
+ * Status is OK
+ *
+ * Issued by: DirectDraw Commands and all callbacks
+ */
+#define DD_OK					0
+
+/****************************************************************************
+ *
+ * DIRECTDRAW ENUMCALLBACK RETURN VALUES
+ *
+ * EnumCallback returns are used to control the flow of the DIRECTDRAW and
+ * DIRECTDRAWSURFACE object enumerations.   They can only be returned by
+ * enumeration callback routines.
+ *
+ ****************************************************************************/
+
+/*
+ * stop the enumeration
+ */
+#define DDENUMRET_CANCEL			0
+
+/*
+ * continue the enumeration
+ */
+#define DDENUMRET_OK				1
+
+/****************************************************************************
+ *
+ * DIRECTDRAW ERRORS
+ *
+ * Errors are represented by negative values and cannot be combined.
+ *
+ ****************************************************************************/
+
+/*
+ * This object is already initialized
+ */
+#define DDERR_ALREADYINITIALIZED		MAKE_DDHRESULT( 5 )
+
+/*
+ * This surface can not be attached to the requested surface.
+ */
+#define DDERR_CANNOTATTACHSURFACE		MAKE_DDHRESULT( 10 )
+
+/*
+ * This surface can not be detached from the requested surface.
+ */
+#define DDERR_CANNOTDETACHSURFACE		MAKE_DDHRESULT( 20 )
+
+/*
+ * Support is currently not available.
+ */
+#define DDERR_CURRENTLYNOTAVAIL			MAKE_DDHRESULT( 40 )
+
+/*
+ * An exception was encountered while performing the requested operation
+ */
+#define DDERR_EXCEPTION				MAKE_DDHRESULT( 55 )
+
+/*
+ * Generic failure.
+ */
+#define DDERR_GENERIC				E_FAIL
+
+/*
+ * Height of rectangle provided is not a multiple of reqd alignment
+ */
+#define DDERR_HEIGHTALIGN			MAKE_DDHRESULT( 90 )
+
+/*
+ * Unable to match primary surface creation request with existing
+ * primary surface.
+ */
+#define DDERR_INCOMPATIBLEPRIMARY		MAKE_DDHRESULT( 95 )
+
+/*
+ * One or more of the caps bits passed to the callback are incorrect.
+ */
+#define DDERR_INVALIDCAPS			MAKE_DDHRESULT( 100 )
+
+/*
+ * DirectDraw does not support provided Cliplist.
+ */
+#define DDERR_INVALIDCLIPLIST			MAKE_DDHRESULT( 110 )
+
+/*
+ * DirectDraw does not support the requested mode
+ */
+#define DDERR_INVALIDMODE			MAKE_DDHRESULT( 120 )
+
+/*
+ * DirectDraw received a pointer that was an invalid DIRECTDRAW object.
+ */
+#define DDERR_INVALIDOBJECT			MAKE_DDHRESULT( 130 )
+
+/*
+ * One or more of the parameters passed to the callback function are
+ * incorrect.
+ */
+#define DDERR_INVALIDPARAMS			E_INVALIDARG
+
+/*
+ * pixel format was invalid as specified
+ */
+#define DDERR_INVALIDPIXELFORMAT		MAKE_DDHRESULT( 145 )
+
+/*
+ * Rectangle provided was invalid.
+ */
+#define DDERR_INVALIDRECT			MAKE_DDHRESULT( 150 )
+
+/*
+ * Operation could not be carried out because one or more surfaces are locked
+ */
+#define DDERR_LOCKEDSURFACES			MAKE_DDHRESULT( 160 )
+
+/*
+ * There is no 3D present.
+ */
+#define DDERR_NO3D				MAKE_DDHRESULT( 170 )
+
+/*
+ * Operation could not be carried out because there is no alpha accleration
+ * hardware present or available.
+ */
+#define DDERR_NOALPHAHW				MAKE_DDHRESULT( 180 )
+
+
+/*
+ * no clip list available
+ */
+#define DDERR_NOCLIPLIST			MAKE_DDHRESULT( 205 )
+
+/*
+ * Operation could not be carried out because there is no color conversion
+ * hardware present or available.
+ */
+#define DDERR_NOCOLORCONVHW			MAKE_DDHRESULT( 210 )
+
+/*
+ * Create function called without DirectDraw object method SetCooperativeLevel
+ * being called.
+ */
+#define DDERR_NOCOOPERATIVELEVELSET		MAKE_DDHRESULT( 212 )
+
+/*
+ * Surface doesn't currently have a color key
+ */
+#define DDERR_NOCOLORKEY			MAKE_DDHRESULT( 215 )
+
+/*
+ * Operation could not be carried out because there is no hardware support
+ * of the dest color key.
+ */
+#define DDERR_NOCOLORKEYHW			MAKE_DDHRESULT( 220 )
+
+/*
+ * No DirectDraw support possible with current display driver
+ */
+#define DDERR_NODIRECTDRAWSUPPORT		MAKE_DDHRESULT( 222 )
+
+/*
+ * Operation requires the application to have exclusive mode but the
+ * application does not have exclusive mode.
+ */
+#define DDERR_NOEXCLUSIVEMODE			MAKE_DDHRESULT( 225 )
+
+/*
+ * Flipping visible surfaces is not supported.
+ */
+#define DDERR_NOFLIPHW				MAKE_DDHRESULT( 230 )
+
+/*
+ * There is no GDI present.
+ */
+#define DDERR_NOGDI				MAKE_DDHRESULT( 240 )
+
+/*
+ * Operation could not be carried out because there is no hardware present
+ * or available.
+ */
+#define DDERR_NOMIRRORHW			MAKE_DDHRESULT( 250 )
+
+/*
+ * Requested item was not found
+ */
+#define DDERR_NOTFOUND				MAKE_DDHRESULT( 255 )
+
+/*
+ * Operation could not be carried out because there is no overlay hardware
+ * present or available.
+ */
+#define DDERR_NOOVERLAYHW			MAKE_DDHRESULT( 260 )
+
+/*
+ * Operation could not be carried out because there is no appropriate raster
+ * op hardware present or available.
+ */
+#define DDERR_NORASTEROPHW			MAKE_DDHRESULT( 280 )
+
+/*
+ * Operation could not be carried out because there is no rotation hardware
+ * present or available.
+ */
+#define DDERR_NOROTATIONHW			MAKE_DDHRESULT( 290 )
+
+/*
+ * Operation could not be carried out because there is no hardware support
+ * for stretching
+ */
+#define DDERR_NOSTRETCHHW			MAKE_DDHRESULT( 310 )
+
+/*
+ * DirectDrawSurface is not in 4 bit color palette and the requested operation
+ * requires 4 bit color palette.
+ */
+#define DDERR_NOT4BITCOLOR			MAKE_DDHRESULT( 316 )
+
+/*
+ * DirectDrawSurface is not in 4 bit color index palette and the requested
+ * operation requires 4 bit color index palette.
+ */
+#define DDERR_NOT4BITCOLORINDEX			MAKE_DDHRESULT( 317 )
+
+/*
+ * DirectDraw Surface is not in 8 bit color mode and the requested operation
+ * requires 8 bit color.
+ */
+#define DDERR_NOT8BITCOLOR			MAKE_DDHRESULT( 320 )
+
+/*
+ * Operation could not be carried out because there is no texture mapping
+ * hardware present or available.
+ */
+#define DDERR_NOTEXTUREHW			MAKE_DDHRESULT( 330 )
+
+/*
+ * Operation could not be carried out because there is no hardware support
+ * for vertical blank synchronized operations.
+ */
+#define DDERR_NOVSYNCHW				MAKE_DDHRESULT( 335 )
+
+/*
+ * Operation could not be carried out because there is no hardware support
+ * for zbuffer blting.
+ */
+#define DDERR_NOZBUFFERHW			MAKE_DDHRESULT( 340 )
+
+/*
+ * Overlay surfaces could not be z layered based on their BltOrder because
+ * the hardware does not support z layering of overlays.
+ */
+#define DDERR_NOZOVERLAYHW			MAKE_DDHRESULT( 350 )
+
+/*
+ * The hardware needed for the requested operation has already been
+ * allocated.
+ */
+#define DDERR_OUTOFCAPS				MAKE_DDHRESULT( 360 )
+
+/*
+ * DirectDraw does not have enough memory to perform the operation.
+ */
+#define DDERR_OUTOFMEMORY			E_OUTOFMEMORY
+
+/*
+ * DirectDraw does not have enough memory to perform the operation.
+ */
+#define DDERR_OUTOFVIDEOMEMORY			MAKE_DDHRESULT( 380 )
+
+/*
+ * hardware does not support clipped overlays
+ */
+#define DDERR_OVERLAYCANTCLIP			MAKE_DDHRESULT( 382 )
+
+/*
+ * Can only have ony color key active at one time for overlays
+ */
+#define DDERR_OVERLAYCOLORKEYONLYONEACTIVE	MAKE_DDHRESULT( 384 )
+
+/*
+ * Access to this palette is being refused because the palette is already
+ * locked by another thread.
+ */
+#define DDERR_PALETTEBUSY			MAKE_DDHRESULT( 387 )
+
+/*
+ * No src color key specified for this operation.
+ */
+#define DDERR_COLORKEYNOTSET			MAKE_DDHRESULT( 400 )
+
+/*
+ * This surface is already attached to the surface it is being attached to.
+ */
+#define DDERR_SURFACEALREADYATTACHED		MAKE_DDHRESULT( 410 )
+
+/*
+ * This surface is already a dependency of the surface it is being made a
+ * dependency of.
+ */
+#define DDERR_SURFACEALREADYDEPENDENT		MAKE_DDHRESULT( 420 )
+
+/*
+ * Access to this surface is being refused because the surface is already
+ * locked by another thread.
+ */
+#define DDERR_SURFACEBUSY			MAKE_DDHRESULT( 430 )
+
+/*
+ * Access to this surface is being refused because no driver exists
+ * which can supply a pointer to the surface.
+ * This is most likely to happen when attempting to lock the primary
+ * surface when no DCI provider is present.
+ * Will also happen on attempts to lock an optimized surface.
+ */
+#define DDERR_CANTLOCKSURFACE                   MAKE_DDHRESULT( 435 )
+
+/*
+ * Access to Surface refused because Surface is obscured.
+ */
+#define DDERR_SURFACEISOBSCURED			MAKE_DDHRESULT( 440 )
+
+/*
+ * Access to this surface is being refused because the surface is gone.
+ * The DIRECTDRAWSURFACE object representing this surface should
+ * have Restore called on it.
+ */
+#define DDERR_SURFACELOST			MAKE_DDHRESULT( 450 )
+
+/*
+ * The requested surface is not attached.
+ */
+#define DDERR_SURFACENOTATTACHED		MAKE_DDHRESULT( 460 )
+
+/*
+ * Height requested by DirectDraw is too large.
+ */
+#define DDERR_TOOBIGHEIGHT			MAKE_DDHRESULT( 470 )
+
+/*
+ * Size requested by DirectDraw is too large --	 The individual height and
+ * width are OK.
+ */
+#define DDERR_TOOBIGSIZE			MAKE_DDHRESULT( 480 )
+
+/*
+ * Width requested by DirectDraw is too large.
+ */
+#define DDERR_TOOBIGWIDTH			MAKE_DDHRESULT( 490 )
+
+/*
+ * Action not supported.
+ */
+#define DDERR_UNSUPPORTED			E_NOTIMPL
+
+/*
+ * FOURCC format requested is unsupported by DirectDraw
+ */
+#define DDERR_UNSUPPORTEDFORMAT			MAKE_DDHRESULT( 510 )
+
+/*
+ * Bitmask in the pixel format requested is unsupported by DirectDraw
+ */
+#define DDERR_UNSUPPORTEDMASK			MAKE_DDHRESULT( 520 )
+
+/*
+ * vertical blank is in progress
+ */
+#define DDERR_VERTICALBLANKINPROGRESS		MAKE_DDHRESULT( 537 )
+
+/*
+ * Informs DirectDraw that the previous Blt which is transfering information
+ * to or from this Surface is incomplete.
+ */
+#define DDERR_WASSTILLDRAWING			MAKE_DDHRESULT( 540 )
+
+
+/*
+ * Rectangle provided was not horizontally aligned on reqd. boundary
+ */
+#define DDERR_XALIGN				MAKE_DDHRESULT( 560 )
+
+/*
+ * The GUID passed to DirectDrawCreate is not a valid DirectDraw driver
+ * identifier.
+ */
+#define DDERR_INVALIDDIRECTDRAWGUID		MAKE_DDHRESULT( 561 )
+
+/*
+ * A DirectDraw object representing this driver has already been created
+ * for this process.
+ */
+#define DDERR_DIRECTDRAWALREADYCREATED		MAKE_DDHRESULT( 562 )
+
+/*
+ * A hardware only DirectDraw object creation was attempted but the driver
+ * did not support any hardware.
+ */
+#define DDERR_NODIRECTDRAWHW			MAKE_DDHRESULT( 563 )
+
+/*
+ * this process already has created a primary surface
+ */
+#define DDERR_PRIMARYSURFACEALREADYEXISTS	MAKE_DDHRESULT( 564 )
+
+/*
+ * software emulation not available.
+ */
+#define DDERR_NOEMULATION			MAKE_DDHRESULT( 565 )
+
+/*
+ * region passed to Clipper::GetClipList is too small.
+ */
+#define DDERR_REGIONTOOSMALL			MAKE_DDHRESULT( 566 )
+
+/*
+ * an attempt was made to set a clip list for a clipper objec that
+ * is already monitoring an hwnd.
+ */
+#define DDERR_CLIPPERISUSINGHWND		MAKE_DDHRESULT( 567 )
+
+/*
+ * No clipper object attached to surface object
+ */
+#define DDERR_NOCLIPPERATTACHED			MAKE_DDHRESULT( 568 )
+
+/*
+ * Clipper notification requires an HWND or
+ * no HWND has previously been set as the CooperativeLevel HWND.
+ */
+#define DDERR_NOHWND				MAKE_DDHRESULT( 569 )
+
+/*
+ * HWND used by DirectDraw CooperativeLevel has been subclassed,
+ * this prevents DirectDraw from restoring state.
+ */
+#define DDERR_HWNDSUBCLASSED			MAKE_DDHRESULT( 570 )
+
+/*
+ * The CooperativeLevel HWND has already been set.
+ * It can not be reset while the process has surfaces or palettes created.
+ */
+#define DDERR_HWNDALREADYSET			MAKE_DDHRESULT( 571 )
+
+/*
+ * No palette object attached to this surface.
+ */
+#define DDERR_NOPALETTEATTACHED			MAKE_DDHRESULT( 572 )
+
+/*
+ * No hardware support for 16 or 256 color palettes.
+ */
+#define DDERR_NOPALETTEHW			MAKE_DDHRESULT( 573 )
+
+/*
+ * If a clipper object is attached to the source surface passed into a
+ * BltFast call.
+ */
+#define DDERR_BLTFASTCANTCLIP			MAKE_DDHRESULT( 574 )
+
+/*
+ * No blter.
+ */
+#define DDERR_NOBLTHW				MAKE_DDHRESULT( 575 )
+
+/*
+ * No DirectDraw ROP hardware.
+ */
+#define DDERR_NODDROPSHW			MAKE_DDHRESULT( 576 )
+
+/*
+ * returned when GetOverlayPosition is called on a hidden overlay
+ */
+#define DDERR_OVERLAYNOTVISIBLE			MAKE_DDHRESULT( 577 )
+
+/*
+ * returned when GetOverlayPosition is called on a overlay that UpdateOverlay
+ * has never been called on to establish a destionation.
+ */
+#define DDERR_NOOVERLAYDEST			MAKE_DDHRESULT( 578 )
+
+/*
+ * returned when the position of the overlay on the destionation is no longer
+ * legal for that destionation.
+ */
+#define DDERR_INVALIDPOSITION			MAKE_DDHRESULT( 579 )
+
+/*
+ * returned when an overlay member is called for a non-overlay surface
+ */
+#define DDERR_NOTAOVERLAYSURFACE		MAKE_DDHRESULT( 580 )
+
+/*
+ * An attempt was made to set the cooperative level when it was already
+ * set to exclusive.
+ */
+#define DDERR_EXCLUSIVEMODEALREADYSET		MAKE_DDHRESULT( 581 )
+
+/*
+ * An attempt has been made to flip a surface that is not flippable.
+ */
+#define DDERR_NOTFLIPPABLE			MAKE_DDHRESULT( 582 )
+
+/*
+ * Can't duplicate primary & 3D surfaces, or surfaces that are implicitly
+ * created.
+ */
+#define DDERR_CANTDUPLICATE			MAKE_DDHRESULT( 583 )
+
+/*
+ * Surface was not locked.  An attempt to unlock a surface that was not
+ * locked at all, or by this process, has been attempted.
+ */
+#define DDERR_NOTLOCKED				MAKE_DDHRESULT( 584 )
+
+/*
+ * Windows can not create any more DCs
+ */
+#define DDERR_CANTCREATEDC			MAKE_DDHRESULT( 585 )
+
+/*
+ * No DC was ever created for this surface.
+ */
+#define DDERR_NODC				MAKE_DDHRESULT( 586 )
+
+/*
+ * This surface can not be restored because it was created in a different
+ * mode.
+ */
+#define DDERR_WRONGMODE				MAKE_DDHRESULT( 587 )
+
+/*
+ * This surface can not be restored because it is an implicitly created
+ * surface.
+ */
+#define DDERR_IMPLICITLYCREATED			MAKE_DDHRESULT( 588 )
+
+/*
+ * The surface being used is not a palette-based surface
+ */
+#define DDERR_NOTPALETTIZED			MAKE_DDHRESULT( 589 )
+
+
+/*
+ * The display is currently in an unsupported mode
+ */
+#define DDERR_UNSUPPORTEDMODE			MAKE_DDHRESULT( 590 )
+
+/*
+ * Operation could not be carried out because there is no mip-map
+ * texture mapping hardware present or available.
+ */
+#define DDERR_NOMIPMAPHW			MAKE_DDHRESULT( 591 )
+
+/*
+ * The requested action could not be performed because the surface was of
+ * the wrong type.
+ */
+#define DDERR_INVALIDSURFACETYPE                MAKE_DDHRESULT( 592 )
+
+
+
+/*
+ * Device does not support optimized surfaces, therefore no video memory optimized surfaces
+ */
+#define DDERR_NOOPTIMIZEHW                      MAKE_DDHRESULT( 600 )
+
+/*
+ * Surface is an optimized surface, but has not yet been allocated any memory
+ */
+#define DDERR_NOTLOADED                         MAKE_DDHRESULT( 601 )
+
+/*
+ * A DC has already been returned for this surface. Only one DC can be
+ * retrieved per surface.
+ */
+#define DDERR_DCALREADYCREATED			MAKE_DDHRESULT( 620 )
+
+/*
+ * An attempt was made to allocate non-local video memory from a device
+ * that does not support non-local video memory.
+ */
+#define DDERR_NONONLOCALVIDMEM                  MAKE_DDHRESULT( 630 )
+
+/*
+ * The attempt to page lock a surface failed.
+ */
+#define DDERR_CANTPAGELOCK			MAKE_DDHRESULT( 640 )
+
+/*
+ * The attempt to page unlock a surface failed.
+ */
+#define DDERR_CANTPAGEUNLOCK			MAKE_DDHRESULT( 660 )
+
+/*
+ * An attempt was made to page unlock a surface with no outstanding page locks.
+ */
+#define DDERR_NOTPAGELOCKED			MAKE_DDHRESULT( 680 )
+
+/*
+ * There is more data available than the specified buffer size could hold
+ */
+#define DDERR_MOREDATA         			MAKE_DDHRESULT( 690 )
+
+/*
+ * The video port is not active
+ */
+#define DDERR_VIDEONOTACTIVE   			MAKE_DDHRESULT( 695 )
+
+/*
+ * Surfaces created by one direct draw device cannot be used directly by
+ * another direct draw device.
+ */
+#define DDERR_DEVICEDOESNTOWNSURFACE   		MAKE_DDHRESULT( 699 )
+
+
+/*
+ * An attempt was made to invoke an interface member of a DirectDraw object
+ * created by CoCreateInstance() before it was initialized.
+ */
+#define DDERR_NOTINITIALIZED                    CO_E_NOTINITIALIZED
+
+/* Alpha bit depth constants */
+
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif
diff --git a/3rdparty/dx5/inc/dinput.h b/3rdparty/dx5/inc/dinput.h
new file mode 100644
index 00000000..5bf9f5ae
--- /dev/null
+++ b/3rdparty/dx5/inc/dinput.h
@@ -0,0 +1,1849 @@
+/****************************************************************************
+ *
+ *  Copyright (C) 1996-1997 Microsoft Corporation.  All Rights Reserved.
+ *
+ *  File:       dinput.h
+ *  Content:    DirectInput include file
+ *
+ ****************************************************************************/
+
+#ifndef __DINPUT_INCLUDED__
+#define __DINPUT_INCLUDED__
+
+#ifndef DIJ_RINGZERO
+
+#ifdef _WIN32
+#define COM_NO_WINDOWS_H
+#include <objbase.h>
+#endif
+
+#endif /* DIJ_RINGZERO */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef DIRECTINPUT_VERSION
+#define DIRECTINPUT_VERSION         0x0500
+#endif
+
+#ifndef DIJ_RINGZERO
+/****************************************************************************
+ *
+ *      Class IDs
+ *
+ ****************************************************************************/
+
+DEFINE_GUID(CLSID_DirectInput,      0x25E609E0,0xB259,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+DEFINE_GUID(CLSID_DirectInputDevice,0x25E609E1,0xB259,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+
+/****************************************************************************
+ *
+ *      Interfaces
+ *
+ ****************************************************************************/
+
+DEFINE_GUID(IID_IDirectInputA,     0x89521360,0xAA8A,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+DEFINE_GUID(IID_IDirectInputW,     0x89521361,0xAA8A,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+DEFINE_GUID(IID_IDirectInput2A,    0x5944E662,0xAA8A,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+DEFINE_GUID(IID_IDirectInput2W,    0x5944E663,0xAA8A,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+
+DEFINE_GUID(IID_IDirectInputDeviceA, 0x5944E680,0xC92E,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+DEFINE_GUID(IID_IDirectInputDeviceW, 0x5944E681,0xC92E,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+DEFINE_GUID(IID_IDirectInputDevice2A,0x5944E682,0xC92E,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+DEFINE_GUID(IID_IDirectInputDevice2W,0x5944E683,0xC92E,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+
+DEFINE_GUID(IID_IDirectInputEffect,  0xE7E1F7C0,0x88D2,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35);
+
+/****************************************************************************
+ *
+ *      Predefined object types
+ *
+ ****************************************************************************/
+
+DEFINE_GUID(GUID_XAxis,   0xA36D02E0,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+DEFINE_GUID(GUID_YAxis,   0xA36D02E1,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+DEFINE_GUID(GUID_ZAxis,   0xA36D02E2,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+DEFINE_GUID(GUID_RxAxis,  0xA36D02F4,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+DEFINE_GUID(GUID_RyAxis,  0xA36D02F5,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+DEFINE_GUID(GUID_RzAxis,  0xA36D02E3,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+DEFINE_GUID(GUID_Slider,  0xA36D02E4,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+
+DEFINE_GUID(GUID_Button,  0xA36D02F0,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+DEFINE_GUID(GUID_Key,     0x55728220,0xD33C,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+
+DEFINE_GUID(GUID_POV,     0xA36D02F2,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+
+DEFINE_GUID(GUID_Unknown, 0xA36D02F3,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+
+/****************************************************************************
+ *
+ *      Predefined product GUIDs
+ *
+ ****************************************************************************/
+
+DEFINE_GUID(GUID_SysMouse,   0x6F1D2B60,0xD5A0,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+DEFINE_GUID(GUID_SysKeyboard,0x6F1D2B61,0xD5A0,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+DEFINE_GUID(GUID_Joystick   ,0x6F1D2B70,0xD5A0,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+
+/****************************************************************************
+ *
+ *      Predefined force feedback effects
+ *
+ ****************************************************************************/
+
+DEFINE_GUID(GUID_ConstantForce,0x13541C20,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35);
+DEFINE_GUID(GUID_RampForce,    0x13541C21,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35);
+DEFINE_GUID(GUID_Square,       0x13541C22,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35);
+DEFINE_GUID(GUID_Sine,         0x13541C23,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35);
+DEFINE_GUID(GUID_Triangle,     0x13541C24,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35);
+DEFINE_GUID(GUID_SawtoothUp,   0x13541C25,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35);
+DEFINE_GUID(GUID_SawtoothDown, 0x13541C26,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35);
+DEFINE_GUID(GUID_Spring,       0x13541C27,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35);
+DEFINE_GUID(GUID_Damper,       0x13541C28,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35);
+DEFINE_GUID(GUID_Inertia,      0x13541C29,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35);
+DEFINE_GUID(GUID_Friction,     0x13541C2A,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35);
+DEFINE_GUID(GUID_CustomForce,  0x13541C2B,0x8E33,0x11D0,0x9A,0xD0,0x00,0xA0,0xC9,0xA0,0x6E,0x35);
+
+
+#endif /* DIJ_RINGZERO */
+
+/****************************************************************************
+ *
+ *      Interfaces and Structures...
+ *
+ ****************************************************************************/
+
+#if(DIRECTINPUT_VERSION >= 0x0500)
+
+/****************************************************************************
+ *
+ *      IDirectInputEffect
+ *
+ ****************************************************************************/
+
+#define DIEFT_ALL                   0x00000000
+
+#define DIEFT_CONSTANTFORCE         0x00000001
+#define DIEFT_RAMPFORCE             0x00000002
+#define DIEFT_PERIODIC              0x00000003
+#define DIEFT_CONDITION             0x00000004
+#define DIEFT_CUSTOMFORCE           0x00000005
+#define DIEFT_HARDWARE              0x000000FF
+
+#define DIEFT_FFATTACK              0x00000200
+#define DIEFT_FFFADE                0x00000400
+#define DIEFT_SATURATION            0x00000800
+#define DIEFT_POSNEGCOEFFICIENTS    0x00001000
+#define DIEFT_POSNEGSATURATION      0x00002000
+#define DIEFT_DEADBAND              0x00004000
+
+#define DIEFT_GETTYPE(n)            LOBYTE(n)
+
+#define DI_DEGREES                  100
+#define DI_FFNOMINALMAX             10000
+#define DI_SECONDS                  1000000
+
+typedef struct DICONSTANTFORCE {
+    LONG  lMagnitude;
+} DICONSTANTFORCE, *LPDICONSTANTFORCE;
+typedef const DICONSTANTFORCE *LPCDICONSTANTFORCE;
+
+typedef struct DIRAMPFORCE {
+    LONG  lStart;
+    LONG  lEnd;
+} DIRAMPFORCE, *LPDIRAMPFORCE;
+typedef const DIRAMPFORCE *LPCDIRAMPFORCE;
+
+typedef struct DIPERIODIC {
+    DWORD dwMagnitude;
+    LONG  lOffset;
+    DWORD dwPhase;
+    DWORD dwPeriod;
+} DIPERIODIC, *LPDIPERIODIC;
+typedef const DIPERIODIC *LPCDIPERIODIC;
+
+typedef struct DICONDITION {
+    LONG  lOffset;
+    LONG  lPositiveCoefficient;
+    LONG  lNegativeCoefficient;
+    DWORD dwPositiveSaturation;
+    DWORD dwNegativeSaturation;
+    LONG  lDeadBand;
+} DICONDITION, *LPDICONDITION;
+typedef const DICONDITION *LPCDICONDITION;
+
+typedef struct DICUSTOMFORCE {
+    DWORD cChannels;
+    DWORD dwSamplePeriod;
+    DWORD cSamples;
+    LPLONG rglForceData;
+} DICUSTOMFORCE, *LPDICUSTOMFORCE;
+typedef const DICUSTOMFORCE *LPCDICUSTOMFORCE;
+
+typedef struct DIENVELOPE {
+    DWORD dwSize;                   /* sizeof(DIENVELOPE)   */
+    DWORD dwAttackLevel;
+    DWORD dwAttackTime;             /* Microseconds         */
+    DWORD dwFadeLevel;
+    DWORD dwFadeTime;               /* Microseconds         */
+} DIENVELOPE, *LPDIENVELOPE;
+typedef const DIENVELOPE *LPCDIENVELOPE;
+
+typedef struct DIEFFECT {
+    DWORD dwSize;                   /* sizeof(DIEFFECT)     */
+    DWORD dwFlags;                  /* DIEFF_*              */
+    DWORD dwDuration;               /* Microseconds         */
+    DWORD dwSamplePeriod;           /* Microseconds         */
+    DWORD dwGain;
+    DWORD dwTriggerButton;          /* or DIEB_NOTRIGGER    */
+    DWORD dwTriggerRepeatInterval;  /* Microseconds         */
+    DWORD cAxes;                    /* Number of axes       */
+    LPDWORD rgdwAxes;               /* Array of axes        */
+    LPLONG rglDirection;            /* Array of directions  */
+    LPDIENVELOPE lpEnvelope;        /* Optional             */
+    DWORD cbTypeSpecificParams;     /* Size of params       */
+    LPVOID lpvTypeSpecificParams;   /* Pointer to params    */
+} DIEFFECT, *LPDIEFFECT;
+typedef const DIEFFECT *LPCDIEFFECT;
+
+#define DIEFF_OBJECTIDS             0x00000001
+#define DIEFF_OBJECTOFFSETS         0x00000002
+#define DIEFF_CARTESIAN             0x00000010
+#define DIEFF_POLAR                 0x00000020
+#define DIEFF_SPHERICAL             0x00000040
+
+#define DIEP_DURATION               0x00000001
+#define DIEP_SAMPLEPERIOD           0x00000002
+#define DIEP_GAIN                   0x00000004
+#define DIEP_TRIGGERBUTTON          0x00000008
+#define DIEP_TRIGGERREPEATINTERVAL  0x00000010
+#define DIEP_AXES                   0x00000020
+#define DIEP_DIRECTION              0x00000040
+#define DIEP_ENVELOPE               0x00000080
+#define DIEP_TYPESPECIFICPARAMS     0x00000100
+#define DIEP_ALLPARAMS              0x000001FF
+#define DIEP_START                  0x20000000
+#define DIEP_NORESTART              0x40000000
+#define DIEP_NODOWNLOAD             0x80000000
+#define DIEB_NOTRIGGER              0xFFFFFFFF
+
+#define DIES_SOLO                   0x00000001
+#define DIES_NODOWNLOAD             0x80000000
+
+#define DIEGES_PLAYING              0x00000001
+#define DIEGES_EMULATED             0x00000002
+
+typedef struct DIEFFESCAPE {
+    DWORD   dwSize;
+    DWORD   dwCommand;
+    LPVOID  lpvInBuffer;
+    DWORD   cbInBuffer;
+    LPVOID  lpvOutBuffer;
+    DWORD   cbOutBuffer;
+} DIEFFESCAPE, *LPDIEFFESCAPE;
+
+#ifndef DIJ_RINGZERO
+
+#undef INTERFACE
+#define INTERFACE IDirectInputEffect
+
+DECLARE_INTERFACE_(IDirectInputEffect, IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+
+    /*** IDirectInputEffect methods ***/
+    STDMETHOD(Initialize)(THIS_ HINSTANCE,DWORD,REFGUID) PURE;
+    STDMETHOD(GetEffectGuid)(THIS_ LPGUID) PURE;
+    STDMETHOD(GetParameters)(THIS_ LPDIEFFECT,DWORD) PURE;
+    STDMETHOD(SetParameters)(THIS_ LPCDIEFFECT,DWORD) PURE;
+    STDMETHOD(Start)(THIS_ DWORD,DWORD) PURE;
+    STDMETHOD(Stop)(THIS) PURE;
+    STDMETHOD(GetEffectStatus)(THIS_ LPDWORD) PURE;
+    STDMETHOD(Download)(THIS) PURE;
+    STDMETHOD(Unload)(THIS) PURE;
+    STDMETHOD(Escape)(THIS_ LPDIEFFESCAPE) PURE;
+};
+
+typedef struct IDirectInputEffect *LPDIRECTINPUTEFFECT;
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectInputEffect_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirectInputEffect_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IDirectInputEffect_Release(p) (p)->lpVtbl->Release(p)
+#define IDirectInputEffect_Initialize(p,a,b,c) (p)->lpVtbl->Initialize(p,a,b,c)
+#define IDirectInputEffect_GetEffectGuid(p,a) (p)->lpVtbl->GetEffectGuid(p,a)
+#define IDirectInputEffect_GetParameters(p,a,b) (p)->lpVtbl->GetParameters(p,a,b)
+#define IDirectInputEffect_SetParameters(p,a,b) (p)->lpVtbl->SetParameters(p,a,b)
+#define IDirectInputEffect_Start(p,a,b) (p)->lpVtbl->Start(p,a,b)
+#define IDirectInputEffect_Stop(p) (p)->lpVtbl->Stop(p)
+#define IDirectInputEffect_GetEffectStatus(p,a) (p)->lpVtbl->GetEffectStatus(p,a)
+#define IDirectInputEffect_Download(p) (p)->lpVtbl->Download(p)
+#define IDirectInputEffect_Unload(p) (p)->lpVtbl->Unload(p)
+#define IDirectInputEffect_Escape(p,a) (p)->lpVtbl->Escape(p,a)
+#else
+#define IDirectInputEffect_QueryInterface(p,a,b) (p)->QueryInterface(a,b)
+#define IDirectInputEffect_AddRef(p) (p)->AddRef()
+#define IDirectInputEffect_Release(p) (p)->Release()
+#define IDirectInputEffect_Initialize(p,a,b,c) (p)->Initialize(a,b,c)
+#define IDirectInputEffect_GetEffectGuid(p,a) (p)->GetEffectGuid(a)
+#define IDirectInputEffect_GetParameters(p,a,b) (p)->GetParameters(a,b)
+#define IDirectInputEffect_SetParameters(p,a,b) (p)->SetParameters(a,b)
+#define IDirectInputEffect_Start(p,a,b) (p)->Start(a,b)
+#define IDirectInputEffect_Stop(p) (p)->Stop()
+#define IDirectInputEffect_GetEffectStatus(p,a) (p)->GetEffectStatus(a)
+#define IDirectInputEffect_Download(p) (p)->Download()
+#define IDirectInputEffect_Unload(p) (p)->Unload()
+#define IDirectInputEffect_Escape(p,a) (p)->Escape(a)
+#endif
+
+#endif /* DIJ_RINGZERO */
+
+#endif /* DIRECTINPUT_VERSION >= 0x0500 */
+
+/****************************************************************************
+ *
+ *      IDirectInputDevice
+ *
+ ****************************************************************************/
+
+#define DIDEVTYPE_DEVICE    1
+#define DIDEVTYPE_MOUSE     2
+#define DIDEVTYPE_KEYBOARD  3
+#define DIDEVTYPE_JOYSTICK  4
+#define DIDEVTYPE_HID       0x00010000
+
+#define DIDEVTYPEMOUSE_UNKNOWN          1
+#define DIDEVTYPEMOUSE_TRADITIONAL      2
+#define DIDEVTYPEMOUSE_FINGERSTICK      3
+#define DIDEVTYPEMOUSE_TOUCHPAD         4
+#define DIDEVTYPEMOUSE_TRACKBALL        5
+
+#define DIDEVTYPEKEYBOARD_UNKNOWN       0
+#define DIDEVTYPEKEYBOARD_PCXT          1
+#define DIDEVTYPEKEYBOARD_OLIVETTI      2
+#define DIDEVTYPEKEYBOARD_PCAT          3
+#define DIDEVTYPEKEYBOARD_PCENH         4
+#define DIDEVTYPEKEYBOARD_NOKIA1050     5
+#define DIDEVTYPEKEYBOARD_NOKIA9140     6
+#define DIDEVTYPEKEYBOARD_NEC98         7
+#define DIDEVTYPEKEYBOARD_NEC98LAPTOP   8
+#define DIDEVTYPEKEYBOARD_NEC98106      9
+#define DIDEVTYPEKEYBOARD_JAPAN106     10
+#define DIDEVTYPEKEYBOARD_JAPANAX      11
+#define DIDEVTYPEKEYBOARD_J3100        12
+
+#define DIDEVTYPEJOYSTICK_UNKNOWN       1
+#define DIDEVTYPEJOYSTICK_TRADITIONAL   2
+#define DIDEVTYPEJOYSTICK_FLIGHTSTICK   3
+#define DIDEVTYPEJOYSTICK_GAMEPAD       4
+#define DIDEVTYPEJOYSTICK_RUDDER        5
+#define DIDEVTYPEJOYSTICK_WHEEL         6
+#define DIDEVTYPEJOYSTICK_HEADTRACKER   7
+
+#define GET_DIDEVICE_TYPE(dwDevType)    LOBYTE(dwDevType)
+#define GET_DIDEVICE_SUBTYPE(dwDevType) HIBYTE(dwDevType)
+
+#if(DIRECTINPUT_VERSION >= 0x0500)
+/* This structure is defined for DirectX 3.0 compatibility */
+
+typedef struct DIDEVCAPS_DX3 {
+    DWORD   dwSize;
+    DWORD   dwFlags;
+    DWORD   dwDevType;
+    DWORD   dwAxes;
+    DWORD   dwButtons;
+    DWORD   dwPOVs;
+} DIDEVCAPS_DX3, *LPDIDEVCAPS_DX3;
+#endif /* DIRECTINPUT_VERSION >= 0x0500 */
+
+typedef struct DIDEVCAPS {
+    DWORD   dwSize;
+    DWORD   dwFlags;
+    DWORD   dwDevType;
+    DWORD   dwAxes;
+    DWORD   dwButtons;
+    DWORD   dwPOVs;
+#if(DIRECTINPUT_VERSION >= 0x0500)
+    DWORD   dwFFSamplePeriod;
+    DWORD   dwFFMinTimeResolution;
+    DWORD   dwFirmwareRevision;
+    DWORD   dwHardwareRevision;
+    DWORD   dwFFDriverVersion;
+#endif /* DIRECTINPUT_VERSION >= 0x0500 */
+} DIDEVCAPS, *LPDIDEVCAPS;
+
+#define DIDC_ATTACHED           0x00000001
+#define DIDC_POLLEDDEVICE       0x00000002
+#define DIDC_EMULATED           0x00000004
+#define DIDC_POLLEDDATAFORMAT   0x00000008
+#if(DIRECTINPUT_VERSION >= 0x0500)
+#define DIDC_FORCEFEEDBACK      0x00000100
+#define DIDC_FFATTACK           0x00000200
+#define DIDC_FFFADE             0x00000400
+#define DIDC_SATURATION         0x00000800
+#define DIDC_POSNEGCOEFFICIENTS 0x00001000
+#define DIDC_POSNEGSATURATION   0x00002000
+#define DIDC_DEADBAND           0x00004000
+#endif /* DIRECTINPUT_VERSION >= 0x0500 */
+
+#define DIDFT_ALL           0x00000000
+
+#define DIDFT_RELAXIS       0x00000001
+#define DIDFT_ABSAXIS       0x00000002
+#define DIDFT_AXIS          0x00000003
+
+#define DIDFT_PSHBUTTON     0x00000004
+#define DIDFT_TGLBUTTON     0x00000008
+#define DIDFT_BUTTON        0x0000000C
+
+#define DIDFT_POV           0x00000010
+
+#define DIDFT_COLLECTION    0x00000040
+#define DIDFT_NODATA        0x00000080
+
+#define DIDFT_ANYINSTANCE   0x00FFFF00
+#define DIDFT_INSTANCEMASK  DIDFT_ANYINSTANCE
+#define DIDFT_MAKEINSTANCE(n) ((WORD)(n) << 8)
+#define DIDFT_GETTYPE(n)     LOBYTE(n)
+#define DIDFT_GETINSTANCE(n) LOWORD((n) >> 8)
+#define DIDFT_FFACTUATOR        0x01000000
+#define DIDFT_FFEFFECTTRIGGER   0x02000000
+
+#define DIDFT_ENUMCOLLECTION(n) ((WORD)(n) << 8)
+#define DIDFT_NOCOLLECTION      0x00FFFF00
+
+
+#ifndef DIJ_RINGZERO
+
+typedef struct _DIOBJECTDATAFORMAT {
+    const GUID *pguid;
+    DWORD   dwOfs;
+    DWORD   dwType;
+    DWORD   dwFlags;
+} DIOBJECTDATAFORMAT, *LPDIOBJECTDATAFORMAT;
+typedef const DIOBJECTDATAFORMAT *LPCDIOBJECTDATAFORMAT;
+
+typedef struct _DIDATAFORMAT {
+    DWORD   dwSize;
+    DWORD   dwObjSize;
+    DWORD   dwFlags;
+    DWORD   dwDataSize;
+    DWORD   dwNumObjs;
+    LPDIOBJECTDATAFORMAT rgodf;
+} DIDATAFORMAT, *LPDIDATAFORMAT;
+typedef const DIDATAFORMAT *LPCDIDATAFORMAT;
+
+#define DIDF_ABSAXIS            0x00000001
+#define DIDF_RELAXIS            0x00000002
+
+extern const DIDATAFORMAT c_dfDIMouse;
+extern const DIDATAFORMAT c_dfDIKeyboard;
+extern const DIDATAFORMAT c_dfDIJoystick;
+extern const DIDATAFORMAT c_dfDIJoystick2;
+
+#if(DIRECTINPUT_VERSION >= 0x0500)
+/* These structures are defined for DirectX 3.0 compatibility */
+
+typedef struct DIDEVICEOBJECTINSTANCE_DX3A {
+    DWORD   dwSize;
+    GUID    guidType;
+    DWORD   dwOfs;
+    DWORD   dwType;
+    DWORD   dwFlags;
+    CHAR    tszName[MAX_PATH];
+} DIDEVICEOBJECTINSTANCE_DX3A, *LPDIDEVICEOBJECTINSTANCE_DX3A;
+typedef struct DIDEVICEOBJECTINSTANCE_DX3W {
+    DWORD   dwSize;
+    GUID    guidType;
+    DWORD   dwOfs;
+    DWORD   dwType;
+    DWORD   dwFlags;
+    WCHAR   tszName[MAX_PATH];
+} DIDEVICEOBJECTINSTANCE_DX3W, *LPDIDEVICEOBJECTINSTANCE_DX3W;
+#ifdef UNICODE
+typedef DIDEVICEOBJECTINSTANCE_DX3W DIDEVICEOBJECTINSTANCE_DX3;
+typedef LPDIDEVICEOBJECTINSTANCE_DX3W LPDIDEVICEOBJECTINSTANCE_DX3;
+#else
+typedef DIDEVICEOBJECTINSTANCE_DX3A DIDEVICEOBJECTINSTANCE_DX3;
+typedef LPDIDEVICEOBJECTINSTANCE_DX3A LPDIDEVICEOBJECTINSTANCE_DX3;
+#endif // UNICODE
+typedef const DIDEVICEOBJECTINSTANCE_DX3A *LPCDIDEVICEOBJECTINSTANCE_DX3A;
+typedef const DIDEVICEOBJECTINSTANCE_DX3W *LPCDIDEVICEOBJECTINSTANCE_DX3W;
+typedef const DIDEVICEOBJECTINSTANCE_DX3  *LPCDIDEVICEOBJECTINSTANCE_DX3;
+#endif /* DIRECTINPUT_VERSION >= 0x0500 */
+
+typedef struct DIDEVICEOBJECTINSTANCEA {
+    DWORD   dwSize;
+    GUID    guidType;
+    DWORD   dwOfs;
+    DWORD   dwType;
+    DWORD   dwFlags;
+    CHAR    tszName[MAX_PATH];
+#if(DIRECTINPUT_VERSION >= 0x0500)
+    DWORD   dwFFMaxForce;
+    DWORD   dwFFForceResolution;
+    WORD    wCollectionNumber;
+    WORD    wDesignatorIndex;
+    WORD    wUsagePage;
+    WORD    wUsage;
+    DWORD   dwDimension;
+    WORD    wExponent;
+    WORD    wReserved;
+#endif /* DIRECTINPUT_VERSION >= 0x0500 */
+} DIDEVICEOBJECTINSTANCEA, *LPDIDEVICEOBJECTINSTANCEA;
+typedef struct DIDEVICEOBJECTINSTANCEW {
+    DWORD   dwSize;
+    GUID    guidType;
+    DWORD   dwOfs;
+    DWORD   dwType;
+    DWORD   dwFlags;
+    WCHAR   tszName[MAX_PATH];
+#if(DIRECTINPUT_VERSION >= 0x0500)
+    DWORD   dwFFMaxForce;
+    DWORD   dwFFForceResolution;
+    WORD    wCollectionNumber;
+    WORD    wDesignatorIndex;
+    WORD    wUsagePage;
+    WORD    wUsage;
+    DWORD   dwDimension;
+    WORD    wExponent;
+    WORD    wReserved;
+#endif /* DIRECTINPUT_VERSION >= 0x0500 */
+} DIDEVICEOBJECTINSTANCEW, *LPDIDEVICEOBJECTINSTANCEW;
+#ifdef UNICODE
+typedef DIDEVICEOBJECTINSTANCEW DIDEVICEOBJECTINSTANCE;
+typedef LPDIDEVICEOBJECTINSTANCEW LPDIDEVICEOBJECTINSTANCE;
+#else
+typedef DIDEVICEOBJECTINSTANCEA DIDEVICEOBJECTINSTANCE;
+typedef LPDIDEVICEOBJECTINSTANCEA LPDIDEVICEOBJECTINSTANCE;
+#endif // UNICODE
+typedef const DIDEVICEOBJECTINSTANCEA *LPCDIDEVICEOBJECTINSTANCEA;
+typedef const DIDEVICEOBJECTINSTANCEW *LPCDIDEVICEOBJECTINSTANCEW;
+typedef const DIDEVICEOBJECTINSTANCE  *LPCDIDEVICEOBJECTINSTANCE;
+
+typedef BOOL (FAR PASCAL * LPDIENUMDEVICEOBJECTSCALLBACKA)(LPCDIDEVICEOBJECTINSTANCEA, LPVOID);
+typedef BOOL (FAR PASCAL * LPDIENUMDEVICEOBJECTSCALLBACKW)(LPCDIDEVICEOBJECTINSTANCEW, LPVOID);
+#ifdef UNICODE
+#define LPDIENUMDEVICEOBJECTSCALLBACK  LPDIENUMDEVICEOBJECTSCALLBACKW
+#else
+#define LPDIENUMDEVICEOBJECTSCALLBACK  LPDIENUMDEVICEOBJECTSCALLBACKA
+#endif // !UNICODE
+
+#if(DIRECTINPUT_VERSION >= 0x0500)
+#define DIDOI_FFACTUATOR        0x00000001
+#define DIDOI_FFEFFECTTRIGGER   0x00000002
+#define DIDOI_POLLED            0x00008000
+#define DIDOI_ASPECTPOSITION    0x00000100
+#define DIDOI_ASPECTVELOCITY    0x00000200
+#define DIDOI_ASPECTACCEL       0x00000300
+#define DIDOI_ASPECTFORCE       0x00000400
+#define DIDOI_ASPECTMASK        0x00000F00
+#endif /* DIRECTINPUT_VERSION >= 0x0500 */
+
+typedef struct DIPROPHEADER {
+    DWORD   dwSize;
+    DWORD   dwHeaderSize;
+    DWORD   dwObj;
+    DWORD   dwHow;
+} DIPROPHEADER, *LPDIPROPHEADER;
+typedef const DIPROPHEADER *LPCDIPROPHEADER;
+
+#define DIPH_DEVICE             0
+#define DIPH_BYOFFSET           1
+#define DIPH_BYID               2
+
+typedef struct DIPROPDWORD {
+    DIPROPHEADER diph;
+    DWORD   dwData;
+} DIPROPDWORD, *LPDIPROPDWORD;
+typedef const DIPROPDWORD *LPCDIPROPDWORD;
+
+typedef struct DIPROPRANGE {
+    DIPROPHEADER diph;
+    LONG    lMin;
+    LONG    lMax;
+} DIPROPRANGE, *LPDIPROPRANGE;
+typedef const DIPROPRANGE *LPCDIPROPRANGE;
+
+#define DIPROPRANGE_NOMIN       ((LONG)0x80000000)
+#define DIPROPRANGE_NOMAX       ((LONG)0x7FFFFFFF)
+
+#ifdef __cplusplus
+#define MAKEDIPROP(prop)    (*(const GUID *)(prop))
+#else
+#define MAKEDIPROP(prop)    ((REFGUID)(prop))
+#endif
+
+#define DIPROP_BUFFERSIZE       MAKEDIPROP(1)
+
+#define DIPROP_AXISMODE         MAKEDIPROP(2)
+
+#define DIPROPAXISMODE_ABS      0
+#define DIPROPAXISMODE_REL      1
+
+#define DIPROP_GRANULARITY      MAKEDIPROP(3)
+
+#define DIPROP_RANGE            MAKEDIPROP(4)
+
+#define DIPROP_DEADZONE         MAKEDIPROP(5)
+
+#define DIPROP_SATURATION       MAKEDIPROP(6)
+
+#define DIPROP_FFGAIN           MAKEDIPROP(7)
+
+#define DIPROP_FFLOAD           MAKEDIPROP(8)
+
+#define DIPROP_AUTOCENTER       MAKEDIPROP(9)
+
+#define DIPROPAUTOCENTER_OFF    0
+#define DIPROPAUTOCENTER_ON     1
+
+#define DIPROP_CALIBRATIONMODE  MAKEDIPROP(10)
+
+#define DIPROPCALIBRATIONMODE_COOKED    0
+#define DIPROPCALIBRATIONMODE_RAW       1
+
+typedef struct DIDEVICEOBJECTDATA {
+    DWORD   dwOfs;
+    DWORD   dwData;
+    DWORD   dwTimeStamp;
+    DWORD   dwSequence;
+} DIDEVICEOBJECTDATA, *LPDIDEVICEOBJECTDATA;
+typedef const DIDEVICEOBJECTDATA *LPCDIDEVICEOBJECTDATA;
+
+#define DIGDD_PEEK          0x00000001
+
+#define DISEQUENCE_COMPARE(dwSequence1, cmp, dwSequence2) \
+                        ((int)((dwSequence1) - (dwSequence2)) cmp 0)
+#define DISCL_EXCLUSIVE     0x00000001
+#define DISCL_NONEXCLUSIVE  0x00000002
+#define DISCL_FOREGROUND    0x00000004
+#define DISCL_BACKGROUND    0x00000008
+
+#if(DIRECTINPUT_VERSION >= 0x0500)
+/* These structures are defined for DirectX 3.0 compatibility */
+
+typedef struct DIDEVICEINSTANCE_DX3A {
+    DWORD   dwSize;
+    GUID    guidInstance;
+    GUID    guidProduct;
+    DWORD   dwDevType;
+    CHAR    tszInstanceName[MAX_PATH];
+    CHAR    tszProductName[MAX_PATH];
+} DIDEVICEINSTANCE_DX3A, *LPDIDEVICEINSTANCE_DX3A;
+typedef struct DIDEVICEINSTANCE_DX3W {
+    DWORD   dwSize;
+    GUID    guidInstance;
+    GUID    guidProduct;
+    DWORD   dwDevType;
+    WCHAR   tszInstanceName[MAX_PATH];
+    WCHAR   tszProductName[MAX_PATH];
+} DIDEVICEINSTANCE_DX3W, *LPDIDEVICEINSTANCE_DX3W;
+#ifdef UNICODE
+typedef DIDEVICEINSTANCE_DX3W DIDEVICEINSTANCE_DX3;
+typedef LPDIDEVICEINSTANCE_DX3W LPDIDEVICEINSTANCE_DX3;
+#else
+typedef DIDEVICEINSTANCE_DX3A DIDEVICEINSTANCE_DX3;
+typedef LPDIDEVICEINSTANCE_DX3A LPDIDEVICEINSTANCE_DX3;
+#endif // UNICODE
+typedef const DIDEVICEINSTANCE_DX3A *LPCDIDEVICEINSTANCE_DX3A;
+typedef const DIDEVICEINSTANCE_DX3W *LPCDIDEVICEINSTANCE_DX3W;
+typedef const DIDEVICEINSTANCE_DX3  *LPCDIDEVICEINSTANCE_DX3;
+#endif /* DIRECTINPUT_VERSION >= 0x0500 */
+
+typedef struct DIDEVICEINSTANCEA {
+    DWORD   dwSize;
+    GUID    guidInstance;
+    GUID    guidProduct;
+    DWORD   dwDevType;
+    CHAR    tszInstanceName[MAX_PATH];
+    CHAR    tszProductName[MAX_PATH];
+#if(DIRECTINPUT_VERSION >= 0x0500)
+    GUID    guidFFDriver;
+    WORD    wUsagePage;
+    WORD    wUsage;
+#endif /* DIRECTINPUT_VERSION >= 0x0500 */
+} DIDEVICEINSTANCEA, *LPDIDEVICEINSTANCEA;
+typedef struct DIDEVICEINSTANCEW {
+    DWORD   dwSize;
+    GUID    guidInstance;
+    GUID    guidProduct;
+    DWORD   dwDevType;
+    WCHAR   tszInstanceName[MAX_PATH];
+    WCHAR   tszProductName[MAX_PATH];
+#if(DIRECTINPUT_VERSION >= 0x0500)
+    GUID    guidFFDriver;
+    WORD    wUsagePage;
+    WORD    wUsage;
+#endif /* DIRECTINPUT_VERSION >= 0x0500 */
+} DIDEVICEINSTANCEW, *LPDIDEVICEINSTANCEW;
+#ifdef UNICODE
+typedef DIDEVICEINSTANCEW DIDEVICEINSTANCE;
+typedef LPDIDEVICEINSTANCEW LPDIDEVICEINSTANCE;
+#else
+typedef DIDEVICEINSTANCEA DIDEVICEINSTANCE;
+typedef LPDIDEVICEINSTANCEA LPDIDEVICEINSTANCE;
+#endif // UNICODE
+typedef const DIDEVICEINSTANCEA *LPCDIDEVICEINSTANCEA;
+typedef const DIDEVICEINSTANCEW *LPCDIDEVICEINSTANCEW;
+typedef const DIDEVICEINSTANCE  *LPCDIDEVICEINSTANCE;
+
+#undef INTERFACE
+#define INTERFACE IDirectInputDeviceW
+
+DECLARE_INTERFACE_(IDirectInputDeviceW, IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+
+    /*** IDirectInputDeviceW methods ***/
+    STDMETHOD(GetCapabilities)(THIS_ LPDIDEVCAPS) PURE;
+    STDMETHOD(EnumObjects)(THIS_ LPDIENUMDEVICEOBJECTSCALLBACKW,LPVOID,DWORD) PURE;
+    STDMETHOD(GetProperty)(THIS_ REFGUID,LPDIPROPHEADER) PURE;
+    STDMETHOD(SetProperty)(THIS_ REFGUID,LPCDIPROPHEADER) PURE;
+    STDMETHOD(Acquire)(THIS) PURE;
+    STDMETHOD(Unacquire)(THIS) PURE;
+    STDMETHOD(GetDeviceState)(THIS_ DWORD,LPVOID) PURE;
+    STDMETHOD(GetDeviceData)(THIS_ DWORD,LPDIDEVICEOBJECTDATA,LPDWORD,DWORD) PURE;
+    STDMETHOD(SetDataFormat)(THIS_ LPCDIDATAFORMAT) PURE;
+    STDMETHOD(SetEventNotification)(THIS_ HANDLE) PURE;
+    STDMETHOD(SetCooperativeLevel)(THIS_ HWND,DWORD) PURE;
+    STDMETHOD(GetObjectInfo)(THIS_ LPDIDEVICEOBJECTINSTANCEW,DWORD,DWORD) PURE;
+    STDMETHOD(GetDeviceInfo)(THIS_ LPDIDEVICEINSTANCEW) PURE;
+    STDMETHOD(RunControlPanel)(THIS_ HWND,DWORD) PURE;
+    STDMETHOD(Initialize)(THIS_ HINSTANCE,DWORD,REFGUID) PURE;
+};
+
+typedef struct IDirectInputDeviceW *LPDIRECTINPUTDEVICEW;
+
+#undef INTERFACE
+#define INTERFACE IDirectInputDeviceA
+
+DECLARE_INTERFACE_(IDirectInputDeviceA, IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+
+    /*** IDirectInputDeviceA methods ***/
+    STDMETHOD(GetCapabilities)(THIS_ LPDIDEVCAPS) PURE;
+    STDMETHOD(EnumObjects)(THIS_ LPDIENUMDEVICEOBJECTSCALLBACKA,LPVOID,DWORD) PURE;
+    STDMETHOD(GetProperty)(THIS_ REFGUID,LPDIPROPHEADER) PURE;
+    STDMETHOD(SetProperty)(THIS_ REFGUID,LPCDIPROPHEADER) PURE;
+    STDMETHOD(Acquire)(THIS) PURE;
+    STDMETHOD(Unacquire)(THIS) PURE;
+    STDMETHOD(GetDeviceState)(THIS_ DWORD,LPVOID) PURE;
+    STDMETHOD(GetDeviceData)(THIS_ DWORD,LPDIDEVICEOBJECTDATA,LPDWORD,DWORD) PURE;
+    STDMETHOD(SetDataFormat)(THIS_ LPCDIDATAFORMAT) PURE;
+    STDMETHOD(SetEventNotification)(THIS_ HANDLE) PURE;
+    STDMETHOD(SetCooperativeLevel)(THIS_ HWND,DWORD) PURE;
+    STDMETHOD(GetObjectInfo)(THIS_ LPDIDEVICEOBJECTINSTANCEA,DWORD,DWORD) PURE;
+    STDMETHOD(GetDeviceInfo)(THIS_ LPDIDEVICEINSTANCEA) PURE;
+    STDMETHOD(RunControlPanel)(THIS_ HWND,DWORD) PURE;
+    STDMETHOD(Initialize)(THIS_ HINSTANCE,DWORD,REFGUID) PURE;
+};
+
+typedef struct IDirectInputDeviceA *LPDIRECTINPUTDEVICEA;
+
+#ifdef UNICODE
+#define IID_IDirectInputDevice IID_IDirectInputDeviceW
+#define IDirectInputDevice IDirectInputDeviceW
+#define IDirectInputDeviceVtbl IDirectInputDeviceWVtbl
+#else
+#define IID_IDirectInputDevice IID_IDirectInputDeviceA
+#define IDirectInputDevice IDirectInputDeviceA
+#define IDirectInputDeviceVtbl IDirectInputDeviceAVtbl
+#endif
+typedef struct IDirectInputDevice *LPDIRECTINPUTDEVICE;
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectInputDevice_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirectInputDevice_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IDirectInputDevice_Release(p) (p)->lpVtbl->Release(p)
+#define IDirectInputDevice_GetCapabilities(p,a) (p)->lpVtbl->GetCapabilities(p,a)
+#define IDirectInputDevice_EnumObjects(p,a,b,c) (p)->lpVtbl->EnumObjects(p,a,b,c)
+#define IDirectInputDevice_GetProperty(p,a,b) (p)->lpVtbl->GetProperty(p,a,b)
+#define IDirectInputDevice_SetProperty(p,a,b) (p)->lpVtbl->SetProperty(p,a,b)
+#define IDirectInputDevice_Acquire(p) (p)->lpVtbl->Acquire(p)
+#define IDirectInputDevice_Unacquire(p) (p)->lpVtbl->Unacquire(p)
+#define IDirectInputDevice_GetDeviceState(p,a,b) (p)->lpVtbl->GetDeviceState(p,a,b)
+#define IDirectInputDevice_GetDeviceData(p,a,b,c,d) (p)->lpVtbl->GetDeviceData(p,a,b,c,d)
+#define IDirectInputDevice_SetDataFormat(p,a) (p)->lpVtbl->SetDataFormat(p,a)
+#define IDirectInputDevice_SetEventNotification(p,a) (p)->lpVtbl->SetEventNotification(p,a)
+#define IDirectInputDevice_SetCooperativeLevel(p,a,b) (p)->lpVtbl->SetCooperativeLevel(p,a,b)
+#define IDirectInputDevice_GetObjectInfo(p,a,b,c) (p)->lpVtbl->GetObjectInfo(p,a,b,c)
+#define IDirectInputDevice_GetDeviceInfo(p,a) (p)->lpVtbl->GetDeviceInfo(p,a)
+#define IDirectInputDevice_RunControlPanel(p,a,b) (p)->lpVtbl->RunControlPanel(p,a,b)
+#define IDirectInputDevice_Initialize(p,a,b,c) (p)->lpVtbl->Initialize(p,a,b,c)
+#else
+#define IDirectInputDevice_QueryInterface(p,a,b) (p)->QueryInterface(a,b)
+#define IDirectInputDevice_AddRef(p) (p)->AddRef()
+#define IDirectInputDevice_Release(p) (p)->Release()
+#define IDirectInputDevice_GetCapabilities(p,a) (p)->GetCapabilities(a)
+#define IDirectInputDevice_EnumObjects(p,a,b,c) (p)->EnumObjects(a,b,c)
+#define IDirectInputDevice_GetProperty(p,a,b) (p)->GetProperty(a,b)
+#define IDirectInputDevice_SetProperty(p,a,b) (p)->SetProperty(a,b)
+#define IDirectInputDevice_Acquire(p) (p)->Acquire()
+#define IDirectInputDevice_Unacquire(p) (p)->Unacquire()
+#define IDirectInputDevice_GetDeviceState(p,a,b) (p)->GetDeviceState(a,b)
+#define IDirectInputDevice_GetDeviceData(p,a,b,c,d) (p)->GetDeviceData(a,b,c,d)
+#define IDirectInputDevice_SetDataFormat(p,a) (p)->SetDataFormat(a)
+#define IDirectInputDevice_SetEventNotification(p,a) (p)->SetEventNotification(a)
+#define IDirectInputDevice_SetCooperativeLevel(p,a,b) (p)->SetCooperativeLevel(a,b)
+#define IDirectInputDevice_GetObjectInfo(p,a,b,c) (p)->GetObjectInfo(a,b,c)
+#define IDirectInputDevice_GetDeviceInfo(p,a) (p)->GetDeviceInfo(a)
+#define IDirectInputDevice_RunControlPanel(p,a,b) (p)->RunControlPanel(a,b)
+#define IDirectInputDevice_Initialize(p,a,b,c) (p)->Initialize(a,b,c)
+#endif
+
+#endif /* DIJ_RINGZERO */
+
+
+#if(DIRECTINPUT_VERSION >= 0x0500)
+
+#define DISFFC_RESET            0x00000001
+#define DISFFC_STOPALL          0x00000002
+#define DISFFC_PAUSE            0x00000004
+#define DISFFC_CONTINUE         0x00000008
+#define DISFFC_SETACTUATORSON   0x00000010
+#define DISFFC_SETACTUATORSOFF  0x00000020
+
+#define DIGFFS_EMPTY            0x00000001
+#define DIGFFS_STOPPED          0x00000002
+#define DIGFFS_PAUSED           0x00000004
+#define DIGFFS_ACTUATORSON      0x00000010
+#define DIGFFS_ACTUATORSOFF     0x00000020
+#define DIGFFS_POWERON          0x00000040
+#define DIGFFS_POWEROFF         0x00000080
+#define DIGFFS_SAFETYSWITCHON   0x00000100
+#define DIGFFS_SAFETYSWITCHOFF  0x00000200
+#define DIGFFS_USERFFSWITCHON   0x00000400
+#define DIGFFS_USERFFSWITCHOFF  0x00000800
+#define DIGFFS_DEVICELOST       0x80000000
+
+#ifndef DIJ_RINGZERO
+
+typedef struct DIEFFECTINFOA {
+    DWORD   dwSize;
+    GUID    guid;
+    DWORD   dwEffType;
+    DWORD   dwStaticParams;
+    DWORD   dwDynamicParams;
+    CHAR    tszName[MAX_PATH];
+} DIEFFECTINFOA, *LPDIEFFECTINFOA;
+typedef struct DIEFFECTINFOW {
+    DWORD   dwSize;
+    GUID    guid;
+    DWORD   dwEffType;
+    DWORD   dwStaticParams;
+    DWORD   dwDynamicParams;
+    WCHAR   tszName[MAX_PATH];
+} DIEFFECTINFOW, *LPDIEFFECTINFOW;
+#ifdef UNICODE
+typedef DIEFFECTINFOW DIEFFECTINFO;
+typedef LPDIEFFECTINFOW LPDIEFFECTINFO;
+#else
+typedef DIEFFECTINFOA DIEFFECTINFO;
+typedef LPDIEFFECTINFOA LPDIEFFECTINFO;
+#endif // UNICODE
+typedef const DIEFFECTINFOA *LPCDIEFFECTINFOA;
+typedef const DIEFFECTINFOW *LPCDIEFFECTINFOW;
+typedef const DIEFFECTINFO  *LPCDIEFFECTINFO;
+
+typedef BOOL (FAR PASCAL * LPDIENUMEFFECTSCALLBACKA)(LPCDIEFFECTINFOA, LPVOID);
+typedef BOOL (FAR PASCAL * LPDIENUMEFFECTSCALLBACKW)(LPCDIEFFECTINFOW, LPVOID);
+#ifdef UNICODE
+#define LPDIENUMEFFECTSCALLBACK  LPDIENUMEFFECTSCALLBACKW
+#else
+#define LPDIENUMEFFECTSCALLBACK  LPDIENUMEFFECTSCALLBACKA
+#endif // !UNICODE
+typedef BOOL (FAR PASCAL * LPDIENUMCREATEDEFFECTOBJECTSCALLBACK)(LPDIRECTINPUTEFFECT, LPVOID);
+
+#undef INTERFACE
+#define INTERFACE IDirectInputDevice2W
+
+DECLARE_INTERFACE_(IDirectInputDevice2W, IDirectInputDeviceW)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+
+    /*** IDirectInputDeviceW methods ***/
+    STDMETHOD(GetCapabilities)(THIS_ LPDIDEVCAPS) PURE;
+    STDMETHOD(EnumObjects)(THIS_ LPDIENUMDEVICEOBJECTSCALLBACKW,LPVOID,DWORD) PURE;
+    STDMETHOD(GetProperty)(THIS_ REFGUID,LPDIPROPHEADER) PURE;
+    STDMETHOD(SetProperty)(THIS_ REFGUID,LPCDIPROPHEADER) PURE;
+    STDMETHOD(Acquire)(THIS) PURE;
+    STDMETHOD(Unacquire)(THIS) PURE;
+    STDMETHOD(GetDeviceState)(THIS_ DWORD,LPVOID) PURE;
+    STDMETHOD(GetDeviceData)(THIS_ DWORD,LPDIDEVICEOBJECTDATA,LPDWORD,DWORD) PURE;
+    STDMETHOD(SetDataFormat)(THIS_ LPCDIDATAFORMAT) PURE;
+    STDMETHOD(SetEventNotification)(THIS_ HANDLE) PURE;
+    STDMETHOD(SetCooperativeLevel)(THIS_ HWND,DWORD) PURE;
+    STDMETHOD(GetObjectInfo)(THIS_ LPDIDEVICEOBJECTINSTANCEW,DWORD,DWORD) PURE;
+    STDMETHOD(GetDeviceInfo)(THIS_ LPDIDEVICEINSTANCEW) PURE;
+    STDMETHOD(RunControlPanel)(THIS_ HWND,DWORD) PURE;
+    STDMETHOD(Initialize)(THIS_ HINSTANCE,DWORD,REFGUID) PURE;
+
+    /*** IDirectInputDevice2W methods ***/
+    STDMETHOD(CreateEffect)(THIS_ REFGUID,LPCDIEFFECT,LPDIRECTINPUTEFFECT *,LPUNKNOWN) PURE;
+    STDMETHOD(EnumEffects)(THIS_ LPDIENUMEFFECTSCALLBACKW,LPVOID,DWORD) PURE;
+    STDMETHOD(GetEffectInfo)(THIS_ LPDIEFFECTINFOW,REFGUID) PURE;
+    STDMETHOD(GetForceFeedbackState)(THIS_ LPDWORD) PURE;
+    STDMETHOD(SendForceFeedbackCommand)(THIS_ DWORD) PURE;
+    STDMETHOD(EnumCreatedEffectObjects)(THIS_ LPDIENUMCREATEDEFFECTOBJECTSCALLBACK,LPVOID,DWORD) PURE;
+    STDMETHOD(Escape)(THIS_ LPDIEFFESCAPE) PURE;
+    STDMETHOD(Poll)(THIS) PURE;
+    STDMETHOD(SendDeviceData)(THIS_ DWORD,LPDIDEVICEOBJECTDATA,LPDWORD,DWORD) PURE;
+};
+
+typedef struct IDirectInputDevice2W *LPDIRECTINPUTDEVICE2W;
+
+#undef INTERFACE
+#define INTERFACE IDirectInputDevice2A
+
+DECLARE_INTERFACE_(IDirectInputDevice2A, IDirectInputDeviceA)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+
+    /*** IDirectInputDeviceA methods ***/
+    STDMETHOD(GetCapabilities)(THIS_ LPDIDEVCAPS) PURE;
+    STDMETHOD(EnumObjects)(THIS_ LPDIENUMDEVICEOBJECTSCALLBACKA,LPVOID,DWORD) PURE;
+    STDMETHOD(GetProperty)(THIS_ REFGUID,LPDIPROPHEADER) PURE;
+    STDMETHOD(SetProperty)(THIS_ REFGUID,LPCDIPROPHEADER) PURE;
+    STDMETHOD(Acquire)(THIS) PURE;
+    STDMETHOD(Unacquire)(THIS) PURE;
+    STDMETHOD(GetDeviceState)(THIS_ DWORD,LPVOID) PURE;
+    STDMETHOD(GetDeviceData)(THIS_ DWORD,LPDIDEVICEOBJECTDATA,LPDWORD,DWORD) PURE;
+    STDMETHOD(SetDataFormat)(THIS_ LPCDIDATAFORMAT) PURE;
+    STDMETHOD(SetEventNotification)(THIS_ HANDLE) PURE;
+    STDMETHOD(SetCooperativeLevel)(THIS_ HWND,DWORD) PURE;
+    STDMETHOD(GetObjectInfo)(THIS_ LPDIDEVICEOBJECTINSTANCEA,DWORD,DWORD) PURE;
+    STDMETHOD(GetDeviceInfo)(THIS_ LPDIDEVICEINSTANCEA) PURE;
+    STDMETHOD(RunControlPanel)(THIS_ HWND,DWORD) PURE;
+    STDMETHOD(Initialize)(THIS_ HINSTANCE,DWORD,REFGUID) PURE;
+
+    /*** IDirectInputDevice2A methods ***/
+    STDMETHOD(CreateEffect)(THIS_ REFGUID,LPCDIEFFECT,LPDIRECTINPUTEFFECT *,LPUNKNOWN) PURE;
+    STDMETHOD(EnumEffects)(THIS_ LPDIENUMEFFECTSCALLBACKA,LPVOID,DWORD) PURE;
+    STDMETHOD(GetEffectInfo)(THIS_ LPDIEFFECTINFOA,REFGUID) PURE;
+    STDMETHOD(GetForceFeedbackState)(THIS_ LPDWORD) PURE;
+    STDMETHOD(SendForceFeedbackCommand)(THIS_ DWORD) PURE;
+    STDMETHOD(EnumCreatedEffectObjects)(THIS_ LPDIENUMCREATEDEFFECTOBJECTSCALLBACK,LPVOID,DWORD) PURE;
+    STDMETHOD(Escape)(THIS_ LPDIEFFESCAPE) PURE;
+    STDMETHOD(Poll)(THIS) PURE;
+    STDMETHOD(SendDeviceData)(THIS_ DWORD,LPDIDEVICEOBJECTDATA,LPDWORD,DWORD) PURE;
+};
+
+typedef struct IDirectInputDevice2A *LPDIRECTINPUTDEVICE2A;
+
+#ifdef UNICODE
+#define IID_IDirectInputDevice2 IID_IDirectInputDevice2W
+#define IDirectInputDevice2 IDirectInputDevice2W
+#define IDirectInputDevice2Vtbl IDirectInputDevice2WVtbl
+#else
+#define IID_IDirectInputDevice2 IID_IDirectInputDevice2A
+#define IDirectInputDevice2 IDirectInputDevice2A
+#define IDirectInputDevice2Vtbl IDirectInputDevice2AVtbl
+#endif
+typedef struct IDirectInputDevice2 *LPDIRECTINPUTDEVICE2;
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectInputDevice2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirectInputDevice2_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IDirectInputDevice2_Release(p) (p)->lpVtbl->Release(p)
+#define IDirectInputDevice2_GetCapabilities(p,a) (p)->lpVtbl->GetCapabilities(p,a)
+#define IDirectInputDevice2_EnumObjects(p,a,b,c) (p)->lpVtbl->EnumObjects(p,a,b,c)
+#define IDirectInputDevice2_GetProperty(p,a,b) (p)->lpVtbl->GetProperty(p,a,b)
+#define IDirectInputDevice2_SetProperty(p,a,b) (p)->lpVtbl->SetProperty(p,a,b)
+#define IDirectInputDevice2_Acquire(p) (p)->lpVtbl->Acquire(p)
+#define IDirectInputDevice2_Unacquire(p) (p)->lpVtbl->Unacquire(p)
+#define IDirectInputDevice2_GetDeviceState(p,a,b) (p)->lpVtbl->GetDeviceState(p,a,b)
+#define IDirectInputDevice2_GetDeviceData(p,a,b,c,d) (p)->lpVtbl->GetDeviceData(p,a,b,c,d)
+#define IDirectInputDevice2_SetDataFormat(p,a) (p)->lpVtbl->SetDataFormat(p,a)
+#define IDirectInputDevice2_SetEventNotification(p,a) (p)->lpVtbl->SetEventNotification(p,a)
+#define IDirectInputDevice2_SetCooperativeLevel(p,a,b) (p)->lpVtbl->SetCooperativeLevel(p,a,b)
+#define IDirectInputDevice2_GetObjectInfo(p,a,b,c) (p)->lpVtbl->GetObjectInfo(p,a,b,c)
+#define IDirectInputDevice2_GetDeviceInfo(p,a) (p)->lpVtbl->GetDeviceInfo(p,a)
+#define IDirectInputDevice2_RunControlPanel(p,a,b) (p)->lpVtbl->RunControlPanel(p,a,b)
+#define IDirectInputDevice2_Initialize(p,a,b,c) (p)->lpVtbl->Initialize(p,a,b,c)
+#define IDirectInputDevice2_CreateEffect(p,a,b,c,d) (p)->lpVtbl->CreateEffect(p,a,b,c,d)
+#define IDirectInputDevice2_EnumEffects(p,a,b,c) (p)->lpVtbl->EnumEffects(p,a,b,c)
+#define IDirectInputDevice2_GetEffectInfo(p,a,b) (p)->lpVtbl->GetEffectInfo(p,a,b)
+#define IDirectInputDevice2_GetForceFeedbackState(p,a) (p)->lpVtbl->GetForceFeedbackState(p,a)
+#define IDirectInputDevice2_SendForceFeedbackCommand(p,a) (p)->lpVtbl->SendForceFeedbackCommand(p,a)
+#define IDirectInputDevice2_EnumCreatedEffectObjects(p,a,b,c) (p)->lpVtbl->EnumCreatedEffectObjects(p,a,b,c)
+#define IDirectInputDevice2_Escape(p,a) (p)->lpVtbl->Escape(p,a)
+#define IDirectInputDevice2_Poll(p) (p)->lpVtbl->Poll(p)
+#define IDirectInputDevice2_SendDeviceData(p,a,b,c,d) (p)->lpVtbl->SendDeviceData(p,a,b,c,d)
+#else
+#define IDirectInputDevice2_QueryInterface(p,a,b) (p)->QueryInterface(a,b)
+#define IDirectInputDevice2_AddRef(p) (p)->AddRef()
+#define IDirectInputDevice2_Release(p) (p)->Release()
+#define IDirectInputDevice2_GetCapabilities(p,a) (p)->GetCapabilities(a)
+#define IDirectInputDevice2_EnumObjects(p,a,b,c) (p)->EnumObjects(a,b,c)
+#define IDirectInputDevice2_GetProperty(p,a,b) (p)->GetProperty(a,b)
+#define IDirectInputDevice2_SetProperty(p,a,b) (p)->SetProperty(a,b)
+#define IDirectInputDevice2_Acquire(p) (p)->Acquire()
+#define IDirectInputDevice2_Unacquire(p) (p)->Unacquire()
+#define IDirectInputDevice2_GetDeviceState(p,a,b) (p)->GetDeviceState(a,b)
+#define IDirectInputDevice2_GetDeviceData(p,a,b,c,d) (p)->GetDeviceData(a,b,c,d)
+#define IDirectInputDevice2_SetDataFormat(p,a) (p)->SetDataFormat(a)
+#define IDirectInputDevice2_SetEventNotification(p,a) (p)->SetEventNotification(a)
+#define IDirectInputDevice2_SetCooperativeLevel(p,a,b) (p)->SetCooperativeLevel(a,b)
+#define IDirectInputDevice2_GetObjectInfo(p,a,b,c) (p)->GetObjectInfo(a,b,c)
+#define IDirectInputDevice2_GetDeviceInfo(p,a) (p)->GetDeviceInfo(a)
+#define IDirectInputDevice2_RunControlPanel(p,a,b) (p)->RunControlPanel(a,b)
+#define IDirectInputDevice2_Initialize(p,a,b,c) (p)->Initialize(a,b,c)
+#define IDirectInputDevice2_CreateEffect(p,a,b,c,d) (p)->CreateEffect(a,b,c,d)
+#define IDirectInputDevice2_EnumEffects(p,a,b,c) (p)->EnumEffects(a,b,c)
+#define IDirectInputDevice2_GetEffectInfo(p,a,b) (p)->GetEffectInfo(a,b)
+#define IDirectInputDevice2_GetForceFeedbackState(p,a) (p)->GetForceFeedbackState(a)
+#define IDirectInputDevice2_SendForceFeedbackCommand(p,a) (p)->SendForceFeedbackCommand(a)
+#define IDirectInputDevice2_EnumCreatedEffectObjects(p,a,b,c) (p)->EnumCreatedEffectObjects(a,b,c)
+#define IDirectInputDevice2_Escape(p,a) (p)->Escape(a)
+#define IDirectInputDevice2_Poll(p) (p)->Poll()
+#define IDirectInputDevice2_SendDeviceData(p,a,b,c,d) (p)->SendDeviceData(a,b,c,d)
+#endif
+
+#endif /* DIJ_RINGZERO */
+
+#endif /* DIRECTINPUT_VERSION >= 0x0500 */
+
+/****************************************************************************
+ *
+ *      Mouse
+ *
+ ****************************************************************************/
+
+#ifndef DIJ_RINGZERO
+
+typedef struct _DIMOUSESTATE {
+    LONG    lX;
+    LONG    lY;
+    LONG    lZ;
+    BYTE    rgbButtons[4];
+} DIMOUSESTATE, *LPDIMOUSESTATE;
+
+#define DIMOFS_X        FIELD_OFFSET(DIMOUSESTATE, lX)
+#define DIMOFS_Y        FIELD_OFFSET(DIMOUSESTATE, lY)
+#define DIMOFS_Z        FIELD_OFFSET(DIMOUSESTATE, lZ)
+#define DIMOFS_BUTTON0 (FIELD_OFFSET(DIMOUSESTATE, rgbButtons) + 0)
+#define DIMOFS_BUTTON1 (FIELD_OFFSET(DIMOUSESTATE, rgbButtons) + 1)
+#define DIMOFS_BUTTON2 (FIELD_OFFSET(DIMOUSESTATE, rgbButtons) + 2)
+#define DIMOFS_BUTTON3 (FIELD_OFFSET(DIMOUSESTATE, rgbButtons) + 3)
+
+#endif /* DIJ_RINGZERO */
+
+/****************************************************************************
+ *
+ *      Keyboard
+ *
+ ****************************************************************************/
+
+#ifndef DIJ_RINGZERO
+
+/****************************************************************************
+ *
+ *      DirectInput keyboard scan codes
+ *
+ ****************************************************************************/
+
+#define DIK_ESCAPE          0x01
+#define DIK_1               0x02
+#define DIK_2               0x03
+#define DIK_3               0x04
+#define DIK_4               0x05
+#define DIK_5               0x06
+#define DIK_6               0x07
+#define DIK_7               0x08
+#define DIK_8               0x09
+#define DIK_9               0x0A
+#define DIK_0               0x0B
+#define DIK_MINUS           0x0C    /* - on main keyboard */
+#define DIK_EQUALS          0x0D
+#define DIK_BACK            0x0E    /* backspace */
+#define DIK_TAB             0x0F
+#define DIK_Q               0x10
+#define DIK_W               0x11
+#define DIK_E               0x12
+#define DIK_R               0x13
+#define DIK_T               0x14
+#define DIK_Y               0x15
+#define DIK_U               0x16
+#define DIK_I               0x17
+#define DIK_O               0x18
+#define DIK_P               0x19
+#define DIK_LBRACKET        0x1A
+#define DIK_RBRACKET        0x1B
+#define DIK_RETURN          0x1C    /* Enter on main keyboard */
+#define DIK_LCONTROL        0x1D
+#define DIK_A               0x1E
+#define DIK_S               0x1F
+#define DIK_D               0x20
+#define DIK_F               0x21
+#define DIK_G               0x22
+#define DIK_H               0x23
+#define DIK_J               0x24
+#define DIK_K               0x25
+#define DIK_L               0x26
+#define DIK_SEMICOLON       0x27
+#define DIK_APOSTROPHE      0x28
+#define DIK_GRAVE           0x29    /* accent grave */
+#define DIK_LSHIFT          0x2A
+#define DIK_BACKSLASH       0x2B
+#define DIK_Z               0x2C
+#define DIK_X               0x2D
+#define DIK_C               0x2E
+#define DIK_V               0x2F
+#define DIK_B               0x30
+#define DIK_N               0x31
+#define DIK_M               0x32
+#define DIK_COMMA           0x33
+#define DIK_PERIOD          0x34    /* . on main keyboard */
+#define DIK_SLASH           0x35    /* / on main keyboard */
+#define DIK_RSHIFT          0x36
+#define DIK_MULTIPLY        0x37    /* * on numeric keypad */
+#define DIK_LMENU           0x38    /* left Alt */
+#define DIK_SPACE           0x39
+#define DIK_CAPITAL         0x3A
+#define DIK_F1              0x3B
+#define DIK_F2              0x3C
+#define DIK_F3              0x3D
+#define DIK_F4              0x3E
+#define DIK_F5              0x3F
+#define DIK_F6              0x40
+#define DIK_F7              0x41
+#define DIK_F8              0x42
+#define DIK_F9              0x43
+#define DIK_F10             0x44
+#define DIK_NUMLOCK         0x45
+#define DIK_SCROLL          0x46    /* Scroll Lock */
+#define DIK_NUMPAD7         0x47
+#define DIK_NUMPAD8         0x48
+#define DIK_NUMPAD9         0x49
+#define DIK_SUBTRACT        0x4A    /* - on numeric keypad */
+#define DIK_NUMPAD4         0x4B
+#define DIK_NUMPAD5         0x4C
+#define DIK_NUMPAD6         0x4D
+#define DIK_ADD             0x4E    /* + on numeric keypad */
+#define DIK_NUMPAD1         0x4F
+#define DIK_NUMPAD2         0x50
+#define DIK_NUMPAD3         0x51
+#define DIK_NUMPAD0         0x52
+#define DIK_DECIMAL         0x53    /* . on numeric keypad */
+#define DIK_F11             0x57
+#define DIK_F12             0x58
+
+#define DIK_F13             0x64    /*                     (NEC PC98) */
+#define DIK_F14             0x65    /*                     (NEC PC98) */
+#define DIK_F15             0x66    /*                     (NEC PC98) */
+
+#define DIK_KANA            0x70    /* (Japanese keyboard)            */
+#define DIK_CONVERT         0x79    /* (Japanese keyboard)            */
+#define DIK_NOCONVERT       0x7B    /* (Japanese keyboard)            */
+#define DIK_YEN             0x7D    /* (Japanese keyboard)            */
+#define DIK_NUMPADEQUALS    0x8D    /* = on numeric keypad (NEC PC98) */
+#define DIK_CIRCUMFLEX      0x90    /* (Japanese keyboard)            */
+#define DIK_AT              0x91    /*                     (NEC PC98) */
+#define DIK_COLON           0x92    /*                     (NEC PC98) */
+#define DIK_UNDERLINE       0x93    /*                     (NEC PC98) */
+#define DIK_KANJI           0x94    /* (Japanese keyboard)            */
+#define DIK_STOP            0x95    /*                     (NEC PC98) */
+#define DIK_AX              0x96    /*                     (Japan AX) */
+#define DIK_UNLABELED       0x97    /*                        (J3100) */
+#define DIK_NUMPADENTER     0x9C    /* Enter on numeric keypad */
+#define DIK_RCONTROL        0x9D
+#define DIK_NUMPADCOMMA     0xB3    /* , on numeric keypad (NEC PC98) */
+#define DIK_DIVIDE          0xB5    /* / on numeric keypad */
+#define DIK_SYSRQ           0xB7
+#define DIK_RMENU           0xB8    /* right Alt */
+#define DIK_HOME            0xC7    /* Home on arrow keypad */
+#define DIK_UP              0xC8    /* UpArrow on arrow keypad */
+#define DIK_PRIOR           0xC9    /* PgUp on arrow keypad */
+#define DIK_LEFT            0xCB    /* LeftArrow on arrow keypad */
+#define DIK_RIGHT           0xCD    /* RightArrow on arrow keypad */
+#define DIK_END             0xCF    /* End on arrow keypad */
+#define DIK_DOWN            0xD0    /* DownArrow on arrow keypad */
+#define DIK_NEXT            0xD1    /* PgDn on arrow keypad */
+#define DIK_INSERT          0xD2    /* Insert on arrow keypad */
+#define DIK_DELETE          0xD3    /* Delete on arrow keypad */
+#define DIK_LWIN            0xDB    /* Left Windows key */
+#define DIK_RWIN            0xDC    /* Right Windows key */
+#define DIK_APPS            0xDD    /* AppMenu key */
+
+/*
+ *  Alternate names for keys, to facilitate transition from DOS.
+ */
+#define DIK_BACKSPACE       DIK_BACK            /* backspace */
+#define DIK_NUMPADSTAR      DIK_MULTIPLY        /* * on numeric keypad */
+#define DIK_LALT            DIK_LMENU           /* left Alt */
+#define DIK_CAPSLOCK        DIK_CAPITAL         /* CapsLock */
+#define DIK_NUMPADMINUS     DIK_SUBTRACT        /* - on numeric keypad */
+#define DIK_NUMPADPLUS      DIK_ADD             /* + on numeric keypad */
+#define DIK_NUMPADPERIOD    DIK_DECIMAL         /* . on numeric keypad */
+#define DIK_NUMPADSLASH     DIK_DIVIDE          /* / on numeric keypad */
+#define DIK_RALT            DIK_RMENU           /* right Alt */
+#define DIK_UPARROW         DIK_UP              /* UpArrow on arrow keypad */
+#define DIK_PGUP            DIK_PRIOR           /* PgUp on arrow keypad */
+#define DIK_LEFTARROW       DIK_LEFT            /* LeftArrow on arrow keypad */
+#define DIK_RIGHTARROW      DIK_RIGHT           /* RightArrow on arrow keypad */
+#define DIK_DOWNARROW       DIK_DOWN            /* DownArrow on arrow keypad */
+#define DIK_PGDN            DIK_NEXT            /* PgDn on arrow keypad */
+
+#endif /* DIJ_RINGZERO */
+
+/****************************************************************************
+ *
+ *      Joystick
+ *
+ ****************************************************************************/
+
+#ifndef DIJ_RINGZERO
+
+typedef struct DIJOYSTATE {
+    LONG    lX;                     /* x-axis position              */
+    LONG    lY;                     /* y-axis position              */
+    LONG    lZ;                     /* z-axis position              */
+    LONG    lRx;                    /* x-axis rotation              */
+    LONG    lRy;                    /* y-axis rotation              */
+    LONG    lRz;                    /* z-axis rotation              */
+    LONG    rglSlider[2];           /* extra axes positions         */
+    DWORD   rgdwPOV[4];             /* POV directions               */
+    BYTE    rgbButtons[32];         /* 32 buttons                   */
+} DIJOYSTATE, *LPDIJOYSTATE;
+
+typedef struct DIJOYSTATE2 {
+    LONG    lX;                     /* x-axis position              */
+    LONG    lY;                     /* y-axis position              */
+    LONG    lZ;                     /* z-axis position              */
+    LONG    lRx;                    /* x-axis rotation              */
+    LONG    lRy;                    /* y-axis rotation              */
+    LONG    lRz;                    /* z-axis rotation              */
+    LONG    rglSlider[2];           /* extra axes positions         */
+    DWORD   rgdwPOV[4];             /* POV directions               */
+    BYTE    rgbButtons[128];        /* 128 buttons                  */
+    LONG    lVX;                    /* x-axis velocity              */
+    LONG    lVY;                    /* y-axis velocity              */
+    LONG    lVZ;                    /* z-axis velocity              */
+    LONG    lVRx;                   /* x-axis angular velocity      */
+    LONG    lVRy;                   /* y-axis angular velocity      */
+    LONG    lVRz;                   /* z-axis angular velocity      */
+    LONG    rglVSlider[2];          /* extra axes velocities        */
+    LONG    lAX;                    /* x-axis acceleration          */
+    LONG    lAY;                    /* y-axis acceleration          */
+    LONG    lAZ;                    /* z-axis acceleration          */
+    LONG    lARx;                   /* x-axis angular acceleration  */
+    LONG    lARy;                   /* y-axis angular acceleration  */
+    LONG    lARz;                   /* z-axis angular acceleration  */
+    LONG    rglASlider[2];          /* extra axes accelerations     */
+    LONG    lFX;                    /* x-axis force                 */
+    LONG    lFY;                    /* y-axis force                 */
+    LONG    lFZ;                    /* z-axis force                 */
+    LONG    lFRx;                   /* x-axis torque                */
+    LONG    lFRy;                   /* y-axis torque                */
+    LONG    lFRz;                   /* z-axis torque                */
+    LONG    rglFSlider[2];          /* extra axes forces            */
+} DIJOYSTATE2, *LPDIJOYSTATE2;
+
+#define DIJOFS_X            FIELD_OFFSET(DIJOYSTATE, lX)
+#define DIJOFS_Y            FIELD_OFFSET(DIJOYSTATE, lY)
+#define DIJOFS_Z            FIELD_OFFSET(DIJOYSTATE, lZ)
+#define DIJOFS_RX           FIELD_OFFSET(DIJOYSTATE, lRx)
+#define DIJOFS_RY           FIELD_OFFSET(DIJOYSTATE, lRy)
+#define DIJOFS_RZ           FIELD_OFFSET(DIJOYSTATE, lRz)
+#define DIJOFS_SLIDER(n)   (FIELD_OFFSET(DIJOYSTATE, rglSlider) + \
+                                                        (n) * sizeof(LONG))
+#define DIJOFS_POV(n)      (FIELD_OFFSET(DIJOYSTATE, rgdwPOV) + \
+                                                        (n) * sizeof(DWORD))
+#define DIJOFS_BUTTON(n)   (FIELD_OFFSET(DIJOYSTATE, rgbButtons) + (n))
+#define DIJOFS_BUTTON0      DIJOFS_BUTTON(0)
+#define DIJOFS_BUTTON1      DIJOFS_BUTTON(1)
+#define DIJOFS_BUTTON2      DIJOFS_BUTTON(2)
+#define DIJOFS_BUTTON3      DIJOFS_BUTTON(3)
+#define DIJOFS_BUTTON4      DIJOFS_BUTTON(4)
+#define DIJOFS_BUTTON5      DIJOFS_BUTTON(5)
+#define DIJOFS_BUTTON6      DIJOFS_BUTTON(6)
+#define DIJOFS_BUTTON7      DIJOFS_BUTTON(7)
+#define DIJOFS_BUTTON8      DIJOFS_BUTTON(8)
+#define DIJOFS_BUTTON9      DIJOFS_BUTTON(9)
+#define DIJOFS_BUTTON10     DIJOFS_BUTTON(10)
+#define DIJOFS_BUTTON11     DIJOFS_BUTTON(11)
+#define DIJOFS_BUTTON12     DIJOFS_BUTTON(12)
+#define DIJOFS_BUTTON13     DIJOFS_BUTTON(13)
+#define DIJOFS_BUTTON14     DIJOFS_BUTTON(14)
+#define DIJOFS_BUTTON15     DIJOFS_BUTTON(15)
+#define DIJOFS_BUTTON16     DIJOFS_BUTTON(16)
+#define DIJOFS_BUTTON17     DIJOFS_BUTTON(17)
+#define DIJOFS_BUTTON18     DIJOFS_BUTTON(18)
+#define DIJOFS_BUTTON19     DIJOFS_BUTTON(19)
+#define DIJOFS_BUTTON20     DIJOFS_BUTTON(20)
+#define DIJOFS_BUTTON21     DIJOFS_BUTTON(21)
+#define DIJOFS_BUTTON22     DIJOFS_BUTTON(22)
+#define DIJOFS_BUTTON23     DIJOFS_BUTTON(23)
+#define DIJOFS_BUTTON24     DIJOFS_BUTTON(24)
+#define DIJOFS_BUTTON25     DIJOFS_BUTTON(25)
+#define DIJOFS_BUTTON26     DIJOFS_BUTTON(26)
+#define DIJOFS_BUTTON27     DIJOFS_BUTTON(27)
+#define DIJOFS_BUTTON28     DIJOFS_BUTTON(28)
+#define DIJOFS_BUTTON29     DIJOFS_BUTTON(29)
+#define DIJOFS_BUTTON30     DIJOFS_BUTTON(30)
+#define DIJOFS_BUTTON31     DIJOFS_BUTTON(31)
+
+
+#endif /* DIJ_RINGZERO */
+
+/****************************************************************************
+ *
+ *  IDirectInput
+ *
+ ****************************************************************************/
+
+#ifndef DIJ_RINGZERO
+
+#define DIENUM_STOP             0
+#define DIENUM_CONTINUE         1
+
+typedef BOOL (FAR PASCAL * LPDIENUMDEVICESCALLBACKA)(LPCDIDEVICEINSTANCEA, LPVOID);
+typedef BOOL (FAR PASCAL * LPDIENUMDEVICESCALLBACKW)(LPCDIDEVICEINSTANCEW, LPVOID);
+#ifdef UNICODE
+#define LPDIENUMDEVICESCALLBACK  LPDIENUMDEVICESCALLBACKW
+#else
+#define LPDIENUMDEVICESCALLBACK  LPDIENUMDEVICESCALLBACKA
+#endif // !UNICODE
+
+#define DIEDFL_ALLDEVICES       0x00000000
+#define DIEDFL_ATTACHEDONLY     0x00000001
+#if(DIRECTINPUT_VERSION >= 0x0500)
+#define DIEDFL_FORCEFEEDBACK    0x00000100
+#endif /* DIRECTINPUT_VERSION >= 0x0500 */
+
+#undef INTERFACE
+#define INTERFACE IDirectInputW
+
+DECLARE_INTERFACE_(IDirectInputW, IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+
+    /*** IDirectInputW methods ***/
+    STDMETHOD(CreateDevice)(THIS_ REFGUID,LPDIRECTINPUTDEVICEW *,LPUNKNOWN) PURE;
+    STDMETHOD(EnumDevices)(THIS_ DWORD,LPDIENUMDEVICESCALLBACKW,LPVOID,DWORD) PURE;
+    STDMETHOD(GetDeviceStatus)(THIS_ REFGUID) PURE;
+    STDMETHOD(RunControlPanel)(THIS_ HWND,DWORD) PURE;
+    STDMETHOD(Initialize)(THIS_ HINSTANCE,DWORD) PURE;
+};
+
+typedef struct IDirectInputW *LPDIRECTINPUTW;
+
+#undef INTERFACE
+#define INTERFACE IDirectInputA
+
+DECLARE_INTERFACE_(IDirectInputA, IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+
+    /*** IDirectInputA methods ***/
+    STDMETHOD(CreateDevice)(THIS_ REFGUID,LPDIRECTINPUTDEVICEA *,LPUNKNOWN) PURE;
+    STDMETHOD(EnumDevices)(THIS_ DWORD,LPDIENUMDEVICESCALLBACKA,LPVOID,DWORD) PURE;
+    STDMETHOD(GetDeviceStatus)(THIS_ REFGUID) PURE;
+    STDMETHOD(RunControlPanel)(THIS_ HWND,DWORD) PURE;
+    STDMETHOD(Initialize)(THIS_ HINSTANCE,DWORD) PURE;
+};
+
+typedef struct IDirectInputA *LPDIRECTINPUTA;
+
+#ifdef UNICODE
+#define IID_IDirectInput IID_IDirectInputW
+#define IDirectInput IDirectInputW
+#define IDirectInputVtbl IDirectInputWVtbl
+#else
+#define IID_IDirectInput IID_IDirectInputA
+#define IDirectInput IDirectInputA
+#define IDirectInputVtbl IDirectInputAVtbl
+#endif
+typedef struct IDirectInput *LPDIRECTINPUT;
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectInput_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirectInput_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IDirectInput_Release(p) (p)->lpVtbl->Release(p)
+#define IDirectInput_CreateDevice(p,a,b,c) (p)->lpVtbl->CreateDevice(p,a,b,c)
+#define IDirectInput_EnumDevices(p,a,b,c,d) (p)->lpVtbl->EnumDevices(p,a,b,c,d)
+#define IDirectInput_GetDeviceStatus(p,a) (p)->lpVtbl->GetDeviceStatus(p,a)
+#define IDirectInput_RunControlPanel(p,a,b) (p)->lpVtbl->RunControlPanel(p,a,b)
+#define IDirectInput_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b)
+#else
+#define IDirectInput_QueryInterface(p,a,b) (p)->QueryInterface(a,b)
+#define IDirectInput_AddRef(p) (p)->AddRef()
+#define IDirectInput_Release(p) (p)->Release()
+#define IDirectInput_CreateDevice(p,a,b,c) (p)->CreateDevice(a,b,c)
+#define IDirectInput_EnumDevices(p,a,b,c,d) (p)->EnumDevices(a,b,c,d)
+#define IDirectInput_GetDeviceStatus(p,a) (p)->GetDeviceStatus(a)
+#define IDirectInput_RunControlPanel(p,a,b) (p)->RunControlPanel(a,b)
+#define IDirectInput_Initialize(p,a,b) (p)->Initialize(a,b)
+#endif
+
+#undef INTERFACE
+#define INTERFACE IDirectInput2W
+
+DECLARE_INTERFACE_(IDirectInput2W, IDirectInputW)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+
+    /*** IDirectInputW methods ***/
+    STDMETHOD(CreateDevice)(THIS_ REFGUID,LPDIRECTINPUTDEVICEW *,LPUNKNOWN) PURE;
+    STDMETHOD(EnumDevices)(THIS_ DWORD,LPDIENUMDEVICESCALLBACKW,LPVOID,DWORD) PURE;
+    STDMETHOD(GetDeviceStatus)(THIS_ REFGUID) PURE;
+    STDMETHOD(RunControlPanel)(THIS_ HWND,DWORD) PURE;
+    STDMETHOD(Initialize)(THIS_ HINSTANCE,DWORD) PURE;
+
+    /*** IDirectInput2W methods ***/
+    STDMETHOD(FindDevice)(THIS_ REFGUID,LPCWSTR,LPGUID) PURE;
+};
+
+typedef struct IDirectInput2W *LPDIRECTINPUT2W;
+
+#undef INTERFACE
+#define INTERFACE IDirectInput2A
+
+DECLARE_INTERFACE_(IDirectInput2A, IDirectInputA)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+
+    /*** IDirectInputA methods ***/
+    STDMETHOD(CreateDevice)(THIS_ REFGUID,LPDIRECTINPUTDEVICEA *,LPUNKNOWN) PURE;
+    STDMETHOD(EnumDevices)(THIS_ DWORD,LPDIENUMDEVICESCALLBACKA,LPVOID,DWORD) PURE;
+    STDMETHOD(GetDeviceStatus)(THIS_ REFGUID) PURE;
+    STDMETHOD(RunControlPanel)(THIS_ HWND,DWORD) PURE;
+    STDMETHOD(Initialize)(THIS_ HINSTANCE,DWORD) PURE;
+
+    /*** IDirectInput2A methods ***/
+    STDMETHOD(FindDevice)(THIS_ REFGUID,LPCSTR,LPGUID) PURE;
+};
+
+typedef struct IDirectInput2A *LPDIRECTINPUT2A;
+
+#ifdef UNICODE
+#define IID_IDirectInput2 IID_IDirectInput2W
+#define IDirectInput2 IDirectInput2W
+#define IDirectInput2Vtbl IDirectInput2WVtbl
+#else
+#define IID_IDirectInput2 IID_IDirectInput2A
+#define IDirectInput2 IDirectInput2A
+#define IDirectInput2Vtbl IDirectInput2AVtbl
+#endif
+typedef struct IDirectInput2 *LPDIRECTINPUT2;
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectInput2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirectInput2_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IDirectInput2_Release(p) (p)->lpVtbl->Release(p)
+#define IDirectInput2_CreateDevice(p,a,b,c) (p)->lpVtbl->CreateDevice(p,a,b,c)
+#define IDirectInput2_EnumDevices(p,a,b,c,d) (p)->lpVtbl->EnumDevices(p,a,b,c,d)
+#define IDirectInput2_GetDeviceStatus(p,a) (p)->lpVtbl->GetDeviceStatus(p,a)
+#define IDirectInput2_RunControlPanel(p,a,b) (p)->lpVtbl->RunControlPanel(p,a,b)
+#define IDirectInput2_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b)
+#define IDirectInput2_FindDevice(p,a,b,c) (p)->lpVtbl->FindDevice(p,a,b,c)
+#else
+#define IDirectInput2_QueryInterface(p,a,b) (p)->QueryInterface(a,b)
+#define IDirectInput2_AddRef(p) (p)->AddRef()
+#define IDirectInput2_Release(p) (p)->Release()
+#define IDirectInput2_CreateDevice(p,a,b,c) (p)->CreateDevice(a,b,c)
+#define IDirectInput2_EnumDevices(p,a,b,c,d) (p)->EnumDevices(a,b,c,d)
+#define IDirectInput2_GetDeviceStatus(p,a) (p)->GetDeviceStatus(a)
+#define IDirectInput2_RunControlPanel(p,a,b) (p)->RunControlPanel(a,b)
+#define IDirectInput2_Initialize(p,a,b) (p)->Initialize(a,b)
+#define IDirectInput2_FindDevice(p,a,b,c) (p)->FindDevice(a,b,c)
+#endif
+
+extern HRESULT WINAPI DirectInputCreateA(HINSTANCE hinst, DWORD dwVersion, LPDIRECTINPUTA *ppDI, LPUNKNOWN punkOuter);
+extern HRESULT WINAPI DirectInputCreateW(HINSTANCE hinst, DWORD dwVersion, LPDIRECTINPUTW *ppDI, LPUNKNOWN punkOuter);
+#ifdef UNICODE
+#define DirectInputCreate  DirectInputCreateW
+#else
+#define DirectInputCreate  DirectInputCreateA
+#endif // !UNICODE
+
+#endif /* DIJ_RINGZERO */
+
+
+/****************************************************************************
+ *
+ *  Return Codes
+ *
+ ****************************************************************************/
+
+/*
+ *  The operation completed successfully.
+ */
+#define DI_OK                           S_OK
+
+/*
+ *  The device exists but is not currently attached.
+ */
+#define DI_NOTATTACHED                  S_FALSE
+
+/*
+ *  The device buffer overflowed.  Some input was lost.
+ */
+#define DI_BUFFEROVERFLOW               S_FALSE
+
+/*
+ *  The change in device properties had no effect.
+ */
+#define DI_PROPNOEFFECT                 S_FALSE
+
+/*
+ *  The operation had no effect.
+ */
+#define DI_NOEFFECT                     S_FALSE
+
+/*
+ *  The device is a polled device.  As a result, device buffering
+ *  will not collect any data and event notifications will not be
+ *  signalled until GetDeviceState is called.
+ */
+#define DI_POLLEDDEVICE                 ((HRESULT)0x00000002L)
+
+/*
+ *  The parameters of the effect were successfully updated by
+ *  IDirectInputEffect::SetParameters, but the effect was not
+ *  downloaded because the device is not exclusively acquired
+ *  or because the DIEP_NODOWNLOAD flag was passed.
+ */
+#define DI_DOWNLOADSKIPPED              ((HRESULT)0x00000003L)
+
+/*
+ *  The parameters of the effect were successfully updated by
+ *  IDirectInputEffect::SetParameters, but in order to change
+ *  the parameters, the effect needed to be restarted.
+ */
+#define DI_EFFECTRESTARTED              ((HRESULT)0x00000004L)
+
+/*
+ *  The parameters of the effect were successfully updated by
+ *  IDirectInputEffect::SetParameters, but some of them were
+ *  beyond the capabilities of the device and were truncated.
+ */
+#define DI_TRUNCATED                    ((HRESULT)0x00000008L)
+
+/*
+ *  Equal to DI_EFFECTRESTARTED | DI_TRUNCATED.
+ */
+#define DI_TRUNCATEDANDRESTARTED        ((HRESULT)0x0000000CL)
+
+/*
+ *  The application requires a newer version of DirectInput.
+ */
+#define DIERR_OLDDIRECTINPUTVERSION     \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_OLD_WIN_VERSION)
+
+/*
+ *  The application was written for an unsupported prerelease version
+ *  of DirectInput.
+ */
+#define DIERR_BETADIRECTINPUTVERSION    \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_RMODE_APP)
+
+/*
+ *  The object could not be created due to an incompatible driver version
+ *  or mismatched or incomplete driver components.
+ */
+#define DIERR_BADDRIVERVER              \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_BAD_DRIVER_LEVEL)
+
+/*
+ * The device or device instance or effect is not registered with DirectInput.
+ */
+#define DIERR_DEVICENOTREG              REGDB_E_CLASSNOTREG
+
+/*
+ * The requested object does not exist.
+ */
+#define DIERR_NOTFOUND                  \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_FILE_NOT_FOUND)
+
+/*
+ * The requested object does not exist.
+ */
+#define DIERR_OBJECTNOTFOUND            \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_FILE_NOT_FOUND)
+
+/*
+ * An invalid parameter was passed to the returning function,
+ * or the object was not in a state that admitted the function
+ * to be called.
+ */
+#define DIERR_INVALIDPARAM              E_INVALIDARG
+
+/*
+ * The specified interface is not supported by the object
+ */
+#define DIERR_NOINTERFACE               E_NOINTERFACE
+
+/*
+ * An undetermined error occured inside the DInput subsystem
+ */
+#define DIERR_GENERIC                   E_FAIL
+
+/*
+ * The DInput subsystem couldn't allocate sufficient memory to complete the
+ * caller's request.
+ */
+#define DIERR_OUTOFMEMORY               E_OUTOFMEMORY
+
+/*
+ * The function called is not supported at this time
+ */
+#define DIERR_UNSUPPORTED               E_NOTIMPL
+
+/*
+ * This object has not been initialized
+ */
+#define DIERR_NOTINITIALIZED            \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_READY)
+
+/*
+ * This object is already initialized
+ */
+#define DIERR_ALREADYINITIALIZED        \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_ALREADY_INITIALIZED)
+
+/*
+ * This object does not support aggregation
+ */
+#define DIERR_NOAGGREGATION             CLASS_E_NOAGGREGATION
+
+/*
+ * Another app has a higher priority level, preventing this call from
+ * succeeding.
+ */
+#define DIERR_OTHERAPPHASPRIO           E_ACCESSDENIED
+
+/*
+ * Access to the device has been lost.  It must be re-acquired.
+ */
+#define DIERR_INPUTLOST                 \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_READ_FAULT)
+
+/*
+ * The operation cannot be performed while the device is acquired.
+ */
+#define DIERR_ACQUIRED                  \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_BUSY)
+
+/*
+ * The operation cannot be performed unless the device is acquired.
+ */
+#define DIERR_NOTACQUIRED               \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_INVALID_ACCESS)
+
+/*
+ * The specified property cannot be changed.
+ */
+#define DIERR_READONLY                  E_ACCESSDENIED
+
+/*
+ * The device already has an event notification associated with it.
+ */
+#define DIERR_HANDLEEXISTS              E_ACCESSDENIED
+
+/*
+ * Data is not yet available.
+ */
+#ifndef E_PENDING
+#define E_PENDING                       0x80070007L
+#endif
+
+/*
+ * Unable to IDirectInputJoyConfig_Acquire because the user
+ * does not have sufficient privileges to change the joystick
+ * configuration.
+ */
+#define DIERR_INSUFFICIENTPRIVS         0x80040200L
+
+/*
+ * The device is full.
+ */
+#define DIERR_DEVICEFULL                0x80040201L
+
+/*
+ * Not all the requested information fit into the buffer.
+ */
+#define DIERR_MOREDATA                  0x80040202L
+
+/*
+ * The effect is not downloaded.
+ */
+#define DIERR_NOTDOWNLOADED             0x80040203L
+
+/*
+ *  The device cannot be reinitialized because there are still effects
+ *  attached to it.
+ */
+#define DIERR_HASEFFECTS                0x80040204L
+
+/*
+ *  The operation cannot be performed unless the device is acquired
+ *  in DISCL_EXCLUSIVE mode.
+ */
+#define DIERR_NOTEXCLUSIVEACQUIRED      0x80040205L
+
+/*
+ *  The effect could not be downloaded because essential information
+ *  is missing.  For example, no axes have been associated with the
+ *  effect, or no type-specific information has been created.
+ */
+#define DIERR_INCOMPLETEEFFECT          0x80040206L
+
+/*
+ *  Attempted to read buffered device data from a device that is
+ *  not buffered.
+ */
+#define DIERR_NOTBUFFERED               0x80040207L
+
+/*
+ *  An attempt was made to modify parameters of an effect while it is
+ *  playing.  Not all hardware devices support altering the parameters
+ *  of an effect while it is playing.
+ */
+#define DIERR_EFFECTPLAYING             0x80040208L
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif  /* __DINPUT_INCLUDED__ */
+
+/****************************************************************************
+ *
+ *  Definitions for non-IDirectInput (VJoyD) features defined more recently
+ *  than the current sdk files
+ *
+ ****************************************************************************/
+
+#ifdef _INC_MMSYSTEM
+#ifndef MMNOJOY
+
+#ifndef __VJOYDX_INCLUDED__
+#define __VJOYDX_INCLUDED__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Flag to indicate that the dwReserved2 field of the JOYINFOEX structure
+ * contains mini-driver specific data to be passed by VJoyD to the mini-
+ * driver instead of doing a poll.
+ */
+#define JOY_PASSDRIVERDATA          0x10000000l
+
+/*
+ * Informs the joystick driver that the configuration has been changed
+ * and should be reloaded from the registery.
+ * dwFlags is reserved and should be set to zero
+ */
+WINMMAPI MMRESULT WINAPI joyConfigChanged( DWORD dwFlags );
+
+/*
+ * Hardware Setting indicating that the device is a headtracker
+ */
+#define JOY_HWS_ISHEADTRACKER       0x02000000l
+
+/*
+ * Hardware Setting indicating that the VxD is used to replace
+ * the standard analog polling
+ */
+#define JOY_HWS_ISGAMEPORTDRIVER    0x04000000l
+
+/*
+ * Hardware Setting indicating that the driver needs a standard
+ * gameport in order to communicate with the device.
+ */
+#define JOY_HWS_ISANALOGPORTDRIVER  0x08000000l 
+
+/*
+ * Hardware Setting indicating that VJoyD should not load this 
+ * driver, it will be loaded externally and will register with
+ * VJoyD of it's own accord.
+ */
+#define JOY_HWS_AUTOLOAD            0x10000000l
+
+/*
+ * Hardware Setting indicating that the driver acquires any 
+ * resources needed without needing a devnode through VJoyD.
+ */
+#define JOY_HWS_NODEVNODE           0x20000000l
+
+/*
+ * Hardware Setting indicating that the VxD can be used as
+ * a port 201h emulator.
+ */
+#define JOY_HWS_ISGAMEPORTEMULATOR  0x40000000l
+
+
+/*
+ * Usage Setting indicating that the settings are volatile and
+ * should be removed if still present on a reboot.
+ */
+#define JOY_US_VOLATILE             0x00000008L
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif  /* __VJOYDX_INCLUDED__ */
+
+#endif  /* not MMNOJOY */
+#endif  /* _INC_MMSYSTEM */
+
+/****************************************************************************
+ *
+ *  Definitions for non-IDirectInput (VJoyD) features defined more recently
+ *  than the current ddk files
+ *
+ ****************************************************************************/
+
+#ifndef DIJ_RINGZERO
+
+#ifdef _INC_MMDDK
+#ifndef MMNOJOYDEV
+
+#ifndef __VJOYDXD_INCLUDED__
+#define __VJOYDXD_INCLUDED__
+/*
+ * Poll type in which the do_other field of the JOYOEMPOLLDATA
+ * structure contains mini-driver specific data passed from an app.
+ */
+#define JOY_OEMPOLL_PASSDRIVERDATA  7
+
+#endif  /* __VJOYDXD_INCLUDED__ */
+
+#endif  /* not MMNOJOYDEV */
+#endif  /* _INC_MMDDK */
+
+#endif /* DIJ_RINGZERO */
diff --git a/3rdparty/dx5/inc/dplay.h b/3rdparty/dx5/inc/dplay.h
new file mode 100644
index 00000000..f5b6bb5c
--- /dev/null
+++ b/3rdparty/dx5/inc/dplay.h
@@ -0,0 +1,1710 @@
+/*==========================================================================;
+ *
+ *  Copyright (C) 1994-1997 Microsoft Corporation.  All Rights Reserved.
+ *
+ *  File:       dplay.h
+ *  Content:    DirectPlay include file
+ *
+ ***************************************************************************/
+
+#ifndef __DPLAY_INCLUDED__
+#define __DPLAY_INCLUDED__
+
+#include <ole2.h>       // for DECLARE_INTERFACE and HRESULT
+
+#define _FACDP  0x877
+#define MAKE_DPHRESULT( code )    MAKE_HRESULT( 1, _FACDP, code )
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * GUIDS used by DirectPlay objects
+ */
+DEFINE_GUID(IID_IDirectPlay2, 0x2b74f7c0, 0x9154, 0x11cf, 0xa9, 0xcd, 0x0, 0xaa, 0x0, 0x68, 0x86, 0xe3);
+DEFINE_GUID(IID_IDirectPlay2A,0x9d460580, 0xa822, 0x11cf, 0x96, 0xc, 0x0, 0x80, 0xc7, 0x53, 0x4e, 0x82);
+
+DEFINE_GUID(IID_IDirectPlay3, 0x133efe40, 0x32dc, 0x11d0, 0x9c, 0xfb, 0x0, 0xa0, 0xc9, 0xa, 0x43, 0xcb);
+DEFINE_GUID(IID_IDirectPlay3A,0x133efe41, 0x32dc, 0x11d0, 0x9c, 0xfb, 0x0, 0xa0, 0xc9, 0xa, 0x43, 0xcb);
+
+// {D1EB6D20-8923-11d0-9D97-00A0C90A43CB}
+DEFINE_GUID(CLSID_DirectPlay,0xd1eb6d20, 0x8923, 0x11d0, 0x9d, 0x97, 0x0, 0xa0, 0xc9, 0xa, 0x43, 0xcb);
+
+/*
+ * GUIDS used by Service Providers shipped with DirectPlay
+ * Use these to identify Service Provider returned by EnumConnections
+ */
+
+// GUID for IPX service provider
+// {685BC400-9D2C-11cf-A9CD-00AA006886E3}
+DEFINE_GUID(DPSPGUID_IPX, 
+0x685bc400, 0x9d2c, 0x11cf, 0xa9, 0xcd, 0x0, 0xaa, 0x0, 0x68, 0x86, 0xe3);
+
+// GUID for TCP/IP service provider
+// 36E95EE0-8577-11cf-960C-0080C7534E82
+DEFINE_GUID(DPSPGUID_TCPIP,
+0x36E95EE0, 0x8577, 0x11cf, 0x96, 0xc, 0x0, 0x80, 0xc7, 0x53, 0x4e, 0x82);
+
+// GUID for Serial service provider
+// {0F1D6860-88D9-11cf-9C4E-00A0C905425E}
+DEFINE_GUID(DPSPGUID_SERIAL,						
+0xf1d6860, 0x88d9, 0x11cf, 0x9c, 0x4e, 0x0, 0xa0, 0xc9, 0x5, 0x42, 0x5e);
+
+// GUID for Modem service provider
+// {44EAA760-CB68-11cf-9C4E-00A0C905425E}
+DEFINE_GUID(DPSPGUID_MODEM,
+0x44eaa760, 0xcb68, 0x11cf, 0x9c, 0x4e, 0x0, 0xa0, 0xc9, 0x5, 0x42, 0x5e);
+
+/****************************************************************************
+ *
+ * DirectPlay Structures
+ *
+ * Various structures used to invoke DirectPlay.
+ *
+ ****************************************************************************/
+
+#ifndef IDIRECTPLAY2_OR_GREATER
+typedef struct IDirectPlay        FAR *LPDIRECTPLAY;
+#else
+typedef struct IUnknown           FAR *LPDIRECTPLAY;
+#endif
+
+typedef struct IDirectPlay2       FAR *LPDIRECTPLAY2;
+typedef struct IDirectPlay2       FAR *LPDIRECTPLAY2A;
+typedef struct IDirectPlay2       IDirectPlay2A;
+
+typedef struct IDirectPlay3       FAR *LPDIRECTPLAY3;
+typedef struct IDirectPlay3       FAR *LPDIRECTPLAY3A;
+typedef struct IDirectPlay3       IDirectPlay3A;
+
+/*
+ * DPID
+ * DirectPlay player and group ID
+ */
+typedef DWORD DPID, FAR *LPDPID;
+
+/*
+ * DPID that system messages come from
+ */
+#define DPID_SYSMSG         0
+
+/*
+ * DPID representing all players in the session
+ */
+#define DPID_ALLPLAYERS     0
+
+/*
+ * DPID representing the server player
+ */
+#define DPID_SERVERPLAYER	1
+
+/*
+ * The player ID is unknown (used with e.g. DPSESSION_NOMESSAGEID)
+ */
+#define DPID_UNKNOWN		0xFFFFFFFF
+
+/*
+ * DPCAPS
+ * Used to obtain the capabilities of a DirectPlay object
+ */
+typedef struct
+{
+    DWORD dwSize;               // Size of structure, in bytes
+    DWORD dwFlags;              // DPCAPS_xxx flags
+    DWORD dwMaxBufferSize;      // Maximum message size, in bytes,  for this service provider
+    DWORD dwMaxQueueSize;       // Obsolete. 
+    DWORD dwMaxPlayers;         // Maximum players/groups (local + remote)
+    DWORD dwHundredBaud;        // Bandwidth in 100 bits per second units; 
+                                // i.e. 24 is 2400, 96 is 9600, etc.
+    DWORD dwLatency;            // Estimated latency; 0 = unknown
+    DWORD dwMaxLocalPlayers;    // Maximum # of locally created players allowed
+    DWORD dwHeaderLength;       // Maximum header length, in bytes, on messages
+                                // added by the service provider
+    DWORD dwTimeout;            // Service provider's suggested timeout value
+                                // This is how long DirectPlay will wait for 
+                                // responses to system messages
+} DPCAPS, FAR *LPDPCAPS;
+
+/*
+ * This DirectPlay object is the session host.  If the host exits the
+ * session, another application will become the host and receive a
+ * DPSYS_HOST system message.
+ */
+#define DPCAPS_ISHOST               0x00000002
+
+/*
+ * The service provider bound to this DirectPlay object can optimize
+ * group messaging.
+ */
+#define DPCAPS_GROUPOPTIMIZED       0x00000008
+
+/*
+ * The service provider bound to this DirectPlay object can optimize
+ * keep alives (see DPSESSION_KEEPALIVE)
+ */
+#define DPCAPS_KEEPALIVEOPTIMIZED   0x00000010
+
+/*
+ * The service provider bound to this DirectPlay object can optimize
+ * guaranteed message delivery.
+ */
+#define DPCAPS_GUARANTEEDOPTIMIZED  0x00000020
+
+/*
+ * This DirectPlay object supports guaranteed message delivery.
+ */
+#define DPCAPS_GUARANTEEDSUPPORTED  0x00000040
+
+/*
+ * This DirectPlay object supports digital signing of messages.
+ */
+#define DPCAPS_SIGNINGSUPPORTED     0x00000080
+
+/*
+ * This DirectPlay object supports encryption of messages.
+ */
+#define DPCAPS_ENCRYPTIONSUPPORTED  0x00000100
+
+
+/*
+ * DPSESSIONDESC2
+ * Used to describe the properties of a DirectPlay
+ * session instance
+ */
+typedef struct
+{
+    DWORD   dwSize;             // Size of structure
+    DWORD   dwFlags;            // DPSESSION_xxx flags
+    GUID    guidInstance;       // ID for the session instance
+    GUID    guidApplication;    // GUID of the DirectPlay application.
+                                // GUID_NULL for all applications.
+    DWORD   dwMaxPlayers;       // Maximum # players allowed in session
+    DWORD   dwCurrentPlayers;   // Current # players in session (read only)
+    union
+    {                           // Name of the session
+        LPWSTR  lpszSessionName;    // Unicode
+        LPSTR   lpszSessionNameA;   // ANSI
+    };
+    union
+    {                           // Password of the session (optional)
+        LPWSTR  lpszPassword;       // Unicode
+        LPSTR   lpszPasswordA;      // ANSI
+    };
+    DWORD   dwReserved1;        // Reserved for future MS use.
+    DWORD   dwReserved2;
+    DWORD   dwUser1;            // For use by the application
+    DWORD   dwUser2;
+    DWORD   dwUser3;
+    DWORD   dwUser4;
+} DPSESSIONDESC2, FAR *LPDPSESSIONDESC2;
+
+/*
+ * LPCDPSESSIONDESC2
+ * A constant pointer to DPSESSIONDESC2
+ */
+typedef const DPSESSIONDESC2 FAR *LPCDPSESSIONDESC2;
+ 
+/*
+ * Applications cannot create new players in this session.
+ */
+#define DPSESSION_NEWPLAYERSDISABLED    0x00000001 
+
+/*
+ * If the DirectPlay object that created the session, the host,
+ * quits, then the host will attempt to migrate to another
+ * DirectPlay object so that new players can continue to be created
+ * and new applications can join the session.
+ */
+#define DPSESSION_MIGRATEHOST           0x00000004
+
+/*
+ * This flag tells DirectPlay not to set the idPlayerTo and idPlayerFrom 
+ * fields in player messages.  This cuts two DWORD's off the message 
+ * overhead.
+ */
+#define DPSESSION_NOMESSAGEID           0x00000008
+
+
+/*
+ * This flag tells DirectPlay to not allow any new applications to
+ * join the session.  Applications already in the session can still
+ * create new players.
+ */
+#define DPSESSION_JOINDISABLED          0x00000020
+
+/*
+ * This flag tells DirectPlay to detect when remote players 
+ * exit abnormally (e.g. their computer or modem gets unplugged)
+ */
+#define DPSESSION_KEEPALIVE             0x00000040
+
+/*
+ * This flag tells DirectPlay not to send a message to all players
+ * when a players remote data changes
+ */
+#define DPSESSION_NODATAMESSAGES        0x00000080
+
+/*
+ * This flag indicates that the session belongs to a secure server
+ * and needs user authentication
+ */
+#define DPSESSION_SECURESERVER          0x00000100
+
+/*
+ * This flag indicates that the session is private and requirs a password
+ * for EnumSessions as well as Open.
+ */
+#define DPSESSION_PRIVATE               0x00000200
+
+/*
+ * This flag indicates that the session requires a password for joining.
+ */
+#define DPSESSION_PASSWORDREQUIRED      0x00000400
+
+/*
+ * This flag tells DirectPlay to route all messages through the server
+ */
+#define DPSESSION_MULTICASTSERVER		0x00000800
+
+/*
+ * This flag tells DirectPlay to only download information about the
+ * DPPLAYER_SERVERPLAYER.  
+ */
+#define DPSESSION_CLIENTSERVER			0x00001000
+
+/*
+ * DPNAME
+ * Used to hold the name of a DirectPlay entity
+ * like a player or a group
+ */
+typedef struct 
+{
+    DWORD   dwSize;             // Size of structure
+    DWORD   dwFlags;            // Not used. Must be zero.
+    union
+    {                           // The short or friendly name
+        LPWSTR  lpszShortName;  // Unicode
+        LPSTR   lpszShortNameA; // ANSI
+    };
+    union
+    {                           // The long or formal name
+        LPWSTR  lpszLongName;   // Unicode
+        LPSTR   lpszLongNameA;  // ANSI
+    };
+
+} DPNAME, FAR *LPDPNAME;
+
+/*
+ * LPCDPNAME
+ * A constant pointer to DPNAME
+ */
+typedef const DPNAME FAR *LPCDPNAME;
+
+/*
+ * DPCREDENTIALS
+ * Used to hold the user name and password of a DirectPlay user
+ */
+typedef struct 
+{
+    DWORD dwSize;               // Size of structure
+    DWORD dwFlags;              // Not used. Must be zero.
+    union
+    {                           // User name of the account
+        LPWSTR  lpszUsername;   // Unicode
+        LPSTR   lpszUsernameA;  // ANSI
+    };    
+    union
+    {                           // Password of the account
+        LPWSTR  lpszPassword;   // Unicode
+        LPSTR   lpszPasswordA;  // ANSI
+    };    
+    union
+    {                           // Domain name of the account
+        LPWSTR  lpszDomain;     // Unicode
+        LPSTR   lpszDomainA;    // ANSI
+    };    
+} DPCREDENTIALS, FAR *LPDPCREDENTIALS;
+
+typedef const DPCREDENTIALS FAR *LPCDPCREDENTIALS;
+
+/*
+ * DPSECURITYDESC
+ * Used to describe the security properties of a DirectPlay
+ * session instance
+ */
+typedef struct 
+{
+    DWORD dwSize;                   // Size of structure
+    DWORD dwFlags;                  // Not used. Must be zero.
+    union
+    {                               // SSPI provider name
+        LPWSTR  lpszSSPIProvider;   // Unicode
+        LPSTR   lpszSSPIProviderA;  // ANSI
+    };
+    union
+    {                               // CAPI provider name
+        LPWSTR lpszCAPIProvider;    // Unicode
+        LPSTR  lpszCAPIProviderA;   // ANSI
+    };
+    DWORD dwCAPIProviderType;       // Crypto Service Provider type
+    DWORD dwEncryptionAlgorithm;    // Encryption Algorithm type
+} DPSECURITYDESC, FAR *LPDPSECURITYDESC;
+
+typedef const DPSECURITYDESC FAR *LPCDPSECURITYDESC;
+
+/*
+ * DPACCOUNTDESC
+ * Used to describe a user membership account
+ */
+typedef struct 
+{
+    DWORD dwSize;                   // Size of structure
+    DWORD dwFlags;                  // Not used. Must be zero.
+    union
+    {                               // Account identifier
+        LPWSTR  lpszAccountID;      // Unicode
+        LPSTR   lpszAccountIDA;     // ANSI
+    };
+} DPACCOUNTDESC, FAR *LPDPACCOUNTDESC;
+
+typedef const DPACCOUNTDESC FAR *LPCDPACCOUNTDESC;
+
+/*
+ * LPCGUID
+ * A constant pointer to a guid
+ */
+typedef const GUID FAR *LPCGUID;
+
+/*
+ * DPLCONNECTION
+ * Used to hold all in the informaion needed to connect
+ * an application to a session or create a session
+ */
+typedef struct
+{
+    DWORD               dwSize;             // Size of this structure
+    DWORD               dwFlags;            // Flags specific to this structure
+    LPDPSESSIONDESC2    lpSessionDesc;      // Pointer to session desc to use on connect
+    LPDPNAME            lpPlayerName;       // Pointer to Player name structure
+    GUID                guidSP;             // GUID of the DPlay SP to use
+    LPVOID              lpAddress;          // Address for service provider
+    DWORD               dwAddressSize;      // Size of address data
+} DPLCONNECTION, FAR *LPDPLCONNECTION;
+
+/*
+ * LPCDPLCONNECTION
+ * A constant pointer to DPLCONNECTION
+ */
+typedef const DPLCONNECTION FAR *LPCDPLCONNECTION;
+
+/*
+ * DPCHAT
+ * Used to hold the a DirectPlay chat message
+ */
+typedef struct
+{
+    DWORD               dwSize;
+    DWORD               dwFlags;
+    union
+    {                          // Message string
+        LPWSTR  lpszMessage;   // Unicode
+        LPSTR   lpszMessageA;  // ANSI
+    };    
+} DPCHAT, FAR * LPDPCHAT;
+
+/****************************************************************************
+ *
+ * Prototypes for DirectPlay callback functions
+ *
+ ****************************************************************************/
+
+/*
+ * Callback for IDirectPlay2::EnumSessions
+ */
+typedef BOOL (FAR PASCAL * LPDPENUMSESSIONSCALLBACK2)(
+    LPCDPSESSIONDESC2   lpThisSD,
+    LPDWORD             lpdwTimeOut,
+    DWORD               dwFlags,
+    LPVOID              lpContext );
+
+/*
+ * This flag is set on the EnumSessions callback dwFlags parameter when
+ * the time out has occurred. There will be no session data for this 
+ * callback. If *lpdwTimeOut is set to a non-zero value and the 
+ * EnumSessionsCallback function returns TRUE then EnumSessions will 
+ * continue waiting until the next timeout occurs. Timeouts are in 
+ * milliseconds.
+ */
+#define DPESC_TIMEDOUT          0x00000001
+
+
+/*
+ * Callback for IDirectPlay2::EnumPlayers
+ *              IDirectPlay2::EnumGroups
+ *              IDirectPlay2::EnumGroupPlayers
+ */
+typedef BOOL (FAR PASCAL *LPDPENUMPLAYERSCALLBACK2)(
+    DPID            dpId,
+    DWORD           dwPlayerType,
+    LPCDPNAME       lpName,
+    DWORD           dwFlags,
+    LPVOID          lpContext );
+
+
+/*
+ * Unicode callback for DirectPlayEnumerate
+ * This callback prototype will be used if compiling
+ * for Unicode strings
+ */
+typedef BOOL (FAR PASCAL * LPDPENUMDPCALLBACK)(
+    LPGUID      lpguidSP,
+    LPWSTR      lpSPName,
+    DWORD       dwMajorVersion,
+    DWORD       dwMinorVersion,
+    LPVOID      lpContext);
+
+/*
+ * ANSI callback for DirectPlayEnumerate
+ * This callback prototype will be used if compiling
+ * for ANSI strings
+ */
+typedef BOOL (FAR PASCAL * LPDPENUMDPCALLBACKA)(
+    LPGUID      lpguidSP,
+    LPSTR       lpSPName,
+    DWORD       dwMajorVersion,     
+    DWORD       dwMinorVersion,
+    LPVOID      lpContext);
+
+/*
+ * Callback for IDirectPlay3(A)::EnumConnections
+ */
+typedef BOOL (FAR PASCAL * LPDPENUMCONNECTIONSCALLBACK)(
+    LPCGUID     lpguidSP,
+	LPVOID		lpConnection,
+	DWORD		dwConnectionSize,
+    LPCDPNAME   lpName,
+	DWORD 		dwFlags,
+	LPVOID 		lpContext);
+
+
+/*
+ * API's
+ */
+
+#ifdef UNICODE
+#define DirectPlayEnumerate     DirectPlayEnumerateW
+#else
+#define DirectPlayEnumerate     DirectPlayEnumerateA
+#endif // UNICODE
+
+extern HRESULT WINAPI DirectPlayEnumerateA( LPDPENUMDPCALLBACKA, LPVOID );
+extern HRESULT WINAPI DirectPlayEnumerateW( LPDPENUMDPCALLBACK, LPVOID );
+extern HRESULT WINAPI DirectPlayCreate( LPGUID lpGUID, LPDIRECTPLAY *lplpDP, IUnknown *pUnk);
+
+/****************************************************************************
+ *
+ * IDirectPlay2 (and IDirectPlay2A) Interface
+ *
+ ****************************************************************************/
+
+#undef INTERFACE
+#define INTERFACE IDirectPlay2
+DECLARE_INTERFACE_( IDirectPlay2, IUnknown )
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface)       (THIS_ REFIID riid, LPVOID * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef)        (THIS)  PURE;
+    STDMETHOD_(ULONG,Release)       (THIS) PURE;
+    /*** IDirectPlay2 methods ***/
+    STDMETHOD(AddPlayerToGroup)     (THIS_ DPID, DPID) PURE;
+    STDMETHOD(Close)                (THIS) PURE;
+    STDMETHOD(CreateGroup)          (THIS_ LPDPID,LPDPNAME,LPVOID,DWORD,DWORD) PURE;
+    STDMETHOD(CreatePlayer)         (THIS_ LPDPID,LPDPNAME,HANDLE,LPVOID,DWORD,DWORD) PURE;
+    STDMETHOD(DeletePlayerFromGroup)(THIS_ DPID,DPID) PURE;
+    STDMETHOD(DestroyGroup)         (THIS_ DPID) PURE;
+    STDMETHOD(DestroyPlayer)        (THIS_ DPID) PURE;
+    STDMETHOD(EnumGroupPlayers)     (THIS_ DPID,LPGUID,LPDPENUMPLAYERSCALLBACK2,LPVOID,DWORD) PURE;
+    STDMETHOD(EnumGroups)           (THIS_ LPGUID,LPDPENUMPLAYERSCALLBACK2,LPVOID,DWORD) PURE;
+    STDMETHOD(EnumPlayers)          (THIS_ LPGUID,LPDPENUMPLAYERSCALLBACK2,LPVOID,DWORD) PURE;
+    STDMETHOD(EnumSessions)         (THIS_ LPDPSESSIONDESC2,DWORD,LPDPENUMSESSIONSCALLBACK2,LPVOID,DWORD) PURE;
+    STDMETHOD(GetCaps)              (THIS_ LPDPCAPS,DWORD) PURE;
+    STDMETHOD(GetGroupData)         (THIS_ DPID,LPVOID,LPDWORD,DWORD) PURE;
+    STDMETHOD(GetGroupName)         (THIS_ DPID,LPVOID,LPDWORD) PURE;
+    STDMETHOD(GetMessageCount)      (THIS_ DPID, LPDWORD) PURE;
+    STDMETHOD(GetPlayerAddress)     (THIS_ DPID,LPVOID,LPDWORD) PURE;
+    STDMETHOD(GetPlayerCaps)        (THIS_ DPID,LPDPCAPS,DWORD) PURE;
+    STDMETHOD(GetPlayerData)        (THIS_ DPID,LPVOID,LPDWORD,DWORD) PURE;
+    STDMETHOD(GetPlayerName)        (THIS_ DPID,LPVOID,LPDWORD) PURE;
+    STDMETHOD(GetSessionDesc)       (THIS_ LPVOID,LPDWORD) PURE;
+    STDMETHOD(Initialize)           (THIS_ LPGUID) PURE;
+    STDMETHOD(Open)                 (THIS_ LPDPSESSIONDESC2,DWORD) PURE;
+    STDMETHOD(Receive)              (THIS_ LPDPID,LPDPID,DWORD,LPVOID,LPDWORD) PURE;
+    STDMETHOD(Send)                 (THIS_ DPID, DPID, DWORD, LPVOID, DWORD) PURE;
+    STDMETHOD(SetGroupData)         (THIS_ DPID,LPVOID,DWORD,DWORD) PURE;
+    STDMETHOD(SetGroupName)         (THIS_ DPID,LPDPNAME,DWORD) PURE;
+    STDMETHOD(SetPlayerData)        (THIS_ DPID,LPVOID,DWORD,DWORD) PURE;
+    STDMETHOD(SetPlayerName)        (THIS_ DPID,LPDPNAME,DWORD) PURE;
+    STDMETHOD(SetSessionDesc)       (THIS_ LPDPSESSIONDESC2,DWORD) PURE;
+};
+
+/****************************************************************************
+ *
+ * IDirectPlay2 interface macros
+ *
+ ****************************************************************************/
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+
+#define IDirectPlay2_QueryInterface(p,a,b)          (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirectPlay2_AddRef(p)                      (p)->lpVtbl->AddRef(p)
+#define IDirectPlay2_Release(p)                     (p)->lpVtbl->Release(p)
+#define IDirectPlay2_AddPlayerToGroup(p,a,b)        (p)->lpVtbl->AddPlayerToGroup(p,a,b)
+#define IDirectPlay2_Close(p)                       (p)->lpVtbl->Close(p)
+#define IDirectPlay2_CreateGroup(p,a,b,c,d,e)       (p)->lpVtbl->CreateGroup(p,a,b,c,d,e)
+#define IDirectPlay2_CreatePlayer(p,a,b,c,d,e,f)    (p)->lpVtbl->CreatePlayer(p,a,b,c,d,e,f)
+#define IDirectPlay2_DeletePlayerFromGroup(p,a,b)   (p)->lpVtbl->DeletePlayerFromGroup(p,a,b)
+#define IDirectPlay2_DestroyGroup(p,a)              (p)->lpVtbl->DestroyGroup(p,a)
+#define IDirectPlay2_DestroyPlayer(p,a)             (p)->lpVtbl->DestroyPlayer(p,a)
+#define IDirectPlay2_EnumGroupPlayers(p,a,b,c,d,e)  (p)->lpVtbl->EnumGroupPlayers(p,a,b,c,d,e)
+#define IDirectPlay2_EnumGroups(p,a,b,c,d)          (p)->lpVtbl->EnumGroups(p,a,b,c,d)
+#define IDirectPlay2_EnumPlayers(p,a,b,c,d)         (p)->lpVtbl->EnumPlayers(p,a,b,c,d)
+#define IDirectPlay2_EnumSessions(p,a,b,c,d,e)      (p)->lpVtbl->EnumSessions(p,a,b,c,d,e)
+#define IDirectPlay2_GetCaps(p,a,b)                 (p)->lpVtbl->GetCaps(p,a,b)
+#define IDirectPlay2_GetMessageCount(p,a,b)         (p)->lpVtbl->GetMessageCount(p,a,b)
+#define IDirectPlay2_GetGroupData(p,a,b,c,d)        (p)->lpVtbl->GetGroupData(p,a,b,c,d)
+#define IDirectPlay2_GetGroupName(p,a,b,c)          (p)->lpVtbl->GetGroupName(p,a,b,c)
+#define IDirectPlay2_GetPlayerAddress(p,a,b,c)      (p)->lpVtbl->GetPlayerAddress(p,a,b,c)
+#define IDirectPlay2_GetPlayerCaps(p,a,b,c)         (p)->lpVtbl->GetPlayerCaps(p,a,b,c)
+#define IDirectPlay2_GetPlayerData(p,a,b,c,d)       (p)->lpVtbl->GetPlayerData(p,a,b,c,d)
+#define IDirectPlay2_GetPlayerName(p,a,b,c)         (p)->lpVtbl->GetPlayerName(p,a,b,c)
+#define IDirectPlay2_GetSessionDesc(p,a,b)          (p)->lpVtbl->GetSessionDesc(p,a,b)
+#define IDirectPlay2_Initialize(p,a)                (p)->lpVtbl->Initialize(p,a)
+#define IDirectPlay2_Open(p,a,b)                    (p)->lpVtbl->Open(p,a,b)
+#define IDirectPlay2_Receive(p,a,b,c,d,e)           (p)->lpVtbl->Receive(p,a,b,c,d,e)
+#define IDirectPlay2_Send(p,a,b,c,d,e)              (p)->lpVtbl->Send(p,a,b,c,d,e)
+#define IDirectPlay2_SetGroupData(p,a,b,c,d)        (p)->lpVtbl->SetGroupData(p,a,b,c,d)
+#define IDirectPlay2_SetGroupName(p,a,b,c)          (p)->lpVtbl->SetGroupName(p,a,b,c)
+#define IDirectPlay2_SetPlayerData(p,a,b,c,d)       (p)->lpVtbl->SetPlayerData(p,a,b,c,d)
+#define IDirectPlay2_SetPlayerName(p,a,b,c)         (p)->lpVtbl->SetPlayerName(p,a,b,c)
+#define IDirectPlay2_SetSessionDesc(p,a,b)          (p)->lpVtbl->SetSessionDesc(p,a,b)
+
+#else /* C++ */
+
+#define IDirectPlay2_QueryInterface(p,a,b)          (p)->QueryInterface(a,b)
+#define IDirectPlay2_AddRef(p)                      (p)->AddRef()
+#define IDirectPlay2_Release(p)                     (p)->Release()
+#define IDirectPlay2_AddPlayerToGroup(p,a,b)        (p)->AddPlayerToGroup(a,b)
+#define IDirectPlay2_Close(p)                       (p)->Close()
+#define IDirectPlay2_CreateGroup(p,a,b,c,d,e)       (p)->CreateGroup(a,b,c,d,e)
+#define IDirectPlay2_CreatePlayer(p,a,b,c,d,e,f)    (p)->CreatePlayer(a,b,c,d,e,f)
+#define IDirectPlay2_DeletePlayerFromGroup(p,a,b)   (p)->DeletePlayerFromGroup(a,b)
+#define IDirectPlay2_DestroyGroup(p,a)              (p)->DestroyGroup(a)
+#define IDirectPlay2_DestroyPlayer(p,a)             (p)->DestroyPlayer(a)
+#define IDirectPlay2_EnumGroupPlayers(p,a,b,c,d,e)  (p)->EnumGroupPlayers(a,b,c,d,e)
+#define IDirectPlay2_EnumGroups(p,a,b,c,d)          (p)->EnumGroups(a,b,c,d)
+#define IDirectPlay2_EnumPlayers(p,a,b,c,d)         (p)->EnumPlayers(a,b,c,d)
+#define IDirectPlay2_EnumSessions(p,a,b,c,d,e)      (p)->EnumSessions(a,b,c,d,e)
+#define IDirectPlay2_GetCaps(p,a,b)                 (p)->GetCaps(a,b)
+#define IDirectPlay2_GetMessageCount(p,a,b)         (p)->GetMessageCount(a,b)
+#define IDirectPlay2_GetGroupData(p,a,b,c,d)        (p)->GetGroupData(a,b,c,d)
+#define IDirectPlay2_GetGroupName(p,a,b,c)          (p)->GetGroupName(a,b,c)
+#define IDirectPlay2_GetPlayerAddress(p,a,b,c)      (p)->GetPlayerAddress(a,b,c)
+#define IDirectPlay2_GetPlayerCaps(p,a,b,c)         (p)->GetPlayerCaps(a,b,c)
+#define IDirectPlay2_GetPlayerData(p,a,b,c,d)       (p)->GetPlayerData(a,b,c,d)
+#define IDirectPlay2_GetPlayerName(p,a,b,c)         (p)->GetPlayerName(a,b,c)
+#define IDirectPlay2_GetSessionDesc(p,a,b)          (p)->GetSessionDesc(a,b)
+#define IDirectPlay2_Initialize(p,a)                (p)->Initialize(a)
+#define IDirectPlay2_Open(p,a,b)                    (p)->Open(a,b)
+#define IDirectPlay2_Receive(p,a,b,c,d,e)           (p)->Receive(a,b,c,d,e)
+#define IDirectPlay2_Send(p,a,b,c,d,e)              (p)->Send(a,b,c,d,e)
+#define IDirectPlay2_SetGroupData(p,a,b,c,d)        (p)->SetGroupData(a,b,c,d)
+#define IDirectPlay2_SetGroupName(p,a,b,c)          (p)->SetGroupName(a,b,c)
+#define IDirectPlay2_SetPlayerData(p,a,b,c,d)       (p)->SetPlayerData(a,b,c,d)
+#define IDirectPlay2_SetPlayerName(p,a,b,c)         (p)->SetPlayerName(a,b,c)
+#define IDirectPlay2_SetSessionDesc(p,a,b)          (p)->SetSessionDesc(a,b)
+
+#endif
+
+/****************************************************************************
+ *
+ * IDirectPlay3 (and IDirectPlay3A) Interface
+ *
+ ****************************************************************************/
+
+#undef INTERFACE
+#define INTERFACE IDirectPlay3
+DECLARE_INTERFACE_( IDirectPlay3, IDirectPlay2 )
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface)       (THIS_ REFIID riid, LPVOID * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef)        (THIS)  PURE;
+    STDMETHOD_(ULONG,Release)       (THIS) PURE;
+    /*** IDirectPlay2 methods ***/
+    STDMETHOD(AddPlayerToGroup)     (THIS_ DPID, DPID) PURE;
+    STDMETHOD(Close)                (THIS) PURE;
+    STDMETHOD(CreateGroup)          (THIS_ LPDPID,LPDPNAME,LPVOID,DWORD,DWORD) PURE;
+    STDMETHOD(CreatePlayer)         (THIS_ LPDPID,LPDPNAME,HANDLE,LPVOID,DWORD,DWORD) PURE;
+    STDMETHOD(DeletePlayerFromGroup)(THIS_ DPID,DPID) PURE;
+    STDMETHOD(DestroyGroup)         (THIS_ DPID) PURE;
+    STDMETHOD(DestroyPlayer)        (THIS_ DPID) PURE;
+    STDMETHOD(EnumGroupPlayers)     (THIS_ DPID,LPGUID,LPDPENUMPLAYERSCALLBACK2,LPVOID,DWORD) PURE;
+    STDMETHOD(EnumGroups)           (THIS_ LPGUID,LPDPENUMPLAYERSCALLBACK2,LPVOID,DWORD) PURE;
+    STDMETHOD(EnumPlayers)          (THIS_ LPGUID,LPDPENUMPLAYERSCALLBACK2,LPVOID,DWORD) PURE;
+    STDMETHOD(EnumSessions)         (THIS_ LPDPSESSIONDESC2,DWORD,LPDPENUMSESSIONSCALLBACK2,LPVOID,DWORD) PURE;
+    STDMETHOD(GetCaps)              (THIS_ LPDPCAPS,DWORD) PURE;
+    STDMETHOD(GetGroupData)         (THIS_ DPID,LPVOID,LPDWORD,DWORD) PURE;
+    STDMETHOD(GetGroupName)         (THIS_ DPID,LPVOID,LPDWORD) PURE;
+    STDMETHOD(GetMessageCount)      (THIS_ DPID, LPDWORD) PURE;
+    STDMETHOD(GetPlayerAddress)     (THIS_ DPID,LPVOID,LPDWORD) PURE;
+    STDMETHOD(GetPlayerCaps)        (THIS_ DPID,LPDPCAPS,DWORD) PURE;
+    STDMETHOD(GetPlayerData)        (THIS_ DPID,LPVOID,LPDWORD,DWORD) PURE;
+    STDMETHOD(GetPlayerName)        (THIS_ DPID,LPVOID,LPDWORD) PURE;
+    STDMETHOD(GetSessionDesc)       (THIS_ LPVOID,LPDWORD) PURE;
+    STDMETHOD(Initialize)           (THIS_ LPGUID) PURE;
+    STDMETHOD(Open)                 (THIS_ LPDPSESSIONDESC2,DWORD) PURE;
+    STDMETHOD(Receive)              (THIS_ LPDPID,LPDPID,DWORD,LPVOID,LPDWORD) PURE;
+    STDMETHOD(Send)                 (THIS_ DPID, DPID, DWORD, LPVOID, DWORD) PURE;
+    STDMETHOD(SetGroupData)         (THIS_ DPID,LPVOID,DWORD,DWORD) PURE;
+    STDMETHOD(SetGroupName)         (THIS_ DPID,LPDPNAME,DWORD) PURE;
+    STDMETHOD(SetPlayerData)        (THIS_ DPID,LPVOID,DWORD,DWORD) PURE;
+    STDMETHOD(SetPlayerName)        (THIS_ DPID,LPDPNAME,DWORD) PURE;
+    STDMETHOD(SetSessionDesc)       (THIS_ LPDPSESSIONDESC2,DWORD) PURE;
+    /*** IDirectPlay3 methods ***/
+    STDMETHOD(AddGroupToGroup)      (THIS_ DPID, DPID) PURE;
+    STDMETHOD(CreateGroupInGroup)   (THIS_ DPID,LPDPID,LPDPNAME,LPVOID,DWORD,DWORD) PURE;
+    STDMETHOD(DeleteGroupFromGroup)	(THIS_ DPID,DPID) PURE;	
+    STDMETHOD(EnumConnections)     	(THIS_ LPCGUID,LPDPENUMCONNECTIONSCALLBACK,LPVOID,DWORD) PURE;
+    STDMETHOD(EnumGroupsInGroup)	(THIS_ DPID,LPGUID,LPDPENUMPLAYERSCALLBACK2,LPVOID,DWORD) PURE;
+	STDMETHOD(GetGroupConnectionSettings)(THIS_ DWORD, DPID, LPVOID, LPDWORD) PURE;
+	STDMETHOD(InitializeConnection) (THIS_ LPVOID,DWORD) PURE;
+    STDMETHOD(SecureOpen)           (THIS_ LPCDPSESSIONDESC2,DWORD,LPCDPSECURITYDESC,LPCDPCREDENTIALS) PURE;
+	STDMETHOD(SendChatMessage)      (THIS_ DPID,DPID,DWORD,LPDPCHAT);
+	STDMETHOD(SetGroupConnectionSettings)(THIS_ DWORD,DPID,LPDPLCONNECTION) PURE;
+	STDMETHOD(StartSession)         (THIS_ DWORD,DPID);
+	STDMETHOD(GetGroupFlags)        (THIS_ DPID,LPDWORD);
+	STDMETHOD(GetGroupParent)       (THIS_ DPID,LPDPID);
+	STDMETHOD(GetPlayerAccount)     (THIS_ DPID, DWORD, LPVOID, LPDWORD) PURE;
+	STDMETHOD(GetPlayerFlags)       (THIS_ DPID,LPDWORD);
+};
+
+/****************************************************************************
+ *
+ * IDirectPlay3 interface macros
+ *
+ ****************************************************************************/
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+
+#define IDirectPlay3_QueryInterface(p,a,b)          (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirectPlay3_AddRef(p)                      (p)->lpVtbl->AddRef(p)
+#define IDirectPlay3_Release(p)                     (p)->lpVtbl->Release(p)
+#define IDirectPlay3_AddPlayerToGroup(p,a,b)        (p)->lpVtbl->AddPlayerToGroup(p,a,b)
+#define IDirectPlay3_Close(p)                       (p)->lpVtbl->Close(p)
+#define IDirectPlay3_CreateGroup(p,a,b,c,d,e)       (p)->lpVtbl->CreateGroup(p,a,b,c,d,e)
+#define IDirectPlay3_CreatePlayer(p,a,b,c,d,e,f)    (p)->lpVtbl->CreatePlayer(p,a,b,c,d,e,f)
+#define IDirectPlay3_DeletePlayerFromGroup(p,a,b)   (p)->lpVtbl->DeletePlayerFromGroup(p,a,b)
+#define IDirectPlay3_DestroyGroup(p,a)              (p)->lpVtbl->DestroyGroup(p,a)
+#define IDirectPlay3_DestroyPlayer(p,a)             (p)->lpVtbl->DestroyPlayer(p,a)
+#define IDirectPlay3_EnumGroupPlayers(p,a,b,c,d,e)  (p)->lpVtbl->EnumGroupPlayers(p,a,b,c,d,e)
+#define IDirectPlay3_EnumGroups(p,a,b,c,d)          (p)->lpVtbl->EnumGroups(p,a,b,c,d)
+#define IDirectPlay3_EnumPlayers(p,a,b,c,d)         (p)->lpVtbl->EnumPlayers(p,a,b,c,d)
+#define IDirectPlay3_EnumSessions(p,a,b,c,d,e)      (p)->lpVtbl->EnumSessions(p,a,b,c,d,e)
+#define IDirectPlay3_GetCaps(p,a,b)                 (p)->lpVtbl->GetCaps(p,a,b)
+#define IDirectPlay3_GetMessageCount(p,a,b)         (p)->lpVtbl->GetMessageCount(p,a,b)
+#define IDirectPlay3_GetGroupData(p,a,b,c,d)        (p)->lpVtbl->GetGroupData(p,a,b,c,d)
+#define IDirectPlay3_GetGroupName(p,a,b,c)          (p)->lpVtbl->GetGroupName(p,a,b,c)
+#define IDirectPlay3_GetPlayerAddress(p,a,b,c)      (p)->lpVtbl->GetPlayerAddress(p,a,b,c)
+#define IDirectPlay3_GetPlayerCaps(p,a,b,c)         (p)->lpVtbl->GetPlayerCaps(p,a,b,c)
+#define IDirectPlay3_GetPlayerData(p,a,b,c,d)       (p)->lpVtbl->GetPlayerData(p,a,b,c,d)
+#define IDirectPlay3_GetPlayerName(p,a,b,c)         (p)->lpVtbl->GetPlayerName(p,a,b,c)
+#define IDirectPlay3_GetSessionDesc(p,a,b)          (p)->lpVtbl->GetSessionDesc(p,a,b)
+#define IDirectPlay3_Initialize(p,a)                (p)->lpVtbl->Initialize(p,a)
+#define IDirectPlay3_Open(p,a,b)                    (p)->lpVtbl->Open(p,a,b)
+#define IDirectPlay3_Receive(p,a,b,c,d,e)           (p)->lpVtbl->Receive(p,a,b,c,d,e)
+#define IDirectPlay3_Send(p,a,b,c,d,e)              (p)->lpVtbl->Send(p,a,b,c,d,e)
+#define IDirectPlay3_SetGroupData(p,a,b,c,d)        (p)->lpVtbl->SetGroupData(p,a,b,c,d)
+#define IDirectPlay3_SetGroupName(p,a,b,c)          (p)->lpVtbl->SetGroupName(p,a,b,c)
+#define IDirectPlay3_SetPlayerData(p,a,b,c,d)       (p)->lpVtbl->SetPlayerData(p,a,b,c,d)
+#define IDirectPlay3_SetPlayerName(p,a,b,c)         (p)->lpVtbl->SetPlayerName(p,a,b,c)
+#define IDirectPlay3_SetSessionDesc(p,a,b)          (p)->lpVtbl->SetSessionDesc(p,a,b)
+#define IDirectPlay3_AddGroupToGroup(p,a,b) 		(p)->lpVtbl->AddGroupToGroup(p,a,b)
+#define IDirectPlay3_CreateGroupInGroup(p,a,b,c,d,e,f) (p)->lpVtbl->CreateGroupInGroup(p,a,b,c,d,e,f)
+#define IDirectPlay3_DeleteGroupFromGroup(p,a,b)   	(p)->lpVtbl->DeleteGroupFromGroup(p,a,b)
+#define IDirectPlay3_EnumConnections(p,a,b,c,d) 	(p)->lpVtbl->EnumConnections(p,a,b,c,d)
+#define IDirectPlay3_EnumGroupsInGroup(p,a,b,c,d,e) (p)->lpVtbl->EnumGroupsInGroup(p,a,b,c,d,e)
+#define IDirectPlay3_GetGroupConnectionSettings(p,a,b,c,d) (p)->lpVtbl->GetGroupConnectionSettings(p,a,b,c,d)
+#define IDirectPlay3_InitializeConnection(p,a,b) 	(p)->lpVtbl->InitializeConnection(p,a,b)
+#define IDirectPlay3_SecureOpen(p,a,b,c,d)          (p)->lpVtbl->SecureOpen(p,a,b,c,d)
+#define IDirectPlay3_SendChatMessage(p,a,b,c,d)     (p)->lpVtbl->SendChatMessage(p,a,b,c,d)
+#define IDirectPlay3_SetGroupConnectionSettings(p,a,b,c) (p)->lpVtbl->SetGroupConnectionSettings(p,a,b,c)
+#define IDirectPlay3_StartSession(p,a,b)            (p)->lpVtbl->StartSession(p,a,b)
+#define IDirectPlay3_GetGroupFlags(p,a,b)           (p)->lpVtbl->GetGroupFlags(p,a,b)
+#define IDirectPlay3_GetGroupParent(p,a,b)          (p)->lpVtbl->GetGroupParent(p,a,b)
+#define IDirectPlay3_GetPlayerAccount(p,a,b,c,d)    (p)->lpVtbl->GetPlayerAccount(p,a,b,c,d)
+#define IDirectPlay3_GetPlayerFlags(p,a,b)          (p)->lpVtbl->GetPlayerFlags(p,a,b)
+
+#else /* C++ */
+
+#define IDirectPlay3_QueryInterface(p,a,b)          (p)->QueryInterface(a,b)
+#define IDirectPlay3_AddRef(p)                      (p)->AddRef()
+#define IDirectPlay3_Release(p)                     (p)->Release()
+#define IDirectPlay3_AddPlayerToGroup(p,a,b)        (p)->AddPlayerToGroup(a,b)
+#define IDirectPlay3_Close(p)                       (p)->Close()
+#define IDirectPlay3_CreateGroup(p,a,b,c,d,e)       (p)->CreateGroup(a,b,c,d,e)
+#define IDirectPlay3_CreatePlayer(p,a,b,c,d,e,f)    (p)->CreatePlayer(a,b,c,d,e,f)
+#define IDirectPlay3_DeletePlayerFromGroup(p,a,b)   (p)->DeletePlayerFromGroup(a,b)
+#define IDirectPlay3_DestroyGroup(p,a)              (p)->DestroyGroup(a)
+#define IDirectPlay3_DestroyPlayer(p,a)             (p)->DestroyPlayer(a)
+#define IDirectPlay3_EnumGroupPlayers(p,a,b,c,d,e)  (p)->EnumGroupPlayers(a,b,c,d,e)
+#define IDirectPlay3_EnumGroups(p,a,b,c,d)          (p)->EnumGroups(a,b,c,d)
+#define IDirectPlay3_EnumPlayers(p,a,b,c,d)         (p)->EnumPlayers(a,b,c,d)
+#define IDirectPlay3_EnumSessions(p,a,b,c,d,e)      (p)->EnumSessions(a,b,c,d,e)
+#define IDirectPlay3_GetCaps(p,a,b)                 (p)->GetCaps(a,b)
+#define IDirectPlay3_GetMessageCount(p,a,b)         (p)->GetMessageCount(a,b)
+#define IDirectPlay3_GetGroupData(p,a,b,c,d)        (p)->GetGroupData(a,b,c,d)
+#define IDirectPlay3_GetGroupName(p,a,b,c)          (p)->GetGroupName(a,b,c)
+#define IDirectPlay3_GetPlayerAddress(p,a,b,c)      (p)->GetPlayerAddress(a,b,c)
+#define IDirectPlay3_GetPlayerCaps(p,a,b,c)         (p)->GetPlayerCaps(a,b,c)
+#define IDirectPlay3_GetPlayerData(p,a,b,c,d)       (p)->GetPlayerData(a,b,c,d)
+#define IDirectPlay3_GetPlayerName(p,a,b,c)         (p)->GetPlayerName(a,b,c)
+#define IDirectPlay3_GetSessionDesc(p,a,b)          (p)->GetSessionDesc(a,b)
+#define IDirectPlay3_Initialize(p,a)                (p)->Initialize(a)
+#define IDirectPlay3_Open(p,a,b)                    (p)->Open(a,b)
+#define IDirectPlay3_Receive(p,a,b,c,d,e)           (p)->Receive(a,b,c,d,e)
+#define IDirectPlay3_Send(p,a,b,c,d,e)              (p)->Send(a,b,c,d,e)
+#define IDirectPlay3_SetGroupData(p,a,b,c,d)        (p)->SetGroupData(a,b,c,d)
+#define IDirectPlay3_SetGroupName(p,a,b,c)          (p)->SetGroupName(a,b,c)
+#define IDirectPlay3_SetPlayerData(p,a,b,c,d)       (p)->SetPlayerData(a,b,c,d)
+#define IDirectPlay3_SetPlayerName(p,a,b,c)         (p)->SetPlayerName(a,b,c)
+#define IDirectPlay3_SetSessionDesc(p,a,b)          (p)->SetSessionDesc(a,b)
+#define IDirectPlay3_AddGroupToGroup(p,a,b) 		(p)->AddGroupToGroup(a,b)
+#define IDirectPlay3_CreateGroupInGroup(p,a,b,c,d,e,f) (p)->CreateGroupInGroup(a,b,c,d,e,f)
+#define IDirectPlay3_DeleteGroupFromGroup(p,a,b)   	(p)->DeleteGroupFromGroup(a,b)
+#define IDirectPlay3_EnumConnections(p,a,b,c,d)     (p)->EnumConnections(a,b,c,d)
+#define IDirectPlay3_EnumGroupsInGroup(p,a,b,c,d,e) (p)->EnumGroupsInGroup(a,b,c,d,e)
+#define IDirectPlay3_GetGroupConnectionSettings(p,a,b,c,d) (p)->GetGroupConnectionSettings(a,b,c,d)
+#define IDirectPlay3_InitializeConnection(p,a,b)    (p)->InitializeConnection(a,b)
+#define IDirectPlay3_SecureOpen(p,a,b,c,d)          (p)->SecureOpen(a,b,c,d)
+#define IDirectPlay3_SendChatMessage(p,a,b,c,d)     (p)->SendChatMessage(a,b,c,d)
+#define IDirectPlay3_SetGroupConnectionSettings(p,a,b,c) (p)->SetGroupConnectionSettings(a,b,c)
+#define IDirectPlay3_StartSession(p,a,b)            (p)->StartSession(a,b)
+#define IDirectPlay3_GetGroupFlags(p,a,b)           (p)->GetGroupFlags(a,b)
+#define IDirectPlay3_GetGroupParent(p,a,b)          (p)->GetGroupParent(a,b)
+#define IDirectPlay3_GetPlayerAccount(p,a,b,c,d)    (p)->GetPlayerAccount(a,b,c,d)
+#define IDirectPlay3_GetPlayerFlags(p,a,b)          (p)->GetPlayerFlags(a,b)
+
+#endif
+
+/****************************************************************************
+ *
+ * EnumConnections API flags
+ *
+ ****************************************************************************/
+
+/*
+ * Enumerate Service Providers
+ */
+#define DPCONNECTION_DIRECTPLAY      0x00000001
+
+/*
+ * Enumerate Lobby Providers
+ */
+#define DPCONNECTION_DIRECTPLAYLOBBY 0x00000002
+
+
+/****************************************************************************
+ *
+ * EnumPlayers API flags
+ *
+ ****************************************************************************/
+
+/*
+ * Enumerate all players in the current session
+ */
+#define DPENUMPLAYERS_ALL           0x00000000
+#define DPENUMGROUPS_ALL            DPENUMPLAYERS_ALL
+
+
+/*
+ * Enumerate only local (created by this application) players
+ * or groups
+ */
+#define DPENUMPLAYERS_LOCAL         0x00000008
+#define DPENUMGROUPS_LOCAL			DPENUMPLAYERS_LOCAL
+
+/*
+ * Enumerate only remote (non-local) players
+ * or groups
+ */
+#define DPENUMPLAYERS_REMOTE        0x00000010
+#define DPENUMGROUPS_REMOTE			DPENUMPLAYERS_REMOTE
+
+/*
+ * Enumerate groups along with the players
+ */
+#define DPENUMPLAYERS_GROUP         0x00000020
+
+/*
+ * Enumerate players or groups in another session 
+ * (must supply lpguidInstance)
+ */
+#define DPENUMPLAYERS_SESSION       0x00000080
+#define DPENUMGROUPS_SESSION		DPENUMPLAYERS_SESSION
+
+/*
+ * Enumerate server players
+ */
+#define DPENUMPLAYERS_SERVERPLAYER  0x00000100
+
+/*
+ * Enumerate spectator players
+ */
+#define DPENUMPLAYERS_SPECTATOR     0x00000200
+
+/*
+ * Enumerate shortcut groups
+ */
+#define DPENUMGROUPS_SHORTCUT       0x00000400
+
+/*
+ * Enumerate staging area groups
+ */
+#define DPENUMGROUPS_STAGINGAREA    0x00000800
+
+/****************************************************************************
+ *
+ * CreatePlayer API flags
+ *
+ ****************************************************************************/
+
+/*
+ * This flag indicates that this player should be designated
+ * the server player. The app should specify this at CreatePlayer.
+ */
+#define DPPLAYER_SERVERPLAYER           DPENUMPLAYERS_SERVERPLAYER
+
+/*
+ * This flag indicates that this player should be designated
+ * a spectator. The app should specify this at CreatePlayer.
+ */
+#define DPPLAYER_SPECTATOR              DPENUMPLAYERS_SPECTATOR
+
+/*
+ * This flag indicates that this player was created locally.
+ * (returned from GetPlayerFlags)
+ */
+#define DPPLAYER_LOCAL                  DPENUMPLAYERS_LOCAL
+
+/****************************************************************************
+ *
+ * CreateGroup API flags
+ *
+ ****************************************************************************/
+
+
+/*
+ * This flag indicates that the StartSession can be called on the group.
+ * The app should specify this at CreateGroup, or CreateGroupInGroup.
+ */
+#define DPGROUP_STAGINGAREA             DPENUMGROUPS_STAGINGAREA
+
+/*
+ * This flag indicates that this group was created locally.
+ * (returned from GetGroupFlags)
+ */
+#define DPGROUP_LOCAL                   DPENUMGROUPS_LOCAL
+
+/****************************************************************************
+ *
+ * EnumSessions API flags
+ *
+ ****************************************************************************/
+
+/*
+ * Enumerate sessions which can be joined
+ */
+#define DPENUMSESSIONS_AVAILABLE    0x00000001 
+
+/*
+ * Enumerate all sessions even if they can't be joined.
+ */
+#define DPENUMSESSIONS_ALL          0x00000002
+
+
+
+
+/*
+ * Start an asynchronous enum sessions
+ */
+ #define DPENUMSESSIONS_ASYNC		0x00000010
+
+/*
+ * Stop an asynchronous enum sessions
+ */
+ #define DPENUMSESSIONS_STOPASYNC	0x00000020
+ 
+/*
+ * Enumerate sessions even if they require a password
+ */
+ #define DPENUMSESSIONS_PASSWORDREQUIRED	0x00000040
+
+/*
+ * Return status about progress of enumeration instead of
+ * showing any status dialogs.
+ */
+ #define DPENUMSESSIONS_RETURNSTATUS 0x00000080
+
+/****************************************************************************
+ *
+ * GetCaps and GetPlayerCaps API flags
+ *
+ ****************************************************************************/
+
+/*
+ * The latency returned should be for guaranteed message sending.
+ * Default is non-guaranteed messaging.
+ */
+#define DPGETCAPS_GUARANTEED        0x00000001 
+
+ 
+/****************************************************************************
+ *
+ * GetGroupData, GetPlayerData API flags
+ * Remote and local Group/Player data is maintained separately. 
+ * Default is DPGET_REMOTE.
+ *
+ ****************************************************************************/
+
+/*
+ * Get the remote data (set by any DirectPlay object in
+ * the session using DPSET_REMOTE)
+ */
+#define DPGET_REMOTE                0x00000000
+
+/*
+ * Get the local data (set by this DirectPlay object 
+ * using DPSET_LOCAL)
+ */
+#define DPGET_LOCAL                 0x00000001
+
+
+/****************************************************************************
+ *
+ * Open API flags
+ *
+ ****************************************************************************/
+
+/*
+ * Join the session that is described by the DPSESSIONDESC2 structure
+ */
+#define DPOPEN_JOIN                 0x00000001
+
+/*
+ * Create a new session as described by the DPSESSIONDESC2 structure
+ */
+#define DPOPEN_CREATE               0x00000002
+
+/*
+ * Return status about progress of open instead of showing
+ * any status dialogs.
+ */
+ #define DPOPEN_RETURNSTATUS		DPENUMSESSIONS_RETURNSTATUS
+
+/****************************************************************************
+ *
+ * DPLCONNECTION flags
+ *
+ ****************************************************************************/
+
+/*
+ * This application should create a new session as
+ * described by the DPSESIONDESC structure
+ */
+#define DPLCONNECTION_CREATESESSION					DPOPEN_CREATE
+
+/*
+ * This application should join the session described by 
+ * the DPSESIONDESC structure with the lpAddress data
+ */
+#define DPLCONNECTION_JOINSESSION					DPOPEN_JOIN
+
+/****************************************************************************
+ *
+ * Receive API flags
+ * Default is DPRECEIVE_ALL
+ *
+ ****************************************************************************/
+
+/*
+ * Get the first message in the queue
+ */
+#define DPRECEIVE_ALL               0x00000001
+
+/*
+ * Get the first message in the queue directed to a specific player 
+ */
+#define DPRECEIVE_TOPLAYER          0x00000002
+
+/*
+ * Get the first message in the queue from a specific player
+ */
+#define DPRECEIVE_FROMPLAYER        0x00000004
+
+/*
+ * Get the message but don't remove it from the queue
+ */
+#define DPRECEIVE_PEEK              0x00000008
+
+
+/****************************************************************************
+ *
+ * Send API flags
+ *
+ ****************************************************************************/
+
+/*
+ * Send the message using a guaranteed send method.
+ * Default is non-guaranteed.
+ */
+#define DPSEND_GUARANTEED           0x00000001
+
+
+/*
+ * This flag is obsolete. It is ignored by DirectPlay
+ */
+#define DPSEND_HIGHPRIORITY         0x00000002
+
+/*
+ * This flag is obsolete. It is ignored by DirectPlay
+ */
+#define DPSEND_OPENSTREAM           0x00000008
+
+/*
+ * This flag is obsolete. It is ignored by DirectPlay
+ */
+#define DPSEND_CLOSESTREAM          0x00000010
+
+/*
+ * Send the message digitally signed to ensure authenticity.
+ */
+#define DPSEND_SIGNED               0x00000020
+
+/*
+ * Send the message with encryption to ensure privacy.
+ */
+#define DPSEND_ENCRYPTED            0x00000040
+
+
+/****************************************************************************
+ *
+ * SetGroupData, SetGroupName, SetPlayerData, SetPlayerName,
+ * SetSessionDesc API flags.
+ * Default is DPSET_REMOTE.
+ *
+ ****************************************************************************/
+
+/* 
+ * Propagate the data to all players in the session
+ */
+#define DPSET_REMOTE                0x00000000
+
+/*
+ * Do not propagate the data to other players
+ */
+#define DPSET_LOCAL                 0x00000001
+
+/*
+ * Used with DPSET_REMOTE, use guaranteed message send to
+ * propagate the data
+ */
+#define DPSET_GUARANTEED            0x00000002
+
+
+/****************************************************************************
+ *
+ * DirectPlay system messages and message data structures
+ *
+ * All system message come 'From' player DPID_SYSMSG.  To determine what type 
+ * of message it is, cast the lpData from Receive to DPMSG_GENERIC and check
+ * the dwType member against one of the following DPSYS_xxx constants. Once
+ * a match is found, cast the lpData to the corresponding of the DPMSG_xxx
+ * structures to access the data of the message.
+ *
+ ****************************************************************************/
+
+/*
+ * A new player or group has been created in the session
+ * Use DPMSG_CREATEPLAYERORGROUP.  Check dwPlayerType to see if it
+ * is a player or a group.
+ */
+#define DPSYS_CREATEPLAYERORGROUP   0x0003  
+
+/*
+ * A player has been deleted from the session
+ * Use DPMSG_DESTROYPLAYERORGROUP
+ */
+#define DPSYS_DESTROYPLAYERORGROUP  0x0005  
+
+/*
+ * A player has been added to a group
+ * Use DPMSG_ADDPLAYERTOGROUP
+ */
+#define DPSYS_ADDPLAYERTOGROUP      0x0007  
+
+/*
+ * A player has been removed from a group
+ * Use DPMSG_DELETEPLAYERFROMGROUP
+ */
+#define DPSYS_DELETEPLAYERFROMGROUP 0x0021  
+
+/*
+ * This DirectPlay object lost its connection with all the
+ * other players in the session.
+ * Use DPMSG_SESSIONLOST.
+ */
+#define DPSYS_SESSIONLOST           0x0031
+
+/*
+ * The current host has left the session.
+ * This DirectPlay object is now the host.
+ * Use DPMSG_HOST.
+ */
+#define DPSYS_HOST                  0x0101
+
+/*
+ * The remote data associated with a player or
+ * group has changed. Check dwPlayerType to see
+ * if it is a player or a group
+ * Use DPMSG_SETPLAYERORGROUPDATA
+ */
+#define DPSYS_SETPLAYERORGROUPDATA  0x0102
+
+/*
+ * The name of a player or group has changed.
+ * Check dwPlayerType to see if it is a player
+ * or a group.
+ * Use DPMSG_SETPLAYERORGROUPNAME
+ */
+#define DPSYS_SETPLAYERORGROUPNAME  0x0103
+
+/*
+ * The session description has changed.
+ * Use DPMSG_SETSESSIONDESC
+ */
+#define DPSYS_SETSESSIONDESC        0x0104
+
+/*
+ * A group has been added to a group
+ * Use DPMSG_ADDGROUPTOGROUP
+ */
+#define DPSYS_ADDGROUPTOGROUP      	0x0105  
+
+/*
+ * A group has been removed from a group
+ * Use DPMSG_DELETEGROUPFROMGROUP
+ */
+#define DPSYS_DELETEGROUPFROMGROUP 	0x0106
+
+/*
+ * A secure player-player message has arrived.
+ * Use DPMSG_SECUREMESSAGE
+ */
+#define DPSYS_SECUREMESSAGE         0x0107
+
+/*
+ * Start a new session.
+ * Use DPMSG_STARTSESSION
+ */
+#define DPSYS_STARTSESSION          0x0108
+
+/*
+ * A chat message has arrived
+ * Use DPMSG_CHAT
+ */
+#define DPSYS_CHAT                  0x0109
+
+/*
+ * Used in the dwPlayerType field to indicate if it applies to a group
+ * or a player
+ */
+#define DPPLAYERTYPE_GROUP          0x00000000
+#define DPPLAYERTYPE_PLAYER         0x00000001
+
+
+/*
+ * DPMSG_GENERIC
+ * Generic message structure used to identify the message type.
+ */
+typedef struct
+{
+    DWORD       dwType;         // Message type
+} DPMSG_GENERIC, FAR *LPDPMSG_GENERIC;
+
+/*
+ * DPMSG_CREATEPLAYERORGROUP
+ * System message generated when a new player or group
+ * created in the session with information about it.
+ */
+typedef struct
+{
+    DWORD       dwType;         // Message type
+    DWORD       dwPlayerType;   // Is it a player or group
+    DPID        dpId;           // ID of the player or group
+    DWORD       dwCurrentPlayers;   // current # players & groups in session
+    LPVOID      lpData;         // pointer to remote data
+    DWORD       dwDataSize;     // size of remote data
+    DPNAME      dpnName;        // structure with name info
+	// the following fields are only available when using
+	// the IDirectPlay3 interface or greater
+    DPID	    dpIdParent;     // id of parent group
+	DWORD		dwFlags;		// player or group flags
+} DPMSG_CREATEPLAYERORGROUP, FAR *LPDPMSG_CREATEPLAYERORGROUP;
+
+/*
+ * DPMSG_DESTROYPLAYERORGROUP
+ * System message generated when a player or group is being
+ * destroyed in the session with information about it.
+ */
+typedef struct
+{
+    DWORD       dwType;         // Message type
+    DWORD       dwPlayerType;   // Is it a player or group
+    DPID        dpId;           // player ID being deleted
+    LPVOID      lpLocalData;    // copy of players local data
+    DWORD       dwLocalDataSize; // sizeof local data
+    LPVOID      lpRemoteData;   // copy of players remote data
+    DWORD       dwRemoteDataSize; // sizeof remote data
+	// the following fields are only available when using
+	// the IDirectPlay3 interface or greater
+    DPNAME      dpnName;        // structure with name info
+    DPID	    dpIdParent;     // id of parent group	
+	DWORD		dwFlags;		// player or group flags
+} DPMSG_DESTROYPLAYERORGROUP, FAR *LPDPMSG_DESTROYPLAYERORGROUP;
+
+/*
+ * DPMSG_ADDPLAYERTOGROUP
+ * System message generated when a player is being added
+ * to a group.
+ */
+typedef struct
+{
+    DWORD       dwType;         // Message type
+    DPID        dpIdGroup;      // group ID being added to
+    DPID        dpIdPlayer;     // player ID being added
+} DPMSG_ADDPLAYERTOGROUP, FAR *LPDPMSG_ADDPLAYERTOGROUP;
+
+/*
+ * DPMSG_DELETEPLAYERFROMGROUP
+ * System message generated when a player is being
+ * removed from a group
+ */
+typedef DPMSG_ADDPLAYERTOGROUP          DPMSG_DELETEPLAYERFROMGROUP;
+typedef DPMSG_DELETEPLAYERFROMGROUP     FAR *LPDPMSG_DELETEPLAYERFROMGROUP;
+
+/*
+ * DPMSG_ADDGROUPTOGROUP
+ * System message generated when a group is being added
+ * to a group.
+ */
+typedef struct
+{
+    DWORD       dwType;         // Message type
+    DPID        dpIdParentGroup; // group ID being added to
+    DPID        dpIdGroup;     // group ID being added
+} DPMSG_ADDGROUPTOGROUP, FAR *LPDPMSG_ADDGROUPTOGROUP;
+
+/*
+ * DPMSG_DELETEGROUPFROMGROUP
+ * System message generated when a GROUP is being
+ * removed from a group
+ */
+typedef DPMSG_ADDGROUPTOGROUP          DPMSG_DELETEGROUPFROMGROUP;
+typedef DPMSG_DELETEGROUPFROMGROUP     FAR *LPDPMSG_DELETEGROUPFROMGROUP;
+
+/*
+ * DPMSG_SETPLAYERORGROUPDATA
+ * System message generated when remote data for a player or
+ * group has changed.
+ */
+typedef struct
+{
+    DWORD       dwType;         // Message type
+    DWORD       dwPlayerType;   // Is it a player or group
+    DPID        dpId;           // ID of player or group
+    LPVOID      lpData;         // pointer to remote data
+    DWORD       dwDataSize;     // size of remote data
+} DPMSG_SETPLAYERORGROUPDATA, FAR *LPDPMSG_SETPLAYERORGROUPDATA;
+
+/*
+ * DPMSG_SETPLAYERORGROUPNAME
+ * System message generated when the name of a player or
+ * group has changed.
+ */
+typedef struct
+{
+    DWORD       dwType;         // Message type
+    DWORD       dwPlayerType;   // Is it a player or group
+    DPID        dpId;           // ID of player or group
+    DPNAME      dpnName;        // structure with new name info
+} DPMSG_SETPLAYERORGROUPNAME, FAR *LPDPMSG_SETPLAYERORGROUPNAME;
+
+/*
+ * DPMSG_SETSESSIONDESC
+ * System message generated when session desc has changed
+ */
+typedef struct
+{
+    DWORD           dwType;     // Message type
+    DPSESSIONDESC2  dpDesc;     // Session desc
+} DPMSG_SETSESSIONDESC, FAR *LPDPMSG_SETSESSIONDESC;
+
+/*
+ * DPMSG_HOST
+ * System message generated when the host has migrated to this
+ * DirectPlay object.
+ *
+ */
+typedef DPMSG_GENERIC       DPMSG_HOST;
+typedef DPMSG_HOST          FAR *LPDPMSG_HOST;
+
+/*
+ * DPMSG_SESSIONLOST
+ * System message generated when the connection to the session is lost.
+ *
+ */
+typedef DPMSG_GENERIC       DPMSG_SESSIONLOST;
+typedef DPMSG_SESSIONLOST   FAR *LPDPMSG_SESSIONLOST;
+
+/*
+ * DPMSG_SECUREMESSAGE
+ * System message generated when a player requests a secure send
+ */
+typedef struct 
+{
+    DWORD		dwType;         // Message Type
+    DWORD		dwFlags;        // Signed/Encrypted
+    DPID        dpIdFrom;       // ID of Sending Player
+    LPVOID		lpData;         // Player message
+    DWORD		dwDataSize;     // Size of player message
+} DPMSG_SECUREMESSAGE, FAR *LPDPMSG_SECUREMESSAGE;
+
+/*
+ * DPMSG_STARTSESSION
+ * System message containing all information required to 
+ * start a new session
+ */
+typedef struct
+{
+    DWORD              dwType;     // Message type
+    LPDPLCONNECTION    lpConn;     // DPLCONNECTION structure
+} DPMSG_STARTSESSION, FAR *LPDPMSG_STARTSESSION;
+
+/*
+ * DPMSG_CHAT
+ * System message containing a chat message
+ */
+typedef struct
+{
+    DWORD              dwType;        // Message type
+    DWORD              dwFlags;       // Message flags
+    DPID               idFromPlayer;  // ID of the Sending Player
+    DPID               idToPlayer;    // ID of the To Player
+    DPID               idToGroup;     // ID of the To Group
+    LPDPCHAT           lpChat;        // Pointer to a structure containing the chat message
+} DPMSG_CHAT, FAR *LPDPMSG_CHAT;
+
+/****************************************************************************
+ *
+ * DIRECTPLAY ERRORS
+ *
+ * Errors are represented by negative values and cannot be combined.
+ *
+ ****************************************************************************/
+#define DP_OK                           S_OK
+#define DPERR_ALREADYINITIALIZED        MAKE_DPHRESULT(   5 )
+#define DPERR_ACCESSDENIED              MAKE_DPHRESULT(  10 )
+#define DPERR_ACTIVEPLAYERS             MAKE_DPHRESULT(  20 )
+#define DPERR_BUFFERTOOSMALL            MAKE_DPHRESULT(  30 )
+#define DPERR_CANTADDPLAYER             MAKE_DPHRESULT(  40 )
+#define DPERR_CANTCREATEGROUP           MAKE_DPHRESULT(  50 )
+#define DPERR_CANTCREATEPLAYER          MAKE_DPHRESULT(  60 )
+#define DPERR_CANTCREATESESSION         MAKE_DPHRESULT(  70 )
+#define DPERR_CAPSNOTAVAILABLEYET       MAKE_DPHRESULT(  80 )
+#define DPERR_EXCEPTION                 MAKE_DPHRESULT(  90 )
+#define DPERR_GENERIC                   E_FAIL
+#define DPERR_INVALIDFLAGS              MAKE_DPHRESULT( 120 )
+#define DPERR_INVALIDOBJECT             MAKE_DPHRESULT( 130 )
+#define DPERR_INVALIDPARAM              E_INVALIDARG
+#define DPERR_INVALIDPARAMS             DPERR_INVALIDPARAM
+#define DPERR_INVALIDPLAYER             MAKE_DPHRESULT( 150 )
+#define DPERR_INVALIDGROUP             	MAKE_DPHRESULT( 155 )
+#define DPERR_NOCAPS                    MAKE_DPHRESULT( 160 )
+#define DPERR_NOCONNECTION              MAKE_DPHRESULT( 170 )
+#define DPERR_NOMEMORY                  E_OUTOFMEMORY
+#define DPERR_OUTOFMEMORY               DPERR_NOMEMORY
+#define DPERR_NOMESSAGES                MAKE_DPHRESULT( 190 )
+#define DPERR_NONAMESERVERFOUND         MAKE_DPHRESULT( 200 )
+#define DPERR_NOPLAYERS                 MAKE_DPHRESULT( 210 )
+#define DPERR_NOSESSIONS                MAKE_DPHRESULT( 220 )
+#define DPERR_PENDING					E_PENDING
+#define DPERR_SENDTOOBIG				MAKE_DPHRESULT( 230 )
+#define DPERR_TIMEOUT                   MAKE_DPHRESULT( 240 )
+#define DPERR_UNAVAILABLE               MAKE_DPHRESULT( 250 )
+#define DPERR_UNSUPPORTED               E_NOTIMPL
+#define DPERR_BUSY                      MAKE_DPHRESULT( 270 )
+#define DPERR_USERCANCEL                MAKE_DPHRESULT( 280 ) 
+#define DPERR_NOINTERFACE               E_NOINTERFACE
+#define DPERR_CANNOTCREATESERVER        MAKE_DPHRESULT( 290 )
+#define DPERR_PLAYERLOST                MAKE_DPHRESULT( 300 )
+#define DPERR_SESSIONLOST               MAKE_DPHRESULT( 310 )
+#define DPERR_UNINITIALIZED             MAKE_DPHRESULT( 320 )
+#define DPERR_NONEWPLAYERS              MAKE_DPHRESULT( 330 )
+#define DPERR_INVALIDPASSWORD           MAKE_DPHRESULT( 340 )
+#define DPERR_CONNECTING                MAKE_DPHRESULT( 350 )
+
+
+#define DPERR_BUFFERTOOLARGE            MAKE_DPHRESULT( 1000 )
+#define DPERR_CANTCREATEPROCESS         MAKE_DPHRESULT( 1010 )
+#define DPERR_APPNOTSTARTED             MAKE_DPHRESULT( 1020 )
+#define DPERR_INVALIDINTERFACE          MAKE_DPHRESULT( 1030 )
+#define DPERR_NOSERVICEPROVIDER         MAKE_DPHRESULT( 1040 )
+#define DPERR_UNKNOWNAPPLICATION        MAKE_DPHRESULT( 1050 )
+#define DPERR_NOTLOBBIED                MAKE_DPHRESULT( 1070 )
+#define DPERR_SERVICEPROVIDERLOADED		MAKE_DPHRESULT( 1080 )
+#define DPERR_ALREADYREGISTERED			MAKE_DPHRESULT( 1090 )
+#define DPERR_NOTREGISTERED				MAKE_DPHRESULT( 1100 )
+
+//
+// Security related errors
+//
+#define DPERR_AUTHENTICATIONFAILED      MAKE_DPHRESULT(  2000 )
+#define DPERR_CANTLOADSSPI              MAKE_DPHRESULT(  2010 )
+#define DPERR_ENCRYPTIONFAILED          MAKE_DPHRESULT(  2020 )
+#define DPERR_SIGNFAILED                MAKE_DPHRESULT(  2030 )
+#define DPERR_CANTLOADSECURITYPACKAGE   MAKE_DPHRESULT(  2040 )
+#define DPERR_ENCRYPTIONNOTSUPPORTED    MAKE_DPHRESULT(  2050 )
+#define DPERR_CANTLOADCAPI              MAKE_DPHRESULT(  2060 )
+#define DPERR_NOTLOGGEDIN               MAKE_DPHRESULT(  2070 )
+#define DPERR_LOGONDENIED               MAKE_DPHRESULT(  2080 )
+
+
+/****************************************************************************
+ *
+ * 	dplay 1.0 obsolete structures + interfaces
+ *	Included for compatibility only. New apps should
+ *	use IDirectPlay2
+ *
+ ****************************************************************************/
+
+// define this to ignore obsolete interfaces and constants
+#ifndef IDIRECTPLAY2_OR_GREATER
+
+#define DPOPEN_OPENSESSION          DPOPEN_JOIN
+#define DPOPEN_CREATESESSION        DPOPEN_CREATE
+
+#define DPENUMSESSIONS_PREVIOUS     0x00000004
+
+#define DPENUMPLAYERS_PREVIOUS      0x00000004
+
+#define DPSEND_GUARANTEE            DPSEND_GUARANTEED
+#define DPSEND_TRYONCE              0x00000004
+
+#define DPCAPS_NAMESERVICE          0x00000001
+#define DPCAPS_NAMESERVER           DPCAPS_ISHOST
+#define DPCAPS_GUARANTEED           0x00000004
+
+#define DPLONGNAMELEN               52
+#define DPSHORTNAMELEN              20
+#define DPSESSIONNAMELEN            32
+#define DPPASSWORDLEN               16
+#define DPUSERRESERVED              16
+
+#define DPSYS_ADDPLAYER             0x0003
+#define DPSYS_DELETEPLAYER          0x0005
+
+#define DPSYS_DELETEGROUP           0x0020
+#define DPSYS_DELETEPLAYERFROMGRP   0x0021
+#define DPSYS_CONNECT               0x484b
+
+typedef struct
+{
+    DWORD       dwType;
+    DWORD       dwPlayerType;
+    DPID        dpId;
+    char        szLongName[DPLONGNAMELEN];
+    char        szShortName[DPSHORTNAMELEN];
+    DWORD       dwCurrentPlayers;
+}   DPMSG_ADDPLAYER;
+
+typedef DPMSG_ADDPLAYER DPMSG_ADDGROUP;
+
+typedef struct
+{
+    DWORD       dwType;
+    DPID        dpIdGroup;
+    DPID        dpIdPlayer;
+} DPMSG_GROUPADD;
+
+typedef DPMSG_GROUPADD DPMSG_GROUPDELETE;
+typedef struct
+{
+    DWORD       dwType;
+    DPID        dpId;
+} DPMSG_DELETEPLAYER;
+
+typedef BOOL (PASCAL *LPDPENUMPLAYERSCALLBACK)(
+    DPID    dpId,
+    LPSTR   lpFriendlyName,
+    LPSTR   lpFormalName,
+    DWORD   dwFlags,
+    LPVOID  lpContext );
+
+typedef struct
+{
+    DWORD   dwSize;
+    GUID    guidSession;                  
+    DWORD   dwSession;                    
+    DWORD   dwMaxPlayers;                 
+    DWORD   dwCurrentPlayers;             
+    DWORD   dwFlags;                      
+    char    szSessionName[DPSESSIONNAMELEN];
+    char    szUserField[DPUSERRESERVED];
+    DWORD   dwReserved1;                  
+    char    szPassword[DPPASSWORDLEN];    
+    DWORD   dwReserved2;                  
+    DWORD   dwUser1;
+    DWORD   dwUser2;
+    DWORD   dwUser3;
+    DWORD   dwUser4;
+} DPSESSIONDESC,*LPDPSESSIONDESC;
+
+typedef BOOL (PASCAL * LPDPENUMSESSIONSCALLBACK)(
+    LPDPSESSIONDESC lpDPSessionDesc,
+    LPVOID      lpContext,
+    LPDWORD     lpdwTimeOut,
+    DWORD       dwFlags);
+
+/*
+ * IDirectPlay
+ */
+#undef INTERFACE
+#define INTERFACE IDirectPlay
+DECLARE_INTERFACE_( IDirectPlay, IUnknown )
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface)       (THIS_ REFIID riid, LPVOID * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef)        (THIS)  PURE;
+    STDMETHOD_(ULONG,Release)       (THIS) PURE;
+    /*** IDirectPlay methods ***/
+    STDMETHOD(AddPlayerToGroup)     (THIS_ DPID, DPID) PURE;
+    STDMETHOD(Close)                (THIS) PURE;
+    STDMETHOD(CreatePlayer)         (THIS_ LPDPID,LPSTR,LPSTR,LPHANDLE) PURE;
+    STDMETHOD(CreateGroup)          (THIS_ LPDPID,LPSTR,LPSTR) PURE;
+    STDMETHOD(DeletePlayerFromGroup)(THIS_ DPID,DPID) PURE;
+    STDMETHOD(DestroyPlayer)        (THIS_ DPID) PURE;
+    STDMETHOD(DestroyGroup)         (THIS_ DPID) PURE;
+    STDMETHOD(EnableNewPlayers)     (THIS_ BOOL) PURE;
+    STDMETHOD(EnumGroupPlayers)     (THIS_ DPID, LPDPENUMPLAYERSCALLBACK,LPVOID,DWORD) PURE;
+    STDMETHOD(EnumGroups)           (THIS_ DWORD, LPDPENUMPLAYERSCALLBACK,LPVOID,DWORD) PURE;
+    STDMETHOD(EnumPlayers)          (THIS_ DWORD, LPDPENUMPLAYERSCALLBACK,LPVOID,DWORD) PURE;
+    STDMETHOD(EnumSessions)         (THIS_ LPDPSESSIONDESC,DWORD,LPDPENUMSESSIONSCALLBACK,LPVOID,DWORD) PURE;
+    STDMETHOD(GetCaps)              (THIS_ LPDPCAPS) PURE;
+    STDMETHOD(GetMessageCount)      (THIS_ DPID, LPDWORD) PURE;
+    STDMETHOD(GetPlayerCaps)        (THIS_ DPID, LPDPCAPS) PURE;
+    STDMETHOD(GetPlayerName)        (THIS_ DPID,LPSTR,LPDWORD,LPSTR,LPDWORD) PURE;
+    STDMETHOD(Initialize)           (THIS_ LPGUID) PURE;
+    STDMETHOD(Open)                 (THIS_ LPDPSESSIONDESC) PURE;
+    STDMETHOD(Receive)              (THIS_ LPDPID,LPDPID,DWORD,LPVOID,LPDWORD) PURE;
+    STDMETHOD(SaveSession)          (THIS_ LPSTR) PURE;
+    STDMETHOD(Send)                 (THIS_ DPID, DPID, DWORD, LPVOID, DWORD) PURE;
+    STDMETHOD(SetPlayerName)        (THIS_ DPID,LPSTR,LPSTR) PURE;
+};
+
+/****************************************************************************
+ *
+ * IDirectPlay interface macros
+ *
+ ****************************************************************************/
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+
+#define IDirectPlay_AddPlayerToGroup(p,a,b)         (p)->lpVtbl->AddPlayerToGroup(p,a,b)
+#define IDirectPlay_Close(p)                        (p)->lpVtbl->Close(p)
+#define IDirectPlay_CreateGroup(p,a,b,c)            (p)->lpVtbl->CreateGroup(p,a,b,c)
+#define IDirectPlay_CreatePlayer(p,a,b,c,d)         (p)->lpVtbl->CreatePlayer(p,a,b,c,d)
+#define IDirectPlay_DeletePlayerFromGroup(p,a,b)    (p)->lpVtbl->DeletePlayerFromGroup(p,a,b)
+#define IDirectPlay_DestroyGroup(p,a)               (p)->lpVtbl->DestroyGroup(p,a)
+#define IDirectPlay_DestroyPlayer(p,a)              (p)->lpVtbl->DestroyPlayer(p,a)
+#define IDirectPlay_EnableNewPlayers(p,a)           (p)->lpVtbl->EnableNewPlayers(p,a)
+#define IDirectPlay_EnumGroupPlayers(p,a,b,c,d)     (p)->lpVtbl->EnumGroupPlayers(p,a,b,c,d)
+#define IDirectPlay_EnumGroups(p,a,b,c,d)           (p)->lpVtbl->EnumGroups(p,a,b,c,d)
+#define IDirectPlay_EnumPlayers(p,a,b,c,d)          (p)->lpVtbl->EnumPlayers(p,a,b,c,d)
+#define IDirectPlay_EnumSessions(p,a,b,c,d,e)       (p)->lpVtbl->EnumSessions(p,a,b,c,d,e)
+#define IDirectPlay_GetCaps(p,a)                    (p)->lpVtbl->GetCaps(p,a)
+#define IDirectPlay_GetMessageCount(p,a,b)          (p)->lpVtbl->GetMessageCount(p,a,b)
+#define IDirectPlay_GetPlayerCaps(p,a,b)            (p)->lpVtbl->GetPlayerCaps(p,a,b)
+#define IDirectPlay_GetPlayerName(p,a,b,c,d,e)      (p)->lpVtbl->GetPlayerName(p,a,b,c,d,e)
+#define IDirectPlay_Initialize(p,a)                 (p)->lpVtbl->Initialize(p,a)
+#define IDirectPlay_Open(p,a)                       (p)->lpVtbl->Open(p,a)
+#define IDirectPlay_Receive(p,a,b,c,d,e)            (p)->lpVtbl->Receive(p,a,b,c,d,e)
+#define IDirectPlay_SaveSession(p,a)                (p)->lpVtbl->SaveSession(p,a)
+#define IDirectPlay_Send(p,a,b,c,d,e)               (p)->lpVtbl->Send(p,a,b,c,d,e)
+#define IDirectPlay_SetPlayerName(p,a,b,c)          (p)->lpVtbl->SetPlayerName(p,a,b,c)
+
+#else /* C++ */
+
+#define IDirectPlay_AddPlayerToGroup(p,a,b)         (p)->AddPlayerToGroup(a,b)
+#define IDirectPlay_Close(p)                        (p)->Close()
+#define IDirectPlay_CreateGroup(p,a,b,c)            (p)->CreateGroup(a,b,c)
+#define IDirectPlay_CreatePlayer(p,a,b,c,d)         (p)->CreatePlayer(a,b,c,d)
+#define IDirectPlay_DeletePlayerFromGroup(p,a,b)    (p)->DeletePlayerFromGroup(a,b)
+#define IDirectPlay_DestroyGroup(p,a)               (p)->DestroyGroup(a)
+#define IDirectPlay_DestroyPlayer(p,a)              (p)->DestroyPlayer(a)
+#define IDirectPlay_EnableNewPlayers(p,a)           (p)->EnableNewPlayers(a)
+#define IDirectPlay_EnumGroupPlayers(p,a,b,c,d)     (p)->EnumGroupPlayers(a,b,c,d)
+#define IDirectPlay_EnumGroups(p,a,b,c,d)           (p)->EnumGroups(a,b,c,d)
+#define IDirectPlay_EnumPlayers(p,a,b,c,d)          (p)->EnumPlayers(a,b,c,d)
+#define IDirectPlay_EnumSessions(p,a,b,c,d,e)       (p)->EnumSessions(a,b,c,d,e)
+#define IDirectPlay_GetCaps(p,a)                    (p)->GetCaps(a)
+#define IDirectPlay_GetMessageCount(p,a,b)          (p)->GetMessageCount(a,b)
+#define IDirectPlay_GetPlayerCaps(p,a,b)            (p)->GetPlayerCaps(a,b)
+#define IDirectPlay_GetPlayerName(p,a,b,c,d,e)      (p)->GetPlayerName(a,b,c,d,e)
+#define IDirectPlay_Initialize(p,a)                 (p)->Initialize(a)
+#define IDirectPlay_Open(p,a)                       (p)->Open(a)
+#define IDirectPlay_Receive(p,a,b,c,d,e)            (p)->Receive(a,b,c,d,e)
+#define IDirectPlay_SaveSession(p,a)                (p)->SaveSession(a)
+#define IDirectPlay_Send(p,a,b,c,d,e)               (p)->Send(a,b,c,d,e)
+#define IDirectPlay_SetPlayerName(p,a,b,c)          (p)->SetPlayerName(a,b,c)
+
+#endif
+
+DEFINE_GUID(IID_IDirectPlay, 0x5454e9a0, 0xdb65, 0x11ce, 0x92, 0x1c, 0x00, 0xaa, 0x00, 0x6c, 0x49, 0x72);
+
+#endif // IDIRECTPLAY2_OR_GREATER
+
+/****************************************************************************
+ *
+ * IDirectPlay macros (included regardless of IDIRECTPLAY2_OR_GREATER flag)
+ *
+ ****************************************************************************/
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+
+#define IDirectPlay_QueryInterface(p,a,b)           (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirectPlay_AddRef(p)                       (p)->lpVtbl->AddRef(p)
+#define IDirectPlay_Release(p)                      (p)->lpVtbl->Release(p)
+
+#else
+
+#define IDirectPlay_QueryInterface(p,a,b)           (p)->QueryInterface(a,b)
+#define IDirectPlay_AddRef(p)                       (p)->AddRef()
+#define IDirectPlay_Release(p)                      (p)->Release()
+
+#endif // IDirectPlay interface macros 
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif
diff --git a/3rdparty/dx5/inc/dplobby.h b/3rdparty/dx5/inc/dplobby.h
new file mode 100644
index 00000000..a1d58963
--- /dev/null
+++ b/3rdparty/dx5/inc/dplobby.h
@@ -0,0 +1,627 @@
+/*==========================================================================;
+ *
+ *  Copyright (C) 1996-1997 Microsoft Corporation.  All Rights Reserved.
+ *
+ *  File:       dplobby.h
+ *  Content:    DirectPlayLobby include file
+ ***************************************************************************/
+#ifndef __DPLOBBY_INCLUDED__
+#define __DPLOBBY_INCLUDED__
+
+#include "dplay.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*
+ * GUIDS used by DirectPlay objects
+ */
+
+/* {AF465C71-9588-11cf-A020-00AA006157AC} */
+DEFINE_GUID(IID_IDirectPlayLobby, 0xaf465c71, 0x9588, 0x11cf, 0xa0, 0x20, 0x0, 0xaa, 0x0, 0x61, 0x57, 0xac);
+/* {26C66A70-B367-11cf-A024-00AA006157AC} */
+DEFINE_GUID(IID_IDirectPlayLobbyA, 0x26c66a70, 0xb367, 0x11cf, 0xa0, 0x24, 0x0, 0xaa, 0x0, 0x61, 0x57, 0xac);
+/* {0194C220-A303-11d0-9C4F-00A0C905425E} */
+DEFINE_GUID(IID_IDirectPlayLobby2, 0x194c220, 0xa303, 0x11d0, 0x9c, 0x4f, 0x0, 0xa0, 0xc9, 0x5, 0x42, 0x5e);
+/* {1BB4AF80-A303-11d0-9C4F-00A0C905425E} */
+DEFINE_GUID(IID_IDirectPlayLobby2A, 0x1bb4af80, 0xa303, 0x11d0, 0x9c, 0x4f, 0x0, 0xa0, 0xc9, 0x5, 0x42, 0x5e);
+/* {2FE8F810-B2A5-11d0-A787-0000F803ABFC} */
+DEFINE_GUID(CLSID_DirectPlayLobby, 0x2fe8f810, 0xb2a5, 0x11d0, 0xa7, 0x87, 0x0, 0x0, 0xf8, 0x3, 0xab, 0xfc);
+
+
+/****************************************************************************
+ *
+ * IDirectPlayLobby Structures
+ *
+ * Various structures used to invoke DirectPlayLobby.
+ *
+ ****************************************************************************/
+
+typedef struct IDirectPlayLobby     FAR *LPDIRECTPLAYLOBBY;
+typedef struct IDirectPlayLobby     FAR *LPDIRECTPLAYLOBBYA;
+typedef struct IDirectPlayLobby     IDirectPlayLobbyA;
+
+typedef struct IDirectPlayLobby2    FAR *LPDIRECTPLAYLOBBY2;
+typedef struct IDirectPlayLobby2    FAR *LPDIRECTPLAYLOBBY2A;
+typedef struct IDirectPlayLobby2    IDirectPlayLobby2A;
+
+
+/*
+ * DPLAPPINFO
+ * Used to hold information about a registered DirectPlay
+ * application
+ */
+typedef struct DPLAPPINFO
+{
+    DWORD       dwSize;             // Size of this structure
+    GUID        guidApplication;    // GUID of the Application
+    union
+    {
+        LPSTR   lpszAppNameA;       // Pointer to the Application Name
+        LPWSTR  lpszAppName;
+    };
+
+} DPLAPPINFO, FAR *LPDPLAPPINFO;
+
+/*
+ * LPCDPLAPPINFO
+ * A constant pointer to DPLAPPINFO
+ */
+typedef const DPLAPPINFO FAR *LPCDPLAPPINFO;
+
+/*
+ * DPCOMPOUNDADDRESSELEMENT
+ *
+ * An array of these is passed to CreateCompoundAddresses()
+ */
+typedef struct DPCOMPOUNDADDRESSELEMENT
+{
+    GUID                guidDataType;
+    DWORD               dwDataSize;
+	LPVOID				lpData;
+} DPCOMPOUNDADDRESSELEMENT, FAR *LPDPCOMPOUNDADDRESSELEMENT;
+
+/*
+ * LPCDPCOMPOUNDADDRESSELEMENT
+ * A constant pointer to DPCOMPOUNDADDRESSELEMENT
+ */
+typedef const DPCOMPOUNDADDRESSELEMENT FAR *LPCDPCOMPOUNDADDRESSELEMENT;
+
+
+/****************************************************************************
+ *
+ * Enumeration Method Callback Prototypes
+ *
+ ****************************************************************************/
+
+/*
+ * Callback for EnumAddress()
+ */
+typedef BOOL (FAR PASCAL *LPDPENUMADDRESSCALLBACK)(
+    REFGUID         guidDataType,
+    DWORD           dwDataSize,
+    LPCVOID         lpData,
+    LPVOID          lpContext);
+
+/*
+ * Callback for EnumAddressTypes()
+ */
+typedef BOOL (FAR PASCAL *LPDPLENUMADDRESSTYPESCALLBACK)(
+    REFGUID         guidDataType,
+    LPVOID          lpContext,
+    DWORD           dwFlags);
+
+/*
+ * Callback for EnumLocalApplications()
+ */
+typedef BOOL (FAR PASCAL * LPDPLENUMLOCALAPPLICATIONSCALLBACK)(
+    LPCDPLAPPINFO   lpAppInfo,
+    LPVOID          lpContext,
+    DWORD           dwFlags);
+
+
+/****************************************************************************
+ *
+ * DirectPlayLobby API Prototypes
+ *
+ ****************************************************************************/
+#ifdef UNICODE
+#define DirectPlayLobbyCreate   DirectPlayLobbyCreateW
+#else
+#define DirectPlayLobbyCreate   DirectPlayLobbyCreateA
+#endif /* UNICODE */
+
+extern HRESULT WINAPI DirectPlayLobbyCreateW(LPGUID, LPDIRECTPLAYLOBBY *, IUnknown *, LPVOID, DWORD );
+extern HRESULT WINAPI DirectPlayLobbyCreateA(LPGUID, LPDIRECTPLAYLOBBYA *, IUnknown *, LPVOID, DWORD );
+
+
+/****************************************************************************
+ *
+ * IDirectPlayLobby (and IDirectPlayLobbyA) Interface
+ *
+ ****************************************************************************/
+#undef INTERFACE
+#define INTERFACE IDirectPlayLobby
+DECLARE_INTERFACE_( IDirectPlayLobby, IUnknown )
+{
+    /*  IUnknown Methods	*/
+    STDMETHOD(QueryInterface)       (THIS_ REFIID riid, LPVOID * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef)        (THIS) PURE;
+    STDMETHOD_(ULONG,Release)       (THIS) PURE;
+
+    /*  IDirectPlayLobby Methods	*/
+    STDMETHOD(Connect)              (THIS_ DWORD, LPDIRECTPLAY2 *, IUnknown FAR *) PURE;
+    STDMETHOD(CreateAddress)        (THIS_ REFGUID, REFGUID, LPCVOID, DWORD, LPVOID, LPDWORD) PURE;
+    STDMETHOD(EnumAddress)          (THIS_ LPDPENUMADDRESSCALLBACK, LPCVOID, DWORD, LPVOID) PURE;
+    STDMETHOD(EnumAddressTypes)     (THIS_ LPDPLENUMADDRESSTYPESCALLBACK, REFGUID, LPVOID, DWORD) PURE;
+    STDMETHOD(EnumLocalApplications)(THIS_ LPDPLENUMLOCALAPPLICATIONSCALLBACK, LPVOID, DWORD) PURE;
+    STDMETHOD(GetConnectionSettings)(THIS_ DWORD, LPVOID, LPDWORD) PURE;
+    STDMETHOD(ReceiveLobbyMessage)  (THIS_ DWORD, DWORD, LPDWORD, LPVOID, LPDWORD) PURE;
+    STDMETHOD(RunApplication)       (THIS_ DWORD, LPDWORD, LPDPLCONNECTION, HANDLE) PURE;
+    STDMETHOD(SendLobbyMessage)     (THIS_ DWORD, DWORD, LPVOID, DWORD) PURE;
+    STDMETHOD(SetConnectionSettings)(THIS_ DWORD, DWORD, LPDPLCONNECTION) PURE;
+    STDMETHOD(SetLobbyMessageEvent) (THIS_ DWORD, DWORD, HANDLE) PURE;
+
+};
+
+/****************************************************************************
+ *
+ * IDirectPlayLobby2 (and IDirectPlayLobby2A) Interface
+ *
+ ****************************************************************************/
+#undef INTERFACE
+#define INTERFACE IDirectPlayLobby2
+DECLARE_INTERFACE_( IDirectPlayLobby2, IDirectPlayLobby )
+{
+    /*  IUnknown Methods	*/
+    STDMETHOD(QueryInterface)       (THIS_ REFIID riid, LPVOID * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef)        (THIS) PURE;
+    STDMETHOD_(ULONG,Release)       (THIS) PURE;
+
+    /*  IDirectPlayLobby Methods	*/
+    STDMETHOD(Connect)              (THIS_ DWORD, LPDIRECTPLAY2 *, IUnknown FAR *) PURE;
+    STDMETHOD(CreateAddress)        (THIS_ REFGUID, REFGUID, LPCVOID, DWORD, LPVOID, LPDWORD) PURE;
+    STDMETHOD(EnumAddress)          (THIS_ LPDPENUMADDRESSCALLBACK, LPCVOID, DWORD, LPVOID) PURE;
+    STDMETHOD(EnumAddressTypes)     (THIS_ LPDPLENUMADDRESSTYPESCALLBACK, REFGUID, LPVOID, DWORD) PURE;
+    STDMETHOD(EnumLocalApplications)(THIS_ LPDPLENUMLOCALAPPLICATIONSCALLBACK, LPVOID, DWORD) PURE;
+    STDMETHOD(GetConnectionSettings)(THIS_ DWORD, LPVOID, LPDWORD) PURE;
+    STDMETHOD(ReceiveLobbyMessage)  (THIS_ DWORD, DWORD, LPDWORD, LPVOID, LPDWORD) PURE;
+    STDMETHOD(RunApplication)       (THIS_ DWORD, LPDWORD, LPDPLCONNECTION, HANDLE) PURE;
+    STDMETHOD(SendLobbyMessage)     (THIS_ DWORD, DWORD, LPVOID, DWORD) PURE;
+    STDMETHOD(SetConnectionSettings)(THIS_ DWORD, DWORD, LPDPLCONNECTION) PURE;
+    STDMETHOD(SetLobbyMessageEvent) (THIS_ DWORD, DWORD, HANDLE) PURE;
+
+    /*  IDirectPlayLobby2 Methods	*/
+    STDMETHOD(CreateCompoundAddress)(THIS_ LPCDPCOMPOUNDADDRESSELEMENT,DWORD,LPVOID,LPDWORD) PURE;
+};
+
+/****************************************************************************
+ *
+ * IDirectPlayLobby interface macros
+ *
+ ****************************************************************************/
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+
+#define IDirectPlayLobby_QueryInterface(p,a,b)              (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirectPlayLobby_AddRef(p)                          (p)->lpVtbl->AddRef(p)
+#define IDirectPlayLobby_Release(p)                         (p)->lpVtbl->Release(p)
+#define IDirectPlayLobby_Connect(p,a,b,c)                   (p)->lpVtbl->Connect(p,a,b,c)
+#define IDirectPlayLobby_CreateAddress(p,a,b,c,d,e,f)       (p)->lpVtbl->CreateAddress(p,a,b,c,d,e,f)
+#define IDirectPlayLobby_CreateCompoundAddress(p,a,b,c,d)   (p)->lpVtbl->CreateCompoundAddress(p,a,b,c,d)
+#define IDirectPlayLobby_EnumAddress(p,a,b,c,d)             (p)->lpVtbl->EnumAddress(p,a,b,c,d)
+#define IDirectPlayLobby_EnumAddressTypes(p,a,b,c,d)        (p)->lpVtbl->EnumAddressTypes(p,a,b,c,d)
+#define IDirectPlayLobby_EnumLocalApplications(p,a,b,c)     (p)->lpVtbl->EnumLocalApplications(p,a,b,c)
+#define IDirectPlayLobby_GetConnectionSettings(p,a,b,c)     (p)->lpVtbl->GetConnectionSettings(p,a,b,c)
+#define IDirectPlayLobby_ReceiveLobbyMessage(p,a,b,c,d,e)   (p)->lpVtbl->ReceiveLobbyMessage(p,a,b,c,d,e)
+#define IDirectPlayLobby_RunApplication(p,a,b,c,d)          (p)->lpVtbl->RunApplication(p,a,b,c,d)
+#define IDirectPlayLobby_SendLobbyMessage(p,a,b,c,d)        (p)->lpVtbl->SendLobbyMessage(p,a,b,c,d)
+#define IDirectPlayLobby_SetConnectionSettings(p,a,b,c)		(p)->lpVtbl->SetConnectionSettings(p,a,b,c)
+#define IDirectPlayLobby_SetLobbyMessageEvent(p,a,b,c)	    (p)->lpVtbl->SetLobbyMessageEvent(p,a,b,c)
+
+#else /* C++ */
+
+#define IDirectPlayLobby_QueryInterface(p,a,b)              (p)->QueryInterface(a,b)
+#define IDirectPlayLobby_AddRef(p)                          (p)->AddRef()
+#define IDirectPlayLobby_Release(p)                         (p)->Release()
+#define IDirectPlayLobby_Connect(p,a,b,c)                   (p)->Connect(a,b,c)
+#define IDirectPlayLobby_CreateAddress(p,a,b,c,d,e,f)       (p)->CreateAddress(a,b,c,d,e,f)
+#define IDirectPlayLobby_CreateCompoundAddress(p,a,b,c,d)   (p)->lpVtbl->CreateCompoundAddress(a,b,c,d)
+#define IDirectPlayLobby_EnumAddress(p,a,b,c,d)             (p)->EnumAddress(a,b,c,d)
+#define IDirectPlayLobby_EnumAddressTypes(p,a,b,c,d)        (p)->EnumAddressTypes(a,b,c,d)
+#define IDirectPlayLobby_EnumLocalApplications(p,a,b,c)     (p)->EnumLocalApplications(a,b,c)
+#define IDirectPlayLobby_GetConnectionSettings(p,a,b,c)     (p)->GetConnectionSettings(a,b,c)
+#define IDirectPlayLobby_ReceiveLobbyMessage(p,a,b,c,d,e)   (p)->ReceiveLobbyMessage(a,b,c,d,e)
+#define IDirectPlayLobby_RunApplication(p,a,b,c,d)          (p)->RunApplication(a,b,c,d)
+#define IDirectPlayLobby_SendLobbyMessage(p,a,b,c,d)        (p)->SendLobbyMessage(a,b,c,d)
+#define IDirectPlayLobby_SetConnectionSettings(p,a,b,c)		(p)->SetConnectionSettings(a,b,c)
+#define IDirectPlayLobby_SetLobbyMessageEvent(p,a,b,c)	    (p)->SetLobbyMessageEvent(a,b,c)
+
+#endif
+
+/****************************************************************************
+ *
+ * DirectPlayLobby Flags
+ *
+ ****************************************************************************/
+
+/*
+ *	This is a message flag used by ReceiveLobbyMessage.  It can be
+ *	returned in the dwMessageFlags parameter to indicate a message from
+ *	the system.
+ */
+#define DPLMSG_SYSTEM					0x00000001
+
+/*
+ *	This is a message flag used by ReceiveLobbyMessage and SendLobbyMessage.
+ *  It is used to indicate that the message is a standard lobby message.
+ *  DPLMSG_SETPROPERTY, DPLMSG_SETPROPERTYRESPONSE, DPLMSG_GETPROPERTY,
+ *	DPLMSG_GETPROPERTYRESPONSE
+ */
+#define DPLMSG_STANDARD					0x00000002
+
+
+/****************************************************************************
+ *
+ * DirectPlayLobby messages and message data structures
+ *
+ * All system messages have a dwMessageFlags value of DPLMSG_SYSTEM returned
+ * from a call to ReceiveLobbyMessage.
+ *
+ * All standard messages have a dwMessageFlags value of DPLMSG_STANDARD returned
+ * from a call to ReceiveLobbyMessage.
+ *
+ ****************************************************************************/
+
+/*
+ * DPLMSG_GENERIC
+ * Generic message structure used to identify the message type.
+ */
+typedef struct _DPLMSG_GENERIC
+{
+    DWORD       dwType;         // Message type
+} DPLMSG_GENERIC, FAR *LPDPLMSG_GENERIC;
+
+/*
+ *  DPLMSG_SETPROPERTY
+ *  Standard message sent by an application to a lobby to set a
+ *  property
+ */
+typedef struct _DPLMSG_SETPROPERTY
+{
+	DWORD	dwType;				// Message type
+	DWORD	dwRequestID;		// Request ID (DPL_NOCONFIRMATION if no confirmation desired)
+	GUID	guidPlayer;			// Player GUID
+	GUID	guidPropertyTag;	// Property GUID
+	DWORD	dwDataSize;			// Size of data
+	DWORD	dwPropertyData[1];	// Buffer containing data
+} DPLMSG_SETPROPERTY, FAR *LPDPLMSG_SETPROPERTY;
+
+#define	DPL_NOCONFIRMATION			0
+
+/*
+ *  DPLMSG_SETPROPERTYRESPONSE
+ *  Standard message returned by a lobby to confirm a 
+ *  DPLMSG_SETPROPERTY message.
+ */
+typedef struct _DPLMSG_SETPROPERTYRESPONSE
+{
+	DWORD	dwType;				// Message type
+	DWORD	dwRequestID;		// Request ID
+	GUID	guidPlayer;			// Player GUID
+	GUID	guidPropertyTag;	// Property GUID
+	HRESULT	hr;					// Return Code
+} DPLMSG_SETPROPERTYRESPONSE, FAR *LPDPLMSG_SETPROPERTYRESPONSE;
+
+/*
+ *  DPLMSG_GETPROPERTY
+ *  Standard message sent by an application to a lobby to request
+ *	the current value of a property
+ */
+typedef struct _DPLMSG_GETPROPERTY
+{
+	DWORD	dwType;				// Message type
+	DWORD	dwRequestID;		// Request ID
+	GUID	guidPlayer;			// Player GUID
+	GUID	guidPropertyTag;	// Property GUID
+} DPLMSG_GETPROPERTY, FAR *LPDPLMSG_GETPROPERTY;
+
+/*
+ *  DPLMSG_GETPROPERTYRESPONSE
+ *  Standard message returned by a lobby in response to a
+ *	DPLMSG_GETPROPERTY message.
+ */
+typedef struct _DPLMSG_GETPROPERTYRESPONSE
+{
+	DWORD	dwType;				// Message type
+	DWORD	dwRequestID;		// Request ID
+	GUID	guidPlayer;			// Player GUID
+	GUID	guidPropertyTag;	// Property GUID
+	HRESULT	hr;					// Return Code
+	DWORD	dwDataSize;			// Size of data
+	DWORD	dwPropertyData[1];	// Buffer containing data
+} DPLMSG_GETPROPERTYRESPONSE, FAR *LPDPLMSG_GETPROPERTYRESPONSE;
+
+
+/******************************************
+ *
+ *	DirectPlay Lobby message dwType values
+ *
+ *****************************************/
+
+/*
+ *  The application has read the connection settings.
+ *  It is now O.K. for the lobby client to release
+ *  its IDirectPlayLobby interface.
+ */
+#define DPLSYS_CONNECTIONSETTINGSREAD   0x00000001
+
+/*
+ *  The application's call to DirectPlayConnect failed
+ */
+#define DPLSYS_DPLAYCONNECTFAILED       0x00000002
+
+/*
+ *  The application has created a DirectPlay session.
+ */
+#define DPLSYS_DPLAYCONNECTSUCCEEDED    0x00000003
+
+/*
+ *  The application has terminated.
+ */
+#define DPLSYS_APPTERMINATED            0x00000004
+
+/*
+ *  The message is a DPLMSG_SETPROPERTY message.
+ */
+#define DPLSYS_SETPROPERTY				0x00000005
+
+/*
+ *  The message is a DPLMSG_SETPROPERTYRESPONSE message.
+ */
+#define DPLSYS_SETPROPERTYRESPONSE		0x00000006
+
+/*
+ *  The message is a DPLMSG_GETPROPERTY message.
+ */
+#define DPLSYS_GETPROPERTY				0x00000007
+
+/*
+ *  The message is a DPLMSG_GETPROPERTYRESPONSE message.
+ */
+#define DPLSYS_GETPROPERTYRESPONSE		0x00000008
+
+
+/****************************************************************************
+ *
+ * DirectPlay defined property GUIDs and associated data structures
+ *
+ ****************************************************************************/
+
+/*
+ * DPLPROPERTY_MessagesSupported
+ *
+ * Request whether the lobby supports standard.  Lobby with respond with either
+ * TRUE or FALSE or may not respond at all.
+ * 
+ * Property data is a single BOOL with TRUE or FALSE
+ */
+// {762CCDA1-D916-11d0-BA39-00C04FD7ED67}
+DEFINE_GUID(DPLPROPERTY_MessagesSupported, 
+0x762ccda1, 0xd916, 0x11d0, 0xba, 0x39, 0x0, 0xc0, 0x4f, 0xd7, 0xed, 0x67);
+
+/*
+ * DPLPROPERTY_LobbyGuid
+ *
+ * Request the GUID that identifies the lobby software that the application
+ * is communicating with.
+ *
+ * Property data is a single GUID.
+ */
+// {F56920A0-D218-11d0-BA39-00C04FD7ED67}
+DEFINE_GUID(DPLPROPERTY_LobbyGuid, 
+0xf56920a0, 0xd218, 0x11d0, 0xba, 0x39, 0x0, 0xc0, 0x4f, 0xd7, 0xed, 0x67);
+
+/*
+ * DPLPROPERTY_PlayerGuid
+ *
+ * Request the GUID that identifies the player on this machine for sending
+ * property data back to the lobby.
+ *
+ * Property data is the DPLDATA_PLAYERDATA structure
+ */
+// {B4319322-D20D-11d0-BA39-00C04FD7ED67}
+DEFINE_GUID(DPLPROPERTY_PlayerGuid, 
+0xb4319322, 0xd20d, 0x11d0, 0xba, 0x39, 0x0, 0xc0, 0x4f, 0xd7, 0xed, 0x67);
+
+/*
+ * DPLDATA_PLAYERGUID
+ *
+ * Data structure to hold the GUID of the player and player creation flags
+ * from the lobby.
+ */
+typedef struct _DPLDATA_PLAYERGUID
+{
+	GUID	guidPlayer;
+	DWORD	dwPlayerFlags;
+} DPLDATA_PLAYERGUID, FAR *LPDPLDATA_PLAYERGUID;
+
+/*
+ * DPLPROPERTY_PlayerScore
+ *
+ * Used to send an array of long integers to the lobby indicating the 
+ * score of a player.
+ *
+ * Property data is the DPLDATA_PLAYERSCORE structure.
+ */
+// {48784000-D219-11d0-BA39-00C04FD7ED67}
+DEFINE_GUID(DPLPROPERTY_PlayerScore, 
+0x48784000, 0xd219, 0x11d0, 0xba, 0x39, 0x0, 0xc0, 0x4f, 0xd7, 0xed, 0x67);
+
+/*
+ * DPLDATA_PLAYERSCORE
+ *
+ * Data structure to hold an array of long integers representing a player score.
+ * Application must allocate enough memory to hold all the scores.
+ */
+typedef struct _DPLDATA_PLAYERSCORE
+{
+	DWORD	dwScoreCount;
+	LONG	Score[1];
+} DPLDATA_PLAYERSCORE, FAR *LPDPLDATA_PLAYERSCORE;
+
+/****************************************************************************
+ *
+ * DirectPlay Address ID's
+ *
+ ****************************************************************************/
+
+/* DirectPlay Address
+ *
+ * A DirectPlay address consists of multiple chunks of data, each tagged
+ * with a GUID signifying the type of data in the chunk. The chunk also
+ * has a length so that unknown chunk types can be skipped.
+ *
+ * The EnumAddress() function is used to parse these address data chunks.
+ */
+
+/*
+ * DPADDRESS
+ *
+ * Header for block of address data elements
+ */
+typedef struct _DPADDRESS
+{
+    GUID                guidDataType;
+    DWORD               dwDataSize;
+} DPADDRESS;
+
+typedef DPADDRESS FAR *LPDPADDRESS;
+
+/*
+ * DPAID_TotalSize
+ *
+ * Chunk is a DWORD containing size of entire DPADDRESS structure
+ */
+
+// {1318F560-912C-11d0-9DAA-00A0C90A43CB}
+DEFINE_GUID(DPAID_TotalSize, 
+0x1318f560, 0x912c, 0x11d0, 0x9d, 0xaa, 0x0, 0xa0, 0xc9, 0xa, 0x43, 0xcb);
+
+/*
+ * DPAID_ServiceProvider
+ *
+ * Chunk is a GUID describing the service provider that created the chunk.
+ * All addresses must contain this chunk.
+ */
+
+// {07D916C0-E0AF-11cf-9C4E-00A0C905425E}
+DEFINE_GUID(DPAID_ServiceProvider, 
+0x7d916c0, 0xe0af, 0x11cf, 0x9c, 0x4e, 0x0, 0xa0, 0xc9, 0x5, 0x42, 0x5e);
+
+/*
+ * DPAID_LobbyProvider
+ *
+ * Chunk is a GUID describing the lobby provider that created the chunk.
+ * All addresses must contain this chunk.
+ */
+
+// {59B95640-9667-11d0-A77D-0000F803ABFC}
+DEFINE_GUID(DPAID_LobbyProvider, 
+0x59b95640, 0x9667, 0x11d0, 0xa7, 0x7d, 0x0, 0x0, 0xf8, 0x3, 0xab, 0xfc);
+
+/*
+ * DPAID_Phone and DPAID_PhoneW
+ *
+ * Chunk is a string containing a phone number (i.e. "1-800-555-1212")
+ * in ANSI or UNICODE format
+ */
+
+// {78EC89A0-E0AF-11cf-9C4E-00A0C905425E}
+DEFINE_GUID(DPAID_Phone, 
+0x78ec89a0, 0xe0af, 0x11cf, 0x9c, 0x4e, 0x0, 0xa0, 0xc9, 0x5, 0x42, 0x5e);
+
+// {BA5A7A70-9DBF-11d0-9CC1-00A0C905425E}
+DEFINE_GUID(DPAID_PhoneW, 
+0xba5a7a70, 0x9dbf, 0x11d0, 0x9c, 0xc1, 0x0, 0xa0, 0xc9, 0x5, 0x42, 0x5e);
+
+/*
+ * DPAID_Modem and DPAID_ModemW
+ *
+ * Chunk is a string containing a modem name registered with TAPI
+ * in ANSI or UNICODE format
+ */
+
+// {F6DCC200-A2FE-11d0-9C4F-00A0C905425E}
+DEFINE_GUID(DPAID_Modem, 
+0xf6dcc200, 0xa2fe, 0x11d0, 0x9c, 0x4f, 0x0, 0xa0, 0xc9, 0x5, 0x42, 0x5e);
+
+// {01FD92E0-A2FF-11d0-9C4F-00A0C905425E}
+DEFINE_GUID(DPAID_ModemW, 
+0x1fd92e0, 0xa2ff, 0x11d0, 0x9c, 0x4f, 0x0, 0xa0, 0xc9, 0x5, 0x42, 0x5e);
+
+/*
+ * DPAID_Inet and DPAID_InetW
+ *
+ * Chunk is a string containing a TCP/IP host name or an IP address
+ * (i.e. "dplay.microsoft.com" or "137.55.100.173") in ANSI or UNICODE format
+ */
+
+// {C4A54DA0-E0AF-11cf-9C4E-00A0C905425E}
+DEFINE_GUID(DPAID_INet, 
+0xc4a54da0, 0xe0af, 0x11cf, 0x9c, 0x4e, 0x0, 0xa0, 0xc9, 0x5, 0x42, 0x5e);
+
+// {E63232A0-9DBF-11d0-9CC1-00A0C905425E}
+DEFINE_GUID(DPAID_INetW, 
+0xe63232a0, 0x9dbf, 0x11d0, 0x9c, 0xc1, 0x0, 0xa0, 0xc9, 0x5, 0x42, 0x5e);
+
+/*
+ * DPCOMPORTADDRESS
+ *
+ * Used to specify com port settings. The constants that define baud rate,
+ * stop bits and parity are defined in WINBASE.H. The constants for flow
+ * control are given below.
+ */
+
+#define DPCPA_NOFLOW        0           // no flow control
+#define DPCPA_XONXOFFFLOW   1           // software flow control
+#define DPCPA_RTSFLOW       2           // hardware flow control with RTS
+#define DPCPA_DTRFLOW       3           // hardware flow control with DTR
+#define DPCPA_RTSDTRFLOW    4           // hardware flow control with RTS and DTR
+
+typedef struct _DPCOMPORTADDRESS
+{
+    DWORD   dwComPort;                  // COM port to use (1-4)
+    DWORD   dwBaudRate;                 // baud rate (100-256k)
+    DWORD   dwStopBits;                 // no. stop bits (1-2)
+    DWORD   dwParity;                   // parity (none, odd, even, mark)
+    DWORD   dwFlowControl;              // flow control (none, xon/xoff, rts, dtr)
+} DPCOMPORTADDRESS;
+
+typedef DPCOMPORTADDRESS FAR *LPDPCOMPORTADDRESS;
+
+/*
+ * DPAID_ComPort
+ *
+ * Chunk contains a DPCOMPORTADDRESS structure defining the serial port.
+ */
+
+// {F2F0CE00-E0AF-11cf-9C4E-00A0C905425E}
+DEFINE_GUID(DPAID_ComPort, 
+0xf2f0ce00, 0xe0af, 0x11cf, 0x9c, 0x4e, 0x0, 0xa0, 0xc9, 0x5, 0x42, 0x5e);
+
+/****************************************************************************
+ *
+ * 	dplobby 1.0 obsolete definitions
+ *	Included for compatibility only.
+ *
+ ****************************************************************************/
+#define DPLAD_SYSTEM          DPLMSG_SYSTEM
+
+
+#ifdef __cplusplus
+};
+#endif /* __cplusplus */
+
+#endif /* __DPLOBBY_INCLUDED__ */
diff --git a/3rdparty/dx5/inc/dsetup.h b/3rdparty/dx5/inc/dsetup.h
new file mode 100644
index 00000000..ea5936a5
--- /dev/null
+++ b/3rdparty/dx5/inc/dsetup.h
@@ -0,0 +1,267 @@
+/*==========================================================================
+ *
+ *  Copyright (C) 1995-1997 Microsoft Corporation.  All Rights Reserved.
+ *
+ *  File:       dsetup.h
+ *  Content:    DirectXSetup, error codes and flags
+ ***************************************************************************/
+
+#ifndef __DSETUP_H__
+#define __DSETUP_H__
+
+#include <windows.h>      // windows stuff
+
+#ifdef _WIN32
+#define COM_NO_WINDOWS_H
+#include <objbase.h>
+#else
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// DSETUP Error Codes, must remain compatible with previous setup.
+#define DSETUPERR_SUCCESS_RESTART        1
+#define DSETUPERR_SUCCESS                0
+#define DSETUPERR_BADWINDOWSVERSION     -1
+#define DSETUPERR_SOURCEFILENOTFOUND    -2
+#define DSETUPERR_BADSOURCESIZE         -3
+#define DSETUPERR_BADSOURCETIME         -4
+#define DSETUPERR_NOCOPY                -5
+#define DSETUPERR_OUTOFDISKSPACE        -6
+#define DSETUPERR_CANTFINDINF           -7
+#define DSETUPERR_CANTFINDDIR           -8
+#define DSETUPERR_INTERNAL              -9
+#define DSETUPERR_NTWITHNO3D            -10  /* REM: obsolete, you'll never see this */
+#define DSETUPERR_UNKNOWNOS             -11
+#define DSETUPERR_USERHITCANCEL         -12
+#define DSETUPERR_NOTPREINSTALLEDONNT   -13
+
+// DSETUP flags. DirectX 5.0 apps should use these flags only.
+#define DSETUP_DDRAWDRV         0x00000008      /* install DirectDraw Drivers           */
+#define DSETUP_DSOUNDDRV        0x00000010      /* install DirectSound Drivers          */
+#define DSETUP_DXCORE           0x00010000	/* install DirectX runtime              */
+#define DSETUP_DIRECTX  (DSETUP_DXCORE|DSETUP_DDRAWDRV|DSETUP_DSOUNDDRV)
+#define DSETUP_TESTINSTALL      0x00020000      /* just test install, don't do anything */
+
+// These OBSOLETE flags are here for compatibility with pre-DX5 apps only.
+// They are present to allow DX3 apps to be recompiled with DX5 and still work.
+// DO NOT USE THEM for DX5. They will go away in future DX releases.
+#define DSETUP_DDRAW            0x00000001      /* OBSOLETE. install DirectDraw           */
+#define DSETUP_DSOUND           0x00000002      /* OBSOLETE. install DirectSound          */
+#define DSETUP_DPLAY            0x00000004      /* OBSOLETE. install DirectPlay           */
+#define DSETUP_DPLAYSP          0x00000020      /* OBSOLETE. install DirectPlay Providers */
+#define DSETUP_DVIDEO           0x00000040      /* OBSOLETE. install DirectVideo          */
+#define DSETUP_D3D              0x00000200      /* OBSOLETE. install Direct3D             */
+#define DSETUP_DINPUT           0x00000800      /* OBSOLETE. install DirectInput          */
+#define DSETUP_DIRECTXSETUP     0x00001000      /* OBSOLETE. install DirectXSetup DLL's   */
+#define DSETUP_NOUI             0x00002000      /* OBSOLETE. install DirectX with NO UI   */
+#define DSETUP_PROMPTFORDRIVERS 0x10000000      /* OBSOLETE. prompt when replacing display/audio drivers */
+#define DSETUP_RESTOREDRIVERS   0x20000000      /* OBSOLETE. restore display/audio drivers */
+
+
+
+//******************************************************************
+// DirectX Setup Callback mechanism
+//******************************************************************
+
+// DSETUP Message Info Codes, passed to callback as Reason parameter.
+#define DSETUP_CB_MSG_NOMESSAGE                     0
+#define DSETUP_CB_MSG_CANTINSTALL_UNKNOWNOS         1
+#define DSETUP_CB_MSG_CANTINSTALL_NT                2
+#define DSETUP_CB_MSG_CANTINSTALL_BETA              3
+#define DSETUP_CB_MSG_CANTINSTALL_NOTWIN32          4
+#define DSETUP_CB_MSG_CANTINSTALL_WRONGLANGUAGE     5
+#define DSETUP_CB_MSG_CANTINSTALL_WRONGPLATFORM     6
+#define DSETUP_CB_MSG_PREINSTALL_NT                 7
+#define DSETUP_CB_MSG_NOTPREINSTALLEDONNT           8
+#define DSETUP_CB_MSG_SETUP_INIT_FAILED             9
+#define DSETUP_CB_MSG_INTERNAL_ERROR                10
+#define DSETUP_CB_MSG_CHECK_DRIVER_UPGRADE          11
+#define DSETUP_CB_MSG_OUTOFDISKSPACE                12
+#define DSETUP_CB_MSG_BEGIN_INSTALL                 13
+#define DSETUP_CB_MSG_BEGIN_INSTALL_RUNTIME         14
+#define DSETUP_CB_MSG_BEGIN_INSTALL_DRIVERS         15
+#define DSETUP_CB_MSG_BEGIN_RESTORE_DRIVERS         16
+#define DSETUP_CB_MSG_FILECOPYERROR                 17
+
+
+#define DSETUP_CB_UPGRADE_TYPE_MASK             0x000F
+#define DSETUP_CB_UPGRADE_KEEP                  0x0001
+#define DSETUP_CB_UPGRADE_SAFE                  0x0002
+#define DSETUP_CB_UPGRADE_FORCE                 0x0004
+#define DSETUP_CB_UPGRADE_UNKNOWN               0x0008
+
+#define DSETUP_CB_UPGRADE_HASWARNINGS           0x0100
+#define DSETUP_CB_UPGRADE_CANTBACKUP            0x0200
+
+#define DSETUP_CB_UPGRADE_DEVICE_ACTIVE         0x0800
+
+#define DSETUP_CB_UPGRADE_DEVICE_DISPLAY        0x1000
+#define DSETUP_CB_UPGRADE_DEVICE_MEDIA          0x2000
+
+
+typedef struct _DSETUP_CB_UPGRADEINFO
+{
+    DWORD UpgradeFlags;
+} DSETUP_CB_UPGRADEINFO;
+
+typedef struct _DSETUP_CB_FILECOPYERROR
+{
+    DWORD dwError;
+} DSETUP_CB_FILECOPYERROR;
+
+
+#ifdef _WIN32
+//
+// Data Structures
+//
+#ifndef UNICODE_ONLY
+typedef struct _DIRECTXREGISTERAPPA {
+    DWORD    dwSize;
+    DWORD    dwFlags;
+    LPSTR    lpszApplicationName;
+    LPGUID   lpGUID;
+    LPSTR    lpszFilename;
+    LPSTR    lpszCommandLine;
+    LPSTR    lpszPath;
+    LPSTR    lpszCurrentDirectory;
+} DIRECTXREGISTERAPPA, *PDIRECTXREGISTERAPPA, *LPDIRECTXREGISTERAPPA;
+#endif //!UNICODE_ONLY
+#ifndef ANSI_ONLY
+typedef struct _DIRECTXREGISTERAPPW {
+    DWORD    dwSize;
+    DWORD    dwFlags;
+    LPWSTR   lpszApplicationName;
+    LPGUID   lpGUID;
+    LPWSTR   lpszFilename;
+    LPWSTR   lpszCommandLine;
+    LPWSTR   lpszPath;
+    LPWSTR   lpszCurrentDirectory;
+} DIRECTXREGISTERAPPW, *PDIRECTXREGISTERAPPW, *LPDIRECTXREGISTERAPPW;
+#endif //!ANSI_ONLY
+#ifdef UNICODE
+typedef DIRECTXREGISTERAPPW DIRECTXREGISTERAPP;
+typedef PDIRECTXREGISTERAPPW PDIRECTXREGISTERAPP;
+typedef LPDIRECTXREGISTERAPPW LPDIRECTXREGISTERAPP;
+#else
+typedef DIRECTXREGISTERAPPA DIRECTXREGISTERAPP;
+typedef PDIRECTXREGISTERAPPA PDIRECTXREGISTERAPP;
+typedef LPDIRECTXREGISTERAPPA LPDIRECTXREGISTERAPP;
+#endif // UNICODE
+
+
+//
+// API
+//
+#ifndef UNICODE_ONLY
+INT
+WINAPI
+DirectXSetupA(
+    HWND  hWnd,
+    LPSTR lpszRootPath,
+    DWORD dwFlags
+    );
+#endif //!UNICODE_ONLY
+#ifndef ANSI_ONLY
+INT
+WINAPI
+DirectXSetupW(
+    HWND   hWnd,
+    LPWSTR lpszRootPath,
+    DWORD  dwFlags
+    );
+#endif //!ANSI_ONLY
+#ifdef UNICODE
+#define DirectXSetup  DirectXSetupW
+#else
+#define DirectXSetup  DirectXSetupA
+#endif // !UNICODE
+
+#ifndef UNICODE_ONLY
+INT
+WINAPI
+DirectXDeviceDriverSetupA(
+    HWND  hWnd,
+    LPSTR lpszDriverClass,
+    LPSTR lpszDriverPath,
+    DWORD dwFlags
+    );
+#endif //!UNICODE_ONLY
+#ifndef ANSI_ONLY
+INT
+WINAPI
+DirectXDeviceDriverSetupW(
+    HWND   hWnd,
+    LPWSTR lpszDriverClass,
+    LPWSTR lpszDriverPath,
+    DWORD  dwFlags
+    );
+#endif //!ANSI_ONLY
+#ifdef UNICODE
+#define DirectXDeviceDriverSetup  DirectXDeviceDriverSetupW
+#else
+#define DirectXDeviceDriverSetup  DirectXDeviceDriverSetupA
+#endif // !UNICODE
+
+#ifndef UNICODE_ONLY
+INT
+WINAPI
+DirectXRegisterApplicationA(
+    HWND                  hWnd,
+    LPDIRECTXREGISTERAPPA lpDXRegApp
+    );
+#endif //!UNICODE_ONLY
+#ifndef ANSI_ONLY
+INT
+WINAPI
+DirectXRegisterApplicationW(
+    HWND                  hWnd,
+    LPDIRECTXREGISTERAPPW lpDXRegApp
+    );
+#endif //!ANSI_ONLY
+#ifdef UNICODE
+#define DirectXRegisterApplication  DirectXRegisterApplicationW
+#else
+#define DirectXRegisterApplication  DirectXRegisterApplicationA
+#endif // !UNICODE
+
+INT
+WINAPI
+DirectXUnRegisterApplication(
+    HWND     hWnd,
+    LPGUID   lpGUID
+    );
+
+//
+// Function Pointers
+//
+#ifdef UNICODE
+typedef INT (WINAPI * LPDIRECTXSETUP)(HWND, LPWSTR, DWORD);
+typedef INT (WINAPI * LPDIRECTXDEVICEDRIVERSETUP)(HWND, LPWSTR, LPSTR, DWORD);
+typedef INT (WINAPI * LPDIRECTXREGISTERAPPLICATION)(HWND, LPDIRECTXREGISTERAPPW);
+#else
+typedef INT (WINAPI * LPDIRECTXSETUP)(HWND, LPSTR, DWORD);
+typedef INT (WINAPI * LPDIRECTXDEVICEDRIVERSETUP)(HWND, LPSTR, LPSTR, DWORD);
+typedef INT (WINAPI * LPDIRECTXREGISTERAPPLICATION)(HWND, LPDIRECTXREGISTERAPPA);
+#endif // UNICODE
+
+typedef DWORD (FAR PASCAL * DSETUP_CALLBACK)(DWORD Reason,
+                                  DWORD MsgType,       /* Same as flags to MessageBox */
+                                  LPSTR szMessage,
+                                  LPSTR szName,
+                                  void *pInfo);
+
+INT WINAPI DirectXSetupSetCallback(DSETUP_CALLBACK Callback);
+INT WINAPI DirectXSetupGetVersion(DWORD *lpdwVersion, DWORD *lpdwMinorVersion);
+
+#endif // WIN32
+
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif
diff --git a/3rdparty/dx5/inc/dsound.h b/3rdparty/dx5/inc/dsound.h
new file mode 100644
index 00000000..0f4b2d3f
--- /dev/null
+++ b/3rdparty/dx5/inc/dsound.h
@@ -0,0 +1,863 @@
+/*==========================================================================;
+ *
+ *  Copyright (C) 1995,1996 Microsoft Corporation.  All Rights Reserved.
+ *
+ *  File:       dsound.h
+ *  Content:    DirectSound include file
+ *
+ **************************************************************************/
+
+#ifndef __DSOUND_INCLUDED__
+#define __DSOUND_INCLUDED__
+
+#include <d3dtypes.h>
+
+#define COM_NO_WINDOWS_H
+#include <objbase.h>
+
+#define _FACDS  0x878
+#define MAKE_DSHRESULT(code)  MAKE_HRESULT(1, _FACDS, code)
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+// Direct Sound Component GUID {47D4D946-62E8-11cf-93BC-444553540000}
+DEFINE_GUID(CLSID_DirectSound, 0x47d4d946, 0x62e8, 0x11cf, 0x93, 0xbc, 0x44, 0x45, 0x53, 0x54, 0x0, 0x0);
+
+// DirectSound Capture Component GUID {B0210780-89CD-11d0-AF08-00A0C925CD16}
+DEFINE_GUID(CLSID_DirectSoundCapture, 0xb0210780, 0x89cd, 0x11d0, 0xaf, 0x8, 0x0, 0xa0, 0xc9, 0x25, 0xcd, 0x16);
+
+//
+// Structures
+// 
+
+#ifdef __cplusplus
+// 'struct' not 'class' per the way DECLARE_INTERFACE_ is defined
+struct IDirectSound;
+struct IDirectSoundBuffer;
+struct IDirectSound3DListener;
+struct IDirectSound3DBuffer;
+struct IDirectSoundCapture;
+struct IDirectSoundCaptureBuffer;
+struct IDirectSoundNotify;
+#endif // __cplusplus
+
+typedef struct IDirectSound *LPDIRECTSOUND;
+typedef struct IDirectSoundBuffer *LPDIRECTSOUNDBUFFER;
+typedef struct IDirectSound3DListener *LPDIRECTSOUND3DLISTENER;
+typedef struct IDirectSound3DBuffer *LPDIRECTSOUND3DBUFFER;
+typedef struct IDirectSoundCapture *LPDIRECTSOUNDCAPTURE;
+typedef struct IDirectSoundCaptureBuffer *LPDIRECTSOUNDCAPTUREBUFFER;
+typedef struct IDirectSoundNotify *LPDIRECTSOUNDNOTIFY;
+
+typedef struct _DSCAPS
+{
+    DWORD           dwSize;
+    DWORD           dwFlags;
+    DWORD           dwMinSecondarySampleRate;
+    DWORD           dwMaxSecondarySampleRate;
+    DWORD           dwPrimaryBuffers;
+    DWORD           dwMaxHwMixingAllBuffers;
+    DWORD           dwMaxHwMixingStaticBuffers;
+    DWORD           dwMaxHwMixingStreamingBuffers;
+    DWORD           dwFreeHwMixingAllBuffers;
+    DWORD           dwFreeHwMixingStaticBuffers;
+    DWORD           dwFreeHwMixingStreamingBuffers;
+    DWORD           dwMaxHw3DAllBuffers;
+    DWORD           dwMaxHw3DStaticBuffers;
+    DWORD           dwMaxHw3DStreamingBuffers;
+    DWORD           dwFreeHw3DAllBuffers;
+    DWORD           dwFreeHw3DStaticBuffers;
+    DWORD           dwFreeHw3DStreamingBuffers;
+    DWORD           dwTotalHwMemBytes;
+    DWORD           dwFreeHwMemBytes;
+    DWORD           dwMaxContigFreeHwMemBytes;
+    DWORD           dwUnlockTransferRateHwBuffers;
+    DWORD           dwPlayCpuOverheadSwBuffers;
+    DWORD           dwReserved1;
+    DWORD           dwReserved2;
+} DSCAPS, *LPDSCAPS;
+
+typedef const DSCAPS *LPCDSCAPS;
+
+typedef struct _DSBCAPS
+{
+    DWORD           dwSize;
+    DWORD           dwFlags;
+    DWORD           dwBufferBytes;
+    DWORD           dwUnlockTransferRate;
+    DWORD           dwPlayCpuOverhead;
+} DSBCAPS, *LPDSBCAPS;
+
+typedef const DSBCAPS *LPCDSBCAPS;
+
+typedef struct _DSBUFFERDESC
+{
+    DWORD           dwSize;
+    DWORD           dwFlags;
+    DWORD           dwBufferBytes;
+    DWORD           dwReserved;
+    LPWAVEFORMATEX  lpwfxFormat;
+} DSBUFFERDESC, *LPDSBUFFERDESC;
+
+typedef const DSBUFFERDESC *LPCDSBUFFERDESC;
+
+typedef struct _DS3DBUFFER
+{
+    DWORD           dwSize;
+    D3DVECTOR       vPosition;
+    D3DVECTOR       vVelocity;
+    DWORD           dwInsideConeAngle;
+    DWORD           dwOutsideConeAngle;
+    D3DVECTOR       vConeOrientation;
+    LONG            lConeOutsideVolume;
+    D3DVALUE        flMinDistance;
+    D3DVALUE        flMaxDistance;
+    DWORD           dwMode;
+} DS3DBUFFER, *LPDS3DBUFFER;
+
+typedef const DS3DBUFFER *LPCDS3DBUFFER;
+
+typedef struct _DS3DLISTENER
+{
+    DWORD           dwSize;
+    D3DVECTOR       vPosition;
+    D3DVECTOR       vVelocity;
+    D3DVECTOR       vOrientFront;
+    D3DVECTOR       vOrientTop;
+    D3DVALUE        flDistanceFactor;
+    D3DVALUE        flRolloffFactor;
+    D3DVALUE        flDopplerFactor;
+} DS3DLISTENER, *LPDS3DLISTENER;
+
+typedef const DS3DLISTENER *LPCDS3DLISTENER;
+
+typedef struct _DSCCAPS
+{
+    DWORD           dwSize;
+    DWORD           dwFlags;
+    DWORD           dwFormats;
+    DWORD           dwChannels;
+} DSCCAPS, *LPDSCCAPS;
+
+typedef const DSCCAPS *LPCDSCCAPS;
+
+typedef struct _DSCBUFFERDESC
+{
+    DWORD           dwSize;
+    DWORD           dwFlags;
+    DWORD           dwBufferBytes;
+    DWORD           dwReserved;
+    LPWAVEFORMATEX  lpwfxFormat;
+} DSCBUFFERDESC, *LPDSCBUFFERDESC;
+
+typedef const DSCBUFFERDESC *LPCDSCBUFFERDESC;
+
+typedef struct _DSCBCAPS 
+{
+    DWORD           dwSize;
+    DWORD           dwFlags;
+    DWORD           dwBufferBytes;
+    DWORD           dwReserved;
+} DSCBCAPS, *LPDSCBCAPS;
+
+typedef const DSCBCAPS *LPCDSCBCAPS;
+
+typedef struct _DSBPOSITIONNOTIFY
+{
+    DWORD           dwOffset;
+    HANDLE          hEventNotify;
+} DSBPOSITIONNOTIFY, *LPDSBPOSITIONNOTIFY;
+
+typedef const DSBPOSITIONNOTIFY *LPCDSBPOSITIONNOTIFY;
+
+//
+// Compatibility typedefs
+//
+
+typedef LPDIRECTSOUND *LPLPDIRECTSOUND;
+typedef LPDIRECTSOUNDBUFFER *LPLPDIRECTSOUNDBUFFER;
+typedef LPDIRECTSOUND3DLISTENER *LPLPDIRECTSOUND3DLISTENER;
+typedef LPDIRECTSOUND3DBUFFER *LPLPDIRECTSOUND3DBUFFER;
+typedef LPDIRECTSOUNDCAPTURE *LPLPDIRECTSOUNDCAPTURE;
+typedef LPDIRECTSOUNDCAPTUREBUFFER *LPLPDIRECTSOUNDCAPTUREBUFFER;
+typedef LPDIRECTSOUNDNOTIFY *LPLPDIRECTSOUNDNOTIFY;
+typedef LPVOID *LPLPVOID;
+typedef const WAVEFORMATEX *LPCWAVEFORMATEX;
+
+//
+// DirectSound API
+//
+
+typedef BOOL (CALLBACK *LPDSENUMCALLBACKW)(LPGUID, LPCWSTR, LPCWSTR, LPVOID);
+typedef BOOL (CALLBACK *LPDSENUMCALLBACKA)(LPGUID, LPCSTR, LPCSTR, LPVOID);
+
+extern HRESULT WINAPI DirectSoundCreate(LPGUID, LPDIRECTSOUND *, LPUNKNOWN);
+extern HRESULT WINAPI DirectSoundEnumerateW(LPDSENUMCALLBACKW, LPVOID);
+extern HRESULT WINAPI DirectSoundEnumerateA(LPDSENUMCALLBACKA, LPVOID);
+
+extern HRESULT WINAPI DirectSoundCaptureCreate(LPGUID, LPDIRECTSOUNDCAPTURE *, LPUNKNOWN);
+extern HRESULT WINAPI DirectSoundCaptureEnumerateW(LPDSENUMCALLBACKW, LPVOID);
+extern HRESULT WINAPI DirectSoundCaptureEnumerateA(LPDSENUMCALLBACKA, LPVOID);
+
+#ifdef UNICODE
+#define LPDSENUMCALLBACK            LPDSENUMCALLBACKW
+#define DirectSoundEnumerate        DirectSoundEnumerateW
+#define DirectSoundCaptureEnumerate DirectSoundCaptureEnumerateW
+#else // UNICODE
+#define LPDSENUMCALLBACK            LPDSENUMCALLBACKA
+#define DirectSoundEnumerate        DirectSoundEnumerateA
+#define DirectSoundCaptureEnumerate DirectSoundCaptureEnumerateA
+#endif // UNICODE
+
+//
+// IDirectSound
+//
+
+DEFINE_GUID(IID_IDirectSound, 0x279AFA83, 0x4981, 0x11CE, 0xA5, 0x21, 0x00, 0x20, 0xAF, 0x0B, 0xE5, 0x60);
+
+#undef INTERFACE
+#define INTERFACE IDirectSound
+
+DECLARE_INTERFACE_(IDirectSound, IUnknown)
+{
+    // IUnknown methods
+    STDMETHOD(QueryInterface)       (THIS_ REFIID, LPVOID FAR *) PURE;
+    STDMETHOD_(ULONG,AddRef)        (THIS) PURE;
+    STDMETHOD_(ULONG,Release)       (THIS) PURE;
+    
+    // IDirectSound methods
+    STDMETHOD(CreateSoundBuffer)    (THIS_ LPCDSBUFFERDESC, LPDIRECTSOUNDBUFFER *, LPUNKNOWN) PURE;
+    STDMETHOD(GetCaps)              (THIS_ LPDSCAPS) PURE;
+    STDMETHOD(DuplicateSoundBuffer) (THIS_ LPDIRECTSOUNDBUFFER, LPDIRECTSOUNDBUFFER *) PURE;
+    STDMETHOD(SetCooperativeLevel)  (THIS_ HWND, DWORD) PURE;
+    STDMETHOD(Compact)              (THIS) PURE;
+    STDMETHOD(GetSpeakerConfig)     (THIS_ LPDWORD) PURE;
+    STDMETHOD(SetSpeakerConfig)     (THIS_ DWORD) PURE;
+    STDMETHOD(Initialize)           (THIS_ LPGUID) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectSound_QueryInterface(p,a,b)       (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirectSound_AddRef(p)                   (p)->lpVtbl->AddRef(p)
+#define IDirectSound_Release(p)                  (p)->lpVtbl->Release(p)
+#define IDirectSound_CreateSoundBuffer(p,a,b,c)  (p)->lpVtbl->CreateSoundBuffer(p,a,b,c)
+#define IDirectSound_GetCaps(p,a)                (p)->lpVtbl->GetCaps(p,a)
+#define IDirectSound_DuplicateSoundBuffer(p,a,b) (p)->lpVtbl->DuplicateSoundBuffer(p,a,b)
+#define IDirectSound_SetCooperativeLevel(p,a,b)  (p)->lpVtbl->SetCooperativeLevel(p,a,b)
+#define IDirectSound_Compact(p)                  (p)->lpVtbl->Compact(p)
+#define IDirectSound_GetSpeakerConfig(p,a)       (p)->lpVtbl->GetSpeakerConfig(p,a)
+#define IDirectSound_SetSpeakerConfig(p,b)       (p)->lpVtbl->SetSpeakerConfig(p,b)
+#define IDirectSound_Initialize(p,a)             (p)->lpVtbl->Initialize(p,a)
+#else // !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectSound_QueryInterface(p,a,b)       (p)->QueryInterface(a,b)
+#define IDirectSound_AddRef(p)                   (p)->AddRef()
+#define IDirectSound_Release(p)                  (p)->Release()
+#define IDirectSound_CreateSoundBuffer(p,a,b,c)  (p)->CreateSoundBuffer(a,b,c)
+#define IDirectSound_GetCaps(p,a)                (p)->GetCaps(a)
+#define IDirectSound_DuplicateSoundBuffer(p,a,b) (p)->DuplicateSoundBuffer(a,b)
+#define IDirectSound_SetCooperativeLevel(p,a,b)  (p)->SetCooperativeLevel(a,b)
+#define IDirectSound_Compact(p)                  (p)->Compact()
+#define IDirectSound_GetSpeakerConfig(p,a)       (p)->GetSpeakerConfig(a)
+#define IDirectSound_SetSpeakerConfig(p,b)       (p)->SetSpeakerConfig(b)
+#define IDirectSound_Initialize(p,a)             (p)->Initialize(a)
+#endif // !defined(__cplusplus) || defined(CINTERFACE)
+
+//
+// IDirectSoundBuffer
+//
+
+DEFINE_GUID(IID_IDirectSoundBuffer, 0x279AFA85, 0x4981, 0x11CE, 0xA5, 0x21, 0x00, 0x20, 0xAF, 0x0B, 0xE5, 0x60);
+
+#undef INTERFACE
+#define INTERFACE IDirectSoundBuffer
+
+DECLARE_INTERFACE_(IDirectSoundBuffer, IUnknown)
+{
+    // IUnknown methods
+    STDMETHOD(QueryInterface)       (THIS_ REFIID, LPVOID FAR *) PURE;
+    STDMETHOD_(ULONG,AddRef)        (THIS) PURE;
+    STDMETHOD_(ULONG,Release)       (THIS) PURE;
+    
+    // IDirectSoundBuffer methods
+    STDMETHOD(GetCaps)              (THIS_ LPDSBCAPS) PURE;
+    STDMETHOD(GetCurrentPosition)   (THIS_ LPDWORD, LPDWORD) PURE;
+    STDMETHOD(GetFormat)            (THIS_ LPWAVEFORMATEX, DWORD, LPDWORD) PURE;
+    STDMETHOD(GetVolume)            (THIS_ LPLONG) PURE;
+    STDMETHOD(GetPan)               (THIS_ LPLONG) PURE;
+    STDMETHOD(GetFrequency)         (THIS_ LPDWORD) PURE;
+    STDMETHOD(GetStatus)            (THIS_ LPDWORD) PURE;
+    STDMETHOD(Initialize)           (THIS_ LPDIRECTSOUND, LPCDSBUFFERDESC) PURE;
+    STDMETHOD(Lock)                 (THIS_ DWORD, DWORD, LPVOID *, LPDWORD, LPVOID *, LPDWORD, DWORD) PURE;
+    STDMETHOD(Play)                 (THIS_ DWORD, DWORD, DWORD) PURE;
+    STDMETHOD(SetCurrentPosition)   (THIS_ DWORD) PURE;
+    STDMETHOD(SetFormat)            (THIS_ LPCWAVEFORMATEX) PURE;
+    STDMETHOD(SetVolume)            (THIS_ LONG) PURE;
+    STDMETHOD(SetPan)               (THIS_ LONG) PURE;
+    STDMETHOD(SetFrequency)         (THIS_ DWORD) PURE;
+    STDMETHOD(Stop)                 (THIS) PURE;
+    STDMETHOD(Unlock)               (THIS_ LPVOID, DWORD, LPVOID, DWORD) PURE;
+    STDMETHOD(Restore)              (THIS) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectSoundBuffer_QueryInterface(p,a,b)        (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirectSoundBuffer_AddRef(p)                    (p)->lpVtbl->AddRef(p)
+#define IDirectSoundBuffer_Release(p)                   (p)->lpVtbl->Release(p)
+#define IDirectSoundBuffer_GetCaps(p,a)                 (p)->lpVtbl->GetCaps(p,a)
+#define IDirectSoundBuffer_GetCurrentPosition(p,a,b)    (p)->lpVtbl->GetCurrentPosition(p,a,b)
+#define IDirectSoundBuffer_GetFormat(p,a,b,c)           (p)->lpVtbl->GetFormat(p,a,b,c)
+#define IDirectSoundBuffer_GetVolume(p,a)               (p)->lpVtbl->GetVolume(p,a)
+#define IDirectSoundBuffer_GetPan(p,a)                  (p)->lpVtbl->GetPan(p,a)
+#define IDirectSoundBuffer_GetFrequency(p,a)            (p)->lpVtbl->GetFrequency(p,a)
+#define IDirectSoundBuffer_GetStatus(p,a)               (p)->lpVtbl->GetStatus(p,a)
+#define IDirectSoundBuffer_Initialize(p,a,b)            (p)->lpVtbl->Initialize(p,a,b)
+#define IDirectSoundBuffer_Lock(p,a,b,c,d,e,f,g)        (p)->lpVtbl->Lock(p,a,b,c,d,e,f,g)
+#define IDirectSoundBuffer_Play(p,a,b,c)                (p)->lpVtbl->Play(p,a,b,c)
+#define IDirectSoundBuffer_SetCurrentPosition(p,a)      (p)->lpVtbl->SetCurrentPosition(p,a)
+#define IDirectSoundBuffer_SetFormat(p,a)               (p)->lpVtbl->SetFormat(p,a)
+#define IDirectSoundBuffer_SetVolume(p,a)               (p)->lpVtbl->SetVolume(p,a)
+#define IDirectSoundBuffer_SetPan(p,a)                  (p)->lpVtbl->SetPan(p,a)
+#define IDirectSoundBuffer_SetFrequency(p,a)            (p)->lpVtbl->SetFrequency(p,a)
+#define IDirectSoundBuffer_Stop(p)                      (p)->lpVtbl->Stop(p)
+#define IDirectSoundBuffer_Unlock(p,a,b,c,d)            (p)->lpVtbl->Unlock(p,a,b,c,d)
+#define IDirectSoundBuffer_Restore(p)                   (p)->lpVtbl->Restore(p)
+#else // !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectSoundBuffer_QueryInterface(p,a,b)        (p)->QueryInterface(a,b)
+#define IDirectSoundBuffer_AddRef(p)                    (p)->AddRef()
+#define IDirectSoundBuffer_Release(p)                   (p)->Release()
+#define IDirectSoundBuffer_GetCaps(p,a)                 (p)->GetCaps(a)
+#define IDirectSoundBuffer_GetCurrentPosition(p,a,b)    (p)->GetCurrentPosition(a,b)
+#define IDirectSoundBuffer_GetFormat(p,a,b,c)           (p)->GetFormat(a,b,c)
+#define IDirectSoundBuffer_GetVolume(p,a)               (p)->GetVolume(a)
+#define IDirectSoundBuffer_GetPan(p,a)                  (p)->GetPan(a)
+#define IDirectSoundBuffer_GetFrequency(p,a)            (p)->GetFrequency(a)
+#define IDirectSoundBuffer_GetStatus(p,a)               (p)->GetStatus(a)
+#define IDirectSoundBuffer_Initialize(p,a,b)            (p)->Initialize(a,b)
+#define IDirectSoundBuffer_Lock(p,a,b,c,d,e,f,g)        (p)->Lock(a,b,c,d,e,f,g)
+#define IDirectSoundBuffer_Play(p,a,b,c)                (p)->Play(a,b,c)
+#define IDirectSoundBuffer_SetCurrentPosition(p,a)      (p)->SetCurrentPosition(a)
+#define IDirectSoundBuffer_SetFormat(p,a)               (p)->SetFormat(a)
+#define IDirectSoundBuffer_SetVolume(p,a)               (p)->SetVolume(a)
+#define IDirectSoundBuffer_SetPan(p,a)                  (p)->SetPan(a)
+#define IDirectSoundBuffer_SetFrequency(p,a)            (p)->SetFrequency(a)
+#define IDirectSoundBuffer_Stop(p)                      (p)->Stop()
+#define IDirectSoundBuffer_Unlock(p,a,b,c,d)            (p)->Unlock(a,b,c,d)
+#define IDirectSoundBuffer_Restore(p)                   (p)->Restore()
+#endif // !defined(__cplusplus) || defined(CINTERFACE)
+
+//
+// IDirectSound3DListener
+//
+
+DEFINE_GUID(IID_IDirectSound3DListener, 0x279AFA84, 0x4981, 0x11CE, 0xA5, 0x21, 0x00, 0x20, 0xAF, 0x0B, 0xE5, 0x60);
+
+#undef INTERFACE
+#define INTERFACE IDirectSound3DListener
+
+DECLARE_INTERFACE_(IDirectSound3DListener, IUnknown)
+{
+    // IUnknown methods
+    STDMETHOD(QueryInterface)           (THIS_ REFIID, LPVOID FAR *) PURE;
+    STDMETHOD_(ULONG,AddRef)            (THIS) PURE;
+    STDMETHOD_(ULONG,Release)           (THIS) PURE;
+
+    // IDirectSound3D methods
+    STDMETHOD(GetAllParameters)         (THIS_ LPDS3DLISTENER) PURE;
+    STDMETHOD(GetDistanceFactor)        (THIS_ LPD3DVALUE) PURE;
+    STDMETHOD(GetDopplerFactor)         (THIS_ LPD3DVALUE) PURE;
+    STDMETHOD(GetOrientation)           (THIS_ LPD3DVECTOR, LPD3DVECTOR) PURE;
+    STDMETHOD(GetPosition)              (THIS_ LPD3DVECTOR) PURE;
+    STDMETHOD(GetRolloffFactor)         (THIS_ LPD3DVALUE) PURE;
+    STDMETHOD(GetVelocity)              (THIS_ LPD3DVECTOR) PURE;
+    STDMETHOD(SetAllParameters)         (THIS_ LPCDS3DLISTENER, DWORD) PURE;
+    STDMETHOD(SetDistanceFactor)        (THIS_ D3DVALUE, DWORD) PURE;
+    STDMETHOD(SetDopplerFactor)         (THIS_ D3DVALUE, DWORD) PURE;
+    STDMETHOD(SetOrientation)           (THIS_ D3DVALUE, D3DVALUE, D3DVALUE, D3DVALUE, D3DVALUE, D3DVALUE, DWORD) PURE;
+    STDMETHOD(SetPosition)              (THIS_ D3DVALUE, D3DVALUE, D3DVALUE, DWORD) PURE;
+    STDMETHOD(SetRolloffFactor)         (THIS_ D3DVALUE, DWORD) PURE;
+    STDMETHOD(SetVelocity)              (THIS_ D3DVALUE, D3DVALUE, D3DVALUE, DWORD) PURE;
+    STDMETHOD(CommitDeferredSettings)   (THIS) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectSound3DListener_QueryInterface(p,a,b)            (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirectSound3DListener_AddRef(p)                        (p)->lpVtbl->AddRef(p)
+#define IDirectSound3DListener_Release(p)                       (p)->lpVtbl->Release(p)
+#define IDirectSound3DListener_GetAllParameters(p,a)            (p)->lpVtbl->GetAllParameters(p,a)
+#define IDirectSound3DListener_GetDistanceFactor(p,a)           (p)->lpVtbl->GetDistanceFactor(p,a)
+#define IDirectSound3DListener_GetDopplerFactor(p,a)            (p)->lpVtbl->GetDopplerFactor(p,a)
+#define IDirectSound3DListener_GetOrientation(p,a,b)            (p)->lpVtbl->GetOrientation(p,a,b)
+#define IDirectSound3DListener_GetPosition(p,a)                 (p)->lpVtbl->GetPosition(p,a)
+#define IDirectSound3DListener_GetRolloffFactor(p,a)            (p)->lpVtbl->GetRolloffFactor(p,a)
+#define IDirectSound3DListener_GetVelocity(p,a)                 (p)->lpVtbl->GetVelocity(p,a)
+#define IDirectSound3DListener_SetAllParameters(p,a,b)          (p)->lpVtbl->SetAllParameters(p,a,b)
+#define IDirectSound3DListener_SetDistanceFactor(p,a,b)         (p)->lpVtbl->SetDistanceFactor(p,a,b)
+#define IDirectSound3DListener_SetDopplerFactor(p,a,b)          (p)->lpVtbl->SetDopplerFactor(p,a,b)
+#define IDirectSound3DListener_SetOrientation(p,a,b,c,d,e,f,g)  (p)->lpVtbl->SetOrientation(p,a,b,c,d,e,f,g)
+#define IDirectSound3DListener_SetPosition(p,a,b,c,d)           (p)->lpVtbl->SetPosition(p,a,b,c,d)
+#define IDirectSound3DListener_SetRolloffFactor(p,a,b)          (p)->lpVtbl->SetRolloffFactor(p,a,b)
+#define IDirectSound3DListener_SetVelocity(p,a,b,c,d)           (p)->lpVtbl->SetVelocity(p,a,b,c,d)
+#define IDirectSound3DListener_CommitDeferredSettings(p)        (p)->lpVtbl->CommitDeferredSettings(p)
+#else // !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectSound3DListener_QueryInterface(p,a,b)            (p)->QueryInterface(a,b)
+#define IDirectSound3DListener_AddRef(p)                        (p)->AddRef()
+#define IDirectSound3DListener_Release(p)                       (p)->Release()
+#define IDirectSound3DListener_GetAllParameters(p,a)            (p)->GetAllParameters(a)
+#define IDirectSound3DListener_GetDistanceFactor(p,a)           (p)->GetDistanceFactor(a)
+#define IDirectSound3DListener_GetDopplerFactor(p,a)            (p)->GetDopplerFactor(a)
+#define IDirectSound3DListener_GetOrientation(p,a,b)            (p)->GetOrientation(a,b)
+#define IDirectSound3DListener_GetPosition(p,a)                 (p)->GetPosition(a)
+#define IDirectSound3DListener_GetRolloffFactor(p,a)            (p)->GetRolloffFactor(a)
+#define IDirectSound3DListener_GetVelocity(p,a)                 (p)->GetVelocity(a)
+#define IDirectSound3DListener_SetAllParameters(p,a,b)          (p)->SetAllParameters(a,b)
+#define IDirectSound3DListener_SetDistanceFactor(p,a,b)         (p)->SetDistanceFactor(a,b)
+#define IDirectSound3DListener_SetDopplerFactor(p,a,b)          (p)->SetDopplerFactor(a,b)
+#define IDirectSound3DListener_SetOrientation(p,a,b,c,d,e,f,g)  (p)->SetOrientation(a,b,c,d,e,f,g)
+#define IDirectSound3DListener_SetPosition(p,a,b,c,d)           (p)->SetPosition(a,b,c,d)
+#define IDirectSound3DListener_SetRolloffFactor(p,a,b)          (p)->SetRolloffFactor(a,b)
+#define IDirectSound3DListener_SetVelocity(p,a,b,c,d)           (p)->SetVelocity(a,b,c,d)
+#define IDirectSound3DListener_CommitDeferredSettings(p)        (p)->CommitDeferredSettings()
+#endif // !defined(__cplusplus) || defined(CINTERFACE)
+
+//
+// IDirectSound3DBuffer
+//
+
+DEFINE_GUID(IID_IDirectSound3DBuffer, 0x279AFA86, 0x4981, 0x11CE, 0xA5, 0x21, 0x00, 0x20, 0xAF, 0x0B, 0xE5, 0x60);
+
+#undef INTERFACE
+#define INTERFACE IDirectSound3DBuffer
+
+DECLARE_INTERFACE_(IDirectSound3DBuffer, IUnknown)
+{
+    // IUnknown methods
+    STDMETHOD(QueryInterface)       (THIS_ REFIID, LPVOID *) PURE;
+    STDMETHOD_(ULONG,AddRef)        (THIS) PURE;
+    STDMETHOD_(ULONG,Release)       (THIS) PURE;
+
+    // IDirectSoundBuffer3D methods
+    STDMETHOD(GetAllParameters)     (THIS_ LPDS3DBUFFER) PURE;
+    STDMETHOD(GetConeAngles)        (THIS_ LPDWORD, LPDWORD) PURE;
+    STDMETHOD(GetConeOrientation)   (THIS_ LPD3DVECTOR) PURE;
+    STDMETHOD(GetConeOutsideVolume) (THIS_ LPLONG) PURE;
+    STDMETHOD(GetMaxDistance)       (THIS_ LPD3DVALUE) PURE;
+    STDMETHOD(GetMinDistance)       (THIS_ LPD3DVALUE) PURE;
+    STDMETHOD(GetMode)              (THIS_ LPDWORD) PURE;
+    STDMETHOD(GetPosition)          (THIS_ LPD3DVECTOR) PURE;
+    STDMETHOD(GetVelocity)          (THIS_ LPD3DVECTOR) PURE;
+    STDMETHOD(SetAllParameters)     (THIS_ LPCDS3DBUFFER, DWORD) PURE;
+    STDMETHOD(SetConeAngles)        (THIS_ DWORD, DWORD, DWORD) PURE;
+    STDMETHOD(SetConeOrientation)   (THIS_ D3DVALUE, D3DVALUE, D3DVALUE, DWORD) PURE;
+    STDMETHOD(SetConeOutsideVolume) (THIS_ LONG, DWORD) PURE;
+    STDMETHOD(SetMaxDistance)       (THIS_ D3DVALUE, DWORD) PURE;
+    STDMETHOD(SetMinDistance)       (THIS_ D3DVALUE, DWORD) PURE;
+    STDMETHOD(SetMode)              (THIS_ DWORD, DWORD) PURE;
+    STDMETHOD(SetPosition)          (THIS_ D3DVALUE, D3DVALUE, D3DVALUE, DWORD) PURE;
+    STDMETHOD(SetVelocity)          (THIS_ D3DVALUE, D3DVALUE, D3DVALUE, DWORD) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectSound3DBuffer_QueryInterface(p,a,b)      (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirectSound3DBuffer_AddRef(p)                  (p)->lpVtbl->AddRef(p)
+#define IDirectSound3DBuffer_Release(p)                 (p)->lpVtbl->Release(p)
+#define IDirectSound3DBuffer_GetAllParameters(p,a)      (p)->lpVtbl->GetAllParameters(p,a)
+#define IDirectSound3DBuffer_GetConeAngles(p,a,b)       (p)->lpVtbl->GetConeAngles(p,a,b)
+#define IDirectSound3DBuffer_GetConeOrientation(p,a)    (p)->lpVtbl->GetConeOrientation(p,a)
+#define IDirectSound3DBuffer_GetConeOutsideVolume(p,a)  (p)->lpVtbl->GetConeOutsideVolume(p,a)
+#define IDirectSound3DBuffer_GetPosition(p,a)           (p)->lpVtbl->GetPosition(p,a)
+#define IDirectSound3DBuffer_GetMinDistance(p,a)        (p)->lpVtbl->GetMinDistance(p,a)
+#define IDirectSound3DBuffer_GetMaxDistance(p,a)        (p)->lpVtbl->GetMaxDistance(p,a)
+#define IDirectSound3DBuffer_GetMode(p,a)               (p)->lpVtbl->GetMode(p,a)
+#define IDirectSound3DBuffer_GetVelocity(p,a)           (p)->lpVtbl->GetVelocity(p,a)
+#define IDirectSound3DBuffer_SetAllParameters(p,a,b)    (p)->lpVtbl->SetAllParameters(p,a,b)
+#define IDirectSound3DBuffer_SetConeAngles(p,a,b,c)     (p)->lpVtbl->SetConeAngles(p,a,b,c)
+#define IDirectSound3DBuffer_SetConeOrientation(p,a,b,c,d) (p)->lpVtbl->SetConeOrientation(p,a,b,c,d)
+#define IDirectSound3DBuffer_SetConeOutsideVolume(p,a,b)(p)->lpVtbl->SetConeOutsideVolume(p,a,b)
+#define IDirectSound3DBuffer_SetPosition(p,a,b,c,d)     (p)->lpVtbl->SetPosition(p,a,b,c,d)
+#define IDirectSound3DBuffer_SetMinDistance(p,a,b)      (p)->lpVtbl->SetMinDistance(p,a,b)
+#define IDirectSound3DBuffer_SetMaxDistance(p,a,b)      (p)->lpVtbl->SetMaxDistance(p,a,b)
+#define IDirectSound3DBuffer_SetMode(p,a,b)             (p)->lpVtbl->SetMode(p,a,b)
+#define IDirectSound3DBuffer_SetVelocity(p,a,b,c,d)     (p)->lpVtbl->SetVelocity(p,a,b,c,d)
+#else // !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectSound3DBuffer_QueryInterface(p,a,b)      (p)->QueryInterface(a,b)
+#define IDirectSound3DBuffer_AddRef(p)                  (p)->AddRef()
+#define IDirectSound3DBuffer_Release(p)                 (p)->Release()
+#define IDirectSound3DBuffer_GetAllParameters(p,a)      (p)->GetAllParameters(a)
+#define IDirectSound3DBuffer_GetConeAngles(p,a,b)       (p)->GetConeAngles(a,b)
+#define IDirectSound3DBuffer_GetConeOrientation(p,a)    (p)->GetConeOrientation(a)
+#define IDirectSound3DBuffer_GetConeOutsideVolume(p,a)  (p)->GetConeOutsideVolume(a)
+#define IDirectSound3DBuffer_GetPosition(p,a)           (p)->GetPosition(a)
+#define IDirectSound3DBuffer_GetMinDistance(p,a)        (p)->GetMinDistance(a)
+#define IDirectSound3DBuffer_GetMaxDistance(p,a)        (p)->GetMaxDistance(a)
+#define IDirectSound3DBuffer_GetMode(p,a)               (p)->GetMode(a)
+#define IDirectSound3DBuffer_GetVelocity(p,a)           (p)->GetVelocity(a)
+#define IDirectSound3DBuffer_SetAllParameters(p,a,b)    (p)->SetAllParameters(a,b)
+#define IDirectSound3DBuffer_SetConeAngles(p,a,b,c)     (p)->SetConeAngles(a,b,c)
+#define IDirectSound3DBuffer_SetConeOrientation(p,a,b,c,d) (p)->SetConeOrientation(a,b,c,d)
+#define IDirectSound3DBuffer_SetConeOutsideVolume(p,a,b)(p)->SetConeOutsideVolume(a,b)
+#define IDirectSound3DBuffer_SetPosition(p,a,b,c,d)     (p)->SetPosition(a,b,c,d)
+#define IDirectSound3DBuffer_SetMinDistance(p,a,b)      (p)->SetMinDistance(a,b)
+#define IDirectSound3DBuffer_SetMaxDistance(p,a,b)      (p)->SetMaxDistance(a,b)
+#define IDirectSound3DBuffer_SetMode(p,a,b)             (p)->SetMode(a,b)
+#define IDirectSound3DBuffer_SetVelocity(p,a,b,c,d)     (p)->SetVelocity(a,b,c,d)
+#endif // !defined(__cplusplus) || defined(CINTERFACE)
+
+//
+// IDirectSoundCapture
+//
+
+DEFINE_GUID(IID_IDirectSoundCapture, 0xb0210781, 0x89cd, 0x11d0, 0xaf, 0x8, 0x0, 0xa0, 0xc9, 0x25, 0xcd, 0x16);
+
+#undef INTERFACE
+#define INTERFACE IDirectSoundCapture
+
+DECLARE_INTERFACE_(IDirectSoundCapture, IUnknown)
+{
+    // IUnknown methods
+    STDMETHOD(QueryInterface)       (THIS_ REFIID, LPVOID *) PURE;
+    STDMETHOD_(ULONG,AddRef)        (THIS) PURE;
+    STDMETHOD_(ULONG,Release)       (THIS) PURE;
+
+    // IDirectSoundCapture methods
+    STDMETHOD(CreateCaptureBuffer)  (THIS_ LPCDSCBUFFERDESC, LPDIRECTSOUNDCAPTUREBUFFER *, LPUNKNOWN) PURE;
+    STDMETHOD(GetCaps)              (THIS_ LPDSCCAPS ) PURE;
+    STDMETHOD(Initialize)           (THIS_ LPGUID) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectSoundCapture_QueryInterface(p,a,b)           (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirectSoundCapture_AddRef(p)                       (p)->lpVtbl->AddRef(p)
+#define IDirectSoundCapture_Release(p)                      (p)->lpVtbl->Release(p)
+#define IDirectSoundCapture_CreateCaptureBuffer(p,a,b,c)    (p)->lpVtbl->CreateCaptureBuffer(p,a,b,c)
+#define IDirectSoundCapture_GetCaps(p,a)                    (p)->lpVtbl->GetCaps(p,a)
+#define IDirectSoundCapture_Initialize(p,a)                 (p)->lpVtbl->Initialize(p,a)
+#else // !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectSoundCapture_QueryInterface(p,a,b)           (p)->QueryInterface(a,b)
+#define IDirectSoundCapture_AddRef(p)                       (p)->AddRef()
+#define IDirectSoundCapture_Release(p)                      (p)->Release()
+#define IDirectSoundCapture_CreateCaptureBuffer(p,a,b,c)    (p)->CreateCaptureBuffer(a,b,c)
+#define IDirectSoundCapture_GetCaps(p,a)                    (p)->GetCaps(a)
+#define IDirectSoundCapture_Initialize(p,a)                 (p)->Initialize(a)
+#endif // !defined(__cplusplus) || defined(CINTERFACE)
+
+//
+// IDirectSoundCaptureBuffer
+//
+
+DEFINE_GUID(IID_IDirectSoundCaptureBuffer, 0xb0210782, 0x89cd, 0x11d0, 0xaf, 0x8, 0x0, 0xa0, 0xc9, 0x25, 0xcd, 0x16);
+
+#undef INTERFACE
+#define INTERFACE IDirectSoundCaptureBuffer
+
+DECLARE_INTERFACE_(IDirectSoundCaptureBuffer, IUnknown)
+{
+    // IUnknown methods
+    STDMETHOD(QueryInterface)       (THIS_ REFIID, LPVOID *) PURE;
+    STDMETHOD_(ULONG,AddRef)        (THIS) PURE;
+    STDMETHOD_(ULONG,Release)       (THIS) PURE;
+
+    // IDirectSoundCaptureBuffer methods
+    STDMETHOD(GetCaps)              (THIS_ LPDSCBCAPS ) PURE;
+    STDMETHOD(GetCurrentPosition)   (THIS_ LPDWORD, LPDWORD ) PURE;
+    STDMETHOD(GetFormat)            (THIS_ LPWAVEFORMATEX, DWORD, LPDWORD ) PURE;
+    STDMETHOD(GetStatus)            (THIS_ LPDWORD ) PURE;
+    STDMETHOD(Initialize)           (THIS_ LPDIRECTSOUNDCAPTURE, LPCDSCBUFFERDESC) PURE;
+    STDMETHOD(Lock)                 (THIS_ DWORD, DWORD, LPVOID *, LPDWORD, LPVOID *, LPDWORD, DWORD) PURE;
+    STDMETHOD(Start)                (THIS_ DWORD) PURE;
+    STDMETHOD(Stop)                 (THIS) PURE;
+    STDMETHOD(Unlock)               (THIS_ LPVOID, DWORD, LPVOID, DWORD) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectSoundCaptureBuffer_QueryInterface(p,a,b)        (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirectSoundCaptureBuffer_AddRef(p)                    (p)->lpVtbl->AddRef(p)
+#define IDirectSoundCaptureBuffer_Release(p)                   (p)->lpVtbl->Release(p)
+#define IDirectSoundCaptureBuffer_GetCaps(p,a)                 (p)->lpVtbl->GetCaps(p,a)
+#define IDirectSoundCaptureBuffer_GetCurrentPosition(p,a,b)    (p)->lpVtbl->GetCurrentPosition(p,a,b)
+#define IDirectSoundCaptureBuffer_GetFormat(p,a,b,c)           (p)->lpVtbl->GetFormat(p,a,b,c)
+#define IDirectSoundCaptureBuffer_GetStatus(p,a)               (p)->lpVtbl->GetStatus(p,a)
+#define IDirectSoundCaptureBuffer_Initialize(p,a,b)            (p)->lpVtbl->Initialize(p,a,b)
+#define IDirectSoundCaptureBuffer_Lock(p,a,b,c,d,e,f,g)        (p)->lpVtbl->Lock(p,a,b,c,d,e,f,g)
+#define IDirectSoundCaptureBuffer_Start(p,a)                   (p)->lpVtbl->Start(p,a)
+#define IDirectSoundCaptureBuffer_Stop(p)                      (p)->lpVtbl->Stop(p)
+#define IDirectSoundCaptureBuffer_Unlock(p,a,b,c,d)            (p)->lpVtbl->Unlock(p,a,b,c,d)
+#else // !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectSoundCaptureBuffer_QueryInterface(p,a,b)        (p)->QueryInterface(a,b)
+#define IDirectSoundCaptureBuffer_AddRef(p)                    (p)->AddRef()
+#define IDirectSoundCaptureBuffer_Release(p)                   (p)->Release()
+#define IDirectSoundCaptureBuffer_GetCaps(p,a)                 (p)->GetCaps(a)
+#define IDirectSoundCaptureBuffer_GetCurrentPosition(p,a,b)    (p)->GetCurrentPosition(a,b)
+#define IDirectSoundCaptureBuffer_GetFormat(p,a,b,c)           (p)->GetFormat(a,b,c)
+#define IDirectSoundCaptureBuffer_GetStatus(p,a)               (p)->GetStatus(a)
+#define IDirectSoundCaptureBuffer_Initialize(p,a,b)            (p)->Initialize(a,b)
+#define IDirectSoundCaptureBuffer_Lock(p,a,b,c,d,e,f,g)        (p)->Lock(a,b,c,d,e,f,g)
+#define IDirectSoundCaptureBuffer_Start(p,a)                   (p)->Start(a)
+#define IDirectSoundCaptureBuffer_Stop(p)                      (p)->Stop()
+#define IDirectSoundCaptureBuffer_Unlock(p,a,b,c,d)            (p)->Unlock(a,b,c,d)
+#endif // !defined(__cplusplus) || defined(CINTERFACE)
+
+//
+// IDirectSoundNotify
+//
+
+DEFINE_GUID(IID_IDirectSoundNotify, 0xb0210783, 0x89cd, 0x11d0, 0xaf, 0x8, 0x0, 0xa0, 0xc9, 0x25, 0xcd, 0x16);
+
+#undef INTERFACE
+#define INTERFACE IDirectSoundNotify
+
+DECLARE_INTERFACE_(IDirectSoundNotify, IUnknown)
+{
+    // IUnknown methods
+    STDMETHOD(QueryInterface)           (THIS_ REFIID, LPVOID *) PURE;
+    STDMETHOD_(ULONG,AddRef)            (THIS) PURE;
+    STDMETHOD_(ULONG,Release)           (THIS) PURE;
+
+    // IDirectSoundNotify methods
+    STDMETHOD(SetNotificationPositions) (THIS_ DWORD, LPCDSBPOSITIONNOTIFY) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectSoundNotify_QueryInterface(p,a,b)            (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirectSoundNotify_AddRef(p)                        (p)->lpVtbl->AddRef(p)
+#define IDirectSoundNotify_Release(p)                       (p)->lpVtbl->Release(p)
+#define IDirectSoundNotify_SetNotificationPositions(p,a,b)  (p)->lpVtbl->SetNotificationPositions(p,a,b)
+#else // !defined(__cplusplus) || defined(CINTERFACE)
+#define IDirectSoundNotify_QueryInterface(p,a,b)            (p)->QueryInterface(a,b)
+#define IDirectSoundNotify_AddRef(p)                        (p)->AddRef()
+#define IDirectSoundNotify_Release(p)                       (p)->Release()
+#define IDirectSoundNotify_SetNotificationPositions(p,a,b)  (p)->SetNotificationPositions(a,b)
+#endif // !defined(__cplusplus) || defined(CINTERFACE)
+
+//
+// IKsPropertySet
+//
+
+#ifndef _IKsPropertySet_
+#define _IKsPropertySet_
+
+#ifdef __cplusplus
+// 'struct' not 'class' per the way DECLARE_INTERFACE_ is defined
+struct IKsPropertySet;
+#endif // __cplusplus
+
+typedef struct IKsPropertySet *LPKSPROPERTYSET;
+
+#define KSPROPERTY_SUPPORT_GET  0x00000001
+#define KSPROPERTY_SUPPORT_SET  0x00000002
+
+DEFINE_GUID(IID_IKsPropertySet, 0x31efac30, 0x515c, 0x11d0, 0xa9, 0xaa, 0x00, 0xaa, 0x00, 0x61, 0xbe, 0x93);
+
+#undef INTERFACE
+#define INTERFACE IKsPropertySet
+
+DECLARE_INTERFACE_(IKsPropertySet, IUnknown)
+{
+    // IUnknown methods
+    STDMETHOD(QueryInterface)   (THIS_ REFIID, LPVOID *) PURE;
+    STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
+    STDMETHOD_(ULONG,Release)   (THIS) PURE;
+
+    // IKsPropertySet methods
+    STDMETHOD(Get)              (THIS_ REFGUID, ULONG, LPVOID, ULONG, LPVOID, ULONG, PULONG) PURE;
+    STDMETHOD(Set)              (THIS_ REFGUID, ULONG, LPVOID, ULONG, LPVOID, ULONG) PURE;
+    STDMETHOD(QuerySupport)     (THIS_ REFGUID, ULONG, PULONG) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IKsPropertySet_QueryInterface(p,a,b)       (p)->lpVtbl->QueryInterface(p,a,b)
+#define IKsPropertySet_AddRef(p)                   (p)->lpVtbl->AddRef(p)
+#define IKsPropertySet_Release(p)                  (p)->lpVtbl->Release(p)
+#define IKsPropertySet_Get(p,a,b,c,d,e,f,g)        (p)->lpVtbl->Get(p,a,b,c,d,e,f,g)
+#define IKsPropertySet_Set(p,a,b,c,d,e,f)          (p)->lpVtbl->Set(p,a,b,c,d,e,f)
+#define IKsPropertySet_QuerySupport(p,a,b,c)       (p)->lpVtbl->QuerySupport(p,a,b,c)
+#else // !defined(__cplusplus) || defined(CINTERFACE)
+#define IKsPropertySet_QueryInterface(p,a,b)       (p)->QueryInterface(a,b)
+#define IKsPropertySet_AddRef(p)                   (p)->AddRef()
+#define IKsPropertySet_Release(p)                  (p)->Release()
+#define IKsPropertySet_Get(p,a,b,c,d,e,f,g)        (p)->Get(a,b,c,d,e,f,g)
+#define IKsPropertySet_Set(p,a,b,c,d,e,f)          (p)->Set(a,b,c,d,e,f)
+#define IKsPropertySet_QuerySupport(p,a,b,c)       (p)->QuerySupport(a,b,c)
+#endif // !defined(__cplusplus) || defined(CINTERFACE)
+
+#endif // _IKsPropertySet_
+
+//
+// Return Codes
+//
+
+#define DS_OK                           0
+
+// The call failed because resources (such as a priority level)
+// were already being used by another caller.
+#define DSERR_ALLOCATED                 MAKE_DSHRESULT(10)
+
+// The control (vol,pan,etc.) requested by the caller is not available.
+#define DSERR_CONTROLUNAVAIL            MAKE_DSHRESULT(30)
+
+// An invalid parameter was passed to the returning function
+#define DSERR_INVALIDPARAM              E_INVALIDARG
+
+// This call is not valid for the current state of this object
+#define DSERR_INVALIDCALL               MAKE_DSHRESULT(50)
+
+// An undetermined error occured inside the DirectSound subsystem
+#define DSERR_GENERIC                   E_FAIL
+
+// The caller does not have the priority level required for the function to
+// succeed.
+#define DSERR_PRIOLEVELNEEDED           MAKE_DSHRESULT(70)
+
+// Not enough free memory is available to complete the operation
+#define DSERR_OUTOFMEMORY               E_OUTOFMEMORY
+
+// The specified WAVE format is not supported
+#define DSERR_BADFORMAT                 MAKE_DSHRESULT(100)
+
+// The function called is not supported at this time
+#define DSERR_UNSUPPORTED               E_NOTIMPL
+
+// No sound driver is available for use
+#define DSERR_NODRIVER                  MAKE_DSHRESULT(120)
+
+// This object is already initialized
+#define DSERR_ALREADYINITIALIZED        MAKE_DSHRESULT(130)
+
+// This object does not support aggregation
+#define DSERR_NOAGGREGATION             CLASS_E_NOAGGREGATION
+
+// The buffer memory has been lost, and must be restored.
+#define DSERR_BUFFERLOST                MAKE_DSHRESULT(150)
+
+// Another app has a higher priority level, preventing this call from
+// succeeding.
+#define DSERR_OTHERAPPHASPRIO           MAKE_DSHRESULT(160)
+
+// This object has not been initialized
+#define DSERR_UNINITIALIZED             MAKE_DSHRESULT(170)
+
+// The requested COM interface is not available
+#define DSERR_NOINTERFACE               E_NOINTERFACE
+
+//
+// Flags
+//
+
+#define DSCAPS_PRIMARYMONO          0x00000001
+#define DSCAPS_PRIMARYSTEREO        0x00000002
+#define DSCAPS_PRIMARY8BIT          0x00000004
+#define DSCAPS_PRIMARY16BIT         0x00000008
+#define DSCAPS_CONTINUOUSRATE       0x00000010
+#define DSCAPS_EMULDRIVER           0x00000020
+#define DSCAPS_CERTIFIED            0x00000040
+#define DSCAPS_SECONDARYMONO        0x00000100
+#define DSCAPS_SECONDARYSTEREO      0x00000200
+#define DSCAPS_SECONDARY8BIT        0x00000400
+#define DSCAPS_SECONDARY16BIT       0x00000800
+
+#define DSBPLAY_LOOPING             0x00000001
+      
+#define DSBSTATUS_PLAYING           0x00000001
+#define DSBSTATUS_BUFFERLOST        0x00000002
+#define DSBSTATUS_LOOPING           0x00000004
+
+#define DSBLOCK_FROMWRITECURSOR     0x00000001
+#define DSBLOCK_ENTIREBUFFER        0x00000002
+
+#define DSSCL_NORMAL                0x00000001
+#define DSSCL_PRIORITY              0x00000002
+#define DSSCL_EXCLUSIVE             0x00000003
+#define DSSCL_WRITEPRIMARY          0x00000004
+
+#define DS3DMODE_NORMAL             0x00000000
+#define DS3DMODE_HEADRELATIVE       0x00000001
+#define DS3DMODE_DISABLE            0x00000002
+
+#define DS3D_IMMEDIATE              0x00000000
+#define DS3D_DEFERRED               0x00000001
+
+#define DS3D_MINDISTANCEFACTOR      0.0f
+#define DS3D_MAXDISTANCEFACTOR      10.0f
+#define DS3D_DEFAULTDISTANCEFACTOR  1.0f
+
+#define DS3D_MINROLLOFFFACTOR       0.0f
+#define DS3D_MAXROLLOFFFACTOR       10.0f
+#define DS3D_DEFAULTROLLOFFFACTOR   1.0f
+
+#define DS3D_MINDOPPLERFACTOR       0.0f
+#define DS3D_MAXDOPPLERFACTOR       10.0f
+#define DS3D_DEFAULTDOPPLERFACTOR   1.0f
+
+#define DS3D_DEFAULTMINDISTANCE     1.0f
+#define DS3D_DEFAULTMAXDISTANCE     1000000000.0f
+
+#define DS3D_MINCONEANGLE           0
+#define DS3D_MAXCONEANGLE           360
+#define DS3D_DEFAULTCONEANGLE       360
+
+#define DS3D_DEFAULTCONEOUTSIDEVOLUME   0
+
+#define DSBCAPS_PRIMARYBUFFER       0x00000001
+#define DSBCAPS_STATIC              0x00000002
+#define DSBCAPS_LOCHARDWARE         0x00000004
+#define DSBCAPS_LOCSOFTWARE         0x00000008
+#define DSBCAPS_CTRL3D              0x00000010
+#define DSBCAPS_CTRLFREQUENCY       0x00000020
+#define DSBCAPS_CTRLPAN             0x00000040
+#define DSBCAPS_CTRLVOLUME          0x00000080
+#define DSBCAPS_CTRLPOSITIONNOTIFY  0x00000100
+#define DSBCAPS_CTRLDEFAULT         0x000000E0
+#define DSBCAPS_CTRLALL             0x000001F0
+#define DSBCAPS_STICKYFOCUS         0x00004000
+#define DSBCAPS_GLOBALFOCUS         0x00008000 
+#define DSBCAPS_GETCURRENTPOSITION2 0x00010000
+#define DSBCAPS_MUTE3DATMAXDISTANCE 0x00020000
+
+#define DSCBCAPS_WAVEMAPPED         0x80000000
+
+#define DSSPEAKER_HEADPHONE         0x00000001
+#define DSSPEAKER_MONO              0x00000002
+#define DSSPEAKER_QUAD              0x00000003
+#define DSSPEAKER_STEREO            0x00000004
+#define DSSPEAKER_SURROUND          0x00000005
+
+#define DSSPEAKER_GEOMETRY_MIN      0x00000005  //   5 degrees
+#define DSSPEAKER_GEOMETRY_NARROW   0x0000000A  //  10 degrees
+#define DSSPEAKER_GEOMETRY_WIDE     0x00000014  //  20 degrees
+#define DSSPEAKER_GEOMETRY_MAX      0x000000B4  // 180 degrees
+
+#define DSSPEAKER_COMBINED(c, g)    ((DWORD)(((BYTE)(c)) | ((DWORD)((BYTE)(g))) << 16))
+#define DSSPEAKER_CONFIG(a)         ((BYTE)(a))
+#define DSSPEAKER_GEOMETRY(a)       ((BYTE)(((DWORD)(a) >> 16) & 0x00FF))
+
+#define DSCCAPS_EMULDRIVER          0x00000020
+
+#define DSCBLOCK_ENTIREBUFFER       0x00000001
+
+#define DSCBSTATUS_CAPTURING        0x00000001
+#define DSCBSTATUS_LOOPING          0x00000002
+
+#define DSCBSTART_LOOPING           0x00000001
+
+#define DSBFREQUENCY_MIN            100
+#define DSBFREQUENCY_MAX            100000
+#define DSBFREQUENCY_ORIGINAL       0
+
+#define DSBPAN_LEFT                 -10000
+#define DSBPAN_CENTER               0
+#define DSBPAN_RIGHT                10000
+
+#define DSBVOLUME_MIN               -10000
+#define DSBVOLUME_MAX               0
+
+#define DSBSIZE_MIN                 4
+#define DSBSIZE_MAX                 0x0FFFFFFF
+
+#define DSBPN_OFFSETSTOP            0xFFFFFFFF
+
+#ifdef __cplusplus
+};
+#endif // __cplusplus
+
+#endif  // __DSOUND_INCLUDED__ 
diff --git a/3rdparty/dx5/inc/dvp.h b/3rdparty/dx5/inc/dvp.h
new file mode 100644
index 00000000..9554de55
--- /dev/null
+++ b/3rdparty/dx5/inc/dvp.h
@@ -0,0 +1,831 @@
+/*==========================================================================;
+ *
+ *  Copyright (C) 1996-1997 Microsoft Corporation.  All Rights Reserved.
+ *
+ *  File:	dvp.h
+ *  Content:	DirectDrawVideoPort include file
+ *
+ ***************************************************************************/
+
+#ifndef __DVP_INCLUDED__
+#define __DVP_INCLUDED__
+#if defined( _WIN32 )  && !defined( _NO_COM )
+#define COM_NO_WINDOWS_H
+#include <objbase.h>
+#else
+#define IUnknown	    void
+#undef  CO_E_NOTINITIALIZED
+#define CO_E_NOTINITIALIZED 0x800401F0L
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * GUIDS used by DirectDrawVideoPort objects
+ */
+#if defined( _WIN32 ) && !defined( _NO_COM )
+DEFINE_GUID( IID_IDDVideoPortContainer,		0x6C142760,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 );
+DEFINE_GUID( IID_IDirectDrawVideoPort,		0xB36D93E0,0x2B43,0x11CF,0xA2,0xDE,0x00,0xAA,0x00,0xB9,0x33,0x56 );
+
+DEFINE_GUID( DDVPTYPE_E_HREFH_VREFH, 0x54F39980L,0xDA60,0x11CF,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8);
+DEFINE_GUID( DDVPTYPE_E_HREFH_VREFL, 0x92783220L,0xDA60,0x11CF,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8);
+DEFINE_GUID( DDVPTYPE_E_HREFL_VREFH, 0xA07A02E0L,0xDA60,0x11CF,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8);
+DEFINE_GUID( DDVPTYPE_E_HREFL_VREFL, 0xE09C77E0L,0xDA60,0x11CF,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8);
+DEFINE_GUID( DDVPTYPE_CCIR656,	     0xFCA326A0L,0xDA60,0x11CF,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8);
+DEFINE_GUID( DDVPTYPE_BROOKTREE,     0x1352A560L,0xDA61,0x11CF,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8);
+DEFINE_GUID( DDVPTYPE_PHILIPS,	     0x332CF160L,0xDA61,0x11CF,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8);
+
+/*
+ * GUIDS used to describe connections
+ */
+
+#endif
+
+/*============================================================================
+ *
+ * DirectDraw Structures
+ *
+ * Various structures used to invoke DirectDraw.
+ *
+ *==========================================================================*/
+
+struct IDirectDraw;
+struct IDirectDrawSurface;
+struct IDirectDrawPalette;
+struct IDirectDrawClipper;
+
+typedef struct IDDVideoPortContainer		FAR *LPDDVIDEOPORTCONTAINER;
+typedef struct IDirectDrawVideoPort		FAR *LPDIRECTDRAWVIDEOPORT;
+
+typedef struct _DDVIDEOPORTCONNECT	FAR *LPDDVIDEOPORTCONNECT;
+typedef struct _DDVIDEOPORTCAPS		FAR *LPDDVIDEOPORTCAPS;
+typedef struct _DDVIDEOPORTDESC		FAR *LPDDVIDEOPORTDESC;
+typedef struct _DDVIDEOPORTINFO		FAR *LPDDVIDEOPORTINFO;
+typedef struct _DDVIDEOPORTBANDWIDTH	FAR *LPDDVIDEOPORTBANDWIDTH;
+typedef struct _DDVIDEOPORTSTATUS	FAR *LPDDVIDEOPORTSTATUS;
+
+typedef struct IDDVideoPortContainerVtbl DDVIDEOPORTCONTAINERCALLBACKS;
+typedef struct IDirectDrawVideoPortVtbl  DIRECTDRAWVIDEOPORTCALLBACKS;
+
+
+/*
+ * API's
+ */
+typedef HRESULT (FAR PASCAL * LPDDENUMVIDEOCALLBACK)(LPDDVIDEOPORTCAPS, LPVOID);
+
+
+/*
+ * INTERACES FOLLOW:
+ *	IDirectDrawVideoPort
+ *	IVideoPort
+ */
+
+/*
+ * IDirectDrawVideoPortContainer
+ */
+#if defined( _WIN32 ) && !defined( _NO_COM )
+#undef INTERFACE
+#define INTERFACE IDDVideoPortContainer
+DECLARE_INTERFACE_( IDDVideoPortContainer, IUnknown )
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
+    STDMETHOD_(ULONG,Release) (THIS) PURE;
+    /*** IDirectDrawVideoPort methods ***/
+    STDMETHOD(CreateVideoPort)(THIS_ DWORD, LPDDVIDEOPORTDESC, LPDIRECTDRAWVIDEOPORT FAR *, IUnknown FAR *) PURE;
+    STDMETHOD(EnumVideoPorts)(THIS_ DWORD, LPDDVIDEOPORTCAPS, LPVOID,LPDDENUMVIDEOCALLBACK ) PURE;
+    STDMETHOD(GetVideoPortConnectInfo)(THIS_ DWORD, LPDWORD, LPDDVIDEOPORTCONNECT ) PURE;
+    STDMETHOD(QueryVideoPortStatus)(THIS_ DWORD, LPDDVIDEOPORTSTATUS ) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IVideoPortContainer_QueryInterface(p, a, b)         (p)->lpVtbl->QueryInterface(p, a, b)
+#define IVideoPortContainer_AddRef(p)                       (p)->lpVtbl->AddRef(p)
+#define IVideoPortContainer_Release(p)                      (p)->lpVtbl->Release(p)
+#define IVideoPortContainer_CreateVideoPort(p, a, b, c, d)  (p)->lpVtbl->CreateVideoPort(p, a, b, c, d)
+#define IVideoPortContainer_EnumVideoPorts(p, a, b, c, d)   (p)->lpVtbl->EnumVideoPorts(p, a, b, c, d)
+#define IVideoPortContainer_GetVideoPortConnectInfo(p, a, b, c) (p)->lpVtbl->GetVideoPortConnectInfo(p, a, b, c)
+#define IVideoPortContainer_QueryVideoPortStatus(p, a, b)   (p)->lpVtbl->QueryVideoPortStatus(p, a, b)
+#else
+#define IVideoPortContainer_QueryInterface(p, a, b)         (p)->QueryInterface(a, b)
+#define IVideoPortContainer_AddRef(p)                       (p)->AddRef()
+#define IVideoPortContainer_Release(p)                      (p)->Release()
+#define IVideoPortContainer_CreateVideoPort(p, a, b, c, d)  (p)->CreateVideoPort(a, b, c, d)
+#define IVideoPortContainer_EnumVideoPorts(p, a, b, c, d)   (p)->EnumVideoPorts(a, b, c, d)
+#define IVideoPortContainer_GetVideoPortConnectInfo(p, a, b, c) (p)->GetVideoPortConnectInfo(a, b, c)
+#define IVideoPortContainer_QueryVideoPortStatus(p, a, b)   (p)->QueryVideoPortStatus(a, b)
+#endif
+
+#endif
+
+
+/*
+ * IDirectDrawVideoPort
+ */
+#if defined( _WIN32 ) && !defined( _NO_COM )
+#undef INTERFACE
+#define INTERFACE IDirectDrawVideoPort
+DECLARE_INTERFACE_( IDirectDrawVideoPort, IUnknown )
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
+    STDMETHOD_(ULONG,Release) (THIS) PURE;
+    /*** IVideoPort methods ***/
+    STDMETHOD(Flip)(THIS_ LPDIRECTDRAWSURFACE, DWORD) PURE;
+    STDMETHOD(GetBandwidthInfo)(THIS_ LPDDPIXELFORMAT, DWORD, DWORD, DWORD, LPDDVIDEOPORTBANDWIDTH) PURE;
+    STDMETHOD(GetColorControls)(THIS_ LPDDCOLORCONTROL) PURE;
+    STDMETHOD(GetInputFormats)(THIS_ LPDWORD, LPDDPIXELFORMAT, DWORD) PURE;
+    STDMETHOD(GetOutputFormats)(THIS_ LPDDPIXELFORMAT, LPDWORD, LPDDPIXELFORMAT, DWORD) PURE;
+    STDMETHOD(GetFieldPolarity)(THIS_ LPBOOL) PURE;
+    STDMETHOD(GetVideoLine)(THIS_ LPDWORD) PURE;
+    STDMETHOD(GetVideoSignalStatus)(THIS_ LPDWORD) PURE;
+    STDMETHOD(SetColorControls)(THIS_ LPDDCOLORCONTROL) PURE;
+    STDMETHOD(SetTargetSurface)(THIS_ LPDIRECTDRAWSURFACE, DWORD) PURE;
+    STDMETHOD(StartVideo)(THIS_ LPDDVIDEOPORTINFO) PURE;
+    STDMETHOD(StopVideo)(THIS) PURE;
+    STDMETHOD(UpdateVideo)(THIS_ LPDDVIDEOPORTINFO) PURE;
+    STDMETHOD(WaitForSync)(THIS_ DWORD, DWORD, DWORD) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IVideoPort_QueryInterface(p,a,b)        (p)->lpVtbl->QueryInterface(p,a,b)
+#define IVideoPort_AddRef(p)                    (p)->lpVtbl->AddRef(p)
+#define IVideoPort_Release(p)                   (p)->lpVtbl->Release(p)
+#define IVideoPort_SetTargetSurface(p,a,b)	(p)->lpVtbl->SetTargetSurface(p,a,b)
+#define IVideoPort_Flip(p,a,b)			(p)->lpVtbl->Flip(p,a,b)
+#define IVideoPort_GetBandwidthInfo(p,a,b,c,d,e) (p)->lpVtbl->GetBandwidthInfo(p,a,b,c,d,e)
+#define IVideoPort_GetColorControls(p,a) 	(p)->lpVtbl->GetColorControls(p,a)
+#define IVideoPort_GetInputFormats(p,a,b,c)	(p)->lpVtbl->GetInputFormats(p,a,b,c)
+#define IVideoPort_GetOutputFormats(p,a,b,c,d)	(p)->lpVtbl->GetOutputFormats(p,a,b,c,d)
+#define IVideoPort_GetFieldPolarity(p,a)	(p)->lpVtbl->GetFieldPolarity(p,a)
+#define IVideoPort_GetVideoLine(p,a)		(p)->lpVtbl->GetVideoLine(p,a)
+#define IVideoPort_GetVideoSignalStatus(p,a)	(p)->lpVtbl->GetVideoSignalStatus(p,a)
+#define IVideoPort_SetColorControls(p,a)	(p)->lpVtbl->SetColorControls(p,a)
+#define IVideoPort_StartVideo(p,a)		(p)->lpVtbl->StartVideo(p,a)
+#define IVideoPort_StopVideo(p)			(p)->lpVtbl->StopVideo(p)
+#define IVideoPort_UpdateVideo(p,a)		(p)->lpVtbl->UpdateVideo(p,a)
+#define IVideoPort_WaitForSync(p,a,b,c)		(p)->lpVtbl->WaitForSync(p,a,b,c)
+#else
+#define IVideoPort_QueryInterface(p,a,b)        (p)->QueryInterface(a,b)
+#define IVideoPort_AddRef(p)                    (p)->AddRef()
+#define IVideoPort_Release(p)                   (p)->Release()
+#define IVideoPort_SetTargetSurface(p,a,b)	(p)->SetTargetSurface(a,b)
+#define IVideoPort_Flip(p,a,b)			(p)->Flip(a,b)
+#define IVideoPort_GetBandwidthInfo(p,a,b,c,d,e) (p)->GetBandwidthInfo(a,b,c,d,e)
+#define IVideoPort_GetColorControls(p,a) 	(p)->GetColorControls(a)
+#define IVideoPort_GetInputFormats(p,a,b,c)	(p)->GetInputFormats(a,b,c)
+#define IVideoPort_GetOutputFormats(p,a,b,c,d)	(p)->GetOutputFormats(a,b,c,d)
+#define IVideoPort_GetFieldPolarity(p,a)	(p)->GetFieldPolarity(a)
+#define IVideoPort_GetVideoLine(p,a)		(p)->GetVideoLine(a)
+#define IVideoPort_GetVideoSignalStatus(p,a)	(p)->GetVideoSignalStatus(a)
+#define IVideoPort_SetColorControls(p,a)	(p)->SetColorControls(a)
+#define IVideoPort_StartVideo(p,a)		(p)->StartVideo(a)
+#define IVideoPort_StopVideo(p)			(p)->StopVideo()
+#define IVideoPort_UpdateVideo(p,a)		(p)->UpdateVideo(a)
+#define IVideoPort_WaitForSync(p,a,b,c)		(p)->WaitForSync(a,b,c)
+#endif
+
+#endif
+
+
+/*
+ * DDVIDEOPORTCONNECT
+ */
+typedef struct _DDVIDEOPORTCONNECT
+{
+    DWORD dwSize;           // size of the DDVIDEOPORTCONNECT structure
+    DWORD dwPortWidth;      // Width of the video port
+    GUID  guidTypeID;       // Description of video port connection
+    DWORD dwFlags;          // Connection flags
+    DWORD dwReserved1;      // Reserved, set to zero.
+} DDVIDEOPORTCONNECT;
+
+
+/*
+ * DDVIDEOPORTCAPS
+ */
+typedef struct _DDVIDEOPORTCAPS
+{
+    DWORD dwSize;			// size of the DDVIDEOPORTCAPS structure
+    DWORD dwFlags;			// indicates which fields contain data
+    DWORD dwMaxWidth;			// max width of the video port field
+    DWORD dwMaxVBIWidth;		// max width of the VBI data
+    DWORD dwMaxHeight; 			// max height of the video port field
+    DWORD dwVideoPortID;		// Video port ID (0 - (dwMaxVideoPorts -1))
+    DWORD dwCaps;			// Video port capabilities
+    DWORD dwFX;				// More video port capabilities
+    DWORD dwNumAutoFlipSurfaces;	// Number of autoflippable surfaces
+    DWORD dwAlignVideoPortBoundary;	// Byte restriction of placement within the surface
+    DWORD dwAlignVideoPortPrescaleWidth;// Byte restriction of width after prescaling
+    DWORD dwAlignVideoPortCropBoundary;	// Byte restriction of left cropping
+    DWORD dwAlignVideoPortCropWidth;	// Byte restriction of cropping width
+    DWORD dwPreshrinkXStep;		// Width can be shrunk in steps of 1/x
+    DWORD dwPreshrinkYStep;		// Height can be shrunk in steps of 1/x
+    DWORD dwNumVBIAutoFlipSurfaces;	// Number of VBI autoflippable surfaces
+    DWORD dwReserved1;			// Reserved for future use
+    DWORD dwReserved2;			// Reserved for future use
+} DDVIDEOPORTCAPS;
+
+/*
+ * The dwMaxWidth and dwMaxVBIWidth members are valid
+ */
+#define DDVPD_WIDTH		0x00000001l
+
+/*
+ * The dwMaxHeight member is valid
+ */
+#define DDVPD_HEIGHT		0x00000002l
+
+/*
+ * The dwVideoPortID member is valid
+ */
+#define DDVPD_ID		0x00000004l
+
+/*
+ * The dwCaps member is valid
+ */
+#define DDVPD_CAPS		0x00000008l
+
+/*
+ * The dwFX member is valid
+ */
+#define DDVPD_FX		0x00000010l
+
+/*
+ * The dwNumAutoFlipSurfaces member is valid
+ */
+#define DDVPD_AUTOFLIP		0x00000020l
+
+/*
+ * All of the alignment members are valid
+ */
+#define DDVPD_ALIGN		0x00000040l
+
+
+/*
+ * DDVIDEOPORTDESC
+ */
+typedef struct _DDVIDEOPORTDESC
+{
+    DWORD dwSize;			// size of the DDVIDEOPORTDESC structure
+    DWORD dwFieldWidth;			// width of the video port field
+    DWORD dwVBIWidth;			// width of the VBI data
+    DWORD dwFieldHeight;		// height of the video port field
+    DWORD dwMicrosecondsPerField;	// Microseconds per video field
+    DWORD dwMaxPixelsPerSecond;		// Maximum pixel rate per second
+    DWORD dwVideoPortID;		// Video port ID (0 - (dwMaxVideoPorts -1))
+    DWORD dwReserved1;			// Reserved for future use - set to zero
+    DDVIDEOPORTCONNECT VideoPortType; 	// Description of video port connection
+    DWORD dwReserved2;			// Reserved for future use - set to zero
+    DWORD dwReserved3;			// Reserved for future use - set to zero
+} DDVIDEOPORTDESC;
+
+
+/*
+ * DDVIDEOPORTINFO
+ */
+typedef struct _DDVIDEOPORTINFO
+{
+    DWORD dwSize;			// Size of the structure
+    DWORD dwOriginX;			// Placement of the video data within the surface.
+    DWORD dwOriginY;			// Placement of the video data within the surface.
+    DWORD dwVPFlags;			// Video port options
+    RECT rCrop;				// Cropping rectangle (optional).
+    DWORD dwPrescaleWidth;		// Determines pre-scaling/zooming in the X direction (optional).
+    DWORD dwPrescaleHeight;		// Determines pre-scaling/zooming in the Y direction (optional).
+    LPDDPIXELFORMAT lpddpfInputFormat;	// Video format written to the video port
+    LPDDPIXELFORMAT lpddpfVBIInputFormat; // Input format of the VBI data
+    LPDDPIXELFORMAT lpddpfVBIOutputFormat;// Output format of the data
+    DWORD dwVBIHeight;			// Specifies the number of lines of data within the vertical blanking interval.
+    DWORD dwReserved1;			// Reserved for future use - set to zero
+    DWORD dwReserved2;			// Reserved for future use - set to zero
+} DDVIDEOPORTINFO;
+
+
+/*
+ * DDVIDEOPORTBANDWIDTH
+ */
+typedef struct _DDVIDEOPORTBANDWIDTH
+{
+    DWORD dwSize;			// Size of the structure
+    DWORD dwCaps;
+    DWORD dwOverlay;           		// Zoom factor at which overlay is supported
+    DWORD dwColorkey;			// Zoom factor at which overlay w/ colorkey is supported
+    DWORD dwYInterpolate;		// Zoom factor at which overlay w/ Y interpolation is supported
+    DWORD dwYInterpAndColorkey;		// Zoom factor at which ovelray w/ Y interpolation and colorkeying is supported
+    DWORD dwReserved1;			// Reserved for future use - set to zero
+    DWORD dwReserved2;			// Reserved for future use - set to zero
+} DDVIDEOPORTBANDWIDTH;
+
+
+/*
+ * DDVIDEOPORTSTATUS
+ */
+typedef struct _DDVIDEOPORTSTATUS
+{
+    DWORD dwSize;			// Size of the structure
+    BOOL  bInUse;			// TRUE if video port is currently being used
+    DWORD dwFlags;           		// Currently not used
+    DWORD dwReserved1;			// Reserved for future use
+    DDVIDEOPORTCONNECT VideoPortType;	// Information about the connection
+    DWORD dwReserved2;			// Reserved for future use
+    DWORD dwReserved3;			// Reserved for future use
+} DDVIDEOPORTSTATUS;
+
+/*============================================================================
+ *
+ * Video Port Flags
+ *
+ * All flags are bit flags.
+ *
+ *==========================================================================*/
+
+/****************************************************************************
+ *
+ * VIDEOPORT DDVIDEOPORTCONNECT FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * When this is set by the driver and passed to the client, this
+ * indicates that the video port is capable of double clocking the data.
+ * When this is set by the client, this indicates that the video port
+ * should enable double clocking.  This flag is only valid with external
+ * syncs.
+ */
+#define DDVPCONNECT_DOUBLECLOCK			0x00000001l
+
+/*
+ * When this is set by the driver and passed to the client, this
+ * indicates that the video port is capable of using an external VACT
+ * signal. When this is set by the client, this indicates that the
+ * video port should use the external VACT signal.
+ */
+#define DDVPCONNECT_VACT			0x00000002l
+
+/*
+ * When this is set by the driver and passed to the client, this
+ * indicates that the video port is capable of treating even fields
+ * like odd fields and visa versa.  When this is set by the client,
+ * this indicates that the video port should treat even fields like odd
+ * fields.
+ */
+#define DDVPCONNECT_INVERTPOLARITY		0x00000004l
+
+/*
+ * Indicates that any data written to the video port during the VREF
+ * period will not be written into the frame buffer. This flag is read only.
+ */
+#define DDVPCONNECT_DISCARDSVREFDATA		0x00000008l
+
+/*
+ * Device will write half lines into the frame buffer, sometimes causing
+ * the data to not be displayed correctly.
+ */
+#define DDVPCONNECT_HALFLINE			0x00000010l
+
+/*
+ * Indicates that the signal is interlaced. This flag is only
+ * set by the client.
+ */
+#define DDVPCONNECT_INTERLACED			0x00000020l
+
+/*
+ * Indicates that video port is shareable and that this video port
+ * will use the even fields.  This flag is only set by the client.
+ */
+#define DDVPCONNECT_SHAREEVEN			0x00000040l
+
+/*
+ * Indicates that video port is shareable and that this video port
+ * will use the odd fields.  This flag is only set by the client.
+ */
+#define DDVPCONNECT_SHAREODD			0x00000080l
+
+/****************************************************************************
+ *
+ * VIDEOPORT DDVIDEOPORTDESC CAPS
+ *
+ ****************************************************************************/
+
+/*
+ * Flip can be performed automatically to avoid tearing.
+ */
+#define DDVPCAPS_AUTOFLIP			0x00000001l
+
+/*
+ * Supports interlaced video
+ */
+#define DDVPCAPS_INTERLACED			0x00000002l
+
+/*
+ * Supports non-interlaced video
+ */
+#define DDVPCAPS_NONINTERLACED			0x00000004l
+
+/*
+ * Indicates that the device can return whether the current field
+ * of an interlaced signal is even or odd.
+ */
+#define DDVPCAPS_READBACKFIELD			0x00000008l
+
+/*
+ * Indicates that the device can return the current line of video
+ * being written into the frame buffer.
+ */
+#define DDVPCAPS_READBACKLINE			0x00000010l
+
+/*
+ * Allows two gen-locked video streams to share a single video port,
+ * where one stream uses the even fields and the other uses the odd
+ * fields. Separate parameters (including address, scaling,
+ * cropping, etc.) are maintained for both fields.)
+ */
+#define DDVPCAPS_SHAREABLE			0x00000020l
+
+/*
+ * Even fields of video can be automatically discarded.
+ */
+#define DDVPCAPS_SKIPEVENFIELDS			0x00000040l
+
+/*
+ * Odd fields of video can be automatically discarded.
+ */
+#define DDVPCAPS_SKIPODDFIELDS			0x00000080l
+
+/*
+ * Indicates that the device is capable of driving the graphics
+ * VSYNC with the video port VSYNC.
+ */
+#define DDVPCAPS_SYNCMASTER			0x00000100l
+
+/*
+ * Indicates that data within the vertical blanking interval can
+ * be written to a different surface.
+ */
+#define DDVPCAPS_VBISURFACE			0x00000200l
+
+/*
+ * Indicates that the video port can perform color operations
+ * on the incoming data before it is written to the frame buffer.
+ */
+#define DDVPCAPS_COLORCONTROL			0x00000400l
+
+/*
+ * Indicates that the video port can accept VBI data in a different
+ * width or format than the regular video data.
+ */
+#define DDVPCAPS_OVERSAMPLEDVBI			0x00000800l
+
+/*
+ * Indicates that the video port can write data directly to system memory
+ */
+#define DDVPCAPS_SYSTEMMEMORY			0x00001000l
+
+
+/****************************************************************************
+ *
+ * VIDEOPORT DDVIDEOPORTDESC FX
+ *
+ ****************************************************************************/
+
+/*
+ * Limited cropping is available to crop out the vertical interval data.
+ */
+#define DDVPFX_CROPTOPDATA			0x00000001l
+
+/*
+ * Incoming data can be cropped in the X direction before it is written
+ * to the surface.
+ */
+#define DDVPFX_CROPX				0x00000002l
+
+/*
+ * Incoming data can be cropped in the Y direction before it is written
+ * to the surface.
+ */
+#define DDVPFX_CROPY				0x00000004l
+
+/*
+ * Supports interleaving interlaced fields in memory.
+ */
+#define DDVPFX_INTERLEAVE			0x00000008l
+
+/*
+ * Supports mirroring left to right as the video data is written
+ * into the frame buffer.
+ */
+#define DDVPFX_MIRRORLEFTRIGHT			0x00000010l
+
+/*
+ * Supports mirroring top to bottom as the video data is written
+ * into the frame buffer.
+ */
+#define DDVPFX_MIRRORUPDOWN			0x00000020l
+
+/*
+ * Data can be arbitrarily shrunk in the X direction before it
+ * is written to the surface.
+ */
+#define DDVPFX_PRESHRINKX			0x00000040l
+
+/*
+ * Data can be arbitrarily shrunk in the Y direction before it
+ * is written to the surface.
+ */
+#define DDVPFX_PRESHRINKY			0x00000080l
+
+/*
+ * Data can be binary shrunk (1/2, 1/4, 1/8, etc.) in the X
+ * direction before it is written to the surface.
+ */
+#define DDVPFX_PRESHRINKXB			0x00000100l
+
+/*
+ * Data can be binary shrunk (1/2, 1/4, 1/8, etc.) in the Y
+ * direction before it is written to the surface.
+ */
+#define DDVPFX_PRESHRINKYB			0x00000200l
+
+/*
+ * Data can be shrunk in increments of 1/x in the X direction
+ * (where X is specified in the DDVIDEOPORTCAPS.dwPreshrinkXStep)
+ * before it is written to the surface.
+ */
+#define DDVPFX_PRESHRINKXS			0x00000400l
+
+/*
+ * Data can be shrunk in increments of 1/x in the Y direction
+ * (where X is specified in the DDVIDEOPORTCAPS.dwPreshrinkYStep)
+ * before it is written to the surface.
+ */
+#define DDVPFX_PRESHRINKYS			0x00000800l
+
+/*
+ * Data can be arbitrarily stretched in the X direction before
+ * it is written to the surface.
+ */
+#define DDVPFX_PRESTRETCHX			0x00001000l
+
+/*
+ * Data can be arbitrarily stretched in the Y direction before
+ * it is written to the surface.
+ */
+#define DDVPFX_PRESTRETCHY			0x00002000l
+
+/*
+ * Data can be integer stretched in the X direction before it is
+ * written to the surface.
+ */
+#define DDVPFX_PRESTRETCHXN			0x00004000l
+
+/*
+ * Data can be integer stretched in the Y direction before it is
+ * written to the surface.
+ */
+#define DDVPFX_PRESTRETCHYN			0x00008000l
+
+/*
+ * Indicates that data within the vertical blanking interval can
+ * be converted independently of the remaining video data.
+ */
+#define DDVPFX_VBICONVERT			0x00010000l
+
+/*
+ * Indicates that scaling can be disabled for data within the
+ * vertical blanking interval.
+ */
+#define DDVPFX_VBINOSCALE			0x00020000l
+
+/*
+ * Indicates that the video data can ignore the left and right
+ * cropping coordinates when cropping oversampled VBI data.
+ */
+#define DDVPFX_IGNOREVBIXCROP			0x00040000l
+
+
+/****************************************************************************
+ *
+ * VIDEOPORT DDVIDEOPORTINFO FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * Perform automatic flipping.   Auto-flipping is performed between
+ * the overlay surface that was attached to the video port using
+ * IDirectDrawVideoPort::AttachSurface and the overlay surfaces that
+ * are attached to the surface via the IDirectDrawSurface::AttachSurface
+ * method.  The flip order is the order in which the overlay surfaces
+ * were. attached.
+ */
+#define DDVP_AUTOFLIP				0x00000001l
+
+/*
+ * Perform conversion using the ddpfOutputFormat information.
+ */
+#define DDVP_CONVERT				0x00000002l
+
+/*
+ * Perform cropping using the specified rectangle.
+ */
+#define DDVP_CROP				0x00000004l
+
+/*
+ * Indicates that interlaced fields should be interleaved in memory.
+ */
+#define DDVP_INTERLEAVE				0x00000008l
+
+/*
+ * Indicates that the data should be mirrored left to right as it's
+ * written into the frame buffer.
+ */
+#define DDVP_MIRRORLEFTRIGHT			0x00000010l
+
+/*
+ * Indicates that the data should be mirrored top to bottom as it's
+ * written into the frame buffer.
+ */
+#define DDVP_MIRRORUPDOWN			0x00000020l
+
+/*
+ * Perform pre-scaling/zooming based on the pre-scale parameters.
+ */
+#define DDVP_PRESCALE				0x00000040l
+
+/*
+ * Ignore input of even fields.
+ */
+#define DDVP_SKIPEVENFIELDS			0x00000080l
+
+/*
+ * Ignore input of odd fields.
+ */
+#define DDVP_SKIPODDFIELDS			0x00000100l
+
+/*
+ * Drive the graphics VSYNCs using the video port VYSNCs.
+ */
+#define DDVP_SYNCMASTER				0x00000200l
+
+/*
+ * The ddpfVBIOutputFormatFormat member contains data that should be used
+ * to convert the data within the vertical blanking interval.
+ */
+#define DDVP_VBICONVERT				0x00000400l
+
+/*
+ * Indicates that data within the vertical blanking interval
+ * should not be scaled.
+ */
+#define DDVP_VBINOSCALE				0x00000800l
+
+/*
+ * Indicates that these bob/weave decisions should not be
+ * overriden by other interfaces.
+ */
+#define DDVP_OVERRIDEBOBWEAVE			0x00001000l
+
+/*
+ * Indicates that the video data should ignore the left and right
+ * cropping coordinates when cropping the VBI data.
+ */
+#define DDVP_IGNOREVBIXCROP			0x00002000l
+
+
+/****************************************************************************
+ *
+ * DIRIRECTDRAWVIDEOPORT GETINPUTFORMAT/GETOUTPUTFORMAT FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * Return formats for the video data
+ */
+#define DDVPFORMAT_VIDEO			0x00000001l
+
+/*
+ * Return formats for the VBI data
+ */
+#define DDVPFORMAT_VBI				0x00000002l
+
+
+/****************************************************************************
+ *
+ * DIRIRECTDRAWVIDEOPORT SETTARGETSURFACE FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * Surface should receive video data (and VBI data if a surface
+ * is not explicitly attached for that purpose)
+ */
+#define DDVPTARGET_VIDEO			0x00000001l
+
+/*
+ * Surface should receive VBI data
+ */
+#define DDVPTARGET_VBI				0x00000002l
+
+
+/****************************************************************************
+ *
+ * DIRIRECTDRAWVIDEOPORT WAITFORSYNC FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * Waits until the beginning of the next VSYNC
+ */
+#define DDVPWAIT_BEGIN				0x00000001l
+
+/*
+ * Waits until the end of the next/current VSYNC
+ */
+#define DDVPWAIT_END				0x00000002l
+
+/*
+ * Waits until the beginning of the specified line
+ */
+#define DDVPWAIT_LINE				0x00000003l
+
+/****************************************************************************
+ *
+ * DIRECTDRAWVIDEOPORT FLIP FLAGS
+ *
+ ****************************************************************************/
+
+/*
+ * Flips the normal video surface
+ */
+#define DDVPFLIP_VIDEO				0x00000001l
+
+/*
+ * Flips the VBI surface
+ */
+#define DDVPFLIP_VBI				0x00000002l
+
+/****************************************************************************
+ *
+ * DIRIRECTDRAWVIDEOPORT GETVIDEOSIGNALSTATUS VALUES
+ *
+ ****************************************************************************/
+
+/*
+ * No video signal is present at the video port
+ */
+#define DDVPSQ_NOSIGNAL				0x00000001l
+
+/*
+ * A valid video signal is present at the video port
+ */
+#define DDVPSQ_SIGNALOK				0x00000002l
+
+/****************************************************************************
+ *
+ * VIDEOPORTBANDWIDTH Flags
+ *
+ ****************************************************************************/
+
+/*
+ * The specified height/width refer to the size of the video port data
+ * written into memory, after prescaling has occured.
+ */
+#define DDVPB_VIDEOPORT				0x00000001l
+
+/*
+ * The specified height/width refer to the source size of the overlay.
+ */
+#define DDVPB_OVERLAY				0x00000002l
+
+/*
+ * This is a query for the device to return which caps this device requires.
+ */
+#define DDVPB_TYPE				0x00000004l
+
+/****************************************************************************
+ *
+ * VIDEOPORTBANDWIDTH Caps
+ *
+ ****************************************************************************/
+
+/*
+ * The bandwidth for this device is dependant on the overlay source size.
+ */
+#define DDVPBCAPS_SOURCE			0x00000001l
+
+/*
+ * The bandwidth for this device is dependant on the overlay destination
+ * size.
+ */
+#define DDVPBCAPS_DESTINATION			0x00000002l
+
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif
diff --git a/3rdparty/dx5/inc/fastfile.h b/3rdparty/dx5/inc/fastfile.h
new file mode 100644
index 00000000..92b37b16
--- /dev/null
+++ b/3rdparty/dx5/inc/fastfile.h
@@ -0,0 +1,24 @@
+/*==========================================================================
+ *
+ *  Copyright (C) 1995-1997 Microsoft Corporation.  All Rights Reserved.
+ *
+ *  File:       fastfile.h
+ *  Content:	Definitions for fastfile access.
+ *
+ * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
+ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
+ * WARRANTIES OF MERCHANTBILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ ***************************************************************************/
+
+typedef LPVOID	HFASTFILE;
+
+extern BOOL FastFileInit( LPSTR fname, int max_handles );
+extern void FastFileFini( void );
+extern HFASTFILE FastFileOpen( LPSTR name );
+extern BOOL FastFileClose( HFASTFILE pfe );
+extern BOOL FastFileRead( HFASTFILE pfh, LPVOID ptr, int size );
+extern BOOL FastFileSeek( HFASTFILE pfe, int off, int how );
+extern long FastFileTell( HFASTFILE pfe );
+extern LPVOID FastFileLock( HFASTFILE pfe, int off, int len );
+extern BOOL FastFileUnlock( HFASTFILE pfe, int off, int len );
diff --git a/3rdparty/dx5/lib/d3drm.lib b/3rdparty/dx5/lib/d3drm.lib
new file mode 100644
index 0000000000000000000000000000000000000000..03af252516753903864a0f1bebf26fbde22167f0
GIT binary patch
literal 15804
zcmeHO&u<e)6#i@z5)zU)B(#W9>XcFhqN(k~iCt*r5VsVSgwzSB;(+7Eu42iFqs6Ic
zFYRBzfddErj-EK>P@#%jd*GbEp{k+^q0%=qJG(QU-M|JTd6SH^JKpzZXXnQ^-@KW5
z9=%+)mRG*${WPJ6>|{2V&SjHHU7V25sqv|-P%ZTW_yibS0frs{!%u<ZFMtylfRlHC
zQxAdD&w$aBz?oaX+55n`$H4h*;NloCwge<8P5KEi@f?_<_j0#^OO&o}4(O+M-$vd8
z4@!mcLUDGcQEymRtIg^9`bs%J0bP2fzEL%VSFLJw&5#zW6<20e%grj!x_I?UK9!c)
zYVzrPYSLEBmYY`X-d9#*_1g`4(^{)F*78|f>55o_Vxw7ZGPRSdtDoJdH*4$lpS*Mn
z^{Tb*e(_dyx!JI$D-}1b5Y1SPyLacUMrC8U*{Ulvno=VRCtjMR<n@iaP6G((T*F!|
z*K0q!O(^8W@>->_+LE|f{h>}}YW*ayZnd@C3(Ms?31z#AY!^1ZZ(3!UMa`nzcn|YN
zXJ0E_o1MQ=Tr3s7T$m|dn_s+9ELFxU)+%Y{ZeG7`s!35>T`%dFaFF7mlX&q^IjHf_
z+1ODv8d7*oeYFBdirNoNN)i_{2BthyX~^<S;o?hCi;j^fGZY5aj1)TJ47GwgL#Lt7
z(7G5jRSFVKB^!PMkA}`grKwV}X=_b{{=(rXz_|GJ&AD$%h3Um<1ZU^0!_Fs&p6B|2
zXZ^r~0pR{6-~tKn5Ffud4m=$O9t{C2gQPnP+|B_{(!k?$!1j4yiE;Er;Q0i-Hw8RQ
zQeLNt+ed+0XXyD9r+@U~2zt<sE*!=Q9LGC&7kwDOAchdf2>Njh!#IjVh#(pubxcy{
z0Z;2}XN(;_orwXbj~Ydxj2A_!jTA-hjuBO;j1E=ojtfQVjtEt#j)j6b3J!SMopcU(
z+OZW3PE{=iQ|aQ-(7C8IRVp@Zt%*<{p62X5R;kx*!hV$%osl%1Sn9nViK6Gvr{ljy
zKr9Mu0g=8)j9J(IAx^3&h*Mt`C?QMBZaj9PSH1XF^<%Y4xmo^*W*ZSkC@N6>zoUzV
z7+rb9H|=zjTu3+8C_gIcm^_cfCW~9cQ4&xS@irAXcJn4+ZPpE^$M|cq9ogrjkfqB5
zn@qAICA=Ig&zO`<urwra(_~x;lhcIh1okGabDU@PEn4X8#yo8k4pZqVd!5H{7~wda
zrxMxS5V2cgTo#%2(`ET!$E=@PM9!n$uJ4oF*Wm7TdgL|7P%1O7lwFLWI(?y~>={`Y
zR+fr<u;V<E5@TfLh``d(l2!{Wohs1l^&Y8wIwWwdGRd@3t3$j;wkdxy<XDJ|HLLfU
z;y1q^ru%Pn(ZZSsR{KOev1Iq0R{P&c_lHQvTPYv+uKiz>=9zc8Nn1=-9%m}~$m4uG
zvH6lLNipuaC}yP-p@$;IZX(DhZX0L|ak4p;8nW8NA}klXSJ|(Z&3{=gk{}~UxMP;r
zmygg0>m&0m*>fz7GtznAGtP-=Z$;5X-%>e<y&a3Ny2~Kau&0C+Q5?l*bl-Um>9-^e
zIu0gsIRi2O(APT+F(Xu_ExObY6fqHKh+&KF5a5N?Tm}~}A4n0!QPASc6EDubf*)KC
z7{+c#$tmJdJVkZ9@ST{w&M@wFlOJS)GmO2dz^zp=C+$^+iRp-;{kbsU#hYPt+cWFK
zFmemBU1-T9Cye=Mo4(y?^HDo2m_s&Nv_0Dp%t+oA%!f9UvM9>!e9eN<Dk(Om+lLu-
z9U>Tp8F`(C8QMO5V;iQ+3p3MUU>R0>8C*Mtwt}4y#pm?fA2s%Yg&%B!+cK$)!8LRQ
z*>Sj`t@1a<&0&EXuOpriFb-=08C>j~lOl?vph2Kv$E&LBY}7oiD{+$s!SR!p=h|%l
zL-5XjREkdH9X6A1(WQo<Yo~63AMbtT5FkjmX4uM{wFWs2IDxEv`mM5$cV*i=ccsi7
zo99%HPQwr#`@J!SdRj3gPlrQ*A69=ETn74BiYSgEPj_$p$cnZZJIVcH_Z(@(4)+__
zt9FmeJc@fn+w7i+oN4#`P1x-;&N)V9+M-JhLFcVrfg8u6Bn*gQ^_Icq8g~96LzJHb
zsa)e!aA%4MZsY8u`KeFEis~n^N9QMj8MUH2gD2?DUuGZ8Pe)bkxPCMtK+bN~<zDVW
zZCqFFqf^X&6*sn<RT$<d?>)eToS-N+Pca2*6kjr5$OLDaNn<C6E$}+cqG4lgi!L<;
zwP*%Z#5gW^VZe+x)9k!&EHL9#b4PdVps3kTXWxS=YJ`Jk2<9g5lc}B0z6D}jA5>qG
z32qA~RiB}~?OhYs@FIM7!@x1#^U|n7xKWTRyS7hbBSvvhZYO5UJ>tE3`aPs!hC9-R
zmSYkcVp{#NY{V$O!hV}G2Xm5WNH71IV=7*_b9ERPX7_WF;y>;OmtD+B`^R5mSi_6$
vaUTMP@t%`j$L`hsn&>+z1?QOk<B>Ij)_)3xmt*uZ%&cO?n140#Kj!`)qr-_)

literal 0
HcmV?d00001

diff --git a/3rdparty/dx5/lib/ddraw.lbw b/3rdparty/dx5/lib/ddraw.lbw
new file mode 100644
index 0000000000000000000000000000000000000000..21a3eddf455f40360c4c00dbc51144b90a8912da
GIT binary patch
literal 1024
zcmeys%fP_Iz`)1=1r5Rsg7GeyMXAXpE=7su&PAz-C8-BGj2IdgFk+G6Oi2N%(o4z7
w5kS|ptP5yv$;Y{HqhVHz(t{`j<cM&Ku!ayul28OjD`r9&jcX!;b5JP(04ymiX8-^I

literal 0
HcmV?d00001

diff --git a/3rdparty/dx5/lib/ddraw.lib b/3rdparty/dx5/lib/ddraw.lib
new file mode 100644
index 0000000000000000000000000000000000000000..d46efa2256269b57ebc9ecdfaf15088376202ad7
GIT binary patch
literal 15336
zcmeHO&2JM&6#v;KK=XwOA%#+kgD66Xrm<ru4n?h_7@DX~h(ahmAQ>y!f`#KmuA$u8
zKY;_{z#qY>2g)fzJ@nK=4?X9=fm4O5s;YW`zBeDcv+LcYOO2FG@}%{8-puaIoB7Re
z-hAxfg-T=b)~B5xr`(bs9m@}oj%P;Q>eR3br!(oi{ClGlz(+vu86bHb=(`W}KLrL}
z07tulV;6wq_ka_Rfx+j%DN29(JaFbNaP|>!?in!j3P_&>M&^KA0~mV%j6VT7dx7qU
zZ|B`T^W|c3YN9lfDSugAnz5EAYPFTcLV6S){iTLw719}2PuH7Pqh6_%Ru*p;@}}l$
zogThj$dc~L%ANYslvP`m4^<o1Vzbz&d^_2&Doyn!k8-kBU0t;ro(C@0?<`vldS*i8
zWj|x<ud)7ft2t}kYtB?xXDX{Ac;!yx>&l{asj;$LoD}bzvMQ^FkrTD*&APQz$PA-w
zn&gC}IVhJncdi$@tJhLZiAplwC-P9?WwO30s*LJF>Mm95RjwHo;_9Sw%g}Va+7#uG
z!BVAh)B47KzC1lMcX@uHT)cQ?a(;Sl;WD?`{KPes%d=NYrPgSQs4lOTJuT?8tY56%
zzB<yZ5-zD%@3ggwakscq+RbIOyML6~`rZ_FTMG;X#tJ0JSPvd-Wh*LV)CSm)3C!xy
zm7#SSCo<&*XpsqIBdg}19_7-ykYmPZ{J3-qMW)WilBskf>N^1+37&<itFvE}ixUeI
z2+w{QoBfUu{q+*3JtVH1?;*ZA3fwymJU#(jPZG}&hdmer=0<>5LqH=3oJ<2x#(@_D
zz=dPLUE<D1XMy{Dz|(%>y;H!mbHMXK;QVPpuh@@$ID~#2z#b&gfxUPahj9c4(T4$a
zp$DDl#yjXm4Dk@D6JEY^dW)MM?S8V$gG{fxJh;n)_UO4ycu=t8&{D0Y2yrtnFqc;}
zn7YwfipBBE;~z)9kAav9SO;QVu>^aE!9x5<WJQd&nNUJb%Rl07-!^;jt;P>kmnzN5
zsf^Bqs2fGH|0}v!5_A=iTvO>rg_3@_Qtle*SYJSDjqhHeVTG$m)Tw;qK2Zf+XZv8c
zn0QRrBWE9nE?ogwW6dqC5#``_CbTBYX-MIu$vGO<f51OV_(}57RfunK%+hbU)gRl;
zT?-hGZL9tx4%3-2H7{Wt#sm)Ms6?t6VyY%+1eU_>MAH(Na67paM!;RKG`N$k0S;(q
z=(6WVjIzr<RHGa`Whbve3YTR`2h_cQVU4k@j^cE;bihbws@!&wBZ7bi32jwwIBQt7
zN3_Ua^!_fHeQc;na~7j0d+GlVbkW372wR^@rf#T~b6Nir#r-UkiCQWo{jL9%(){M1
zZd9qsa}rFYgW_IDrq*76$bT8>9dvQ&r0k~~vzrthayv@Gfr4ovTa$?KTU4v^zt_#b
z`7N3tV@NrDR@f_gXpGya^(ozQoW}0yqV1V;60WD>=%Bnz4&tX1F}7WcOv9m*T1EG`
z=q2_9$bYsR*z3dggxs*%6Sg;IV#M5Lb+U6!>mWw2h!SQ7U6}cVLcW->XApsq3C%Ov
z@m8MsgYw^MJVO&Z_J~{(mS^IG89njl6{slSh3(ejaLoH!MfW(EjBUJ_28zX(pe3NN
z?2;WfeO1XWe^Sm{4JrLprggeZ35%43ffO}0i2%2-<ysu9xINE2C1}BlF%fMWTJokx
zDbeyf<-OI=LW@iP8!da_tXW5aQ`lxL4o+y<&6YUW)z>)jEYAi(<PFB2@fII<yD~}#
zik=1SC?Lh3QD|Y-mN;k`)<%lQM6s{YK3^r5&a~j=AIg2JamssCrggeZ2|EJqZNZD$
z<%qyI#P(}(_~o=#(LIg={c3*kpvJYG6GS#)y_eju-ihTE4mlq2^l__Uhj&BP=`tlO
zc4$@0u2N_JD++wW)@yN)6Fj5#F|(~c?@mI^em~S)+Zm{l+rRDNnryz+uX#zZ-fCRK
z8v*OOyQzCvuIYk%zkKVjz^LsHVXwn6f!?p%yx=AJUGG;RNU!P2pbT|0N?ZphqQEO5
zy<e}1ZTEiDJI4F%f&ZzRD4@pQ`xV<Es)xk!8U0h<ufL(<NLTx2PFdGJv-Ezq>xk3~
za|tvGi18nh+`e$eL5$11-~lP@3@JO_I=kMkI{^o5j6`R3*MBF#%{JLql-MV0+U4Em
z(mQ7yO2Yq0W)xV(jSSww=HVxB9P&3*oK$|h<Ir~96*vgvv~C1e?fiEI+$b{m#V~GT
zM>qU9v~%_u`!q)Ev)fT%7XNus;69^5iftl)$`D8?q0y3WUDw^NjB-e!h0pUx0Vn>9
z66n`ToY)^Lw98+~?jVHpYlKAPG}N0RM1Q){K7{O?vkHe5Lik&s=yFKlYOUlD=R>9-
mi0rP`@??O-Z?$$nVZ`|KD+2zjzgH4?RzV`gFmXe-r1M`6AMmmO

literal 0
HcmV?d00001

diff --git a/3rdparty/dx5/lib/dinput.lib b/3rdparty/dx5/lib/dinput.lib
new file mode 100644
index 0000000000000000000000000000000000000000..d105311a3b5824f6fb0c7a334e86026d8b534d8d
GIT binary patch
literal 15336
zcmeI(d7K+%83*t;yS-Q<ELgE9N6>;*aLL|XC?%x}W$CsJ?G_3YHf?v?E-W-`x6pEi
za^K;;A>21aMFm8SS`qJvh^UBB@kWh`h>FzbH^=jveYU0YkAEodr^)=j?@TgpX5M*c
zlG*MyZOPEGmDB6?PK+#5+ora)Cp)GlM^-07H+6(5Q|Fx9+PSeZt$E(L31xXqq<5Sm
zvllzJ%X;TJo^@{g^xn>aq5fsVT_<GM49^_uUozZ3Bh}dEMpqy1RrhwyNza?#)7yFA
zf|>KX(mnI$_jY#8O)u<my}ff6c6X1SFEa*?&-RXfLw`M+ndz@>S#RI+&aOjNty?`j
zu<SV3JJL;I#q9odOIIx!>I*$*)tc4)?o7X7ezSTGUO0DlZ|97j8Sd?F-R9)fV7q7P
zwvx^Je2sH;W1X8m-noeroGZ&?v261xJ36<17w4Ys@OFW#aWOa6jq#@A-8eVFZRKh=
zv0?w$x3|9=8u|tY{Vl(x-rSmO(e2$G8{@{j^mOxUez%rq7i$>qUptHxlyNeBOdd}L
zj>$AppU5-}^eq`)GPyOVmObIz26;RaRA9MOeX<lR*Ai5F%gLeP<nZx|S*|Upb~{L@
zgb1do`b25t?tpX>+51lRdsw8KIO#G$@fCBU4!^^li+)0^y*7q-LGnv%W9oGz9PB7D
zmyq>EKQGo^E8A{UuR<*fmeE&vpT1UVM!u@Xjg@r;@9ceYyt+1q&mI<k8ECh#N~Se#
znmljr*x%A%@=l-eH|3`Kj2qo&X8b?&nc#e}*%Q#)?K6$7(Q&568)pV(vj@jnEP6a)
zZ=mP*Aw){bZF>Az8CeDq%SEfgV-V}AaXZQL=FV1c`%^WwM@G+>_o>qI{^nCPhpm|?
z0Y_@Iq+ER|>S!L>@||VYW>5TeZ@2BO9Ziw8`+H=)G#sO5MLxpTvD$FRi#Cb5UZM<Z
zVH-KaCRq^6;>nxp#4h+>b<pFQ!j)p*bjs&n6zn{V&nekA(eW6|#^rHRWI5EOT%v@j
zEm&4IQE(>0JC64@0k+wA$2}&L5^hN}K+hFTDd$S4Ss9*lyfXvdwKlA2!7@_8Wm;K-
z`d#r96ui>8sev%5acOz(9ep*q#jDND9Y=iwg9A%j8dfbmHoOXHZ=c%UmTV1rTsUb=
zCfnND5{c%P_C~)hQ`a4fxrNJ~XdWjUZ=0Z%(Q`Da7D>;<addUiLvaz1aOsRpyi&Vy
zV=g=hu~nnSC?7TUQPk+7QKMf(J;@m3NpyZfT#xk!WwP-U<GqZN;&|lsjmGG((fJr$
zqQ=EV)VL&z8r>)Ac4PF6=zO`r9^rkA_cg|TiN1b6<LSox8>ftC7$0Cf)40?4K;wgq
zXBi)C++}=-@oeL6<2lB2jprHTSd4DJLyhMfFEH*gUTA!nv0MU=Sl=S!BaDwUKFWBp
z@zKV|821`yjF%WMHC|@iXWVbR+<1jCt|p?}f57-y<Kv76jgL1z!FZK%*7!u@A>-A?
z!^UfjPclB)c&+g|<5P@JH9pPwbmKFO&os^%pJlw>_-x~IjL$Vb&-i@f3yd!`zR37u
z<4cS$HNMRFa^t-56~<Q@UuAr?@ioTR8eeC8z3~mkHyYn$e6#T_#<v>ZW?V47-S`gU
zJB{x$zT5a7<9m(oGrr&W0pkaaA2NQ}_z~krjf-OMdZI>xl*i-|_2b4*8JCPV7*8_Z
z$+#T4R)Uo0<l(J9@C(K-8dr>8HrDkA@2BezTn(2WBSFfm^6=Il_;uqqjB(u;U4D$Q
zu0MD`UB4Lf>g6FXarN?amrTR*E(znjxp6Ng<aui^CFQx!ODTEY%1dc^p5Ud7JdgKM
zR#VP1-Y>7IpsA>-ByZub7r%S@>#a!g*ISk3uNN!z*IO?Wsg`$6Nb=X4)RdCszh7FC
z|9%-s{`+Mm`R|vLB>&JpnfUKlkmSE#QBz4$&^}2)`y>VJlN7X1CIW0fNkRK01?|(+
zBWbL+T*LB#L7cf!-rVTiidaL#;^1q=GQWBgzue(_!S2CaPOzg>G6#FrKd9al%tVdf
z?e+|6F!7gZ9aVF{s2W_mg~fl>;*c`+YX(Nu;EWs=f0?sF%CyE^D$kqx^?hi?s^Ay;
zrpXJMn%Y}iT<@%fU7fw@d4~mQ!Qen&|4@MWr_5M8usX!LDAq=BWF#LE$&0*P=WX=n
z|NOgLV{@{@ewVveHu5&XXSCntUXV>NP3BDuj(_y0cfQN{8>>Yo(Q8rk$*AA?E;n*}
z%re{OVB;?1LyTt|cN@<!o@<QpAlyIEa|zA{d&wg#{+L-W^vBGEB!A3IN|K>UM#_{t
z`(q|v?T?umN&c9b)s&Mo&U@rF6*Lt!JtxQ6md4iRhRu(yI8M>-kp*LGN#<~Dofs^@
zvGv1|m&l@0@S8<g{F+oqnff)@)?x8$@Xa$Ue$9%IGWBclZ73{$4ZdH5rN&(>(TuGy
zht~i0$l5e|WDS2Qx4)9Lbu<S*+4{ed^~kSe$Gp$)5%`35WSvy+kE}g1MUfxYMvSb|
z_j2A0%#%kvMq}H>YiJD4@mhKeJcdTkijSqyBje*}^xF7%8vQvwfksb{Z$;x6h}Y3L
zI^tW?IBw!`8a*@qE*fW>_%`&m@U}EINxYuk4&IL59^RgQH~elIy*xgV#uY{UJ@gLn
z4)lBB_tF?0;*;nd;T>t&tuFpP`u*_xX<W6&ccOQOccyoNccFKMccl|>g5C|@js5`q
z0s4dR2kFW1WExjp@!jb?;63OM!5^Zhz*A_95%CYxAAvtY?+NcoV>FHLMSm3jDBS=z
z(0jvs(@8i<H^Pl{6Wl~&#ELi5-kG_D_Rh?$w0CB1qucTNc6us2mF|E$=zZXQ=zZaR
zX<RYIr_uYt`_a?k>Gb~a{&WgX(KFx~^a1bz^h|gr-3fQn2f_!^2f+u?v*1~@cV<4A
z?!x>o+B-8JLeIwh*>pGDP2+44pF?|R=DD<YW}Zi<v3#076h4%m56`C;zzgUexQAW{
zFQgBH52Fu<52qKwi|8ZZBWRrK;z!a)!AH^fo)KS69}OQ(9|Ipl_rkq&2F}n+;3f1@
zcqxtRg7`AJ5ALJ;;eL8Kyqw0FI=+Hl39qCF-~swr_*nWl_&9nH9;A<lkEc(7PoP)9
ztLQA8rB8%Uq=(=k8rK!^)$}ktOs|30&?mts(I>+v(`(_i^g4JQeF}UEeJXq^eHwfk
zeL8$PeFl66jjN#enRE`$(PzPD(d*&$^x5#)^f~Z3^ttf4^m*`k^!f1l^abz*^o8(+
z^hNMR^u_SS^d;~m^ri5n^kwj6^yTp7bRN#rSHM@$SHf4)SHV}&SHoA+*TC1%*TUD*
z*TL7(*TdJ-H^4X0H^Mj4H^Dd2H^Vp6x4^g1x5Bs5x52m31-L-p4&P4S0pCI23ExTI
z1>Z&A4c|@Q1K&g63*SrM2j55E58qEe06#!K2tP<a1V2PS3_nai0zX1O3O`C0;UfJp
z_+#|P;g8dwfImS$20uoB68<FpDfm<Lr{Pc2kHe4CPry&mPr^^qpMgI^KLtNUe-{2M
z{W<t^^ylHv(<Qh>e*yji{YChT^q1f-(Hr0m^q1i;(@(=s(_ewVLO%mPLw^<iD*ZM1
zYxLLQuhZXvzd?T!{wDn`_*?Y1;cwGrxJ-Ws{to>t{4D)l_`CFT@N@L{;P27T!_U*-
zhrdt10KY*00R92}L->dEkKiBCFTyX<KZbuyzXZQT{{;RCU4bj~PvM`^KZAcp{~Z1~
z{WAPA{R{XP^e^FG(!YX#MgJQ9HT@g-H}r4e-_pN>e@DLpze4{W{yqH%_z(0S;Xl$<
zxJv&C{uBLY_|NoT;J?tX!mrYQh5t&w2ERuC4gMSbI{Z5Qclhu0Kj44R|AhZZzX88N
z{|o*X{U-b-y%FB%dy?dOdDO_m`{Ex%@XI)v_;)${l<<tYq^6Xnw5E)vtfri%yrzPt
zqNb9jvZjirswT8GXrHEprlh8nrnIJvrmUu%ro5(trlO{jrn07rrm7}v(4c*q5}J~l
zQkv45GMciQa+>m*3Yv<VN}9@=Dw?XAaH}I|pQePSq^6Xnw5E)vtfri%yrzPtqNb9j
zvZjirswOu^+ovg^DXA%?DXl4^DXS@`DX*!Zsi>)>sjR7@sj3M-p9b4cQ$kZxQ%X}>
zQ$|x(Q%+M}Q$bTvQ%O@<Q$<r%6B-w^Pg6ouQd3G(T2n?-R#Q$>UQ<C+QBz4%SyM$*
zRTF-?7RaMsQ$kZxQ%X}>Q$|x(Q%+M}Q$bTvQ%O@<Q$<r%6Mke5+NUX@DXA%?DXl4^
zDXS@`DX*!Zsi>)>sjR7@sj3OL1A_KxN@z-IN@+@K%4o`J%4y1LDrhQdDrqWfs%WZe
z!i|fdeVP)QlA2PQ(wZ`wvYK+5@|p^oikeEA%9<*gs+w?%C1{_fgr=mXl%}+%jHaxn
zoTj{{f~KOTlBTkzil(Y2+zblZrzxQ+sVSu?ttq1^t0|``uc@G^sHvo>tf``@stLD$
zg7#@jXi92IX-aF#Xv%8JY07IVXew$dX)0@~XsT+$E#{zoni86lno^q5nlhTQnsS=*
znhKhVno63=nkt&An%uV9K1~TtNlhtDX-yeTSxq@jc})dPMNK75Wla@LRZSD?w|s}N
z=`HRM;(inEF^w#8`t&Y0F+(mzq)hal{Yy_d`AcaCYA~ts{x&_hM;HCihQU3$uxjLu
zI;nNuUn(^I=l9cE+QU0-yr1@pv_J+luh{!(7f9_id2H}!JA5+pmkPlg|8M!_uaML-
zi2Hw)6x7H;g*(MMUpny!OQ+F0$yi8sk~(_*E}PuR2}}#t<6pm{R{jdedqz4(l3XfC
z+Wg<vG`_{&#i#f7rA%2+la&Ye?smaU)cAXMN>GD|-ve4k)ucw$bc=!>;Q#kh-lFw9
La^Ju8AF%uzcYt+m

literal 0
HcmV?d00001

diff --git a/3rdparty/dx5/lib/dplayx.lib b/3rdparty/dx5/lib/dplayx.lib
new file mode 100644
index 0000000000000000000000000000000000000000..21a5f06a9610feadae962242bf639181d17be445
GIT binary patch
literal 5328
zcmeHL%}*0i5T9+KEfr!3#*-h#=oRS~-5NC8P!hokO(_9SOQBUr%14^w$H~SM2SbcU
zV~ht6{t0+79EpF0e})GVoOvJJ_u4MC37R(XCGWj`GqbxhZ+<g7Z^x&L)s4*u!MkC-
znN!K68H*(+b#hp)<0(^c)`9>K0tg%e1m^*U0{|l@0GAH{MsYo`2jDw(=Z_5o_>b(&
zR<*oQ%T<c6W~$|4t!zc2pb%$w_P5JbqML2WX&3s6PS5VHuZtI?t>~osD227cSoYlG
z++x09XJ(gX@^iVuV&2Z=vgs$QVA~7J*=#Ex8C%<XwxYITOEXKe$d$?La^*7Xnz@Q0
z+{SYRgr!XDXQdYz+W)0ozWj7%cYmh_uerh8+`_}<g-3QKT}VT>Xh}pQZq|YXm%Rai
zQy;*QAK(!25<m=`i~t;52AChkjzYs@3|24zLof(F@IwF$@M!BGcvTlFyY0Y9+vhgq
z|Hx@X-akMN2h>EVQsEftlxGsDXd};L4G;Xte~Y~_Fk>K!egYVm3@-u7y<uiT&>(6$
zH54RS8ra;JI^FnJ`4d~EVy$>PDqnI1FEVKVDt2mK>=uNMh1?V);(!4K&lNeMTM#~`
zxw(-nZV}s4{zO090@^b_I3DBo$(<wxJRtS60FH^WDJe`7da74a;v|CvM<(G=h<=j>
z(dbS9Q><w6Kn_Q{HS2cF%5GWAvFy*V7>OnoEE)`pq?2%kA@(9h+EOE5O|vU!AYVBv
z{Yu~2>&SHd&;+~IJrP%Q=W$fQH#F&<kQ$LLCAko@1(OnIamgaNO}S9yRFZDjHDq0s
zM`EUGm6v(s3qF5{zuuUrm0#8rRq&GoZ?V4@G_pP%3a<&zY1V%fGIFv)?XCYT1;k8p
zXLo2p7#_s#qg}33SM{NHdkxZvu6Q%fYQN}8rZfY>PK+__SVS3eNA<fTm1G)`$vj0_
z!mHiofkE*uJ?ieE<hfOhYf;oKB4g&1g2>+W9b&0Yy%&8q&H=zi56d+zzSGJd_vG2V
z_tae2yWYcCs8jDn@7>b8cfVcaHN3~q0j|N<_4goV_J{v4bJeN$yZ`t}?E?Lma!yoP
zqj%#Eze#oKz34yokrpxN0jpj7wVsGvUD$O7?Gq1T1yiTq{~ql0Tc>*uMp`PE?}#G&
zp+QZa2ehh^s?T?f&Fen5s`3NMd}=S(IOAPK{#PL*CoANf@u>Esb24vy6@WIsdE^O=
zY0B$TswG?NQdwaVN3SsP8!IYId6&T|O!ZvKt5DKfHZDV}8<K>x2U0kSN~Vpv=bQn9
FzX9&$hGYN$

literal 0
HcmV?d00001

diff --git a/3rdparty/dx5/lib/dsetup.lib b/3rdparty/dx5/lib/dsetup.lib
new file mode 100644
index 0000000000000000000000000000000000000000..0730545294ea16feceb2c31d77f81ad3cdc7d8af
GIT binary patch
literal 9534
zcmeHN&2Jk;6#uPFKI){wX{lOOr8r7K&_nQ7Tw7FStvEm+q*3C~-W=ns8W)pBj)_n&
ztT^<<i8DwX@+b7rLl5B}=-<F!&{Genm-623%z9@(k~lKbZk3UqXXm{)J8$PV@6DHI
zZa2HF?K`PYGioZA%7uKXR4J?MOjeY0*?iu9+)M%Z0GK=grXB+6EHM2NxcC&f^cc8Y
z1g^XSu08{<QTckA)L#QL&w<%}VEhR%apCm!Ctfsa?XJ=4-LDz@?UqsNw)c(hy3zY-
zx2oq#2$kM*OP3!tx7K^z_Ra%6mv`!{84ucfJ)>LQ-R-nn&0hP_PE{`-CBEkpOB?#{
zvp5UQPUrh(>jyobb>3tNzBGDYv^&OkMt6@I^2r3>+rZM^*UjDLj_!GxV6PZ0uY}ri
zOem_YP?z+L-Pj5Ed~Ut5^zG{1wR)qrxW2Hqv|7Kr)~Ky7);Cs3w6d|h?3a_E{o`&U
z6bc)tqjhY!6dey}iY&l(3%cW!EC3ZH7mR+s(~}IQU+jf6P{ReRU+#i8R4739%RNy0
z6>Pv2ei-b(*cjUg*T33W`KD2;)~gsiaul4%F-@W4$vALf0(e1mFbO=I0$!5f=|$l2
zC8BFU`8x1?2H2kkUQ?`jb`>aI23}nOvS};);2n%$8lxD)INn7XQ#gkd&SL_T(2zJ%
zo^;&cEQZ*z)Ee|>F(f$rEB+D?XwG6t$kY)QL+sEpx7F#`(d4+*$9zSEkj!RkSxeyN
zpMMvA)j+-v`~zqcT9Q{K;fZ1fg#?NT$0br^UH-9hCp)g<|0<trZ#8?(8+qBtd-PDF
z@4rvPDM_RweJJ!w7L$G`ykg&_$9x@`L(aX4b*YQ2KDFOCW_1Dg*%<nW+4W>kvH=N5
z`*h%tIopzBS;B8kN=}h=h|$-X?{k<>;oeDHlV$^_%x$ew=`>4{VU5LH{+3u1^H|iZ
zvB)+FC^XR*1!**6bz2rh&RBU^PEqaI_lY06%1ZT7Ihh~j=8G=dZ9nQz3m)6&r7>*F
zmMn-|M^=tATIt(~^|oa}<gDjrsozDDJcflxp;B;tRnkJ_fZl)3ZeE+~89(=2ri{|_
zZ$!Tf9)Eo%o!Jz~DPRAG(2<#*4*vSTq=Lv<@6Cr?;4wTxG|IhfGP&*Hwv!rL#7}n8
z-t_+ECmGT-Wcog4S!a2aCVNz^CAqBQc&3FEM~S3TD}fQw*2nfstltC{C|6gvA?qan
z(!XJkNenzT<ANgftI70MpeQz3p&PuxQ7q5L!WU`NVKPM##f;*MpZR>zyA2*9dKLHl
z5Zy>hk<4U@B6^=F=+%7a1?(T}gNjfX2c6{$F+q`LDwF9gLDAj?4iCk0E*6oL);1<n
z6j9_=rc4RkqDOUA<38#O1@07cpgcwA9YS=YDDC)6rYIseD`BHNfjhy-sfV$l01h5M
z<KcPd2|K1J;`fn)Uo{v%-)VU$gs1SqN-Ux$9fF%oQN-|ug5l?(7`pE>hKXP)76{Vb
z-DHX)f-?$&d<qpX|G96RLg5=YhL+>ue{_OuGDQ)+6ZxNdXEW6E7<u;}?Ntn&l9^0V
zM9?|_6h4@M9_)YKOWPs(U_90_bRldqMG?Uh?I6UhdMI#%uU;zgI7Ooqc9SWJ$lVlv
T$5{f4KHm%b-@_4iOR4_=ZwRV<

literal 0
HcmV?d00001

diff --git a/3rdparty/dx5/lib/dsound.lbw b/3rdparty/dx5/lib/dsound.lbw
new file mode 100644
index 0000000000000000000000000000000000000000..2f8071f247b2e46c843bfebf78d398ece67473ce
GIT binary patch
literal 1024
zcmeys%fP_Iz`)1=1q~7mV(~7SMXAXp!TF_mDXw{?xv52oC8^<)I&2vl7BJ$H=1M6B
zsn<)%$q~h>|7;h~o)VnqJFdWMz9S*?9e+a17hw=WcE58`D$w!H9j0KnW068KR}jhF
z5PkY!Ghtx^qCcKR<_!yW0D~*cAHpyO1A{h@X#vCvKpZQM9HfXOp~%P}j4T5QG(}zp
f?CKpA*>R;FVEV%nH^8)sJuy1616?%=s1O1Gj}w_y

literal 0
HcmV?d00001

diff --git a/3rdparty/dx5/lib/dsound.lib b/3rdparty/dx5/lib/dsound.lib
new file mode 100644
index 0000000000000000000000000000000000000000..fb4d55989992e1cfda93d3a90c4afedc519186be
GIT binary patch
literal 5646
zcmeHKPfrs;6o0$hS|}1r;NU^y8ZjmwuzzWZglwfG5-SjBgSVy9CXf^)O);J@@pBM9
zg%>^bV2EcAoH+DDc<^9?@6GP)%(A;IYcxXYOXlBuZ)V<m^P4xj_h%cO&8@lQ6WvXv
z>0+@|%;jg?Y&~s{3+ZXQw~+*ZTL43c0LfE;(McS(0mhC1#!moZ2LK7w36dv{&B}JC
zwb@;Jv%lM%Z|rsVJFWRntI=&4nJoAS7k2k|S{;;^jnakk_49JyRRfoE1Z*91@#V_$
zYR#-Htj(`3uGE%S&C1$xeW?Pbxm2%Ky>b+6@9ddA9!Ty5sW_W6CquO?6Fu7rhdnEV
zY~YA#<@c7SmY=of^`#ePrCcjRWYlB?YK9Ru2QkD<0^k@+8!>b=25>SCa5w~TikO)k
zWzd2I48btOAPzS`0o66u{2(9&*b6Slwg32WLh*0#W5H^w*=}1%3e7q*StsjM6&32Q
zKjl6sm|qY}eE?-d(I^`QQwl{Y=A>W^TY`$DOBHLKCUoZCRG8XsHoA?;EZ<`SI~DZ*
z6&4~5ivg*gtvAh>Slz_(R?;KB0eX+x^F+EBA{J9?#RLlh#Vi5h#H@Kdl4O7i+&%-K
zN1QFrVV2OU8t3Fm2N^=AAUMRoN0m)96QE>|s8L}BYtx%_Lz8k)E)$+z4vU#=QNp6a
zut+x9N1@oU$dR=~bXK#hCn`ECF>?3Zk-dw;z;`AY+4e$Svfa8z_++2Ay}&IZTbg`e
zw+5s+&hlJDdRu%T>B%g&Uw2USr%t3Gy)IQH#!loXu0LXJuS|7Y@4AvHH?aQ^%V(QM
zC#R?M4g2I=-hV;aS4q!E`FsBjbx!>C*c~7d`P`?DL`F*QojoK5VLgt8tg{FoL;E(;
zn2)^gn)T=b$bOPfnnG*YxTM}$_Xjq>Q>6mBxVy}2c2hBeezW-bk&biY83HK#Xs%f*
z#Bnb<8_{e{p$KrYbZGR5v#?d+8P=EjfC~IBi+U>x*_?DMEc{T|t{Q%Hj7%SkOi}Tp
zfEPc`$3XcyU`UtT7Z`f%;x6DQ5JSRU`b`LaNg`+0LBf%G5suae3r8WpiP3SC&Uo_C
zcSQ76%SRJvQy+^=QS*`J!V&vzy$0_XdCp1XAf2<YRpBYtJ~>GGGY@>gegiQj4`S%4
zziNoNjW+eM$P^VZF&Qx;mtO<akoTMfY94SFwkphF?M01n^WrBf@|RC~aBvg%#m)L)
J;3njW`UM9D(9i$?

literal 0
HcmV?d00001

diff --git a/3rdparty/dx5/lib/dxguid.lib b/3rdparty/dx5/lib/dxguid.lib
new file mode 100644
index 0000000000000000000000000000000000000000..0a31406325c95ffe4e94d680b22998149b81753d
GIT binary patch
literal 56332
zcmeHQdwf*I^*?}Cii$2MqN0t;LxE~`H;;`^LN<X&0&5bUDr8BPWFgrNn+*_rg{R<K
zz!!oB5kW-pRiCW_+N!mXRIAp<=U1rx*=lX;Pk*-k*#7A6+?hLf@7$T2z0SSx7koaK
z?4A3X?>T3_bLQMRbI-asnyPEOwBH3e{J&5^VPUAS$RFa1b8_|lyuzY<`m?ql06Y({
z;R}HJdVqVr1ZZdixEKG<o&m7_uK>{qKx{6+roI4;`1d|M_rZez4-EpS!)xZ?`L$ty
zjd)GG5#WKZ0Pe@%OD+WHz^!~Hz>B8=bm6(b84EBG@AvEwfJK)BtR4z*<GBEfv3%8V
zfOfpkO?d2My!S_VYy>`UWEsGRxd7+leSUi}z<E^wA6yDB3a@!@48V^=0Hg6a?_*hD
zB*3rnxIX~UeHFl%2LRge`q!TW2=xX?R{*4H0Nz{&@YX7T`~g`09l#}f09vtLx8wfq
zj{x3Y3Q&M}7mNq^)wKY(VfkfG09^blfUzq9Ui})Ncn!cC>j5tOJ-|hH&92V?icnrZ
ze-hxeR{$=30pJ%81MK-Fz%7FTZpH1D{s1M5@p=^d%HaTa^aGeb6JX6jfW#btd5!oR
zkFEPVKyo%f6XL(?D}a_-fTvL&lP(9CItAb{l+Wff0cK+TcAN$<1M9vs2jFVNw*}?*
zIBr*z0c^u#PvCjm@%%^d_my~jEB>B^$EKhhB4YunvFs^4=SjSNdKJK<c)SXq^Dy3H
zGT!&9i2yaYJ%jtxrU2ZD^;`QLKr`0$?!N-e#X2qx0NjB0T5&GGwPOGl;ytfJT`n65
za6OhU$MTy`0=Nc`jl=U_#^2-X0ZQ@r&-w$D;oqO)-*6MaFRuqE#Am#O_07EyU~d{A
z4`sIxj|H)w?;z%P@!scO3UI;20F~1Kp2Kr1ux>xWI!?g9&*T2(SpGuJtdffA^6;#Z
za6A>OO9#VMmBop8b2J@KCZLC7)v>hXa5%OgUKf)bD2vLAQ_*JW=~{VtA{|S$B%7k?
zWJ+?&ig-h#tPZ3+%e9qJymdU<B)Kg+l<f|&)<)UYSUk2Z-c%oxRk;$6X1Q-9m261G
zT3h1_V%ph~M^raP>yry52Wn!A(rqc3IQ1i09zD4=mYNc8ZIg;+N<6l(C7F^5oE^$?
z`>CmD3#&CXws0zH;K-DeG{sw5GUB5L$`dVZ#<NXDyur}}k)~)n{~)cTA~}1urMNoT
zmZ;~?Bt<3B7AnYacuJ&ZdZcvL*s4jBCe&1wmclHftfZv8svy6>R8l%?d{t@L_*ql5
z|82@Egz^fT^J%&H{K)w7it<P`-XT(~HQ8iyglL5BmQU20Wajr&wnLDkT`h<ctE6XC
zChKF(><qGFoF8dSCeVuLd1S{pR2@rc4cvOOnq)fKR2^STuBwPsO^TFO)l8p79z3os
zjxr8MGR0`ut<i>9Yjs<TW>GQAVNF@Flz15}udYjKCLWGdN5)M?A(Tg^nf59tg-a_<
z`_-jY<;9u^+37VUk@5)4BA1SBOQ$uGBReI@revxlnMkLSO(oH$rrFWDd9B8=L~A;l
zNS7s38jI2M+gj7fW^+k67&a~p=x1SB>7sNjQ6H;Eqhj|9N1KU(lN*(#;&qg4$?o{_
za7k0Nm7Q9ih^5l;sD8W4lkKhPc-=gGcS0<chzYf2rN-kX#L(`^&GFalWHeQ8enMre
zJ|5)?;;nVDrlx2jmTYS^5b1ZQ#Il(A?1{-lMY1m1G$meN8EZCyj7*xMUsHu}&4Q|0
zRJ<t809Lh|cNUv=s-p|j$z-}QoLtD1#EK>(kq|)Dam`Zc&n9Z#bf+a1Pc*P2^V_1D
z&Cnz5txO7;5`s$Kt-*dF(a^-spPZPN$W#DP#*$j2v&zMEz>xbi6PW3y-!tg%a?N^?
zO^jQj@kJ32b{zDO-XU9d(X_b3i~%Ku)>BIt#p>G9v9WD)<_J$2UtA%*litg6cdx9R
zCOwyRot7H1VrzA(#*LNUrV3jy_q?h~;Zn1cVma4vUx<rhIcW1hS}Z<=mKUc|T90D6
z6?JJOg*K;CSI2t3Rw_QXOe>b(hwo)Ax07kBs*;q-@5Xc^prg)*<@Q>k;oaCD6Y)%%
zJr|uz;UTnGUb6`DT&zCO(?OeKRu9TjQRY8ciVg2cUM^xXyGxd9m`5Z4W(VXoXU>;!
zH_a!LUothGurX=sZt=H5B9@*l$F7%JkuwYyaIBa=ow|6YT4)90DTdEyIn&%LbI;Rm
zLpwU5I1+7&rPIjYmU~sVrRI=Ph`d~^lzu_b?oKw(Hwc}(jySM^Vo4b~SEd?~^CYL~
z3}t^ravPn!#QW0&k}FEFXRx$WQXyI%PT{B|CEgC*67-zr#IeJ*BH^DwJ#*7JS^+P3
zQo^Iuig+cE67eM6#kbs_l!_0b#WpwLi}i7W>As{S7?$*;`jLuwE4qCaVUc5Y*BFBi
z>tpl-cGpczrsH#1?=+zmU32s;)9qU4_r2p@`ThbU?u9`wm^%U^C>WWjIu9cd7^xUL
z3ZprrF(UM1jNY7&(Vh!%KNq7)evCq4gyYO0z~DT90r>!Z3-AUQrsy34_zt(f76JSo
zqZJ=rgb^c*O6<7=qYoINc;YgQh+))YO)*A%FcPx31fx0_y_j2y8%AN~j>E_sMl@!Y
zV|3+mjLJ;F4WlR1Dgh!BF^Vw>>xEI6vMca6MrSIjF@jcu$0lP`1|uC)rs9T?j;iTc
zHUp1eiN~+PzgJ^~WhP!X3!^Hvcr1!hqS^SYIvVMl8^d~F#HpzP>(Gdiy*U2GC`{u#
z{ELy6#%7G{B`^w@#OPiN)^9#OFNODM#d~8!rmPL`zW{$P#Ck2lXS8EI7h}Zj8r-hM
z{p)c5dfaY68Ft{d1m(CC<+uzZdCPHI0Wf?e{=E_Zt^ydk8eqsx04LpyGQI`3TT#xp
z;dVPfzdKOYTG(j~z(L%;TMO{_bpT)8g>t_e;LCe(yBFY#`*43f{=Of7Z@|AB@tg<n
zng>x|n*atqggV@e&v_WPEdZxIf@NFr?>7AVC~n(vdkpt?;PJ=t+$R8XcH;IV{(cJU
z_%xP3gWI#X{RGc@4!7s=_zU>=MciJ(`o9d&|EIY947XRX&aVP|joW9t&^C5sbZZYr
z0bj$2)$15>`#DD0et}WeH!$M&CPqNt!f4qqF`D)^M$vwS(aOE3pM9vWE{wu;qmF-#
zGJgkU`!34$Hz?=#&`#gS?E|#c-(s}vL#*RRh~Z-r)P+TG8MMM!NW&$t04|0xa4nQT
z8(ag|!KF|P7ePCOVKFR(tKdo)3hUr8coNQo+o2ljVKz*LI;epd28f@7UT_rr1bV}>
z&<CD@qv0ty27Ulf!*TF991A<(bcjGF41h^c2@k^-H~|L2V3-JVVIypX6X6Qj25~qI
zPJuJvei#Cq;ba&D8{j0^1P{Wg@DMxz4bTYp!I`igqA(9CAOYo22F=g{m%})i4-?>4
z7zqJb3D-jr+z9z_6NI1xR>5dk2CHEOEP(=83KxPOM#1@T3)~EOupE92H$W~n)(hY^
z2tpGiVLYUu6t0FDPzzI`3Z}tKm=3dG4orcw;chqwa^PM#3+{m*!6V><yPzLD3jJX_
z91l;xPUs6igmcj(N5CC09L;hVtYv|gBaucu&dPjm-lG@7u{L2q&KH+nl;yrhB8`UE
zNyTRhD>7R(6*0%ze6Hq)@TY1ex*K9XQTHH(qLL$#Ms(DVL>gH%4BhA>kwzM*I}&L;
z5@`${i8N|2WRFA|wMe<~e%j>u@WXmdR!1U@^d&wE$H~KnM<R{pNR<{$JQ8WdQ3;9l
z9f>rWB5+3{jf8f|_@$>vV*|eB_lNxFCuh$klkM0HyF$whJAZC&K|w)Ijz1LCkJR?7
z=+z5ut$#6Cfx)1oant^tpQ?|hqx84-|B1L=oY^J6#=w{{oq@n-uWs!2ZP*Q+Zyh~$
z=J|8t`0AGaJNO@*tJjOwtj@UFeD7XZ+NYOxck$m*dXaWcZ;Wx^tT6NJihktIg+<>3
zbDk%d_pkZCUjKOrF;D6dGuF&4<^dVZ`V<k0x$v-KZdp9zB?o#gEc6nyKKF%U&KEGF
z8FT*(+b;5RdcH-`w#Q6)aeBku-M+0DDgI}l$Np_&+lBeAF`t^zGYMW8^Lum~4?4#l
zVlAGwYgO#E-wqx)`p$0O#_ee1{Yu`p!ya^v{p1Yx%rqt)x5#Ju>k&im8J+WO`({O*
zpS{-q?D6k(`(7%7U6VfeOM@M5ziZq>DDKR(EUl~4=UowtFA$l{4t*e(w|G_boA!=g
zFzCaq=&@#Qne7}adK^?(CZ$muC=j{MP73}aZ)~7r=d-8x*_@T%v1V?iKy1L`?XdTv
z)CNS>V;ETz$g}{yN54t21+>il#qfq_x_q5O@nu4E>JFP0P~e{RPS<QehQ1hd-HW_u
zi{8R}s^~jEuc?WBywA602%>K)PuZdOi1#e$8E%pHm~I8FTX3&d)Ou~>87F+Ws>`=w
zVvjyefqUN5`Cgwss!tH5`py>_&mK3k1lrH3;)d6+Y#hC@%lGJB)OX{`Pi^##HFMk6
zbzjajZI-m~e39SmF&A-ujVk8igO?8cB!K+(uO9n$teIQPr$}0OkhSi7k=p{yy!F2Z
zw}p7*s}!xg<LI)DXK(BB-F+N%yiq-IshzgnbDIn~&OXxZT;w%-<gB-&cCL!N^OPCs
zchlXz=MJLIPni0V9dh@)Hc-<!nd)myrPfi4tj4?+ruK}!c`x=xMSVAYUQjvg(|x{I
zclU)+2l@=QL+uf(5!9yn+!S}7$ZEE@i@d@8)W`#8eEU|H@6|WLrPVb!nwO8tv1V>t
z_>U|toJ6oP^U-t(h#Y4tfe_0Hr1q|=`B6h^1_p2I_O0(md+$u-+eyGZ#|<*<y~LD~
zK)5|mWH^@LC|W$<pRH81`12g%cF%C6KO+{;awI5bk=yJsv!0IXS{3sMhnU@S8;L>D
zGzOaBpxd{|Z1$M>7OskUm_y87GMg#;gW?Vf%$CdgY0<t}i>JC?p=jUdIKz!KbIWWe
z810%Qx#)-mChGw)i%+>je3nDR?wRZ)192u}h_vaTz+<_LrA0mS{>pMiJ-3WHBiZ?0
z)*cLN=2p)cf5ph|(seB`*&#<=>kzejCd;6%Zf~XOS2}8e%X&b~SdLn_s;<B8-Msmm
z?A}VyJ(u-2EL_WuBeoq7IgBy1Xxn^$wM@~rzjB5bYv$IrGyRpGYe{t+5LxU{WB$}3
zX7?<X!CXbN8FkDehcSN6rst)Kdj4OBnB8-j2{X;@)G><;W{;VTKxtc6#eBdaX7>!H
zy)&faOq$zCTeHYswumj!VpYVu{&C=s@2tu?(g?U`FKe{elo>?1%r9~o>x~5)FJf|`
z`d*@F<4ZpaPd`69cVo@ma@m=hzD@B`ey#-3zF*`ud;IK(JNz9E@w?}>GwkuRxRPJw
zIEGTxKi_w&>VG!kziE3`KMiZ<R{w)#_yfhd<%>+m#?u0FODwTN(ei5tR;_k|+&$A-
zV~ND_4V{aOcc_u?|KVrDrazrs=k6JgAU99iC(!jMYOct3w#Y49ud4H9$DH-#-qqc{
zoqaK?G;Hr6o2U}j%&oOsx!ybhh;Uu5$aTy+6)c`Drj<jv?gmARU*ZtG_gqKNvs?}8
z+vJK|XOEwaR^8!W{@wZ!OUn28ww#4YcgOyBt)2GWb6t*w>j?f}*hp%n79esS^Wg*w
zutZg_SG0g-4kh58^GH<H)Y}sYP_EAv8P6U!i$_t-tKu&E@HgZBG`q{U_NP6@)3Ii5
z+r7Ye6gaW@q732X==1w>?UC~~uZsN5F9((8+}`cGAG2+DEjs-*xy@tEGQhdHgU;vo
zSv9UrCJzve7iFl<z|EqGf~6Pn8oy4_(ywub+e~$exX-e*bqzPS_6F5`hVBlV40g}E
zU}$+LtM1Ko=b;R^>`5wv4B;6vU|y_f2P~pNTmH3*cCi1FLDNf`yL>w?NBa*A+hk+^
zX2MgHf%Q$AW(TGvPN)Pj)aO6~JOijoV9?ux{yhJkeZC#zdz65g`V=K#?e#J(fhJLC
zy<SMdf%Z1wjRXcdk^t7sH3!NhKvP9b5)jxhWN@Cf6$EmbY-lUEMzIz6oJqg~HauIx
zhI}dwu>ye&?PcIE;;lec274T_VaNkElv#m!r6wW)feS+hPOBC8EwP@(idJyEGb`|b
z3$3vpjR}lp#fVQ}N_EhguqXV?TcE8#6@Ncx_&s1kG9TRJ{c8BhdQzkpFr_>=z|O|R
z?y&#R5q2)+L9rLGj(j!jY<(=v@-fALCAk>rSzj+&KCk(9Maw_N8F~-+Po{a2eo8ej
z;XQloJnyMu?|uBX%>xqIJRmL!LQ(TF-ZSNzl6GGx;XM|~7PZeJ0@U^wDQf>HXWI9G
z_pCFbHQU!yMXCM;|1V^4yNI5R4c(#d;|#qAtaqBE?<Wf}63v^^A&ho!uX&#JR5icI
z(I}8hhfuVA8SCkZpcK7?_3UH&yxlKUw0m%*c`gk?5xvar^+a-F_n2%TaK0V-fH7Zz
z+Py0JZC`wT{PK&kjefZ_2u1WGHM^%#ZqwRKdY{J)gSGyzK*E5`+N~TA$Ym{r%3^_{
zB|PFx79KF*xl&n(OUe^TNZ9aDOX4AClJI~H<&q$LDA<H4al+t6#sOBF@LS#nv?<!e
z{Zlqix(s8YJx4~k#0karLEd}{?L%Kimhgiqi6Se0Yp$Fs{`;Ka_rNDSN7^Qg@eo;Q
zQfm*UgbG6n%m)yyfccG-8PbYYaE~)7crYp^@iD;)*cxv1onXF%8|@{)bEB#R?s6sp
z54e$xiUkRn$42=QMr0!((E=DlPzz{Pw1BnF@O!|B#7hwHXGTY+L<__I4>kHb9iitE
zEfiT$j$RudQQOaxc!>7s`PQ$h``ewN_kaWCt)E2(bqPqkL>B)Pt)F=c)cRA3)(<D2
zyY`>Abo*96hBE?=E<R8GegG3eT*rpR5duR`-;(7?xX&Iv9~)3bU%LC0@Z-TQ-;yN0
z8^}31VT0ZS?#t2oKrSN2e@sE^|MDd4XD<Ps{Zu6ob|wL@*pHI{-}jl4F&O(9Go3{1
z=h4qswEo_Xte;E9aKnBadSi8b;sFLl_Ui#X^9g9%S4H2;8F~-cPmGM1V*{r23<sL$
zc~2Glrt(u)ee-@c-s93U6g4mMUS?53t<?ub-ZN&qh<4ATZ&9@S+N<U~+&a9=xA`>8
z8h<f3Mb3LzvqQl8nXk4G^djfkqYv>OuPXZ8XFf4^<eYBbs*Q;L<>%+xp!b0DNJbLZ
z>S<qRO4=|io_RE)&iU4!RMdILkN$AoT3qR>=boNR+EBE3(%MOuq4o1sn#N7Z8;1=$
zgjRO^U>?T8et=$1pUp4GHI6lNZSNWE>@!;IQ(y$U=;0abUx<2VeLrP+RlOfrzUA2G
zTC!PtzylAD%y4FUFJa$6(=A@Ya;!Cr$a(KBp=j}Yj(h)ae=N_6+yj;)-W@@1UIx+-
z0f~TP0);gOZ19;V0e%*ksswg9lYj?IM`nQ$2~^5I|3<tVQ-X)l_U)~J_wiI^kh6Qr
zt$pWaYx`V+ha&G;-vXGvF+|Zzd_23i0RAGr^*1ZFf!Zxq1EU{xWnn%{JaNr@r1cvg
zx6FL-QsX^SVuzu3d*r;2ql$e0!VUXtvm^I__lSpQAg3SkWFOxo=q22DsL|&H7OioB
z-UIHFp{JiPtsuPTm+&6bu*iFi4QQX&q-gc~*ET;>GOEk>(0}#h-(t;NTfKFrkJjch
zAMnz&Z<_FD*uFh}p7)jU_kVE0^~Y!9JZ{3DBIj9W{|ZYX6Xr7!p92{%>A16j<sYBa
z6x^CE+kqoKMHyH}c$y5@N8~gMFgbk&de*mzEr2ltML$om1+19XG4)HF^|G#b+c|x9
z_a7nmcscS@L~qUO)6nZ*z6;Q}riuQt<2Ocs?(pyb<`D-Bz|o%~e(St{4L|jHO~jWS
zx8<#-s@^+K2~B_Ix~$A+CO$>nrnj1OX?@c4^>1&JR-c=3cn$n)EGyW(MelPJ?S6m%
z=RX)z(&c-y4s)FL?6p}pDc1x1MDO%%P6j{q^d-1$+q*ITb7$`zj@T~X0dBJXp(&=J
zsa=16@qKVxG8$FweTgI7c^=@Fu{`@EsK)XI-wVArEDsZp`snF+w{O#X=;yrfyO-rG
zU*G}y9#}p|wI7n;XFa*l+AZ2w^>bD@(tgMT{4(vc&wmjg-$Zsaw=ER1N6%t??mV2@
z5l%cDKSy?IYuB4{dt~1mr=#0I#sHWEn3ZSKzv>vT<Gycd9E@@}+EbH&{U~QV9p&U5
ze)Ri$FYa`Jo+Cf+(9;pFj^0FmS#@ve=~Z>#IehcK9iZpPPYpfk>5cJyNlAHCL4E<%
zx{34-7w+2s869*G(cwtX3*3?M<rU?TYU<%g*p7|dt!>?!!=)O>>%6+Hc1+edUcdvk
zv*vJ_Ml|{-yEVoSNchf92G%)?sxsK^ES~ED-;w^F#B+^kMkbt1_&y+EJl3ySZNM7M
zRDGB6nlt<!Fka?eh6#U5E46+J+u0*$eIV`YRgrgm_xj4^w|4v1{RzM8@LF-9+|vtq
zz;+qUPfR8%l6BE0lt5*y8JDkUrJi0u!g{v&E#n(i{A1d-|7Y9cY!NN2nd^ui8Q&1g
zXK(Nr?x2MA*qbWB;zPXNRo_*2z)KgMH8ks+dJkBStf*)j*9F6R^hUySwx}&p3{})Q
z^ZI`M;IOQyz2Z3zwYGMs{;giZb3qBu+2dzEKW*)*`1fD(+4AjW+2*BT&0Jf%bzBn+
zk1wv!;cLBIP{MUAMlIO9<-0|yb8}$TiS^grm2IX1*330}F<X(-yoBfMv9rh))x0Y9
z{U3fZx-+}wd%$zzoGkN9>^uqA*<<J5RjOhi>ufHf2V7@ei%naasG%`UdiOk$?~He`
zqQ&#=U3C^_A4fCsux73;UTp7d7N$N6S7f^$(6gu}wRu(aWzO{O0oz&M&<8P^5nI@j
zOr`Y*rpR_ZpyzvdRrI$xn}hBF+nFNvraV0}<K>BrXK;Ep+gF`~e}^;t9xxuUeKG$c
z6>W}@mY*+jo-KOos8$vI8b|1{X0BU48Py8tt@-Ks682*~TQ&<&%|Ke`Oa@-DpCE$_
z_vcI4&mKL`eyZs2c81<7_7l)&*5$~Tuph%H>Yn+)l>1e)5bt${-UId{bMyrCMiwGv
z015xuOMv-9?j*3@nFKuGKQdQCkbrfKt^x@Q+Q}ebd_BUQ3^qB-O7?&SM`?LDf()1!
zz$GS=(O-dt51G$rZ4-f9-Xl=WR^RMQ8XoZB2&pu*K0zW02{+nHf^QqDlGy4@5*~1)
z+%A}JERlwUE1C91yI^vntweQ2hcV7p^YDNxhfD1Ozv|nN!q1$>7sN=~CVA^EVN5$Y
z_=^~ixRXQ2nggF7opnW@0uLBd94}N=n*HTM30FFO2cWv9OK(T3nqbXbdyLk1{&Y1T
z^LVLH!jAU%dF`v>ul?EYURzbv?R#Jk=4_sKn$3!?SToo7W!fj}SLpNF3MGta8wWQ=
z64drpSF`HnY&9zn7*ULkRaIuPwF@QuXOErl4OFo&bi{vHGuN88&T7>x-!xKU`j>E@
zy$skm!kzy6I&1wNaGw|-tg6h6ltL2bV<Q4<|7U&ssk(mQuG|v_oHq#HfenF<H;?=7
z8u>dgteI>5%b1VP*9}RS?@;4E){*Y9W`_hn^M&-;UJ~wOtz6VUJ3?(=bp_M@&hUG{
zeX{m%j1-OaYC;kYWJpCBFzaw9gA<*}zyl5><7NKMnC|<S*7B7wpuGebH@cI+0A~{L
zfB{Xj-r}iPU0Uk}NdHd-K*onf0uL4$YZi+(z)L`NMeCCsNdRl+ng?VOAbo&Y0s<5E
zBmw3fQX5c}z$wlo-~kg_^LvO5MC)RiHc%umVNtIAx;4BHth%~?$36KwH_ywqb{W>p
zwFSt0VDrjlMFI!fqYoHgd!X7^Mc?ko55$_eMn6;=2U|E$HVQ5hc(BO8DzJcMMvUs0
zEuw2*A2niGRvYku2dy*ywKhP#0Q}y$G3}Mkf9wIbvC=EmzAElrO}&2Jnsq&Yt!5eZ
ztIdCuwf(8_glTq!KQ}{uhYNp)!><^b$<GCT8Y`t4F5G8~=&bh)`7!*A;RL(4%=uUS
ziqi^*-|#V$pBjGayK(}5Y}=eUu@re*;LpvFUv~6-&!>uhr9<>)@>4@^wSIy=80PS2
zXfGRn>#CKi_?J4gelzW<;XlX1{bu9Wg+M$&KPFhPg&mj_SiDzk1N=-G)$h3F?)aPk
zsw=vEk8a1jpXe)V<s)IOW^Oq!GgD?lEB1UXu~fQU8vv2k?-$w69yyB&Q}$Oye!$_k
z``ojiX|@DqKhp<0_1@1fvY#z}V>K^#_@fTL+UTDBq+e~E%8-l9$Ml=c=2gGcS?BOe
zo$i@0WAi4(2d3&aFLItea(0C3Tow5ehu>&*&w19km&xRr<}ty-%66=06E)9{Q2eT2
zC|>3aKbQKU#`)Gh&xD`p-<0;j*q)&j@Q3)AuPXli4!=q5p7S!_q@Gs1C{D8-{H8>Y
z!-e?w4iUR&xeVeNCd4AUvB-_6W9IKt8(*fFxBjg|#O~S6^sV)F0-1U-rlbz0<wK46
z4-PTA=d}#x>ZW)-y6+UTDWM}fX5MpC)pO3$)Z~lb&HC+OteIQSt-t2K>Uk{fwC@Uv
z{u+x)i+0UC8EV(d747;PXFA53xy3ucz&klHFOgiB&@qcXnmuNA#2x17s56qC?`7Aq
zd-fuksYJ)s?X44H?X#27RK1Q{<S_flJa5}86m^|5q-J37wr=10Zd_%tGhws#hM!B^
zQ0u2N*?A?&L~A;lNS7s3b#xZ5KPY-=w#Y*~d#fTp+aYpKnQVSrG!@gC%#^Odn9LqC
z@0F@z9_kD;*350oCYfo(%4<^bXriIXKrQf@pINfVXG|WnZLd_c@!<|pyXP}9{-SL=
zx-gwgrW?Z=snMP*Phhnkkn=XKiu_!M$lbGArne4bE}qd_=Lw9~17_aFRWXlrh}peY
zma*}&RJ<-7Pa2vQ*vxPDcFCHPaHFD)=Ps%4ef#RHJdVjCZd<lB)1HjCN-@A%mky_J
znxP(NH6>=~>}D$iYo@uX4CZ}aP&w?=eZE(B_k~dh`V6*-uyKhQZu>IUftNHzTlKM*
zDIJ3$XJbl{;h4Wp8E%!L_LB~gyJxsergdeqtu;nrQ+_igVr0k7du^(?cl{$hs^-ov
z-=ljmrrNmjQ#*~j=Qrz$agnBIyS`$aDFx$j;U07F(t)1@x_uk|g<e~~lDF+}yXQC=
z?jZG6^F@|py_RU_yuMc}+Idd%pMQN0vfRddddBUZ<p^%`do)eq6t^kag6Z2HH;XgT
z_N|J0|IE(|7Ov>>-F+N%yiq-Isg1s|W^UP?tbQMkR7a@qRuU<X=%_`%jg2-%ZS$ya
zQq*?s)-S@1Z+H1NOhj!TJ$9xYYWJ+hqpqA3F0Is2i$0qz>LSMSRM)Dg=U-K}bJbm4
zzRn!&J<-%1cBtKRnsv6QX5tme*|V9Qi@uvZcGd#iVb9sKu2-MU$ZL~&*0_6Kv(Aw*
zu<P@L{g{eiiJAMEe=69!B}d|BMSDN-pMSbw%hTPytv3Svv(IDyw$r?Ob|dJm>_$~j
z`*Kr~1mn0vjlMG{{_Ws*x_vJd;c7V_{H4JLJ(nb*=DiX0;YdZKYEq=Ms%H8uf_xmV
zoS~1@Oeqo!J!3Rc_e?I-@^4YpJ&aj2{!|C(-E$pzUt~tFnSLx)U6(W>6Q(4I?D+YX
zuZn-ypbwAPxj!q{W6j+5aJu%3%fqv(W2pu4x){DAUto$bo6;n*qPN7NRMB^?{&JBM
z^zM0&jMKvr4Sl3BnP5?wLXqv*$V9Ms3+7u@Eq>1@e?Rz8R<6gIxz)G{b7itV)~vU3
zQ#u6Gvpr_MZ&$_KS-ItP2YTkxA=EgIyd$G}E}zKeewY#<7-Hs^i(2M+?KV{{@B8X&
VCy3qi8i~eG#3jk*2w5NG{{hy;m!SXv

literal 0
HcmV?d00001

diff --git a/3rdparty/dx5/lib/fastfile.lbw b/3rdparty/dx5/lib/fastfile.lbw
new file mode 100644
index 0000000000000000000000000000000000000000..467ebf88744c83c419b5422b801f4fce70108e8d
GIT binary patch
literal 6144
zcmeI0d34m(702)UWs*!nRuYGOE1*TnPXk4ks3asAKq48k8Vrt;nP2!#G8?lHw8%*v
zLT8wW&?>k9f(%8}R>ia`?Ww^ii`t6O;{p|z4jvIbg0=#l9@Fo8lOf3@c>KG^;rQYA
z-n;L<`|k4I!?Wo`IwD3rzm}iVl_hiQT$ZLf5C6|(ci9wAU4zNvZLr#uI(=b9rG8Oq
ziCkm}XsPA#vWn@`ugwZ1Q_I6M8p>SX^RMrV85K1JWNJCRrs3PMKT_ZMz&K23$UQ%H
zn0anpv&n0A+GVT5T-R)MSe(rsSv3VlLV^r0jvfjLo5``FPObBJEhhI0S^Xq17K0Zb
zd}^$2;B=)yRwo3;K;Tf;`LS0F5O8>9H4+%nqdmJ<yV-k(OOe&$z<7*3g}KA~&vkiJ
zm&x4pOIb}8=06URIP+aj7Z;J$8-<c5FRLU^R?`RHq1)=f4v&cyp5M45eg!zF-sFLq
zSz?9N>-Wc-2?@pRcDiNtS>dLgzkX*BH?6Q(Wwk-*_~T`*oGz=W!jOuM9}HrM&!b?K
zp<<Ppo9-WE6^9L>{QL(5%ua`_o)-evjr#}Du!=A7@DFHkD{$9Ev5{%jCkJtcL-95v
zA_*cT7I`<vr-a!8cgd<hFbZMk<2n7qZn41Ijbip|l_%q8W7KYw)sunIJ+pJ;X4_W4
z1!shP*TF||Ic2+3S?w}8EV4RMh}?{lh!e5fJ$HD#id|MUVv!{<F>Vn@{fuj6b-CC<
z^}rptU1nJ=5kBOjaW#Wciy2$Y5s|*IVSjw2qXI5jJt9=p464H6K|cLk?12l!?Exwr
zUg73Up<~0NRbzCPxpfw0l{k8M=_{+vE|lg0p<~uSS9w&$W;404%rs%?3%`9P-cqE#
z$H~j@UqYgCVAkTCv0H4&n0&F!N2{KRH<jyfIh}}Ut%!L(EQvcrTyBpFOAR6%mDp`u
zIGi>Gl`~wd@YrRGYj&)-CWdy$Z^T*O7_IU@3wOPieSVOrIV>V=`AN!M9(NRRmwT*;
z+TDYnGZve*URF;D{apj~H}k^~nOiFa470bz8{l&^Ihs+tBZa`yfdbfr)dDx_FI#vk
zd{!j>Z=$gpxC6M+<nuaZH6%1tVu`pwI89=Or-ca>gP34bgupye8T=57t8Ke^wXA+9
zM#~3|TJ0#hQvn?u%rByh-mAh2tG0^p^8p_I*bQ}u2e*_7+3|%inh$fM`waIucI9AK
zPy@;YE-N22WQxgcR%P|vkGpJRx45i!1*T#Lcj0!P_(QjSLxaMv#-V`(NT+T28Ih)_
zthhu|Tv%C{Fu$Tgqc1J2Oe$VbURGsDG**_}Qt5jzg{-4AM9C6+J&=gUKpES!C7BY7
z%9d1AzKhX){H38yVEeXcDM|EB-yQ2tNnnq0VIyDQRIE2Of$iOrL>ePj9KrQZf`%a)
zcJQH8O6r!n6S_6siKP!onAbLhv>vb9YPP$KMD6L6YAi+d7dd?nFBP|qp>#c7GJ3pZ
z^j3$}NJIFr$yR8yIn6YzeJE7eT>6EiHCmeW3yUzRx$PRtFhbf=u6Ue2w^=Eqbj&hc
zYKx}1DK<>Y+fyjX=$el!nZ9Yuq%>oZTQPaDq78FTiBXj|=-XY-Mqgh3mo)wk&1vqL
zO%+S4gPp;5^16ao@b+gM!LtWH(ij>GL}NGaY3;~d_bL8vOs#07;7r~n23tG4R~j0l
z--dqTt$~<KUdL^<w{{v-w6hu$42_I`wN&(#_9pr-bo+AhP6WqbEUGR#t&uiwFQss@
zPGXT^I!OwT)=3HBDLP3Lk#$mHq);a%h4nfqIb5!jwBcKHQc7gGPD%|oa=G<7X-Fib
zlhPvFfbcH#)wSs;r;m$nHo07Q?-bII_AIzoc&ew5Mz>`n7-&^nmFBVr;Y98Iop`@q
z$IYbqlm_Z42V6j-z)~6y-b~ZMDw+!#XdYNYOTbz(fpugBmy-irL0+(t?gj1i0O+8d
zpp*81E9nW)O&y?@UIu-16l|t9z}55#cqj3={EE(ichfo0PZz*-#PG^qPouy9jR)_g
zN#K1n1svHvI+}DPJn1w>m%fBjj5fZ*5{HF+Z8?->ta8}<ZGFP7{lxwN-HrT@)JXjz
z?i(T^8Vj3{(Oh0)7xYkQIPx$W^Ti_1g6|>oSZ8!llOXz@hrPs8XlZ$MO_l!!K9Mq8
zSAjhZZ&nEZu0WO^^(HM9R)mC9YqvLj@Ajn>PSr{2kxZSG5gyLd;ukt8Gm^)%WG<SK
z5`0ArIw>nst&_4N^&Ci_p^>#nIG#Qkk^8vt4xN+}38T5PZ89%2o71B##LEe#CF<T}
z)4LUgv_($4%j8y!v}4zwh}FXUnjY7P{e(oJwRU+k%A?&!gTnfdD67_Qy&2VcUy707
zG`_364lykb%Z;}!tL+SRRB*5OzsQaGW!;0^5h&Nq_`78`Wv&b0<DNB>G{HkJWaG1D
zLsB65dh%v%&@=xbDX@U~4@=jR?=z!{QM#vilIGd%3n(n<q})gf-#i?b79PQy6L=|I
zg}MvR&`DQB=I{zEKm|r!coTPF8TX#Tu~#SQZWPtBm9B#m9-u|wLsSMnOx!Ko$O!JB
z2JjJbfjemx_$aLfcT)fiQxN<;Z2|YvcJMKJ6x>I9!6)cRa6h$!&(UAOztB<eZ*&~&
zpp)Q1>IPq;Q4*nsCWEig4Db*YfQLyB9-+nHQ8Iw9QZ@KGEd#r#9vsEb`FfAI{fu-q
zF9R*QL*lTChBF$kgE$Y1qTP8NttVE^ipDgrE8552^5>Ip<lzL^Lm?I{(u4}Lr?TMU
zv|y1o_}-b+0{=@{bI!Wo%<J&KoXZ1zYv(-$R1U4lp)CJ*%&W=kSk`%%$BBZ+mLdF0
zYcQDTpUu39c^$^u&ejumML$9d)7V@2wb^T<&7$q&D1wk?MYM=bI9(?Viy)*)k;xp>
z5Xd)0sNN<Ec6NeX;0Lr4{E*gwA5#nX39Sbs6addq8~7z{1izxK;5pg`enUIK|Ii-r
zJUs<|NA2K6IspEc{sBttZBWDB0h8Frpq70Krn1k$H1-vk!7hT??0ax1OG+ThWf|Zo
zmJ5zyBf)WOA~=Cv4Nhb-cxu-HVtl!t;D~b|RG?YF-V2Ivb_`yEQ-$M_Lt6jEfvzh^
zW5@FiG1o=Uk|}Qlk3==}%*R<2d?n`m<h%|Pq;P-iGvv~Qpy*`2D|_vwK2hSq_d_L`
z;JfTlP4LLU)6&;_HXLdBIN|HCF}o*7sXRzhB$uO<1Lu+y*@`phG|xR1`wUfS*l}?(
z2CFn;Y2-q6@cmwcx`M}GQ0SJl)}y}M)~+>)`3CKpWZd(-J0a&xiT|SHn-o6~x;1;s
zTfyT&gXREFQXvc%`LaR_HK7^o)j3~7QAPG8Mg0VOa#f^b^7GyJAw>;or+1|j%f%xN
zahNJC>m0xNMPxwlG0C&}(nD#H!|FBiYqhsayq);n)!S9(QXEEJ^pp{MVTt3|$n&;W
zj6cSVJWVMxCRXLZ+pEdQ^RHK~TrpXUJgs`WDio#3xTarMCI0niB<zEpzW+Hq0w%MW
z7{7|m2dA(_;MF2FQ<)v#)0hvO$+(U=tOd+xLGT8)3A~a04xGoff`x1+Sj6^%#cUr~
z!kz{fuou8ZtOLA>y$vpA?}Mf6pWqU98mwez!7BC*Si>%Ww=r(w?Tmr-EETk{Y_Nfi
z0OvoqmRMr%dlQ@KbMZrfdfud3{wd`66F~%|&*L_WkM_JebEDtl<usgs_kTr==3U~2
zF`j>Q2Zm6~BX*NloiTfsds83<EyeCbW5ou<gg=M+{LcNI$M~n;|B(l-q6OpVc5H~h
znrQ@H$7Mvb_&5JugEY3L#QwMM1lIeSLLyu`Bt#{$-nJ;#K5bFYecIw2=+hR*N1wJh
ZVfwViA;jX(7FZB}jQo_H(Xjnk{tv+DXC(jt

literal 0
HcmV?d00001

diff --git a/3rdparty/dx5/lib/fastfile.lib b/3rdparty/dx5/lib/fastfile.lib
new file mode 100644
index 0000000000000000000000000000000000000000..8587c24d2f1530472aae3ba60793a615ed05fe68
GIT binary patch
literal 5270
zcmd5=Z){sv6~E8VvmMuI>@{t(tpmeMVav$!r;FRA8~M|OG)kz~v?)tyTqk*H9UR9>
zp2?7!ZPc-lxdicN5+BBwX=4(6VB*^*B;?4WZB}(s`=J_|kjjJvQ$cL4w5|I<_?>&-
z-#S*uH%@f#JNMjkf9KqD&pm#5UpkmtoIdkZ@Uf_y_IJkP2in`?2i)Rlt1)id-)?ZH
zf{ZaV<@)Do$-ag8TxwBc$$`|8K9J66eVK(N$8aE>P1}=)vuWKP4KGZ8*B%|oX<2)8
zR7=g+qft$BXdcrt8GG({HbXf7^N!=@-cJP;Z23Am+PbpE-~Z1pXA$LDM7d>QYL0eX
z>s;GfTRS^DqtSiw4r80Ag2T!#_RIX69pP<^jbNulEi;SSwEjI!ju_huW>qyu#xodZ
zExPus?hxMx{<qMp7`ha}XgG1IWk#FIpN<Wfs$npfq4O7q-e5S~dnaBL0Dp&${~o!L
z@CDw~(vpcq&zN&y@Gr2|@>X^gA7c?TBJyu5yDvii0CZkA^dcD7+Q&0~#?oj+wea4?
z+!A!23<xzwu(j~M51o>sR}1e8SpN${M<Uk7`#tp5?}A6?ehE5FbrQ{kM=k#zh0Z}k
zua<uYv3>wL=Nx*q@O})PUpe%)I*-%9dks4EbQM8lw-(-R=zP_ow-w$R*0&itghx~h
z?~l-X=Pr139`AlmypN&h!(AgX<M;I$Z8nw9=$Z7?6T^pl`=U<4k>Nw%>KW-Djq*dW
zK%wkSn9qL@MB%MKh0>EUu#p6eE(sAGA`vB<pItDn5M!fbVj<UKVSax7x;HV`y}6SV
zU!ks8&fn8fo}8%61xt^Ufb_=Zm{cj2^@kGXAmLtiR=~=&><m_h=hQhirx5$Xm`hh*
zDSW!AKZ{xV^USe3pn^^);g(SJ)>h*Ip@#7AE9>ujOZDWsdS!A#i1{JUzXkIKMZ99i
z!nQ-vqGR+iTKW)LBl{xy2Zf9Z%pSo}Odb$iFZ%lhcLY5}-N(kzHwkV6{SLv+pqF^(
z!0i^YAEIv%+{@^93GOxYbPhiDI(oU{50>mAI67Y+yNq5UUjrxg-nV2Qg1Z;Z$8Mvi
z%<wS}c1<PM$F_r$c6Wo5Ycav17!i3`hyuYvXnr>KGV#T7Lva;PW1v6AMR1E7dgy6+
zs^-kj1Q#i@dCiXS4WE>mI`s+XtSOBcCu^_kD8E9+@8~8g<eoey+J}r6#a>2)&S@{2
zk3DS7?gRG~A)~S+R}5OR5pXgh;}$m!PM&ra9AWyHZpoepCo_PeBJGyI$*BJXoQygc
z_9AtHd<s1%;(k{6XCo&+Sn=vlN5@X&>pIHG$%(>SjTL@27AtNxtiFWFANg0y4XZx`
z_vR+3xqS0?pIm9a&DYmI@bFL8&c?#Ge$6kQA)LZr)w#&6SLMO19f~zReKa9b8<_mV
z;>Y@zJFfC4Nwe!SeV0_@>%6J>o*pTb!@XUfE#I_!!1Y=42KjbA7D+Z=xgd&EY0z6r
z1WLJ(bkowMq9S)oaimJ)V-!aji&=1wqBXK*^fG2Y04HM$hP{nO7z%4pY21wFXDD!9
zRGJ+;P`It+Ll<a<$*bE@uF!xofJg)t&o(ryI~Mbfjuo%!PjOG-Qzah<P-C&YA`2QH
z3Q;Xn&+}&@UGG{#ugF35olQ|7)pe9UQN!YZl!yBba5Ck<Sno(G3y7=I37O?`n{@dR
zJ{$`bH&#@*%M&3g*y=hTigaBRBC(ZCaf@K9LJ4Z)Q<4&ic;MNEW^e7pas8Ow+z8La
z_7wlM;_oP*MD|qpkeBy{*7iKibCIrFwpiRq<W-aU5x<PoLDF14iG;cJs&FGYSsM4!
zmIVkIlbZ&^=x3KmWx+;zcB2`t97mL&la4IIEcV-2+{oXLXSld=ww{j%y8ir}k2k58
zZuA0sqEfi+$v<dJhvjq~?~XLD^NTm4hK7>gOB#IKt6t(?>-ymNd-=B`z}Y4|JvmVt
z@{*&%Tcabl)~EyFL@4iAKN{Q|MiOo4VXjar)bSoKKOAaSDsRwb+A@iT#JU!GktP_>
ze>M>WrKRON)(iHukUQUxDFs!9ijJF{@3NFAszPPTOjyZT|3P5J!=lDdw$}n8iSr$n
zaza(8l$$snaebV&Xtk<Dp+NQ|ncCZpu~*n?alA!S@~aA!x@w~9N;ZX#n0^F3{mj`C
zN*p3v@=c8BXT+AAz=*uFB^pMO%)PH*NV#U~{M^uB!e<)L&!Z%B)t^j(rSo2u<fAG{
z9l}C;vu)i6Nz^6T3yCDt))SBfEFI_RQ2BG8j#pqiPscBG=x2e-rX<tEu)+A5X=~h^
zvLy3Wl5;MJ(;xEE?T^38AA0dt6)MBzy(AOxC4;GB<WF*HNu#d_Qimi?TS183w(6>E
z(MzwYn5Elo>o<n2ZNiolnR3XDysZkEN~x;QPmn0d0@?tSzZ;O$S0U4Fa3j}OA=9gY
zs!&Zf@oetAA!?{XrrY91Zm2@0^H&urvDL`e3{j*CnF^d6IZ}m81zc6ks)zx|wDC8C
z*-?c|x6X~cqY9Z`T56r(O#^vn6*9fvx{-GZWIC*5a!FrIPtWJ<FE{dQ&>8w_6dP@C
z-PgIFB{MYY&&~)z{Bf4d4fIRCl_h7E2m1T6x*WG-t~a$Lm&V&*AU&T;CPz}av9z{)
zWR`%s+p$U*fH;@Vo|bkFn96;NT1wYQ)0pq+Zr@iu2`OBY`1H~0sJ66_U!2yuE#2XT
z)Qlyybn)@alJ<1B!DH-T(Aoi3XL19BayuOk1F1|;1|PM$0Yv8d7V^fXJL7ir<d-$e
ysZ?fQQFC}CzQYZsvNMQ+<>vA1yemAIFu&WmKfm4a6_32IRgEuh*3!FvtNSlM?t|d~

literal 0
HcmV?d00001

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3d1d0a1e..3645e122 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,6 +4,7 @@ project(isle CXX)
 
 option(ISLE_BUILD_APP "Build ISLE.EXE application" ON)
 option(ISLE_USE_SMARTHEAP "Build with SmartHeap" ${MSVC})
+option(ISLE_USE_DX5 "Build with internal DirectX 5 SDK" ON)
 
 add_library(lego1 SHARED
   LEGO1/act1state.cpp
@@ -195,6 +196,12 @@ if (ISLE_USE_SMARTHEAP)
   target_link_libraries(lego1 PRIVATE SmartHeap::SmartHeap)
 endif()
 
+# Use internal DirectX 5 if required
+if (ISLE_USE_DX5)
+  target_include_directories(lego1 PRIVATE "${CMAKE_SOURCE_DIR}/3rdparty/dx5/inc")
+  target_link_directories(lego1 PRIVATE "${CMAKE_SOURCE_DIR}/3rdparty/dx5/lib")
+endif()
+
 # Link libraries
 target_link_libraries(lego1 PRIVATE ddraw dsound winmm)
 
@@ -212,6 +219,12 @@ if (ISLE_BUILD_APP)
   # Include LEGO1 headers in ISLE
   target_include_directories(isle PRIVATE "${CMAKE_SOURCE_DIR}/LEGO1")
 
+  # Use internal DirectX 5 if required
+  if (ISLE_USE_DX5)
+    target_include_directories(isle PRIVATE "${CMAKE_SOURCE_DIR}/3rdparty/dx5/inc")
+    target_link_directories(isle PRIVATE "${CMAKE_SOURCE_DIR}/3rdparty/dx5/lib")
+  endif()
+
   if (ISLE_USE_SMARTHEAP)
     target_link_libraries(isle PRIVATE SmartHeap::SmartHeap)
   endif()
diff --git a/README.md b/README.md
index 2be5373a..d2aa8de7 100644
--- a/README.md
+++ b/README.md
@@ -24,10 +24,9 @@ These instructions will outline how to compile this repository into an accurate
 You will need the following software installed:
 
 - Microsoft Visual C++ 4.2. This can be found on many abandonware sites, but the installer can be a little iffy on modern versions of Windows. For convenience, I made a [portable version](https://github.com/itsmattkc/msvc420) that can be downloaded and used quickly instead.
-- DirectX 5 SDK. Similarly, this can be found on many abandonware sites.
 - [CMake](https://cmake.org/). A copy is often included with the "Desktop development with C++" workload in newer versions of Visual Studio, however it can also be installed as a standalone app.
 
-#### Compiling From Command Line
+#### Compiling
 
 1. Open a Command Prompt (`cmd`).
 1. From Visual C++ 4.2, run `BIN/VCVARS32.BAT x86` to populate the path and other environment variables for compiling with MSVC.
@@ -37,6 +36,7 @@ You will need the following software installed:
 ```
 cmake <path-to-source> -G "NMake Makefiles" -DCMAKE_BUILD_TYPE=RelWithDebInfo
 ```
+  - **Visual C++ 4.2 has issues with paths containing spaces**. If you get configure or build errors, make sure neither CMake, the repository, nor Visual C++ 4.2 is in a path that contains spaces.
   - Replace `<path-to-source>` with the source repository. Can be `..` if your build folder is inside the source repository.
   - `RelWithDebInfo` is recommended because it will produce debug symbols useful for further decompilation work. However, you can change this to `Release` if you don't need them. `Debug` builds are not recommended because they are unlikely to be compatible with the retail `LEGO1.DLL`, which is currently the only way to really use this decomp.
   - `NMake Makefiles` is most recommended because it will be immediately compatible with Visual C++ 4.2. For faster builds, you can use `Ninja` (if you have it installed), however due to limitations in Visual C++ 4.2, you can only build `Release` builds this way (debug symbols cannot be generated with `Ninja`).
diff --git a/dx5sdk/cdrom/setup.iss b/dx5sdk/cdrom/setup.iss
deleted file mode 100644
index 65d3f56f..00000000
--- a/dx5sdk/cdrom/setup.iss
+++ /dev/null
@@ -1,34 +0,0 @@
-[InstallShield Silent]
-Version=v5.00.000
-File=Response File
-[DlgOrder]
-Dlg0=SdWelcome-0
-Count=7
-Dlg1=SdLicense-0
-Dlg2=SdSetupTypeEx-0
-Dlg3=SdAskDestPath-0
-Dlg4=SdSelectFolder-0
-Dlg5=SdStartCopy-0
-Dlg6=SdFinish-0
-[SdWelcome-0]
-Result=1
-[SdLicense-0]
-Result=1
-[SdSetupTypeEx-0]
-Result=Compact
-[SdAskDestPath-0]
-szDir=C:\dxsdk
-Result=1
-[SdSelectFolder-0]
-szFolder=Microsoft DirectX 5 SDK
-Result=1
-[SdStartCopy-0]
-Result=1
-[Application]
-Name=the Microsoft DirectX 5 SDK
-Version=5
-Company=Microsoft
-[SdFinish-0]
-Result=1
-bOpt1=0
-bOpt2=0

From d41b7f2ca45f4da27b0dafd0ad0735a7a579e1a1 Mon Sep 17 00:00:00 2001
From: Christian Semmler <mail@csemmler.com>
Date: Sun, 6 Aug 2023 16:26:14 -0400
Subject: [PATCH 17/21] Add GetDeviceModeFinder to WndProc (#102)

---
 ISLE/isleapp.cpp         |  2 +-
 LEGO1/legovideomanager.h | 13 +++++++++----
 LEGO1/mxdirect3d.h       | 25 +++++++++++++++++++++++++
 LEGO1/mxdirectdraw.cpp   | 12 ++++++------
 LEGO1/mxdirectdraw.h     |  4 ++--
 5 files changed, 43 insertions(+), 13 deletions(-)

diff --git a/ISLE/isleapp.cpp b/ISLE/isleapp.cpp
index 8d175dfa..93500783 100644
--- a/ISLE/isleapp.cpp
+++ b/ISLE/isleapp.cpp
@@ -357,7 +357,7 @@ LRESULT WINAPI WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
     }
     return DefWindowProcA(hWnd, uMsg, wParam, lParam);
   case WM_DISPLAYCHANGE:
-    if (g_isle && VideoManager() && g_isle->m_fullScreen && VideoManager()->m_unk74 && VideoManager()->m_unk74[0x220]) {
+    if (g_isle && VideoManager() && g_isle->m_fullScreen && VideoManager()->GetDirect3D() && VideoManager()->GetDirect3D()->GetDeviceModeFinder()) {
       int targetWidth = LOWORD(lParam);
       int targetHeight = HIWORD(lParam);
       int targetDepth = wParam;
diff --git a/LEGO1/legovideomanager.h b/LEGO1/legovideomanager.h
index 379ec468..60f670fb 100644
--- a/LEGO1/legovideomanager.h
+++ b/LEGO1/legovideomanager.h
@@ -2,7 +2,9 @@
 #define LEGOVIDEOMANAGER_H
 
 #include "mxvideomanager.h"
+#include "mxdirect3d.h"
 #include "lego3dmanager.h"
+#include "decomp.h"
 
 // VTABLE 0x100d9c88
 // SIZE 0x590
@@ -18,13 +20,16 @@ class LegoVideoManager : public MxVideoManager
   __declspec(dllexport) void MoveCursor(int x, int y);
 
   inline Lego3DManager *Get3DManager() { return this->m_3dManager; }
+  inline MxDirect3D *GetDirect3D() { return this->m_direct3d; }
+
   void SetSkyColor(float r, float g, float b);
 
-  int m_unk64;
+private:
+  undefined4 m_unk64;
   Lego3DManager *m_3dManager;
-  int m_unk6c;
-  int m_unk70;
-  int *m_unk74;
+  undefined4 m_unk6c;
+  undefined4 m_unk70;
+  MxDirect3D *m_direct3d;
 };
 
 #endif // LEGOVIDEOMANAGER_H
diff --git a/LEGO1/mxdirect3d.h b/LEGO1/mxdirect3d.h
index e69de29b..ecc1f0aa 100644
--- a/LEGO1/mxdirect3d.h
+++ b/LEGO1/mxdirect3d.h
@@ -0,0 +1,25 @@
+#ifndef MXDIRECT3D_H
+#define MXDIRECT3D_H
+
+#include "mxdirectdraw.h"
+#include "decomp.h"
+
+#include <d3d.h>
+
+class MxDeviceModeFinder;
+
+// SIZE 0x894
+class MxDirect3D : public MxDirectDraw
+{
+public:
+  inline MxDeviceModeFinder *GetDeviceModeFinder() { return this->m_pDeviceModeFinder; };
+
+private:
+  MxDeviceModeFinder *m_pDeviceModeFinder;
+  IDirect3D *m_pDirect3d;
+  IDirect3DDevice *m_pDirect3dDevice;
+  undefined4 m_unk88c;
+  undefined4 m_unk890;
+};
+
+#endif // MXDIRECT3D_H
\ No newline at end of file
diff --git a/LEGO1/mxdirectdraw.cpp b/LEGO1/mxdirectdraw.cpp
index dbe07d12..625a6fae 100644
--- a/LEGO1/mxdirectdraw.cpp
+++ b/LEGO1/mxdirectdraw.cpp
@@ -2,6 +2,7 @@
 #include "mxdirectdraw.h"
 #include "decomp.h"
 
+DECOMP_SIZE_ASSERT(MxDirectDraw, 0x880);
 
 #ifndef DDSCAPS_3DDEVICE
 #define DDSCAPS_3DDEVICE 0x00002000l
@@ -100,7 +101,7 @@ int MxDirectDraw::GetPrimaryBitDepth()
     dwRGBBitCount = ddsd.ddpfPixelFormat.dwRGBBitCount;
     g_is_PALETTEINDEXED8 = (ddsd.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) != 0;
     pDDraw->Release();
-}
+  }
 
   return dwRGBBitCount;
 }
@@ -738,7 +739,7 @@ BOOL MxDirectDraw::DDSetMode(int width, int height, int bpp)
 
     EnableResizing(m_hWndMain, FALSE);
 
-	if (!m_bIsOnPrimaryDevice)
+	  if (!m_bIsOnPrimaryDevice)
     {
       lpDD = NULL;
       result = DirectDrawCreate(0, &lpDD, 0);
@@ -1096,7 +1097,7 @@ BOOL MxDirectDraw::SetPaletteEntries(
   
   if (m_pPalette != NULL)
   {
-	HRESULT result;
+	  HRESULT result;
     result = m_pPalette->SetEntries(0, 0, _countof(m_paletteEntries), m_paletteEntries);
     if (result != DD_OK)
     {
@@ -1194,13 +1195,12 @@ void MxDirectDraw::FUN_1009E020()
     line = (byte*)ddsd.lpSurface;
     for (j = ddsd.dwHeight; j-- ;)
     {
-	  memset(line, 0, ddsd.dwWidth);
-	  line += ddsd.lPitch;
+      memset(line, 0, ddsd.dwWidth);
+      line += ddsd.lPitch;
     }
 
     m_pBackBuffer->Unlock(ddsd.lpSurface);
 
-
     if (m_bFlipSurfaces)
     {
       m_pFrontBuffer->Flip(NULL, DDFLIP_WAIT);
diff --git a/LEGO1/mxdirectdraw.h b/LEGO1/mxdirectdraw.h
index 2024a3ac..3e2c710a 100644
--- a/LEGO1/mxdirectdraw.h
+++ b/LEGO1/mxdirectdraw.h
@@ -3,11 +3,11 @@
 #define MXDIRECTDRAW_H
 
 #include <ddraw.h>
-#include <Windows.h>
+#include <windows.h>
 
 extern BOOL g_is_PALETTEINDEXED8;
 
-//size 0x880
+// SIZE 0x880
 class MxDirectDraw
 {
 public:

From bd9dca0d3fef2fe1662f169cff10a0b6e64de10a Mon Sep 17 00:00:00 2001
From: Christian Semmler <mail@csemmler.com>
Date: Tue, 8 Aug 2023 22:38:07 -0400
Subject: [PATCH 18/21] Implement most of MxDSAction (#103)

* Implement most of MxDSAction

* Update mxdsaction.h

* Update mxdsobject.cpp
---
 ISLE/isleapp.cpp     |   6 +-
 LEGO1/mxdsaction.cpp | 181 +++++++++++++++++++++++++++++++++++++++++++
 LEGO1/mxdsaction.h   |  25 +++++-
 LEGO1/mxdsobject.cpp |  32 ++++----
 LEGO1/mxdsobject.h   |  23 +++---
 LEGO1/mxvector.h     |   2 +
 6 files changed, 234 insertions(+), 35 deletions(-)

diff --git a/ISLE/isleapp.cpp b/ISLE/isleapp.cpp
index 93500783..198389a3 100644
--- a/ISLE/isleapp.cpp
+++ b/ISLE/isleapp.cpp
@@ -90,7 +90,7 @@ void IsleApp::Close()
 
     VideoManager()->Get3DManager()->GetLego3DView()->GetViewManager()->RemoveAll(NULL);
 
-    Lego()->RemoveWorld(ds.GetAtomId(), ds.GetUnknown1c());
+    Lego()->RemoveWorld(ds.GetAtomId(), ds.GetObjectId());
     Lego()->vtable24(ds);
     TransitionManager()->SetWaitIndicator(NULL);
     Lego()->vtable3c();
@@ -729,7 +729,7 @@ inline void IsleApp::Tick(BOOL sleepIfNotNextFrame)
 
       ds.SetAtomId(stream->atom);
       ds.SetUnknown24(-1);
-      ds.SetUnknown1c(0);
+      ds.SetObjectId(0);
       VideoManager()->EnableFullScreenMovie(TRUE, TRUE);
 
       if (Start(&ds) != SUCCESS) {
@@ -738,7 +738,7 @@ inline void IsleApp::Tick(BOOL sleepIfNotNextFrame)
     } else {
       ds.SetAtomId(stream->atom);
       ds.SetUnknown24(-1);
-      ds.SetUnknown1c(0);
+      ds.SetObjectId(0);
       if (Start(&ds) != SUCCESS) {
         return;
       }
diff --git a/LEGO1/mxdsaction.cpp b/LEGO1/mxdsaction.cpp
index d6e1fdb5..7b977d1f 100644
--- a/LEGO1/mxdsaction.cpp
+++ b/LEGO1/mxdsaction.cpp
@@ -41,3 +41,184 @@ MxDSAction::~MxDSAction()
 {
   delete this->m_unk7c;
 }
+
+// OFFSET: LEGO1 0x100adaf0
+void MxDSAction::CopyFrom(MxDSAction &p_dsAction)
+{
+  this->SetObjectId(p_dsAction.GetObjectId());
+  this->m_flags = p_dsAction.m_flags;
+  this->m_startTime = p_dsAction.m_startTime;
+  this->m_duration = p_dsAction.m_duration;
+  this->m_loopCount = p_dsAction.m_loopCount;
+
+  // TODO
+  // this->m_location.SetVector(p_dsAction.m_location.GetData());
+  // this->m_direction.SetVector(p_dsAction.m_direction.GetData());
+  // this->m_up.SetVector(p_dsAction.m_up.GetData());
+
+  FUN_100ADE60(p_dsAction.m_unk80, p_dsAction.m_unk7c);
+  this->m_unk84 = p_dsAction.m_unk84;
+  this->m_unk88 = p_dsAction.m_unk88;
+  this->m_omni = p_dsAction.m_omni;
+  this->m_someTimingField = p_dsAction.m_someTimingField;
+}
+
+// OFFSET: LEGO1 0x100adc10
+MxDSAction &MxDSAction::operator=(MxDSAction &p_dsAction)
+{
+  if (this == &p_dsAction)
+    return *this;
+
+  MxDSObject::operator=(p_dsAction);
+  this->CopyFrom(p_dsAction);
+  return *this;
+}
+
+// OFFSET: LEGO1 0x100adbe0
+MxU32 MxDSAction::GetSizeOnDisk()
+{
+  MxU32 totalSizeOnDisk;
+
+  totalSizeOnDisk = MxDSObject::GetSizeOnDisk() + 90 + this->m_unk80;
+  this->m_sizeOnDisk = totalSizeOnDisk - MxDSObject::GetSizeOnDisk();
+
+  return totalSizeOnDisk;
+}
+
+// OFFSET: LEGO1 0x100adf70
+void MxDSAction::Deserialize(char **p_source, MxS16 p_unk24)
+{
+  MxDSObject::Deserialize(p_source, p_unk24);
+
+  this->m_flags = *(DWORD*) *p_source;
+  *p_source += sizeof(DWORD);
+  this->m_startTime = *(DWORD*) *p_source;
+  *p_source += sizeof(DWORD);
+  this->m_duration = *(MxLong*) *p_source;
+  *p_source += sizeof(MxLong);
+  this->m_loopCount = *(MxS32*) *p_source;
+  *p_source += sizeof(MxS32);
+  this->m_location[0] = *(double*) *p_source;
+  *p_source += sizeof(double);
+  this->m_location[1] = *(double*) *p_source;
+  *p_source += sizeof(double);
+  this->m_location[2] = *(double*) *p_source;
+  *p_source += sizeof(double);
+  this->m_direction[0] = *(double*) *p_source;
+  *p_source += sizeof(double);
+  this->m_direction[1] = *(double*) *p_source;
+  *p_source += sizeof(double);
+  this->m_direction[2] = *(double*) *p_source;
+  *p_source += sizeof(double);
+  this->m_up[0] = *(double*) *p_source;
+  *p_source += sizeof(double);
+  this->m_up[1] = *(double*) *p_source;
+  *p_source += sizeof(double);
+  this->m_up[2] = *(double*) *p_source;
+  *p_source += sizeof(double);
+
+  MxU16 extralen = *(MxU16*) *p_source;
+  *p_source += sizeof(MxU16);
+  if (extralen) {
+    FUN_100ADE60(extralen, *p_source);
+    *p_source += extralen;
+  }
+}
+
+// OFFSET: LEGO1 0x100ad940
+MxLong MxDSAction::GetDuration()
+{
+  return this->m_duration;
+}
+
+// OFFSET: LEGO1 0x100ad950
+void MxDSAction::SetDuration(MxLong p_duration)
+{
+  this->m_duration = p_duration;
+}
+
+// OFFSET: LEGO1 0x100adc40
+MxDSAction *MxDSAction::Clone()
+{
+  MxDSAction *clone = new MxDSAction();
+
+  if (clone)
+    *clone = *this;
+
+  return clone;
+}
+
+// OFFSET: LEGO1 0x100add00
+void MxDSAction::MergeFrom(MxDSAction &p_dsAction)
+{
+  if (p_dsAction.m_startTime != INT_MIN)
+    this->m_startTime = p_dsAction.m_startTime;
+
+  if (p_dsAction.GetDuration() != INT_MIN)
+    this->m_duration = p_dsAction.GetDuration();
+
+  if (p_dsAction.m_loopCount != -1)
+    this->m_loopCount = p_dsAction.m_loopCount;
+
+  if (p_dsAction.m_location[0] != FLT_MAX)
+    this->m_location[0] = p_dsAction.m_location[0];
+  if (p_dsAction.m_location[1] != FLT_MAX)
+    this->m_location[1] = p_dsAction.m_location[1];
+  if (p_dsAction.m_location[2] != FLT_MAX)
+    this->m_location[2] = p_dsAction.m_location[2];
+
+  if (p_dsAction.m_direction[0] != FLT_MAX)
+    this->m_direction[0] = p_dsAction.m_direction[0];
+  if (p_dsAction.m_direction[1] != FLT_MAX)
+    this->m_direction[1] = p_dsAction.m_direction[1];
+  if (p_dsAction.m_direction[2] != FLT_MAX)
+    this->m_direction[2] = p_dsAction.m_direction[2];
+
+  if (p_dsAction.m_up[0] != FLT_MAX)
+    this->m_up[0] = p_dsAction.m_up[0];
+  if (p_dsAction.m_up[1] != FLT_MAX)
+    this->m_up[1] = p_dsAction.m_up[1];
+  if (p_dsAction.m_up[2] != FLT_MAX)
+    this->m_up[2] = p_dsAction.m_up[2];
+
+  // TODO
+  if (p_dsAction.m_unk80 &&
+      p_dsAction.m_unk7c &&
+      *p_dsAction.m_unk7c &&
+      !strncmp("XXX", (const char*) p_dsAction.m_unk7c, 3))
+  {
+    delete this->m_unk7c;
+    this->m_unk80 = 0;
+    FUN_100ADE60(p_dsAction.m_unk80, p_dsAction.m_unk7c);
+  }
+}
+
+// OFFSET: LEGO1 0x100ad960
+MxBool MxDSAction::HasId(MxU32 p_objectId)
+{
+  return this->GetObjectId() == p_objectId;
+}
+
+// OFFSET: LEGO1 0x100ada40
+void MxDSAction::SetSomeTimingField(MxLong p_someTimingField)
+{
+  this->m_someTimingField = p_someTimingField;
+}
+
+// OFFSET: LEGO1 0x100ada50
+MxLong MxDSAction::GetSomeTimingField()
+{
+  return this->m_someTimingField;
+}
+
+// OFFSET: LEGO1 0x100adcd0
+MxLong MxDSAction::GetCurrentTime()
+{
+  return Timer()->GetTime() - this->m_someTimingField;
+}
+
+// OFFSET: LEGO1 0x100ade60 STUB
+void MxDSAction::FUN_100ADE60(MxU16 p_length, void *p_data)
+{
+  // TOOD
+}
\ No newline at end of file
diff --git a/LEGO1/mxdsaction.h b/LEGO1/mxdsaction.h
index 10a14365..069986bf 100644
--- a/LEGO1/mxdsaction.h
+++ b/LEGO1/mxdsaction.h
@@ -13,6 +13,9 @@ class MxDSAction : public MxDSObject
   __declspec(dllexport) MxDSAction();
   __declspec(dllexport) virtual ~MxDSAction();
 
+  void CopyFrom(MxDSAction &p_dsAction);
+  MxDSAction &operator=(MxDSAction &p_dsAction);
+
   // OFFSET: LEGO1 0x100ad980
   inline virtual const char *ClassName() const override // vtable+0x0c
   {
@@ -25,21 +28,35 @@ class MxDSAction : public MxDSObject
   {
     return !strcmp(name, MxDSAction::ClassName()) || MxDSObject::IsA(name);
   }
+
+  virtual MxU32 GetSizeOnDisk(); // vtable+18;
+  virtual void Deserialize(char **p_source, MxS16 p_unk24); // vtable+1c;
+  virtual MxLong GetDuration(); // vtable+24;
+  virtual void SetDuration(LONG p_duration); // vtable+28;
+  virtual MxDSAction *Clone(); // vtable+2c;
+  virtual void MergeFrom(MxDSAction &p_dsAction); // vtable+30;
+  virtual MxBool HasId(MxU32 p_objectId); // vtable+34;
+  virtual void SetSomeTimingField(MxLong p_someTimingField); // vtable+38;
+  virtual MxLong GetSomeTimingField(); // vtable+3c;
+  virtual MxLong GetCurrentTime(); // vtable+40;
+
+  void FUN_100ADE60(MxU16 p_length, void *p_data);
+
 private:
-  undefined4 m_unk2c;
+  MxU32 m_sizeOnDisk;
   DWORD m_flags;
   DWORD m_startTime;
-  LONG m_duration;
+  MxLong m_duration;
   MxS32 m_loopCount;
   MxVector3Data m_location;
   MxVector3Data m_direction;
   MxVector3Data m_up;
   undefined4 *m_unk7c;
-  undefined2 m_unk80;
+  MxU16 m_unk80;
   undefined4 m_unk84;
   undefined4 m_unk88;
   MxOmni* m_omni; // 0x8c
-  MxS32 m_someTimingField; // 0x90
+  MxLong m_someTimingField; // 0x90
 };
 
 #endif // MXDSACTION_H
diff --git a/LEGO1/mxdsobject.cpp b/LEGO1/mxdsobject.cpp
index 2b478b88..57663cee 100644
--- a/LEGO1/mxdsobject.cpp
+++ b/LEGO1/mxdsobject.cpp
@@ -13,7 +13,7 @@ MxDSObject::MxDSObject()
   this->m_unk14 = 0;
   this->m_objectName = NULL;
   this->m_unk24 = -1;
-  this->m_unk1c = -1;
+  this->m_objectId = -1;
   this->m_unk28 = 0;
 }
 
@@ -30,7 +30,7 @@ void MxDSObject::CopyFrom(MxDSObject &p_dsObject)
   this->SetSourceName(p_dsObject.m_sourceName);
   this->m_unk14 = p_dsObject.m_unk14;
   this->SetObjectName(p_dsObject.m_objectName);
-  this->m_unk1c = p_dsObject.m_unk1c;
+  this->m_objectId = p_dsObject.m_objectId;
   this->m_unk24 = p_dsObject.m_unk24;
   this->m_atomId = p_dsObject.m_atomId;
   this->m_unk28 = p_dsObject.m_unk28;
@@ -91,39 +91,39 @@ undefined4 MxDSObject::unk14()
 }
 
 // OFFSET: LEGO1 0x100bf9d0
-MxU32 MxDSObject::CalculateUnk08()
+MxU32 MxDSObject::GetSizeOnDisk()
 {
-  MxU32 unk08;
+  MxU32 sizeOnDisk;
 
   if (this->m_sourceName)
-    unk08 = strlen(this->m_sourceName) + 3;
+    sizeOnDisk = strlen(this->m_sourceName) + 3;
   else
-    unk08 = 3;
+    sizeOnDisk = 3;
 
-  unk08 += 4;
+  sizeOnDisk += 4;
 
   if (this->m_objectName)
-    unk08 += strlen(this->m_objectName) + 1;
+    sizeOnDisk += strlen(this->m_objectName) + 1;
   else
-    unk08++;
+    sizeOnDisk++;
 
-  unk08 += 4;
-  this->m_unk08 = unk08;
-  return unk08;
+  sizeOnDisk += 4;
+  this->m_sizeOnDisk = sizeOnDisk;
+  return sizeOnDisk;
 }
 
 // OFFSET: LEGO1 0x100bfa20
-void MxDSObject::Parse(char **p_source, MxS16 p_unk24)
+void MxDSObject::Deserialize(char **p_source, MxS16 p_unk24)
 {
   this->SetSourceName(*p_source);
   *p_source += strlen(this->m_sourceName) + 1;
   this->m_unk14 = *(undefined4*) *p_source;
-  *p_source += 4;
+  *p_source += sizeof(undefined4);
 
   this->SetObjectName(*p_source);
   *p_source += strlen(this->m_objectName) + 1;
-  this->m_unk1c = *(undefined4*) *p_source;
-  *p_source += 4;
+  this->m_objectId = *(MxU32*) *p_source;
+  *p_source += sizeof(MxU32);
 
   this->m_unk24 = p_unk24;
 }
diff --git a/LEGO1/mxdsobject.h b/LEGO1/mxdsobject.h
index a13f382f..5dfc894c 100644
--- a/LEGO1/mxdsobject.h
+++ b/LEGO1/mxdsobject.h
@@ -28,29 +28,28 @@ class MxDSObject : public MxCore
   inline virtual MxBool IsA(const char *name) const override { return !strcmp(name, MxDSObject::ClassName()) || MxCore::IsA(name); }; // vtable+10;
 
   virtual undefined4 unk14(); // vtable+14;
-  virtual MxU32 CalculateUnk08(); // vtable+18;
-  virtual void Parse(char **p_source, MxS16 p_unk24); // vtable+1c;
-
-  inline const MxAtomId& GetAtomId() { return this->m_atomId; }
-  inline undefined4 GetUnknown1c() { return this->m_unk1c; }
-
-  inline void SetUnknown1c(undefined4 p_unk1c) { this->m_unk1c = p_unk1c; }
-  inline void SetUnknown24(MxS16 p_unk24) { this->m_unk24 = p_unk24; }
-
+  virtual MxU32 GetSizeOnDisk(); // vtable+18;
+  virtual void Deserialize(char **p_source, MxS16 p_unk24); // vtable+1c;
   // OFFSET: ISLE 0x401c40
   // OFFSET: LEGO1 0x10005530
-  inline void SetAtomId(MxAtomId p_atomId) { this->m_atomId = p_atomId; }
+  inline virtual void SetAtomId(MxAtomId p_atomId) { this->m_atomId = p_atomId; } // vtable+20;
+
+  inline const MxAtomId& GetAtomId() { return this->m_atomId; }
+  inline MxU32 GetObjectId() { return this->m_objectId; }
+
+  inline void SetObjectId(MxU32 p_objectId) { this->m_objectId = p_objectId; }
+  inline void SetUnknown24(MxS16 p_unk24) { this->m_unk24 = p_unk24; }
 
 protected:
   inline void SetType(MxDSType p_type) { this->m_type = p_type; }
 
 private:
-  MxU32 m_unk08;
+  MxU32 m_sizeOnDisk;
   MxU16 m_type;
   char* m_sourceName;
   undefined4 m_unk14;
   char *m_objectName;
-  undefined4 m_unk1c;
+  MxU32 m_objectId;
   MxAtomId m_atomId;
   MxS16 m_unk24;
   undefined4 m_unk28;
diff --git a/LEGO1/mxvector.h b/LEGO1/mxvector.h
index f5b8e686..e55e8d56 100644
--- a/LEGO1/mxvector.h
+++ b/LEGO1/mxvector.h
@@ -60,6 +60,8 @@ class MxVector2
   virtual void SetVector(MxVector2 *other);
   virtual void SetVector(float *other);
 
+  inline float& operator[](size_t idx) { return m_data[idx]; }
+  inline const float operator[](size_t idx) const { return m_data[idx]; }
 protected:
   float *m_data;
 };

From 88bfb3c419b05f9386763074a072f37a856e82ae Mon Sep 17 00:00:00 2001
From: Christian Semmler <mail@csemmler.com>
Date: Wed, 9 Aug 2023 19:48:49 -0400
Subject: [PATCH 19/21] Match MxDSAction::CopyFrom (#104)

* Match MxDSAction::CopyFrom

* Fix src/dest

* Update mxvector.h

* Update mxvector.h

* Update mxvector.h

* Update mxdsaction.cpp
---
 LEGO1/mxdsaction.cpp |  9 ++++-----
 LEGO1/mxvector.h     | 41 +++++++++++++++++++++++++++++++++--------
 2 files changed, 37 insertions(+), 13 deletions(-)

diff --git a/LEGO1/mxdsaction.cpp b/LEGO1/mxdsaction.cpp
index 7b977d1f..a62ecfd3 100644
--- a/LEGO1/mxdsaction.cpp
+++ b/LEGO1/mxdsaction.cpp
@@ -51,10 +51,9 @@ void MxDSAction::CopyFrom(MxDSAction &p_dsAction)
   this->m_duration = p_dsAction.m_duration;
   this->m_loopCount = p_dsAction.m_loopCount;
 
-  // TODO
-  // this->m_location.SetVector(p_dsAction.m_location.GetData());
-  // this->m_direction.SetVector(p_dsAction.m_direction.GetData());
-  // this->m_up.SetVector(p_dsAction.m_up.GetData());
+  this->m_location.CopyFrom(p_dsAction.m_location);
+  this->m_direction.CopyFrom(p_dsAction.m_direction);
+  this->m_up.CopyFrom(p_dsAction.m_up);
 
   FUN_100ADE60(p_dsAction.m_unk80, p_dsAction.m_unk7c);
   this->m_unk84 = p_dsAction.m_unk84;
@@ -221,4 +220,4 @@ MxLong MxDSAction::GetCurrentTime()
 void MxDSAction::FUN_100ADE60(MxU16 p_length, void *p_data)
 {
   // TOOD
-}
\ No newline at end of file
+}
diff --git a/LEGO1/mxvector.h b/LEGO1/mxvector.h
index e55e8d56..ae58abd9 100644
--- a/LEGO1/mxvector.h
+++ b/LEGO1/mxvector.h
@@ -57,8 +57,8 @@ class MxVector2
   virtual void DivScalar(float *p_value);
 
   // vtable + 0x6C
-  virtual void SetVector(MxVector2 *other);
-  virtual void SetVector(float *other);
+  virtual void SetVector(MxVector2 *p_other);
+  virtual void SetVector(float *p_other);
 
   inline float& operator[](size_t idx) { return m_data[idx]; }
   inline const float operator[](size_t idx) const { return m_data[idx]; }
@@ -134,12 +134,29 @@ class MxVector4 : public MxVector3
 class MxVector3Data : public MxVector3
 {
 public:
-  inline MxVector3Data() : MxVector3(&x) {}
+  inline MxVector3Data() : MxVector3(storage) {}
   inline MxVector3Data(float p_x, float p_y, float p_z)
-    : MxVector3(&x)
+    : MxVector3(storage)
     , x(p_x), y(p_y), z(p_z)
     {}
-  float x, y, z;
+
+  union {
+    float storage[3];
+    struct {
+      float x;
+      float y;
+      float z;
+    };
+  };
+
+  void CopyFrom(MxVector3Data &p_other) {
+    EqualsImpl(p_other.m_data);
+
+    float *dest = this->storage;
+    float *src = p_other.storage;
+    for (size_t i = sizeof(storage) / sizeof(float); i > 0; --i)
+      *dest++ = *src++; 
+  }
 };
 
 // VTABLE 0x100d41e8
@@ -147,8 +164,16 @@ class MxVector3Data : public MxVector3
 class MxVector4Data : public MxVector4
 {
 public:
-  inline MxVector4Data() : MxVector4(&x) {}
-  float x, y, z, w;
+  inline MxVector4Data() : MxVector4(storage) {}
+  union {
+    float storage[4];
+    struct {
+      float x;
+      float y;
+      float z;
+      float w;
+    };
+  };
 };
 
-#endif // MXVECTOR_H
\ No newline at end of file
+#endif // MXVECTOR_H

From a02e07c4d77c5ef815b96db690e48bfcfce113b2 Mon Sep 17 00:00:00 2001
From: Christian Semmler <mail@csemmler.com>
Date: Thu, 10 Aug 2023 13:57:19 -0400
Subject: [PATCH 20/21] Implement MxDSAction::AppendData (#105)

* Implement MxDSAction::ConcatData

* use GLOBAL

* Update mxdsaction.cpp

* Update mxdsaction.h

* Move TWOCC/FOURCC to common header file

* Fix

* Fix deletes
---
 LEGO1/mxdsaction.cpp | 67 +++++++++++++++++++++++++++++++-------------
 LEGO1/mxdsaction.h   |  6 ++--
 LEGO1/mxdsfile.cpp   |  2 --
 LEGO1/mxtypes.h      |  3 ++
 4 files changed, 53 insertions(+), 25 deletions(-)

diff --git a/LEGO1/mxdsaction.cpp b/LEGO1/mxdsaction.cpp
index a62ecfd3..32bc4f0d 100644
--- a/LEGO1/mxdsaction.cpp
+++ b/LEGO1/mxdsaction.cpp
@@ -3,13 +3,18 @@
 #include <float.h>
 #include <limits.h>
 
+DECOMP_SIZE_ASSERT(MxDSAction, 0x94)
+
+// GLOBAL OFFSET: LEGO1 0x10101410
+MxU16 g_unkSep = TWOCC(',', ' ');
+
 // OFFSET: LEGO1 0x100ad810
 MxDSAction::MxDSAction()
 {
   this->m_flags = 32;
   this->m_startTime = INT_MIN;
-  this->m_unk7c = NULL;
-  this->m_unk80 = 0;
+  this->m_unkData = NULL;
+  this->m_unkLength = 0;
   this->m_duration = INT_MIN;
   this->m_loopCount = -1;
 
@@ -39,7 +44,7 @@ MxDSAction::MxDSAction()
 // OFFSET: LEGO1 0x100ada80
 MxDSAction::~MxDSAction()
 {
-  delete this->m_unk7c;
+  delete[] this->m_unkData;
 }
 
 // OFFSET: LEGO1 0x100adaf0
@@ -55,7 +60,7 @@ void MxDSAction::CopyFrom(MxDSAction &p_dsAction)
   this->m_direction.CopyFrom(p_dsAction.m_direction);
   this->m_up.CopyFrom(p_dsAction.m_up);
 
-  FUN_100ADE60(p_dsAction.m_unk80, p_dsAction.m_unk7c);
+  AppendData(p_dsAction.m_unkLength, p_dsAction.m_unkData);
   this->m_unk84 = p_dsAction.m_unk84;
   this->m_unk88 = p_dsAction.m_unk88;
   this->m_omni = p_dsAction.m_omni;
@@ -78,7 +83,7 @@ MxU32 MxDSAction::GetSizeOnDisk()
 {
   MxU32 totalSizeOnDisk;
 
-  totalSizeOnDisk = MxDSObject::GetSizeOnDisk() + 90 + this->m_unk80;
+  totalSizeOnDisk = MxDSObject::GetSizeOnDisk() + 90 + this->m_unkLength;
   this->m_sizeOnDisk = totalSizeOnDisk - MxDSObject::GetSizeOnDisk();
 
   return totalSizeOnDisk;
@@ -116,11 +121,11 @@ void MxDSAction::Deserialize(char **p_source, MxS16 p_unk24)
   this->m_up[2] = *(double*) *p_source;
   *p_source += sizeof(double);
 
-  MxU16 extralen = *(MxU16*) *p_source;
+  MxU16 unkLength = *(MxU16*) *p_source;
   *p_source += sizeof(MxU16);
-  if (extralen) {
-    FUN_100ADE60(extralen, *p_source);
-    *p_source += extralen;
+  if (unkLength) {
+    AppendData(unkLength, *p_source);
+    *p_source += unkLength;
   }
 }
 
@@ -181,14 +186,14 @@ void MxDSAction::MergeFrom(MxDSAction &p_dsAction)
     this->m_up[2] = p_dsAction.m_up[2];
 
   // TODO
-  if (p_dsAction.m_unk80 &&
-      p_dsAction.m_unk7c &&
-      *p_dsAction.m_unk7c &&
-      !strncmp("XXX", (const char*) p_dsAction.m_unk7c, 3))
-  {
-    delete this->m_unk7c;
-    this->m_unk80 = 0;
-    FUN_100ADE60(p_dsAction.m_unk80, p_dsAction.m_unk7c);
+  MxU16 unkLength = p_dsAction.m_unkLength;
+  char *unkData = p_dsAction.m_unkData;
+  if (unkLength && unkData) {
+    if (!this->m_unkData || !strncmp("XXX", this->m_unkData, 3)) {
+      delete[] this->m_unkData;
+      this->m_unkLength = 0;
+      AppendData(unkLength, unkData);
+    }
   }
 }
 
@@ -216,8 +221,30 @@ MxLong MxDSAction::GetCurrentTime()
   return Timer()->GetTime() - this->m_someTimingField;
 }
 
-// OFFSET: LEGO1 0x100ade60 STUB
-void MxDSAction::FUN_100ADE60(MxU16 p_length, void *p_data)
+// OFFSET: LEGO1 0x100ade60
+void MxDSAction::AppendData(MxU16 p_unkLength, const char *p_unkData)
 {
-  // TOOD
+  if (this->m_unkData == p_unkData || !p_unkData)
+    return;
+
+  if (this->m_unkLength) {
+    char *concat = new char[p_unkLength + this->m_unkLength + sizeof(g_unkSep)];
+    memcpy(concat, this->m_unkData, this->m_unkLength);
+
+    *(MxU16*) &concat[this->m_unkLength] = g_unkSep;
+    memcpy(&concat[this->m_unkLength + sizeof(g_unkSep)], p_unkData, p_unkLength);
+
+    this->m_unkLength += p_unkLength + sizeof(g_unkSep);
+    delete[] this->m_unkData;
+    this->m_unkData = concat;
+  }
+  else {
+    char *copy = new char[p_unkLength];
+    this->m_unkData = copy;
+
+    if (copy) {
+      this->m_unkLength = p_unkLength;
+      memcpy(copy, p_unkData, p_unkLength);
+    }
+  }
 }
diff --git a/LEGO1/mxdsaction.h b/LEGO1/mxdsaction.h
index 069986bf..a677741c 100644
--- a/LEGO1/mxdsaction.h
+++ b/LEGO1/mxdsaction.h
@@ -40,7 +40,7 @@ class MxDSAction : public MxDSObject
   virtual MxLong GetSomeTimingField(); // vtable+3c;
   virtual MxLong GetCurrentTime(); // vtable+40;
 
-  void FUN_100ADE60(MxU16 p_length, void *p_data);
+  void AppendData(MxU16 p_unkLength, const char *p_unkData);
 
 private:
   MxU32 m_sizeOnDisk;
@@ -51,8 +51,8 @@ class MxDSAction : public MxDSObject
   MxVector3Data m_location;
   MxVector3Data m_direction;
   MxVector3Data m_up;
-  undefined4 *m_unk7c;
-  MxU16 m_unk80;
+  char *m_unkData;
+  MxU16 m_unkLength;
   undefined4 m_unk84;
   undefined4 m_unk88;
   MxOmni* m_omni; // 0x8c
diff --git a/LEGO1/mxdsfile.cpp b/LEGO1/mxdsfile.cpp
index 60f8533e..8bccf914 100644
--- a/LEGO1/mxdsfile.cpp
+++ b/LEGO1/mxdsfile.cpp
@@ -5,8 +5,6 @@
 #define SI_MAJOR_VERSION 2
 #define SI_MINOR_VERSION 2
 
-#define FOURCC(a, b, c, d) (((a) << 0) | ((b) << 8) | ((c) << 16) | ((d) << 24))
-
 // OFFSET: LEGO1 0x100cc4b0
 MxDSFile::MxDSFile(const char *filename, MxULong skipReadingChunks)
 {
diff --git a/LEGO1/mxtypes.h b/LEGO1/mxtypes.h
index 1f0aaac7..fc8d47b5 100644
--- a/LEGO1/mxtypes.h
+++ b/LEGO1/mxtypes.h
@@ -41,4 +41,7 @@ typedef MxU8 MxBool;
 #define FALSE 0
 #endif
 
+#define TWOCC(a, b) (((a) << 0) | ((b) << 8))
+#define FOURCC(a, b, c, d) (((a) << 0) | ((b) << 8) | ((c) << 16) | ((d) << 24))
+
 #endif // MXTYPE_H

From 4e0149361eb311db6c8382e2a3b10ab224e872f8 Mon Sep 17 00:00:00 2001
From: Christian Semmler <mail@csemmler.com>
Date: Thu, 10 Aug 2023 13:57:53 -0400
Subject: [PATCH 21/21] Implement MxDSAction (#106)

---
 LEGO1/mxdsaction.h        |  2 +-
 LEGO1/mxdsmediaaction.cpp | 96 ++++++++++++++++++++++++++++++++++++---
 LEGO1/mxdsmediaaction.h   | 26 +++++++----
 3 files changed, 107 insertions(+), 17 deletions(-)

diff --git a/LEGO1/mxdsaction.h b/LEGO1/mxdsaction.h
index a677741c..2d177f8f 100644
--- a/LEGO1/mxdsaction.h
+++ b/LEGO1/mxdsaction.h
@@ -55,7 +55,7 @@ class MxDSAction : public MxDSObject
   MxU16 m_unkLength;
   undefined4 m_unk84;
   undefined4 m_unk88;
-  MxOmni* m_omni; // 0x8c
+  MxOmni *m_omni; // 0x8c
   MxLong m_someTimingField; // 0x90
 };
 
diff --git a/LEGO1/mxdsmediaaction.cpp b/LEGO1/mxdsmediaaction.cpp
index a8acde30..d368aa3d 100644
--- a/LEGO1/mxdsmediaaction.cpp
+++ b/LEGO1/mxdsmediaaction.cpp
@@ -1,21 +1,103 @@
 #include "mxdsmediaaction.h"
 
+DECOMP_SIZE_ASSERT(MxDSMediaAction, 0xb8)
+
 // OFFSET: LEGO1 0x100c8b40
 MxDSMediaAction::MxDSMediaAction()
 {
-  this->m_unk98 = 0;
+  this->m_mediaSrcPath = NULL;
   this->m_unk9c = 0;
   this->m_unka0 = 0;
-  this->m_unka4 = 0;
-  this->m_unka8 = 0;
-  this->m_unkac = 1;
-  this->m_unkb4 = 0xffffffff;
-  this->m_unkb0 = 0;
+  this->m_framesPerSecond = 0;
+  this->m_mediaFormat = 0;
+  this->m_paletteManagement = 1;
+  this->m_unkb4 = -1;
+  this->m_sustainTime = 0;
   this->SetType(MxDSType_MediaAction);
 }
 
 // OFFSET: LEGO1 0x100c8cf0
 MxDSMediaAction::~MxDSMediaAction()
 {
-  delete this->m_unk98;
+  delete[] this->m_mediaSrcPath;
 }
+
+// OFFSET: LEGO1 0x100c8d60
+void MxDSMediaAction::CopyFrom(MxDSMediaAction &p_dsMediaAction)
+{
+  CopyMediaSrcPath(p_dsMediaAction.m_mediaSrcPath);
+
+  // TODO
+  this->m_unk9c = p_dsMediaAction.m_unk9c;
+  this->m_unka0 = p_dsMediaAction.m_unka0;
+
+  this->m_framesPerSecond = p_dsMediaAction.m_framesPerSecond;
+  this->m_mediaFormat = p_dsMediaAction.m_mediaFormat;
+  this->m_paletteManagement = p_dsMediaAction.m_paletteManagement;
+  this->m_sustainTime = p_dsMediaAction.m_sustainTime;
+}
+
+// OFFSET: LEGO1 0x100c8dc0
+MxDSMediaAction &MxDSMediaAction::operator=(MxDSMediaAction &p_dsMediaAction)
+{
+  if (this == &p_dsMediaAction)
+    return *this;
+
+  MxDSAction::operator=(p_dsMediaAction);
+  this->CopyFrom(p_dsMediaAction);
+  return *this;
+}
+
+// OFFSET: LEGO1 0x100c8f10
+MxU32 MxDSMediaAction::GetSizeOnDisk()
+{
+  MxU32 totalSizeOnDisk = MxDSAction::GetSizeOnDisk();
+
+  if (this->m_mediaSrcPath)
+    totalSizeOnDisk += strlen(this->m_mediaSrcPath) + 1;
+  else
+    totalSizeOnDisk++;
+
+  totalSizeOnDisk += 24;
+  this->m_sizeOnDisk = totalSizeOnDisk - MxDSAction::GetSizeOnDisk();
+  return totalSizeOnDisk;
+}
+
+// OFFSET: LEGO1 0x100c8f60
+void MxDSMediaAction::Deserialize(char **p_source, MxS16 p_unk24)
+{
+  MxDSAction::Deserialize(p_source, p_unk24);
+
+  CopyMediaSrcPath(*p_source);
+  *p_source += strlen(this->m_mediaSrcPath) + 1;
+  
+  this->m_unk9c = *(undefined4*) *p_source;
+  *p_source += sizeof(undefined4);
+  this->m_unka0 = *(undefined4*) *p_source;
+  *p_source += sizeof(undefined4);
+  this->m_framesPerSecond = *(MxS32*) *p_source;
+  *p_source += sizeof(MxS32);
+  this->m_mediaFormat = *(MxS32*) *p_source;
+  *p_source += sizeof(MxS32);
+  this->m_paletteManagement = *(MxS32*) *p_source;
+  *p_source += sizeof(MxS32);
+  this->m_sustainTime = *(MxLong*) *p_source;
+  *p_source += sizeof(MxLong);
+}
+
+// OFFSET: LEGO1 0x100c8e80
+void MxDSMediaAction::CopyMediaSrcPath(const char *p_mediaSrcPath)
+{
+  if (this->m_mediaSrcPath == p_mediaSrcPath)
+    return;
+
+  delete[] this->m_mediaSrcPath;
+
+  if (p_mediaSrcPath) {
+    this->m_mediaSrcPath = new char[strlen(p_mediaSrcPath) + 1];
+    if (this->m_mediaSrcPath)
+      strcpy(this->m_mediaSrcPath, p_mediaSrcPath);
+  }
+  else
+    this->m_mediaSrcPath = NULL;
+}
\ No newline at end of file
diff --git a/LEGO1/mxdsmediaaction.h b/LEGO1/mxdsmediaaction.h
index 5e6a6141..1ebbfdd2 100644
--- a/LEGO1/mxdsmediaaction.h
+++ b/LEGO1/mxdsmediaaction.h
@@ -12,6 +12,9 @@ class MxDSMediaAction : public MxDSAction
   MxDSMediaAction();
   virtual ~MxDSMediaAction() override;
 
+  void CopyFrom(MxDSMediaAction &p_dsMediaAction);
+  MxDSMediaAction &operator=(MxDSMediaAction &p_dsMediaAction);
+
   // OFFSET: LEGO1 0x100c8be0
   inline virtual const char *ClassName() const override // vtable+0x0c
   {
@@ -24,16 +27,21 @@ class MxDSMediaAction : public MxDSAction
   {
     return !strcmp(name, MxDSMediaAction::ClassName()) || MxDSAction::IsA(name);
   }
+
+  virtual MxU32 GetSizeOnDisk(); // vtable+18;
+  virtual void Deserialize(char **p_source, MxS16 p_unk24); // vtable+1c;
+
+  void CopyMediaSrcPath(const char *p_mediaSrcPath);
 private:
-  MxS32* m_unk94;
-  MxS32* m_unk98;
-  MxS32* m_unk9c;
-  MxS32* m_unka0;
-  MxS32* m_unka4;
-  MxS32* m_unka8;
-  MxS32 m_unkac;
-  MxS32* m_unkb0;
-  MxS32 m_unkb4;
+  MxU32 m_sizeOnDisk;
+  char *m_mediaSrcPath;
+  undefined4 m_unk9c;
+  undefined4 m_unka0;
+  MxS32 m_framesPerSecond;
+  MxS32 m_mediaFormat;
+  MxS32 m_paletteManagement;
+  MxLong m_sustainTime;
+  undefined4 m_unkb4;
 };
 
 #endif // MXDSMEDIAACTION_H