Initial

Histogram/ClrRect.hpp

@@ -0,0 +1,79 @@
+#ifndef _HISTOGRAM_COLORRECT_HPP_
+#define _HISTOGRAM_COLORRECT_HPP_
+#ifndef _ENGINE_RECT3D_HPP_
+#include <engine/rect3d.hpp>
+#endif
+
+class ColorRect : public Rect3D
+{
+public:
+  ColorRect(void);
+  ColorRect(const ColorRect &someColorRect);
+  ColorRect(const Rect3D &someRect3D,BYTE paletteIndex);
+  ColorRect(const ColorRect &someColorRect,BYTE paletteIndex);
+  virtual~ColorRect();
+  ColorRect &operator=(const ColorRect &someColorRect);
+  WORD operator==(const ColorRect &someColorRect);
+  BYTE paletteIndex(void)const;
+  void paletteIndex(BYTE paletteIndex);
+private:
+  BYTE mPaletteIndex;
+};
+
+inline
+ColorRect::ColorRect(void)
+: mPaletteIndex(0)
+{
+}
+
+inline
+ColorRect::ColorRect(const ColorRect &someColorRect)
+{
+  *this=someColorRect;
+}
+
+inline
+ColorRect::ColorRect(const ColorRect &someColorRect,BYTE paletteIndex)
+: Rect3D((Rect3D&)someColorRect), mPaletteIndex(paletteIndex)
+{
+}
+
+inline
+ColorRect::ColorRect(const Rect3D &someRect3D,BYTE paletteIndex)
+: mPaletteIndex(paletteIndex)
+{
+  (Rect3D&)*this=(Rect3D&)someRect3D;
+}
+
+inline
+ColorRect::~ColorRect()
+{
+}
+
+inline
+ColorRect &ColorRect::operator=(const ColorRect &someColorRect)
+{
+  (Rect3D&)*this=(Rect3D&)someColorRect;
+  paletteIndex(someColorRect.paletteIndex());
+  return *this;
+}
+
+inline
+WORD ColorRect::operator==(const ColorRect &someColorRect)
+{
+  return ((Rect3D&)*this==(Rect3D&)someColorRect&&
+    paletteIndex()==someColorRect.paletteIndex());
+}
+
+inline
+BYTE ColorRect::paletteIndex(void)const
+{
+  return mPaletteIndex;
+}
+
+inline
+void ColorRect::paletteIndex(BYTE paletteIndex)
+{
+  mPaletteIndex=paletteIndex;
+}
+#endif			

Histogram/Graph3D.cpp

@@ -0,0 +1,25 @@
+#include <histogram/graph3d.hpp>
+
+Graph3D::Graph3D(GUIWindow &someGUIWindow)
+: mGUIWindow(&someGUIWindow), DIB3D(someGUIWindow)
+{
+}
+
+Graph3D::Graph3D(GUIWindow &someGUIWindow,PurePalette &purePalette)
+: mGUIWindow(&someGUIWindow), DIB3D(someGUIWindow,purePalette)
+{
+}
+
+Graph3D::~Graph3D()
+{
+}
+
+WORD Graph3D::viewPortWidth(void)const
+{
+  return ((SmartPointer<GUIWindow>&)mGUIWindow)->width();
+}
+
+WORD Graph3D::viewPortHeight(void)const
+{
+  return ((SmartPointer<GUIWindow>&)mGUIWindow)->height();
+}

Histogram/Graph3D.hpp

@@ -0,0 +1,32 @@
+#ifndef _HISTOGRAM_GRAPH3D_HPP_
+#define _HISTOGRAM_GRAPH3D_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_SMARTPOINTER_HPP_
+#include <common/pointer.hpp>
+#endif
+#ifndef _ENGINE_DIB3D_HPP_
+#include <engine/dib3d.hpp>
+#endif
+
+class Graph3D : public DIB3D
+{
+public:
+  Graph3D(GUIWindow &someGUIWindow);
+	Graph3D(GUIWindow &someGUIWindow,PurePalette &purePalette);
+  virtual ~Graph3D();
+protected:
+  WORD viewPortWidth(void)const;
+  WORD viewPortHeight(void)const;
+private:
+  Graph3D &operator=(const Graph3D &someGraph3D);
+	SmartPointer<GUIWindow> mGUIWindow;
+}; 
+
+inline
+Graph3D &Graph3D::operator=(const Graph3D &/*someGraph3D*/)
+{ // private implementation
+  return *this;
+}
+#endif

Histogram/GraphDlg.cpp

@@ -0,0 +1,67 @@
+#include <common/stdio.hpp>
+#include <common/string.hpp>
+#include <common/rect.hpp>
+#include <histogram/graphdlg.hpp>
+#include <histogram/graphwnd.hpp>
+
+GraphDlg::GraphDlg(void)
+{
+  mDestroyHandler.setCallback(this,&GraphDlg::destroyHandler);
+  mInitHandler.setCallback(this,&GraphDlg::initHandler);
+  mCommandHandler.setCallback(this,&GraphDlg::commandHandler);
+  mCloseHandler.setCallback(this,&GraphDlg::closeHandler);
+  insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+  insertHandler(VectorHandler::InitDialogHandler,&mInitHandler);
+  insertHandler(VectorHandler::CommandHandler,&mCommandHandler);
+  insertHandler(VectorHandler::CloseHandler,&mCloseHandler);
+}
+
+GraphDlg::~GraphDlg()
+{
+  removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+  removeHandler(VectorHandler::InitDialogHandler,&mInitHandler);
+  removeHandler(VectorHandler::CommandHandler,&mCommandHandler);
+  removeHandler(VectorHandler::CloseHandler,&mCloseHandler);
+}
+
+bool GraphDlg::perform(TabEntries &entries,HWND hParent)
+{
+  WORD returnCode;
+	mTabEntries=entries;
+  returnCode=::DialogBoxParam(processInstance(),(LPSTR)"GRAPHDIALOG",hParent,DWindow::DlgProc,(LPARAM)(DWindow*)this);
+  return returnCode;
+}
+
+CallbackData::ReturnType GraphDlg::initHandler(CallbackData &/*someCallbackData*/)
+{
+  mGraphWindow=::new GraphWindow(*this,Rect(3,3,width()-6,height()-58));
+	mGraphWindow.disposition(PointerDisposition::Delete);
+	mGraphWindow->setFocus();
+	mGraphWindow->showHistogram(mTabEntries);
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType GraphDlg::destroyHandler(CallbackData &/*someCallbackData*/)
+{
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType GraphDlg::closeHandler(CallbackData &/*someCallbackData*/)
+{
+  endDialog(TRUE);
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType GraphDlg::commandHandler(CallbackData &someCallbackData)
+{
+  switch(someCallbackData.wmCommandID())
+  {
+    case IDCANCEL :
+      endDialog(false);
+      break;
+    case IDOK :
+		  endDialog(true);
+			break;
+  }
+  return (CallbackData::ReturnType)FALSE;
+}

Histogram/GraphDlg.hpp

@@ -0,0 +1,40 @@
+#ifndef _HISTOGRAM_GRAPHDLG_HPP_
+#define _HISTOGRAM_GRAPHDLG_HPP_
+#ifndef _COMMON_SMARTPOINTER_HPP_
+#include <common/pointer.hpp>
+#endif
+#ifndef _COMMON_DWINDOW_HPP_
+#include <common/dwindow.hpp>
+#endif
+#ifndef _COMMON_SDATE_HPP_
+#include <common/sdate.hpp>
+#endif
+#ifndef _GUITAR_TABENTRY_HPP_
+#include <guitar/tabentry.hpp>
+#endif
+#ifndef _THREAD_THREADCALLBACK_HPP_
+#include <thread/tcallbck.hpp>
+#endif
+
+class GraphWindow;
+
+class GraphDlg : private DWindow
+{
+public:
+  GraphDlg(void);
+  virtual ~GraphDlg();									  
+	bool perform(TabEntries &entries,HWND hParent);
+private:
+  CallbackData::ReturnType destroyHandler(CallbackData &someCallbackData);
+  CallbackData::ReturnType initHandler(CallbackData &someCallbackData);
+  CallbackData::ReturnType commandHandler(CallbackData &someCallbackData);
+  CallbackData::ReturnType closeHandler(CallbackData &someCallbackData);
+
+  Callback<GraphDlg> mCommandHandler; 
+  Callback<GraphDlg> mDestroyHandler;
+  Callback<GraphDlg> mInitHandler;
+  Callback<GraphDlg> mCloseHandler;
+	SmartPointer<GraphWindow> mGraphWindow;
+	TabEntries mTabEntries;
+};
+#endif

Histogram/GraphWnd.cpp

@@ -0,0 +1,256 @@
+#include <histogram/graphwnd.hpp>
+#include <histogram/graph3d.hpp>
+#include <histogram/clrrect.hpp>
+#include <music/scales.hpp>
+#include <engine/spacial.hpp>
+#include <engine/rect3d.hpp>
+#include <common/string.hpp>
+#include <common/rect.hpp>
+#include <common/catmull.hpp>
+
+char GraphWindow::smszClassName[]={"GraphWindow"};
+char GraphWindow::smszMenuName[]={""};
+
+GraphWindow::GraphWindow(GUIWindow &parentWindow,const Rect &winRect)
+{
+  mPaintHandler.setCallback(this,&GraphWindow::paintHandler);
+  mCreateHandler.setCallback(this,&GraphWindow::createHandler);
+  mDestroyHandler.setCallback(this,&GraphWindow::destroyHandler);
+  mKeyDownHandler.setCallback(this,&GraphWindow::keyDownHandler);
+  mLeftButtonDownHandler.setCallback(this,&GraphWindow::leftButtonDownHandler);
+  mDialogCodeHandler.setCallback(this,&GraphWindow::dialogCodeHandler);
+  insertHandler(VectorHandler::PaintHandler,&mPaintHandler);
+  insertHandler(VectorHandler::CreateHandler,&mCreateHandler);
+  insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+  insertHandler(VectorHandler::KeyDownHandler,&mKeyDownHandler);
+  insertHandler(VectorHandler::LeftButtonDownHandler,&mLeftButtonDownHandler);
+  insertHandler(VectorHandler::DialogCodeHandler,&mDialogCodeHandler);
+  registerClass();
+  initializePalette();
+  createWindow(parentWindow,winRect);
+  mGraph3D=::new Graph3D(*this,mGraphPalette);
+  mGraph3D.disposition(PointerDisposition::Delete);
+  setPerspective();
+  show(SW_SHOW);
+  update();
+}
+
+GraphWindow::GraphWindow(const GraphWindow &/*someGraphWindow*/)
+{ // private implementation
+}
+
+GraphWindow::~GraphWindow()
+{
+  removeHandler(VectorHandler::PaintHandler,&mPaintHandler);
+  removeHandler(VectorHandler::CreateHandler,&mCreateHandler);
+  removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+  removeHandler(VectorHandler::KeyDownHandler,&mKeyDownHandler);
+  removeHandler(VectorHandler::LeftButtonDownHandler,&mLeftButtonDownHandler);
+  removeHandler(VectorHandler::DialogCodeHandler,&mDialogCodeHandler);
+}
+
+void GraphWindow::initializePalette(void)
+{
+  Array<RGBColor> rgbColors;;
+
+  rgbColors.size(4);
+  rgbColors[0]=RGBColor(0,0,0);
+  rgbColors[1]=RGBColor(255,255,255);
+  rgbColors[2]=RGBColor(255,0,0);
+  rgbColors[3]=RGBColor(0,255,0);
+  mGraphPalette.setPaletteColors(rgbColors);
+}
+
+void GraphWindow::registerClass(void)const
+{
+  HINSTANCE hInstance(processInstance());
+  WNDCLASS wndClass;
+
+  if(::GetClassInfo(hInstance,smszClassName,(WNDCLASS FAR*)&wndClass))return;
+  wndClass.style         =CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS|CS_OWNDC;
+  wndClass.lpfnWndProc   =(WNDPROC)Window::WndProc;
+  wndClass.cbClsExtra    =0;
+  wndClass.cbWndExtra    =sizeof(GraphWindow*);
+  wndClass.hInstance     =hInstance;
+  wndClass.hIcon         =::LoadIcon(NULL,IDI_APPLICATION);
+  wndClass.hCursor       =::LoadCursor(NULL,IDC_ARROW);
+  wndClass.hbrBackground =(HBRUSH)::GetStockObject(HOLLOW_BRUSH);
+  wndClass.lpszMenuName  =smszMenuName;
+  wndClass.lpszClassName =smszClassName;
+  ::RegisterClass(&wndClass);
+  assert(0!=::GetClassInfo(hInstance,smszClassName,(WNDCLASS FAR*)&wndClass));
+}
+
+void GraphWindow::createWindow(GUIWindow &parentWindow,const Rect &winRect)
+{
+  Window::createWindow(WS_EX_CLIENTEDGE,String(smszClassName),String(smszMenuName),
+	  WS_CHILD|WS_OVERLAPPED|WS_CLIPCHILDREN|WS_BORDER,winRect,
+          parentWindow,(HMENU)103,processInstance(),(LPSTR)this);
+  show(SW_SHOW);
+  update();
+}
+
+CallbackData::ReturnType GraphWindow::paintHandler(CallbackData &someCallbackData)
+{
+  if(!mGraph3D.isOkay())return (CallbackData::ReturnType)FALSE;
+  PaintInformation *pPaintInfo=(PaintInformation*)someCallbackData.lParam();
+  mGraph3D->clearBits();
+  for(int rectIndex=0;rectIndex<mGraphRects.size();rectIndex++)
+  {
+    ColorRect &colorRect=mGraphRects[rectIndex];
+    mGraph3D->rectangle(colorRect,colorRect.paletteIndex());
+  }
+  mGraph3D->bitBlt((PureDevice&)*pPaintInfo);
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType GraphWindow::createHandler(CallbackData &/*someCallbackData*/)
+{
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType GraphWindow::leftButtonDownHandler(CallbackData &/*someCallbackData*/)
+{
+  setFocus();
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType GraphWindow::dialogCodeHandler(CallbackData &/*someCallbackData*/)
+{
+  return (CallbackData::ReturnType)DLGC_WANTARROWS|DLGC_WANTCHARS;
+}
+
+CallbackData::ReturnType GraphWindow::keyDownHandler(CallbackData &someCallbackData)
+{
+  switch(someCallbackData.wParam())
+  {
+    case inKey :
+      if(shiftKeyPressed())mGraph3D->cameraTwistDegrees(mGraph3D->cameraTwistDegrees()-ThetaDelta);
+      mGraph3D->viewPlaneDistance(mGraph3D->viewPlaneDistance()+ViewDelta);
+      invalidate(FALSE);
+      break;
+    case outKey :
+      if(shiftKeyPressed())mGraph3D->cameraTwistDegrees(mGraph3D->cameraTwistDegrees()+ThetaDelta);
+      mGraph3D->viewPlaneDistance(mGraph3D->viewPlaneDistance()-ViewDelta);
+      invalidate(FALSE);
+      break;
+    case UpArrow :
+      if(handleUpArrow())invalidate(FALSE);
+      break;
+    case DownArrow :
+      if(handleDownArrow())invalidate(FALSE);
+      break;
+    case LeftArrow :
+      if(handleLeftArrow())invalidate(FALSE);
+      break;
+    case RightArrow :
+      if(handleRightArrow())invalidate(FALSE);
+      break;
+  }
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType GraphWindow::destroyHandler(CallbackData &/*someCallbackData*/)
+{
+  return (CallbackData::ReturnType)FALSE;
+}
+
+void GraphWindow::showHistogram(TabEntries &entries)
+{
+  Block<int> vectorInt;
+	IonianScale ionianScale;
+
+	mGraphRects.remove();
+	setPerspective();
+  for(int itemIndex=0;itemIndex<entries.size();itemIndex++)
+	{
+	  TabEntry &entry=entries[itemIndex];
+		for(int index=0;index<entry.size();index++)
+		{
+		  Note note=entry[index].getNote();
+		}
+	}
+
+
+
+/*
+  Array<int> vectorInt;
+  int itemIndex;
+  int vectorIndex;
+
+  vectorInt.size((Note::B-Note::C)+1);
+	for(int index=0;index<vectorInt.size();index++)vectorInt[index]=0;
+  mGraphRects.remove();
+  setPerspective();
+  for(itemIndex=0,vectorIndex=0;itemIndex<entries.size();itemIndex++,vectorIndex++)
+	{
+	  TabEntry &entry=entries[itemIndex];
+		for(int index=0;index<entry.size();index++)
+		{
+		  int value=entry[index].getNote().getNote();
+			vectorInt[value]=vectorInt[value]+1;
+		}
+	}
+*/
+//  showHistogram(vectorInt,mGraph3D->getPalette().paletteIndex(RGBColor(255,255,255)));
+//  invalidate();
+}
+
+void GraphWindow::showHistogram(Array<int> &vectorInt,BYTE paletteIndex,int zDepth)
+{
+  Array<int> scrnInt;
+  int widthAdjust(5);
+
+  WORD sizeFactor(((((float)width()-20)/(float)widthAdjust)/(float)(Note::B-Note::C)+1)*100.00);
+  SpacialTransform resample;
+  resample.transform(vectorInt,scrnInt,sizeFactor);
+  for(int itemIndex=0,xPoint=widthAdjust;itemIndex<scrnInt.size();itemIndex++,xPoint+=widthAdjust)
+  {
+    Vector3D outerPlane(Point3D(xPoint,scrnInt[itemIndex]+1,zDepth),
+    Point3D(xPoint+widthAdjust,scrnInt[itemIndex]+1,zDepth),Point3D(xPoint+widthAdjust,0,zDepth),Point3D(xPoint,0,zDepth));
+    Rect3D rect3D(outerPlane,10);
+    mGraphRects.insert(&ColorRect(rect3D,paletteIndex));
+  }
+}
+
+bool GraphWindow::handleUpArrow(void)
+{
+  Point3D cameraPoint(mGraph3D->cameraPoint());
+  cameraPoint.y(cameraPoint.y()+TurnDelta);
+  mGraph3D->cameraPoint(cameraPoint);
+  return TRUE;
+}
+
+bool GraphWindow::handleDownArrow(void)
+{
+  Point3D cameraPoint(mGraph3D->cameraPoint());
+  cameraPoint.y(cameraPoint.y()-TurnDelta);
+  mGraph3D->cameraPoint(cameraPoint);
+  return TRUE;
+}
+
+bool GraphWindow::handleLeftArrow(void)
+{
+  Point3D cameraPoint(mGraph3D->cameraPoint());
+  if(shiftKeyPressed())mGraph3D->cameraTwistDegrees(mGraph3D->cameraTwistDegrees()-ThetaDelta);
+  else cameraPoint.x(cameraPoint.x()+TurnDelta);
+  mGraph3D->cameraPoint(cameraPoint);
+  return TRUE;
+}
+
+bool GraphWindow::handleRightArrow(void)
+{
+  Point3D cameraPoint(mGraph3D->cameraPoint());
+  if(shiftKeyPressed())mGraph3D->cameraTwistDegrees(mGraph3D->cameraTwistDegrees()+ThetaDelta);
+  else cameraPoint.x(cameraPoint.x()-TurnDelta);
+  mGraph3D->cameraPoint(cameraPoint);
+  return TRUE;
+}
+
+void GraphWindow::setPerspective(void)
+{
+  mGraph3D->cameraTwistDegrees(134.64);
+  mGraph3D->viewPlaneDistance(40);
+  mGraph3D->cameraPoint(Point3D(-385,75,75));
+  mGraph3D->focusPoint(Point3D(0,0,1));
+}

Histogram/GraphWnd.hpp

@@ -0,0 +1,92 @@
+#ifndef _HISTOGRAM_GRAPHWINDOW_HPP_
+#define _HISTOGRAM_GRAPHWINDOW_HPP_
+#ifndef _COMMON_WINDOW_HPP_
+#include <common/window.hpp>
+#endif
+#ifndef _COMMON_SMARTPOINTER_HPP_
+#include <common/pointer.hpp>
+#endif
+#ifndef _COMMON_PUREPALETTE_HPP_
+#include <common/purepal.hpp>
+#endif
+//#ifndef _HISTOGRAM_GRAPH3D_HPP_
+//#include <histogram/graph3d.hpp>
+//#endif
+//#ifndef _MUSIC_NOTE_HPP_
+//#include <music/note.hpp>
+//#endif
+#ifndef _GUITAR_TABENTRY_HPP_
+#include <guitar/TabEntry.hpp>
+#endif
+
+template <class T>
+class Block;
+template <class T>
+class Callback;
+//template <class T>
+//class PureCheck;
+class Graph3D;
+class Rect3D;
+class ColorRect;
+class FloatPairs;
+
+class GraphWindow : public Window
+{
+public:
+  GraphWindow(GUIWindow &parentWindow,const Rect &winRect);
+  virtual ~GraphWindow();
+  void showHistogram(TabEntries &entries);
+//  void showHistogram(Array<Note> &notes);
+//  void showBalance(Block<PureCheck> &pureChecks);
+private:
+  enum {MaxRotate=360,MinRotate=-360};
+  enum {ThetaDelta=10,ViewDelta=5,TurnDelta=20};
+  enum {LeftArrow=0x25,RightArrow=0x27,UpArrow=0x26,DownArrow=0x28,inKey=0x49,outKey=0x4F};
+  GraphWindow(const GraphWindow &someGraphWindow);
+  GraphWindow &operator=(const GraphWindow &someGraphWindow);
+  void registerClass(void)const;
+  void initializePalette(void);
+  void createWindow(GUIWindow &parentWindow,const Rect &winRect);
+  void clamp(Array<FloatPairs> &vector);
+//  void clamp(PureVector<FloatPairs> &vector);
+  void showHistogram(Array<int> &vectorInt,BYTE paletteIndex,int zDepth=0);
+//  void showBalance(int baseMonths,PureVector<int> &vectorInt,BYTE paletteIndex,int zDepth=0);
+  bool handleLeftArrow(void);
+  bool handleRightArrow(void);
+  bool handleUpArrow(void);
+  bool handleDownArrow(void);
+  void setPerspective(void);
+  bool shiftKeyPressed(void)const;
+
+  CallbackData::ReturnType paintHandler(CallbackData &someCallbackData);
+  CallbackData::ReturnType createHandler(CallbackData &someCallbackData);
+  CallbackData::ReturnType destroyHandler(CallbackData &someCallbackData);
+  CallbackData::ReturnType keyDownHandler(CallbackData &someCallbackData);
+  CallbackData::ReturnType leftButtonDownHandler(CallbackData &someCallbackData);
+  CallbackData::ReturnType dialogCodeHandler(CallbackData &someCallbackData);
+
+  Callback<GraphWindow> mPaintHandler;
+  Callback<GraphWindow> mCreateHandler;
+  Callback<GraphWindow> mDestroyHandler;
+  Callback<GraphWindow> mKeyDownHandler;
+  Callback<GraphWindow> mLeftButtonDownHandler;
+  Callback<GraphWindow> mDialogCodeHandler;
+  SmartPointer<Graph3D> mGraph3D;
+  Block<ColorRect> mGraphRects;
+  PurePalette mGraphPalette;
+  static char smszClassName[];
+  static char smszMenuName[];
+};
+
+inline
+GraphWindow &GraphWindow::operator=(const GraphWindow &/*someGraphWindow*/)
+{ // private implementation
+  return *this;
+}
+
+inline
+bool GraphWindow::shiftKeyPressed(void)const
+{
+  return ::GetKeyState(VK_SHIFT)&0x8000;
+}
+#endif

Histogram/Histogram.rc

@@ -0,0 +1,9 @@
+GRAPHDIALOG DIALOG 6, 15, 340, 205
+STYLE DS_MODALFRAME | 0x4L | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "Graph"
+FONT 8, "MS Sans Serif"
+{
+ PUSHBUTTON "Dismiss", IDCANCEL, 171, 180, 50, 14
+ GROUPBOX "", -1, 5, 4, 326, 166, BS_GROUPBOX
+ DEFPUSHBUTTON "Graph", IDOK, 119, 180, 50, 14
+}

Histogram/histogram.dsp

@@ -0,0 +1,104 @@
+# Microsoft Developer Studio Project File - Name="histogram" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=histogram - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "histogram.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "histogram.mak" CFG="histogram - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "histogram - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "histogram - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "histogram - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ELSEIF  "$(CFG)" == "histogram - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD CPP /nologo /Gz /MTd /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /D "STRICT" /D "__FLAT__" /YX /FD /GZ /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ENDIF 
+
+# Begin Target
+
+# Name "histogram - Win32 Release"
+# Name "histogram - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\Graph3D.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\GraphDlg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\GraphWnd.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# End Group
+# End Target
+# End Project

Histogram/histogram.dsw

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

Histogram/histogram.plg

@@ -0,0 +1,31 @@
+<html>
+<body>
+<pre>
+<h1>Build Log</h1>
+<h3>
+--------------------Configuration: histogram - Win32 Debug--------------------
+</h3>
+<h3>Command Lines</h3>
+Creating temporary file "C:\DOCUME~1\TERNET~1\LOCALS~1\Temp\RSP27E.tmp" with contents
+[
+/nologo /Gz /MTd /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /D "STRICT" /D "__FLAT__" /Fp"Debug/histogram.pch" /YX /Fo"Debug/" /Fd"Debug/" /FD /GZ /c 
+"F:\work\Histogram\Graph3D.cpp"
+"F:\work\Histogram\GraphDlg.cpp"
+"F:\work\Histogram\GraphWnd.cpp"
+]
+Creating command line "cl.exe @C:\DOCUME~1\TERNET~1\LOCALS~1\Temp\RSP27E.tmp" 
+Creating command line "link.exe -lib /nologo /out:"Debug\histogram.lib"  .\Debug\Graph3D.obj .\Debug\GraphDlg.obj .\Debug\GraphWnd.obj \work\exe\msengine.lib \work\exe\music.lib "
+<h3>Output Window</h3>
+Compiling...
+Graph3D.cpp
+GraphDlg.cpp
+GraphWnd.cpp
+Creating library...
+
+
+
+<h3>Results</h3>
+histogram.lib - 0 error(s), 0 warning(s)
+</pre>
+</body>
+</html>

Histogram/scraps.txt

@@ -0,0 +1,92 @@
+/*
+  Array<FloatPairs> vectorCDB;
+  Array<int> vectorInt;
+  int itemIndex;
+  int fvectorIndex;
+
+  mGraphRects.remove();
+  setPerspective();
+  vectorCDB.size(pureChecks.size()*3);
+  vectorInt.size(pureChecks.size());
+
+  for(itemIndex=0,vectorIndex=0;itemIndex<pureChecks.size();itemIndex++,vectorIndex++)
+	vectorCDB[vectorIndex]=FloatPairs(pureChecks[itemIndex].balance(),itemIndex);
+
+  for(itemIndex=0;itemIndex<pureChecks.size();itemIndex++,vectorIndex++)
+	vectorCDB[vectorIndex]=FloatPairs(pureChecks[itemIndex].debit(),itemIndex);
+
+  for(itemIndex=0;itemIndex<pureChecks.size();itemIndex++,vectorIndex++)
+	vectorCDB[vectorIndex]=FloatPairs(pureChecks[itemIndex].credit(),itemIndex);
+
+  clamp(vectorCDB);
+  for(itemIndex=0,vectorIndex=0;itemIndex<pureChecks.size();itemIndex++,vectorIndex++)vectorInt[itemIndex]=vectorCDB[vectorIndex].column();
+  showBalance(vectorInt.size(),vectorInt,mGraph3D->getPalette().paletteIndex(RGBColor(255,255,255)));
+  for(itemIndex=0;itemIndex<pureChecks.size();itemIndex++,vectorIndex++)vectorInt[itemIndex]=vectorCDB[vectorIndex].column();
+  showBalance(vectorInt.size(),vectorInt,mGraph3D->getPalette().paletteIndex(RGBColor(255,0,0)),10);
+  for(itemIndex=0;itemIndex<pureChecks.size();itemIndex++,vectorIndex++)vectorInt[itemIndex]=vectorCDB[vectorIndex].column();
+  showBalance(vectorInt.size(),vectorInt,mGraph3D->getPalette().paletteIndex(RGBColor(0,255,0)),20);
+*/
+
+
+
+
+
+
+/*
+  Array<FloatPairs> vectorCDB;
+  Array<int> vectorInt;
+  int itemIndex;
+  int vectorIndex;
+
+  mGraphRects.remove();
+  setPerspective();
+  vectorCDB.size(entries.size());
+  vectorInt.size(entries.size());
+
+  for(itemIndex=0,vectorIndex=0;itemIndex<entries.size();itemIndex++,vectorIndex++)
+	{
+	  TabEntry &entry=entries[itemIndex];
+		for(int index=0;index<entry.size();index++)
+		{
+	    vectorCDB[vectorIndex]=FloatPairs(entry[index].getNote().getNote(),itemIndex);
+		}
+	}
+*/
+
+//  for(itemIndex=0,vectorIndex=0;itemIndex<pureChecks.size();itemIndex++,vectorIndex++)
+//	{
+//	  vectorCDB[vectorIndex]=FloatPairs(pureChecks[itemIndex].balance(),itemIndex);
+//	}
+
+//  for(itemIndex=0;itemIndex<pureChecks.size();itemIndex++,vectorIndex++)
+//	vectorCDB[vectorIndex]=FloatPairs(pureChecks[itemIndex].debit(),itemIndex);
+
+//  for(itemIndex=0;itemIndex<pureChecks.size();itemIndex++,vectorIndex++)
+//	vectorCDB[vectorIndex]=FloatPairs(pureChecks[itemIndex].credit(),itemIndex);
+
+//  clamp(vectorCDB);
+
+//  for(itemIndex=0,vectorIndex=0;itemIndex<entries.size();itemIndex++,vectorIndex++)vectorInt[itemIndex]=vectorCDB[vectorIndex].column();
+//	{
+//    showHistogram(vectorInt.size(),vectorInt,mGraph3D->getPalette().paletteIndex(RGBColor(255,255,255)));
+//    showHistogram(vectorInt,mGraph3D->getPalette().paletteIndex(RGBColor(255,255,255)));
+//	}
+
+
+
+/*
+void GraphWindow::clamp(Array<FloatPairs> &vector)
+{
+  float factor=0.00;
+  float vectorMax;
+
+  if(!vector.size())return;
+  for(int itemIndex=0;itemIndex<vector.size();itemIndex++)
+  {
+    if(!itemIndex)vectorMax=vector[itemIndex].column();
+    else if(vector[itemIndex].column()>vectorMax)vectorMax=vector[itemIndex].column();
+  }
+  factor=(1.00/(float)vectorMax);
+  for(itemIndex=0;itemIndex<vector.size();itemIndex++)vector[itemIndex].column((float)vector[itemIndex].column()*factor*100.00);
+}
+*/

ddraw/BLTFX.HPP

@@ -0,0 +1,507 @@
+#ifndef _DDRAW_BLITEFFECTS_HPP_
+#define _DDRAW_BLITEFFECTS_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _DDRAW_DDRAW_HPP_
+#include <ddraw/ddraw.hpp>
+#endif
+
+class BltEffects : private DDBLTFX
+{
+public:
+  BltEffects(void);
+	BltEffects(const BltEffects &someBltEffects);
+	BltEffects(const DDBLTFX &someDDBLTFX);
+	virtual ~BltEffects();
+	BltEffects &operator=(const BltEffects &someBltEffects);
+	BltEffects &operator=(const DDBLTFX &someDDBLTFX);
+	DWORD ddFx(void)const;
+	void ddFx(DWORD ddFx);
+	DWORD rop(void)const;
+	void rop(DWORD rop);
+	DWORD ddRop(void)const;
+	void ddRop(DWORD ddRop);
+	DWORD rotationAngle(void)const;
+	void rotationAngle(DWORD rotationAngle);
+	DWORD zBufferOpCode(void)const;
+	void zBufferOpCode(DWORD zBufferOpCode);
+	DWORD zBufferLow(void)const;
+	void zBufferLow(DWORD zBufferLow);
+	DWORD zBufferHigh(void)const;
+	void zBufferHigh(DWORD zBufferHigh);
+	DWORD zBufferBaseDest(void)const;
+	void zBufferBaseDest(DWORD zBufferBaseDest);
+	DWORD zDestConstBitDepth(void)const;
+	void zDestConstBitDepth(DWORD zDestConstBitDepth);
+	DWORD zDestConst(void)const;
+	void zDestConst(DWORD zDestConst);
+	LPDIRECTDRAWSURFACE szBufferDest(void);
+	void szBufferDest(LPDIRECTDRAWSURFACE lpDirectDrawSurface);
+	DWORD zSrcConstBitDepth(void)const;
+	void zSrcConstBitDepth(DWORD zSrcConstBitDepth);
+	DWORD zSrcConst(void)const;
+	void zSrcConst(DWORD zSrcConst);
+	LPDIRECTDRAWSURFACE szBufferSrc(void);
+	void szBufferSrc(LPDIRECTDRAWSURFACE lpDirectDrawSurface);
+	DWORD alphaEdgeBlendBitDepth(void)const;
+	void alphaEdgeBlendBitDepth(DWORD alphaEdgeBlendBitDepth);
+	DWORD alphaEdgeBlend(void)const;
+	void alphaEdgeBlend(DWORD alphaEdgeBlend);
+	DWORD alphaDestConstBitDepth(void)const;
+	void alphaDestConstBitDepth(DWORD alphaDestConstBitDepth);
+	DWORD alphaDestConst(void)const;
+	void alphaDestConst(DWORD alphaDestConst);
+	LPDIRECTDRAWSURFACE lpAlphaDest(void);
+	void lpAlphaDest(LPDIRECTDRAWSURFACE lpAlphaConst);
+	DWORD alphaSrcConstBitDepth(void)const;
+	void alphaSrcConstBitDepth(DWORD alphaSrcConstBitDepth);
+	DWORD alphaSrcConst(void)const;
+	void alphaSrcConst(DWORD alphaSrcConst);
+	LPDIRECTDRAWSURFACE alphaSrc(void);
+	void alphaSrc(LPDIRECTDRAWSURFACE alphaSrc);
+	DWORD fillColor(void)const;
+	void fillColor(DWORD fillColor);
+	DWORD fillDepth(void)const;
+	void fillDepth(DWORD fillDepth);
+	DWORD fillPixel(void)const;
+	void fillPixel(DWORD fillPixel);
+	LPDIRECTDRAWSURFACE ddsPattern(void);
+	void ddsPattern(LPDIRECTDRAWSURFACE ddsPattern);
+	const DDCOLORKEY &ckDestColorKey(void)const;
+	void ckDestColorKey(const DDCOLORKEY &ckDestColorKey);
+	const DDCOLORKEY &ckSrcColorKey(void)const;
+	void ckSrcColorKey(const DDCOLORKEY &ckSrcColorKey);
+	DDBLTFX &getDDBLTFX(void);
+private:
+  void zeroInit(void);
+};
+
+inline
+BltEffects::BltEffects(void)
+{
+  zeroInit();
+}
+
+inline
+BltEffects::BltEffects(const BltEffects &someBltEffects)
+{
+  zeroInit();
+  *this=someBltEffects;
+}
+
+inline
+BltEffects::BltEffects(const DDBLTFX &someDDBLTFX)
+{
+  zeroInit();
+  *this=someDDBLTFX;
+}
+
+inline
+BltEffects::~BltEffects()
+{
+}
+
+inline
+BltEffects &BltEffects::operator=(const BltEffects &someBltEffects)
+{
+  ddFx(someBltEffects.ddFx());
+	rop(someBltEffects.rop());
+	ddRop(someBltEffects.ddRop());
+	rotationAngle(someBltEffects.rotationAngle());
+	zBufferOpCode(someBltEffects.zBufferOpCode());
+	zBufferLow(someBltEffects.zBufferLow());
+	zBufferHigh(someBltEffects.zBufferHigh());
+	zBufferBaseDest(someBltEffects.zBufferBaseDest());
+	zDestConstBitDepth(someBltEffects.zDestConstBitDepth());
+	zDestConst(someBltEffects.zDestConst());
+	zSrcConstBitDepth(someBltEffects.zSrcConstBitDepth());
+	zSrcConst(someBltEffects.zSrcConst());
+	alphaEdgeBlendBitDepth(someBltEffects.alphaEdgeBlendBitDepth());
+	alphaEdgeBlend(someBltEffects.alphaEdgeBlend());
+	alphaDestConstBitDepth(someBltEffects.alphaDestConstBitDepth());
+	alphaDestConst(someBltEffects.alphaDestConst());
+	alphaSrcConstBitDepth(someBltEffects.alphaSrcConstBitDepth());
+	alphaSrcConst(someBltEffects.alphaSrcConst());
+	fillColor(someBltEffects.fillColor());
+	ckDestColorKey(someBltEffects.ckDestColorKey());
+	ckSrcColorKey(someBltEffects.ckSrcColorKey());
+	return *this;
+}
+
+inline
+BltEffects &BltEffects::operator=(const DDBLTFX &someDDBLTFX)
+{
+  ddFx(someDDBLTFX.dwDDFX);
+	rop(someDDBLTFX.dwROP);
+	ddRop(someDDBLTFX.dwDDROP);
+	rotationAngle(someDDBLTFX.dwRotationAngle);
+	zBufferOpCode(someDDBLTFX.dwZBufferOpCode);
+	zBufferLow(someDDBLTFX.dwZBufferLow);
+	zBufferHigh(someDDBLTFX.dwZBufferHigh);
+	zBufferBaseDest(someDDBLTFX.dwZBufferBaseDest);
+	zDestConstBitDepth(someDDBLTFX.dwZDestConstBitDepth);
+	zDestConst(someDDBLTFX.dwZDestConst);
+	zSrcConstBitDepth(someDDBLTFX.dwZSrcConstBitDepth);
+	zSrcConst(someDDBLTFX.dwZSrcConst);
+	alphaEdgeBlendBitDepth(someDDBLTFX.dwAlphaEdgeBlendBitDepth);
+	alphaEdgeBlend(someDDBLTFX.dwAlphaEdgeBlend);
+	alphaDestConstBitDepth(someDDBLTFX.dwAlphaDestConstBitDepth);
+	alphaDestConst(someDDBLTFX.dwAlphaDestConst);
+	alphaSrcConstBitDepth(someDDBLTFX.dwAlphaSrcConstBitDepth);
+	alphaSrcConst(someDDBLTFX.dwAlphaSrcConst);
+	fillColor(someDDBLTFX.dwFillColor);
+	ckDestColorKey(someDDBLTFX.ddckDestColorkey);
+	ckSrcColorKey(someDDBLTFX.ddckDestColorkey);
+	return *this;
+}
+
+inline
+DWORD BltEffects::ddFx(void)const
+{
+  return DDBLTFX::dwDDFX;
+}
+
+inline
+void BltEffects::ddFx(DWORD ddFx)
+{
+  DDBLTFX::dwDDFX=ddFx;
+}
+
+inline
+DWORD BltEffects::rop(void)const
+{
+  return DDBLTFX::dwROP;
+}
+
+inline
+void BltEffects::rop(DWORD rop)
+{
+  DDBLTFX::dwROP=rop;
+}
+
+inline
+DWORD BltEffects::ddRop(void)const
+{
+  return DDBLTFX::dwDDROP;
+}
+	
+inline
+void BltEffects::ddRop(DWORD ddRop)
+{
+  DDBLTFX::dwDDROP=ddRop;
+}
+
+inline
+DWORD BltEffects::rotationAngle(void)const
+{
+  return DDBLTFX::dwRotationAngle;
+}
+
+inline
+void BltEffects::rotationAngle(DWORD rotationAngle)
+{
+  DDBLTFX::dwRotationAngle=rotationAngle;
+}
+
+inline
+DWORD BltEffects::zBufferOpCode(void)const
+{
+  return DDBLTFX::dwZBufferOpCode;
+}
+
+inline
+void BltEffects::zBufferOpCode(DWORD zBufferOpCode)
+{
+  DDBLTFX::dwZBufferOpCode=zBufferOpCode;
+}
+
+inline
+DWORD BltEffects::zBufferLow(void)const
+{
+  return DDBLTFX::dwZBufferLow;
+}
+
+inline
+void BltEffects::zBufferLow(DWORD zBufferLow)
+{
+  DDBLTFX::dwZBufferLow=zBufferLow;
+}
+
+inline
+DWORD BltEffects::zBufferHigh(void)const
+{
+  return DDBLTFX::dwZBufferHigh;
+}
+
+inline
+void BltEffects::zBufferHigh(DWORD zBufferHigh)
+{
+  DDBLTFX::dwZBufferHigh=zBufferHigh;
+}
+
+inline
+DWORD BltEffects::zBufferBaseDest(void)const
+{
+  return DDBLTFX::dwZBufferBaseDest;
+}
+
+inline
+void BltEffects::zBufferBaseDest(DWORD zBufferBaseDest)
+{
+  DDBLTFX::dwZBufferBaseDest=zBufferBaseDest;
+}
+
+inline
+DWORD BltEffects::zDestConstBitDepth(void)const
+{
+  return DDBLTFX::dwZDestConstBitDepth; 
+}
+
+inline
+void BltEffects::zDestConstBitDepth(DWORD zDestConstBitDepth)
+{
+  DDBLTFX::dwZDestConstBitDepth=zDestConstBitDepth;
+}
+
+inline
+DWORD BltEffects::zDestConst(void)const
+{
+  return DDBLTFX::dwZDestConst;
+}
+
+inline
+void BltEffects::zDestConst(DWORD zDestConst)
+{
+  DDBLTFX::dwZDestConst=zDestConst;
+}
+
+inline
+LPDIRECTDRAWSURFACE BltEffects::szBufferDest(void)
+{
+  return DDBLTFX::lpDDSZBufferDest;
+}
+
+inline
+void BltEffects::szBufferDest(LPDIRECTDRAWSURFACE lpDirectDrawSurface)
+{
+  DDBLTFX::lpDDSZBufferDest=lpDirectDrawSurface;
+}
+
+inline
+DWORD BltEffects::zSrcConstBitDepth(void)const
+{
+  return DDBLTFX::dwZSrcConstBitDepth;
+}
+
+inline
+void BltEffects::zSrcConstBitDepth(DWORD zSrcConstBitDepth)
+{
+  DDBLTFX::dwZSrcConstBitDepth=zSrcConstBitDepth;
+}
+
+inline
+DWORD BltEffects::zSrcConst(void)const
+{
+  return DDBLTFX::dwZSrcConst;
+}
+
+inline
+void BltEffects::zSrcConst(DWORD zSrcConst)
+{
+  DDBLTFX::dwZSrcConst;
+}
+
+inline
+LPDIRECTDRAWSURFACE BltEffects::szBufferSrc(void)
+{
+  return DDBLTFX::lpDDSZBufferSrc;
+}
+
+inline
+void BltEffects::szBufferSrc(LPDIRECTDRAWSURFACE lpDirectDrawSurface)
+{
+  DDBLTFX::lpDDSZBufferSrc=lpDirectDrawSurface;
+}
+
+inline
+DWORD BltEffects::alphaEdgeBlendBitDepth(void)const
+{
+  return DDBLTFX::dwAlphaEdgeBlendBitDepth;
+}
+
+inline
+void BltEffects::alphaEdgeBlendBitDepth(DWORD alphaEdgeBlendBitDepth)
+{
+  DDBLTFX::dwAlphaEdgeBlendBitDepth=alphaEdgeBlendBitDepth;
+}
+
+inline
+DWORD BltEffects::alphaEdgeBlend(void)const
+{
+  return DDBLTFX::dwAlphaEdgeBlend;
+}
+
+inline
+void BltEffects::alphaEdgeBlend(DWORD alphaEdgeBlend)
+{
+  DDBLTFX::dwAlphaEdgeBlend=alphaEdgeBlend;
+}
+
+inline
+DWORD BltEffects::alphaDestConstBitDepth(void)const
+{
+  return DDBLTFX::dwAlphaDestConstBitDepth;
+}
+
+inline
+void BltEffects::alphaDestConstBitDepth(DWORD alphaDestConstBitDepth)
+{
+  DDBLTFX::dwAlphaDestConstBitDepth=alphaDestConstBitDepth;
+}
+
+inline
+DWORD BltEffects::alphaDestConst(void)const
+{
+  return DDBLTFX::dwAlphaDestConst;
+}
+
+inline
+void BltEffects::alphaDestConst(DWORD alphaDestConst)
+{
+  DDBLTFX::dwAlphaDestConst=alphaDestConst;
+}
+
+inline
+LPDIRECTDRAWSURFACE BltEffects::lpAlphaDest(void)
+{
+  return DDBLTFX::lpDDSAlphaDest;
+}
+
+inline
+void BltEffects::lpAlphaDest(LPDIRECTDRAWSURFACE lpAlphaConst)
+{
+  DDBLTFX::lpDDSAlphaDest=lpAlphaConst;
+}
+
+inline
+DWORD BltEffects::alphaSrcConstBitDepth(void)const
+{
+  return DDBLTFX::dwAlphaSrcConstBitDepth;
+}
+
+inline
+void BltEffects::alphaSrcConstBitDepth(DWORD alphaSrcConstBitDepth)
+{
+  DDBLTFX::dwAlphaSrcConstBitDepth=alphaSrcConstBitDepth;
+}
+
+inline
+DWORD BltEffects::alphaSrcConst(void)const
+{
+  return DDBLTFX::dwAlphaSrcConst;
+}
+
+inline
+void BltEffects::alphaSrcConst(DWORD alphaSrcConst)
+{
+  DDBLTFX::dwAlphaSrcConst=alphaSrcConst;
+}
+
+inline
+LPDIRECTDRAWSURFACE BltEffects::alphaSrc(void)
+{
+  return DDBLTFX::lpDDSAlphaSrc;
+}
+
+inline
+void BltEffects::alphaSrc(LPDIRECTDRAWSURFACE alphaSrc)
+{
+  DDBLTFX::lpDDSAlphaSrc=alphaSrc;
+}
+
+inline
+DWORD BltEffects::fillColor(void)const
+{
+  return DDBLTFX::dwFillColor;
+}
+
+inline
+void BltEffects::fillColor(DWORD fillColor)
+{
+  DDBLTFX::dwFillColor=fillColor;
+}
+
+inline
+DWORD BltEffects::fillDepth(void)const
+{
+  return DDBLTFX::dwFillDepth;
+}
+
+inline
+void BltEffects::fillDepth(DWORD fillDepth)
+{
+  DDBLTFX::dwFillDepth=fillDepth;
+}
+
+inline
+DWORD BltEffects::fillPixel(void)const
+{
+  return DDBLTFX::dwFillPixel;
+}
+
+inline
+void BltEffects::fillPixel(DWORD fillPixel)
+{
+  DDBLTFX::dwFillPixel=fillPixel;
+}
+
+inline
+LPDIRECTDRAWSURFACE BltEffects::ddsPattern(void)
+{
+  return DDBLTFX::lpDDSPattern;
+}
+
+inline
+void BltEffects::ddsPattern(LPDIRECTDRAWSURFACE ddsPattern)
+{
+  DDBLTFX::lpDDSPattern=ddsPattern;
+}
+
+inline
+const DDCOLORKEY &BltEffects::ckDestColorKey(void)const
+{
+  return DDBLTFX::ddckDestColorkey;
+}
+
+inline
+void BltEffects::ckDestColorKey(const DDCOLORKEY &ckDestColorKey)
+{
+  DDBLTFX::ddckDestColorkey=ckDestColorKey;
+}
+
+inline
+const DDCOLORKEY &BltEffects::ckSrcColorKey(void)const
+{
+  return DDBLTFX::ddckSrcColorkey;
+}
+
+inline
+void BltEffects::ckSrcColorKey(const DDCOLORKEY &ckSrcColorKey)
+{
+  DDBLTFX::ddckSrcColorkey=ckSrcColorKey;
+}
+
+inline
+DDBLTFX &BltEffects::getDDBLTFX(void)
+{
+  return (DDBLTFX&)*this;
+}
+
+inline
+void BltEffects::zeroInit(void)
+{
+  ::memset(&getDDBLTFX(),0,sizeof(DDBLTFX));
+  DDBLTFX::dwSize=sizeof(DDBLTFX); 
+}
+#endif

ddraw/DDRAW.BAK

@@ -0,0 +1,873 @@
+# Microsoft Developer Studio Generated NMAKE File, Format Version 4.20
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+
+!IF "$(CFG)" == ""
+CFG=ddraw - Win32 Debug
+!MESSAGE No configuration specified.  Defaulting to ddraw - Win32 Debug.
+!ENDIF 
+
+!IF "$(CFG)" != "ddraw - Win32 Release" && "$(CFG)" != "ddraw - Win32 Debug"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE on this makefile
+!MESSAGE by defining the macro CFG on the command line.  For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "ddraw.mak" CFG="ddraw - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "ddraw - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "ddraw - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE 
+NULL=nul
+!ENDIF 
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "ddraw - Win32 Debug"
+CPP=cl.exe
+RSC=rc.exe
+MTL=mktyplib.exe
+
+!IF  "$(CFG)" == "ddraw - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+OUTDIR=.\Release
+INTDIR=.\Release
+
+ALL : "$(OUTDIR)\ddraw.exe"
+
+CLEAN : 
+	-@erase "$(INTDIR)\devenum.obj"
+	-@erase "$(INTDIR)\direct3d.obj"
+	-@erase "$(INTDIR)\draw.obj"
+	-@erase "$(INTDIR)\drawsfc.obj"
+	-@erase "$(INTDIR)\dspenum.obj"
+	-@erase "$(INTDIR)\Main.obj"
+	-@erase "$(INTDIR)\Mainwnd.obj"
+	-@erase "$(INTDIR)\palette.obj"
+	-@erase "$(INTDIR)\texture.obj"
+	-@erase "$(OUTDIR)\ddraw.exe"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+CPP_PROJ=/nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS"\
+ /Fp"$(INTDIR)/ddraw.pch" /YX /Fo"$(INTDIR)/" /c 
+CPP_OBJS=.\Release/
+CPP_SBRS=.\.
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /win32
+MTL_PROJ=/nologo /D "NDEBUG" /win32 
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/ddraw.bsc" 
+BSC32_SBRS= \
+	
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\
+ odbccp32.lib /nologo /subsystem:windows /incremental:no\
+ /pdb:"$(OUTDIR)/ddraw.pdb" /machine:I386 /out:"$(OUTDIR)/ddraw.exe" 
+LINK32_OBJS= \
+	"$(INTDIR)\devenum.obj" \
+	"$(INTDIR)\direct3d.obj" \
+	"$(INTDIR)\draw.obj" \
+	"$(INTDIR)\drawsfc.obj" \
+	"$(INTDIR)\dspenum.obj" \
+	"$(INTDIR)\Main.obj" \
+	"$(INTDIR)\Mainwnd.obj" \
+	"$(INTDIR)\palette.obj" \
+	"$(INTDIR)\texture.obj" \
+	"..\Exe\mscommon.lib" \
+	"..\Exe\msengine.lib"
+
+"$(OUTDIR)\ddraw.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "ddraw - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "msvcobj"
+# PROP Intermediate_Dir "msvcobj"
+# PROP Target_Dir ""
+OUTDIR=.\msvcobj
+INTDIR=.\msvcobj
+
+ALL : "$(OUTDIR)\ddraw.exe"
+
+CLEAN : 
+	-@erase "$(INTDIR)\devenum.obj"
+	-@erase "$(INTDIR)\direct3d.obj"
+	-@erase "$(INTDIR)\draw.obj"
+	-@erase "$(INTDIR)\drawsfc.obj"
+	-@erase "$(INTDIR)\dspenum.obj"
+	-@erase "$(INTDIR)\Main.obj"
+	-@erase "$(INTDIR)\Mainwnd.obj"
+	-@erase "$(INTDIR)\palette.obj"
+	-@erase "$(INTDIR)\texture.obj"
+	-@erase "$(INTDIR)\Tmap32.obj"
+	-@erase "$(INTDIR)\vc40.idb"
+	-@erase "$(INTDIR)\vc40.pdb"
+	-@erase "$(OUTDIR)\ddraw.exe"
+	-@erase "$(OUTDIR)\ddraw.ilk"
+	-@erase "$(OUTDIR)\ddraw.pdb"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /Zp1 /MTd /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /YX /c
+CPP_PROJ=/nologo /Zp1 /MTd /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS"\
+ /D "STRICT" /D "__FLAT__" /Fp"$(INTDIR)/ddraw.pch" /YX /Fo"$(INTDIR)/"\
+ /Fd"$(INTDIR)/" /c 
+CPP_OBJS=.\msvcobj/
+CPP_SBRS=.\.
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /win32
+MTL_PROJ=/nologo /D "_DEBUG" /win32 
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/ddraw.bsc" 
+BSC32_SBRS= \
+	
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib ddraw.lib dxguid.lib /nologo /subsystem:windows /debug /machine:I386
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib ddraw.lib dxguid.lib\
+ /nologo /subsystem:windows /incremental:yes /pdb:"$(OUTDIR)/ddraw.pdb" /debug\
+ /machine:I386 /out:"$(OUTDIR)/ddraw.exe" 
+LINK32_OBJS= \
+	"$(INTDIR)\devenum.obj" \
+	"$(INTDIR)\direct3d.obj" \
+	"$(INTDIR)\draw.obj" \
+	"$(INTDIR)\drawsfc.obj" \
+	"$(INTDIR)\dspenum.obj" \
+	"$(INTDIR)\Main.obj" \
+	"$(INTDIR)\Mainwnd.obj" \
+	"$(INTDIR)\palette.obj" \
+	"$(INTDIR)\texture.obj" \
+	"$(INTDIR)\Tmap32.obj" \
+	"..\Exe\mscommon.lib" \
+	"..\Exe\msengine.lib"
+
+"$(OUTDIR)\ddraw.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ENDIF 
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+################################################################################
+# Begin Target
+
+# Name "ddraw - Win32 Release"
+# Name "ddraw - Win32 Debug"
+
+!IF  "$(CFG)" == "ddraw - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "ddraw - Win32 Debug"
+
+!ENDIF 
+
+################################################################################
+# Begin Source File
+
+SOURCE=.\Main.cpp
+
+!IF  "$(CFG)" == "ddraw - Win32 Release"
+
+DEP_CPP_MAIN_=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\Ddraw.hpp"\
+	{$(INCLUDE)}"\.\device3d.hpp"\
+	{$(INCLUDE)}"\.\direct3d.hpp"\
+	{$(INCLUDE)}"\.\drawsfc.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\mainwnd.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\rowinfo.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\common\array.hpp"\
+	{$(INCLUDE)}"\Common\Assert.hpp"\
+	{$(INCLUDE)}"\Common\Bitmap.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Bmdata.hpp"\
+	{$(INCLUDE)}"\Common\Bminfo.hpp"\
+	{$(INCLUDE)}"\Common\Boverlay.hpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\Common\Dib.hpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Palentry.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Pen.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Pointer.hpp"\
+	{$(INCLUDE)}"\Common\Purebmp.hpp"\
+	{$(INCLUDE)}"\Common\Purehdc.hpp"\
+	{$(INCLUDE)}"\Common\Purepal.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Rgbquad.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Window.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\Main.obj" : $(SOURCE) $(DEP_CPP_MAIN_) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "ddraw - Win32 Debug"
+
+DEP_CPP_MAIN_=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\Ddraw.hpp"\
+	{$(INCLUDE)}"\.\device3d.hpp"\
+	{$(INCLUDE)}"\.\direct3d.hpp"\
+	{$(INCLUDE)}"\.\drawsfc.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\mainwnd.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\rowinfo.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\common\array.hpp"\
+	{$(INCLUDE)}"\Common\Assert.hpp"\
+	{$(INCLUDE)}"\Common\Bitmap.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Bmdata.hpp"\
+	{$(INCLUDE)}"\Common\Bminfo.hpp"\
+	{$(INCLUDE)}"\Common\Boverlay.hpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\Common\Dib.hpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Palentry.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Pen.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Pointer.hpp"\
+	{$(INCLUDE)}"\Common\Purebmp.hpp"\
+	{$(INCLUDE)}"\Common\Purehdc.hpp"\
+	{$(INCLUDE)}"\Common\Purepal.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Rgbquad.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Window.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\Main.obj" : $(SOURCE) $(DEP_CPP_MAIN_) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\devenum.cpp
+DEP_CPP_DEVEN=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\Ddraw.hpp"\
+	{$(INCLUDE)}"\.\devdesc.hpp"\
+	{$(INCLUDE)}"\.\devenum.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\devenum.obj" : $(SOURCE) $(DEP_CPP_DEVEN) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Mainwnd.cpp
+DEP_CPP_MAINW=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\Ddraw.hpp"\
+	{$(INCLUDE)}"\.\device3d.hpp"\
+	{$(INCLUDE)}"\.\direct3d.hpp"\
+	{$(INCLUDE)}"\.\draw.hpp"\
+	{$(INCLUDE)}"\.\drawsfc.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\mainwnd.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\rowinfo.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\.\texture.hpp"\
+	{$(INCLUDE)}"\common\array.hpp"\
+	{$(INCLUDE)}"\Common\Assert.hpp"\
+	{$(INCLUDE)}"\Common\Bitmap.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Bmdata.hpp"\
+	{$(INCLUDE)}"\Common\Bminfo.hpp"\
+	{$(INCLUDE)}"\Common\Boverlay.hpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\Common\Dib.hpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Keydata.hpp"\
+	{$(INCLUDE)}"\Common\Math.hpp"\
+	{$(INCLUDE)}"\Common\Palentry.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Pen.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Pointer.hpp"\
+	{$(INCLUDE)}"\Common\Purebmp.hpp"\
+	{$(INCLUDE)}"\Common\Purehdc.hpp"\
+	{$(INCLUDE)}"\Common\Purepal.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Rgbquad.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vector2d.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Window.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\Engine\angle.hpp"\
+	{$(INCLUDE)}"\Engine\angle3d.hpp"\
+	{$(INCLUDE)}"\Engine\Asmutil.hpp"\
+	{$(INCLUDE)}"\Engine\Device3d.hpp"\
+	{$(INCLUDE)}"\Engine\Point3d.hpp"\
+	{$(INCLUDE)}"\Engine\Pureedge.hpp"\
+	{$(INCLUDE)}"\Engine\Puremap.hpp"\
+	{$(INCLUDE)}"\Engine\Purevsys.hpp"\
+	{$(INCLUDE)}"\Engine\Texture.hpp"\
+	{$(INCLUDE)}"\Engine\Vector3d.hpp"\
+	{$(INCLUDE)}"\Engine\Viewsys.hpp"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\Mainwnd.obj" : $(SOURCE) $(DEP_CPP_MAINW) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=\Work\Exe\mscommon.lib
+
+!IF  "$(CFG)" == "ddraw - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "ddraw - Win32 Debug"
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\dspenum.cpp
+DEP_CPP_DSPEN=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\Ddraw.hpp"\
+	{$(INCLUDE)}"\.\dspenum.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\dspenum.obj" : $(SOURCE) $(DEP_CPP_DSPEN) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\draw.cpp
+DEP_CPP_DRAW_=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\Ddraw.hpp"\
+	{$(INCLUDE)}"\.\devdesc.hpp"\
+	{$(INCLUDE)}"\.\devenum.hpp"\
+	{$(INCLUDE)}"\.\device3d.hpp"\
+	{$(INCLUDE)}"\.\direct3d.hpp"\
+	{$(INCLUDE)}"\.\draw.hpp"\
+	{$(INCLUDE)}"\.\dspenum.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Palentry.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Pointer.hpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\draw.obj" : $(SOURCE) $(DEP_CPP_DRAW_) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\direct3d.cpp
+DEP_CPP_DIREC=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\Ddraw.hpp"\
+	{$(INCLUDE)}"\.\devdesc.hpp"\
+	{$(INCLUDE)}"\.\devenum.hpp"\
+	{$(INCLUDE)}"\.\device3d.hpp"\
+	{$(INCLUDE)}"\.\direct3d.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Palentry.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Pointer.hpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\direct3d.obj" : $(SOURCE) $(DEP_CPP_DIREC) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\palette.cpp
+DEP_CPP_PALET=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\Ddraw.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Filetime.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Openfile.hpp"\
+	{$(INCLUDE)}"\common\overlap.hpp"\
+	{$(INCLUDE)}"\Common\Palentry.hpp"\
+	{$(INCLUDE)}"\Common\Pen.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Pointer.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Purehdc.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Systime.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\palette.obj" : $(SOURCE) $(DEP_CPP_PALET) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\drawsfc.cpp
+DEP_CPP_DRAWS=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\Ddraw.hpp"\
+	{$(INCLUDE)}"\.\drawsfc.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\rowinfo.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Math.hpp"\
+	{$(INCLUDE)}"\Common\Palentry.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Pointer.hpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\drawsfc.obj" : $(SOURCE) $(DEP_CPP_DRAWS) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Tmap32.asm
+
+!IF  "$(CFG)" == "ddraw - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "ddraw - Win32 Debug"
+
+# Begin Custom Build
+IntDir=.\msvcobj
+InputPath=.\Tmap32.asm
+InputName=Tmap32
+
+"$(IntDir)\$(InputName).obj" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   tasm32 /zi  /c  /ml  /m3 $(InputName).asm $(IntDir)\$(InputName).obj
+
+# End Custom Build
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\texture.cpp
+
+!IF  "$(CFG)" == "ddraw - Win32 Release"
+
+DEP_CPP_TEXTU=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\Ddraw.hpp"\
+	{$(INCLUDE)}"\.\drawsfc.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\rowinfo.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\.\texture.hpp"\
+	{$(INCLUDE)}"\common\array.hpp"\
+	{$(INCLUDE)}"\Common\Assert.hpp"\
+	{$(INCLUDE)}"\Common\Bitmap.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Bmdata.hpp"\
+	{$(INCLUDE)}"\Common\Bminfo.hpp"\
+	{$(INCLUDE)}"\Common\Boverlay.hpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Math.hpp"\
+	{$(INCLUDE)}"\Common\Palentry.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Pen.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Pointer.hpp"\
+	{$(INCLUDE)}"\Common\Purebmp.hpp"\
+	{$(INCLUDE)}"\Common\Purehdc.hpp"\
+	{$(INCLUDE)}"\Common\Purepal.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Rgbquad.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vector2d.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Window.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\Engine\angle.hpp"\
+	{$(INCLUDE)}"\Engine\angle3d.hpp"\
+	{$(INCLUDE)}"\Engine\Device3d.hpp"\
+	{$(INCLUDE)}"\Engine\Point3d.hpp"\
+	{$(INCLUDE)}"\Engine\Pureedge.hpp"\
+	{$(INCLUDE)}"\Engine\Puremap.hpp"\
+	{$(INCLUDE)}"\Engine\Purevsys.hpp"\
+	{$(INCLUDE)}"\Engine\Vector3d.hpp"\
+	{$(INCLUDE)}"\Engine\Viewsys.hpp"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\texture.obj" : $(SOURCE) $(DEP_CPP_TEXTU) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "ddraw - Win32 Debug"
+
+DEP_CPP_TEXTU=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\Ddraw.hpp"\
+	{$(INCLUDE)}"\.\drawsfc.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\rowinfo.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\.\texture.hpp"\
+	{$(INCLUDE)}"\common\array.hpp"\
+	{$(INCLUDE)}"\Common\Assert.hpp"\
+	{$(INCLUDE)}"\Common\Bitmap.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Bmdata.hpp"\
+	{$(INCLUDE)}"\Common\Bminfo.hpp"\
+	{$(INCLUDE)}"\Common\Boverlay.hpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Math.hpp"\
+	{$(INCLUDE)}"\Common\Palentry.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Pen.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Pointer.hpp"\
+	{$(INCLUDE)}"\Common\Purebmp.hpp"\
+	{$(INCLUDE)}"\Common\Purehdc.hpp"\
+	{$(INCLUDE)}"\Common\Purepal.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Rgbquad.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vector2d.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Window.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\Engine\angle.hpp"\
+	{$(INCLUDE)}"\Engine\angle3d.hpp"\
+	{$(INCLUDE)}"\Engine\Device3d.hpp"\
+	{$(INCLUDE)}"\Engine\Point3d.hpp"\
+	{$(INCLUDE)}"\Engine\Pureedge.hpp"\
+	{$(INCLUDE)}"\Engine\Puremap.hpp"\
+	{$(INCLUDE)}"\Engine\Purevsys.hpp"\
+	{$(INCLUDE)}"\Engine\Vector3d.hpp"\
+	{$(INCLUDE)}"\Engine\Viewsys.hpp"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\texture.obj" : $(SOURCE) $(DEP_CPP_TEXTU) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=\Work\Exe\msengine.lib
+
+!IF  "$(CFG)" == "ddraw - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "ddraw - Win32 Debug"
+
+!ENDIF 
+
+# End Source File
+# End Target
+# End Project
+################################################################################

ddraw/DDRAW.DSW

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

ddraw/DDRAW.HPP

@@ -0,0 +1,5 @@
+#ifndef _DDRAW_DDRAW_HPP_
+#define _DDRAW_DDRAW_HPP_
+#include <mssdk\include\ddraw.h>
+#include <mssdk\include\d3d.h>
+#endif

ddraw/DDRAW.MAK

@@ -0,0 +1,873 @@
+# Microsoft Developer Studio Generated NMAKE File, Format Version 4.20
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+
+!IF "$(CFG)" == ""
+CFG=ddraw - Win32 Debug
+!MESSAGE No configuration specified.  Defaulting to ddraw - Win32 Debug.
+!ENDIF 
+
+!IF "$(CFG)" != "ddraw - Win32 Release" && "$(CFG)" != "ddraw - Win32 Debug"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE on this makefile
+!MESSAGE by defining the macro CFG on the command line.  For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "ddraw.mak" CFG="ddraw - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "ddraw - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "ddraw - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE 
+NULL=nul
+!ENDIF 
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "ddraw - Win32 Debug"
+CPP=cl.exe
+RSC=rc.exe
+MTL=mktyplib.exe
+
+!IF  "$(CFG)" == "ddraw - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+OUTDIR=.\Release
+INTDIR=.\Release
+
+ALL : "$(OUTDIR)\ddraw.exe"
+
+CLEAN : 
+	-@erase "$(INTDIR)\devenum.obj"
+	-@erase "$(INTDIR)\direct3d.obj"
+	-@erase "$(INTDIR)\draw.obj"
+	-@erase "$(INTDIR)\drawsfc.obj"
+	-@erase "$(INTDIR)\dspenum.obj"
+	-@erase "$(INTDIR)\Main.obj"
+	-@erase "$(INTDIR)\Mainwnd.obj"
+	-@erase "$(INTDIR)\palette.obj"
+	-@erase "$(INTDIR)\texture.obj"
+	-@erase "$(OUTDIR)\ddraw.exe"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+CPP_PROJ=/nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS"\
+ /Fp"$(INTDIR)/ddraw.pch" /YX /Fo"$(INTDIR)/" /c 
+CPP_OBJS=.\Release/
+CPP_SBRS=.\.
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /win32
+MTL_PROJ=/nologo /D "NDEBUG" /win32 
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/ddraw.bsc" 
+BSC32_SBRS= \
+	
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\
+ odbccp32.lib /nologo /subsystem:windows /incremental:no\
+ /pdb:"$(OUTDIR)/ddraw.pdb" /machine:I386 /out:"$(OUTDIR)/ddraw.exe" 
+LINK32_OBJS= \
+	"$(INTDIR)\devenum.obj" \
+	"$(INTDIR)\direct3d.obj" \
+	"$(INTDIR)\draw.obj" \
+	"$(INTDIR)\drawsfc.obj" \
+	"$(INTDIR)\dspenum.obj" \
+	"$(INTDIR)\Main.obj" \
+	"$(INTDIR)\Mainwnd.obj" \
+	"$(INTDIR)\palette.obj" \
+	"$(INTDIR)\texture.obj" \
+	"..\Exe\mscommon.lib" \
+	"..\Exe\msengine.lib"
+
+"$(OUTDIR)\ddraw.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "ddraw - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "msvcobj"
+# PROP Intermediate_Dir "msvcobj"
+# PROP Target_Dir ""
+OUTDIR=.\msvcobj
+INTDIR=.\msvcobj
+
+ALL : "$(OUTDIR)\ddraw.exe"
+
+CLEAN : 
+	-@erase "$(INTDIR)\devenum.obj"
+	-@erase "$(INTDIR)\direct3d.obj"
+	-@erase "$(INTDIR)\draw.obj"
+	-@erase "$(INTDIR)\drawsfc.obj"
+	-@erase "$(INTDIR)\dspenum.obj"
+	-@erase "$(INTDIR)\Main.obj"
+	-@erase "$(INTDIR)\Mainwnd.obj"
+	-@erase "$(INTDIR)\palette.obj"
+	-@erase "$(INTDIR)\texture.obj"
+	-@erase "$(INTDIR)\Tmap32.obj"
+	-@erase "$(INTDIR)\vc40.idb"
+	-@erase "$(INTDIR)\vc40.pdb"
+	-@erase "$(OUTDIR)\ddraw.exe"
+	-@erase "$(OUTDIR)\ddraw.ilk"
+	-@erase "$(OUTDIR)\ddraw.pdb"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /Zp1 /MTd /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /YX /c
+CPP_PROJ=/nologo /Zp1 /MTd /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS"\
+ /D "STRICT" /D "__FLAT__" /Fp"$(INTDIR)/ddraw.pch" /YX /Fo"$(INTDIR)/"\
+ /Fd"$(INTDIR)/" /c 
+CPP_OBJS=.\msvcobj/
+CPP_SBRS=.\.
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /win32
+MTL_PROJ=/nologo /D "_DEBUG" /win32 
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/ddraw.bsc" 
+BSC32_SBRS= \
+	
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib ddraw.lib dxguid.lib /nologo /subsystem:windows /debug /machine:I386
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib ddraw.lib dxguid.lib\
+ /nologo /subsystem:windows /incremental:yes /pdb:"$(OUTDIR)/ddraw.pdb" /debug\
+ /machine:I386 /out:"$(OUTDIR)/ddraw.exe" 
+LINK32_OBJS= \
+	"$(INTDIR)\devenum.obj" \
+	"$(INTDIR)\direct3d.obj" \
+	"$(INTDIR)\draw.obj" \
+	"$(INTDIR)\drawsfc.obj" \
+	"$(INTDIR)\dspenum.obj" \
+	"$(INTDIR)\Main.obj" \
+	"$(INTDIR)\Mainwnd.obj" \
+	"$(INTDIR)\palette.obj" \
+	"$(INTDIR)\texture.obj" \
+	"$(INTDIR)\Tmap32.obj" \
+	"..\Exe\mscommon.lib" \
+	"..\Exe\msengine.lib"
+
+"$(OUTDIR)\ddraw.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ENDIF 
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+################################################################################
+# Begin Target
+
+# Name "ddraw - Win32 Release"
+# Name "ddraw - Win32 Debug"
+
+!IF  "$(CFG)" == "ddraw - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "ddraw - Win32 Debug"
+
+!ENDIF 
+
+################################################################################
+# Begin Source File
+
+SOURCE=.\Main.cpp
+
+!IF  "$(CFG)" == "ddraw - Win32 Release"
+
+DEP_CPP_MAIN_=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\Ddraw.hpp"\
+	{$(INCLUDE)}"\.\device3d.hpp"\
+	{$(INCLUDE)}"\.\direct3d.hpp"\
+	{$(INCLUDE)}"\.\drawsfc.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\mainwnd.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\rowinfo.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\common\array.hpp"\
+	{$(INCLUDE)}"\Common\Assert.hpp"\
+	{$(INCLUDE)}"\Common\Bitmap.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Bmdata.hpp"\
+	{$(INCLUDE)}"\Common\Bminfo.hpp"\
+	{$(INCLUDE)}"\Common\Boverlay.hpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\Common\Dib.hpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Palentry.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Pen.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Pointer.hpp"\
+	{$(INCLUDE)}"\Common\Purebmp.hpp"\
+	{$(INCLUDE)}"\Common\Purehdc.hpp"\
+	{$(INCLUDE)}"\Common\Purepal.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Rgbquad.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Window.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\Main.obj" : $(SOURCE) $(DEP_CPP_MAIN_) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "ddraw - Win32 Debug"
+
+DEP_CPP_MAIN_=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\Ddraw.hpp"\
+	{$(INCLUDE)}"\.\device3d.hpp"\
+	{$(INCLUDE)}"\.\direct3d.hpp"\
+	{$(INCLUDE)}"\.\drawsfc.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\mainwnd.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\rowinfo.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\common\array.hpp"\
+	{$(INCLUDE)}"\Common\Assert.hpp"\
+	{$(INCLUDE)}"\Common\Bitmap.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Bmdata.hpp"\
+	{$(INCLUDE)}"\Common\Bminfo.hpp"\
+	{$(INCLUDE)}"\Common\Boverlay.hpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\Common\Dib.hpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Palentry.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Pen.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Pointer.hpp"\
+	{$(INCLUDE)}"\Common\Purebmp.hpp"\
+	{$(INCLUDE)}"\Common\Purehdc.hpp"\
+	{$(INCLUDE)}"\Common\Purepal.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Rgbquad.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Window.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\Main.obj" : $(SOURCE) $(DEP_CPP_MAIN_) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\devenum.cpp
+DEP_CPP_DEVEN=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\Ddraw.hpp"\
+	{$(INCLUDE)}"\.\devdesc.hpp"\
+	{$(INCLUDE)}"\.\devenum.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\devenum.obj" : $(SOURCE) $(DEP_CPP_DEVEN) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Mainwnd.cpp
+DEP_CPP_MAINW=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\Ddraw.hpp"\
+	{$(INCLUDE)}"\.\device3d.hpp"\
+	{$(INCLUDE)}"\.\direct3d.hpp"\
+	{$(INCLUDE)}"\.\draw.hpp"\
+	{$(INCLUDE)}"\.\drawsfc.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\mainwnd.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\rowinfo.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\.\texture.hpp"\
+	{$(INCLUDE)}"\common\array.hpp"\
+	{$(INCLUDE)}"\Common\Assert.hpp"\
+	{$(INCLUDE)}"\Common\Bitmap.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Bmdata.hpp"\
+	{$(INCLUDE)}"\Common\Bminfo.hpp"\
+	{$(INCLUDE)}"\Common\Boverlay.hpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\Common\Dib.hpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Keydata.hpp"\
+	{$(INCLUDE)}"\Common\Math.hpp"\
+	{$(INCLUDE)}"\Common\Palentry.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Pen.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Pointer.hpp"\
+	{$(INCLUDE)}"\Common\Purebmp.hpp"\
+	{$(INCLUDE)}"\Common\Purehdc.hpp"\
+	{$(INCLUDE)}"\Common\Purepal.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Rgbquad.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vector2d.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Window.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\Engine\angle.hpp"\
+	{$(INCLUDE)}"\Engine\angle3d.hpp"\
+	{$(INCLUDE)}"\Engine\Asmutil.hpp"\
+	{$(INCLUDE)}"\Engine\Device3d.hpp"\
+	{$(INCLUDE)}"\Engine\Point3d.hpp"\
+	{$(INCLUDE)}"\Engine\Pureedge.hpp"\
+	{$(INCLUDE)}"\Engine\Puremap.hpp"\
+	{$(INCLUDE)}"\Engine\Purevsys.hpp"\
+	{$(INCLUDE)}"\Engine\Texture.hpp"\
+	{$(INCLUDE)}"\Engine\Vector3d.hpp"\
+	{$(INCLUDE)}"\Engine\Viewsys.hpp"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\Mainwnd.obj" : $(SOURCE) $(DEP_CPP_MAINW) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=\Work\Exe\mscommon.lib
+
+!IF  "$(CFG)" == "ddraw - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "ddraw - Win32 Debug"
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\dspenum.cpp
+DEP_CPP_DSPEN=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\Ddraw.hpp"\
+	{$(INCLUDE)}"\.\dspenum.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\dspenum.obj" : $(SOURCE) $(DEP_CPP_DSPEN) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\draw.cpp
+DEP_CPP_DRAW_=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\Ddraw.hpp"\
+	{$(INCLUDE)}"\.\devdesc.hpp"\
+	{$(INCLUDE)}"\.\devenum.hpp"\
+	{$(INCLUDE)}"\.\device3d.hpp"\
+	{$(INCLUDE)}"\.\direct3d.hpp"\
+	{$(INCLUDE)}"\.\draw.hpp"\
+	{$(INCLUDE)}"\.\dspenum.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Palentry.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Pointer.hpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\draw.obj" : $(SOURCE) $(DEP_CPP_DRAW_) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\direct3d.cpp
+DEP_CPP_DIREC=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\Ddraw.hpp"\
+	{$(INCLUDE)}"\.\devdesc.hpp"\
+	{$(INCLUDE)}"\.\devenum.hpp"\
+	{$(INCLUDE)}"\.\device3d.hpp"\
+	{$(INCLUDE)}"\.\direct3d.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Palentry.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Pointer.hpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\direct3d.obj" : $(SOURCE) $(DEP_CPP_DIREC) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\palette.cpp
+DEP_CPP_PALET=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\Ddraw.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Filetime.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Openfile.hpp"\
+	{$(INCLUDE)}"\common\overlap.hpp"\
+	{$(INCLUDE)}"\Common\Palentry.hpp"\
+	{$(INCLUDE)}"\Common\Pen.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Pointer.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Purehdc.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Systime.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\palette.obj" : $(SOURCE) $(DEP_CPP_PALET) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\drawsfc.cpp
+DEP_CPP_DRAWS=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\Ddraw.hpp"\
+	{$(INCLUDE)}"\.\drawsfc.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\rowinfo.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Math.hpp"\
+	{$(INCLUDE)}"\Common\Palentry.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Pointer.hpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\drawsfc.obj" : $(SOURCE) $(DEP_CPP_DRAWS) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Tmap32.asm
+
+!IF  "$(CFG)" == "ddraw - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "ddraw - Win32 Debug"
+
+# Begin Custom Build
+IntDir=.\msvcobj
+InputPath=.\Tmap32.asm
+InputName=Tmap32
+
+"$(IntDir)\$(InputName).obj" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   tasm32 /zi  /c  /ml  /m3 $(InputName).asm $(IntDir)\$(InputName).obj
+
+# End Custom Build
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\texture.cpp
+
+!IF  "$(CFG)" == "ddraw - Win32 Release"
+
+DEP_CPP_TEXTU=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\Ddraw.hpp"\
+	{$(INCLUDE)}"\.\drawsfc.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\rowinfo.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\.\texture.hpp"\
+	{$(INCLUDE)}"\common\array.hpp"\
+	{$(INCLUDE)}"\Common\Assert.hpp"\
+	{$(INCLUDE)}"\Common\Bitmap.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Bmdata.hpp"\
+	{$(INCLUDE)}"\Common\Bminfo.hpp"\
+	{$(INCLUDE)}"\Common\Boverlay.hpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Math.hpp"\
+	{$(INCLUDE)}"\Common\Palentry.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Pen.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Pointer.hpp"\
+	{$(INCLUDE)}"\Common\Purebmp.hpp"\
+	{$(INCLUDE)}"\Common\Purehdc.hpp"\
+	{$(INCLUDE)}"\Common\Purepal.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Rgbquad.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vector2d.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Window.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\Engine\angle.hpp"\
+	{$(INCLUDE)}"\Engine\angle3d.hpp"\
+	{$(INCLUDE)}"\Engine\Device3d.hpp"\
+	{$(INCLUDE)}"\Engine\Point3d.hpp"\
+	{$(INCLUDE)}"\Engine\Pureedge.hpp"\
+	{$(INCLUDE)}"\Engine\Puremap.hpp"\
+	{$(INCLUDE)}"\Engine\Purevsys.hpp"\
+	{$(INCLUDE)}"\Engine\Vector3d.hpp"\
+	{$(INCLUDE)}"\Engine\Viewsys.hpp"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\texture.obj" : $(SOURCE) $(DEP_CPP_TEXTU) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "ddraw - Win32 Debug"
+
+DEP_CPP_TEXTU=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\Ddraw.hpp"\
+	{$(INCLUDE)}"\.\drawsfc.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\rowinfo.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\.\texture.hpp"\
+	{$(INCLUDE)}"\common\array.hpp"\
+	{$(INCLUDE)}"\Common\Assert.hpp"\
+	{$(INCLUDE)}"\Common\Bitmap.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Bmdata.hpp"\
+	{$(INCLUDE)}"\Common\Bminfo.hpp"\
+	{$(INCLUDE)}"\Common\Boverlay.hpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Math.hpp"\
+	{$(INCLUDE)}"\Common\Palentry.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Pen.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Pointer.hpp"\
+	{$(INCLUDE)}"\Common\Purebmp.hpp"\
+	{$(INCLUDE)}"\Common\Purehdc.hpp"\
+	{$(INCLUDE)}"\Common\Purepal.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Rgbquad.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vector2d.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Window.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\Engine\angle.hpp"\
+	{$(INCLUDE)}"\Engine\angle3d.hpp"\
+	{$(INCLUDE)}"\Engine\Device3d.hpp"\
+	{$(INCLUDE)}"\Engine\Point3d.hpp"\
+	{$(INCLUDE)}"\Engine\Pureedge.hpp"\
+	{$(INCLUDE)}"\Engine\Puremap.hpp"\
+	{$(INCLUDE)}"\Engine\Purevsys.hpp"\
+	{$(INCLUDE)}"\Engine\Vector3d.hpp"\
+	{$(INCLUDE)}"\Engine\Viewsys.hpp"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\texture.obj" : $(SOURCE) $(DEP_CPP_TEXTU) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=\Work\Exe\msengine.lib
+
+!IF  "$(CFG)" == "ddraw - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "ddraw - Win32 Debug"
+
+!ENDIF 
+
+# End Source File
+# End Target
+# End Project
+################################################################################

ddraw/DDRAW.PLG

@@ -0,0 +1,540 @@
+<html>
+<body>
+<pre>
+<h1>Build Log</h1>
+<h3>
+--------------------Configuration: ddraw - Win32 Debug--------------------
+</h3>
+<h3>Command Lines</h3>
+Creating temporary file "C:\WINNT\Profiles\sean\LOCALS~1\Temp\RSP2A.tmp" with contents
+[
+/nologo /Zp1 /MTd /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /Fp".\msvcobj/ddraw.pch" /YX /Fo".\msvcobj/" /Fd".\msvcobj/" /FD /c 
+"D:\work\DDRAW\devenum.cpp"
+"D:\work\DDRAW\direct3d.cpp"
+"D:\work\DDRAW\draw.cpp"
+"D:\work\DDRAW\drawsfc.cpp"
+"D:\work\DDRAW\dspenum.cpp"
+"D:\work\DDRAW\Main.cpp"
+"D:\work\DDRAW\Mainwnd.cpp"
+"D:\work\DDRAW\palette.cpp"
+"D:\work\DDRAW\texture.cpp"
+]
+Creating command line "cl.exe @C:\WINNT\Profiles\sean\LOCALS~1\Temp\RSP2A.tmp" 
+Creating temporary file "C:\WINNT\Profiles\sean\LOCALS~1\Temp\RSP2B.tmp" with contents
+[
+kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib ddraw.lib c:\parts\mssdk\lib\dxguid.lib /nologo /subsystem:windows /incremental:yes /pdb:".\msvcobj/ddraw.pdb" /debug /machine:I386 /out:".\msvcobj/ddraw.exe" 
+.\msvcobj\devenum.obj
+.\msvcobj\direct3d.obj
+.\msvcobj\draw.obj
+.\msvcobj\drawsfc.obj
+.\msvcobj\dspenum.obj
+.\msvcobj\Main.obj
+.\msvcobj\Mainwnd.obj
+.\msvcobj\palette.obj
+.\msvcobj\texture.obj
+..\Exe\mscommon.lib
+..\Exe\msengine.lib
+.\msvcobj\Tmap32.obj
+]
+Creating command line "link.exe @C:\WINNT\Profiles\sean\LOCALS~1\Temp\RSP2B.tmp"
+<h3>Output Window</h3>
+Compiling...
+devenum.cpp
+direct3d.cpp
+d:\work\ddraw\direct3d.hpp(18) : error C2065: 'IDirect3D3' : undeclared identifier
+d:\work\ddraw\direct3d.hpp(19) : fatal error C1903: unable to recover from previous error(s); stopping compilation
+draw.cpp
+d:\work\ddraw\draw.hpp(27) : error C2065: 'DDSCL_MULTITHREADED' : undeclared identifier
+d:\work\ddraw\draw.hpp(27) : error C2057: expected constant expression
+d:\work\ddraw\draw.hpp(28) : error C2065: 'DDSCL_FPUSETUP' : undeclared identifier
+d:\work\ddraw\draw.hpp(28) : error C2057: expected constant expression
+d:\work\ddraw\draw.hpp(51) : error C2065: 'IDirectDraw4' : undeclared identifier
+d:\work\ddraw\draw.hpp(51) : error C2955: 'SmartPointer' : use of class template requires template argument list
+        d:\work\common\pointer.hpp(34) : see declaration of 'SmartPointer'
+d:\work\ddraw\draw.hpp(51) : fatal error C1903: unable to recover from previous error(s); stopping compilation
+drawsfc.cpp
+d:\work\ddraw\pixform.hpp(13) : error C2065: 'DDPF_ALPHAPREMULT' : undeclared identifier
+d:\work\ddraw\pixform.hpp(13) : error C2057: expected constant expression
+d:\work\ddraw\pixform.hpp(14) : error C2065: 'DDPF_BUMPLUMINANCE' : undeclared identifier
+d:\work\ddraw\pixform.hpp(14) : error C2057: expected constant expression
+d:\work\ddraw\pixform.hpp(14) : error C2065: 'DDPF_BUMPDUDV' : undeclared identifier
+d:\work\ddraw\pixform.hpp(14) : error C2057: expected constant expression
+d:\work\ddraw\pixform.hpp(15) : error C2065: 'DDPF_LUMINANCE' : undeclared identifier
+d:\work\ddraw\pixform.hpp(15) : error C2057: expected constant expression
+d:\work\ddraw\pixform.hpp(18) : error C2065: 'DDPF_STENCILBUFFER' : undeclared identifier
+d:\work\ddraw\pixform.hpp(18) : error C2057: expected constant expression
+d:\work\ddraw\pixform.hpp(214) : error C2039: 'dwLuminanceBitCount' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(214) : error C2065: 'dwLuminanceBitCount' : undeclared identifier
+d:\work\ddraw\pixform.hpp(220) : error C2039: 'dwLuminanceBitCount' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(226) : error C2039: 'dwBumpBitCount' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(226) : error C2065: 'dwBumpBitCount' : undeclared identifier
+d:\work\ddraw\pixform.hpp(232) : error C2039: 'dwBumpBitCount' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(286) : error C2039: 'dwZBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(286) : error C2065: 'dwZBitMask' : undeclared identifier
+d:\work\ddraw\pixform.hpp(292) : error C2039: 'dwZBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(322) : error C2039: 'dwStencilBitDepth' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(322) : error C2065: 'dwStencilBitDepth' : undeclared identifier
+d:\work\ddraw\pixform.hpp(328) : error C2039: 'dwStencilBitDepth' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(334) : error C2039: 'dwLuminanceBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(334) : error C2065: 'dwLuminanceBitMask' : undeclared identifier
+d:\work\ddraw\pixform.hpp(340) : error C2039: 'dwLuminanceBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(346) : error C2039: 'dwBumpDuBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(346) : error C2065: 'dwBumpDuBitMask' : undeclared identifier
+d:\work\ddraw\pixform.hpp(352) : error C2039: 'dwBumpDuBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(358) : error C2039: 'dwBumpDvBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(358) : error C2065: 'dwBumpDvBitMask' : undeclared identifier
+d:\work\ddraw\pixform.hpp(364) : error C2039: 'dwBumpDvBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(370) : error C2039: 'dwStencilBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(370) : error C2065: 'dwStencilBitMask' : undeclared identifier
+d:\work\ddraw\pixform.hpp(376) : error C2039: 'dwStencilBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(382) : error C2039: 'dwBumpLuminanceBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(382) : error C2065: 'dwBumpLuminanceBitMask' : undeclared identifier
+d:\work\ddraw\pixform.hpp(388) : error C2039: 'dwBumpLuminanceBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(418) : error C2039: 'dwLuminanceAlphaBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(418) : error C2065: 'dwLuminanceAlphaBitMask' : undeclared identifier
+d:\work\ddraw\pixform.hpp(424) : error C2039: 'dwLuminanceAlphaBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\sfccaps.hpp(8) : error C2504: 'DDSCAPS2' : base class undefined
+d:\work\ddraw\sfccaps.hpp(19) : error C2065: 'DDSCAPS2_HARDWAREDEINTERLACE' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(19) : error C2057: expected constant expression
+d:\work\ddraw\sfccaps.hpp(20) : error C2065: 'DDSCAPS2_HINTANTIALIASING' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(20) : error C2057: expected constant expression
+d:\work\ddraw\sfccaps.hpp(20) : error C2065: 'DDSCAPS2_HINTDYNAMIC' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(20) : error C2057: expected constant expression
+d:\work\ddraw\sfccaps.hpp(21) : error C2065: 'DDSCAPS2_HINTSTATIC' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(21) : error C2057: expected constant expression
+d:\work\ddraw\sfccaps.hpp(21) : error C2065: 'DDSCAPS2_OPAQUE' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(21) : error C2057: expected constant expression
+d:\work\ddraw\sfccaps.hpp(21) : error C2065: 'DDSCAPS2_TEXTUREMANAGE' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(21) : error C2057: expected constant expression
+d:\work\ddraw\sfccaps.hpp(24) : error C2629: unexpected 'class SurfaceCapabilities ('
+d:\work\ddraw\sfccaps.hpp(24) : error C2238: unexpected token(s) preceding ';'
+d:\work\ddraw\sfccaps.hpp(28) : error C2143: syntax error : missing ',' before '&'
+d:\work\ddraw\sfccaps.hpp(28) : error C2059: syntax error : '&'
+d:\work\ddraw\sfccaps.hpp(33) : error C2143: syntax error : missing ';' before '&'
+d:\work\ddraw\sfccaps.hpp(33) : error C2501: 'DDSCAPS2' : missing storage-class or type specifiers
+d:\work\ddraw\sfccaps.hpp(33) : error C2501: 'getDDSCAPS2' : missing storage-class or type specifiers
+d:\work\ddraw\sfccaps.hpp(40) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(40) : error C2065: 'dwCaps' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(41) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(41) : error C2065: 'dwCaps2' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(42) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(42) : error C2065: 'dwCaps3' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(43) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(43) : error C2065: 'dwCaps4' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(55) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(56) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(57) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(58) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(62) : error C2143: syntax error : missing ',' before '&'
+d:\work\ddraw\sfccaps.hpp(62) : error C2059: syntax error : '&'
+d:\work\ddraw\sfccaps.hpp(63) : error C2511: 'SurfaceCapabilities::SurfaceCapabilities' : overloaded member function 'void (const int)' not found in 'SurfaceCapabilities'
+        d:\work\ddraw\sfccaps.hpp(7) : see declaration of 'SurfaceCapabilities'
+d:\work\ddraw\sfccaps.hpp(81) : error C2143: syntax error : missing ',' before '&'
+d:\work\ddraw\sfccaps.hpp(81) : error C2059: syntax error : '&'
+d:\work\ddraw\sfccaps.hpp(83) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(83) : error C2065: 'someDDSCAPS2' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(83) : error C2228: left of '.dwCaps' must have class/struct/union type
+d:\work\ddraw\sfccaps.hpp(84) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(84) : error C2228: left of '.dwCaps2' must have class/struct/union type
+d:\work\ddraw\sfccaps.hpp(85) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(85) : error C2228: left of '.dwCaps3' must have class/struct/union type
+d:\work\ddraw\sfccaps.hpp(86) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(86) : error C2228: left of '.dwCaps4' must have class/struct/union type
+d:\work\ddraw\sfccaps.hpp(93) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(99) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(105) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(111) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(115) : error C2143: syntax error : missing ';' before '&'
+d:\work\ddraw\sfccaps.hpp(115) : error C2433: 'DDSCAPS2' : 'inline' not permitted on data declarations
+d:\work\ddraw\sfccaps.hpp(115) : error C2501: 'DDSCAPS2' : missing storage-class or type specifiers
+d:\work\ddraw\sfccaps.hpp(116) : error C2501: 'getDDSCAPS2' : missing storage-class or type specifiers
+d:\work\ddraw\sfccaps.hpp(117) : error C2059: syntax error : ')'
+d:\work\ddraw\sfcdesc.hpp(11) : error C2504: 'DDSURFACEDESC2' : base class undefined
+d:\work\ddraw\sfcdesc.hpp(18) : error C2065: 'DDSD_TEXTURESTAGE' : undeclared identifier
+d:\work\ddraw\sfcdesc.hpp(18) : error C2057: expected constant expression
+d:\work\ddraw\sfcdesc.hpp(21) : error C2629: unexpected 'class SurfaceDescription ('
+d:\work\ddraw\sfcdesc.hpp(21) : error C2238: unexpected token(s) preceding ';'
+d:\work\ddraw\sfcdesc.hpp(24) : error C2143: syntax error : missing ',' before '&'
+d:\work\ddraw\sfcdesc.hpp(24) : fatal error C1003: error count exceeds 100; stopping compilation
+dspenum.cpp
+d:\work\ddraw\sfccaps.hpp(8) : error C2504: 'DDSCAPS2' : base class undefined
+d:\work\ddraw\sfccaps.hpp(19) : error C2065: 'DDSCAPS2_HARDWAREDEINTERLACE' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(19) : error C2057: expected constant expression
+d:\work\ddraw\sfccaps.hpp(20) : error C2065: 'DDSCAPS2_HINTANTIALIASING' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(20) : error C2057: expected constant expression
+d:\work\ddraw\sfccaps.hpp(20) : error C2065: 'DDSCAPS2_HINTDYNAMIC' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(20) : error C2057: expected constant expression
+d:\work\ddraw\sfccaps.hpp(21) : error C2065: 'DDSCAPS2_HINTSTATIC' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(21) : error C2057: expected constant expression
+d:\work\ddraw\sfccaps.hpp(21) : error C2065: 'DDSCAPS2_OPAQUE' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(21) : error C2057: expected constant expression
+d:\work\ddraw\sfccaps.hpp(21) : error C2065: 'DDSCAPS2_TEXTUREMANAGE' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(21) : error C2057: expected constant expression
+d:\work\ddraw\sfccaps.hpp(24) : error C2629: unexpected 'class SurfaceCapabilities ('
+d:\work\ddraw\sfccaps.hpp(24) : error C2238: unexpected token(s) preceding ';'
+d:\work\ddraw\sfccaps.hpp(28) : error C2143: syntax error : missing ',' before '&'
+d:\work\ddraw\sfccaps.hpp(28) : error C2059: syntax error : '&'
+d:\work\ddraw\sfccaps.hpp(33) : error C2143: syntax error : missing ';' before '&'
+d:\work\ddraw\sfccaps.hpp(33) : error C2501: 'DDSCAPS2' : missing storage-class or type specifiers
+d:\work\ddraw\sfccaps.hpp(33) : error C2501: 'getDDSCAPS2' : missing storage-class or type specifiers
+d:\work\ddraw\sfccaps.hpp(40) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(40) : error C2065: 'dwCaps' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(41) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(41) : error C2065: 'dwCaps2' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(42) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(42) : error C2065: 'dwCaps3' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(43) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(43) : error C2065: 'dwCaps4' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(55) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(56) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(57) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(58) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(62) : error C2143: syntax error : missing ',' before '&'
+d:\work\ddraw\sfccaps.hpp(62) : error C2059: syntax error : '&'
+d:\work\ddraw\sfccaps.hpp(63) : error C2511: 'SurfaceCapabilities::SurfaceCapabilities' : overloaded member function 'void (const int)' not found in 'SurfaceCapabilities'
+        d:\work\ddraw\sfccaps.hpp(7) : see declaration of 'SurfaceCapabilities'
+d:\work\ddraw\sfccaps.hpp(81) : error C2143: syntax error : missing ',' before '&'
+d:\work\ddraw\sfccaps.hpp(81) : error C2059: syntax error : '&'
+d:\work\ddraw\sfccaps.hpp(83) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(83) : error C2065: 'someDDSCAPS2' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(83) : error C2228: left of '.dwCaps' must have class/struct/union type
+d:\work\ddraw\sfccaps.hpp(84) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(84) : error C2228: left of '.dwCaps2' must have class/struct/union type
+d:\work\ddraw\sfccaps.hpp(85) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(85) : error C2228: left of '.dwCaps3' must have class/struct/union type
+d:\work\ddraw\sfccaps.hpp(86) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(86) : error C2228: left of '.dwCaps4' must have class/struct/union type
+d:\work\ddraw\sfccaps.hpp(93) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(99) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(105) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(111) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(115) : error C2143: syntax error : missing ';' before '&'
+d:\work\ddraw\sfccaps.hpp(115) : error C2433: 'DDSCAPS2' : 'inline' not permitted on data declarations
+d:\work\ddraw\sfccaps.hpp(115) : error C2501: 'DDSCAPS2' : missing storage-class or type specifiers
+d:\work\ddraw\sfccaps.hpp(116) : error C2501: 'getDDSCAPS2' : missing storage-class or type specifiers
+d:\work\ddraw\sfccaps.hpp(117) : error C2059: syntax error : ')'
+d:\work\ddraw\sfcdesc.hpp(11) : error C2504: 'DDSURFACEDESC2' : base class undefined
+d:\work\ddraw\sfcdesc.hpp(18) : error C2065: 'DDSD_TEXTURESTAGE' : undeclared identifier
+d:\work\ddraw\sfcdesc.hpp(18) : error C2057: expected constant expression
+d:\work\ddraw\sfcdesc.hpp(21) : error C2629: unexpected 'class SurfaceDescription ('
+d:\work\ddraw\sfcdesc.hpp(21) : error C2238: unexpected token(s) preceding ';'
+d:\work\ddraw\sfcdesc.hpp(24) : error C2143: syntax error : missing ',' before '&'
+d:\work\ddraw\sfcdesc.hpp(24) : error C2059: syntax error : '&'
+d:\work\ddraw\sfcdesc.hpp(59) : error C2143: syntax error : missing ';' before '&'
+d:\work\ddraw\sfcdesc.hpp(59) : error C2501: 'DDSURFACEDESC2' : missing storage-class or type specifiers
+d:\work\ddraw\sfcdesc.hpp(59) : error C2501: 'getDDSURFACEDESC2' : missing storage-class or type specifiers
+d:\work\ddraw\sfcdesc.hpp(77) : error C2143: syntax error : missing ',' before '&'
+d:\work\ddraw\sfcdesc.hpp(77) : error C2059: syntax error : '&'
+d:\work\ddraw\sfcdesc.hpp(78) : error C2511: 'SurfaceDescription::SurfaceDescription' : overloaded member function 'void (const int)' not found in 'SurfaceDescription'
+        d:\work\ddraw\sfcdesc.hpp(10) : see declaration of 'SurfaceDescription'
+d:\work\ddraw\sfcdesc.hpp(90) : error C2065: 'DDSURFACEDESC2' : undeclared identifier
+d:\work\ddraw\sfcdesc.hpp(95) : error C2143: syntax error : missing ',' before '&'
+d:\work\ddraw\sfcdesc.hpp(95) : error C2059: syntax error : '&'
+d:\work\ddraw\sfcdesc.hpp(97) : error C2065: 'someDDSURFACEDESC2' : undeclared identifier
+d:\work\ddraw\sfcdesc.hpp(98) : error C2653: 'DDSURFACEDESC2' : is not a class or namespace name
+d:\work\ddraw\sfcdesc.hpp(98) : error C2065: 'dwSize' : undeclared identifier
+d:\work\ddraw\sfcdesc.hpp(105) : error C2653: 'DDSURFACEDESC2' : is not a class or namespace name
+d:\work\ddraw\sfcdesc.hpp(105) : error C2065: 'dwFlags' : undeclared identifier
+d:\work\ddraw\sfcdesc.hpp(111) : error C2653: 'DDSURFACEDESC2' : is not a class or namespace name
+d:\work\ddraw\sfcdesc.hpp(117) : error C2653: 'DDSURFACEDESC2' : is not a class or namespace name
+d:\work\ddraw\sfcdesc.hpp(117) : error C2065: 'dwHeight' : undeclared identifier
+d:\work\ddraw\sfcdesc.hpp(123) : error C2653: 'DDSURFACEDESC2' : is not a class or namespace name
+d:\work\ddraw\sfcdesc.hpp(129) : error C2653: 'DDSURFACEDESC2' : is not a class or namespace name
+d:\work\ddraw\sfcdesc.hpp(129) : error C2065: 'dwWidth' : undeclared identifier
+d:\work\ddraw\sfcdesc.hpp(135) : error C2653: 'DDSURFACEDESC2' : is not a class or namespace name
+d:\work\ddraw\sfcdesc.hpp(141) : error C2653: 'DDSURFACEDESC2' : is not a class or namespace name
+d:\work\ddraw\sfcdesc.hpp(147) : error C2653: 'DDSURFACEDESC2' : is not a class or namespace name
+d:\work\ddraw\sfcdesc.hpp(153) : error C2653: 'DDSURFACEDESC2' : is not a class or namespace name
+d:\work\ddraw\sfcdesc.hpp(153) : error C2065: 'dwLinearSize' : undeclared identifier
+d:\work\ddraw\sfcdesc.hpp(159) : error C2653: 'DDSURFACEDESC2' : is not a class or namespace name
+d:\work\ddraw\sfcdesc.hpp(165) : error C2653: 'DDSURFACEDESC2' : is not a class or namespace name
+d:\work\ddraw\sfcdesc.hpp(165) : error C2065: 'dwBackBufferCount' : undeclared identifier
+d:\work\ddraw\sfcdesc.hpp(171) : error C2653: 'DDSURFACEDESC2' : is not a class or namespace name
+d:\work\ddraw\sfcdesc.hpp(177) : error C2653: 'DDSURFACEDESC2' : is not a class or namespace name
+d:\work\ddraw\sfcdesc.hpp(177) : error C2065: 'dwMipMapCount' : undeclared identifier
+d:\work\ddraw\sfcdesc.hpp(183) : error C2653: 'DDSURFACEDESC2' : is not a class or namespace name
+d:\work\ddraw\sfcdesc.hpp(189) : error C2653: 'DDSURFACEDESC2' : is not a class or namespace name
+d:\work\ddraw\sfcdesc.hpp(189) : error C2065: 'dwRefreshRate' : undeclared identifier
+d:\work\ddraw\sfcdesc.hpp(195) : error C2653: 'DDSURFACEDESC2' : is not a class or namespace name
+d:\work\ddraw\sfcdesc.hpp(201) : error C2653: 'DDSURFACEDESC2' : is not a class or namespace name
+d:\work\ddraw\sfcdesc.hpp(201) : error C2065: 'dwAlphaBitDepth' : undeclared identifier
+d:\work\ddraw\sfcdesc.hpp(207) : error C2653: 'DDSURFACEDESC2' : is not a class or namespace name
+d:\work\ddraw\sfcdesc.hpp(213) : error C2653: 'DDSURFACEDESC2' : is not a class or namespace name
+d:\work\ddraw\sfcdesc.hpp(213) : fatal error C1003: error count exceeds 100; stopping compilation
+Main.cpp
+d:\work\ddraw\pixform.hpp(13) : error C2065: 'DDPF_ALPHAPREMULT' : undeclared identifier
+d:\work\ddraw\pixform.hpp(13) : error C2057: expected constant expression
+d:\work\ddraw\pixform.hpp(14) : error C2065: 'DDPF_BUMPLUMINANCE' : undeclared identifier
+d:\work\ddraw\pixform.hpp(14) : error C2057: expected constant expression
+d:\work\ddraw\pixform.hpp(14) : error C2065: 'DDPF_BUMPDUDV' : undeclared identifier
+d:\work\ddraw\pixform.hpp(14) : error C2057: expected constant expression
+d:\work\ddraw\pixform.hpp(15) : error C2065: 'DDPF_LUMINANCE' : undeclared identifier
+d:\work\ddraw\pixform.hpp(15) : error C2057: expected constant expression
+d:\work\ddraw\pixform.hpp(18) : error C2065: 'DDPF_STENCILBUFFER' : undeclared identifier
+d:\work\ddraw\pixform.hpp(18) : error C2057: expected constant expression
+d:\work\ddraw\pixform.hpp(214) : error C2039: 'dwLuminanceBitCount' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(214) : error C2065: 'dwLuminanceBitCount' : undeclared identifier
+d:\work\ddraw\pixform.hpp(220) : error C2039: 'dwLuminanceBitCount' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(226) : error C2039: 'dwBumpBitCount' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(226) : error C2065: 'dwBumpBitCount' : undeclared identifier
+d:\work\ddraw\pixform.hpp(232) : error C2039: 'dwBumpBitCount' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(286) : error C2039: 'dwZBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(286) : error C2065: 'dwZBitMask' : undeclared identifier
+d:\work\ddraw\pixform.hpp(292) : error C2039: 'dwZBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(322) : error C2039: 'dwStencilBitDepth' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(322) : error C2065: 'dwStencilBitDepth' : undeclared identifier
+d:\work\ddraw\pixform.hpp(328) : error C2039: 'dwStencilBitDepth' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(334) : error C2039: 'dwLuminanceBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(334) : error C2065: 'dwLuminanceBitMask' : undeclared identifier
+d:\work\ddraw\pixform.hpp(340) : error C2039: 'dwLuminanceBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(346) : error C2039: 'dwBumpDuBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(346) : error C2065: 'dwBumpDuBitMask' : undeclared identifier
+d:\work\ddraw\pixform.hpp(352) : error C2039: 'dwBumpDuBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(358) : error C2039: 'dwBumpDvBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(358) : error C2065: 'dwBumpDvBitMask' : undeclared identifier
+d:\work\ddraw\pixform.hpp(364) : error C2039: 'dwBumpDvBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(370) : error C2039: 'dwStencilBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(370) : error C2065: 'dwStencilBitMask' : undeclared identifier
+d:\work\ddraw\pixform.hpp(376) : error C2039: 'dwStencilBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(382) : error C2039: 'dwBumpLuminanceBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(382) : error C2065: 'dwBumpLuminanceBitMask' : undeclared identifier
+d:\work\ddraw\pixform.hpp(388) : error C2039: 'dwBumpLuminanceBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(418) : error C2039: 'dwLuminanceAlphaBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(418) : error C2065: 'dwLuminanceAlphaBitMask' : undeclared identifier
+d:\work\ddraw\pixform.hpp(424) : error C2039: 'dwLuminanceAlphaBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\sfccaps.hpp(8) : error C2504: 'DDSCAPS2' : base class undefined
+d:\work\ddraw\sfccaps.hpp(19) : error C2065: 'DDSCAPS2_HARDWAREDEINTERLACE' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(19) : error C2057: expected constant expression
+d:\work\ddraw\sfccaps.hpp(20) : error C2065: 'DDSCAPS2_HINTANTIALIASING' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(20) : error C2057: expected constant expression
+d:\work\ddraw\sfccaps.hpp(20) : error C2065: 'DDSCAPS2_HINTDYNAMIC' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(20) : error C2057: expected constant expression
+d:\work\ddraw\sfccaps.hpp(21) : error C2065: 'DDSCAPS2_HINTSTATIC' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(21) : error C2057: expected constant expression
+d:\work\ddraw\sfccaps.hpp(21) : error C2065: 'DDSCAPS2_OPAQUE' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(21) : error C2057: expected constant expression
+d:\work\ddraw\sfccaps.hpp(21) : error C2065: 'DDSCAPS2_TEXTUREMANAGE' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(21) : error C2057: expected constant expression
+d:\work\ddraw\sfccaps.hpp(24) : error C2629: unexpected 'class SurfaceCapabilities ('
+d:\work\ddraw\sfccaps.hpp(24) : error C2238: unexpected token(s) preceding ';'
+d:\work\ddraw\sfccaps.hpp(28) : error C2143: syntax error : missing ',' before '&'
+d:\work\ddraw\sfccaps.hpp(28) : error C2059: syntax error : '&'
+d:\work\ddraw\sfccaps.hpp(33) : error C2143: syntax error : missing ';' before '&'
+d:\work\ddraw\sfccaps.hpp(33) : error C2501: 'DDSCAPS2' : missing storage-class or type specifiers
+d:\work\ddraw\sfccaps.hpp(33) : error C2501: 'getDDSCAPS2' : missing storage-class or type specifiers
+d:\work\ddraw\sfccaps.hpp(40) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(40) : error C2065: 'dwCaps' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(41) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(41) : error C2065: 'dwCaps2' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(42) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(42) : error C2065: 'dwCaps3' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(43) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(43) : error C2065: 'dwCaps4' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(55) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(56) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(57) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(58) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(62) : error C2143: syntax error : missing ',' before '&'
+d:\work\ddraw\sfccaps.hpp(62) : error C2059: syntax error : '&'
+d:\work\ddraw\sfccaps.hpp(63) : error C2511: 'SurfaceCapabilities::SurfaceCapabilities' : overloaded member function 'void (const int)' not found in 'SurfaceCapabilities'
+        d:\work\ddraw\sfccaps.hpp(7) : see declaration of 'SurfaceCapabilities'
+d:\work\ddraw\sfccaps.hpp(81) : error C2143: syntax error : missing ',' before '&'
+d:\work\ddraw\sfccaps.hpp(81) : error C2059: syntax error : '&'
+d:\work\ddraw\sfccaps.hpp(83) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(83) : error C2065: 'someDDSCAPS2' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(83) : error C2228: left of '.dwCaps' must have class/struct/union type
+d:\work\ddraw\sfccaps.hpp(84) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(84) : error C2228: left of '.dwCaps2' must have class/struct/union type
+d:\work\ddraw\sfccaps.hpp(85) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(85) : error C2228: left of '.dwCaps3' must have class/struct/union type
+d:\work\ddraw\sfccaps.hpp(86) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(86) : error C2228: left of '.dwCaps4' must have class/struct/union type
+d:\work\ddraw\sfccaps.hpp(93) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(99) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(105) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(111) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(115) : error C2143: syntax error : missing ';' before '&'
+d:\work\ddraw\sfccaps.hpp(115) : error C2433: 'DDSCAPS2' : 'inline' not permitted on data declarations
+d:\work\ddraw\sfccaps.hpp(115) : error C2501: 'DDSCAPS2' : missing storage-class or type specifiers
+d:\work\ddraw\sfccaps.hpp(116) : error C2501: 'getDDSCAPS2' : missing storage-class or type specifiers
+d:\work\ddraw\sfccaps.hpp(117) : error C2059: syntax error : ')'
+d:\work\ddraw\sfcdesc.hpp(11) : error C2504: 'DDSURFACEDESC2' : base class undefined
+d:\work\ddraw\sfcdesc.hpp(18) : error C2065: 'DDSD_TEXTURESTAGE' : undeclared identifier
+d:\work\ddraw\sfcdesc.hpp(18) : error C2057: expected constant expression
+d:\work\ddraw\sfcdesc.hpp(21) : error C2629: unexpected 'class SurfaceDescription ('
+d:\work\ddraw\sfcdesc.hpp(21) : error C2238: unexpected token(s) preceding ';'
+d:\work\ddraw\sfcdesc.hpp(24) : error C2143: syntax error : missing ',' before '&'
+d:\work\ddraw\sfcdesc.hpp(24) : fatal error C1003: error count exceeds 100; stopping compilation
+Mainwnd.cpp
+d:\work\ddraw\pixform.hpp(13) : error C2065: 'DDPF_ALPHAPREMULT' : undeclared identifier
+d:\work\ddraw\pixform.hpp(13) : error C2057: expected constant expression
+d:\work\ddraw\pixform.hpp(14) : error C2065: 'DDPF_BUMPLUMINANCE' : undeclared identifier
+d:\work\ddraw\pixform.hpp(14) : error C2057: expected constant expression
+d:\work\ddraw\pixform.hpp(14) : error C2065: 'DDPF_BUMPDUDV' : undeclared identifier
+d:\work\ddraw\pixform.hpp(14) : error C2057: expected constant expression
+d:\work\ddraw\pixform.hpp(15) : error C2065: 'DDPF_LUMINANCE' : undeclared identifier
+d:\work\ddraw\pixform.hpp(15) : error C2057: expected constant expression
+d:\work\ddraw\pixform.hpp(18) : error C2065: 'DDPF_STENCILBUFFER' : undeclared identifier
+d:\work\ddraw\pixform.hpp(18) : error C2057: expected constant expression
+d:\work\ddraw\pixform.hpp(214) : error C2039: 'dwLuminanceBitCount' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(214) : error C2065: 'dwLuminanceBitCount' : undeclared identifier
+d:\work\ddraw\pixform.hpp(220) : error C2039: 'dwLuminanceBitCount' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(226) : error C2039: 'dwBumpBitCount' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(226) : error C2065: 'dwBumpBitCount' : undeclared identifier
+d:\work\ddraw\pixform.hpp(232) : error C2039: 'dwBumpBitCount' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(286) : error C2039: 'dwZBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(286) : error C2065: 'dwZBitMask' : undeclared identifier
+d:\work\ddraw\pixform.hpp(292) : error C2039: 'dwZBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(322) : error C2039: 'dwStencilBitDepth' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(322) : error C2065: 'dwStencilBitDepth' : undeclared identifier
+d:\work\ddraw\pixform.hpp(328) : error C2039: 'dwStencilBitDepth' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(334) : error C2039: 'dwLuminanceBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(334) : error C2065: 'dwLuminanceBitMask' : undeclared identifier
+d:\work\ddraw\pixform.hpp(340) : error C2039: 'dwLuminanceBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(346) : error C2039: 'dwBumpDuBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(346) : error C2065: 'dwBumpDuBitMask' : undeclared identifier
+d:\work\ddraw\pixform.hpp(352) : error C2039: 'dwBumpDuBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(358) : error C2039: 'dwBumpDvBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(358) : error C2065: 'dwBumpDvBitMask' : undeclared identifier
+d:\work\ddraw\pixform.hpp(364) : error C2039: 'dwBumpDvBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(370) : error C2039: 'dwStencilBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(370) : error C2065: 'dwStencilBitMask' : undeclared identifier
+d:\work\ddraw\pixform.hpp(376) : error C2039: 'dwStencilBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(382) : error C2039: 'dwBumpLuminanceBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(382) : error C2065: 'dwBumpLuminanceBitMask' : undeclared identifier
+d:\work\ddraw\pixform.hpp(388) : error C2039: 'dwBumpLuminanceBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(418) : error C2039: 'dwLuminanceAlphaBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\pixform.hpp(418) : error C2065: 'dwLuminanceAlphaBitMask' : undeclared identifier
+d:\work\ddraw\pixform.hpp(424) : error C2039: 'dwLuminanceAlphaBitMask' : is not a member of '_DDPIXELFORMAT'
+        d:\parts\mssdk\include\ddraw.h(388) : see declaration of '_DDPIXELFORMAT'
+d:\work\ddraw\sfccaps.hpp(8) : error C2504: 'DDSCAPS2' : base class undefined
+d:\work\ddraw\sfccaps.hpp(19) : error C2065: 'DDSCAPS2_HARDWAREDEINTERLACE' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(19) : error C2057: expected constant expression
+d:\work\ddraw\sfccaps.hpp(20) : error C2065: 'DDSCAPS2_HINTANTIALIASING' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(20) : error C2057: expected constant expression
+d:\work\ddraw\sfccaps.hpp(20) : error C2065: 'DDSCAPS2_HINTDYNAMIC' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(20) : error C2057: expected constant expression
+d:\work\ddraw\sfccaps.hpp(21) : error C2065: 'DDSCAPS2_HINTSTATIC' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(21) : error C2057: expected constant expression
+d:\work\ddraw\sfccaps.hpp(21) : error C2065: 'DDSCAPS2_OPAQUE' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(21) : error C2057: expected constant expression
+d:\work\ddraw\sfccaps.hpp(21) : error C2065: 'DDSCAPS2_TEXTUREMANAGE' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(21) : error C2057: expected constant expression
+d:\work\ddraw\sfccaps.hpp(24) : error C2629: unexpected 'class SurfaceCapabilities ('
+d:\work\ddraw\sfccaps.hpp(24) : error C2238: unexpected token(s) preceding ';'
+d:\work\ddraw\sfccaps.hpp(28) : error C2143: syntax error : missing ',' before '&'
+d:\work\ddraw\sfccaps.hpp(28) : error C2059: syntax error : '&'
+d:\work\ddraw\sfccaps.hpp(33) : error C2143: syntax error : missing ';' before '&'
+d:\work\ddraw\sfccaps.hpp(33) : error C2501: 'DDSCAPS2' : missing storage-class or type specifiers
+d:\work\ddraw\sfccaps.hpp(33) : error C2501: 'getDDSCAPS2' : missing storage-class or type specifiers
+d:\work\ddraw\sfccaps.hpp(40) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(40) : error C2065: 'dwCaps' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(41) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(41) : error C2065: 'dwCaps2' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(42) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(42) : error C2065: 'dwCaps3' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(43) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(43) : error C2065: 'dwCaps4' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(55) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(56) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(57) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(58) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(62) : error C2143: syntax error : missing ',' before '&'
+d:\work\ddraw\sfccaps.hpp(62) : error C2059: syntax error : '&'
+d:\work\ddraw\sfccaps.hpp(63) : error C2511: 'SurfaceCapabilities::SurfaceCapabilities' : overloaded member function 'void (const int)' not found in 'SurfaceCapabilities'
+        d:\work\ddraw\sfccaps.hpp(7) : see declaration of 'SurfaceCapabilities'
+d:\work\ddraw\sfccaps.hpp(81) : error C2143: syntax error : missing ',' before '&'
+d:\work\ddraw\sfccaps.hpp(81) : error C2059: syntax error : '&'
+d:\work\ddraw\sfccaps.hpp(83) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(83) : error C2065: 'someDDSCAPS2' : undeclared identifier
+d:\work\ddraw\sfccaps.hpp(83) : error C2228: left of '.dwCaps' must have class/struct/union type
+d:\work\ddraw\sfccaps.hpp(84) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(84) : error C2228: left of '.dwCaps2' must have class/struct/union type
+d:\work\ddraw\sfccaps.hpp(85) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(85) : error C2228: left of '.dwCaps3' must have class/struct/union type
+d:\work\ddraw\sfccaps.hpp(86) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(86) : error C2228: left of '.dwCaps4' must have class/struct/union type
+d:\work\ddraw\sfccaps.hpp(93) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(99) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(105) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(111) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+d:\work\ddraw\sfccaps.hpp(115) : error C2143: syntax error : missing ';' before '&'
+d:\work\ddraw\sfccaps.hpp(115) : error C2433: 'DDSCAPS2' : 'inline' not permitted on data declarations
+d:\work\ddraw\sfccaps.hpp(115) : error C2501: 'DDSCAPS2' : missing storage-class or type specifiers
+d:\work\ddraw\sfccaps.hpp(116) : error C2501: 'getDDSCAPS2' : missing storage-class or type specifiers
+d:\work\ddraw\sfccaps.hpp(117) : error C2059: syntax error : ')'
+d:\work\ddraw\sfcdesc.hpp(11) : error C2504: 'DDSURFACEDESC2' : base class undefined
+d:\work\ddraw\sfcdesc.hpp(18) : error C2065: 'DDSD_TEXTURESTAGE' : undeclared identifier
+d:\work\ddraw\sfcdesc.hpp(18) : error C2057: expected constant expression
+d:\work\ddraw\sfcdesc.hpp(21) : error C2629: unexpected 'class SurfaceDescription ('
+d:\work\ddraw\sfcdesc.hpp(21) : error C2238: unexpected token(s) preceding ';'
+d:\work\ddraw\sfcdesc.hpp(24) : error C2143: syntax error : missing ',' before '&'
+d:\work\ddraw\sfcdesc.hpp(24) : fatal error C1003: error count exceeds 100; stopping compilation
+palette.cpp
+d:\work\ddraw\palette.hpp(21) : error C2065: 'DDPCAPS_ALPHA' : undeclared identifier
+d:\work\ddraw\palette.hpp(21) : error C2057: expected constant expression
+texture.cpp
+cl.exe terminated at user request.
+
+</pre>
+</body>
+</html>

ddraw/DEVDESC.HPP

@@ -0,0 +1,156 @@
+#ifndef _DDRAW_DEVICEDESCRIPTION_HPP_
+#define _DDRAW_DEVICEDESCRIPTION_HPP_
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _DDRAW_DDRAW_HPP_
+#include <ddraw/ddraw.hpp>
+#endif
+
+class DeviceDescription
+{
+public:
+  DeviceDescription(void);
+	DeviceDescription(const DeviceDescription &someDeviceDescription);
+	virtual ~DeviceDescription();
+	DeviceDescription &operator=(const DeviceDescription &someDeviceDescription);
+	const GUID &guid(void)const;
+	void guid(const GUID &guid);
+	const String &deviceName(void)const;
+	void deviceName(const String &deviceName);
+	const String &deviceDescription(void)const;
+	void deviceDescription(const String &deviceDescription);
+	const D3DDEVICEDESC &hwDeviceDescription(void)const;
+	void hwDeviceDescription(const D3DDEVICEDESC &hwDeviceDescription);
+	const D3DDEVICEDESC &swDeviceDescription(void)const;
+	void swDeviceDescription(const D3DDEVICEDESC &swDeviceDescription);
+	BOOL isHardware(void)const;
+	BOOL selected(void)const;
+	void selected(BOOL selected);
+private:
+  void zeroInit(void);
+
+  GUID mGUID;
+	String mDeviceName;
+	String mDeviceDescription;
+	D3DDEVICEDESC mHWDeviceDescription;
+	D3DDEVICEDESC mSWDeviceDescription;
+	BOOL mIsSelected;
+};
+
+inline
+DeviceDescription::DeviceDescription(void)
+{
+  zeroInit();
+}
+
+inline
+DeviceDescription::DeviceDescription(const DeviceDescription &someDeviceDescription)
+{
+	*this=someDeviceDescription;
+}
+
+inline
+DeviceDescription::~DeviceDescription()
+{
+}
+
+inline
+DeviceDescription &DeviceDescription::operator=(const DeviceDescription &someDeviceDescription)
+{
+  guid(someDeviceDescription.guid());
+	deviceName(someDeviceDescription.deviceName());
+	deviceDescription(someDeviceDescription.deviceDescription());
+	hwDeviceDescription(someDeviceDescription.hwDeviceDescription());
+	swDeviceDescription(someDeviceDescription.swDeviceDescription());
+	selected(someDeviceDescription.selected());
+	return *this;
+}
+
+inline
+const GUID &DeviceDescription::guid(void)const
+{
+  return mGUID;
+}
+
+inline
+void DeviceDescription::guid(const GUID &guid)
+{
+  ::memcpy(&mGUID,&((GUID&)guid),sizeof(GUID));
+}
+
+inline
+const String &DeviceDescription::deviceName(void)const
+{
+  return mDeviceName;
+}
+
+inline
+void DeviceDescription::deviceName(const String &deviceName)
+{
+  mDeviceName=deviceName;
+}
+
+inline
+const String &DeviceDescription::deviceDescription(void)const
+{
+  return mDeviceDescription;
+}
+
+inline
+void DeviceDescription::deviceDescription(const String &deviceDescription)
+{
+  mDeviceDescription=deviceDescription;
+}
+
+inline
+const D3DDEVICEDESC &DeviceDescription::hwDeviceDescription(void)const
+{
+  return mHWDeviceDescription;
+}
+
+inline
+void DeviceDescription::hwDeviceDescription(const D3DDEVICEDESC &hwDeviceDescription)
+{
+  ::memcpy(&mHWDeviceDescription,&(D3DDEVICEDESC&)hwDeviceDescription,sizeof(D3DDEVICEDESC));
+}
+
+inline
+const D3DDEVICEDESC &DeviceDescription::swDeviceDescription(void)const
+{
+  return mSWDeviceDescription;
+}
+
+inline
+void DeviceDescription::swDeviceDescription(const D3DDEVICEDESC &swDeviceDescription)
+{
+  ::memcpy(&mSWDeviceDescription,&(D3DDEVICEDESC&)swDeviceDescription,sizeof(D3DDEVICEDESC));
+}
+
+inline
+BOOL DeviceDescription::isHardware(void)const
+{
+  return hwDeviceDescription().dcmColorModel;
+}
+
+inline
+BOOL DeviceDescription::selected(void)const
+{
+  return mIsSelected;
+}
+
+inline
+void DeviceDescription::selected(BOOL selected)
+{
+  mIsSelected=selected;
+}
+
+inline
+void DeviceDescription::zeroInit(void)
+{
+  ::memset(&mGUID,0,sizeof(mGUID));
+	::memset(&mHWDeviceDescription,0,sizeof(mHWDeviceDescription));
+	::memset(&mSWDeviceDescription,0,sizeof(mSWDeviceDescription));
+	mIsSelected=FALSE;
+}
+#endif

ddraw/DEVENUM.CPP

@@ -0,0 +1,63 @@
+#include <ddraw/devenum.hpp>
+
+DeviceEnumerator::DeviceEnumerator(void)
+{
+}
+
+DeviceEnumerator::DeviceEnumerator(const DeviceEnumerator &someDeviceEnumerator)
+{ // private implementation
+  *this=someDeviceEnumerator;
+}
+
+DeviceEnumerator::~DeviceEnumerator()
+{
+}
+
+DeviceEnumerator &DeviceEnumerator::operator=(const DeviceEnumerator &/*someDeviceEnumerator*/)
+{  // private implementation
+  return *this;
+}
+
+Block<DeviceDescription> &DeviceEnumerator::enumeratedDevices(void)
+{
+  return mEnumeratedDevices;
+}
+
+HRESULT WINAPI DeviceEnumerator::enumDeviceCallback(LPGUID lpGUID,LPSTR lpszDeviceDesc,LPSTR lpszDeviceName,LPD3DDEVICEDESC lpd3dHWDeviceDesc,LPD3DDEVICEDESC lpd3dSWDeviceDesc,LPVOID lpUserArg)
+{
+  DeviceEnumerator &deviceEnumerator=(*(DeviceEnumerator*)lpUserArg);
+  DeviceDescription deviceDescription;
+
+	deviceDescription.guid(*lpGUID);
+	deviceDescription.deviceName(lpszDeviceName);
+	deviceDescription.deviceDescription(lpszDeviceDesc);
+	deviceDescription.hwDeviceDescription(*lpd3dHWDeviceDesc);
+	deviceDescription.swDeviceDescription(*lpd3dSWDeviceDesc);
+  deviceEnumerator.mEnumeratedDevices.insert(&deviceDescription);
+	DeviceDescription &currDeviceDescription=deviceEnumerator.mEnumeratedDevices[deviceEnumerator.mEnumeratedDevices.size()-1];
+  deviceEnumerator.enumDevice(currDeviceDescription);
+	if(currDeviceDescription.selected())return D3DENUMRET_CANCEL;
+	return D3DENUMRET_OK;
+}
+
+// virtuals
+void DeviceEnumerator::enumDevice(DeviceDescription &deviceDescription)
+{
+  const D3DDEVICEDESC &swhwDeviceDescription=deviceDescription.isHardware()?deviceDescription.hwDeviceDescription():deviceDescription.swDeviceDescription();
+
+	if(deviceDescription.isHardware())
+	{
+	  deviceDescription.selected(TRUE);
+		return;
+	}
+	if(!(swhwDeviceDescription.dwDeviceRenderBitDepth&PreferredDeviceBitDepth))return;
+	if(D3DCOLOR_MONO==swhwDeviceDescription.dcmColorModel)
+	{
+	  if(!(swhwDeviceDescription.dpcTriCaps.dwShadeCaps&D3DPSHADECAPS_COLORGOURAUDMONO))return;
+	}
+	else
+	{
+    if(!(swhwDeviceDescription.dpcTriCaps.dwShadeCaps&D3DPSHADECAPS_COLORGOURAUDRGB))return;
+	}
+  return;
+}

ddraw/DEVENUM.HPP

@@ -0,0 +1,30 @@
+#ifndef _DDRAW_DEVICEENUMERATOR_HPP_
+#define _DDRAW_DEVICEENUMERATOR_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_BLOCK_HPP_
+#include <common/block.hpp>
+#endif
+#ifndef _DDRAW_DEVICEDESCRIPTION_HPP_
+#include <ddraw/devdesc.hpp>
+#endif
+
+class DeviceEnumerator
+{
+public:
+  friend class Direct3D;
+  DeviceEnumerator(void);
+	virtual ~DeviceEnumerator();
+	Block<DeviceDescription> &enumeratedDevices(void);
+protected:
+  virtual void enumDevice(DeviceDescription &deviceDescription);
+private:
+  enum{PreferredDeviceBitDepth=24};
+  DeviceEnumerator(const DeviceEnumerator &someDeviceEnumerator);
+	DeviceEnumerator &operator=(const DeviceEnumerator &someDeviceEnumerator);
+  static HRESULT WINAPI enumDeviceCallback(LPGUID lpGUID,LPSTR lpszDeviceDesc,LPSTR lpszDeviceName,LPD3DDEVICEDESC lpd3dHWDeviceDesc,LPD3DDEVICEDESC lpd3dSWDeviceDesc,LPVOID lpUserArg);
+
+	Block<DeviceDescription> mEnumeratedDevices;
+};
+#endif

ddraw/DEVICE3D.HPP

@@ -0,0 +1,107 @@
+#ifndef _DDRAW_DIRECTDEVICE3D_HPP_
+#define _DDRAW_DIRECTDEVICE3D_HPP_
+#ifndef _COMMON_SMARTPOINTER_HPP_
+#include <common/pointer.hpp>
+#endif
+#ifndef _DDRAW_DDRAW_HPP_
+#include <ddraw/ddraw.hpp>
+#endif
+
+class Matrix;
+
+class DirectDevice3D : public SmartPointer<IDirect3DDevice3>
+{
+public:
+  enum DrawPrimitiveFlags{DoNotClip=D3DDP_DONOTCLIP,DoNotLight=D3DDP_DONOTLIGHT,
+         DoNotUpdateExtents=D3DDP_DONOTUPDATEEXTENTS,WaitUntilRendered=D3DDP_WAIT};
+  enum TransformStateTypeFlags{World=D3DTRANSFORMSTATE_WORLD,View=D3DTRANSFORMSTATE_VIEW,
+	       Projection=D3DTRANSFORMSTATE_PROJECTION,ForceDoubleWord=D3DTRANSFORMSTATE_FORCE_DWORD};
+  DirectDevice3D(void);
+	virtual ~DirectDevice3D();
+	DirectDevice3D &operator=(IDirect3DDevice3 *pIDirect3DDevice3);
+  BOOL setRenderState(D3DRENDERSTATETYPE renderStateType,DWORD renderState);
+  BOOL drawPrimitve(D3DPRIMITIVETYPE primitiveType,DWORD vertexTypeDesc,LPVOID pVertices,DWORD vertexCount,DrawPrimitiveFlags primitiveFlags=WaitUntilRendered);
+	BOOL setTransform(TransformStateTypeFlags transformType,Matrix &matrix);
+	BOOL beginScene(void);
+	BOOL endScene(void);
+	void destroy(void);
+private:
+  DirectDevice3D(const DirectDevice3D &someDirectDevice3D);
+	DirectDevice3D &operator=(const DirectDevice3D &someDirectDevice3D);
+};
+
+inline
+DirectDevice3D::DirectDevice3D(void)
+{
+}
+
+inline
+DirectDevice3D::~DirectDevice3D()
+{
+  destroy();
+}
+
+inline
+void DirectDevice3D::destroy(void)
+{
+  if(!isOkay())return;
+	operator->()->Release();
+	SmartPointer<IDirect3DDevice3>::destroy();
+}
+
+inline
+DirectDevice3D::DirectDevice3D(const DirectDevice3D &someDirectDevice3D)
+{ // private implementation
+  *this=someDirectDevice3D;
+}
+
+inline
+DirectDevice3D &DirectDevice3D::operator=(const DirectDevice3D &/*someDevice3D*/)
+{ // private implementation
+  return *this;
+}
+
+inline
+DirectDevice3D &DirectDevice3D::operator=(IDirect3DDevice3 *pIDirect3DDevice3)
+{
+  destroy();
+	SmartPointer<IDirect3DDevice3>::operator=(pIDirect3DDevice3);
+  return *this;
+}
+
+inline
+BOOL DirectDevice3D::setRenderState(D3DRENDERSTATETYPE renderStateType,DWORD renderState)
+{
+  if(!isOkay())return FALSE;
+	return D3D_OK==operator->()->SetRenderState(renderStateType,renderState);
+}
+
+inline
+BOOL DirectDevice3D::drawPrimitve(D3DPRIMITIVETYPE primitiveType,DWORD vertexTypeDesc,LPVOID pVertices,DWORD vertexCount,DrawPrimitiveFlags primitiveFlags)
+{
+  if(!isOkay())return FALSE;
+	return D3D_OK==operator->()->DrawPrimitive(primitiveType,vertexTypeDesc,pVertices,vertexCount,primitiveFlags);
+}
+
+inline
+BOOL DirectDevice3D::setTransform(TransformStateTypeFlags transformType,Matrix &matrix)
+{
+  if(!isOkay())return FALSE;
+	return D3D_OK==operator->()->SetTransform(D3DTRANSFORMSTATETYPE(transformType),(D3DMATRIX*)&matrix);
+}
+
+inline
+BOOL DirectDevice3D::beginScene(void)
+{
+  if(!isOkay())return FALSE;
+	return D3D_OK==operator->()->BeginScene();
+}
+
+inline
+BOOL DirectDevice3D::endScene(void)
+{
+  if(!isOkay())return FALSE;
+	return D3D_OK==operator->()->EndScene();
+}
+#endif
+

ddraw/DIRECT3D.CPP

@@ -0,0 +1,53 @@
+#include <ddraw/direct3d.hpp>
+#include <ddraw/devenum.hpp>
+#include <ddraw/devdesc.hpp>
+#include <ddraw/surface.hpp>
+#include <ddraw/device3d.hpp>
+
+Direct3D::Direct3D(void)
+{
+}
+
+Direct3D::Direct3D(const Direct3D &someDirect3D)
+{ // private implementation
+  *this=someDirect3D;
+}
+
+Direct3D::~Direct3D()
+{
+  destroy();
+}
+
+Direct3D &Direct3D::operator=(const Direct3D &/*someDirect3D*/)
+{  // private implementation
+  return *this;
+}
+
+void Direct3D::destroy(void)
+{
+  if(!isOkay())return;
+	operator->()->Release();
+	SmartPointer<IDirect3D3>::destroy();
+}
+
+BOOL Direct3D::enumerateDevice(DeviceEnumerator &deviceEnumerator)
+{
+  if(!isOkay())return FALSE;
+  deviceEnumerator.enumeratedDevices().remove();
+	operator->()->EnumDevices(DeviceEnumerator::enumDeviceCallback,&deviceEnumerator);
+	return TRUE;
+}
+
+DirectDrawError Direct3D::createDevice(const DeviceDescription &deviceDescription,Surface &surface,DirectDevice3D &device3D)
+{
+  LPDIRECT3DDEVICE3 lpDirect3DDevice3;
+	DirectDrawError status;
+
+//	device3D.destroy();
+  if(!isOkay())return DirectDrawError::GenericFailure;
+	status=DirectDrawError::DirectDrawResult(operator->()->CreateDevice(deviceDescription.guid(),(IDirectDrawSurface4*)((SmartPointer<IDirectDrawSurface4>&)surface),&lpDirect3DDevice3,0));
+	if(!status.okResult())return status;
+	device3D=lpDirect3DDevice3;
+	return status;
+//  (SmartPointer<IDirect3DDevice3>&)device3D=lpDirect3DDevice3;
+}

ddraw/DIRECT3D.HPP

@@ -0,0 +1,30 @@
+#ifndef _DDRAW_DIRECT3D_HPP_
+#define _DDRAW_DIRECT3D_HPP_
+#ifndef _COMMON_SMARTPOINTER_HPP_
+#include <common/pointer.hpp>
+#endif
+#ifndef _DDRAW_DDRAW_HPP_
+#include <ddraw/ddraw.hpp>
+#endif
+#ifndef _DDRAW_DIRECTDRAWERROR_HPP_
+#include <ddraw/error.hpp>
+#endif
+
+class DeviceEnumerator;
+class DeviceDescription;
+class Surface;
+class DirectDevice3D;
+
+class Direct3D : private SmartPointer<IDirect3D3>
+{
+public:
+  Direct3D(void);
+	virtual ~Direct3D();
+	void destroy(void);
+  BOOL enumerateDevice(DeviceEnumerator &deviceEnumerator);
+  DirectDrawError createDevice(const DeviceDescription &deviceDescription,Surface &surface,DirectDevice3D &device3D);
+private:
+  Direct3D(const Direct3D &someDirect3D);
+	Direct3D &operator=(const Direct3D &someDirect3D);
+};
+#endif

ddraw/DRAW.CPP

@@ -0,0 +1,157 @@
+#include <ddraw/draw.hpp>
+#include <ddraw/surface.hpp>
+#include <ddraw/dspenum.hpp>
+#include <ddraw/sfcdesc.hpp>
+#include <ddraw/direct3d.hpp>
+#include <ddraw/device3d.hpp>
+#include <ddraw/devenum.hpp>
+#include <ddraw/palette.hpp>
+#include <common/guiwnd.hpp>
+
+DirectDraw::DirectDraw(void)
+{
+  createDirectDraw();
+}
+
+DirectDraw::DirectDraw(const DirectDraw &directDraw)
+{ // private implementation
+  *this=directDraw;
+}
+
+DirectDraw &DirectDraw::operator=(const DirectDraw &/*directDraw*/)
+{
+  return *this;
+}
+
+DirectDraw::~DirectDraw()
+{
+  destroy();
+}
+
+DirectDrawError DirectDraw::setCooperativeLevel(GUIWindow &parentWindow,CoopFlags coopFlags)
+{
+  if(!isOkay())return DirectDrawError::GenericFailure;
+	return DirectDrawError::DirectDrawResult(mDirectDraw4->SetCooperativeLevel(parentWindow,coopFlags));
+}
+
+DirectDrawError DirectDraw::testCooperativeLevel(void)
+{
+  if(!isOkay())return DirectDrawError::GenericFailure;
+  return DirectDrawError::DirectDrawResult(mDirectDraw4->TestCooperativeLevel());
+}
+
+DirectDrawError DirectDraw::setCooperativeLevel(CoopFlags coopFlags)
+{
+  if(!isOkay())return DirectDrawError::GenericFailure;
+	return DirectDrawError::DirectDrawResult(mDirectDraw4->SetCooperativeLevel((HWND)0,coopFlags));
+}
+
+BOOL DirectDraw::enumerateModes(DisplayEnumerator &displayEnumerator)
+{
+  if(!isOkay())return FALSE;
+	displayEnumerator.enumeratedModes().remove();
+	mDirectDraw4->EnumDisplayModes(DDEDM_REFRESHRATES,0,&displayEnumerator,DisplayEnumerator::enumModesCallback);
+	return TRUE;
+}
+
+BOOL DirectDraw::setDisplayMode(int width,int height,int bpp,int refreshRate)
+{
+  if(!isOkay())return FALSE;
+	return (DD_OK==mDirectDraw4->SetDisplayMode(width,height,bpp,refreshRate,0));
+}
+
+BOOL DirectDraw::getDisplayMode(SurfaceDescription &surfaceDescription)
+{
+	if(!isOkay())return FALSE;
+	return (DD_OK==mDirectDraw4->GetDisplayMode(&surfaceDescription.getDDSURFACEDESC2()));
+}
+
+BOOL DirectDraw::restoreDisplayMode(void)
+{
+  if(!isOkay())return FALSE;
+	return (DD_OK==mDirectDraw4->RestoreDisplayMode());
+}
+
+BOOL DirectDraw::restoreAllSurfaces(void)
+{
+  if(!isOkay())return FALSE;
+	return DD_OK==mDirectDraw4->RestoreAllSurfaces();
+}
+
+DirectDrawError DirectDraw::createSurface(const SurfaceDescription &surfaceDescription,Surface &surface)
+{
+  LPDIRECTDRAWSURFACE4 lpDDSurface4;
+	DirectDrawError errorResult(DirectDrawError::GenericFailure);
+
+  surface.destroy();
+  if(!isOkay())return DirectDrawError::GenericFailure;
+	errorResult=DirectDrawError::DirectDrawResult(mDirectDraw4->CreateSurface(&((SurfaceDescription&)surfaceDescription).getDDSURFACEDESC2(),&lpDDSurface4,0));
+	if(!(DirectDrawError::Ok==errorResult.result()))return errorResult;
+	(SmartPointer<IDirectDrawSurface4>&)surface=lpDDSurface4;
+	return errorResult;
+}
+
+BOOL DirectDraw::createDirectDraw(void)
+{
+  HRESULT hResult;
+  LPDIRECTDRAW lpDirectDraw;
+	LPDIRECTDRAW4 lpDirectDraw4;
+
+	hResult=::DirectDrawCreate(NULL,&lpDirectDraw,NULL);
+	if(hResult<0)return FALSE;
+	mDirectDraw=lpDirectDraw;
+	hResult=mDirectDraw->QueryInterface(IID_IDirectDraw4,(void**)&lpDirectDraw4);
+	if(hResult<0){mDirectDraw->Release();mDirectDraw.destroy();return FALSE;}
+  mDirectDraw4=lpDirectDraw4;
+	return isOkay();
+}
+
+DirectDrawError DirectDraw::createDirect3D(Surface &renderSurface,Direct3D &direct3D,DirectDevice3D &device3D)
+{
+	DirectDrawError status(DirectDrawError::GenericFailure);
+  LPDIRECT3D3 lpDirect3D3;
+	LPDIRECT3DDEVICE3 lpDirect3DDevice3;
+	DeviceEnumerator enumDevice;
+
+  if(!isOkay())return status;
+	direct3D.destroy();
+	status=DirectDrawError::DirectDrawResult(mDirectDraw->QueryInterface(IID_IDirect3D3,(void**)&lpDirect3D3));
+	if(!status.okResult())return status;
+	(SmartPointer<IDirect3D3>&)direct3D=lpDirect3D3;
+	direct3D.enumerateDevice(enumDevice);
+	if(!enumDevice.enumeratedDevices().size()){direct3D.destroy();status.result(DirectDrawError::GenericFailure);return status;}
+	status=direct3D.createDevice(enumDevice.enumeratedDevices()[0],renderSurface,device3D);
+	if(!status.okResult())return status;
+	return status;
+}
+
+DirectDrawError DirectDraw::createPalette(DirectPalette &directPalette)
+{
+  DirectDrawError status(DirectDrawError::GenericFailure);
+  LPDIRECTDRAWPALETTE lpDDPalette;
+
+  if(!isOkay())return status;
+	directPalette.destroy();
+	status=DirectDrawError::DirectDrawResult(mDirectDraw4->CreatePalette(directPalette.flags(),&((PALETTEENTRY&)directPalette[0]),&lpDDPalette,0));
+	if(!status.okResult())return status;
+	(SmartPointer<IDirectDrawPalette>&)directPalette=lpDDPalette;
+	return status;
+}
+
+DirectDrawError DirectDraw::flipToGDISurface(void)
+{
+  if(!isOkay())return DirectDrawError::GenericFailure;
+	return DirectDrawError::DirectDrawResult(mDirectDraw4->FlipToGDISurface());
+}
+
+void DirectDraw::destroy(void)
+{
+  if(!isOkay())return;
+	if(mDirectDraw4.isOkay()){mDirectDraw4->Release();mDirectDraw4.destroy();}
+	if(mDirectDraw.isOkay()){mDirectDraw->Release();mDirectDraw.destroy();}
+}
+
+BOOL DirectDraw::isOkay(void)const
+{
+  return mDirectDraw.isOkay()&&mDirectDraw4.isOkay();
+}

ddraw/DRAW.HPP

@@ -0,0 +1,53 @@
+#ifndef _DDRAW_DIRECTDRAW_HPP_
+#define _DDRAW_DIRECTDRAW_HPP_
+#ifndef _COMMON_SMARTPOINTER_HPP_
+#include <common/pointer.hpp>
+#endif
+#ifndef _DDRAW_DDRAW_HPP_
+#include <ddraw/ddraw.hpp>
+#endif
+#ifndef _DDRAW_DIRECTDRAWERROR_HPP_
+#include <ddraw/error.hpp>
+#endif
+
+class SurfaceDescription;
+class DisplayEnumerator;
+class GUIWindow;
+class Direct3D;
+class DirectDevice3D;
+class DirectPalette;
+class Surface;
+
+class DirectDraw
+{
+public:
+  enum CoopFlags{FullScreen=DDSCL_FULLSCREEN,AllowReboot=DDSCL_ALLOWREBOOT,
+	      NoWindowChanges=DDSCL_NOWINDOWCHANGES,Normal=DDSCL_NORMAL,Exclusive=DDSCL_EXCLUSIVE,
+				SetFocusWindow=DDSCL_SETFOCUSWINDOW,SetDeviceWindow=DDSCL_SETDEVICEWINDOW,
+				CreateDeviceWindow=DDSCL_CREATEDEVICEWINDOW,Multithreaded=DDSCL_MULTITHREADED,
+				FPUSetup=DDSCL_FPUSETUP};
+  DirectDraw(void);
+	virtual ~DirectDraw();
+  BOOL enumerateModes(DisplayEnumerator &displayEnumerator);
+	BOOL setDisplayMode(int width,int height,int bpp,int refreshRate=0);
+	BOOL getDisplayMode(SurfaceDescription &surfaceDescription);
+	BOOL restoreDisplayMode(void);
+	BOOL restoreAllSurfaces(void);
+	DirectDrawError createSurface(const SurfaceDescription &surfaceDescription,Surface &surface);
+  DirectDrawError createDirect3D(Surface &renderSurface,Direct3D &direct3D,DirectDevice3D &device3D);
+	DirectDrawError setCooperativeLevel(GUIWindow &parentWindow,CoopFlags coopFlags);
+	DirectDrawError setCooperativeLevel(CoopFlags coopFlags);
+  DirectDrawError testCooperativeLevel(void);
+	DirectDrawError flipToGDISurface(void);
+	DirectDrawError createPalette(DirectPalette &directPalette);
+	BOOL isOkay(void)const;
+	void destroy(void);
+private:
+  DirectDraw(const DirectDraw &directDraw);
+	DirectDraw &operator=(const DirectDraw &directDraw);
+  BOOL createDirectDraw(void);
+
+  SmartPointer<IDirectDraw> mDirectDraw;
+	SmartPointer<IDirectDraw4> mDirectDraw4;
+};
+#endif

ddraw/DRAWSFC.CPP

@@ -0,0 +1,161 @@
+#include <ddraw/drawsfc.hpp>
+#include <common/point.hpp>
+#include <common/rgbcolor.hpp>
+#include <common/math.hpp>
+
+void DrawingSurface::setRowInfo(void)
+{
+  if(!isLocked())return;
+  mRowInfo.rowCount(mSurfaceDescription.height());
+	for(int row=0;row<mRowInfo.rowCount();row++)
+	  mRowInfo[row]=int((BYTE*)mSurfaceDescription.ptrSurface()+(row*(mSurfaceDescription.width()+(mSurfaceDescription.lPitch()-mSurfaceDescription.width()))));
+}
+
+void DrawingSurface::clear(void)
+{
+  if(!isLocked())return;
+	if(pitch()==width())::memset(mSurfaceDescription.ptrSurface(),0,extent());
+	else
+	{
+    int sfcHeight(height());
+	  int sfcWidth(width());
+	  for(int index=0;index<sfcHeight;index++)::memset((void*)mRowInfo[index],0,sfcWidth);
+	}
+}
+
+void DrawingSurface::setBits(BYTE byteValue)
+{
+  if(!isLocked())return;
+  int sfcHeight(height());
+	int sfcWidth(width());
+	for(int index=0;index<sfcHeight;index++)::memset((void*)mRowInfo[index],byteValue,sfcWidth);
+}
+
+void DrawingSurface::line(const Point &firstPoint,const Point &secondPoint,BYTE byteValue)
+{
+	int xRunning((LONG)firstPoint.x()<<0x10);
+	int yRunning((LONG)firstPoint.y()<<0x10);
+	int xDelta;
+	int yDelta;
+	short xDir(1);
+	short yDir(1);
+	short steps;
+
+	if(secondPoint.x()<firstPoint.x())xDir=-1;
+	if(secondPoint.y()<firstPoint.y())yDir=-1;
+	xDelta=(int)secondPoint.x()-(int)firstPoint.x();
+	yDelta=(int)secondPoint.y()-(int)firstPoint.y();
+	if(xDelta<0)xDelta=-xDelta;
+  if(yDelta<0)yDelta=-yDelta;
+	if(xDelta<yDelta)
+	{
+		xDelta<<=0x10;
+		if(yDelta)xDelta/=yDelta;
+    else xDelta=1L;
+		steps=yDelta;
+    yDelta=0x10000;
+	}
+	else
+	{
+		yDelta<<=0x10;
+		if(xDelta)yDelta/=xDelta;
+    else yDelta=1L;
+		steps=xDelta;
+    xDelta=0x10000;
+	}
+	if(-1==xDir&&-1==yDir)
+	{
+		for(short stepIndex=0;stepIndex<steps;stepIndex++)
+		{
+      setByte(yRunning>>0x10,xRunning>>0x10,byteValue);
+      xRunning-=xDelta;
+			yRunning-=yDelta;
+		}
+	}
+	else if(-1==xDir&&1==yDir)
+	{
+		for(short stepIndex=0;stepIndex<steps;stepIndex++)
+		{
+      setByte(yRunning>>0x10,xRunning>>0x10,byteValue);
+			xRunning-=xDelta;
+      yRunning+=yDelta;
+    }
+	}
+	else if(1==xDir&&-1==yDir)
+	{
+		for(short itemIndex=0;itemIndex<steps;itemIndex++)
+		{
+      setByte(yRunning>>0x10,xRunning>>0x10,byteValue);
+			xRunning+=xDelta;
+			yRunning-=yDelta;
+		}
+	}
+	else if(1==xDir&&1==yDir)
+	{
+		for(short itemIndex=0;itemIndex<steps;itemIndex++)
+		{
+      setByte(yRunning>>0x10,xRunning>>0x10,byteValue);
+			xRunning+=xDelta;
+      yRunning+=yDelta;
+    }
+  }
+}
+
+WORD DrawingSurface::square(const Point &centerPoint,WORD lineLength,BYTE palIndex)
+{
+	WORD halfLength(lineLength>>0x01);
+	Point topLeft;
+	Point topRight;
+	Point bottomLeft;
+	Point bottomRight;
+
+	if(!isOkay())return FALSE;
+	topLeft.x(centerPoint.x()-halfLength);
+	topLeft.y(centerPoint.y()-halfLength);
+	topRight.x(centerPoint.x()+halfLength);
+	topRight.y(centerPoint.y()-halfLength);
+	bottomRight.x(centerPoint.x()+halfLength);
+	bottomRight.y(centerPoint.y()+halfLength);
+	bottomLeft.x(centerPoint.x()-halfLength);
+	bottomLeft.y(centerPoint.y()+halfLength);
+	line(topLeft,topRight,palIndex);
+	line(topRight,bottomRight,palIndex);
+	line(bottomRight,bottomLeft,palIndex);
+	line(bottomLeft,topLeft,palIndex);
+	return TRUE;
+}
+
+WORD DrawingSurface::circle(const Point &xyPoint,WORD radius,WORD palIndex,WORD aspectValue)
+{
+	int a(radius);
+	int af;
+	int bf;
+	int b(0);
+	int target(1);
+	int radiusSquared(radius*radius);
+
+	if(!isOkay())return FALSE;
+	while(a>=b)
+	{
+    b=(int)(Math::sqrt(radiusSquared-(a*a))+.50);
+		int temp(target);
+		target=b;
+		b=temp;
+		while(b<target)
+		{
+		  if(100.00!=aspectValue)af=(aspectValue*a)/100.00,bf=(aspectValue*b)/100.00;
+			else af=a,bf=b;
+			setByte(xyPoint.x()+af,xyPoint.y()+b,palIndex);
+			setByte(xyPoint.x()+bf,xyPoint.y()+a,palIndex);
+			setByte(xyPoint.x()-af,xyPoint.y()+b,palIndex);
+			setByte(xyPoint.x()-bf,xyPoint.y()+a,palIndex);
+			setByte(xyPoint.x()-af,xyPoint.y()-b,palIndex);
+			setByte(xyPoint.x()-bf,xyPoint.y()-a,palIndex);
+			setByte(xyPoint.x()+af,xyPoint.y()-b,palIndex);
+			setByte(xyPoint.x()+bf,xyPoint.y()-a,palIndex);
+      ++b;
+		}
+		--a;
+	}
+  return TRUE;
+}

ddraw/DRAWSFC.HPP

@@ -0,0 +1,147 @@
+#ifndef _DDRAW_DRAWINGSURFACE_HPP_
+#define _DDRAW_DRAWINGSURFACE_HPP_
+#ifndef _DDRAW_SURFACE_HPP_
+#include <ddraw/surface.hpp>
+#endif
+#ifndef _DDRAW_ROWINFO_HPP_
+#include <ddraw/rowinfo.hpp>
+#endif
+
+class Point;
+class RGBColor;
+
+class DrawingSurface : public Surface
+{
+public:
+  DrawingSurface(void);
+	virtual ~DrawingSurface();
+  void setByte(WORD row,WORD col,BYTE byteValue);
+  BYTE getByte(WORD row,WORD col);
+	void clear(void);
+	void setBits(BYTE byteValue);
+	void line(const Point &firstPoint,const Point &secondPoint,BYTE byteValue);
+	WORD square(const Point &centerPoint,WORD lineLength,const RGBColor &lineColor);
+  WORD square(const Point &centerPoint,WORD lineLength,BYTE indexColor);
+  WORD circle(const Point &xyPoint,WORD radius,WORD palIndex,WORD aspectValue=100);
+	BOOL lock(BOOL initRowArray=TRUE);
+	BOOL unlock(void);
+	BOOL isLocked(void)const;
+	DWORD width(void)const;
+	DWORD height(void)const;
+	DWORD pitch(void)const;
+	DWORD extent(void)const;
+	LPVOID ptrSurface(void);
+private:
+  DrawingSurface(const DrawingSurface &someDrawingSurface);
+	DrawingSurface &operator=(const DrawingSurface &someDrawingSurface);
+	void setRowInfo(void);
+	void extent(DWORD extent);
+
+	SurfaceDescription mSurfaceDescription;
+	RowInfo mRowInfo;
+	BOOL mIsLocked;
+	DWORD mExtent;
+};
+
+inline
+DrawingSurface::DrawingSurface(void)
+: mIsLocked(FALSE), mExtent(0)
+{
+}
+
+inline
+DrawingSurface::~DrawingSurface()
+{
+}
+
+inline
+DrawingSurface::DrawingSurface(const DrawingSurface &someDrawingSurface)
+{ // private implementation
+  *this=someDrawingSurface;
+}
+
+inline
+DrawingSurface &DrawingSurface::operator=(const DrawingSurface &/*someDrawingSurface*/)
+{ // private implementation
+  return *this;
+}
+
+inline
+BOOL DrawingSurface::lock(BOOL initRowArray)
+{
+  if(isLocked())return FALSE;
+  if(Surface::lock(mSurfaceDescription).okResult())mIsLocked=TRUE;
+  extent(width()*height());
+	if(initRowArray)setRowInfo();
+	return mIsLocked;
+}
+
+inline
+BOOL DrawingSurface::unlock(void)
+{
+  mIsLocked=FALSE;
+  return Surface::unlock().okResult();
+}
+
+inline
+BOOL DrawingSurface::isLocked(void)const
+{
+  return mIsLocked;
+}
+
+inline
+DWORD DrawingSurface::width(void)const
+{
+  if(!isLocked())return FALSE;
+	return mSurfaceDescription.width();
+}
+
+inline
+DWORD DrawingSurface::height(void)const
+{
+  if(!isLocked())return FALSE;
+	return mSurfaceDescription.height();
+}
+
+inline
+DWORD DrawingSurface::pitch(void)const
+{
+  if(!isLocked())return FALSE;
+	return mSurfaceDescription.lPitch();
+}
+
+inline
+DWORD DrawingSurface::extent(void)const
+{
+  if(!isLocked())return FALSE;
+  return mExtent;
+}
+
+inline
+void DrawingSurface::extent(DWORD extent)
+{
+  mExtent=extent;
+}
+
+inline
+void DrawingSurface::setByte(WORD row,WORD col,BYTE byteValue)
+{
+  if(!isLocked())return;
+	if(row>=mSurfaceDescription.height()||col>=mSurfaceDescription.width())return;
+	*((BYTE*)mRowInfo[row]+col)=byteValue;
+}
+
+inline
+BYTE DrawingSurface::getByte(WORD row,WORD col)
+{
+  if(!isLocked())return 0;
+	return *((BYTE*)mRowInfo[row]+col);
+}
+
+inline
+LPVOID DrawingSurface::ptrSurface(void)
+{
+  if(!isLocked())return 0;
+	return mSurfaceDescription.ptrSurface();
+}
+#endif

ddraw/DSPENUM.CPP

@@ -0,0 +1,32 @@
+#include <ddraw/dspenum.hpp>
+
+DisplayEnumerator::DisplayEnumerator(void)
+{
+}
+
+DisplayEnumerator::DisplayEnumerator(const DisplayEnumerator &someDisplayEnumerator)
+{ // private implementation
+  *this=someDisplayEnumerator;
+}
+
+DisplayEnumerator::~DisplayEnumerator()
+{
+}
+
+DisplayEnumerator &DisplayEnumerator::operator=(const DisplayEnumerator &/*someDisplayEnumerator*/)
+{  // private implementation
+  return *this;
+}
+
+void DisplayEnumerator::enumModes(SurfaceDescription &surfaceDescription)
+{
+}
+
+HRESULT WINAPI DisplayEnumerator::enumModesCallback(LPDDSURFACEDESC2 lpDDSurfaceDesc,LPVOID lpContext)
+{
+  DisplayEnumerator &displayEnumerator=*(DisplayEnumerator*)lpContext;
+	SurfaceDescription &surfaceDescription=*(SurfaceDescription*)lpDDSurfaceDesc;
+	displayEnumerator.mEnumeratedModes.insert(&surfaceDescription);
+  displayEnumerator.enumModes(displayEnumerator.mEnumeratedModes[displayEnumerator.mEnumeratedModes.size()-1]);
+  return DDENUMRET_OK;
+}

ddraw/DSPENUM.HPP

@@ -0,0 +1,35 @@
+#ifndef _DDRAW_DISPLAYENUMERATOR_HPP_
+#define _DDRAW_DISPLAYENUMERATOR_HPP_
+#ifndef _COMMON_BLOCK_HPP_
+#include <common/block.hpp>
+#endif
+#ifndef _DDRAW_DDRAW_HPP_
+#include <ddraw/ddraw.hpp>
+#endif
+#ifndef _DDRAW_SURFACEDESCRIPTION_HPP_
+#include <ddraw/sfcdesc.hpp>
+#endif
+
+class DisplayEnumerator
+{
+public:
+  friend class DirectDraw;
+	DisplayEnumerator(void);
+	virtual ~DisplayEnumerator();
+	Block<SurfaceDescription> &enumeratedModes(void);
+protected:
+  virtual void enumModes(SurfaceDescription &surfaceDescription);
+private:
+  DisplayEnumerator(const DisplayEnumerator &someDisplayEnumerator);
+	DisplayEnumerator &operator=(const DisplayEnumerator &someDisplayEnumerator);
+  static HRESULT WINAPI enumModesCallback(LPDDSURFACEDESC2 lpDDSurfaceDesc,LPVOID lpContext);
+
+	Block<SurfaceDescription> mEnumeratedModes;
+};
+
+inline
+Block<SurfaceDescription> &DisplayEnumerator::enumeratedModes(void)
+{
+  return mEnumeratedModes;
+}
+#endif

ddraw/ERROR.HPP

@@ -0,0 +1,188 @@
+#ifndef _DDRAW_DIRECTDRAWERROR_HPP_
+#define _DDRAW_DIRECTDRAWERROR_HPP_
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _DDRAW_DDRAW_HPP_
+#include <ddraw/ddraw.hpp>
+#endif
+
+class DirectDrawError
+{
+public:
+  enum DirectDrawResult{Ok=DD_OK,GenericFailure=DDERR_GENERIC,IncompatiblePrimary=DDERR_INCOMPATIBLEPRIMARY,
+	  InvalidCaps=DDERR_INVALIDCAPS,InvalidPixelFormat=DDERR_INVALIDPIXELFORMAT,Exception=DDERR_EXCEPTION,
+		NoAlphaHardware=DDERR_NOALPHAHW,NoCooperativeLevelSet=DDERR_NOCOOPERATIVELEVELSET,
+		NoDirectDrawHardware=DDERR_NODIRECTDRAWHW,NoEmulation=DDERR_NOEMULATION,InvalidObject=DDERR_INVALIDOBJECT,
+		NoExclusiveMode=DDERR_NOEXCLUSIVEMODE,NoFlipHardware=DDERR_NOFLIPHW,NoMipMapHardware=DDERR_NOMIPMAPHW,
+		NoOverlayHardware=DDERR_NOOVERLAYHW,NoZBufferHardware=DDERR_NOZBUFFERHW,OutOfMemory=DDERR_OUTOFMEMORY,
+		OutOfVideoMemory=DDERR_OUTOFVIDEOMEMORY,PrimarySurfaceAlreadyExists=DDERR_PRIMARYSURFACEALREADYEXISTS,
+		UnsupportedMode=DDERR_UNSUPPORTEDMODE,InvalidParams=DDERR_INVALIDPARAMS,InvalidRect=DDERR_INVALIDRECT,
+		NoBltHardware=DDERR_NOBLTHW,SurfaceBusy=DDERR_SURFACEBUSY,SurfaceLost=DDERR_SURFACELOST,
+		NoSupport=DDERR_UNSUPPORTED,WasStillDrawing=DDERR_WASSTILLDRAWING,InvalidClipList=DDERR_INVALIDCLIPLIST,
+		NoClipList=DDERR_NOCLIPLIST,NoRasterHardware=DDERR_NODDROPSHW,NoMirrorHardware=DDERR_NOMIRRORHW,
+		NoRasterOpHardware=DDERR_NORASTEROPHW,NoRotationHardware=DDERR_NOROTATIONHW,
+		NoStretchHardware=DDERR_NOSTRETCHHW,NoLockedSurfaces=DDERR_LOCKEDSURFACES,NotFound=DDERR_NOTFOUND};
+  DirectDrawError(void);
+	DirectDrawError(const DirectDrawError &someDirectDrawError);
+	DirectDrawError(DirectDrawResult directDrawResult);
+	virtual ~DirectDrawError();
+	DirectDrawError &operator=(const DirectDrawError &someDirectDrawError);
+	DirectDrawError &operator=(DirectDrawResult directDrawResult);
+	BOOL operator==(const DirectDrawError &someDirectDrawError)const;
+	BOOL operator==(DirectDrawResult directDrawResult)const;
+	operator String(void)const;
+	DirectDrawResult result(void)const;
+	void result(DirectDrawResult result);
+	BOOL okResult(void)const;
+private:
+  DirectDrawResult mDirectDrawResult;
+};
+
+inline
+DirectDrawError::DirectDrawError(void)
+: mDirectDrawResult(GenericFailure)
+{
+}
+
+inline
+DirectDrawError::DirectDrawError(const DirectDrawError &someDirectDrawError)
+{
+  *this=someDirectDrawError;
+}
+
+inline
+DirectDrawError::DirectDrawError(DirectDrawResult directDrawResult)
+{
+  *this=directDrawResult;
+}
+
+inline
+DirectDrawError::~DirectDrawError()
+{
+}
+
+inline
+DirectDrawError &DirectDrawError::operator=(const DirectDrawError &someDirectDrawError)
+{
+  result(someDirectDrawError.result());
+	return *this;
+}
+
+inline
+DirectDrawError &DirectDrawError::operator=(DirectDrawResult directDrawResult)
+{
+  result(directDrawResult);
+	return *this;
+}
+
+inline
+BOOL DirectDrawError::operator==(const DirectDrawError &someDirectDrawError)const
+{
+  return result()==someDirectDrawError.result();
+}
+
+inline
+BOOL DirectDrawError::operator==(DirectDrawResult directDrawResult)const
+{
+  return result()==directDrawResult;
+}
+
+inline
+DirectDrawError::operator String(void)const
+{
+  switch(result())
+	{
+    case Ok :
+		  return String("Ok");
+		case GenericFailure :
+		  return String("GenericFailure");
+		case IncompatiblePrimary :
+		  return String("IncompatiblePrimary");
+		case InvalidCaps :
+		  return String("InvalidCaps");
+		case InvalidPixelFormat :
+		  return String("InvalidPixelFormat");
+		case NoAlphaHardware :
+		  return String("NoAlphaHardware");
+		case NoCooperativeLevelSet :
+		  return String("NoCooperativeLevelSet");
+		case NoDirectDrawHardware :
+		  return String("NoDirectDrawHardware");
+		case NoEmulation :
+		  return String("NoEmulation");
+		case NoExclusiveMode :
+		  return String("NoExclusiveMode");
+		case NoFlipHardware :
+		  return String("NoFlipHardware");
+		case NoMipMapHardware :
+		  return String("NoMipMapHardware");
+		case NoOverlayHardware :
+		  return String("NoOverlayHardware");
+		case NoZBufferHardware :
+		  return String("NoZBufferHardware");
+		case OutOfMemory :
+		  return String("OutOfMemory");
+		case OutOfVideoMemory :
+		  return String("OutOfVideoMemory");
+		case PrimarySurfaceAlreadyExists :
+		  return String("PrimarySurfaceAlreadyExists");
+		case UnsupportedMode :
+		  return String("UnsupportedMode");
+		case Exception :
+		  return String("Exception");
+		case InvalidParams :
+		  return String("InvalidParams");
+		case InvalidRect :
+		  return String("InvalidRect");
+		case NoBltHardware :
+		  return String("NoBltHardware");
+		case SurfaceBusy :
+		  return String("SurfaceBusy");
+		case SurfaceLost :
+		  return String("SurfaceLost");
+		case NoSupport :
+		  return String("NoSupport");
+		case WasStillDrawing :
+		  return String("WasStillDrawing");
+		case InvalidClipList :
+		  return String("InvalidClipList");
+		case NoClipList :
+		  return String("NoClipList");
+		case NoRasterHardware :
+		  return String("NoRasterHardware");
+		case NoMirrorHardware :
+		  return String("NoMirrorHardware");
+		case NoRasterOpHardware :
+		  return String("NoRasterOpHardware");
+		case NoRotationHardware :
+		  return String("NoRotationHardware");
+		case NoStretchHardware :
+		  return String("NoStretchHardware");
+		case NoLockedSurfaces :
+		  return String("NoLockedSurfaces");
+    case NotFound :
+		  return String("NotFound");
+		default :
+		  return String("UndefinedError");
+	}
+}
+
+inline
+DirectDrawError::DirectDrawResult DirectDrawError::result(void)const
+{
+  return mDirectDrawResult;  
+}
+
+inline
+void DirectDrawError::result(DirectDrawResult result)
+{
+  mDirectDrawResult=result;
+}
+
+inline
+BOOL DirectDrawError::okResult(void)const
+{
+  return Ok==mDirectDrawResult;
+}
+#endif

ddraw/HOLD/ASMUTIL.ASM

@@ -0,0 +1,29 @@
+;*************************************************************************************
+; MODULE: ASMUTIL.ASM                                           DATE: JANUARY 29, 1999
+; AUTHOR: SEAN M. KESSLER
+; TARGET: 32 BIT TARGET (WIN32s, WIN95, WINNT)
+; FUNCTION : UTLITITIES
+;*************************************************************************************
+INCLUDE ..\COMMON\COMMONM.INC
+INCLUDE ..\COMMON\MATH.INC
+.386
+.MODEL FLAT
+
+RowInfo STRUC
+  RowArray@@mvptr DD ?
+  RowArray@@mPtrRow DD 1024 DUP(?)
+  RowArray@@mRowCount DD ?
+RowInfo ENDS
+.DATA
+
+rowArray RowInfo <?,<?>,0>
+
+_setRowInfo proc near     ; void setRowInfo(
+
+_setRowInfo endp
+
+
+
+.CODE
+END
+

ddraw/HOLD/ASMUTIL.HPP

@@ -0,0 +1,100 @@
+#ifndef _DDRAW_ASMUTIL_HPP_
+#define _DDRAW_ASMUTIL_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+
+class Point;
+class PureEdge;
+class PureMap;
+
+extern "C"
+{
+	void clearBitmap(DWORD lpBitmapData,DWORD imageExtent);
+	void setBits(DWORD lpBitmapData,DWORD imageExtent,BYTE charByte);
+	void lineWINGBlt(DWORD lpWINGData,Point *lpFirstPoint,Point *lpSecondPoint,DWORD width,DWORD height,WORD value);
+	void initEdge(int edgeType,PureEdge *lpPureEdge);
+	void mapTexture(PureMap *lpEdgeMap);
+  void setMaskInfo(WORD useMask,BYTE maskValue);
+	void setSrcBitmapInfo(WORD width,WORD height,UHUGE *lpSrcBitmapImage);
+	void setDstBitmapInfo(WORD width,WORD height,WORD pitch,UHUGE *lpDstBitmapImage);
+	void getSrcDataByte(WORD row,WORD col);
+	void resampleClip(char *lpIn,char *lpOut,DWORD inLen,DWORD outLen,DWORD outClip);
+}
+
+class ASMRoutines
+{
+public:
+  static void clearBitmap(DWORD lpBitmapData,DWORD imageExtent);
+	static void setBits(DWORD lpBitmapData,DWORD imageExtent,BYTE charByte);
+	static void line(DWORD lpWINGData,Point *lpFirstPoint,Point *lpSecondPoint,DWORD width,DWORD imageExtent,WORD value);
+	static void initEdge(int edgeType,PureEdge *lpPureEdge);
+	static void mapTexture(PureMap *lpEdgeMap);
+  static void setMaskInfo(WORD useMask,BYTE maskValue);
+	static void setSrcBitmapInfo(WORD width,WORD height,UHUGE *lpSrcBitmapImage);
+	static void setDstBitmapInfo(WORD width,WORD height,UHUGE *lpDstBitmapImage);
+	static void getSrcDataByte(WORD row,WORD col);
+	static void resampleClip(char *lpIn,char *lpOut,DWORD inLen,DWORD outLen,DWORD outClip);
+};
+
+inline
+void ASMRoutines::clearBitmap(DWORD lpBitmapData,DWORD imageExtent)
+{
+  ::clearBitmap(lpBitmapData,imageExtent);
+}
+
+inline
+void ASMRoutines::setBits(DWORD lpBitmapData,DWORD imageExtent,BYTE charByte)
+{
+  ::setBits(lpBitmapData,imageExtent,charByte);
+}
+
+inline
+void ASMRoutines::line(DWORD ptrData,Point *lpFirstPoint,Point *lpSecondPoint,DWORD width,DWORD height,WORD value)
+{
+  ::lineWINGBlt(ptrData,lpFirstPoint,lpSecondPoint,width,height,value);
+}
+
+inline
+void ASMRoutines::initEdge(int edgeType,PureEdge *lpPureEdge)
+{
+  ::initEdge(edgeType,lpPureEdge);
+}
+
+inline
+void ASMRoutines::mapTexture(PureMap *lpEdgeMap)
+{
+  ::mapTexture(lpEdgeMap);
+}
+
+inline
+void ASMRoutines::setMaskInfo(WORD useMask,BYTE maskValue)
+{
+  ::setMaskInfo(useMask,maskValue);
+}
+
+inline
+void ASMRoutines::setSrcBitmapInfo(WORD width,WORD height,UHUGE *lpSrcBitmapImage)
+{
+  ::setSrcBitmapInfo(width,height,lpSrcBitmapImage);
+}
+
+inline
+void ASMRoutines::setDstBitmapInfo(WORD width,WORD height,UHUGE *lpDstBitmapImage)
+{
+  ::setDstBitmapInfo(width,height,lpDstBitmapImage);
+}
+
+inline
+void ASMRoutines::getSrcDataByte(WORD row,WORD col)
+{
+  ::getSrcDataByte(row,col);
+}
+
+inline
+void ASMRoutines::resampleClip(char *lpIn,char *lpOut,DWORD inLen,DWORD outLen,DWORD outClip)
+{
+  ::resampleClip(lpIn,lpOut,inLen,outLen,outClip);
+}
+#endif
+

ddraw/HOLD/TRIMAP32.ASM

@@ -0,0 +1,436 @@
+;********************************************************************************************************
+; MODULE: TRIMAP32.ASM                                               DATE: FEBRUARY 11, 1999
+; AUTHOR: SEAN M. KESSLER                                            
+; TARGET: 32 BIT TARGET																							 
+; FUNCTION : TEXTURE MAPPING TRIANGLES
+;********************************************************************************************************
+SMART
+.386
+.MODEL FLAT
+.DATA
+
+BitShift EQU 0Bh
+
+bmData@@mSrcWidth        DD ?
+bmData@@mSrcHeight       DD ?
+bmData@@mSrcExtent       DD ?
+bmData@@mlpSrcPtr        DD ?
+bmData@@mDstWidth        DD ?
+bmData@@mDstPitch        DD ?
+bmData@@mDstHeight       DD ?
+bmData@@mDstExtent       DD ?
+bmData@@mlpDstPtr        DD ?
+bmData@@mlpDstIndexPtr   DD ?
+bmData@@mlpPixelCallback DD ?
+bmData@@mlpEdgeCallback  DD ?
+
+.LALL
+INCLUDE ..\COMMON\COMMON.INC
+INCLUDE ..\DDRAW\TRIMAP32.INC
+INCLUDE ..\DDRAW\UTIL32.INC
+.CODE
+
+edgeCallback MACRO
+  pushad                          ; save all general purpose registers 
+	push esi                        ; save pointer to edge
+	call bmData@@mlpEdgeCallback    ; call handler
+	add esp,04h                     ; adjust stack 
+	popad                           ; restore all general purpose registers
+ENDM
+
+pixelCallback MACRO
+  pushad                          ; save all general purpose registers 
+	mov eax,ui                      ; move ui to eax register
+	round eax                       ; adjust/round
+	push eax                        ; save ui
+	mov eax,vi                      ; move vi to eax register
+	round eax                       ; adjust/round
+	push eax                        ; save vi
+	push x                          ; save x
+	push y													; save y
+	call bmData@@mlpPixelCallback 	; call callback
+	add esp,10h											; adjust stack
+	popad														; restore all general purpose registers
+ENDM
+
+pixelMarker MACRO
+  pushad                          ; save all general purpose registers 
+	push 0000h                      ; push 0
+	push 0000h											; push 0
+	push 0000h											; push 0
+	push 0000h											; push 0
+	call bmData@@mlpPixelCallback 	; call callback
+	add esp,10h											; adjust stack
+	popad														; restore all general purpose registers
+ENDM
+
+round MACRO register
+LOCAL @@return
+  mov edx,register								; copy register to edx
+	and edx,7FFh                    ; get remainder to edx register
+	shr register,BitShift           ; get whole number to register
+	cmp edx,400h                    ; if remainder>1024 then increment eax
+	jle @@return                    ; ... otherwise return
+	inc register                    ; increment value in eax
+@@return:
+ENDM
+
+scanline MACRO
+	mov ecx,[esi].DirectTriEdge@@mxRight             ; move mxRight into ecx
+	sub ecx,[esi].DirectTriEdge@@mxLeft              ; subtract out mxLeft, this is dx
+	cmp ecx,0000h                                    ; compare dx to zero
+	je @@scanlineLoopEnd                             ; if dx is zero then don't scan the line
+;	mov eax,[esi].DirectTriEdge@@muRight             ; move muRight into eax 
+;	sub eax,[esi].DirectTriEdge@@muLeft              ; subtract out muLeft
+	mov eax,[esi].DirectTriEdge@@muLeft              ; move muLeft into eax register
+	sub eax,[esi].DirectTriEdge@@muRight             ; subtract out muRight
+	shl eax,BitShift                                 ; multiply this by 2048
+	divide eax,ecx                                   ; divide by dx, this is du
+	mov du,eax                                       ; store du into local variable
+;	mov eax,[esi].DirectTriEdge@@mvRight             ; move mvRight into eax
+;	sub eax,[esi].DirectTriEdge@@mvLeft              ; subtract out mvLeft
+	mov eax,[esi].DirectTriEdge@@mvLeft              ; move mvLeft into eax
+	sub eax,[esi].DirectTriEdge@@mvRight             ; subtract out mvRight
+	shl eax,BitShift                                 ; multiply this by 2048
+	divide eax,ecx                                   ; divide by dx, this is dv
+	mov dv,eax                                       ; store dv into local variable
+	mov eax,[esi].DirectTriEdge@@muLeft              ; move muLeft into eax
+	mov ui,eax                                       ; muLeft is initial value for ui
+	mov eax,[esi].DirectTriEdge@@mvLeft              ; move mvLeft into eax
+	mov vi,eax                                       ; mvLeft is initial value for vi
+	mov eax,[esi].DirectTriEdge@@mxLeft              ; move mxLeft into eax
+	mov x,eax                                        ; mxLeft is initial value for x
+	shr x,BitShift                                   ; truncate mxLeft value
+	pixelMarker
+@@scanlineLoop:                                    ; scanline loop sync address
+  mov eax,[esi].DirectTriEdge@@mxRight             ; move mxRight into eax
+	shr eax,BitShift                                 ; truncate mxRight
+	cmp x,eax                                        ; compare x to mxRight
+	jg @@scanlineLoopEnd                             ; if x>mxRight then we're done with the scanline
+  pixelCallback	
+  getSrcDataByte                                   ; get source byte at [ui][vi] to cl register
+	setDstDataByte                                   ; set destination byte at [x][y],cl
+	incrementScanLine                                ; advance along the scanline
+	jmp @@scanlineLoop                               ; continue execution
+@@scanlineLoopEnd:                                 ; end scanline sync address
+ENDM
+
+incrementScanLine MACRO                            ; advance along the scanline
+  mov eax,ui                                       ; move ui to eax
+	shl eax,BitShift		  													 ; multiply by 2048
+	add eax,du                                       ; add in du
+	shr eax,BitShift                                 ; divide by 2048
+	mov ui,eax                                       ; update ui
+	mov eax,vi                                       ; move vi to eax
+	shl eax,BitShift                                 ; multiply by 2048
+	add eax,dv                                       ; add in dv
+	shr eax,BitShift                                 ; divide by 2048
+	mov vi,eax                                       ; update vi
+	inc x                                            ; increment x
+ENDM
+
+getSrcDataByte MACRO                              ; cl=getSrcDataByte(ui,vi)
+LOCAL @@continue    
+  mov ebx,vi                                       ; move column into ebx
+	round ebx                                        ; round the result
+	cmp ebx,bmData@@mSrcWidth                        ; compare column to width
+	jge @@continue                                   ; if column greater than width we're done
+	mov eax,ui                                       ; move row into eax
+	round eax                                        ; round the result
+	cmp eax,bmData@@mSrcHeight                       ; compare row to height
+	jge @@continue                                   ; if row greater than height we're done
+	imul eax,bmData@@mSrcWidth                       ; multiply (row*width)->eax
+	add eax,bmData@@mSrcWidth                        ; add in the width
+	mov edx,bmData@@mSrcExtent                       ; move bitmap extent to edx
+	sub edx,eax                                      ; subtract (row*width)+width from extent
+	add edx,ebx                                      ; now add in the column
+	mov ebx,bmData@@mlpSrcPtr                        ; move bitmap pointer into ebx
+	mov cl,byte ptr[ebx+edx]                         ; get the byte
+@@continue:
+ENDM
+
+setDstDataByte MACRO												       ; setDstDataByte x,y,cl
+  mov eax,x                                        ; move column into ebx
+	cmp eax,bmData@@mDstWidth                        ; compare column to width
+	jge @@continue                                   ; if column greater than width, return
+	mov eax,y                                        ; move row into eax
+	cmp eax,bmData@@mDstHeight                       ; compare row to height
+	jge @@continue                                   ; if row greater than height, return
+	imul eax,bmData@@mDstWidth                       ; multiply (row*width)->eax
+	add eax,bmData@@mDstWidth                        ; add in the width
+	mov edx,bmData@@mDstExtent                       ; move bitmap extent to edx
+	sub edx,eax                                      ; subtract (row*width)+width from extent
+	add edx,x                                       ; now add in the column
+	mov eax,bmData@@mlpDstPtr                        ; move bitmap pointer into ebx
+	mov byte ptr[eax+edx],cl												 ; set the byte
+@@continue:
+ENDM
+
+verifyLeft MACRO                                   ; verifyLeft(eax has mxLeft)
+LOCAL @@noChangeDir                                ; local sync address
+  cmp scanMode,0002h                               ; check the scan mode
+	jne @@noChangeDir                                ; if scan mode is not LeftHandDiscontinuous then done
+  mov ebx,[esi].DirectTriEdge@@mx2                 ; move x2 into ebx register
+	shl ebx,BitShift                                 ; adjust ebx for precision
+	cmp eax,ebx                                      ; compare mxLeft to x2
+	jge @@noChangeDir                                ; if mxLeft>=x1 then we're okay
+	sub eax,[esi].DirectTriEdge@@mDXLeft             ; subtract out mDXLeft, this is adjusted mxLeft
+	mov [esi].DirectTriEdge@@mxLeft,eax              ; save adjusted mxLeft
+	mov ebx,[esi].DirectTriEdge@@my1                 ; move y1 into ebx register
+	sub ebx,y                        								 ; subtract (y1-y)
+	mov ecx,[esi].DirectTriEdge@@mx1                 ; move x1 into ecx register
+	sub ecx,[esi].DirectTriEdge@@mx2                 ; subtract (x1-x2)
+	shl ecx,BitShift                                 ; adjust eax for precision
+	divide ecx,ebx                                   ; eax has (x1-x2)/(y1-y), result to eax
+	mov [esi].DirectTriEdge@@mDXLeft,eax             ; this is new mDXLeft
+	mov ebx,[esi].DirectTriEdge@@mxLeft              ; move mxLeft into ebx register
+	add ebx,eax                                      ; ebx has mxLeft+mDXLeft
+	mov [esi].DirectTriEdge@@mxLeft,ebx              ; this is new mxLeft
+@@noChangeDir:                                     ; no change direction sync address
+ENDM
+
+verifyRight MACRO                                  ; verifyRight (eax has mxRight)
+LOCAL @@noChangeDir																 ; local sync address
+  cmp scanMode,0001h                               ; check the scan mode
+	jne @@noChangeDir                                ; if scan mode is not RightHandDiscontinuous then done
+	mov ebx,[esi].DirectTriEdge@@mx2                 ; is mxRight greater than x2
+	shl ebx,BitShift                                 ; adjust ebx for precision
+	cmp eax,ebx                                      ; check mxLeft against x2
+	jle @@noChangeDir                                ; if mxLeft<=x2 then we're okay
+	sub eax,[esi].DirectTriEdge@@mDXRight            ; subtract mDXRight from mxRight
+	mov [esi].DirectTriEdge@@mxRight,eax             ; this is new mxRight 
+	mov ebx,[esi].DirectTriEdge@@my1                 ; move y1 into ebx register
+	sub ebx,[esi].DirectTriEdge@@my2                 ; subtract (y1-y2) this is new dy
+	mov ecx,[esi].DirectTriEdge@@mx1                 ; move x1 into ecx
+	sub ecx,[esi].DirectTriEdge@@mx2                 ; subtract (x1-x2)
+	shl ecx,BitShift                                 ; muliply by 2048 for precision
+	divide ecx,ebx                                   ; ecx has (x1-x2)/(y1-y), result to eax
+	mov [esi].DirectTriEdge@@mDXRight,eax            ; this is new mDXRight
+	mov ebx,[esi].DirectTriEdge@@mxRight             ; move mxRight into ebx register
+	add ebx,eax                                      ; add mDXRight to mxRight
+	mov [esi].DirectTriEdge@@mxRight,ebx             ; this is new mxRight
+@@noChangeDir:
+ENDM
+
+increment MACRO
+	mov eax,[esi].DirectTriEdge@@mxLeft              ; move mxLeft into eax
+	add eax,[esi].DirectTriEdge@@mDXLeft						 ; add in the delta
+	mov [esi].DirectTriEdge@@mxLeft,eax              ; this is new mxLeft
+	verifyLeft                                       ; verify mxLeft
+	mov eax,[esi].DirectTriEdge@@mxRight             ; move mxRight into eax
+	add eax,[esi].DirectTriEdge@@mDXRight            ; add in the delta
+	mov [esi].DirectTriEdge@@mxRight,eax             ; this is new mxRight
+	verifyRight                                      ; verify mxLeft
+	mov eax,[esi].DirectTriEdge@@muLeft              ; move muLeft into eax
+	add eax,[esi].DirectTriEdge@@mDULeft						 ; add in the delta
+	mov [esi].DirectTriEdge@@muLeft,eax							 ; this is new muLeft
+	mov eax,[esi].DirectTriEdge@@muRight						 ; move muRight into eax 
+	add eax,[esi].DirectTriEdge@@mDURight						 ; add in the delta
+	mov [esi].DirectTriEdge@@muRight,eax						 ; this is new muRight
+	mov eax,[esi].DirectTriEdge@@mvLeft							 ; move mvLeft into eax
+	add eax,[esi].DirectTriEdge@@mDVLeft						 ; add in the delta
+	mov [esi].DirectTriEdge@@mvLeft,eax							 ; this is new mvLeft
+	mov eax,[esi].DirectTriEdge@@mvRight						 ; move mvRight into eax
+	add eax,[esi].DirectTriEdge@@mDVRight						 ; add in the delta
+	mov [esi].DirectTriEdge@@mvRight,eax						 ; this is new mvRight
+	inc y							                               ; increment y
+ENDM
+
+initialize MACRO
+LOCAL @@RightHandDiscontinuous,@@LeftHandleDiscontinuous,@@LevelPlane,@@NonLevelPlane,@@PlaneInitSync, \
+      @@InitFailed
+	mov eax,[esi].DirectTriEdge@@my2                 ; move y2 into eax register
+	cmp eax,[esi].DirectTriEdge@@my0                 ; does y2==y0
+	je @@LevelPlane                                  ; if so then handle initialization for it
+	mov eax,[esi].DirectTriEdge@@mx2                 ; move x2 into eax register
+	cmp eax,[esi].DirectTriEdge@@mx1                 ; compare x2 to x1
+	jg @@RightHandDiscontinuous                      ; if x2>x1 then it's right handed
+	jmp @@LeftHandDiscontinuous                      ; otherwise we treat it as left handed
+@@LevelPlane:                                      ; LevelPlane sync address
+  mov scanMode,0000h                               ; set mode for traversal
+  mov ebx,[esi].DirectTriEdge@@my1                 ; move y1 into ebx register
+	sub ebx,[esi].DirectTriEdge@@my2                 ; ebx has (y1-y2), this is dy
+	cmp ebx,0000h                                    ; is ebx zero?
+	je @@InitFail                                    ; if so then set error code
+	mov eax,[esi].DirectTriEdge@@mx1                 ; move x1 into eax
+	sub eax,[esi].DirectTriEdge@@mx0  							 ; eax has (x1-x0)
+	shl eax,BitShift		  													 ; multiply result by 2048 for precision
+	divide eax,ebx                                   ; eax has (x2-x0)/(y1-y2)
+	mov [esi].DirectTriEdge@@mDXLeft,eax						 ; this is mDXLeft
+	mov eax,[esi].DirectTriEdge@@mx1                 ; move x1 into eax register
+	sub eax,[esi].DirectTriEdge@@mx2                 ; eax has (x1-x2)
+	shl eax,BitShift                                 ; multiply result by 2048 for precision
+	divide eax,ebx                                   ; eax has (x1-x2)/(y1-y2)
+	mov [esi].DirectTriEdge@@mDXRight,eax            ; this is mDXRight
+	mov eax,[esi].DirectTriEdge@@mx0                 ; move x0 into eax register
+	mov ebx,[esi].DirectTriEdge@@mx2                 ; move x2 into ebx register
+	shl eax,BitShift                                 ; adjust mxLeft for precision
+	shl ebx,BitShift                                 ; adjust mxRight for precision
+	mov [esi].DirectTriEdge@@mxLeft,eax              ; mxLeft=x0
+	mov [esi].DirectTriEdge@@mxRight,ebx             ; mxRight=x2
+	jmp @@PlaneInitSync                              ; we're done initializing x,y params
+@@RightHandDiscontinuous:                          ; RightHandDiscontinuous sync address
+  mov scanMode,0001h                               ; set mode for traversal
+	mov ebx,[esi].DirectTriEdge@@my1                 ; move y1 to ebx register
+	sub ebx,[esi].DirectTriEdge@@my0                 ; ebx has (y1-y0), this is dy
+	mov eax,[esi].DirectTriEdge@@mx1                 ; move x1 to eax register
+	sub eax,[esi].DirectTriEdge@@mx0                 ; eax has (x1-x0)
+	shl eax,BitShift                                 ; multiply result by 2048 for precision
+	divide eax,ebx                                   ; eax has (x1-x0)/(y1-y0)
+	mov [esi].DirectTriEdge@@mDXLeft,eax             ; this is mDXLeft
+	mov ebx,[esi].DirectTriEdge@@my2                 ; move y2 into ebx register
+	sub ebx,[esi].DirectTriEdge@@my0                 ; ebx has (y2-y0), this is dy
+	mov eax,[esi].DirectTriEdge@@mx2                 ; move x2 into eax register
+	sub eax,[esi].DirectTriEdge@@mx0                 ; eax has (x2-x0)
+	shl eax,BitShift                                 ; multiply eax by 2048 for precision
+	divide eax,ebx                                   ; eax has (x2-x0)/(y2-y0)
+	mov [esi].DirectTriEdge@@mDXRight,eax            ; this is mDXRight
+	mov eax,[esi].DirectTriEdge@@mx0                 ; move x0 into eax register
+	shl eax,BitShift                                 ; adjust mxLeft/mxRight for precision
+	mov [esi].DirectTriEdge@@mxLeft,eax              ; move x0 into mxLeft
+	mov [esi].DirectTriEdge@@mxRight,eax             ; move x0 into mxRight
+  jmp @@PlaneInitSync                              ; we're done initializing x,y params
+@@LeftHandDiscontinuous:                           ; LeftHandDiscontinuous sync address
+  mov scanMode,0002h                               ; set mode for traversal
+	mov ebx,[esi].DirectTriEdge@@my2                 ; move y2 into ebx register
+	sub ebx,[esi].DirectTriEdge@@my0                 ; subtract (y2-y0), this is dy
+	mov eax,[esi].DirectTriEdge@@mx2                 ; move x2 into eax register
+	sub eax,[esi].DirectTriEdge@@mx0                 ; subtract x2-x0
+	shl eax,BitShift                                 ; multiply by 2048 for precision
+	divide eax,ebx                                   ; eax has (x2-x0)/(y2-y0)
+	mov [esi].DirectTriEdge@@mDXLeft,eax             ; this is mDXLeft
+	mov ebx,[esi].DirectTriEdge@@my1                 ; move y1 into ebx register
+	sub ebx,[esi].DirectTriEdge@@my0                 ; subtract (y1-y0), this is dy
+	mov eax,[esi].DirectTriEdge@@mx1                 ; move x1 into eax register
+	sub eax,[esi].DirectTriEdge@@mx0                 ; subtract (x0-x1)
+	shl eax,BitShift                                 ; multiply by 2048 for precision
+	divide eax,ebx                                   ; divide (x1-x0)/(y1-y0)
+	mov [esi].DirectTriEdge@@mDXRight,eax            ; this is mDXRight
+	mov eax,[esi].DirectTriEdge@@mx0                 ; move x0 into eax register
+	shl eax,BitShift                                 ; adjust mxLeft/mxRight for precision
+	mov [esi].DirectTriEdge@@mxLeft,eax              ; mxLeft=x0
+	mov [esi].DirectTriEdge@@mxRight,eax             ; mxRight=x0
+  jmp @@PlaneInitSync                              ; we're done initializing x,y params
+@@PlaneInitSync:                                   ; PlaneInitSync address
+  mov eax,[esi].DirectTriEdge@@mu2                 ; move u2 into eax
+	sub eax,[esi].DirectTriEdge@@mu0								 ; eax has (u2-u0)
+	shl eax,BitShift					  										 ; multiply result by 2048 for precision
+	divide eax,ebx																	 ; eax has (u2-u0)/(y2-y0)
+	mov [esi].DirectTriEdge@@mDULeft,eax             ; this is mDULeft
+	mov eax,[esi].DirectTriEdge@@mu1                 ; move u1 into eax
+	sub eax,[esi].DirectTriEdge@@mu0                 ; eax has (u1-u0)
+	shl eax,BitShift																 ; multiply result by 2048 for precision
+	divide eax,ebx                                   ; eax has (u1-u0)/(y2-y0)
+	mov [esi].DirectTriEdge@@mDURight,eax            ; this is mDURight
+	mov eax,[esi].DirectTriEdge@@mv2                 ; move v2 into eax
+	sub eax,[esi].DirectTriEdge@@mv0                 ; eax has (v2-v0)
+	shl eax,BitShift                                 ; multiply result by 2048 for precision
+	divide eax,ebx																	 ; eax has (v2-v0)/(y2-y0)
+	mov [esi].DirectTriEdge@@mDVLeft,eax             ; this is mDVLeft
+  mov eax,[esi].DirectTriEdge@@mv1                 ; move v1 into eax
+	sub eax,[esi].DirectTriEdge@@mv0                 ; eax has (v1-v0)
+	shl eax,BitShift                                 ; multiply result by 2048 for precision
+	divide eax,ebx																	 ; eax has (v1-v0)/(y2-y0)
+	mov [esi].DirectTriEdge@@mDVRight,eax            ; this is mDVRight
+	mov eax,[esi].DirectTriEdge@@mu0                 ; move u0 into eax
+	mov [esi].DirectTriEdge@@muLeft,eax              ; muLeft=u0
+	mov [esi].DirectTriEdge@@muRight,eax             ; muRight=u0
+	mov eax,[esi].DirectTriEdge@@mv0                 ; move v0 into eax
+	mov [esi].DirectTriEdge@@mvLeft,eax              ; mvLeft=v0
+	mov [esi].DirectTriEdge@@mvRight,eax             ; mvRight=v0
+	jmp @@InitSuccess																 ; jump over failure code
+@@InitFail:                                        ; InitFail sync address
+  stc                                              ; Carry Flag set on failure
+@@InitSuccess:                                     ; InitSuccess sync address
+ENDM
+
+_directTriSetSrcBitmapInfo proc near ; void setSrcBitmapInfo(WORD width,WORD height,UHUGE *lpBitmapImage)
+	push  ebp                                        ; save old stack frame
+	mov   ebp,esp                                    ; create new stack frame
+	push  eax                                        ; save eax register
+	push  ebx                                        ; save ebx register
+	mov   eax,dword ptr[ebp+08h]                     ; move width into eax register
+	mov   bmData@@mSrcWidth,eax                      ; move width into bmData@@mSrcWidth
+	mov   ebx,dword ptr[ebp+0Ch]                     ; move height into ebx register
+	mov   bmData@@mSrcHeight,ebx                     ; move height into ebx register
+	imul eax,ebx                                     ; multiply width*height, result to eax
+	mov   bmData@@mSrcExtent,eax                     ; (width*height) to mSrcExtent
+	push  dword ptr[ebp+10h]                         ; save lpBitmapImage on stack
+	pop   bmData@@mlpSrcPtr                          ; restore in mlpSrcPtr
+	pop   ebx                                        ; restore ebx register
+	pop   eax                                        ; restore eax register
+	pop   ebp                                        ; restore old stack frame
+	retn                                             ; return near to caller
+_directTriSetSrcBitmapInfo endp
+_directTriSetDstBitmapInfo proc near    ; void setDstBitmapInfo(WORD width,WORD height,WORD pitch,UHUGE *lpBitmapImage)
+	push  ebp                                        ; save old stack frame
+	mov   ebp,esp                                    ; create new stack frame
+	push  eax                                        ; save eax register
+	push  ebx                                        ; save ebx register
+	mov   eax,dword ptr[ebp+10h]                     ; move pitch into eax register
+	mov   bmData@@mDstPitch,eax                      ; move pitch into mDstPitch
+	mov   eax,dword ptr[ebp+08h]                     ; move width into eeax register
+	mov   bmData@@mDstWidth,eax                      ; move width into mDstWidth
+	mov   ebx,dword ptr[ebp+0Ch]                     ; move height into ebx register
+	mov   bmData@@mDstHeight,ebx                     ; move height into mDstHeight
+	imul  eax,ebx                                    ; multiply width*height, result to eax
+	mov   bmData@@mDstExtent,eax                     ; move (width*height) into mDstExtent
+	push  dword ptr[ebp+14h]                         ; save lpBitmapImage on stack
+	pop   bmData@@mlpDstPtr                          ; restore in mlpDstPtr
+	pop   ebx                                        ; restore ebx register
+	pop   eax                                        ; restore eax register
+	pop   ebp                                        ; restore old stack frame
+	retn                                             ; return near to caller
+_directTriSetDstBitmapInfo endp
+
+_directTriSetPixelCallback proc near
+  push ebp
+	mov ebp,esp
+	mov eax,[ebp+08h]
+	mov bmData@@mlpPixelCallback,eax
+	pop ebp
+	retn
+_directTriSetPixelCallback endp
+
+_directTriSetEdgeCallback proc near
+  push ebp
+	mov ebp,esp
+	mov eax,[ebp+08h]
+	mov bmData@@mlpEdgeCallback,eax
+	pop ebp
+	retn
+_directTriSetEdgeCallback endp
+
+_directTriMapTexture proc near                     ; void directTriMapTexture(DirectTriEdge *pEdge)
+LOCAL y:DWORD,x:DWORD,du:DWORD,dv:DWORD,ui:DWORD,vi:DWORD,scanMode:DWORD=LocalLength ; local variables for proc
+  push ebp                                         ; save prior stack frame
+	mov  ebp,esp                                     ; create new frame
+	sub esp,LocalLength                              ; make room for local variables
+	pushad                                           ; save all general purpose registers
+	mov esi,[ebp+08h]                                ; move pEdge to esi register
+	clc                                              ; clear the carry flag
+	initialize                                       ; initialize the edge
+	jc @@verticalLoopEnd                             ; if we failed to initialize edge then return
+	mov eax,[esi].DirectTriEdge@@my0                 ; move y0 into eax
+	mov y,eax                                        ; initialize y with y0 
+@@verticalLoop:                                    ; beginning of vertical loop
+	mov ecx,[esi].DirectTriEdge@@my1                 ; move y1 into ecx
+	cmp y,ecx                                        ; compare y to y1
+	jg @@verticalLoopEnd                             ; if y>y1 then we're done
+	scanline                                         ; perform scanline on the horizontal
+	increment                                        ; increment along the vertical
+	edgeCallback                                     ; call the edge handler
+	jmp @@verticalLoop                               ; continue execution
+@@verticalLoopEnd:                                 ; end loop sync address
+  popad                                            ; restore all general purpose registers
+	add esp,LocalLength                              ; remove local variables from frame
+	pop  ebp                                         ; restore prior stack frame
+	retn                                             ; return near to caller
+_directTriMapTexture endp
+public _directTriSetSrcBitmapInfo
+public _directTriSetDstBitmapInfo
+public _directTriMapTexture
+public _directTriSetPixelCallback
+public _directTriSetEdgeCallback
+
+END

ddraw/HOLD/TRIMAP32.INC

@@ -0,0 +1,32 @@
+;********************************************************************************************************
+; FILE:TRIMAP32.INC
+; FUNCTION: INCLUDE FILE FOR ASM TRIANGLE TEXTURE MAPPING (DIRECT DRAW VERSION)
+; AUTHOR:SEAN M. KESSLER
+;********************************************************************************************************
+DirectTriEdge STRUC
+  DirectTriEdge@@vfptr    DD ?
+	DirectTriEdge@@mDXLeft 	DD ?
+	DirectTriEdge@@mDXRight	DD ?
+	DirectTriEdge@@mDULeft	DD ?
+	DirectTriEdge@@mDURight	DD ?
+	DirectTriEdge@@mDVLeft	DD ?
+	DirectTriEdge@@mDVRight DD ?
+	DirectTriEdge@@mxLeft	  DD ?
+	DirectTriEdge@@mxRight  DD ?
+	DirectTriEdge@@mvLeft	  DD ?
+	DirectTriEdge@@mvRight  DD ?
+	DirectTriEdge@@muLeft	  DD ?
+	DirectTriEdge@@muRight  DD ?
+	DirectTriEdge@@mx0      DD ?
+	DirectTriEdge@@my0		  DD ?
+	DirectTriEdge@@mx1		  DD ?
+	DirectTriEdge@@my1		  DD ?
+	DirectTriEdge@@mx2		  DD ?
+	DirectTriEdge@@my2		  DD ?
+	DirectTriEdge@@mu0		  DD ?
+	DirectTriEdge@@mv0		  DD ?
+	DirectTriEdge@@mu1		  DD ?
+	DirectTriEdge@@mv1	 	  DD ?
+	DirectTriEdge@@mu2 		  DD ?
+	DirectTriEdge@@mv2		  DD ?
+DirectTriEdge ENDS

ddraw/HOLD/TRITEXTR.CPP

@@ -0,0 +1,113 @@
+#include <ddraw/tritextr.hpp>
+#include <common/bitmap.hpp>
+#include <common/dib.hpp>
+#include <common/file.hpp>
+#include <engine/device3d.hpp>
+#include <ddraw/drawsfc.hpp>
+
+File outFile("output.dat","wb");
+
+DirectTriTexture::DirectTriTexture(const Triangle3D &angle3D,Bitmap &textureBitmap,DIBitmap &drawingSurface,Device3D &displayDevice,MapFrom mapFrom)
+{
+  mTriangle3D=angle3D;
+	displayDevice.mapCoordinates(mTriangle3D,mTriangle);
+//	mTriangle.orderPoints();
+	mTriEdge.x0(mTriangle[0].x());
+	mTriEdge.y0(mTriangle[0].y());
+	mTriEdge.x1(mTriangle[1].x());
+	mTriEdge.y1(mTriangle[1].y());
+	mTriEdge.x2(mTriangle[2].x());
+	mTriEdge.y2(mTriangle[2].y());
+	if(MapFromUpperRight==mapFrom)
+	{
+	  mTriEdge.u0(0);
+		mTriEdge.v0(0);
+		mTriEdge.u1(textureBitmap.width()-1);
+ 		mTriEdge.v1(0);
+		mTriEdge.u2(textureBitmap.width()-1);
+		mTriEdge.v2(textureBitmap.height()-1);
+	}
+	else
+	{
+	  mTriEdge.u0(0);
+		mTriEdge.v0(0);
+		mTriEdge.u1(textureBitmap.width()-1);
+		mTriEdge.v1(textureBitmap.height()-1);
+		mTriEdge.u2(0);
+		mTriEdge.v2(textureBitmap.height()-1);
+	}
+	::directTriSetSrcBitmapInfo(textureBitmap.width(),textureBitmap.height(),textureBitmap.getDataPtr());
+	::directTriSetDstBitmapInfo(drawingSurface.width(),drawingSurface.height(),drawingSurface.width(),(unsigned char*)drawingSurface.ptrData());
+	::directTriSetPixelCallback(&DirectTriTexture::pixelCallback);
+	::directTriSetEdgeCallback(&DirectTriTexture::edgeCallback);
+}
+
+DirectTriTexture::DirectTriTexture(const Triangle3D &angle3D,Bitmap &textureBitmap,DrawingSurface &drawingSurface,Device3D &displayDevice,MapFrom mapFrom)
+{
+  mTriangle3D=angle3D;
+	displayDevice.mapCoordinates(mTriangle3D,mTriangle);
+//	mTriangle.orderPoints();
+	mTriEdge.x0(mTriangle[0].x());
+	mTriEdge.y0(mTriangle[0].y());
+	mTriEdge.x1(mTriangle[1].x());
+	mTriEdge.y1(mTriangle[1].y());
+	mTriEdge.x2(mTriangle[2].x());
+	mTriEdge.y2(mTriangle[2].y());
+	if(MapFromUpperRight==mapFrom)
+	{
+	  mTriEdge.u0(0);
+		mTriEdge.v0(0);
+		mTriEdge.u1(textureBitmap.width()-1);
+		mTriEdge.v1(0);
+		mTriEdge.u2(textureBitmap.width()-1);
+		mTriEdge.v2(textureBitmap.height()-1);
+	}
+	else
+	{
+	  mTriEdge.u0(0);
+		mTriEdge.v0(0);
+		mTriEdge.u1(textureBitmap.width()-1);
+		mTriEdge.v1(textureBitmap.height()-1);
+		mTriEdge.u2(0);
+		mTriEdge.v2(textureBitmap.height()-1);
+	}
+	::directTriSetSrcBitmapInfo(textureBitmap.width(),textureBitmap.height(),textureBitmap.getDataPtr());
+	::directTriSetDstBitmapInfo(drawingSurface.width(),drawingSurface.height(),drawingSurface.pitch(),(unsigned char*)drawingSurface.ptrSurface());
+	::directTriSetPixelCallback(&DirectTriTexture::pixelCallback);
+	::directTriSetEdgeCallback(&DirectTriTexture::edgeCallback);
+}
+
+DirectTriTexture::~DirectTriTexture()
+{
+}
+
+void DirectTriTexture::mapTexture(void)
+{
+  ::directTriMapTexture(&mTriEdge);
+}
+
+void DirectTriTexture::pixelCallback(int y,int x,int vi,int ui)
+{
+#if 0
+  String strDebug;
+
+  if(!y&&!x&&!vi&&!ui)outFile.writeLine("scanline");
+	else
+	{
+	  ::sprintf(strDebug,"ui: %d vi:%d x:%d y:%d",ui,vi,x,y);
+	  outFile.writeLine(strDebug);
+	}
+#endif
+}
+
+void DirectTriTexture::edgeCallback(DirectTriEdge *pEdge)
+{
+#if 0
+  String strDebug;
+	strDebug.reserve(1024);
+	::sprintf(strDebug,"xLeft:%d xRight:%d uLeft:%d uRight:%d vLeft:%d vRight:%d dxLeft:%d dxRight:%d duLeft:%d duRight:%d dvLeft:%d duRight:%d",
+    int((float)pEdge->xLeft()/2048.00),int((float)pEdge->xRight()/2048.00),int((float)pEdge->uLeft()/2048.00),int((float)pEdge->uRight()/2048.00),int((float)pEdge->vLeft()/2048.00),int((float)pEdge->vRight()/2048.00),
+		int((float)pEdge->dxLeft()/2048.00),int((float)pEdge->dxRight()/2048.00),int((float)pEdge->duLeft()/2048.00),int((float)pEdge->duRight()/2048.00),int((float)pEdge->dvLeft()/2048.00),int((float)pEdge->dvRight()/2048.00));
+	outFile.writeLine(strDebug);
+#endif
+}

ddraw/HOLD/TRITEXTR.HPP

@@ -0,0 +1,42 @@
+#ifndef _DDRAW_DIRECTTRITEXTURE_HPP_
+#define	_DDRAW_DIRECTTRITEXTURE_HPP_
+#ifndef _ENGINE_TRIANGLE3D_HPP_
+#include <engine/angle3d.hpp>
+#endif
+#ifndef _ENGINE_TRIANGLE_HPP_
+#include <engine/angle.hpp>
+#endif
+#ifndef _DDRAW_TRIEDGE_HPP_
+#include <ddraw/triedge.hpp>
+#endif
+
+class Bitmap;
+class DrawingSurface;
+class Device3D;
+class DIBitmap;
+
+extern "C"
+{
+  void directTriSetSrcBitmapInfo(DWORD width,DWORD height,unsigned char *lpSrcBitmapImage);
+	void directTriSetDstBitmapInfo(DWORD width,DWORD height,DWORD pitch,unsigned char *lpDstBitmapImage);
+	void directTriMapTexture(DirectTriEdge *pDirectTriEdge);
+	void directTriSetPixelCallback(void (*PFNPIXELCALLBACK)(int ui,int vi,int x,int y));
+	void directTriSetEdgeCallback(void (*PFNEDGECALLBACK)(DirectTriEdge *pEdge));
+}
+
+class DirectTriTexture
+{
+public:
+  enum MapFrom{MapFromUpperRight,MapFromLowerLeft};
+	DirectTriTexture(const Triangle3D &angle3D,Bitmap &textureBitmap,DrawingSurface &drawingSurface,Device3D &displayDevice,MapFrom mapFrom=MapFromUpperRight);
+	DirectTriTexture(const Triangle3D &angle3D,Bitmap &textureBitmap,DIBitmap &drawingSurface,Device3D &displayDevice,MapFrom mapFrom=MapFromUpperRight);
+	virtual ~DirectTriTexture();
+	void mapTexture(void);
+private:
+  static void pixelCallback(int ui,int vi,int x,int y);
+	static void edgeCallback(DirectTriEdge *pEdge);
+  Triangle3D mTriangle3D;
+	Triangle mTriangle;
+	DirectTriEdge mTriEdge;
+};
+#endif

ddraw/MAIN.CPP

@@ -0,0 +1,8 @@
+#include <common/windows.hpp>
+#include <ddraw/mainwnd.hpp>
+
+int PASCAL WinMain(HINSTANCE /*hInstance*/,HINSTANCE /*hPrevInstance*/,LPSTR /*lpszCmdLine*/,int /*nCmdShow*/)
+{
+	MainWindow mainWindow;
+	return mainWindow.messageLoop();
+}

ddraw/MAINWND.CPP

@@ -0,0 +1,393 @@
+//#define _USEDIRECTDRAW_
+#include <ddraw/mainwnd.hpp>
+#include <ddraw/draw.hpp>
+#include <ddraw/sfccaps.hpp>
+#include <ddraw/sfcdesc.hpp>
+#include <ddraw/surface.hpp>
+#include <ddraw/pixform.hpp>
+#include <ddraw/texture.hpp>
+#include <engine/device3d.hpp>
+#include <engine/texture.hpp>
+#include <common/keydata.hpp>
+#include <stdio.h>
+
+char MainWindow::szClassName[]="DDrawTest";
+char MainWindow::szMenuName[]="";
+
+MainWindow::MainWindow(void)
+: mTextureBitmap("c:\\work\\scene\\media\\bmp\\FLAT221.bmp")
+{
+  mPaintHandler.setCallback(this,&MainWindow::paintHandler);
+	mDestroyHandler.setCallback(this,&MainWindow::destroyHandler);
+	mCommandHandler.setCallback(this,&MainWindow::commandHandler);
+	mKeyDownHandler.setCallback(this,&MainWindow::keyDownHandler);
+	mKeyUpHandler.setCallback(this,&MainWindow::keyUpHandler);
+	mSizeHandler.setCallback(this,&MainWindow::sizeHandler);
+	mCreateHandler.setCallback(this,&MainWindow::createHandler);
+	mTimerHandler.setCallback(this,&MainWindow::timerHandler);
+	mActivateAppHandler.setCallback(this,&MainWindow::activateAppHandler);
+	mDisplayChangeHandler.setCallback(this,&MainWindow::displayChangeHandler);
+	mDialogCodeHandler.setCallback(this,&MainWindow::dialogCodeHandler);
+	insertHandlers();
+	registerClass();
+	::CreateWindow(szClassName,szClassName,
+		WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_MAXIMIZEBOX|WS_DLGFRAME|WS_CLIPCHILDREN|WS_SIZEBOX,
+		CW_USEDEFAULT,CW_USEDEFAULT,
+		CW_USEDEFAULT,CW_USEDEFAULT,
+		NULL,NULL,processInstance(),(LPSTR)this);
+	show(SW_SHOW);
+	update();
+}
+
+MainWindow::~MainWindow()
+{
+	destroy();
+}
+
+void MainWindow::insertHandlers(void)
+{
+	insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	insertHandler(VectorHandler::PaintHandler,&mPaintHandler);
+	insertHandler(VectorHandler::CommandHandler,&mCommandHandler);
+	insertHandler(VectorHandler::SizeHandler,&mSizeHandler);
+	insertHandler(VectorHandler::KeyDownHandler,&mKeyDownHandler);
+	insertHandler(VectorHandler::KeyUpHandler,&mKeyUpHandler);
+	insertHandler(VectorHandler::CreateHandler,&mCreateHandler);
+	insertHandler(VectorHandler::TimerHandler,&mTimerHandler);
+	insertHandler(VectorHandler::ActivateAppHandler,&mActivateAppHandler);
+	insertHandler(VectorHandler::DisplayChangeHandler,&mDisplayChangeHandler);
+	insertHandler(VectorHandler::DialogCodeHandler,&mDialogCodeHandler);
+}
+
+void MainWindow::removeHandlers(void)
+{
+	removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	removeHandler(VectorHandler::PaintHandler,&mPaintHandler);
+	removeHandler(VectorHandler::CommandHandler,&mCommandHandler);
+	removeHandler(VectorHandler::SizeHandler,&mSizeHandler);
+	removeHandler(VectorHandler::KeyDownHandler,&mKeyDownHandler);
+	insertHandler(VectorHandler::KeyDownHandler,&mKeyDownHandler);
+	removeHandler(VectorHandler::CreateHandler,&mCreateHandler);
+	removeHandler(VectorHandler::TimerHandler,&mTimerHandler);
+	removeHandler(VectorHandler::ActivateAppHandler,&mActivateAppHandler);
+	removeHandler(VectorHandler::DisplayChangeHandler,&mDisplayChangeHandler);
+	removeHandler(VectorHandler::DialogCodeHandler,&mDialogCodeHandler);
+}
+                                      
+void MainWindow::registerClass(void)const
+{
+	WNDCLASS wndClass;
+
+	if(::GetClassInfo(processInstance(),className(),(WNDCLASS FAR*)&wndClass))return;
+	wndClass.style         =CS_HREDRAW|CS_VREDRAW|CS_OWNDC|CS_DBLCLKS;
+	wndClass.lpfnWndProc   =(WNDPROC)Window::WndProc;
+	wndClass.cbClsExtra    =0;
+	wndClass.cbWndExtra    =sizeof(MainWindow*);
+	wndClass.hInstance     =processInstance();
+  wndClass.hIcon         =::LoadIcon(NULL,IDI_APPLICATION);
+	wndClass.hCursor       =::LoadCursor(NULL,IDC_ARROW);
+	wndClass.hbrBackground =(HBRUSH)::GetStockObject(BLACK_BRUSH);
+	wndClass.lpszMenuName  =szMenuName;
+	wndClass.lpszClassName =szClassName;
+	::RegisterClass(&wndClass);
+	assert(0!=::GetClassInfo(processInstance(),className(),(WNDCLASS FAR*)&wndClass));
+}
+
+#if defined(_USEDIRECTDRAW_)
+CallbackData::ReturnType MainWindow::createHandler(CallbackData &/*someCallbackData*/)
+{
+  SurfaceCapabilities surfaceCapabilities(SurfaceCapabilities::Capabilities(SurfaceCapabilities::PrimarySurface|SurfaceCapabilities::Device3D));
+	SurfaceDescription surfaceDescription;
+
+	mDevice3D=::new Device3D(*this);
+  mDevice3D.disposition(PointerDisposition::Delete);
+	mDevice3D->focusPoint(Point3D(0,0,-1));
+  mDirectDraw=::new DirectDraw();
+	mDirectDraw.disposition(PointerDisposition::Delete);
+	mDirectDraw->setCooperativeLevel(*this,DirectDraw::CoopFlags(DirectDraw::Exclusive|DirectDraw::FullScreen));
+	mDirectDraw->setDisplayMode(DisplayWidth,DisplayHeight,DisplayBPP);
+  surfaceDescription.flags(SurfaceDescription::Capabilities);
+  surfaceDescription.surfaceCapabilities(surfaceCapabilities);
+	if(!mDirectDraw->createSurface(surfaceDescription,mPrimarySurface).okResult())return FALSE;
+  mDirectPalette.readPalette("c:\\work\\scene\\media\\bmp\\redwall1.pal");
+//  mDirectPalette.systemPalette();
+  mDirectDraw->createPalette(mDirectPalette);
+	mPrimarySurface.setPalette(mDirectPalette);
+	mPrimarySurface.lock();
+	mPrimarySurface.unlock();
+//	mDirectDraw->createDirect3D(mPrimarySurface,mDirect3D,mDirectDevice3D);
+	return FALSE;
+}
+
+CallbackData::ReturnType MainWindow::destroyHandler(CallbackData &/*someCallbackData*/)
+{
+  mDirectPalette.destroy();
+  mDirectDevice3D.destroy();
+  mDirect3D.destroy();
+  mPrimarySurface.destroy();
+	mDirectDraw.destroy();
+	removeHandlers();
+	::PostQuitMessage(0);
+	return (CallbackData::ReturnType)FALSE;
+}
+#else
+CallbackData::ReturnType MainWindow::createHandler(CallbackData &/*someCallbackData*/)
+{
+//  PurePalette purePalette("c:\\work\\scene\\media\\bmp\\redwall1.pal");
+	mPalette="c:\\work\\scene\\media\\bmp\\redwall1.pal";
+	mDevice3D=::new Device3D(*this);
+  mDevice3D.disposition(PointerDisposition::Delete);
+	mDevice3D->focusPoint(Point3D(0,0,-1));
+	mDIBitmap=::new DIBitmap(*mDevice3D,width(),height(),mPalette);
+	mDIBitmap.disposition(PointerDisposition::Delete);
+	mPalette.usePalette(*mDevice3D,TRUE);
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::destroyHandler(CallbackData &/*someCallbackData*/)
+{
+	removeHandlers();
+	::PostQuitMessage(0);
+  return FALSE;
+}
+#endif
+
+CallbackData::ReturnType MainWindow::activateAppHandler(CallbackData &someCallbackData)
+{
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::displayChangeHandler(CallbackData &someCallbackData)
+{
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::sizeHandler(CallbackData &/*someCallbackData*/)
+{
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::commandHandler(CallbackData &someCallbackData)
+{
+	switch(someCallbackData.wmCommandID())
+	{
+	  default :
+		  break;
+	}
+	return (CallbackData::ReturnType)FALSE;
+}
+
+#if defined(_USEDIRECTDRAW_)
+CallbackData::ReturnType MainWindow::paintHandler(CallbackData &/*someCallbackData*/)
+{
+  Vector3D dstPoints;
+	Triangle3D angle3D;
+	Triangle angle;
+
+//	mDirectDraw->setCooperativeLevel(*this,DirectDraw::CoopFlags(DirectDraw::Normal));
+	mDirectDraw->setCooperativeLevel(*this,DirectDraw::CoopFlags(DirectDraw::Exclusive|DirectDraw::FullScreen));
+	mDirectDraw->setDisplayMode(DisplayWidth,DisplayHeight,DisplayBPP);
+	mDirectDraw->restoreAllSurfaces();
+
+//	dstPoints[0]=Point3D(-20,20,10);
+//	dstPoints[1]=Point3D(20,20,10);
+//	dstPoints[2]=Point3D(20,-20,10);
+//	dstPoints[3]=Point3D(-20,-20,10);
+	angle3D[0]=Point3D(-20,0,0);
+	angle3D[1]=Point3D(0,20,0);
+	angle3D[2]=Point3D(20,0,0);
+
+	mPrimarySurface.lock();
+	mPrimarySurface.clear();
+//	DirectTexture directTexture(dstPoints,mTextureBitmap,mPrimarySurface,*mDevice3D);
+  DirectTexture directTexture(angle3D,mTextureBitmap,mPrimarySurface,*mDevice3D);
+	directTexture.mapTexture();
+
+	mDevice3D->mapCoordinates(angle3D,angle);
+	mPrimarySurface.line(angle[0],angle[1],192);
+	mPrimarySurface.line(angle[1],angle[2],192);
+	mPrimarySurface.line(angle[2],angle[0],192);
+
+	mPrimarySurface.unlock();
+	return (CallbackData::ReturnType)FALSE;
+}
+#else
+CallbackData::ReturnType MainWindow::paintHandler(CallbackData &/*someCallbackData*/)
+{
+	Triangle3D angle3D[3];
+	Triangle angle;
+
+
+//VERTEX(-4,16,-25);
+//VERTEX(-24,16,-25);
+//VERTEX(-9,-10,11);
+//VERTEX(5,-19,0);
+//VERTEX(-11,12,-36);
+//VERTEX(-31,12,-36);
+//VERTEX(-11,-19,2);
+//VERTEX(3,-28,-8);
+//VERTEX(-2,1,-28);
+//VERTEX(-17,10,-17);
+//VERTEX(-10,14,-5);
+//VERTEX(4,5,-16);
+//SURFACE(3,0,2);
+//SURFACE(2,0,1);
+//SURFACE(7,3,2);
+//SURFACE(7,2,6);
+//SURFACE(3,7,0);
+//SURFACE(0,7,4);
+//SURFACE(0,4,1);
+//SURFACE(1,4,5);
+//SURFACE(6,2,1);
+//SURFACE(6,1,5);
+//SURFACE(5,4,6);
+//SURFACE(6,4,7);
+
+	(angle3D[0])[0]=Point3D(5,-19,0);
+	(angle3D[0])[1]=Point3D(-4,16,-25);
+	(angle3D[0])[2]=Point3D(-9,-10,11);
+
+	(angle3D[1])[0]=Point3D(-9,-10,11);
+	(angle3D[1])[1]=Point3D(-4,16,-25);
+	(angle3D[1])[2]=Point3D(-24,-16,-25);
+
+	(angle3D[2])[0]=Point3D(3,-28,-8);
+	(angle3D[2])[1]=Point3D(5,-19,0);
+	(angle3D[2])[2]=Point3D(-9,-10,11);
+
+//  Vector3D dstPoints;
+//	dstPoints[0]=Point3D(-20,20,10);
+//	dstPoints[1]=Point3D(20,20,10);
+//	dstPoints[2]=Point3D(20,-20,10);
+//	dstPoints[3]=Point3D(-20,-20,10);
+//	Texture texture(dstPoints,mTextureBitmap,*mDIBitmap,*mDevice3D);
+
+
+  mDIBitmap->clearBits();
+	for(int index=0;index<sizeof(angle3D)/sizeof(Triangle3D);index++)
+	{
+    Texture texture(angle3D[index],mTextureBitmap,*mDIBitmap,*mDevice3D,Texture::MapLowerLeft);
+	  texture.mapTexture();
+	}
+	for(index=0;index<sizeof(angle3D)/sizeof(Triangle3D);index++)
+	{
+	  mDevice3D->mapCoordinates(angle3D[index],angle);
+	  mDIBitmap->line(angle[0],angle[1],192);
+	  mDIBitmap->line(angle[1],angle[2],192);
+	  mDIBitmap->line(angle[2],angle[0],192);
+	}
+	mDIBitmap->bitBlt(*mDevice3D);
+
+#if 0
+  Triangle3D angle3D;
+	Triangle angle;
+
+  mDIBitmap->clearBits();
+	angle3D[0]=Point3D(0,0,0);
+	angle3D[1]=Point3D(128,0,0);
+	angle3D[2]=Point3D(0,128,0);
+  {
+    DirectTriTexture directTriTexture(angle3D,mTextureBitmap,*mDIBitmap,*mDevice3D);
+	  directTriTexture.mapTexture();
+	}
+	mDevice3D->mapCoordinates(angle3D,angle);
+	mDIBitmap->line(angle[0],angle[1],192);
+	mDIBitmap->line(angle[1],angle[2],192);
+	mDIBitmap->line(angle[2],angle[0],192);
+	mDIBitmap->bitBlt(*mDevice3D);
+#endif
+	return (CallbackData::ReturnType)FALSE;
+}
+#endif
+
+CallbackData::ReturnType MainWindow::timerHandler(CallbackData &/*someCallbackData*/)
+{
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::dialogCodeHandler(CallbackData &/*someCallbackData*/)
+{
+  return (CallbackData::ReturnType)DLGC_WANTALLKEYS;
+}
+
+CallbackData::ReturnType MainWindow::keyUpHandler(CallbackData &/*someCallbackData*/)
+{
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::keyDownHandler(CallbackData &someCallbackData)
+{
+	KeyData keyData(someCallbackData);
+	int repeatIndex;
+
+  switch(keyData.virtualKey())
+	{
+		case inKey :
+			if(shiftKeyPressed())mDevice3D->cameraTwistDegrees(mDevice3D->cameraTwistDegrees()-ThetaDelta);
+			mDevice3D->viewPlaneDistance(mDevice3D->viewPlaneDistance()+ViewDelta);
+      invalidate(FALSE);
+			break;
+		case outKey :
+			if(shiftKeyPressed())mDevice3D->cameraTwistDegrees(mDevice3D->cameraTwistDegrees()+ThetaDelta);
+			mDevice3D->viewPlaneDistance(mDevice3D->viewPlaneDistance()-ViewDelta);
+			invalidate(FALSE);
+			break;
+		case VK_UP :
+		  for(repeatIndex=0;repeatIndex<keyData.repeatCount();repeatIndex++)if(!handleUpArrow())break;
+			invalidate(FALSE);
+			break;
+		case VK_DOWN :
+      for(repeatIndex=0;repeatIndex<keyData.repeatCount();repeatIndex++)if(!handleDownArrow())break;
+			invalidate(FALSE);
+			break;
+		case VK_LEFT :
+      for(repeatIndex=0;repeatIndex<keyData.repeatCount();repeatIndex++)if(!handleLeftArrow())break;
+			invalidate(FALSE);
+			break;
+		case VK_RIGHT :
+      for(repeatIndex=0;repeatIndex<keyData.repeatCount();repeatIndex++)if(!handleRightArrow())break;
+			invalidate(FALSE);
+			break;
+	}
+	return (CallbackData::ReturnType)FALSE;
+}
+
+WORD MainWindow::handleUpArrow(void)
+{
+	Point3D cameraPoint(mDevice3D->cameraPoint());
+	cameraPoint.y(cameraPoint.y()+TurnDelta);
+	mDevice3D->cameraPoint(cameraPoint);
+	return TRUE;
+}
+
+WORD MainWindow::handleDownArrow(void)
+{
+	Point3D cameraPoint(mDevice3D->cameraPoint());
+	cameraPoint.y(cameraPoint.y()-TurnDelta);
+	mDevice3D->cameraPoint(cameraPoint);
+	return TRUE;
+}
+
+WORD MainWindow::handleLeftArrow(void)
+{
+	Point3D cameraPoint(mDevice3D->cameraPoint());
+	if(shiftKeyPressed())mDevice3D->cameraTwistDegrees(mDevice3D->cameraTwistDegrees()-ThetaDelta);
+	else cameraPoint.x(cameraPoint.x()+TurnDelta);
+	mDevice3D->cameraPoint(cameraPoint);
+	return TRUE;
+}
+
+WORD MainWindow::handleRightArrow(void)
+{
+	Point3D cameraPoint(mDevice3D->cameraPoint());
+	if(shiftKeyPressed())mDevice3D->cameraTwistDegrees(mDevice3D->cameraTwistDegrees()+ThetaDelta);
+  else cameraPoint.x(cameraPoint.x()-TurnDelta);
+  mDevice3D->cameraPoint(cameraPoint);
+	return TRUE;
+}
+
+inline
+WORD MainWindow::shiftKeyPressed(void)const
+{
+  return ::GetKeyState(VK_SHIFT)&0x8000;
+}

ddraw/MAINWND.HPP

@@ -0,0 +1,97 @@
+#ifndef _DDRAW_MAINWINDOW_HPP_
+#define _DDRAW_MAINWINDOW_HPP_
+#ifndef _COMMON_WINDOW_HPP_
+#include <common/window.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _COMMON_SMARTPOINTER_HPP_
+#include <common/pointer.hpp>
+#endif
+#ifndef _COMMON_DIBITMAP_HPP_
+#include <common/dib.hpp>
+#endif
+#ifndef _COMMON_BITMAP_HPP_
+#include <common/bitmap.hpp>
+#endif
+#ifndef _DDRAW_DRAWINGSURFACE_HPP_
+#include <ddraw/drawsfc.hpp>
+#endif
+#ifndef _DDRAW_DIRECT3D_HPP_
+#include <ddraw/direct3d.hpp>
+#endif
+#ifndef _DDRAW_DEVICE3D_HPP_
+#include <ddraw/device3d.hpp>
+#endif
+#ifndef _DDRAW_DIRECTPALETTE_HPP_
+#include <ddraw/palette.hpp>
+#endif
+
+class DirectDraw;
+class Device3D;
+
+class MainWindow : public Window
+{
+public:
+	MainWindow(void);
+	virtual ~MainWindow();
+	static String className(void);
+private:
+	enum {MaxRotate=360,MinRotate=-360};
+	enum {ThetaDelta=10,ViewDelta=5,TurnDelta=20};
+	enum {inKey=0x49,outKey=0x4F};
+  enum{DisplayWidth=640,DisplayHeight=480,DisplayBPP=8};
+	CallbackData::ReturnType paintHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType destroyHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType commandHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType keyDownHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType keyUpHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType sizeHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType timerHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType createHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType activateAppHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType displayChangeHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType dialogCodeHandler(CallbackData &someCallbackData);
+
+  WORD shiftKeyPressed(void)const;
+  WORD handleUpArrow(void);
+  WORD handleDownArrow(void);
+  WORD handleLeftArrow(void);
+  WORD handleRightArrow(void);
+	void registerClass(void)const;
+	void insertHandlers(void);
+	void removeHandlers(void);
+
+  Callback<MainWindow> mActivateAppHandler;
+	Callback<MainWindow> mDisplayChangeHandler;
+	Callback<MainWindow> mPaintHandler;
+	Callback<MainWindow> mDestroyHandler;
+	Callback<MainWindow> mCommandHandler;
+	Callback<MainWindow> mKeyDownHandler;
+	Callback<MainWindow> mSizeHandler;
+	Callback<MainWindow> mTimerHandler;
+	Callback<MainWindow> mCreateHandler;
+	Callback<MainWindow> mKeyUpHandler;
+	Callback<MainWindow> mDialogCodeHandler;
+	static char szClassName[];
+	static char szMenuName[];
+	SmartPointer<DirectDraw> mDirectDraw;
+	DrawingSurface mPrimarySurface;
+	Direct3D mDirect3D;
+  DirectDevice3D mDirectDevice3D;
+	DirectPalette mDirectPalette;
+	SmartPointer<Device3D> mDevice3D;
+	SmartPointer<DIBitmap> mDIBitmap;
+	Bitmap mTextureBitmap;
+	PurePalette mPalette;
+};
+
+inline
+String MainWindow::className(void)
+{
+	return String(szClassName);
+}
+#endif
+
+

ddraw/MATRIX.HPP

@@ -0,0 +1,9 @@
+#ifndef _DDRAW_MATRIX_HPP_
+#define _DDRAW_MATRIX_HPP_
+#ifndef _DDRAW_DDRAW_HPP_
+#include <ddraw/ddraw.hpp>
+#endif
+
+typedef D3DMATRIX Matrix;
+#endif
+

ddraw/MSDRAW.BAK

@@ -0,0 +1,782 @@
+# Microsoft Developer Studio Generated NMAKE File, Format Version 4.20
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+!IF "$(CFG)" == ""
+CFG=msdraw - Win32 Debug
+!MESSAGE No configuration specified.  Defaulting to msdraw - Win32 Debug.
+!ENDIF 
+
+!IF "$(CFG)" != "msdraw - Win32 Release" && "$(CFG)" != "msdraw - Win32 Debug"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE on this makefile
+!MESSAGE by defining the macro CFG on the command line.  For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "msdraw.mak" CFG="msdraw - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "msdraw - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "msdraw - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE 
+NULL=nul
+!ENDIF 
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "msdraw - Win32 Debug"
+CPP=cl.exe
+
+!IF  "$(CFG)" == "msdraw - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+OUTDIR=.\Release
+INTDIR=.\Release
+
+ALL : "$(OUTDIR)\msdraw.lib"
+
+CLEAN : 
+	-@erase "$(INTDIR)\devenum.obj"
+	-@erase "$(INTDIR)\direct3d.obj"
+	-@erase "$(INTDIR)\draw.obj"
+	-@erase "$(INTDIR)\drawsfc.obj"
+	-@erase "$(INTDIR)\dspenum.obj"
+	-@erase "$(INTDIR)\palette.obj"
+	-@erase "$(INTDIR)\texture.obj"
+	-@erase "$(OUTDIR)\msdraw.lib"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+CPP_PROJ=/nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS"\
+ /Fp"$(INTDIR)/msdraw.pch" /YX /Fo"$(INTDIR)/" /c 
+CPP_OBJS=.\Release/
+CPP_SBRS=.\.
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/msdraw.bsc" 
+BSC32_SBRS= \
+	
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/msdraw.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)\devenum.obj" \
+	"$(INTDIR)\direct3d.obj" \
+	"$(INTDIR)\draw.obj" \
+	"$(INTDIR)\drawsfc.obj" \
+	"$(INTDIR)\dspenum.obj" \
+	"$(INTDIR)\palette.obj" \
+	"$(INTDIR)\texture.obj"
+
+"$(OUTDIR)\msdraw.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "msdraw - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "msvcobj"
+# PROP Intermediate_Dir "msvcobj"
+# PROP Target_Dir ""
+OUTDIR=.\msvcobj
+INTDIR=.\msvcobj
+
+ALL : "..\exe\msdraw.lib"
+
+CLEAN : 
+	-@erase "$(INTDIR)\devenum.obj"
+	-@erase "$(INTDIR)\direct3d.obj"
+	-@erase "$(INTDIR)\draw.obj"
+	-@erase "$(INTDIR)\drawsfc.obj"
+	-@erase "$(INTDIR)\dspenum.obj"
+	-@erase "$(INTDIR)\palette.obj"
+	-@erase "$(INTDIR)\texture.obj"
+	-@erase "$(INTDIR)\tmap32.obj"
+	-@erase "..\exe\msdraw.lib"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /Zp1 /MTd /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /Fp"..\exe\msvc42.pch" /YX /c
+CPP_PROJ=/nologo /Zp1 /MTd /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D\
+ "STRICT" /D "__FLAT__" /Fp"..\exe\msvc42.pch" /YX /Fo"$(INTDIR)/" /c 
+CPP_OBJS=.\msvcobj/
+CPP_SBRS=.\.
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/msdraw.bsc" 
+BSC32_SBRS= \
+	
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\exe\msdraw.lib"
+LIB32_FLAGS=/nologo /out:"..\exe\msdraw.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)\devenum.obj" \
+	"$(INTDIR)\direct3d.obj" \
+	"$(INTDIR)\draw.obj" \
+	"$(INTDIR)\drawsfc.obj" \
+	"$(INTDIR)\dspenum.obj" \
+	"$(INTDIR)\palette.obj" \
+	"$(INTDIR)\texture.obj" \
+	"$(INTDIR)\tmap32.obj"
+
+"..\exe\msdraw.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ENDIF 
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+################################################################################
+# Begin Target
+
+# Name "msdraw - Win32 Release"
+# Name "msdraw - Win32 Debug"
+
+!IF  "$(CFG)" == "msdraw - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "msdraw - Win32 Debug"
+
+!ENDIF 
+
+################################################################################
+# Begin Source File
+
+SOURCE=.\direct3d.cpp
+
+!IF  "$(CFG)" == "msdraw - Win32 Release"
+
+DEP_CPP_DIREC=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\devdesc.hpp"\
+	{$(INCLUDE)}"\.\devenum.hpp"\
+	{$(INCLUDE)}"\.\device3d.hpp"\
+	{$(INCLUDE)}"\.\direct3d.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\common\gdipoint.hpp"\
+	{$(INCLUDE)}"\common\palentry.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\common\pointer.hpp"\
+	{$(INCLUDE)}"\common\rect.hpp"\
+	{$(INCLUDE)}"\common\rgbcolor.hpp"\
+	{$(INCLUDE)}"\common\stdlib.hpp"\
+	{$(INCLUDE)}"\common\string.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\direct3d.obj" : $(SOURCE) $(DEP_CPP_DIREC) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "msdraw - Win32 Debug"
+
+DEP_CPP_DIREC=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\devdesc.hpp"\
+	{$(INCLUDE)}"\.\devenum.hpp"\
+	{$(INCLUDE)}"\.\device3d.hpp"\
+	{$(INCLUDE)}"\.\direct3d.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\common\gdipoint.hpp"\
+	{$(INCLUDE)}"\common\palentry.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\common\pointer.hpp"\
+	{$(INCLUDE)}"\common\rect.hpp"\
+	{$(INCLUDE)}"\common\rgbcolor.hpp"\
+	{$(INCLUDE)}"\common\stdlib.hpp"\
+	{$(INCLUDE)}"\common\string.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\direct3d.obj" : $(SOURCE) $(DEP_CPP_DIREC) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\draw.cpp
+
+!IF  "$(CFG)" == "msdraw - Win32 Release"
+
+DEP_CPP_DRAW_=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\devdesc.hpp"\
+	{$(INCLUDE)}"\.\devenum.hpp"\
+	{$(INCLUDE)}"\.\device3d.hpp"\
+	{$(INCLUDE)}"\.\direct3d.hpp"\
+	{$(INCLUDE)}"\.\draw.hpp"\
+	{$(INCLUDE)}"\.\dspenum.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\common\callback.hpp"\
+	{$(INCLUDE)}"\common\callback.tpp"\
+	{$(INCLUDE)}"\common\cbdata.hpp"\
+	{$(INCLUDE)}"\common\cbptr.hpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\common\gdipoint.hpp"\
+	{$(INCLUDE)}"\common\guiwnd.hpp"\
+	{$(INCLUDE)}"\common\palentry.hpp"\
+	{$(INCLUDE)}"\common\pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\common\pointer.hpp"\
+	{$(INCLUDE)}"\common\rect.hpp"\
+	{$(INCLUDE)}"\common\rgbcolor.hpp"\
+	{$(INCLUDE)}"\common\stdlib.hpp"\
+	{$(INCLUDE)}"\common\string.hpp"\
+	{$(INCLUDE)}"\common\vhandler.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\common\windowsx.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\draw.obj" : $(SOURCE) $(DEP_CPP_DRAW_) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "msdraw - Win32 Debug"
+
+DEP_CPP_DRAW_=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\devdesc.hpp"\
+	{$(INCLUDE)}"\.\devenum.hpp"\
+	{$(INCLUDE)}"\.\device3d.hpp"\
+	{$(INCLUDE)}"\.\direct3d.hpp"\
+	{$(INCLUDE)}"\.\draw.hpp"\
+	{$(INCLUDE)}"\.\dspenum.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\common\callback.hpp"\
+	{$(INCLUDE)}"\common\callback.tpp"\
+	{$(INCLUDE)}"\common\cbdata.hpp"\
+	{$(INCLUDE)}"\common\cbptr.hpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\common\gdipoint.hpp"\
+	{$(INCLUDE)}"\common\guiwnd.hpp"\
+	{$(INCLUDE)}"\common\palentry.hpp"\
+	{$(INCLUDE)}"\common\pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\common\pointer.hpp"\
+	{$(INCLUDE)}"\common\rect.hpp"\
+	{$(INCLUDE)}"\common\rgbcolor.hpp"\
+	{$(INCLUDE)}"\common\stdlib.hpp"\
+	{$(INCLUDE)}"\common\string.hpp"\
+	{$(INCLUDE)}"\common\vhandler.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\common\windowsx.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\draw.obj" : $(SOURCE) $(DEP_CPP_DRAW_) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\dspenum.cpp
+
+!IF  "$(CFG)" == "msdraw - Win32 Release"
+
+DEP_CPP_DSPEN=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\dspenum.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\dspenum.obj" : $(SOURCE) $(DEP_CPP_DSPEN) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "msdraw - Win32 Debug"
+
+DEP_CPP_DSPEN=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\dspenum.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\dspenum.obj" : $(SOURCE) $(DEP_CPP_DSPEN) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\devenum.cpp
+
+!IF  "$(CFG)" == "msdraw - Win32 Release"
+
+DEP_CPP_DEVEN=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\devdesc.hpp"\
+	{$(INCLUDE)}"\.\devenum.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\common\stdlib.hpp"\
+	{$(INCLUDE)}"\common\string.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\devenum.obj" : $(SOURCE) $(DEP_CPP_DEVEN) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "msdraw - Win32 Debug"
+
+DEP_CPP_DEVEN=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\devdesc.hpp"\
+	{$(INCLUDE)}"\.\devenum.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\common\stdlib.hpp"\
+	{$(INCLUDE)}"\common\string.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\devenum.obj" : $(SOURCE) $(DEP_CPP_DEVEN) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\drawsfc.cpp
+DEP_CPP_DRAWS=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\drawsfc.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\rowinfo.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\common\gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Math.hpp"\
+	{$(INCLUDE)}"\common\palentry.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\common\pointer.hpp"\
+	{$(INCLUDE)}"\common\rect.hpp"\
+	{$(INCLUDE)}"\common\rgbcolor.hpp"\
+	{$(INCLUDE)}"\common\stdlib.hpp"\
+	{$(INCLUDE)}"\common\string.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\drawsfc.obj" : $(SOURCE) $(DEP_CPP_DRAWS) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\texture.cpp
+
+!IF  "$(CFG)" == "msdraw - Win32 Release"
+
+DEP_CPP_TEXTU=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\drawsfc.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\rowinfo.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\.\texture.hpp"\
+	{$(INCLUDE)}"\common\array.hpp"\
+	{$(INCLUDE)}"\common\assert.hpp"\
+	{$(INCLUDE)}"\Common\Bitmap.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\Common\Bmdata.hpp"\
+	{$(INCLUDE)}"\Common\Bminfo.hpp"\
+	{$(INCLUDE)}"\Common\Boverlay.hpp"\
+	{$(INCLUDE)}"\common\callback.hpp"\
+	{$(INCLUDE)}"\common\callback.tpp"\
+	{$(INCLUDE)}"\common\cbdata.hpp"\
+	{$(INCLUDE)}"\common\cbptr.hpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\common\gdipoint.hpp"\
+	{$(INCLUDE)}"\common\guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Math.hpp"\
+	{$(INCLUDE)}"\common\palentry.hpp"\
+	{$(INCLUDE)}"\common\pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Pen.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\common\pointer.hpp"\
+	{$(INCLUDE)}"\Common\Purebmp.hpp"\
+	{$(INCLUDE)}"\Common\Purehdc.hpp"\
+	{$(INCLUDE)}"\Common\Purepal.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\common\rect.hpp"\
+	{$(INCLUDE)}"\common\rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Rgbquad.hpp"\
+	{$(INCLUDE)}"\common\stdlib.hpp"\
+	{$(INCLUDE)}"\common\string.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vector2d.hpp"\
+	{$(INCLUDE)}"\common\vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Window.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\common\windowsx.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\Engine\angle.hpp"\
+	{$(INCLUDE)}"\Engine\angle3d.hpp"\
+	{$(INCLUDE)}"\Engine\Device3d.hpp"\
+	{$(INCLUDE)}"\Engine\Point3d.hpp"\
+	{$(INCLUDE)}"\Engine\Pureedge.hpp"\
+	{$(INCLUDE)}"\Engine\Puremap.hpp"\
+	{$(INCLUDE)}"\Engine\Purevsys.hpp"\
+	{$(INCLUDE)}"\Engine\Vector3d.hpp"\
+	{$(INCLUDE)}"\Engine\Viewsys.hpp"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\texture.obj" : $(SOURCE) $(DEP_CPP_TEXTU) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "msdraw - Win32 Debug"
+
+DEP_CPP_TEXTU=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\drawsfc.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\rowinfo.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\.\texture.hpp"\
+	{$(INCLUDE)}"\common\array.hpp"\
+	{$(INCLUDE)}"\common\assert.hpp"\
+	{$(INCLUDE)}"\Common\Bitmap.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\Common\Bmdata.hpp"\
+	{$(INCLUDE)}"\Common\Bminfo.hpp"\
+	{$(INCLUDE)}"\Common\Boverlay.hpp"\
+	{$(INCLUDE)}"\common\callback.hpp"\
+	{$(INCLUDE)}"\common\callback.tpp"\
+	{$(INCLUDE)}"\common\cbdata.hpp"\
+	{$(INCLUDE)}"\common\cbptr.hpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\common\gdipoint.hpp"\
+	{$(INCLUDE)}"\common\guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Math.hpp"\
+	{$(INCLUDE)}"\common\palentry.hpp"\
+	{$(INCLUDE)}"\common\pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Pen.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\common\pointer.hpp"\
+	{$(INCLUDE)}"\Common\Purebmp.hpp"\
+	{$(INCLUDE)}"\Common\Purehdc.hpp"\
+	{$(INCLUDE)}"\Common\Purepal.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\common\rect.hpp"\
+	{$(INCLUDE)}"\common\rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Rgbquad.hpp"\
+	{$(INCLUDE)}"\common\stdlib.hpp"\
+	{$(INCLUDE)}"\common\string.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vector2d.hpp"\
+	{$(INCLUDE)}"\common\vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Window.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\common\windowsx.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\Engine\angle.hpp"\
+	{$(INCLUDE)}"\Engine\angle3d.hpp"\
+	{$(INCLUDE)}"\Engine\Device3d.hpp"\
+	{$(INCLUDE)}"\Engine\Point3d.hpp"\
+	{$(INCLUDE)}"\Engine\Pureedge.hpp"\
+	{$(INCLUDE)}"\Engine\Puremap.hpp"\
+	{$(INCLUDE)}"\Engine\Purevsys.hpp"\
+	{$(INCLUDE)}"\Engine\Vector3d.hpp"\
+	{$(INCLUDE)}"\Engine\Viewsys.hpp"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\texture.obj" : $(SOURCE) $(DEP_CPP_TEXTU) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\palette.cpp
+
+!IF  "$(CFG)" == "msdraw - Win32 Release"
+
+DEP_CPP_PALET=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Filetime.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\common\gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Openfile.hpp"\
+	{$(INCLUDE)}"\common\overlap.hpp"\
+	{$(INCLUDE)}"\common\palentry.hpp"\
+	{$(INCLUDE)}"\Common\Pen.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\common\pointer.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Purehdc.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\common\rect.hpp"\
+	{$(INCLUDE)}"\common\rgbcolor.hpp"\
+	{$(INCLUDE)}"\common\stdlib.hpp"\
+	{$(INCLUDE)}"\common\string.hpp"\
+	{$(INCLUDE)}"\Common\Systime.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\palette.obj" : $(SOURCE) $(DEP_CPP_PALET) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "msdraw - Win32 Debug"
+
+DEP_CPP_PALET=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Filetime.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\common\gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Openfile.hpp"\
+	{$(INCLUDE)}"\common\overlap.hpp"\
+	{$(INCLUDE)}"\common\palentry.hpp"\
+	{$(INCLUDE)}"\Common\Pen.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\common\pointer.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Purehdc.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\common\rect.hpp"\
+	{$(INCLUDE)}"\common\rgbcolor.hpp"\
+	{$(INCLUDE)}"\common\stdlib.hpp"\
+	{$(INCLUDE)}"\common\string.hpp"\
+	{$(INCLUDE)}"\Common\Systime.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\palette.obj" : $(SOURCE) $(DEP_CPP_PALET) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\tmap32.asm
+
+!IF  "$(CFG)" == "msdraw - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "msdraw - Win32 Debug"
+
+# Begin Custom Build
+IntDir=.\msvcobj
+InputPath=.\tmap32.asm
+InputName=tmap32
+
+"$(IntDir)\$(InputName).obj" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   tasm32 /zi  /c  /ml  /m3 $(InputName).asm $(IntDir)\$(InputName).obj
+
+# End Custom Build
+
+!ENDIF 
+
+# End Source File
+# End Target
+# End Project
+################################################################################

ddraw/MSDRAW.DSW

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

ddraw/MSDRAW.MAK

@@ -0,0 +1,782 @@
+# Microsoft Developer Studio Generated NMAKE File, Format Version 4.20
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+!IF "$(CFG)" == ""
+CFG=msdraw - Win32 Debug
+!MESSAGE No configuration specified.  Defaulting to msdraw - Win32 Debug.
+!ENDIF 
+
+!IF "$(CFG)" != "msdraw - Win32 Release" && "$(CFG)" != "msdraw - Win32 Debug"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE on this makefile
+!MESSAGE by defining the macro CFG on the command line.  For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "msdraw.mak" CFG="msdraw - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "msdraw - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "msdraw - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE 
+NULL=nul
+!ENDIF 
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "msdraw - Win32 Debug"
+CPP=cl.exe
+
+!IF  "$(CFG)" == "msdraw - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+OUTDIR=.\Release
+INTDIR=.\Release
+
+ALL : "$(OUTDIR)\msdraw.lib"
+
+CLEAN : 
+	-@erase "$(INTDIR)\devenum.obj"
+	-@erase "$(INTDIR)\direct3d.obj"
+	-@erase "$(INTDIR)\draw.obj"
+	-@erase "$(INTDIR)\drawsfc.obj"
+	-@erase "$(INTDIR)\dspenum.obj"
+	-@erase "$(INTDIR)\palette.obj"
+	-@erase "$(INTDIR)\texture.obj"
+	-@erase "$(OUTDIR)\msdraw.lib"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+CPP_PROJ=/nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS"\
+ /Fp"$(INTDIR)/msdraw.pch" /YX /Fo"$(INTDIR)/" /c 
+CPP_OBJS=.\Release/
+CPP_SBRS=.\.
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/msdraw.bsc" 
+BSC32_SBRS= \
+	
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/msdraw.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)\devenum.obj" \
+	"$(INTDIR)\direct3d.obj" \
+	"$(INTDIR)\draw.obj" \
+	"$(INTDIR)\drawsfc.obj" \
+	"$(INTDIR)\dspenum.obj" \
+	"$(INTDIR)\palette.obj" \
+	"$(INTDIR)\texture.obj"
+
+"$(OUTDIR)\msdraw.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "msdraw - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "msvcobj"
+# PROP Intermediate_Dir "msvcobj"
+# PROP Target_Dir ""
+OUTDIR=.\msvcobj
+INTDIR=.\msvcobj
+
+ALL : "..\exe\msdraw.lib"
+
+CLEAN : 
+	-@erase "$(INTDIR)\devenum.obj"
+	-@erase "$(INTDIR)\direct3d.obj"
+	-@erase "$(INTDIR)\draw.obj"
+	-@erase "$(INTDIR)\drawsfc.obj"
+	-@erase "$(INTDIR)\dspenum.obj"
+	-@erase "$(INTDIR)\palette.obj"
+	-@erase "$(INTDIR)\texture.obj"
+	-@erase "$(INTDIR)\tmap32.obj"
+	-@erase "..\exe\msdraw.lib"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /Zp1 /MTd /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /Fp"..\exe\msvc42.pch" /YX /c
+CPP_PROJ=/nologo /Zp1 /MTd /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D\
+ "STRICT" /D "__FLAT__" /Fp"..\exe\msvc42.pch" /YX /Fo"$(INTDIR)/" /c 
+CPP_OBJS=.\msvcobj/
+CPP_SBRS=.\.
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/msdraw.bsc" 
+BSC32_SBRS= \
+	
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\exe\msdraw.lib"
+LIB32_FLAGS=/nologo /out:"..\exe\msdraw.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)\devenum.obj" \
+	"$(INTDIR)\direct3d.obj" \
+	"$(INTDIR)\draw.obj" \
+	"$(INTDIR)\drawsfc.obj" \
+	"$(INTDIR)\dspenum.obj" \
+	"$(INTDIR)\palette.obj" \
+	"$(INTDIR)\texture.obj" \
+	"$(INTDIR)\tmap32.obj"
+
+"..\exe\msdraw.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ENDIF 
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+################################################################################
+# Begin Target
+
+# Name "msdraw - Win32 Release"
+# Name "msdraw - Win32 Debug"
+
+!IF  "$(CFG)" == "msdraw - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "msdraw - Win32 Debug"
+
+!ENDIF 
+
+################################################################################
+# Begin Source File
+
+SOURCE=.\direct3d.cpp
+
+!IF  "$(CFG)" == "msdraw - Win32 Release"
+
+DEP_CPP_DIREC=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\devdesc.hpp"\
+	{$(INCLUDE)}"\.\devenum.hpp"\
+	{$(INCLUDE)}"\.\device3d.hpp"\
+	{$(INCLUDE)}"\.\direct3d.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\common\gdipoint.hpp"\
+	{$(INCLUDE)}"\common\palentry.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\common\pointer.hpp"\
+	{$(INCLUDE)}"\common\rect.hpp"\
+	{$(INCLUDE)}"\common\rgbcolor.hpp"\
+	{$(INCLUDE)}"\common\stdlib.hpp"\
+	{$(INCLUDE)}"\common\string.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\direct3d.obj" : $(SOURCE) $(DEP_CPP_DIREC) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "msdraw - Win32 Debug"
+
+DEP_CPP_DIREC=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\devdesc.hpp"\
+	{$(INCLUDE)}"\.\devenum.hpp"\
+	{$(INCLUDE)}"\.\device3d.hpp"\
+	{$(INCLUDE)}"\.\direct3d.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\common\gdipoint.hpp"\
+	{$(INCLUDE)}"\common\palentry.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\common\pointer.hpp"\
+	{$(INCLUDE)}"\common\rect.hpp"\
+	{$(INCLUDE)}"\common\rgbcolor.hpp"\
+	{$(INCLUDE)}"\common\stdlib.hpp"\
+	{$(INCLUDE)}"\common\string.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\direct3d.obj" : $(SOURCE) $(DEP_CPP_DIREC) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\draw.cpp
+
+!IF  "$(CFG)" == "msdraw - Win32 Release"
+
+DEP_CPP_DRAW_=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\devdesc.hpp"\
+	{$(INCLUDE)}"\.\devenum.hpp"\
+	{$(INCLUDE)}"\.\device3d.hpp"\
+	{$(INCLUDE)}"\.\direct3d.hpp"\
+	{$(INCLUDE)}"\.\draw.hpp"\
+	{$(INCLUDE)}"\.\dspenum.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\common\callback.hpp"\
+	{$(INCLUDE)}"\common\callback.tpp"\
+	{$(INCLUDE)}"\common\cbdata.hpp"\
+	{$(INCLUDE)}"\common\cbptr.hpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\common\gdipoint.hpp"\
+	{$(INCLUDE)}"\common\guiwnd.hpp"\
+	{$(INCLUDE)}"\common\palentry.hpp"\
+	{$(INCLUDE)}"\common\pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\common\pointer.hpp"\
+	{$(INCLUDE)}"\common\rect.hpp"\
+	{$(INCLUDE)}"\common\rgbcolor.hpp"\
+	{$(INCLUDE)}"\common\stdlib.hpp"\
+	{$(INCLUDE)}"\common\string.hpp"\
+	{$(INCLUDE)}"\common\vhandler.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\common\windowsx.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\draw.obj" : $(SOURCE) $(DEP_CPP_DRAW_) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "msdraw - Win32 Debug"
+
+DEP_CPP_DRAW_=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\devdesc.hpp"\
+	{$(INCLUDE)}"\.\devenum.hpp"\
+	{$(INCLUDE)}"\.\device3d.hpp"\
+	{$(INCLUDE)}"\.\direct3d.hpp"\
+	{$(INCLUDE)}"\.\draw.hpp"\
+	{$(INCLUDE)}"\.\dspenum.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\common\callback.hpp"\
+	{$(INCLUDE)}"\common\callback.tpp"\
+	{$(INCLUDE)}"\common\cbdata.hpp"\
+	{$(INCLUDE)}"\common\cbptr.hpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\common\gdipoint.hpp"\
+	{$(INCLUDE)}"\common\guiwnd.hpp"\
+	{$(INCLUDE)}"\common\palentry.hpp"\
+	{$(INCLUDE)}"\common\pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\common\pointer.hpp"\
+	{$(INCLUDE)}"\common\rect.hpp"\
+	{$(INCLUDE)}"\common\rgbcolor.hpp"\
+	{$(INCLUDE)}"\common\stdlib.hpp"\
+	{$(INCLUDE)}"\common\string.hpp"\
+	{$(INCLUDE)}"\common\vhandler.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\common\windowsx.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\draw.obj" : $(SOURCE) $(DEP_CPP_DRAW_) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\dspenum.cpp
+
+!IF  "$(CFG)" == "msdraw - Win32 Release"
+
+DEP_CPP_DSPEN=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\dspenum.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\dspenum.obj" : $(SOURCE) $(DEP_CPP_DSPEN) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "msdraw - Win32 Debug"
+
+DEP_CPP_DSPEN=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\dspenum.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\dspenum.obj" : $(SOURCE) $(DEP_CPP_DSPEN) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\devenum.cpp
+
+!IF  "$(CFG)" == "msdraw - Win32 Release"
+
+DEP_CPP_DEVEN=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\devdesc.hpp"\
+	{$(INCLUDE)}"\.\devenum.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\common\stdlib.hpp"\
+	{$(INCLUDE)}"\common\string.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\devenum.obj" : $(SOURCE) $(DEP_CPP_DEVEN) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "msdraw - Win32 Debug"
+
+DEP_CPP_DEVEN=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\devdesc.hpp"\
+	{$(INCLUDE)}"\.\devenum.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\common\stdlib.hpp"\
+	{$(INCLUDE)}"\common\string.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\devenum.obj" : $(SOURCE) $(DEP_CPP_DEVEN) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\drawsfc.cpp
+DEP_CPP_DRAWS=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\drawsfc.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\rowinfo.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\common\gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Math.hpp"\
+	{$(INCLUDE)}"\common\palentry.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\common\pointer.hpp"\
+	{$(INCLUDE)}"\common\rect.hpp"\
+	{$(INCLUDE)}"\common\rgbcolor.hpp"\
+	{$(INCLUDE)}"\common\stdlib.hpp"\
+	{$(INCLUDE)}"\common\string.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\drawsfc.obj" : $(SOURCE) $(DEP_CPP_DRAWS) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\texture.cpp
+
+!IF  "$(CFG)" == "msdraw - Win32 Release"
+
+DEP_CPP_TEXTU=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\drawsfc.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\rowinfo.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\.\texture.hpp"\
+	{$(INCLUDE)}"\common\array.hpp"\
+	{$(INCLUDE)}"\common\assert.hpp"\
+	{$(INCLUDE)}"\Common\Bitmap.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\Common\Bmdata.hpp"\
+	{$(INCLUDE)}"\Common\Bminfo.hpp"\
+	{$(INCLUDE)}"\Common\Boverlay.hpp"\
+	{$(INCLUDE)}"\common\callback.hpp"\
+	{$(INCLUDE)}"\common\callback.tpp"\
+	{$(INCLUDE)}"\common\cbdata.hpp"\
+	{$(INCLUDE)}"\common\cbptr.hpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\common\gdipoint.hpp"\
+	{$(INCLUDE)}"\common\guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Math.hpp"\
+	{$(INCLUDE)}"\common\palentry.hpp"\
+	{$(INCLUDE)}"\common\pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Pen.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\common\pointer.hpp"\
+	{$(INCLUDE)}"\Common\Purebmp.hpp"\
+	{$(INCLUDE)}"\Common\Purehdc.hpp"\
+	{$(INCLUDE)}"\Common\Purepal.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\common\rect.hpp"\
+	{$(INCLUDE)}"\common\rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Rgbquad.hpp"\
+	{$(INCLUDE)}"\common\stdlib.hpp"\
+	{$(INCLUDE)}"\common\string.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vector2d.hpp"\
+	{$(INCLUDE)}"\common\vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Window.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\common\windowsx.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\Engine\angle.hpp"\
+	{$(INCLUDE)}"\Engine\angle3d.hpp"\
+	{$(INCLUDE)}"\Engine\Device3d.hpp"\
+	{$(INCLUDE)}"\Engine\Point3d.hpp"\
+	{$(INCLUDE)}"\Engine\Pureedge.hpp"\
+	{$(INCLUDE)}"\Engine\Puremap.hpp"\
+	{$(INCLUDE)}"\Engine\Purevsys.hpp"\
+	{$(INCLUDE)}"\Engine\Vector3d.hpp"\
+	{$(INCLUDE)}"\Engine\Viewsys.hpp"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\texture.obj" : $(SOURCE) $(DEP_CPP_TEXTU) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "msdraw - Win32 Debug"
+
+DEP_CPP_TEXTU=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\bltfx.hpp"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\drawsfc.hpp"\
+	{$(INCLUDE)}"\.\error.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\.\pixform.hpp"\
+	{$(INCLUDE)}"\.\rowinfo.hpp"\
+	{$(INCLUDE)}"\.\sfccaps.hpp"\
+	{$(INCLUDE)}"\.\sfcdesc.hpp"\
+	{$(INCLUDE)}"\.\surface.hpp"\
+	{$(INCLUDE)}"\.\texture.hpp"\
+	{$(INCLUDE)}"\common\array.hpp"\
+	{$(INCLUDE)}"\common\assert.hpp"\
+	{$(INCLUDE)}"\Common\Bitmap.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\Common\Bmdata.hpp"\
+	{$(INCLUDE)}"\Common\Bminfo.hpp"\
+	{$(INCLUDE)}"\Common\Boverlay.hpp"\
+	{$(INCLUDE)}"\common\callback.hpp"\
+	{$(INCLUDE)}"\common\callback.tpp"\
+	{$(INCLUDE)}"\common\cbdata.hpp"\
+	{$(INCLUDE)}"\common\cbptr.hpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\common\gdipoint.hpp"\
+	{$(INCLUDE)}"\common\guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Math.hpp"\
+	{$(INCLUDE)}"\common\palentry.hpp"\
+	{$(INCLUDE)}"\common\pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Pen.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\common\pointer.hpp"\
+	{$(INCLUDE)}"\Common\Purebmp.hpp"\
+	{$(INCLUDE)}"\Common\Purehdc.hpp"\
+	{$(INCLUDE)}"\Common\Purepal.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\common\rect.hpp"\
+	{$(INCLUDE)}"\common\rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Rgbquad.hpp"\
+	{$(INCLUDE)}"\common\stdlib.hpp"\
+	{$(INCLUDE)}"\common\string.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vector2d.hpp"\
+	{$(INCLUDE)}"\common\vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Window.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\common\windowsx.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\Engine\angle.hpp"\
+	{$(INCLUDE)}"\Engine\angle3d.hpp"\
+	{$(INCLUDE)}"\Engine\Device3d.hpp"\
+	{$(INCLUDE)}"\Engine\Point3d.hpp"\
+	{$(INCLUDE)}"\Engine\Pureedge.hpp"\
+	{$(INCLUDE)}"\Engine\Puremap.hpp"\
+	{$(INCLUDE)}"\Engine\Purevsys.hpp"\
+	{$(INCLUDE)}"\Engine\Vector3d.hpp"\
+	{$(INCLUDE)}"\Engine\Viewsys.hpp"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\texture.obj" : $(SOURCE) $(DEP_CPP_TEXTU) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\palette.cpp
+
+!IF  "$(CFG)" == "msdraw - Win32 Release"
+
+DEP_CPP_PALET=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Filetime.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\common\gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Openfile.hpp"\
+	{$(INCLUDE)}"\common\overlap.hpp"\
+	{$(INCLUDE)}"\common\palentry.hpp"\
+	{$(INCLUDE)}"\Common\Pen.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\common\pointer.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Purehdc.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\common\rect.hpp"\
+	{$(INCLUDE)}"\common\rgbcolor.hpp"\
+	{$(INCLUDE)}"\common\stdlib.hpp"\
+	{$(INCLUDE)}"\common\string.hpp"\
+	{$(INCLUDE)}"\Common\Systime.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\palette.obj" : $(SOURCE) $(DEP_CPP_PALET) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "msdraw - Win32 Debug"
+
+DEP_CPP_PALET=\
+	"..\..\parts\mssdk\include\d3dcaps.h"\
+	"..\..\parts\mssdk\include\d3dtypes.h"\
+	"..\..\parts\mssdk\include\d3dvec.inl"\
+	{$(INCLUDE)}"\.\ddraw.hpp"\
+	{$(INCLUDE)}"\.\palette.hpp"\
+	{$(INCLUDE)}"\common\block.hpp"\
+	{$(INCLUDE)}"\common\block.tpp"\
+	{$(INCLUDE)}"\common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Filetime.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\common\gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Openfile.hpp"\
+	{$(INCLUDE)}"\common\overlap.hpp"\
+	{$(INCLUDE)}"\common\palentry.hpp"\
+	{$(INCLUDE)}"\Common\Pen.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\common\pointer.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Purehdc.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\common\rect.hpp"\
+	{$(INCLUDE)}"\common\rgbcolor.hpp"\
+	{$(INCLUDE)}"\common\stdlib.hpp"\
+	{$(INCLUDE)}"\common\string.hpp"\
+	{$(INCLUDE)}"\Common\Systime.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\common\windows.hpp"\
+	{$(INCLUDE)}"\ddraw.h"\
+	{$(INCLUDE)}"\mssdk\include\d3d.h"\
+	
+
+"$(INTDIR)\palette.obj" : $(SOURCE) $(DEP_CPP_PALET) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\tmap32.asm
+
+!IF  "$(CFG)" == "msdraw - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "msdraw - Win32 Debug"
+
+# Begin Custom Build
+IntDir=.\msvcobj
+InputPath=.\tmap32.asm
+InputName=tmap32
+
+"$(IntDir)\$(InputName).obj" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   tasm32 /zi  /c  /ml  /m3 $(InputName).asm $(IntDir)\$(InputName).obj
+
+# End Custom Build
+
+!ENDIF 
+
+# End Source File
+# End Target
+# End Project
+################################################################################

ddraw/MSDRAW.PLG

@@ -0,0 +1,239 @@
+--------------------Configuration: msdraw - Win32 Debug--------------------
+Begining build with project "C:\WORK\ddraw\msdraw.dsp", at root.
+Active configuration is Win32 (x86) Static Library (based on Win32 (x86) Static Library)
+
+Project's tools are:
+			"32-bit C/C++ Compiler for 80x86" with flags "/nologo /Zp1 /MTd /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /Fp"..\exe\msvc42.pch" /YX /Fo".\msvcobj/" /Fd".\msvcobj/" /FD /c "
+			"Browser Database Maker" with flags "/nologo /o".\msvcobj/msdraw.bsc" "
+			"Library Manager" with flags "/nologo /out:"..\exe\msdraw.lib" "
+			"Custom Build" with flags ""
+			"<Component 0xa>" with flags ""
+
+Creating temp file "C:\WINDOWS\TEMP\RSP9332.TMP" with contents </nologo /Zp1 /MTd /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /Fp"..\exe\msvc42.pch" /YX /Fo".\msvcobj/" /Fd".\msvcobj/" /FD /c 
+"C:\WORK\ddraw\devenum.cpp"
+"C:\WORK\ddraw\direct3d.cpp"
+"C:\WORK\ddraw\draw.cpp"
+"C:\WORK\ddraw\drawsfc.cpp"
+"C:\WORK\ddraw\dspenum.cpp"
+"C:\WORK\ddraw\palette.cpp"
+"C:\WORK\ddraw\texture.cpp"
+>
+Creating command line "cl.exe @C:\WINDOWS\TEMP\RSP9332.TMP" 
+Creating command line "link.exe -lib /nologo /out:"..\exe\msdraw.lib"  .\msvcobj\devenum.obj .\msvcobj\direct3d.obj .\msvcobj\draw.obj .\msvcobj\drawsfc.obj .\msvcobj\dspenum.obj .\msvcobj\palette.obj .\msvcobj\texture.obj .\msvcobj\tmap32.obj" 
+Compiling...
+devenum.cpp
+direct3d.cpp
+c:\work\ddraw/direct3d.hpp(18) : error C2065: 'IDirect3D3' : undeclared identifier
+c:\work\ddraw/pixform.hpp(13) : error C2065: 'DDPF_ALPHAPREMULT' : undeclared identifier
+c:\work\ddraw/pixform.hpp(13) : error C2057: expected constant expression
+c:\work\ddraw/pixform.hpp(14) : error C2065: 'DDPF_BUMPLUMINANCE' : undeclared identifier
+c:\work\ddraw/pixform.hpp(14) : error C2057: expected constant expression
+c:\work\ddraw/pixform.hpp(14) : error C2065: 'DDPF_BUMPDUDV' : undeclared identifier
+c:\work\ddraw/pixform.hpp(14) : error C2057: expected constant expression
+c:\work\ddraw/pixform.hpp(15) : error C2065: 'DDPF_LUMINANCE' : undeclared identifier
+c:\work\ddraw/pixform.hpp(15) : error C2057: expected constant expression
+c:\work\ddraw/pixform.hpp(18) : error C2065: 'DDPF_STENCILBUFFER' : undeclared identifier
+c:\work\ddraw/pixform.hpp(18) : error C2057: expected constant expression
+c:\work\ddraw/pixform.hpp(19) : error C2065: 'DDPF_ZPIXELS' : undeclared identifier
+c:\work\ddraw/pixform.hpp(19) : error C2057: expected constant expression
+c:\work\ddraw/pixform.hpp(214) : error C2039: 'dwLuminanceBitCount' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(214) : error C2065: 'dwLuminanceBitCount' : undeclared identifier
+c:\work\ddraw/pixform.hpp(220) : error C2039: 'dwLuminanceBitCount' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(226) : error C2039: 'dwBumpBitCount' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(226) : error C2065: 'dwBumpBitCount' : undeclared identifier
+c:\work\ddraw/pixform.hpp(232) : error C2039: 'dwBumpBitCount' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(286) : error C2039: 'dwZBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(286) : error C2065: 'dwZBitMask' : undeclared identifier
+c:\work\ddraw/pixform.hpp(292) : error C2039: 'dwZBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(322) : error C2039: 'dwStencilBitDepth' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(322) : error C2065: 'dwStencilBitDepth' : undeclared identifier
+c:\work\ddraw/pixform.hpp(328) : error C2039: 'dwStencilBitDepth' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(334) : error C2039: 'dwLuminanceBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(334) : error C2065: 'dwLuminanceBitMask' : undeclared identifier
+c:\work\ddraw/pixform.hpp(340) : error C2039: 'dwLuminanceBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(346) : error C2039: 'dwBumpDuBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(346) : error C2065: 'dwBumpDuBitMask' : undeclared identifier
+c:\work\ddraw/pixform.hpp(352) : error C2039: 'dwBumpDuBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(358) : error C2039: 'dwBumpDvBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(358) : error C2065: 'dwBumpDvBitMask' : undeclared identifier
+c:\work\ddraw/pixform.hpp(364) : error C2039: 'dwBumpDvBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(370) : error C2039: 'dwStencilBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(370) : error C2065: 'dwStencilBitMask' : undeclared identifier
+c:\work\ddraw/pixform.hpp(376) : error C2039: 'dwStencilBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(382) : error C2039: 'dwBumpLuminanceBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(382) : error C2065: 'dwBumpLuminanceBitMask' : undeclared identifier
+c:\work\ddraw/pixform.hpp(388) : error C2039: 'dwBumpLuminanceBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(418) : error C2039: 'dwLuminanceAlphaBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(418) : error C2065: 'dwLuminanceAlphaBitMask' : undeclared identifier
+c:\work\ddraw/pixform.hpp(424) : error C2039: 'dwLuminanceAlphaBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(430) : error C2039: 'dwRGBZBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(430) : error C2065: 'dwRGBZBitMask' : undeclared identifier
+c:\work\ddraw/pixform.hpp(436) : error C2039: 'dwRGBZBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(442) : error C2039: 'dwYUVZBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(442) : error C2065: 'dwYUVZBitMask' : undeclared identifier
+c:\work\ddraw/pixform.hpp(448) : error C2039: 'dwYUVZBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/bltfx.hpp(450) : error C2039: 'dwFillPixel' : is not a member of '_DDBLTFX'
+c:\work\ddraw/bltfx.hpp(450) : error C2065: 'dwFillPixel' : undeclared identifier
+c:\work\ddraw/bltfx.hpp(456) : error C2039: 'dwFillPixel' : is not a member of '_DDBLTFX'
+c:\work\ddraw/sfccaps.hpp(8) : error C2504: 'DDSCAPS2' : base class undefined
+c:\work\ddraw/sfccaps.hpp(17) : error C2065: 'DDSCAPS_VIDEOPORT' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(17) : error C2057: expected constant expression
+c:\work\ddraw/sfccaps.hpp(17) : error C2065: 'DDSCAPS_LOCALVIDMEM' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(17) : error C2057: expected constant expression
+c:\work\ddraw/sfccaps.hpp(18) : error C2065: 'DDSCAPS_STANDARDVGAMODE' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(18) : error C2057: expected constant expression
+c:\work\ddraw/sfccaps.hpp(18) : error C2065: 'DDSCAPS_OPTIMIZED' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(18) : error C2057: expected constant expression
+c:\work\ddraw/sfccaps.hpp(19) : error C2065: 'DDSCAPS2_HARDWAREDEINTERLACE' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(19) : error C2057: expected constant expression
+c:\work\ddraw/sfccaps.hpp(20) : error C2065: 'DDSCAPS2_HINTANTIALIASING' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(20) : error C2057: expected constant expression
+c:\work\ddraw/sfccaps.hpp(20) : error C2065: 'DDSCAPS2_HINTDYNAMIC' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(20) : error C2057: expected constant expression
+c:\work\ddraw/sfccaps.hpp(21) : error C2065: 'DDSCAPS2_HINTSTATIC' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(21) : error C2057: expected constant expression
+c:\work\ddraw/sfccaps.hpp(21) : error C2065: 'DDSCAPS2_OPAQUE' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(21) : error C2057: expected constant expression
+c:\work\ddraw/sfccaps.hpp(21) : error C2065: 'DDSCAPS2_TEXTUREMANAGE' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(21) : error C2057: expected constant expression
+c:\work\ddraw/sfccaps.hpp(24) : error C2629: unexpected 'class SurfaceCapabilities ('
+c:\work\ddraw/sfccaps.hpp(24) : error C2238: unexpected token(s) preceding ';'
+c:\work\ddraw/sfccaps.hpp(28) : error C2143: syntax error : missing ')' before '&'
+c:\work\ddraw/sfccaps.hpp(28) : error C2059: syntax error : '&'
+c:\work\ddraw/sfccaps.hpp(28) : error C2143: syntax error : missing ';' before '&'
+c:\work\ddraw/sfccaps.hpp(28) : error C2501: 'someDDSCAPS2' : missing decl-specifiers
+c:\work\ddraw/sfccaps.hpp(28) : error C2143: syntax error : missing ';' before ')'
+c:\work\ddraw/sfccaps.hpp(28) : error C2238: unexpected token(s) preceding ';'
+c:\work\ddraw/sfccaps.hpp(33) : error C2501: 'DDSCAPS2' : missing decl-specifiers
+c:\work\ddraw/sfccaps.hpp(33) : error C2143: syntax error : missing ';' before '&'
+c:\work\ddraw/sfccaps.hpp(33) : error C2501: 'getDDSCAPS2' : missing decl-specifiers
+c:\work\ddraw/sfccaps.hpp(40) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+c:\work\ddraw/sfccaps.hpp(40) : error C2065: 'dwCaps' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(41) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+c:\work\ddraw/sfccaps.hpp(41) : error C2065: 'dwCaps2' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(42) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+c:\work\ddraw/sfccaps.hpp(42) : error C2065: 'dwCaps3' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(43) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+c:\work\ddraw/sfccaps.hpp(43) : error C2065: 'dwCaps4' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(55) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+c:\work\ddraw/sfccaps.hpp(56) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+c:\work\ddraw/sfccaps.hpp(57) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+c:\work\ddraw/sfccaps.hpp(58) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+c:\work\ddraw/sfccaps.hpp(62) : error C2143: syntax error : missing ')' before '&'
+c:\work\ddraw/sfccaps.hpp(62) : error C2511: 'SurfaceCapabilities::SurfaceCapabilities' : overloaded member function not found in 'SurfaceCapabilities'
+C:\WORK\ddraw\direct3d.cpp(54) : fatal error C1004: unexpected end of file found
+draw.cpp
+c:\work\ddraw/draw.hpp(26) : error C2065: 'DDSCL_SETFOCUSWINDOW' : undeclared identifier
+c:\work\ddraw/draw.hpp(26) : error C2057: expected constant expression
+c:\work\ddraw/draw.hpp(26) : error C2065: 'DDSCL_SETDEVICEWINDOW' : undeclared identifier
+c:\work\ddraw/draw.hpp(26) : error C2057: expected constant expression
+c:\work\ddraw/draw.hpp(27) : error C2065: 'DDSCL_CREATEDEVICEWINDOW' : undeclared identifier
+c:\work\ddraw/draw.hpp(27) : error C2057: expected constant expression
+c:\work\ddraw/draw.hpp(27) : error C2065: 'DDSCL_MULTITHREADED' : undeclared identifier
+c:\work\ddraw/draw.hpp(27) : error C2057: expected constant expression
+c:\work\ddraw/draw.hpp(28) : error C2065: 'DDSCL_FPUSETUP' : undeclared identifier
+c:\work\ddraw/draw.hpp(28) : error C2057: expected constant expression
+c:\work\ddraw/draw.hpp(51) : error C2065: 'IDirectDraw4' : undeclared identifier
+c:\work\ddraw/draw.hpp(51) : error C2955: 'SmartPointer' : use of class template requires template argument list
+c:\work\ddraw/draw.hpp(51) : fatal error C1903: unable to recover from previous error(s); stopping compilation
+drawsfc.cpp
+c:\work\ddraw/pixform.hpp(13) : error C2065: 'DDPF_ALPHAPREMULT' : undeclared identifier
+c:\work\ddraw/pixform.hpp(13) : error C2057: expected constant expression
+c:\work\ddraw/pixform.hpp(14) : error C2065: 'DDPF_BUMPLUMINANCE' : undeclared identifier
+c:\work\ddraw/pixform.hpp(14) : error C2057: expected constant expression
+c:\work\ddraw/pixform.hpp(14) : error C2065: 'DDPF_BUMPDUDV' : undeclared identifier
+c:\work\ddraw/pixform.hpp(14) : error C2057: expected constant expression
+c:\work\ddraw/pixform.hpp(15) : error C2065: 'DDPF_LUMINANCE' : undeclared identifier
+c:\work\ddraw/pixform.hpp(15) : error C2057: expected constant expression
+c:\work\ddraw/pixform.hpp(18) : error C2065: 'DDPF_STENCILBUFFER' : undeclared identifier
+c:\work\ddraw/pixform.hpp(18) : error C2057: expected constant expression
+c:\work\ddraw/pixform.hpp(19) : error C2065: 'DDPF_ZPIXELS' : undeclared identifier
+c:\work\ddraw/pixform.hpp(19) : error C2057: expected constant expression
+c:\work\ddraw/pixform.hpp(214) : error C2039: 'dwLuminanceBitCount' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(214) : error C2065: 'dwLuminanceBitCount' : undeclared identifier
+c:\work\ddraw/pixform.hpp(220) : error C2039: 'dwLuminanceBitCount' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(226) : error C2039: 'dwBumpBitCount' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(226) : error C2065: 'dwBumpBitCount' : undeclared identifier
+c:\work\ddraw/pixform.hpp(232) : error C2039: 'dwBumpBitCount' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(286) : error C2039: 'dwZBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(286) : error C2065: 'dwZBitMask' : undeclared identifier
+c:\work\ddraw/pixform.hpp(292) : error C2039: 'dwZBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(322) : error C2039: 'dwStencilBitDepth' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(322) : error C2065: 'dwStencilBitDepth' : undeclared identifier
+c:\work\ddraw/pixform.hpp(328) : error C2039: 'dwStencilBitDepth' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(334) : error C2039: 'dwLuminanceBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(334) : error C2065: 'dwLuminanceBitMask' : undeclared identifier
+c:\work\ddraw/pixform.hpp(340) : error C2039: 'dwLuminanceBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(346) : error C2039: 'dwBumpDuBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(346) : error C2065: 'dwBumpDuBitMask' : undeclared identifier
+c:\work\ddraw/pixform.hpp(352) : error C2039: 'dwBumpDuBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(358) : error C2039: 'dwBumpDvBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(358) : error C2065: 'dwBumpDvBitMask' : undeclared identifier
+c:\work\ddraw/pixform.hpp(364) : error C2039: 'dwBumpDvBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(370) : error C2039: 'dwStencilBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(370) : error C2065: 'dwStencilBitMask' : undeclared identifier
+c:\work\ddraw/pixform.hpp(376) : error C2039: 'dwStencilBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(382) : error C2039: 'dwBumpLuminanceBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(382) : error C2065: 'dwBumpLuminanceBitMask' : undeclared identifier
+c:\work\ddraw/pixform.hpp(388) : error C2039: 'dwBumpLuminanceBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(418) : error C2039: 'dwLuminanceAlphaBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(418) : error C2065: 'dwLuminanceAlphaBitMask' : undeclared identifier
+c:\work\ddraw/pixform.hpp(424) : error C2039: 'dwLuminanceAlphaBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(430) : error C2039: 'dwRGBZBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(430) : error C2065: 'dwRGBZBitMask' : undeclared identifier
+c:\work\ddraw/pixform.hpp(436) : error C2039: 'dwRGBZBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(442) : error C2039: 'dwYUVZBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/pixform.hpp(442) : error C2065: 'dwYUVZBitMask' : undeclared identifier
+c:\work\ddraw/pixform.hpp(448) : error C2039: 'dwYUVZBitMask' : is not a member of '_DDPIXELFORMAT'
+c:\work\ddraw/bltfx.hpp(450) : error C2039: 'dwFillPixel' : is not a member of '_DDBLTFX'
+c:\work\ddraw/bltfx.hpp(450) : error C2065: 'dwFillPixel' : undeclared identifier
+c:\work\ddraw/bltfx.hpp(456) : error C2039: 'dwFillPixel' : is not a member of '_DDBLTFX'
+c:\work\ddraw/sfccaps.hpp(8) : error C2504: 'DDSCAPS2' : base class undefined
+c:\work\ddraw/sfccaps.hpp(17) : error C2065: 'DDSCAPS_VIDEOPORT' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(17) : error C2057: expected constant expression
+c:\work\ddraw/sfccaps.hpp(17) : error C2065: 'DDSCAPS_LOCALVIDMEM' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(17) : error C2057: expected constant expression
+c:\work\ddraw/sfccaps.hpp(18) : error C2065: 'DDSCAPS_STANDARDVGAMODE' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(18) : error C2057: expected constant expression
+c:\work\ddraw/sfccaps.hpp(18) : error C2065: 'DDSCAPS_OPTIMIZED' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(18) : error C2057: expected constant expression
+c:\work\ddraw/sfccaps.hpp(19) : error C2065: 'DDSCAPS2_HARDWAREDEINTERLACE' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(19) : error C2057: expected constant expression
+c:\work\ddraw/sfccaps.hpp(20) : error C2065: 'DDSCAPS2_HINTANTIALIASING' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(20) : error C2057: expected constant expression
+c:\work\ddraw/sfccaps.hpp(20) : error C2065: 'DDSCAPS2_HINTDYNAMIC' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(20) : error C2057: expected constant expression
+c:\work\ddraw/sfccaps.hpp(21) : error C2065: 'DDSCAPS2_HINTSTATIC' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(21) : error C2057: expected constant expression
+c:\work\ddraw/sfccaps.hpp(21) : error C2065: 'DDSCAPS2_OPAQUE' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(21) : error C2057: expected constant expression
+c:\work\ddraw/sfccaps.hpp(21) : error C2065: 'DDSCAPS2_TEXTUREMANAGE' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(21) : error C2057: expected constant expression
+c:\work\ddraw/sfccaps.hpp(24) : error C2629: unexpected 'class SurfaceCapabilities ('
+c:\work\ddraw/sfccaps.hpp(24) : error C2238: unexpected token(s) preceding ';'
+c:\work\ddraw/sfccaps.hpp(28) : error C2143: syntax error : missing ')' before '&'
+c:\work\ddraw/sfccaps.hpp(28) : error C2059: syntax error : '&'
+c:\work\ddraw/sfccaps.hpp(28) : error C2143: syntax error : missing ';' before '&'
+c:\work\ddraw/sfccaps.hpp(28) : error C2501: 'someDDSCAPS2' : missing decl-specifiers
+c:\work\ddraw/sfccaps.hpp(28) : error C2143: syntax error : missing ';' before ')'
+c:\work\ddraw/sfccaps.hpp(28) : error C2238: unexpected token(s) preceding ';'
+c:\work\ddraw/sfccaps.hpp(33) : error C2501: 'DDSCAPS2' : missing decl-specifiers
+c:\work\ddraw/sfccaps.hpp(33) : error C2143: syntax error : missing ';' before '&'
+c:\work\ddraw/sfccaps.hpp(33) : error C2501: 'getDDSCAPS2' : missing decl-specifiers
+c:\work\ddraw/sfccaps.hpp(40) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+c:\work\ddraw/sfccaps.hpp(40) : error C2065: 'dwCaps' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(41) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+c:\work\ddraw/sfccaps.hpp(41) : error C2065: 'dwCaps2' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(42) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+c:\work\ddraw/sfccaps.hpp(42) : error C2065: 'dwCaps3' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(43) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+c:\work\ddraw/sfccaps.hpp(43) : error C2065: 'dwCaps4' : undeclared identifier
+c:\work\ddraw/sfccaps.hpp(55) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+c:\work\ddraw/sfccaps.hpp(56) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+c:\work\ddraw/sfccaps.hpp(57) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+c:\work\ddraw/sfccaps.hpp(58) : error C2653: 'DDSCAPS2' : is not a class or namespace name
+c:\work\ddraw/sfccaps.hpp(62) : error C2143: syntax error : missing ')' before '&'
+c:\work\ddraw/sfccaps.hpp(62) : error C2511: 'SurfaceCapabilities::SurfaceCapabilities' : overloaded member function not found in 'SurfaceCapabilities'
+C:\WORK\ddraw\drawsfc.cpp(162) : fatal error C1004: unexpected end of file found
+dspenum.cpp
+

ddraw/Msdraw.001

@@ -0,0 +1,208 @@
+# Microsoft Developer Studio Project File - Name="msdraw" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 5.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=msdraw - Win32 Release
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "msdraw.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "msdraw.mak" CFG="msdraw - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "msdraw - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "msdraw - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+
+!IF  "$(CFG)" == "msdraw - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir ".\Release"
+# PROP BASE Intermediate_Dir ".\Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir ".\Release"
+# PROP Intermediate_Dir ".\Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ELSEIF  "$(CFG)" == "msdraw - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir ".\Debug"
+# PROP BASE Intermediate_Dir ".\Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ".\msvcobj"
+# PROP Intermediate_Dir ".\msvcobj"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /Zp1 /MTd /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /Fp"..\exe\msvc42.pch" /YX /FD /c
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\exe\msdraw.lib"
+
+!ENDIF 
+
+# Begin Target
+
+# Name "msdraw - Win32 Release"
+# Name "msdraw - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90"
+# Begin Source File
+
+SOURCE=.\devenum.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\direct3d.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\draw.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\drawsfc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\dspenum.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\palette.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\texture.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\tmap32.asm
+
+!IF  "$(CFG)" == "msdraw - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "msdraw - Win32 Debug"
+
+# Begin Custom Build
+IntDir=.\.\msvcobj
+InputPath=.\tmap32.asm
+InputName=tmap32
+
+"$(IntDir)\$(InputName).obj" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	c:\parts\tasm32\tasm32 /zi  /c  /ml  /m3 $(InputName).asm\
+ $(IntDir)\$(InputName).obj
+
+# End Custom Build
+
+!ENDIF 
+
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
+# Begin Source File
+
+SOURCE=.\bltfx.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ddraw.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\devdesc.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\devenum.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\device3d.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\direct3d.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\draw.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\drawsfc.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\dspenum.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\error.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\palette.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\pixform.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\rowinfo.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\sfccaps.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\sfcdesc.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\surface.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\texture.hpp
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project

ddraw/Msdraw.dsp

@@ -0,0 +1,213 @@
+# Microsoft Developer Studio Project File - Name="msdraw" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=msdraw - Win32 Release
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "Msdraw.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "Msdraw.mak" CFG="msdraw - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "msdraw - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "msdraw - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "msdraw - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir ".\Release"
+# PROP BASE Intermediate_Dir ".\Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir ".\Release"
+# PROP Intermediate_Dir ".\Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
+# ADD BASE RSC /l 0x409
+# ADD RSC /l 0x409
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ELSEIF  "$(CFG)" == "msdraw - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir ".\Debug"
+# PROP BASE Intermediate_Dir ".\Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ".\msvcobj"
+# PROP Intermediate_Dir ".\msvcobj"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /Zp1 /MTd /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /Fp"..\exe\msvc42.pch" /YX /FD /c
+# ADD BASE RSC /l 0x409
+# ADD RSC /l 0x409
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\exe\msdraw.lib"
+
+!ENDIF 
+
+# Begin Target
+
+# Name "msdraw - Win32 Release"
+# Name "msdraw - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90"
+# Begin Source File
+
+SOURCE=.\devenum.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\direct3d.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\draw.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\drawsfc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\dspenum.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\palette.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\texture.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\tmap32.asm
+
+!IF  "$(CFG)" == "msdraw - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "msdraw - Win32 Debug"
+
+# Begin Custom Build
+IntDir=.\msvcobj
+InputPath=.\tmap32.asm
+InputName=tmap32
+
+"$(IntDir)\$(InputName).obj" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	\parts\tasm32\tasm32 /zi  /c  /ml  /m3 $(InputName).asm  $(IntDir)\$(InputName).obj
+
+# End Custom Build
+
+!ENDIF 
+
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
+# Begin Source File
+
+SOURCE=.\bltfx.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ddraw.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\devdesc.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\devenum.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\device3d.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\direct3d.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\draw.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\drawsfc.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\dspenum.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\error.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\palette.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\pixform.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\rowinfo.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\sfccaps.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\sfcdesc.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\surface.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\texture.hpp
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project

ddraw/PALETTE.CPP

@@ -0,0 +1,83 @@
+#include <ddraw/palette.hpp>
+#include <common/openfile.hpp>
+#include <common/filemap.hpp>
+#include <common/pview.hpp>
+#include <common/purehdc.hpp>
+
+WORD DirectPalette::systemPalette(void)
+{
+	PureDevice screenDevice;
+  WORD systemPaletteEntries;
+
+  screenDevice.screenDevice();
+	systemPaletteEntries=::GetSystemPaletteEntries(screenDevice,0,MaxColors,(PALETTEENTRY FAR*)&mPaletteEntries);
+  return systemPaletteEntries;
+}
+
+BOOL DirectPalette::readPalette(const String &strPathFileName)
+{
+  FileHandle palFile(strPathFileName);
+	FileMap palMap(palFile);
+	PureViewOfFile palView(palMap);
+	PaletteEntry paletteEntry;
+	String strLine;
+	int palEntries;
+	char *pLine;
+	char strTokens[]={' ','\0'};
+
+	if(!palFile.isOkay())return FALSE;
+	palView.getLine(strLine);
+	if(!(strLine==String("JASC-PAL")))return FALSE;
+	palView.getLine(strLine);
+	if(!(strLine==String("0100")))return FALSE;
+	palView.getLine(strLine);
+	palEntries=::atoi(strLine);
+	if(palEntries!=MaxColors)return FALSE;
+	for(int palEntry=0;palEntry<palEntries;palEntry++)
+	{
+	  palView.getLine(strLine);
+		pLine=(char*)strLine;
+		pLine=::strtok(pLine,strTokens);
+		if(!pLine)continue;
+    paletteEntry.red(::atoi(pLine));
+		pLine=::strtok(0,strTokens);
+		if(!pLine)continue;
+		paletteEntry.green(::atoi(pLine));
+		pLine=::strtok(0,strTokens);
+		if(!pLine)continue;
+		paletteEntry.blue(::atoi(pLine));
+		paletteEntry.flags(PaletteEntry::NoCollapse);
+		mPaletteEntries[palEntry]=paletteEntry;
+	}
+	return TRUE;
+}
+
+void DirectPalette::initPalette(void)
+{
+  for(int index=0;index<10;index++) 
+  { 
+	  mPaletteEntries[index].flags(PaletteEntry::Explicit);
+		mPaletteEntries[index].red(index);
+		mPaletteEntries[index].green(0);
+		mPaletteEntries[index].blue(0);
+	  mPaletteEntries[246+index].flags(PaletteEntry::Explicit);
+		mPaletteEntries[246+index].red(246+index);
+		mPaletteEntries[246+index].green(0);
+		mPaletteEntries[246+index].blue(0);
+	}
+  for(index=10;index<26;index++) 
+  { 
+	  mPaletteEntries[index].flags(PaletteEntry::PaletteFlags(PaletteEntry::NoCollapse|PaletteEntry::Reserved));
+		mPaletteEntries[index].red(255);
+		mPaletteEntries[index].green(64);
+		mPaletteEntries[index].blue(32);
+  } 
+	for(;index<246;index++)
+  { 
+	  mPaletteEntries[index].flags(PaletteEntry::NoCollapse);
+		mPaletteEntries[index].red(25);
+		mPaletteEntries[index].green(6);
+		mPaletteEntries[index].blue(63);
+  } 
+} 
+

ddraw/PALETTE.HPP

@@ -0,0 +1,94 @@
+#ifndef _DDRAW_DIRECTPALETTE_HPP_
+#define _DDRAW_DIRECTPALETTE_HPP_
+#ifndef _COMMON_PALETTEENTRY_HPP_
+#include <common/palentry.hpp>
+#endif
+#ifndef _COMMON_SMARTPOINTER_HPP_
+#include <common/pointer.hpp>
+#endif
+#ifndef _DDRAW_DDRAW_HPP_
+#include <ddraw/ddraw.hpp>
+#endif
+
+class String;
+
+class DirectPalette : private SmartPointer<IDirectDrawPalette>
+{
+public:
+  friend class DirectDraw;
+	friend class Surface;
+  enum CreationFlags{PalIndex1Bit=DDPCAPS_1BIT,PalIndex2Bit=DDPCAPS_2BIT,PalIndex4Bit=DDPCAPS_4BIT,
+	  PalIndex8Bit=DDPCAPS_8BIT,PalIndex8BitEntries=DDPCAPS_8BITENTRIES,PalAlpha=DDPCAPS_ALPHA,
+		PalAllow256Entries=DDPCAPS_ALLOW256,PalInitialize=DDPCAPS_INITIALIZE,PalPrimarySurface=DDPCAPS_PRIMARYSURFACE,
+		PalPrimarySurfaceLeft=DDPCAPS_PRIMARYSURFACELEFT,PalVSync=DDPCAPS_VSYNC};
+	DirectPalette(void);
+	virtual ~DirectPalette();
+	DWORD flags(void);
+	void flags(DWORD flags);
+	PaletteEntry &operator[](int palIndex);
+  BOOL readPalette(const String &strPathFileName);
+  WORD systemPalette(void);
+	void destroy(void);
+private:
+  enum {MaxColors=256};
+  DirectPalette(const DirectPalette &someDirectPalette);
+	DirectPalette &operator=(const DirectPalette &someDirectPalette);
+	void initPalette(void);
+
+	PaletteEntry mPaletteEntries[MaxColors];
+  DWORD mPaletteFlags;
+};
+
+inline
+DirectPalette::DirectPalette(void)
+: mPaletteFlags(PalIndex8Bit|PalAllow256Entries)
+{
+  initPalette();
+}
+
+inline
+DirectPalette::DirectPalette(const DirectPalette &someDirectPalette)
+{ // private implementation
+  *this=someDirectPalette;
+}
+
+inline
+DirectPalette::~DirectPalette(void)
+{
+  destroy();
+}
+
+inline
+DirectPalette &DirectPalette::operator=(const DirectPalette &/*someDirectPalette*/)
+{ // private implementation
+  return *this;
+}
+
+inline
+PaletteEntry &DirectPalette::operator[](int palIndex)
+{
+  return mPaletteEntries[palIndex];
+}
+
+inline
+DWORD DirectPalette::flags(void)
+{
+  return mPaletteFlags;
+}
+
+inline
+void DirectPalette::flags(DWORD flags)
+{
+  mPaletteFlags=flags;
+}
+
+inline
+void DirectPalette::destroy(void)
+{
+  if(!isOkay())return;
+	operator->()->Release();
+  SmartPointer<IDirectDrawPalette>::destroy();
+}
+#endif
+
+

ddraw/PIXFORM.HPP

@@ -0,0 +1,469 @@
+#ifndef _DDRAW_PIXELFORMAT_HPP_
+#define _DDRAW_PIXELFORMAT_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _DDRAW_DDRAW_HPP_
+#include <ddraw/ddraw.hpp>
+#endif
+
+class PixelFormat : private DDPIXELFORMAT
+{
+public:
+  enum ControlFlags{Alpha=DDPF_ALPHA,AlphaPixels=DDPF_ALPHAPIXELS,AlphaPreMult=DDPF_ALPHAPREMULT,
+	  BumpLuminance=DDPF_BUMPLUMINANCE,BumpDUDV=DDPF_BUMPDUDV,Compressed=DDPF_COMPRESSED,
+		FourCC=DDPF_FOURCC,Luminance=DDPF_LUMINANCE,PaletteIndexed1=DDPF_PALETTEINDEXED1,
+		PaletteIndexed2=DDPF_PALETTEINDEXED2,PaletteIndexed4=DDPF_PALETTEINDEXED4,
+		PaletteIndexed8=DDPF_PALETTEINDEXED8,PaletteIndexedTo8=DDPF_PALETTEINDEXEDTO8,
+		RGB=DDPF_RGB,RGBToYUV=DDPF_RGBTOYUV,StencilBuffer=DDPF_STENCILBUFFER,YUV=DDPF_YUV,
+		ZBuffer=DDPF_ZBUFFER,ZPixels=DDPF_ZPIXELS};
+  PixelFormat(void);
+	PixelFormat(const PixelFormat &somePixelFormat);
+	PixelFormat(const DDPIXELFORMAT &someDDPIXELFORMAT);
+	virtual ~PixelFormat();
+	PixelFormat &operator=(const PixelFormat &somePixelFormat);
+	PixelFormat &operator=(const DDPIXELFORMAT &someDDPIXELFORMAT);
+	DWORD flags(void)const;
+	void flags(DWORD flags);
+	void flags(ControlFlags controlFlags);
+	DWORD fourCC(void)const;
+	void fourCC(DWORD fourCC);
+	DWORD rgbBitCount(void)const;
+	void rgbBitCount(DWORD rgbBitCount);
+	DWORD yuvBitCount(void)const;
+	void yuvBitCount(DWORD yuvBitCount);
+	DWORD zBufferBitDepth(void)const;
+	void zBufferBitDepth(DWORD zBufferBitDepth);
+	DWORD alphaBitDepth(void)const;
+	void alphaBitDepth(DWORD alphaBitDepth);
+	DWORD luminanceBitCount(void)const;
+	void luminanceBitCount(DWORD luminanceBitCount);
+	DWORD bumpBitCount(void)const;
+	void bumpBitCount(DWORD bumpBitCount);
+	DWORD rBitMask(void)const;
+	void rBitMask(DWORD resBitMask);
+	DWORD yBitMask(void)const;
+	void yBitMask(DWORD yBitMask);
+	DWORD gBitMask(void)const;
+	void gBitMask(DWORD gBitMask);
+	DWORD uBitMask(void)const;
+	void uBitMask(DWORD uBitMask);
+	DWORD zBitMask(void)const;
+	void zBitMask(DWORD zBitMask);
+	DWORD bBitMask(void)const;
+	void bBitMask(DWORD bBitMask);
+	DWORD vBitMask(void)const;
+	void vBitMask(DWORD vBitMask);
+	DWORD stencilBitDepth(void)const;
+	void stencilBitDepth(DWORD stencilBitDepth);
+	DWORD luminanceBitMask(void)const;
+	void luminanceBitMask(DWORD luminanceBitMask);
+	DWORD bumpDuBitMask(void)const;
+	void bumpDuBitMask(DWORD bumpDuBitMask);
+	DWORD bumpDvBitMask(void)const;
+	void bumpDvBitMask(DWORD bumpDvBitMask);
+	DWORD stencilBitMask(void)const;
+	void stencilBitMask(DWORD stencilBitMask);
+	DWORD bumpLuminanceBitMask(void)const;
+	void bumpLuminanceBitMask(DWORD bumpLuminanceBitMask);
+	DWORD rgbAlphaBitMask(void)const;
+	void rgbAlphaBitMask(DWORD rgbAlphaBitMask);
+	DWORD yuvAlphaBitMask(void)const;
+	void yuvAlphaBitMask(DWORD yuvAlphaBitMask);
+	DWORD luminanceAlphaBitMask(void)const;
+	void luminanceAlphaBitMask(DWORD luminanceAlphaBitMask);
+	DWORD rgbZBitMask(void)const;
+	void rgbZBitMask(DWORD rgbZBitMask);
+	DWORD yuvZBitMask(void)const;
+	void yuvZBitMask(DWORD yuvZBitMask);
+	DDPIXELFORMAT &getDDPIXELFORMAT(void);
+private:
+  void zeroInit(void);
+};
+
+inline
+PixelFormat::PixelFormat(void)
+{
+  zeroInit();
+}
+
+inline
+PixelFormat::PixelFormat(const PixelFormat &somePixelFormat)
+{
+  *this=somePixelFormat;
+}
+
+inline
+PixelFormat::PixelFormat(const DDPIXELFORMAT &someDDPIXELFORMAT)
+{
+  *this=someDDPIXELFORMAT;
+}
+
+inline
+PixelFormat::~PixelFormat()
+{
+}
+
+inline
+PixelFormat &PixelFormat::operator=(const PixelFormat &somePixelFormat)
+{
+  flags(somePixelFormat.flags());
+	fourCC(somePixelFormat.fourCC());
+	rgbBitCount(somePixelFormat.rgbBitCount());
+	rBitMask(somePixelFormat.rBitMask());
+	gBitMask(somePixelFormat.gBitMask());
+	bBitMask(somePixelFormat.bBitMask());
+	rgbAlphaBitMask(somePixelFormat.rgbAlphaBitMask());
+	return *this;
+}
+
+inline
+PixelFormat &PixelFormat::operator=(const DDPIXELFORMAT &someDDPIXELFORMAT)
+{
+  flags(someDDPIXELFORMAT.dwFlags);
+	fourCC(someDDPIXELFORMAT.dwFourCC);
+	rgbBitCount(someDDPIXELFORMAT.dwRGBBitCount);
+	rBitMask(someDDPIXELFORMAT.dwRBitMask);
+	gBitMask(someDDPIXELFORMAT.dwGBitMask);
+	bBitMask(someDDPIXELFORMAT.dwBBitMask);
+	rgbAlphaBitMask(someDDPIXELFORMAT.dwRGBAlphaBitMask);
+	return *this;
+}
+
+inline
+DWORD PixelFormat::flags(void)const
+{
+  return DDPIXELFORMAT::dwFlags;
+}
+
+inline
+void PixelFormat::flags(DWORD flags)
+{
+  DDPIXELFORMAT::dwFlags=flags;
+}
+
+inline
+void PixelFormat::flags(ControlFlags controlFlags)
+{
+  DDPIXELFORMAT::dwFlags=(DWORD)controlFlags;
+}
+
+inline
+DWORD PixelFormat::fourCC(void)const
+{
+  return DDPIXELFORMAT::dwFourCC;
+}
+
+inline
+void PixelFormat::fourCC(DWORD fourCC)
+{
+  DDPIXELFORMAT::dwFourCC=fourCC;
+}
+
+inline
+DWORD PixelFormat::rgbBitCount(void)const
+{
+  return DDPIXELFORMAT::dwRGBBitCount;
+}
+
+inline
+void PixelFormat::rgbBitCount(DWORD rgbBitCount)
+{
+  DDPIXELFORMAT::dwRGBBitCount=rgbBitCount;
+}
+
+inline
+DWORD PixelFormat::yuvBitCount(void)const
+{
+  return DDPIXELFORMAT::dwYUVBitCount;
+}
+
+inline
+void PixelFormat::yuvBitCount(DWORD yuvBitCount)
+{
+  DDPIXELFORMAT::dwYUVBitCount=yuvBitCount;
+}
+
+inline
+DWORD PixelFormat::zBufferBitDepth(void)const
+{
+  return DDPIXELFORMAT::dwZBufferBitDepth;
+}
+
+inline
+void PixelFormat::zBufferBitDepth(DWORD zBufferBitDepth)
+{
+  DDPIXELFORMAT::dwZBufferBitDepth=zBufferBitDepth;
+}
+
+inline
+DWORD PixelFormat::alphaBitDepth(void)const
+{
+  return DDPIXELFORMAT::dwAlphaBitDepth;
+}
+
+inline
+void PixelFormat::alphaBitDepth(DWORD alphaBitDepth)
+{
+  DDPIXELFORMAT::dwAlphaBitDepth=alphaBitDepth;
+}
+
+inline
+DWORD PixelFormat::luminanceBitCount(void)const
+{
+  return DDPIXELFORMAT::dwLuminanceBitCount;
+}
+
+inline
+void PixelFormat::luminanceBitCount(DWORD luminanceBitCount)
+{
+  DDPIXELFORMAT::dwLuminanceBitCount=luminanceBitCount;
+}
+
+inline
+DWORD PixelFormat::bumpBitCount(void)const
+{
+  return DDPIXELFORMAT::dwBumpBitCount;
+}
+
+inline
+void PixelFormat::bumpBitCount(DWORD bumpBitCount)
+{
+  DDPIXELFORMAT::dwBumpBitCount=bumpBitCount;
+}
+
+inline
+DWORD PixelFormat::rBitMask(void)const
+{
+  return DDPIXELFORMAT::dwRBitMask;
+}
+
+inline
+void PixelFormat::rBitMask(DWORD rBitMask)
+{
+  DDPIXELFORMAT::dwRBitMask=rBitMask;
+}
+
+inline
+DWORD PixelFormat::yBitMask(void)const
+{
+  return DDPIXELFORMAT::dwYBitMask;
+}
+
+inline
+void PixelFormat::yBitMask(DWORD yBitMask)
+{
+  DDPIXELFORMAT::dwYBitMask=yBitMask;
+}
+
+inline
+DWORD PixelFormat::gBitMask(void)const
+{
+  return DDPIXELFORMAT::dwGBitMask;
+}
+
+inline
+void PixelFormat::gBitMask(DWORD gBitMask)
+{
+  DDPIXELFORMAT::dwGBitMask=gBitMask;
+}
+
+inline
+DWORD PixelFormat::uBitMask(void)const
+{
+  return DDPIXELFORMAT::dwUBitMask;
+}
+
+inline
+void PixelFormat::uBitMask(DWORD uBitMask)
+{
+  DDPIXELFORMAT::dwUBitMask=uBitMask;
+}
+
+inline
+DWORD PixelFormat::zBitMask(void)const
+{
+  return DDPIXELFORMAT::dwZBitMask;
+}
+
+inline
+void PixelFormat::zBitMask(DWORD zBitMask)
+{
+  DDPIXELFORMAT::dwZBitMask=zBitMask;
+}
+
+inline
+DWORD PixelFormat::bBitMask(void)const
+{
+  return DDPIXELFORMAT::dwBBitMask;
+}
+
+inline
+void PixelFormat::bBitMask(DWORD bBitMask)
+{
+  DDPIXELFORMAT::dwBBitMask=bBitMask;
+}
+
+inline
+DWORD PixelFormat::vBitMask(void)const
+{
+  return DDPIXELFORMAT::dwVBitMask;
+}
+
+inline
+void PixelFormat::vBitMask(DWORD vBitMask)
+{
+  DDPIXELFORMAT::dwVBitMask=vBitMask;
+}
+
+inline
+DWORD PixelFormat::stencilBitDepth(void)const
+{
+  return DDPIXELFORMAT::dwStencilBitDepth;
+}
+
+inline
+void PixelFormat::stencilBitDepth(DWORD stencilBitDepth)
+{
+  DDPIXELFORMAT::dwStencilBitDepth=stencilBitDepth;
+}
+
+inline
+DWORD PixelFormat::luminanceBitMask(void)const
+{
+  return DDPIXELFORMAT::dwLuminanceBitMask;
+}
+
+inline
+void PixelFormat::luminanceBitMask(DWORD luminanceBitMask)
+{
+  DDPIXELFORMAT::dwLuminanceBitMask=luminanceBitMask;
+}
+
+inline
+DWORD PixelFormat::bumpDuBitMask(void)const
+{
+  return DDPIXELFORMAT::dwBumpDuBitMask;
+}
+
+inline
+void PixelFormat::bumpDuBitMask(DWORD bumpDuBitMask)
+{
+  DDPIXELFORMAT::dwBumpDuBitMask=bumpDuBitMask;
+}
+
+inline
+DWORD PixelFormat::bumpDvBitMask(void)const
+{
+  return DDPIXELFORMAT::dwBumpDvBitMask;
+}
+
+inline
+void PixelFormat::bumpDvBitMask(DWORD bumpDvBitMask)
+{
+  DDPIXELFORMAT::dwBumpDvBitMask;
+}
+
+inline
+DWORD PixelFormat::stencilBitMask(void)const
+{
+  return DDPIXELFORMAT::dwStencilBitMask;
+}
+
+inline
+void PixelFormat::stencilBitMask(DWORD stencilBitMask)
+{
+  DDPIXELFORMAT::dwStencilBitMask=stencilBitMask;
+}
+
+inline
+DWORD PixelFormat::bumpLuminanceBitMask(void)const
+{
+  return DDPIXELFORMAT::dwBumpLuminanceBitMask;
+}
+
+inline
+void PixelFormat::bumpLuminanceBitMask(DWORD bumpLuminanceBitMask)
+{
+  DDPIXELFORMAT::dwBumpLuminanceBitMask=bumpLuminanceBitMask;
+}
+
+inline
+DWORD PixelFormat::rgbAlphaBitMask(void)const
+{
+  return DDPIXELFORMAT::dwRGBAlphaBitMask;
+}
+
+inline
+void PixelFormat::rgbAlphaBitMask(DWORD rgbAlphaBitMask)
+{
+  DDPIXELFORMAT::dwRGBAlphaBitMask=rgbAlphaBitMask;
+}
+
+inline
+DWORD PixelFormat::yuvAlphaBitMask(void)const
+{
+  return DDPIXELFORMAT::dwYUVAlphaBitMask;
+}
+
+inline
+void PixelFormat::yuvAlphaBitMask(DWORD yuvAlphaBitMask)
+{
+  DDPIXELFORMAT::dwYUVAlphaBitMask=yuvAlphaBitMask;
+}
+
+inline
+DWORD PixelFormat::luminanceAlphaBitMask(void)const
+{
+  return DDPIXELFORMAT::dwLuminanceAlphaBitMask;
+}
+
+inline
+void PixelFormat::luminanceAlphaBitMask(DWORD luminanceAlphaBitMask)
+{
+  DDPIXELFORMAT::dwLuminanceAlphaBitMask=luminanceAlphaBitMask;
+}
+
+inline
+DWORD PixelFormat::rgbZBitMask(void)const
+{
+  return DDPIXELFORMAT::dwRGBZBitMask;
+}
+
+inline
+void PixelFormat::rgbZBitMask(DWORD rgbZBitMask)
+{
+  DDPIXELFORMAT::dwRGBZBitMask=rgbZBitMask;
+}
+
+inline
+DWORD PixelFormat::yuvZBitMask(void)const
+{
+  return DDPIXELFORMAT::dwYUVZBitMask;
+}
+
+inline
+void PixelFormat::yuvZBitMask(DWORD yuvZBitMask)
+{
+  DDPIXELFORMAT::dwYUVZBitMask=yuvZBitMask=yuvZBitMask;
+}
+
+inline
+DDPIXELFORMAT &PixelFormat::getDDPIXELFORMAT(void)
+{
+  return (DDPIXELFORMAT&)*this;
+}
+
+inline
+void PixelFormat::zeroInit(void)
+{
+  DDPIXELFORMAT::dwSize=sizeof(DDPIXELFORMAT);
+	DDPIXELFORMAT::dwFlags=0;
+	DDPIXELFORMAT::dwFourCC=0;
+	DDPIXELFORMAT::dwRGBBitCount=0;
+	DDPIXELFORMAT::dwRBitMask=0;
+	DDPIXELFORMAT::dwGBitMask=0;
+	DDPIXELFORMAT::dwBBitMask=0;
+	DDPIXELFORMAT::dwRGBAlphaBitMask=0;
+}
+#endif

ddraw/RESULT.HPP

@@ -0,0 +1,11 @@
+#ifndef _DDRAW_RESULTCODE_HPP_
+#define _DDRAW_RESULTCODE_HPP_
+
+  enum DirectDrawResult{Ok=DD_OK,IncompatiblePrimary=DDERR_INCOMPATIBLEPRIMARY,InvalidCaps=DDERR_INVALIDCAPS,
+	  InvalidPixelFormat=DDERR_INVALIDPIXELFORMAT,NoAlphaHardware=DDERR_NOALPHAHW,
+		NoCooperativeLevelSet=DDERR_NOCOOPERATIVELEVELSET,NoDirectDrawHardware=NODIRECTDRAWHW,
+		NoEmulation=DDERR_NOEMULATION,NoExclusiveMode=DDERR_NOEXCLUSIVEMODE,NoFlipHardware=DDERR_NOFLIPHW,
+		NoMipMapHardware=DDERR_NOMIMAPHW,NoOverlayHardware=DDERR_NOOVERLAYHW,NoZBufferHardware=DDERR_NOZBUFFERHW,
+		OutOfMemory=DDERR_OUTOFMEMORY,OutOfVideoMemory=DDERR_OUTOFVIDEOMEMORY,
+		PrimarySurfaceAlreadyExists=DDERR_PRIMARYSURFACEALREADYEXISTS,UnsupportedMode=DDERR_UNSUPPORTEDMODE};
+

ddraw/ROWINFO.HPP

@@ -0,0 +1,57 @@
+#ifndef _DDRAW_ROWINFO_HPP_
+#define _DDRAW_ROWINFO_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+
+class RowInfo
+{
+public:
+  enum {MaxRows=1024};
+  RowInfo(void);
+	virtual ~RowInfo();
+	int &operator[](int rowIndex);
+	int rowCount(void);
+	void rowCount(int rowCount);
+private:
+  void zeroInit(void);
+  int mRowArray[MaxRows];
+	int mRowCount;
+};
+
+inline
+RowInfo::RowInfo(void)
+: mRowCount(0)
+{
+  zeroInit();
+}
+
+inline
+RowInfo::~RowInfo()
+{
+}
+
+inline
+int &RowInfo::operator[](int rowIndex)
+{
+  return mRowArray[rowIndex];
+}
+
+inline
+int RowInfo::rowCount(void)
+{
+  return mRowCount;
+}
+
+inline
+void RowInfo::rowCount(int rowCount)
+{
+  mRowCount=rowCount;
+}
+
+inline
+void RowInfo::zeroInit(void)
+{
+  ::memset(mRowArray,0,sizeof(mRowArray));
+}
+#endif

ddraw/SCRAPS.TXT

@@ -0,0 +1,439 @@
+// **************************
+
+class MyDeviceEnumerator : public DeviceEnumerator
+{
+public:
+protected:
+  virtual void enumDevice(DeviceDescription &deviceDescription);
+private:
+};
+
+void MyDeviceEnumerator::enumDevice(DeviceDescription &deviceDescription)
+{
+  ::OutputDebugString(deviceDescription.deviceName()+String(" ")+deviceDescription.deviceDescription()+String("\n"));
+	return;
+}
+
+
+
+
+DDPIXELFORMAT
+The DDPIXELFORMAT structure describes the pixel format of a DirectDrawSurface object for the IDirectDrawSurface4::GetPixelFormat method.
+typedef struct _DDPIXELFORMAT{ 
+    DWORD dwSize; 
+    DWORD dwFlags; 
+    DWORD dwFourCC; 
+    union 
+    { 
+        DWORD dwRGBBitCount; 
+        DWORD dwYUVBitCount; 
+        DWORD dwZBufferBitDepth; 
+        DWORD dwAlphaBitDepth; 
+        DWORD dwLuminanceBitCount; // new for DirectX 6.0
+        DWORD dwBumpBitCount;      // new for DirectX 6.0
+    } DUMMYUNIONNAMEN(1);
+    union 
+    { 
+        DWORD dwRBitMask; 
+        DWORD dwYBitMask; 
+        DWORD dwStencilBitDepth;   // new for DirectX 6.0
+        DWORD dwLuminanceBitMask;  // new for DirectX 6.0
+        DWORD dwBumpDuBitMask;     // new for DirectX 6.0
+    } DUMMYUNIONNAMEN(2);
+    union 
+    { 
+        DWORD dwGBitMask; 
+        DWORD dwUBitMask; 
+        DWORD dwZBitMask;          // new for DirectX 6.0
+        DWORD dwBumpDvBitMask;     // new for DirectX 6.0
+    } DUMMYUNIONNAMEN(3);
+    union 
+    { 
+        DWORD dwBBitMask; 
+        DWORD dwVBitMask; 
+        DWORD dwStencilBitMask;    // new for DirectX 6.0
+        DWORD dwBumpLuminanceBitMask;  // new for DirectX 6.0
+    } DUMMYUNIONNAMEN(4);
+    union 
+    { 
+        DWORD dwRGBAlphaBitMask; 
+        DWORD dwYUVAlphaBitMask; 
+        DWORD dwLuminanceAlphaBitMask; // new for DirectX 6.0
+        DWORD dwRGBZBitMask; 
+        DWORD dwYUVZBitMask; 
+    } DUMMYUNIONNAMEN(5);
+} DDPIXELFORMAT, FAR* LPDDPIXELFORMAT; 
+ 
+Members
+dwSize
+Size of the structure, in bytes. This member must be initialized before the structure is used.
+dwFlags
+Optional control flags. 
+DDPF_ALPHA 
+The pixel format describes an alpha-only surface. 
+DDPF_ALPHAPIXELS 
+The surface has alpha channel information in the pixel format. 
+DDPF_ALPHAPREMULT
+The surface uses the premultiplied alpha format. That is, the color components in each pixel are premultiplied by the alpha component.
+DDPF_BUMPLUMINANCE
+The luminance data in the pixel format is valid, and the dwLuminanceBitMask member descibes valid luminance bits for a luminance-only or luminance-alpha surface.
+DDPF_BUMPDUDV
+Bump-map data in the pixel format is valid. Bump-map information is in the dwBumpBitCount, dwBumpDuBitMask, dwBumpDvBitMask, and dwBumpLuminanceBitMask members.
+DDPF_COMPRESSED 
+The surface will accept pixel data in the specified format and compress it during the write operation. 
+DDPF_FOURCC 
+The dwFourCC member is valid and contains a FOURCC code describing a non-RGB pixel format. 
+DDPF_LUMINANCE
+The pixel format describes a luminance-only or luminance-alpha surface.
+DDPF_PALETTEINDEXED1 
+DDPF_PALETTEINDEXED2 
+DDPF_PALETTEINDEXED4 
+DDPF_PALETTEINDEXED8 
+The surface is 1-, 2-, 4-, or 8-bit color indexed. 
+DDPF_PALETTEINDEXEDTO8 
+The surface is 1-, 2-, or 4-bit color indexed to an 8-bit palette. 
+DDPF_RGB 
+The RGB data in the pixel format structure is valid. 
+DDPF_RGBTOYUV 
+The surface will accept RGB data and translate it during the write operation 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. 
+DDPF_STENCILBUFFER
+The surface encodes stencil and depth information in each pixel of the z-buffer. This flag can only be used if the DDPF_ZBUFFER flag is also specified.
+DDPF_YUV 
+The YUV data in the pixel format structure is valid. 
+DDPF_ZBUFFER 
+The pixel format describes a z-buffer surface. 
+DDPF_ZPIXELS 
+The surface contains z information in the pixels.
+dwFourCC
+FourCC code. For more information see, Four Character Codes (FOURCC).
+dwRGBBitCount
+RGB bits per pixel (4, 8, 16, 24, or 32).
+dwYUVBitCount
+YUV bits per pixel (4, 8, 16, 24, or 32).
+dwZBufferBitDepth
+Z-buffer bit depth (8, 16, 24, or 32).
+dwAlphaBitDepth
+Alpha channel bit depth (1, 2, 4, or 8) for an alpha-only surface (DDPF_ALPHA). For pixel formats that contain alpha information interleaved with color data (DDPF_ALPHAPIXELS), you must count the bits in the dwRGBAlphaBitMask member to obtain the bit-depth of the alpha component. For more information, see Remarks.
+dwLuminanceBitCount
+Total luminance bits per pixel. This member applies only to luminance-only and luminance-alpha surfaces. 
+dwBumpBitCount
+Total bump-map bits per pixel in a bump-map surface.
+dwRBitMask
+Mask for red bits.
+dwYBitMask
+Mask for Y bits.
+dwStencilBitDepth
+Bit depth of the stencil buffer. This member specifies how many bits are reserved within each pixel of the z-buffer for stencil information (the total number of z-bits is equal to dwZBufferBitDepth minus dwStencilBitDepth).
+dwLuminanceBitMask
+Mask for luminance bits.
+dwBumpDuBitMask
+Mask for bump-map U-delta bits. 
+dwGBitMask
+Mask for green bits.
+dwUBitMask
+Mask for U bits.
+dwZBitMask
+Mask for z bits.
+dwBumpDvBitMask
+Mask for bump-map V-delta bits. 
+dwBBitMask
+Mask for blue bits.
+dwVBitMask
+Mask for V bits.
+dwStencilBitMask
+Mask for stencil bits within each z-buffer pixel.
+dwBumpLuminanceBitMask
+Mask for luminance in a bump-map pixel. 
+dwRGBAlphaBitMask and dwYUVAlphaBitMask and dwLuminanceAlphaBitMask
+Masks for alpha channel.
+dwRGBZBitMask and dwYUVZBitMask
+Masks for z channel.
+
+Remarks
+The dwAlphaBitDepth member reflects the bit depth of an alpha-only pixel format (DDPF_ALPHA). For pixel formats that include the alpha component with color components (DDPF_ALPHAPIXELS), the alpha bit depth is obtained by counting the bits in the various mask members. The following example function returns the number of bits set in a given bitmask:
+WORD GetNumberOfBits( DWORD dwMask )
+{
+    WORD wBits = 0;
+    while( dwMask )
+    {
+        dwMask = dwMask & ( dwMask - 1 );  
+        wBits++;
+    }
+    return wBits;
+}
+ 
+The unions in this structure have been updated to work with compilers that don't support nameless unions. If your compiler doesn't support nameless unions, define the NONAMELESSUNION token before including the Ddraw.h header file.
+
+
+
+
+CallbackData::ReturnType MainWindow::activateAppHandler(CallbackData &someCallbackData)
+{
+#if 0
+  if(!mDirectDraw.isOkay())return (CallbackData::ReturnType)FALSE;
+  if(someCallbackData.wParam())
+	{
+	  mDirectDraw->setCooperativeLevel(*this,DirectDraw::CoopFlags(DirectDraw::Exclusive|DirectDraw::FullScreen));
+//	  mDirectDraw->setDisplayMode(800,600,24);
+//    Surface primarySurface;
+//    SurfaceDescription surfaceDescription;
+//	  SurfaceCapabilities surfaceCapabilities(SurfaceCapabilities::Capabilities(SurfaceCapabilities::PrimarySurface|SurfaceCapabilities::Device3D));
+//	  surfaceDescription.flags(SurfaceDescription::Capabilities);
+//	  surfaceDescription.width(800);
+//	  surfaceDescription.height(600);
+//	  surfaceDescription.surfaceCapabilities(surfaceCapabilities);
+//		DirectDrawError errorResult(mDirectDraw->createSurface(surfaceDescription,primarySurface));
+	}
+	else mDirectDraw->restoreDisplayMode();
+#endif
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::displayChangeHandler(CallbackData &someCallbackData)
+{
+#if 0
+  if(!mDirectDraw.isOkay())return (CallbackData::ReturnType)FALSE;
+	if(!mDirectDraw->testCooperativeLevel())::OutputDebugString("testCooperativeLevel failed\n");
+	else ::OutputDebugString("testCooperativeLevel succeeded\n");
+#endif
+  return (CallbackData::ReturnType)FALSE;
+}
+
+
+
+  enum RenderState{RenderStateTextureHandler=D3DRENDERSTATE_TEXTUREHANDLE,
+	  RenderStateAntialias=D3DRENDERSTATE_ANTIALIAS,RenderStateTextureAddress=D3DRENDERSTATE_TEXTUREADDRESS,
+	  RenderStateTexturePerspective=D3DRENDERSTATE_TEXTUREPERSPECTIVE,RenderStateWrapU=D3DRENDERSTATE_WRAPU,
+		RenderStateWrapV=D3DRENDERSTATE_WRAPV,RenderStateZEnable=D3DRENDERSTATE_ZENABLE,
+		RenderStateFillMode=D3DRENDERSTATE_FILLMODE,RenderStateShadeMode=D3DRENDERSTATE_SHADEMODE,
+		RenderStateLinePattern=D3DRENDERSTATE_LINEPATTERN,RenderStateMonoEnable=D3DRENDERSTATE_MONOENABLE,
+		RenderStateROP2=D3DRENDERSTATE_ROP2,RenderStatePlaneMask=D3DRENDERSTATE_PLANEMASK,
+		RenderStateZWriteEnable=D3DRENDERSTATE_ZWRITEENABLE,RenderStateAlphaTestEnable=D3DRENDERSTATE_ALPHATESTENABLE,
+		RenderStateLastPixel=D3DRENDERSTATE_LASTPIXEL,RenderStateTextureMag=D3DRENDERSTATE_TEXTUREMAG,
+		RenderStateTextureMin=D3DRENDERSTATE_TEXTUREMIN,RenderStateSrcBlend=D3DRENDERSTATE_SRCBLEND,
+		RenderStateDestBlend=D3DRENDERSTATE_DESTBLEND,RenderStateTextureMapBlend=D3DRENDERSTATE_TEXTUREMAPBLEND,
+		RenderStateCullMode=D3DRENDERSTATE_CULLMODE,RenderStateZFunc=D3DRENDERSTATE_ZFUNC,
+		RenderStateAlphaRef=D3DRENDERSTATE_ALPHAREF,RenderStateAlphaFunc=D3DRENDERSTATE_ALPHAFUNC,
+		RenderStateDitherEnable=D3DRENDERSTATE_DITHERENABLE,
+		RenderStateAlphaBlendEnable=D3DRENDERSTATE_ALPHABLENDENABLE,
+		RenderStateFogEnable=D3DRENDERSTATE_FOGENABLE,
+		RenderStateSpecularEnable=D3DRENDERSTATE_SPECULARENABLE,RenderStateZVisible=D3DRENDERSTATE_ZVISIBLE,
+		RenderStateSubPixel=D3DRENDERSTATE_SUBPIXEL,RenderStateStippledAlpha=D3DRENDERSTATE_STIPPLEDALPHA,
+		RenderStateFogColor=D3DRENDERSTATE_FOGCOLOR,RenderStateFogTableMode=D3DRENDERSTATE_FOGTABLEMODE,
+		RenderStateFogTableStartD3DRENDERSTATE_FOGTABLESTART,RenderStateFogTableEnd=D3DRENDERSTATE_FOGTABLEEND,
+		RenderStateFogTableDensity=D3DRENDERSTATE_FOGTABLEDENSITY,RenderStateStippleEnable=D3DRENDERSTATE_STIPPLEENABLE,
+		RenderStateEdgeAntialias=D3DRENDERSTATE_EDGEANTIALIAS,RenderStateColorKeyEnable=D3DRENDERSTATE_COLORKEYENABLE,
+		RenderStateBorderColor=D3DRENDERSTATE_BORDERCOLOR,RenderStateTextureAddressU=D3DRENDERSTATE_TEXTUREADDRESSU,
+		RenderStateTextureAddressV=D3DRENDERSTATE_TEXTUREADDRESSV,RenderStateMipMapLODBias=D3DRENDERSTATE_MIPMAPLODBIAS,
+		RenderStateZBias=D3DRENDERSTATE_ZBIAS,RenderStateRangeFogEnable=D3DRENDERSTATE_RANGEFOGENABLE,
+		RenderStateAnisotropy=D3DRENDERSTATE_ANISOTROPY,RenderStateFlushBatch=D3DRENDERSTATE_FLUSHBATCH,
+		RenderStateTranslucentSortIndependent=D3DRENDERSTATE_TRANSLUCENTSORTINDEPENDENT,
+		RenderStateStencilEnable=D3DRENDERSTATE_STENCILENABLE,RenderStateStencilFail=D3DRENDERSTATE_STENCILFAIL,
+		RenderStateStencilZFail=D3DRENDERSTATE_STENCILZFAIL,RenderStateStencilPass=D3DRENDERSTATE_STENCILPASS,
+		RenderStateStencilFunc=D3DRENDERSTATE_STENCILFUNC,RenderStateStencilRef=D3DRENDERSTATE_STENCILREF,
+		RenderStateStencilMask=D3DRENDERSTATE_STENCILMASK,RenderStateStencilWriteMask=D3DRENDERSTATE_STENCILWRITEMASK,
+		RenderStateTetxureFactor=D3DRENDERSTATE_TEXTUREFACTOR,RenderStateStipplePattern31=D3DRENDERSTATE_STIPPLEPATTERN31,
+		RenderStateWrap0=D3DRENDERSTATE_WRAP0,RenderStateWrap7=D3DRENDERSTATE_WRAP7,
+		RenderStateForceDoubleWord=D3DRENDERSTATE_FORCE_DWORD};
+
+
+  surfaceDescription.flags(SurfaceDescription::Capabilities);  // |SurfaceDescription::BackBufferCount
+  surfaceDescription.surfaceCapabilities(surfaceCapabilities);
+//	surfaceDescription.backBufferCount(1);
+  // |SurfaceCapabilities::Complex|SurfaceCapabilities::Flip
+
+	  PixelFormat pixelFormat;
+	BltEffects bltEffects;
+	DirectDrawError status;
+
+	mDirectDraw->setCooperativeLevel(*this,DirectDraw::CoopFlags(DirectDraw::Exclusive|DirectDraw::FullScreen));
+	mDirectDraw->setDisplayMode(DisplayWidth,DisplayHeight,DisplayBPP);
+	mDirectDraw->restoreAllSurfaces();
+	mPrimarySurface.getPixelFormat(pixelFormat);
+
+
+//	BltEffects bltEffects;
+//	for(int i=0;i<100;i++)
+//	{
+//	  bltEffects.fillColor(pixelFormat.bBitMask());
+//		mPrimarySurface.blt(bltEffects,Surface::BltFlags((int)Surface::BltColorFill|(int)Surface::BltEffects));
+//	  bltEffects.fillColor(pixelFormat.rBitMask());
+//	  mPrimarySurface.blt(bltEffects,Surface::BltFlags((int)Surface::BltColorFill|(int)Surface::BltEffects));
+//	  bltEffects.fillColor(pixelFormat.gBitMask());
+//	  mPrimarySurface.blt(bltEffects,Surface::BltFlags((int)Surface::BltColorFill|(int)Surface::BltEffects));
+//	}
+
+
+#if 0
+//	SurfaceDescription surfaceDescription;
+//	if(!mPrimarySurface.lock(surfaceDescription).okResult())::OutputDebugString("Lock Failed\n");
+  DWORD ticks(::GetTickCount());
+	if(!mPrimarySurface.lock(FALSE))::OutputDebugString("Lock Failed\n");
+	else 
+	{
+	  int width(mPrimarySurface.width());
+		int height(mPrimarySurface.height());
+
+		mPrimarySurface.setBits(255);
+
+    for(int rep=0;rep<200;rep++)
+		{
+      for(int x=100;x<200;x++)
+		  {
+		    mPrimarySurface.circle(Point(x,100),50,0);
+		    mPrimarySurface.circle(Point(x,100),50,255);
+		  }
+		}
+
+
+//		for(int colorIndex=0;colorIndex<255;colorIndex++)
+//		{
+//		  mPrimarySurface.setBits(colorIndex);
+//		  for(int row=0;row<height;row++)
+//		  {
+//		    for(int col=0;col<width;col++)
+//			  {
+//			    mPrimarySurface.setByte(row,col,colorIndex);
+//			  }
+//		  }
+//		}
+	}
+	String strTime;
+	::sprintf(strTime,"seconds:%d\n",(::GetTickCount()-ticks)/1000);
+
+//	  for(int index=0;index<255;index++)
+//		{
+//		  mPrimarySurface.setByte();
+//	    LPVOID lpVoid=surfaceDescription.ptrSurface();
+//		  for(int i=0;i<480;i++)
+//		  {
+//	      ::memset(lpVoid,index,640);
+//			  lpVoid=(void*)((char*)lpVoid+surfaceDescription.lPitch());
+//		  }
+//		}
+//	}
+	mPrimarySurface.unlock();
+	::OutputDebugString(strTime);
+#endif
+
+
+roundEAX MACRO
+LOCAL @@return
+  mov edx,eax                     ; copy eax to edx
+	and edx,7FFh                    ; get remainder to edx register
+	shr eax,BitShift                ; get whole number to eax register
+	cmp edx,400h                    ; if remainder>1024 then increment eax
+	jle @@return                    ; ... otherwise return
+	inc eax                         ; increment value in eax
+@@return:
+ENDM
+
+
+
+;if 0
+;**********************
+	mov eax,[esi].DirectTriEdge@@mxLeft              ; move mxLeft into eax
+	shl eax,BitShift																 ; multiply by 2048
+	add eax,[esi].DirectTriEdge@@mDXLeft						 ; add in the delta
+	roundEAX                                         ; adjust and round the value
+	mov [esi].DirectTriEdge@@mxLeft,eax              ; this is new mxLeft
+	verifyLeft																			 ; check/adjust mxLeft
+	mov eax,[esi].DirectTriEdge@@mxRight             ; move mxRight into eax
+	shl eax,BitShift                                 ; multiply by 2048
+	add eax,[esi].DirectTriEdge@@mDXRight            ; add in the delta
+	roundEAX                                         ; adjust and round the value
+	mov [esi].DirectTriEdge@@mxRight,eax             ; this is new mxRight
+	verifyRight                                      ; check/adjust mxRight
+	mov eax,[esi].DirectTriEdge@@muLeft              ; move muLeft into eax
+	shl eax,BitShift                                 ; multiply by 2048
+	add eax,[esi].DirectTriEdge@@mDULeft						 ; add in the delta
+	roundEAX                                         ; adjust and round the value
+	mov [esi].DirectTriEdge@@muLeft,eax							 ; this is new muLeft
+	mov eax,[esi].DirectTriEdge@@muRight						 ; move muRight into eax 
+	shl eax,BitShift																 ; multiply by 2048
+	add eax,[esi].DirectTriEdge@@mDURight						 ; add in the delta
+	roundEAX                                         ; adjust and round the value
+	mov [esi].DirectTriEdge@@muRight,eax						 ; this is new muRight
+	mov eax,[esi].DirectTriEdge@@mvLeft							 ; move mvLeft into eax
+	shl eax,BitShift																 ; multiply by 2048
+	add eax,[esi].DirectTriEdge@@mDVLeft						 ; add in the delta
+	roundEAX                                         ; adjust and round the value
+	mov [esi].DirectTriEdge@@mvLeft,eax							 ; this is new mvLeft
+	mov eax,[esi].DirectTriEdge@@mvRight						 ; move mvRight into eax
+	shl eax,BitShift																 ; multiply by 2048
+	add eax,[esi].DirectTriEdge@@mDVRight						 ; add in the delta
+	roundEAX                                         ; adjust and round the value
+	mov [esi].DirectTriEdge@@mvRight,eax						 ; this is new mvRight
+	inc y							                               ; increment y
+;**********************
+;endif
+
+
+if 0
+initialize MACRO
+	mov eax,[esi].DirectTriEdge@@my2                 ; move my2 into eax
+	sub eax,[esi].DirectTriEdge@@my0								 ; eax has (y2-y0)
+	mov [esi].DirectTriEdge@@mDY,eax								 ; move (y2-y0) into mDY variable
+	mov eax,[esi].DirectTriEdge@@mx2                 ; move x2 into eax
+	sub eax,[esi].DirectTriEdge@@mx0  							 ; eax has (x2-x0)
+	shl eax,BitShift																			 ; multiply result by 2048 for precision
+	divide eax,[esi].DirectTriEdge@@mDY              ; eax has (x2-x0)/(y2-y0) 
+	mov [esi].DirectTriEdge@@mDXLeft,eax						 ; this is mDXLeft
+	mov eax,[esi].DirectTriEdge@@mx1                 ; move x1 into eax
+	sub eax,[esi].DirectTriEdge@@mx0	  						 ; eax has (x1-x0)
+	shl eax,BitShift																			 ; multiply result by 2048 for precision
+	divide eax,[esi].DirectTriEdge@@mDY							 ; eax has (x1-x0)/(y2-y0)
+	mov [esi].DirectTriEdge@@mDXRight,eax						 ; this is mDXRight
+  mov eax,[esi].DirectTriEdge@@mu2                 ; move u2 into eax
+	sub eax,[esi].DirectTriEdge@@mu0								 ; eax has (u2-u0)
+	shl eax,BitShift																			 ; multiply result by 2048 for precision
+	divide eax,[esi].DirectTriEdge@@mDY              ; eax has (u2-u0)/(y2-y0)
+	mov [esi].DirectTriEdge@@mDULeft,eax             ; this is mDULeft
+	mov eax,[esi].DirectTriEdge@@mu1                 ; move u1 into eax
+	sub eax,[esi].DirectTriEdge@@mu0                 ; eax has (u1-u0)
+	shl eax,BitShift																			 ; multiply result by 2048 for precision
+	divide eax,[esi].DirectTriEdge@@mDY              ; eax has (u1-u0)/(y2-y0)
+	mov [esi].DirectTriEdge@@mDURight,eax            ; this is mDURight
+	mov eax,[esi].DirectTriEdge@@mv2                 ; move v2 into eax
+	sub eax,[esi].DirectTriEdge@@mv0                 ; eax has (v2-v0)
+	shl eax,BitShift                                      ; multiply result by 2048 for precision
+	divide eax,[esi].DirectTriEdge@@mDY              ; eax has (v2-v0)/(y2-y0)
+	mov [esi].DirectTriEdge@@mDVLeft,eax             ; this is mDVLeft
+  mov eax,[esi].DirectTriEdge@@mv1                 ; move v1 into eax
+	sub eax,[esi].DirectTriEdge@@mv0                 ; eax has (v1-v0)
+	shl eax,BitShift                                      ; multiply result by 2048 for precision
+	divide eax,[esi].DirectTriEdge@@mDY              ; eax has (v1-v0)/(y2-y0)
+	mov [esi].DirectTriEdge@@mDVRight,eax            ; this is mDVRight
+	mov eax,[esi].DirectTriEdge@@mx0                 ; move x0 into eax
+	mov [esi].DirectTriEdge@@mxLeft,eax              ; mxLeft=x0
+	mov [esi].DirectTriEdge@@mxRight,eax             ; mxRight=x0
+	mov eax,[esi].DirectTriEdge@@mu0                 ; move u0 into eax
+	mov [esi].DirectTriEdge@@muLeft,eax              ; muLeft=u0
+	mov [esi].DirectTriEdge@@muRight,eax             ; muRight=u0
+	mov eax,[esi].DirectTriEdge@@mv0                 ; move v0 into eax
+	mov [esi].DirectTriEdge@@mvLeft,eax              ; mvLeft=v0
+	mov [esi].DirectTriEdge@@mvRight,eax             ; mvRight=v0
+ENDM
+endif
+
+
+
+
+
+;	cmp eax,[esi].DirectTriEdge@@mx2                 ; is mxLeft less than x2
+;	jge @@noChangeDir                                ; if not then continue
+;	shl eax,BitShift                                 ; adjust mxLeft for precision
+	sub eax,[esi].DirectTriEdge@@mDXLeft             ; subtract out mDXLeft, this is adjusted mxLeft
+	mov [esi].DirectTriEdge@@mxLeft,eax              ; save adjusted mxLeft
+	mov ebx,[esi].DirectTriEdge@@my1                 ; move y1 into ebx register
+	sub ebx,y                        								 ; subtract (y1-y)
+	mov ecx,[esi].DirectTriEdge@@mx1                 ; move x1 into ecx register
+	sub ecx,[esi].DirectTriEdge@@mx2                 ; subtract (x1-x2)
+	shl ecx,BitShift                                 ; adjust eax for precision
+	divide ecx,ebx                                   ; eax has (x1-x2)/(y1-y), result to eax
+	mov [esi].DirectTriEdge@@mDXLeft,eax             ; this is new mDXLeft
+	mov ebx,[esi].DirectTriEdge@@mxLeft              ; move mxLeft into ebx register
+	add ebx,eax                                      ; ebx has mxLeft+mDXLeft
+	shr ebx,BitShift                                 ; adjust eax for precision
+	mov [esi].DirectTriEdge@@mxLeft,ebx              ; this is new mxLeft
+@@noChangeDir:

ddraw/SFCCAPS.HPP

@@ -0,0 +1,119 @@
+#ifndef _DDRAW_SURFACECAPABILITIES_HPP_
+#define _DDRAW_SURFACECAPABILITIES_HPP_
+#ifndef _DDRAW_DDRAW_HPP_
+#include <ddraw/ddraw.hpp>
+#endif
+
+class SurfaceCapabilities : private DDSCAPS2
+{
+public:
+  enum Capabilities{Alpha=DDSCAPS_ALPHA,BackBuffer=DDSCAPS_BACKBUFFER,Complex=DDSCAPS_COMPLEX,Flip=DDSCAPS_FLIP,
+	  FrontBuffer=DDSCAPS_FRONTBUFFER,OffScreenPlain=DDSCAPS_OFFSCREENPLAIN,Overlay=DDSCAPS_OVERLAY,
+		Palette=DDSCAPS_PALETTE,PrimarySurface=DDSCAPS_PRIMARYSURFACE,
+		PrimarySurfaceLeft=DDSCAPS_PRIMARYSURFACELEFT,SystemMemory=DDSCAPS_SYSTEMMEMORY,
+		Texture=DDSCAPS_TEXTURE,Device3D=DDSCAPS_3DDEVICE,VideoMemory=DDSCAPS_VIDEOMEMORY,
+		Visible=DDSCAPS_VISIBLE,WriteOnly=DDSCAPS_WRITEONLY,ZBuffer=DDSCAPS_ZBUFFER,
+		OwnDC=DDSCAPS_OWNDC,LiveVideo=DDSCAPS_LIVEVIDEO,HardwareCodec=DDSCAPS_HWCODEC,Modex=DDSCAPS_MODEX,
+		AllocOnLoad=DDSCAPS_ALLOCONLOAD,VideoPort=DDSCAPS_VIDEOPORT,LocalVidMem=DDSCAPS_LOCALVIDMEM,
+		StandardVGAMode=DDSCAPS_STANDARDVGAMODE,Optimized=DDSCAPS_OPTIMIZED};
+	enum AdditionalCapabilities{None=0,HardwareDeInterlace=DDSCAPS2_HARDWAREDEINTERLACE,
+	  HintAntialiasing=DDSCAPS2_HINTANTIALIASING,HintDynamic=DDSCAPS2_HINTDYNAMIC,
+		HintStatic=DDSCAPS2_HINTSTATIC,Opaque=DDSCAPS2_OPAQUE,TextureManager=DDSCAPS2_TEXTUREMANAGE};
+  SurfaceCapabilities(void);
+	SurfaceCapabilities(const SurfaceCapabilities &someSurfaceCapabilities);
+  SurfaceCapabilities(const DDSCAPS2 &someDDSCAPS2);
+	SurfaceCapabilities(Capabilities surfaceCapabilities,AdditionalCapabilities additionalCapabilities=None);
+	virtual ~SurfaceCapabilities();
+	SurfaceCapabilities &operator=(const SurfaceCapabilities &someSurfaceCapabilities);
+	SurfaceCapabilities &operator=(const DDSCAPS2 &someDDSCAPS2);
+  Capabilities surfaceCapabilities(void)const;
+	void surfaceCapabilities(Capabilities surfaceCapabilities);
+	AdditionalCapabilities additionalCapabilities(void)const;
+	void additionalCapabilities(AdditionalCapabilities additionalCapabilities);
+	DDSCAPS2 &getDDSCAPS2(void);
+private:
+};
+
+inline
+SurfaceCapabilities::SurfaceCapabilities(void)
+{
+  DDSCAPS2::dwCaps=0;
+	DDSCAPS2::dwCaps2=0;
+	DDSCAPS2::dwCaps3=0;
+	DDSCAPS2::dwCaps4=0;
+}
+
+inline
+SurfaceCapabilities::SurfaceCapabilities(const SurfaceCapabilities &someSurfaceCapabilities)
+{
+  *this=someSurfaceCapabilities;
+}
+
+inline
+SurfaceCapabilities::SurfaceCapabilities(Capabilities surfaceCapabilities,AdditionalCapabilities additionalCapabilities)
+{
+  DDSCAPS2::dwCaps=(DWORD)surfaceCapabilities;
+	DDSCAPS2::dwCaps2=(DWORD)additionalCapabilities;
+	DDSCAPS2::dwCaps3=0;
+	DDSCAPS2::dwCaps4=0;
+}
+
+inline
+SurfaceCapabilities::SurfaceCapabilities(const DDSCAPS2 &someDDSCAPS2)
+{
+  *this=someDDSCAPS2;
+}
+
+inline
+SurfaceCapabilities::~SurfaceCapabilities()
+{
+}
+
+inline
+SurfaceCapabilities &SurfaceCapabilities::operator=(const SurfaceCapabilities &someSurfaceCapabilities)
+{
+  surfaceCapabilities(someSurfaceCapabilities.surfaceCapabilities());
+	additionalCapabilities(someSurfaceCapabilities.additionalCapabilities());
+	return *this;
+}
+
+inline
+SurfaceCapabilities &SurfaceCapabilities::operator=(const DDSCAPS2 &someDDSCAPS2)
+{
+  DDSCAPS2::dwCaps=someDDSCAPS2.dwCaps;
+	DDSCAPS2::dwCaps2=someDDSCAPS2.dwCaps2;
+	DDSCAPS2::dwCaps3=someDDSCAPS2.dwCaps3;
+	DDSCAPS2::dwCaps4=someDDSCAPS2.dwCaps4;
+	return *this;
+}
+
+inline
+SurfaceCapabilities::Capabilities SurfaceCapabilities::surfaceCapabilities(void)const
+{
+  return Capabilities(DDSCAPS2::dwCaps);
+}
+
+inline
+void SurfaceCapabilities::surfaceCapabilities(Capabilities surfaceCapabilities)
+{
+  DDSCAPS2::dwCaps=(DWORD)surfaceCapabilities;
+}
+
+inline
+SurfaceCapabilities::AdditionalCapabilities SurfaceCapabilities::additionalCapabilities(void)const
+{
+  return AdditionalCapabilities(DDSCAPS2::dwCaps2);
+}
+
+inline
+void SurfaceCapabilities::additionalCapabilities(AdditionalCapabilities additionalCapabilities)
+{
+  DDSCAPS2::dwCaps2=(DWORD)additionalCapabilities;
+}
+
+inline
+DDSCAPS2 &SurfaceCapabilities::getDDSCAPS2(void)
+{
+  return (DDSCAPS2&)*this;
+}
+#endif

ddraw/SFCDESC.HPP

@@ -0,0 +1,318 @@
+#ifndef _DDRAW_SURFACEDESCRIPTION_HPP_
+#define _DDRAW_SURFACEDESCRIPTION_HPP_
+#ifndef _DDRAW_DDRAW_HPP_
+#include <ddraw/ddraw.hpp>
+#endif
+#ifndef _DDRAW_SURFACECAPABILITIES_HPP_
+#include <ddraw/sfccaps.hpp>
+#endif
+
+class SurfaceDescription : private DDSURFACEDESC2
+{
+public:
+enum SurfaceFlags{Capabilities=DDSD_CAPS,Height=DDSD_HEIGHT,Width=DDSD_WIDTH,Pitch=DDSD_PITCH,
+      BackBufferCount=DDSD_BACKBUFFERCOUNT,ZBufferBitDepth=DDSD_ZBUFFERBITDEPTH,
+			AlphaBitDepth=DDSD_ALPHABITDEPTH,Surface=DDSD_LPSURFACE,PixelFormat=DDSD_PIXELFORMAT,
+			CKDestinationOverlay=DDSD_CKDESTOVERLAY,CKSourceOverlay=DDSD_CKSRCOVERLAY,
+			CKSourceBlt=DDSD_CKSRCBLT,MipMapCount=DDSD_MIPMAPCOUNT,RefreshRate=DDSD_REFRESHRATE,
+			LinearSize=DDSD_LINEARSIZE,TextureStage=DDSD_TEXTURESTAGE,All=DDSD_ALL};
+  SurfaceDescription(void);
+	SurfaceDescription(const SurfaceDescription &someSurfaceDescription);
+  SurfaceDescription(const DDSURFACEDESC2 &someDDSURFACEDESC2);
+	virtual ~SurfaceDescription();
+	SurfaceDescription &operator=(const SurfaceDescription &someSurfaceDescription);
+	SurfaceDescription &operator=(const DDSURFACEDESC2 &someDDSURFDESC2);
+	DWORD flags(void)const;
+	void flags(DWORD flags);
+	DWORD height(void)const;
+	void height(DWORD height);
+	DWORD width(void)const;
+	void width(DWORD width);
+	LONG lPitch(void)const;
+	void lPitch(LONG lPitch);
+	DWORD linearSize(void)const;
+	void linearSize(DWORD linearSize);
+	DWORD backBufferCount(void)const;
+	void backBufferCount(DWORD backBufferCount);
+	DWORD mipMapCount(void)const;
+	void mipMapCount(DWORD mipMapCount);
+	DWORD refreshRate(void)const;
+	void refreshRate(DWORD refreshRate);
+	DWORD alphaBitDepth(void)const;
+	void alphaBitDepth(DWORD alphaBitDepth);
+	LPVOID ptrSurface(void);
+	void ptrSurface(LPVOID pSurface);
+	const DDCOLORKEY &ckDestOverlay(void)const;
+	void ckDestOverlay(const DDCOLORKEY &ckDestOverlay);
+	const DDCOLORKEY &ckDestBlt(void)const;
+	void ckDestBlt(const DDCOLORKEY &ckDestBlt);
+	const DDCOLORKEY &ckSrcOverlay(void)const;
+	void ckSrcOverlay(const DDCOLORKEY &ckSrcOverlay);
+	const DDCOLORKEY &ckSrcBlt(void)const;
+	void ckSrcBlt(const DDCOLORKEY &ckSrcBlt);
+	const DDPIXELFORMAT &pixelFormat(void)const;
+	void pixelFormat(const DDPIXELFORMAT &pixelFormat);
+	SurfaceCapabilities surfaceCapabilities(void)const;
+	void surfaceCapabilities(const SurfaceCapabilities &surfaceCapabilities);
+  DWORD textureStage(void)const;
+	void textureStage(DWORD textureStage);
+	DDSURFACEDESC2 &getDDSURFACEDESC2(void);
+private:
+  void zeroInit(void);
+};
+
+inline
+SurfaceDescription::SurfaceDescription(void)
+{
+  zeroInit();
+}
+
+inline
+SurfaceDescription::SurfaceDescription(const SurfaceDescription &someSurfaceDescription)
+{
+  *this=someSurfaceDescription;
+}
+
+inline
+SurfaceDescription::SurfaceDescription(const DDSURFACEDESC2 &someDDSURFACEDESC2)
+{
+  *this=someDDSURFACEDESC2;
+}
+
+inline
+SurfaceDescription::~SurfaceDescription()
+{
+}
+
+inline
+SurfaceDescription &SurfaceDescription::operator=(const SurfaceDescription &someSurfaceDescription)
+{
+  ::memcpy(&getDDSURFACEDESC2(),&((SurfaceDescription&)someSurfaceDescription).getDDSURFACEDESC2(),sizeof(DDSURFACEDESC2));
+	return *this;
+}
+
+inline
+SurfaceDescription &SurfaceDescription::operator=(const DDSURFACEDESC2 &someDDSURFACEDESC2)
+{
+  ::memcpy(&getDDSURFACEDESC2(),&someDDSURFACEDESC2,sizeof(DDSURFACEDESC2));
+	DDSURFACEDESC2::dwSize=sizeof(DDSURFACEDESC2);
+	return *this;
+}
+
+inline
+DWORD SurfaceDescription::flags(void)const
+{
+  return DDSURFACEDESC2::dwFlags;
+}
+
+inline
+void SurfaceDescription::flags(DWORD flags)
+{
+  DDSURFACEDESC2::dwFlags=flags;
+}
+
+inline
+DWORD SurfaceDescription::height(void)const
+{
+  return DDSURFACEDESC2::dwHeight;
+}
+
+inline
+void SurfaceDescription::height(DWORD height)
+{
+  DDSURFACEDESC2::dwHeight=height;
+}
+
+inline
+DWORD SurfaceDescription::width(void)const
+{
+  return DDSURFACEDESC2::dwWidth;
+}
+
+inline
+void SurfaceDescription::width(DWORD width)
+{
+  DDSURFACEDESC2::dwWidth=width;
+}
+
+inline
+LONG SurfaceDescription::lPitch(void)const
+{
+  return DDSURFACEDESC2::lPitch;
+}
+
+inline
+void SurfaceDescription::lPitch(LONG lPitch)
+{
+  DDSURFACEDESC2::lPitch=lPitch;
+}
+
+inline
+DWORD SurfaceDescription::linearSize(void)const
+{
+  return DDSURFACEDESC2::dwLinearSize;
+}
+
+inline
+void SurfaceDescription::linearSize(DWORD linearSize)
+{
+  DDSURFACEDESC2::dwLinearSize=linearSize;
+}
+
+inline
+DWORD SurfaceDescription::backBufferCount(void)const
+{
+  return DDSURFACEDESC2::dwBackBufferCount;
+}
+
+inline
+void SurfaceDescription::backBufferCount(DWORD backBufferCount)
+{
+  DDSURFACEDESC2::dwBackBufferCount=backBufferCount;
+}
+
+inline
+DWORD SurfaceDescription::mipMapCount(void)const
+{
+  return DDSURFACEDESC2::dwMipMapCount;
+}
+
+inline
+void SurfaceDescription::mipMapCount(DWORD mipMapCount)
+{
+  DDSURFACEDESC2::dwMipMapCount=mipMapCount;
+}
+
+inline
+DWORD SurfaceDescription::refreshRate(void)const
+{
+  return DDSURFACEDESC2::dwRefreshRate;
+}
+
+inline
+void SurfaceDescription::refreshRate(DWORD refreshRate)
+{
+  DDSURFACEDESC2::dwRefreshRate=refreshRate;
+}
+
+inline
+DWORD SurfaceDescription::alphaBitDepth(void)const
+{
+  return DDSURFACEDESC2::dwAlphaBitDepth;
+}
+
+inline
+void SurfaceDescription::alphaBitDepth(DWORD alphaBitDepth)
+{
+  DDSURFACEDESC2::dwAlphaBitDepth=alphaBitDepth;
+}
+
+inline
+LPVOID SurfaceDescription::ptrSurface(void)
+{
+  return DDSURFACEDESC2::lpSurface;
+}
+
+inline
+void SurfaceDescription::ptrSurface(LPVOID pSurface)
+{
+  DDSURFACEDESC2::lpSurface=pSurface;
+}
+
+inline
+const DDCOLORKEY &SurfaceDescription::ckDestOverlay(void)const
+{
+  return DDSURFACEDESC2::ddckCKDestOverlay;
+}
+
+inline
+void SurfaceDescription::ckDestOverlay(const DDCOLORKEY &ckDestOverlay)
+{
+  DDSURFACEDESC2::ddckCKDestOverlay=ckDestOverlay;
+}
+
+inline
+const DDCOLORKEY &SurfaceDescription::ckDestBlt(void)const
+{
+  return DDSURFACEDESC2::ddckCKDestBlt;
+}
+
+inline
+void SurfaceDescription::ckDestBlt(const DDCOLORKEY &ckDestBlt)
+{
+  DDSURFACEDESC2::ddckCKDestBlt=ckDestBlt;
+}
+
+inline
+const DDCOLORKEY &SurfaceDescription::ckSrcOverlay(void)const
+{
+  return DDSURFACEDESC2::ddckCKSrcOverlay;
+}
+
+inline
+void SurfaceDescription::ckSrcOverlay(const DDCOLORKEY &ckSrcOverlay)
+{
+  DDSURFACEDESC2::ddckCKSrcOverlay=ckSrcOverlay;
+}
+
+inline
+const DDCOLORKEY &SurfaceDescription::ckSrcBlt(void)const
+{
+  return DDSURFACEDESC2::ddckCKSrcBlt;
+}
+
+inline
+void SurfaceDescription::ckSrcBlt(const DDCOLORKEY &ckSrcBlt)
+{
+  DDSURFACEDESC2::ddckCKSrcBlt=ckSrcBlt;
+}
+
+inline
+const DDPIXELFORMAT &SurfaceDescription::pixelFormat(void)const
+{
+  return DDSURFACEDESC2::ddpfPixelFormat;
+}
+
+inline
+void SurfaceDescription::pixelFormat(const DDPIXELFORMAT &pixelFormat)
+{
+  DDSURFACEDESC2::ddpfPixelFormat=pixelFormat;
+}
+
+inline
+SurfaceCapabilities SurfaceDescription::surfaceCapabilities(void)const
+{
+  return SurfaceCapabilities(DDSURFACEDESC2::ddsCaps);
+}
+
+inline
+void SurfaceDescription::surfaceCapabilities(const SurfaceCapabilities &surfaceCapabilities)
+{
+  DDSURFACEDESC2::ddsCaps=((SurfaceCapabilities&)surfaceCapabilities).getDDSCAPS2();
+}
+
+inline
+DWORD SurfaceDescription::textureStage(void)const
+{
+  return DDSURFACEDESC2::dwTextureStage;
+}
+
+inline
+void SurfaceDescription::textureStage(DWORD textureStage)
+{
+  DDSURFACEDESC2::dwTextureStage;
+}
+
+inline
+DDSURFACEDESC2 &SurfaceDescription::getDDSURFACEDESC2(void)
+{
+  return (DDSURFACEDESC2&)*this;
+}
+
+inline
+void SurfaceDescription::zeroInit(void)
+{
+  ::memset(&getDDSURFACEDESC2(),0,sizeof(DDSURFACEDESC2));
+  DDSURFACEDESC2::dwSize=sizeof(DDSURFACEDESC2);
+}
+#endif

ddraw/SURFACE.HPP

@@ -0,0 +1,222 @@
+#ifndef _DDRAW_SURFACE_HPP_
+#define _DDRAW_SURFACE_HPP_
+#ifndef _COMMON_SMARTPOINTER_HPP_
+#include <common/pointer.hpp>
+#endif
+#ifndef _COMMON_GDIPOINT_HPP_
+#include <common/gdipoint.hpp>
+#endif
+#ifndef _COMMON_RECTANGLE_HPP_
+#include <common/rect.hpp>
+#endif
+#ifndef _DDRAW_DDRAW_HPP_
+#include <ddraw/ddraw.hpp>
+#endif
+#ifndef _DDRAW_PIXELFORMAT_HPP_
+#include <ddraw/pixform.hpp>
+#endif
+#ifndef _DDRAW_BLITEFFECTS_HPP_
+#include <ddraw/bltfx.hpp>
+#endif
+#ifndef _DDRAW_SURFACEDESCRIPTION_HPP_
+#include <ddraw/sfcdesc.hpp>
+#endif
+#ifndef _DDRAW_DIRECTPALETTE_HPP_
+#include <ddraw/palette.hpp>
+#endif
+#ifndef _DDRAW_DIRECTDRAWERROR_HPP_
+#include <ddraw/error.hpp>
+#endif
+
+class Surface : private SmartPointer<IDirectDrawSurface4>
+{
+public:
+  enum Disposition{Release,Assume};
+  enum BltFastFlags{BltFastDstColorKey=DDBLTFAST_DESTCOLORKEY,BltFastNoColorKey=DDBLTFAST_NOCOLORKEY,
+	  BltFastSrcColorKey=DDBLTFAST_SRCCOLORKEY,BltFastWait=DDBLTFAST_WAIT};
+	enum BltFlags{BltColorFill=DDBLT_COLORFILL,BltEffects=DDBLT_DDFX,BltRaster=DDBLT_DDROPS,
+	  BltDepthFill=DDBLT_DEPTHFILL,BltKeyDstOverride=DDBLT_KEYDESTOVERRIDE,
+		BltKeySrcOverride=DDBLT_KEYSRCOVERRIDE,BltUseWin32Raster=DDBLT_ROP,BltRotationAngle=DDBLT_ROTATIONANGLE,
+		BltKeyDst=DDBLT_KEYDEST,BltKeySrc=DDBLT_KEYSRC,BltAsync=DDBLT_ASYNC,BltWait=DDBLT_WAIT};
+	enum LockFlags{LockNoSysLock=DDLOCK_NOSYSLOCK,LockReadOnly=DDLOCK_READONLY,
+	  LockSurfaceMemPtr=DDLOCK_SURFACEMEMORYPTR,LockWait=DDLOCK_WAIT,LockWriteOnly=DDLOCK_WRITEONLY};
+  friend class DirectDraw;
+  Surface(void);
+	virtual ~Surface();
+	DirectDrawError getPixelFormat(PixelFormat &pixelFormat);
+	DirectDrawError bltFast(const GDIPoint &xyDstPoint,Surface &srcSurface,const Rect &srcRect,BltFastFlags bltFlags=BltFastWait);
+	DirectDrawError bltFast(const GDIPoint &xyDstPoint,Surface &srcSurface,BltFastFlags bltFlags=BltFastWait);
+	DirectDrawError bltFast(Surface &srcSurface,BltFastFlags bltFlags=BltFastWait);
+  DirectDrawError blt(const Rect &dstRect,Surface &srcSurface,const Rect &srcRect,BltFlags bltFlags=BltWait);
+  DirectDrawError blt(const Rect &dstRect,Surface &srcSurface,const Rect &srcRect,::BltEffects &bltEffects,BltFlags bltFlags=BltWait);
+  DirectDrawError blt(Surface &srcSurface,::BltEffects &bltEffects,BltFlags bltFlags=BltWait);
+  DirectDrawError blt(::BltEffects &bltEffects,BltFlags bltFlags=BltWait);
+  DirectDrawError setPalette(DirectPalette &directPalette);
+	DirectDrawError getDC(HDC &hDC);
+	DirectDrawError releaseDC(HDC hDC);
+  DirectDrawError lock(SurfaceDescription &surfaceDescription,LockFlags lockFlags=LockFlags((int)LockNoSysLock|(int)LockWriteOnly|(int)LockSurfaceMemPtr|(int)LockWait));
+	DirectDrawError unlock(void);
+  DirectDrawError getAttachedSurface(const SurfaceCapabilities &surfaceCapabilities,Surface &surface);
+	DirectDrawError flip(void);
+	void destroy(void);
+	BOOL isOkay(void)const;
+private:
+  Surface(const Surface &someSurface);
+	Surface &operator=(const Surface &someSurface);
+	Disposition mDisposition;
+};
+
+inline
+Surface::Surface(void)
+: mDisposition(Release)
+{
+}
+
+inline
+Surface::Surface(const Surface &someSurface)
+{ // private implementation
+  *this=someSurface;
+}
+
+inline
+Surface::~Surface()
+{
+  destroy();
+}
+
+inline
+Surface &Surface::operator=(const Surface &/*someSurface*/)
+{ // private implementation
+  return *this;
+}
+
+inline
+DirectDrawError Surface::getPixelFormat(PixelFormat &pixelFormat)
+{
+  if(!isOkay())return DirectDrawError::GenericFailure;
+	return DirectDrawError::DirectDrawResult(operator->()->GetPixelFormat(&pixelFormat.getDDPIXELFORMAT()));
+}
+
+inline
+DirectDrawError Surface::bltFast(const GDIPoint &xyDstPoint,Surface &srcSurface,const Rect &srcRect,BltFastFlags bltFlags)
+{
+  if(!isOkay()||!srcSurface.isOkay())return DirectDrawError::GenericFailure;
+	return DirectDrawError::DirectDrawResult(operator->()->BltFast(xyDstPoint.x(),xyDstPoint.y(),(IDirectDrawSurface4*)((SmartPointer<IDirectDrawSurface4>&)*this),(RECT*)(Rect&)srcRect,(DWORD)bltFlags));
+}
+
+inline
+DirectDrawError Surface::bltFast(const GDIPoint &xyDstPoint,Surface &srcSurface,BltFastFlags bltFlags)
+{
+  if(!isOkay()||!srcSurface.isOkay())return DirectDrawError::GenericFailure;
+	return DirectDrawError::DirectDrawResult(operator->()->BltFast(xyDstPoint.x(),xyDstPoint.y(),(IDirectDrawSurface4*)((SmartPointer<IDirectDrawSurface4>&)*srcSurface),0,(DWORD)bltFlags));
+}
+
+inline
+DirectDrawError Surface::bltFast(Surface &srcSurface,BltFastFlags bltFlags)
+{
+  if(!isOkay()||!srcSurface.isOkay())return DirectDrawError::GenericFailure;
+	return DirectDrawError::DirectDrawResult(operator->()->BltFast(0,0,(IDirectDrawSurface4*)((SmartPointer<IDirectDrawSurface4>&)srcSurface),0,(DWORD)bltFlags));
+}
+
+inline
+DirectDrawError Surface::blt(const Rect &dstRect,Surface &srcSurface,const Rect &srcRect,BltFlags bltFlags)
+{
+  if(!isOkay()||!srcSurface.isOkay())return DirectDrawError::GenericFailure;
+  return DirectDrawError::DirectDrawResult(operator->()->Blt((RECT*)(Rect&)dstRect,(IDirectDrawSurface4*)((SmartPointer<IDirectDrawSurface4>&)srcSurface),(RECT*)(Rect&)srcRect,(DWORD)bltFlags,0));
+}
+
+inline
+DirectDrawError Surface::blt(const Rect &dstRect,Surface &srcSurface,const Rect &srcRect,::BltEffects &bltEffects,BltFlags bltFlags)
+{
+  if(!isOkay()||!srcSurface.isOkay())return DirectDrawError::GenericFailure;
+  return DirectDrawError::DirectDrawResult(operator->()->Blt((RECT*)(Rect&)dstRect,(IDirectDrawSurface4*)((SmartPointer<IDirectDrawSurface4>&)srcSurface),(RECT*)(Rect&)srcRect,(DWORD)bltFlags|(DWORD)BltEffects,&bltEffects.getDDBLTFX()));
+}
+
+inline
+DirectDrawError Surface::blt(Surface &srcSurface,::BltEffects &bltEffects,BltFlags bltFlags)
+{
+  if(!isOkay()||!srcSurface.isOkay())return DirectDrawError::GenericFailure;
+  return DirectDrawError::DirectDrawResult(operator->()->Blt(0,(IDirectDrawSurface4*)((SmartPointer<IDirectDrawSurface4>&)srcSurface),0,(DWORD)bltFlags,&bltEffects.getDDBLTFX()));
+}
+
+inline
+DirectDrawError Surface::blt(::BltEffects &bltEffects,BltFlags bltFlags)
+{
+  if(!isOkay())return DirectDrawError::GenericFailure;
+  return DirectDrawError::DirectDrawResult(operator->()->Blt(0,0,0,(DWORD)bltFlags|BltEffects,&bltEffects.getDDBLTFX()));
+}
+
+inline
+DirectDrawError Surface::setPalette(DirectPalette &directPalette)
+{
+  DirectDrawError status(DirectDrawError::GenericFailure);
+
+  if(!isOkay()||!directPalette.isOkay())return status;
+	status=DirectDrawError::DirectDrawResult(operator->()->SetPalette((IDirectDrawPalette*)directPalette));
+  return status;
+}
+
+inline
+DirectDrawError Surface::getDC(HDC &hDC)
+{
+  if(!isOkay())return DirectDrawError::GenericFailure;
+	return DirectDrawError::DirectDrawResult(operator->()->GetDC(&hDC));
+}
+
+inline
+DirectDrawError Surface::releaseDC(HDC hDC)
+{
+  if(!isOkay())return DirectDrawError::GenericFailure;
+	return DirectDrawError::DirectDrawResult(operator->()->ReleaseDC(hDC));
+}
+
+inline
+DirectDrawError Surface::lock(SurfaceDescription &surfaceDescription,LockFlags lockFlags)
+{
+  if(!isOkay())return DirectDrawError::GenericFailure;
+	return DirectDrawError::DirectDrawResult(operator->()->Lock(0,&surfaceDescription.getDDSURFACEDESC2(),lockFlags,0));
+}
+
+inline
+DirectDrawError Surface::unlock(void)
+{
+  if(!isOkay())return DirectDrawError::GenericFailure;
+	return DirectDrawError::DirectDrawResult(operator->()->Unlock(0));
+}
+
+inline
+DirectDrawError Surface::getAttachedSurface(const SurfaceCapabilities &surfaceCapabilities,Surface &surface)
+{
+  DirectDrawError status(DirectDrawError::GenericFailure);
+  LPDIRECTDRAWSURFACE4 lpDirectDrawSurface;
+
+  if(!isOkay())return status;
+	surface.destroy();
+	status=DirectDrawError::DirectDrawResult(operator->()->GetAttachedSurface(&((SurfaceCapabilities&)surfaceCapabilities).getDDSCAPS2(),&lpDirectDrawSurface));
+	if(!status.okResult())return status;
+  (SmartPointer<IDirectDrawSurface4>&)surface=lpDirectDrawSurface;
+	surface.mDisposition=Surface::Assume;
+	return status;
+}
+
+inline
+DirectDrawError Surface::flip(void)
+{
+  if(!isOkay())return DirectDrawError::GenericFailure;
+	return DirectDrawError::DirectDrawResult(operator->()->Flip(0,DDFLIP_WAIT));
+}
+
+inline
+void Surface::destroy(void)
+{
+  if(!isOkay())return;
+  if(Release==mDisposition)operator->()->Release();
+	SmartPointer<IDirectDrawSurface4>::destroy();
+}
+
+inline
+BOOL Surface::isOkay(void)const
+{
+  return SmartPointer<IDirectDrawSurface4>::isOkay();
+}
+#endif

ddraw/TEXTURE.CPP

@@ -0,0 +1,80 @@
+#include <ddraw/texture.hpp>
+#include <ddraw/drawsfc.hpp>
+#include <common/bitmap.hpp>
+#include <engine/point3d.hpp>
+#include <engine/angle3d.hpp>
+#include <engine/angle.hpp>
+
+DirectTexture::DirectTexture(const Vector3D &dstPoints,Bitmap &textureBitmap,DrawingSurface &drawingSurface,Device3D &displayDevice)
+: mEdgeMap(&mLeftEdge,&mRightEdge)
+{
+	mDstPoints3D=dstPoints;
+  displayDevice.translatePoint(mDstPoints3D,mDstPoints2D);
+	mLeftEdge.numVertexes(Vector3D::VectorPoints);
+	mRightEdge.numVertexes(Vector3D::VectorPoints);
+	mTexturePoints[0]=Point(0,0);
+	mTexturePoints[1]=Point(textureBitmap.width()-1,0);
+	mTexturePoints[2]=Point(textureBitmap.width()-1,textureBitmap.height()-1);
+	mTexturePoints[3]=Point(0,textureBitmap.height()-1);
+	mLeftEdge.setSrcPoints((Point*)&mTexturePoints);
+	mLeftEdge.setDstPoints((Point*)&mDstPoints2D);
+	mRightEdge.setSrcPoints((Point*)&mTexturePoints);
+	mRightEdge.setDstPoints((Point*)&mDstPoints2D);
+	::directSetSrcBitmapInfo(textureBitmap.width(),textureBitmap.height(),textureBitmap.getDataPtr());
+  ::directSetDstBitmapInfo(drawingSurface.width(),drawingSurface.height(),drawingSurface.pitch(),(unsigned char*)drawingSurface.ptrSurface());
+}
+
+DirectTexture::DirectTexture(const Vector2D &dstPoints,Bitmap &textureBitmap,DrawingSurface &drawingSurface)
+: mEdgeMap(&mLeftEdge,&mRightEdge)
+{
+  mDstPoints2D=dstPoints;
+	mLeftEdge.numVertexes(Vector3D::VectorPoints);
+	mRightEdge.numVertexes(Vector3D::VectorPoints);
+	mTexturePoints[0]=Point(0,0);
+	mTexturePoints[1]=Point(textureBitmap.width()-1,0);
+	mTexturePoints[2]=Point(textureBitmap.width()-1,textureBitmap.height()-1);
+	mTexturePoints[3]=Point(0,textureBitmap.height()-1);
+	mLeftEdge.setSrcPoints((Point*)&mTexturePoints);
+	mLeftEdge.setDstPoints((Point*)&mDstPoints2D);
+	mRightEdge.setSrcPoints((Point*)&mTexturePoints);
+	mRightEdge.setDstPoints((Point*)&mDstPoints2D);
+	::directSetSrcBitmapInfo(textureBitmap.width(),textureBitmap.height(),textureBitmap.getDataPtr());
+	::directSetDstBitmapInfo(drawingSurface.width(),drawingSurface.height(),drawingSurface.pitch(),(unsigned char*)drawingSurface.ptrSurface());
+}
+
+DirectTexture::DirectTexture(const Triangle3D &angle3D,Bitmap &textureBitmap,DrawingSurface &drawingSurface,Device3D &displayDevice,TriMap triMap)
+: mEdgeMap(&mLeftEdge,&mRightEdge)
+{
+	Triangle angle2D;
+
+  displayDevice.mapCoordinates((Triangle3D&)angle3D,angle2D);
+	mDstPoints2D[0]=angle2D[0];
+	mDstPoints2D[1]=angle2D[1];
+	mDstPoints2D[2]=angle2D[2];
+	mLeftEdge.numVertexes(Triangle::VectorPoints);
+	mRightEdge.numVertexes(Triangle::VectorPoints);
+	switch(triMap)
+	{
+	  case MapCenter :
+	    mTexturePoints[0]=Point(0,textureBitmap.height()-1);
+	    mTexturePoints[1]=Point(textureBitmap.width()/2,0);
+	    mTexturePoints[2]=Point(textureBitmap.width()-1,textureBitmap.height()-1);
+			break;
+		case MapUpperRight :
+	    mTexturePoints[0]=Point(0,0);
+	    mTexturePoints[1]=Point(textureBitmap.width()-1,0);
+	    mTexturePoints[2]=Point(textureBitmap.width()-1,textureBitmap.height()-1);
+			break;
+		case MapLowerLeft :
+	    mTexturePoints[0]=Point(0,0);
+			mTexturePoints[1]=Point(textureBitmap.width()-1,textureBitmap.height()-1);
+	    mTexturePoints[2]=Point(0,textureBitmap.height()-1);
+		  break;
+	}
+	mLeftEdge.setSrcPoints((Point*)&mTexturePoints);
+	mLeftEdge.setDstPoints((Point*)&mDstPoints2D);
+	mRightEdge.setSrcPoints((Point*)&mTexturePoints);
+	mRightEdge.setDstPoints((Point*)&mDstPoints2D);
+	::directSetSrcBitmapInfo(textureBitmap.width(),textureBitmap.height(),textureBitmap.getDataPtr());
+	::directSetDstBitmapInfo(drawingSurface.width(),drawingSurface.height(),drawingSurface.pitch(),(unsigned char*)drawingSurface.ptrSurface());
+}

ddraw/TEXTURE.HPP

@@ -0,0 +1,71 @@
+#ifndef _DDRAW_TEXTURE_HPP_
+#define _DDRAW_TEXTURE_HPP_
+#ifndef _COMMON_VECTOR2D_HPP_
+#include <common/vector2d.hpp>
+#endif
+#ifndef _ENGINE_VECTOR3D_HPP_
+#include <engine/vector3d.hpp>
+#endif
+#ifndef _ENGINE_DEVICE3D_HPP_
+#include <engine/device3d.hpp>
+#endif
+#ifndef _ENGINE_PUREEDGE_HPP_
+#include <engine/pureedge.hpp>
+#endif
+#ifndef _ENGINE_PUREMAP_HPP_
+#include <engine/puremap.hpp>
+#endif
+
+class Bitmap;
+class DrawingSurface;
+class Triangle3D;
+
+extern "C"
+{
+	void directMapTexture(PureMap *lpEdgeMap);
+	void directInitEdge(int edgeType,PureEdge *lpPureEdge);
+	void directSetSrcBitmapInfo(WORD width,WORD height,UHUGE *lpSrcBitmapImage);
+	void directSetDstBitmapInfo(WORD width,WORD height,WORD pitch,UHUGE *lpDstBitmapImage);
+  void directSetMaskInfo(WORD useMask,BYTE maskValue);
+}
+
+class DirectTexture
+{
+public:
+  enum TriMap{MapCenter,MapLowerLeft,MapUpperRight};
+  typedef void (DirectTexture::*PMFI)(long pixelPoint,long imagePoint);
+	DirectTexture(const Vector3D &dstPoints,Bitmap &textureBitmap,DrawingSurface &drawingSurface,Device3D &displayDevice);
+  DirectTexture(const Vector2D &dstPoints,Bitmap &textureBitmap,DrawingSurface &drawingSurface);
+  DirectTexture(const Triangle3D &angle3D,Bitmap &textureBitmap,DrawingSurface &drawingSurface,Device3D &displayDevice,TriMap triMap=MapCenter);
+	virtual ~DirectTexture();
+	void mapTexture(void);
+private:
+  enum EdgeType{LeftEdge=-1,RightEdge=1};
+	DirectTexture &operator=(const DirectTexture &someTexture);
+	PureEdge mLeftEdge;
+	PureEdge mRightEdge;
+	PureMap mEdgeMap;
+	Vector2D mTexturePoints;
+	Vector2D mDstPoints2D;
+	Vector3D mDstPoints3D;
+};
+
+inline
+DirectTexture &DirectTexture::operator=(const DirectTexture &/*someTexture*/)
+{ // undefined
+	return *this;
+}
+
+inline
+DirectTexture::~DirectTexture()
+{
+}
+
+inline
+void DirectTexture::mapTexture(void)
+{
+	::directInitEdge(LeftEdge,&mLeftEdge);
+	::directInitEdge(RightEdge,&mRightEdge);
+	::directMapTexture(&mEdgeMap);
+}
+#endif

ddraw/TMAP32.ASM

@@ -0,0 +1,493 @@
+;********************************************************************************************************
+; MODULE: TMAP32.ASM                                           DATE: DECEMBER 28, 1994
+; AUTHOR: SEAN M. KESSLER                                            JUNE 06, 1995
+; TARGET: 32 BIT TARGET																							 JANUARY 29, 1999 (DIRECT DRAW VERSION)
+; FUNCTION : TEXTURE MAPPING POLYGONS IN PERSPECTIVE
+;********************************************************************************************************
+SMART
+.386
+.MODEL FLAT
+.DATA
+.LALL
+INCLUDE ..\COMMON\COMMON.INC
+INCLUDE ..\DDRAW\TMAP32.INC
+INCLUDE ..\DDRAW\UTIL32.INC
+bmData@@mSrcWidth      DW 00h
+bmData@@mSrcHeight     DW 00h
+bmData@@mSrcExtent     DD 00h
+bmData@@mlpSrcPtr      DD 00h
+bmData@@mDstWidth      DW 00h
+bmData@@mDstPitch      DW 00h
+bmData@@mDstHeight     DW 00h
+bmData@@mDstExtent     DD 00h
+bmData@@mlpDstPtr      DD 00h
+bmData@@mlpDstIndexPtr DD 00h
+bmData@@mPrecision     DW 4000h
+bmData@@mMaskValue     DB 0FFh
+bmData@@mUseMask       DB 00h
+
+MINVALUE  EQU -32767
+MAXVALUE  EQU  32767
+MINVERTEX EQU      3
+.CODE
+LOCALS
+roundEBX MACRO varOne
+LOCAL @@return
+	mov  edx,varOne                 ; move value into edx register
+	mov  ebx,varOne                 ; move value into ebx register
+	and  edx,00003FFFh              ; get remainder into edx register
+	shr  ebx,14                     ; get whole number to ebx register
+	cmp  edx,8192                   ; if remainder > 8192, increment ebx
+	jle  @@return                   ; otherwise return
+	inc  ebx                        ; increment value in ebx
+@@return:
+ENDM
+roundEAX MACRO varOne
+LOCAL @@return
+	mov  edx,varOne                 ; move value into edx register
+	mov  eax,varOne                 ; move value into eax register
+	and  edx,00003FFFh              ; get remainder into edx register
+	shr  eax,14                     ; get whole number to eax register
+	cmp  edx,8192                   ; if remainder > 8192, increment ebx
+  jle  @@return                   ; otherwise return 
+	inc  eax                        ; increment value in eax
+@@return:
+ENDM
+getPoint MACRO address,index
+	movzx eax,index                                  ; move index into eax register
+	shl   eax,02h                                    ; multiply ax by size of far pointer
+	add   eax,address                                ; add in the address
+	movzx ebx,[eax].Point@@y                         ; get the y value to bx register
+	movzx eax,[eax].Point@@x                         ; get the x value to ax register
+ENDM
+newEdge MACRO                                      ; (PureEdge*) in eax, sets edx=1=error, otherwise edx=0
+	movzx ebx,[eax].PureEdge@@mEdgeDirection         ; save edgeDirection
+	push  ebx                                        ; push edgeDirection
+	push  [eax].PureEdge@@mCurrentEdgeEnd            ; push currentEdge end (ie) nextEdge index
+	mov   ecx,eax                                    ; move (PureEdge*) to ecx register
+	call  _directSetupEdge                           ; attempt to setup new edge
+	add   esp,06h                                    ; readjust the stack
+	mov   edx,eax                                    ; move return code to edx register
+ENDM
+getSrcDataByte MACRO                               ; BYTE getSrcDataByte(eax=colRow)
+	multiply ax,bmData@@mSrcWidth                    ; multiply (row*width)-> eax
+	movzx edx,bmData@@mSrcWidth                      ; move width to edx register
+	add   eax,edx                                    ; add in width (ie) (row*width)+width
+	mov   edx,bmData@@mSrcExtent                     ; move source bitmap extent to edx
+	sub   edx,eax                                    ; sub result from source bmp extent
+	add   edx,ebx                                    ; add column back in
+	mov   ebx,bmData@@mlpSrcPtr                      ; move mlpSrcPtr to ebx register
+	mov   cl,byte ptr[ebx+edx]                       ; get source byte at ebx+edx to cl
+ENDM
+setDstDataByte MACRO                                ; void setDstDataByte(cl=charByte)
+	mov  ebx,bmData@@mlpDstIndexPtr                   ; get scanline pointer to ebx
+	mov  byte ptr[ebx],cl                             ; move byte into frame bitmap
+	inc  bmData@@mlpDstIndexPtr                       ; increment scanline pointer
+ENDM
+setDstIndexPtr MACRO
+  multiply [esi].PureMap@@myValue,bmData@@mDstPitch ; multiply row*pitch result to eax 
+	mov [esi].PureMap@@mBitmapIndex,eax               ; save offset to row in bitmap
+ENDM
+adjDstIndexPtr MACRO
+	mov edx,[esi].PureMap@@mBitmapIndex               ; retrieve offset into bitmap
+	movzx ebx,[esi].PureMap@@mxDest                   ; move column into bx register
+	add edx,ebx                                       ; now add column number back in
+	add edx,bmData@@mlpDstPtr                         ; offset index by start
+	mov bmData@@mlpDstIndexPtr,edx                    ; store value into DstIndexPtr
+ENDM
+increment MACRO                                 ; assumes (PureEdge*) is in eax register, sets carry on error
+	LOCAL @@newEdge,@@adjTerm,@@error,@@success,@@return
+	dec   [eax].PureEdge@@mRemainingScanLines     ; decrement mRemainingScanLines
+	jz    @@newEdge                               ; if no more scan lines, try to setup new edge
+	mov   ebx,[eax].PureEdge@@mxSourceStep        ; get mxSourceStep to ebx register
+	add   ebx,[eax].PureEdge@@mxSource            ; add in mxSource
+	mov   [eax].PureEdge@@mxSource,ebx            ; replace mxSource with new value
+	mov   ebx,[eax].PureEdge@@mySourceStep        ; get mySourceStep into ebx register
+	add   ebx,[eax].PureEdge@@mySource            ; add in mySource
+	mov   [eax].PureEdge@@mySource,ebx            ; replace mySource with new value
+	mov   bx,[eax].PureEdge@@mxDestLocation       ; get mxDestLocation into ebx register
+	add   bx,[eax].PureEdge@@mxStep               ; add in mxStep
+	mov   [eax].PureEdge@@mxDestLocation,bx       ; replace mxDestLocation with new value
+	mov   bx,[eax].PureEdge@@mxErrorTerm          ; get mxErrorTerm to bx register
+	add   bx,[eax].PureEdge@@mxAdjustUp           ; add in mxAdjustUp
+	mov   [eax].PureEdge@@mxErrorTerm,bx	 	      ; replace mxErrorTerm with new value
+	cmp   bx,00h                                  ; compare mxErrorTerm to zero
+	jle   @@success                               ; mxErrorTerm is less equal zero
+@@adjTerm:                                      ; adjTerm sync address
+	mov   bx,[eax].PureEdge@@mxDestLocation       ; get mxDestLocation to bx register
+	add   bx,[eax].PureEdge@@mxDirection          ; add in mxDirection
+	mov   [eax].PureEdge@@mxDestLocation,bx       ; replace mxDestLocation with new value
+	mov   bx,[eax].PureEdge@@mxErrorTerm          ; move mxErrorTerm into bx register
+	sub   bx,[eax].PureEdge@@mxAdjustDown         ; add in mxAdjustDown
+	mov   [eax].PureEdge@@mxErrorTerm,bx          ; replace mxErrorTerm with new value
+	jmp   @@success                               ; we're done here
+@@newEdge:                                      ; newEdge sync address
+	newEdge                                       ; attempt to create new edge
+	cmp   edx,0001h                               ; did prior call fail ?
+	jne   @@success                               ; no, we're done here
+@@error:		  																	; error sync address
+	stc                                           ; error sets carry
+	jmp   @@return                                ; jump to return
+@@success:                                      ; ok sync address
+	clc                                           ; success clears carry
+@@return:                                       ; return sync address
+ENDM
+scanOutputLine MACRO                      ; void scanOutputLine(ecx=(PureEdge*))
+	LOCAL @@xLoop,@@skipImageBit,@@continue,@@return   ; local label
+	mov   edi,[esi].PureMap@@mlpLeftEdge    ; move (PureEdge*)lpLeftEdge to ecx register
+	mov   eax,[edi].PureEdge@@mxSource      ; move PureEdge::mxSource to eax register
+	mov   [esi].PureMap@@mxSource,eax       ; move PureEdge::mxSource to PureMap::mxSource
+	mov   eax,[edi].PureEdge@@mySource      ; move PureEdge::mySource to eax register
+	mov   [esi].PureMap@@mySource,eax       ; move PureEdge::mySource to PureMap::mySource
+	mov   dx,[edi].PureEdge@@mxDestLocation ; move PureEdge::mxDestLocation to ax
+	mov   [esi].PureMap@@mxDest,dx          ; move PureEdge::mxDestLocation to PureMap::mxDest
+	mov   edi,[esi].PureMap@@mlpRightEdge   ; move (PureEdge*)lpRightEdge to ecx register
+	xor   eax,eax                           ; clear out eax register
+	mov   ax,[edi].PureEdge@@mxDestLocation ; move PureEdge::mxDestLocation to ax register
+	mov   [esi].PureMap@@mxDestMax,ax       ; move PureEdge::mxDestLocation to PureMap::mxDestMax
+	sub   ax,dx                             ; mxDestMax-mxDest
+  jz    @@return                          ; if width is zero then return
+	mov   [esi].PureMap@@mDestWidth,eax     ; move width into PureMap::mDestWidth
+	mov   eax,[edi].PureEdge@@mxSource      ; move PureEdge::mxSource into eax
+	sub   eax,[esi].PureMap@@mxSource       ; subtract out PureMap::mxSource
+	divide  eax,[esi].PureMap@@mDestWidth     ; now divide by PureMap::mDestWidth
+	mov   [esi].PureMap@@mxSourceStep,eax   ; move new value to PureMap@@mxSourceStep
+	mov   eax,[edi].PureEdge@@mySource      ; move PureEdge::mySource into eax
+	sub   eax,[esi].PureMap@@mySource       ; subtract out PureMap::mySource
+	divide  eax,[esi].PureMap@@mDestWidth     ; now divide by PureMap::mDestWidth
+	mov   [esi].PureMap@@mySourceStep,eax   ; move new value to PureMap@@mySourceStep
+	setDstIndexPtr                          ; set destination index pointer to row/col
+@@xLoop:                                  ; xLoop test
+	mov   ax,[esi].PureMap@@mxDest          ; move mxDest to ax register
+	cmp   ax,[esi].PureMap@@mxDestMax       ; compare mxDest to ax register
+	jge   @@return                          ; if its greater equal return
+	cmp   ax,bmData@@mDstWidth              ; is destination x greater than frame width?
+	jge   @@return                          ; yes, stop scanning this output line
+	or    ax,ax                             ; does mxDest extend too far left of frame buffer
+	jl    @@skipImageBit                    ; if it does then skip putImageBits
+	adjDstIndexPtr                          ; adjust index to reflect changed mxDest
+@@continue:                               ; sync address
+	roundEAX [esi].PureMap@@mySource        ; round PureMap@@mySource -> eax (row)
+	roundEBX [esi].PureMap@@mxSource        ; round PureMap@@mxSource -> ebx (col)
+	getSrcDataByte                          ; getSrcDataByte at eax=colRow, byteValue gets placed into cl
+	setDstDataByte                          ; setDstDataByte at mlpDstIndexPtr,cl=byteValue
+@@skipImageBit:                           ; skipImageBit bypass address
+	mov   eax,[esi].PureMap@@mxSourceStep   ; move mxSourceStep to eax
+	add   [esi].PureMap@@mxSource,eax       ; add mxSouceStep to mxSource
+	mov   ebx,[esi].PureMap@@mySourceStep   ; move mySourceStep to eax
+	add   [esi].PureMap@@mySource,ebx       ; add mySourceStep to mySource
+	inc   [esi].PureMap@@mxDest             ; increment loop counter
+	jmp   @@xLoop                           ; loop through xLoop
+@@return:                                 ; return sync label
+ENDM
+scanOutputLineMask MACRO                  ; void scanOutputLineMask(ecx=(PureEdge*)) - uses mask settings
+	LOCAL @@xLoop,@@skipImageBit,@@continue,@@return   ; local label
+	mov   edi,[esi].PureMap@@mlpLeftEdge    ; move (PureEdge*)lpLeftEdge to ecx register
+	mov   eax,[edi].PureEdge@@mxSource      ; move PureEdge::mxSource to eax register
+	mov   [esi].PureMap@@mxSource,eax       ; move PureEdge::mxSource to PureMap::mxSource
+	mov   eax,[edi].PureEdge@@mySource      ; move PureEdge::mySource to eax register
+	mov   [esi].PureMap@@mySource,eax       ; move PureEdge::mySource to PureMap::mySource
+	mov   dx,[edi].PureEdge@@mxDestLocation ; move PureEdge::mxDestLocation to ax
+	mov   [esi].PureMap@@mxDest,dx          ; move PureEdge::mxDestLocation to PureMap::mxDest
+	mov   edi,[esi].PureMap@@mlpRightEdge   ; move (PureEdge*)lpRightEdge to ecx register
+	xor   eax,eax                           ; clear out eax register
+	mov   ax,[edi].PureEdge@@mxDestLocation ; move PureEdge::mxDestLocation to ax register
+	mov   [esi].PureMap@@mxDestMax,ax       ; move PureEdge::mxDestLocation to PureMap::mxDestMax
+	sub   ax,dx                             ; mxDestMax-mxDest
+  jz    @@return                          ; if width is zero then return
+	mov   [esi].PureMap@@mDestWidth,eax     ; move width into PureMap::mDestWidth
+	mov   eax,[edi].PureEdge@@mxSource      ; move PureEdge::mxSource into eax
+	sub   eax,[esi].PureMap@@mxSource       ; subtract out PureMap::mxSource
+	divide  eax,[esi].PureMap@@mDestWidth     ; now divide by PureMap::mDestWidth
+	mov   [esi].PureMap@@mxSourceStep,eax   ; move new value to PureMap@@mxSourceStep
+	mov   eax,[edi].PureEdge@@mySource      ; move PureEdge::mySource into eax
+	sub   eax,[esi].PureMap@@mySource       ; subtract out PureMap::mySource
+	divide  eax,[esi].PureMap@@mDestWidth     ; now divide by PureMap::mDestWidth
+	mov   [esi].PureMap@@mySourceStep,eax   ; move new value to PureMap@@mySourceStep
+	setDstIndexPtr                          ; set destination index pointer to row/col
+@@xLoop:                                  ; xLoop test
+	mov   ax,[esi].PureMap@@mxDest          ; move mxDest to ax register
+	cmp   ax,[esi].PureMap@@mxDestMax       ; compare mxDest to ax register
+	jge   @@return                          ; if its greater equal return
+	cmp   ax,bmData@@mDstWidth              ; is destination x greater than frame width?
+	jge   @@return                          ; yes, stop scanning this output line
+	or    ax,ax                             ; does mxDest extend too far left of frame buffer
+	jl    @@skipImageBit                    ; if it does then skip putImageBits
+	adjDstIndexPtr                          ; adjust index to reflect changed mxDest
+@@continue:                               ; sync address
+	roundEAX [esi].PureMap@@mySource        ; round PureMap@@mySource -> eax (row)
+	roundEBX [esi].PureMap@@mxSource        ; round PureMap@@mxSource -> ebx (col)
+	getSrcDataByte                          ; getSrcDataByte at eax=colRow, byteValue gets placed into cl
+	cmp cl,bmData@@mMaskValue               ; are we attempting to output a byte in our mask
+	je @@skipImageBit                       ; if so then do not set the byte
+	setDstDataByte                          ; setDstDataByte at mlpDstIndexPtr,cl=byteValue
+@@skipImageBit:                           ; skipImageBit bypass address
+	mov   eax,[esi].PureMap@@mxSourceStep   ; move mxSourceStep to eax
+	add   [esi].PureMap@@mxSource,eax       ; add mxSouceStep to mxSource
+	mov   ebx,[esi].PureMap@@mySourceStep   ; move mySourceStep to eax
+	add   [esi].PureMap@@mySource,ebx       ; add mySourceStep to mySource
+	inc   [esi].PureMap@@mxDest             ; increment loop counter
+	jmp   @@xLoop                           ; loop through xLoop
+@@return:                                 ; return sync label
+ENDM
+_directMapTexture proc near                     ; void mapTexture(PureMap *lpTextureMap)
+	push  ebp                               ; save old stack frame
+	mov   ebp,esp                           ; create new stack frame
+	pushad                                  ; save all general purpose registers, required.
+	mov   esi,dword ptr[ebp+8]              ; move (PureMap*) to esi register
+	mov   edx,[esi].PureMap@@mlpLeftEdge    ; move PureMap->mlpLeftEdge to edx
+	mov   bx,[edx].PureEdge@@mMaxVertex     ; move left edge mMaxVertex to bx register
+	getPoint [edx].PureEdge@@mlpDstList,bx  ; get point
+	mov   [esi].PureMap@@myValue,bx         ; myValue=mLeftEdge[mLeft.maxVertex()].y()
+@@forever:                                ; (ie) while(TRUE)
+	mov   ax,[esi].PureMap@@myValue         ; move myValue to ax register
+	cmp   ax,bmData@@mDstHeight             ; is myValue greater than frame buffer height
+	jge   @@return                          ; if so then we're done mapping the texture
+	cmp   ax,00h                            ; is myValue within frame buffer at all
+	jl    @@skipOutputLine                  ; if not then skip this output line
+	cmp   bmData@@mUseMask,00h              ; are we using mask settings
+	jne   @@scanMask                        ; if so then scan the output line, excluding masked bits
+	scanOutputLine                          ; otherwise just scan the output line
+	jmp @@skipOutputLine                    ; jump over the mask code
+@@scanMask:                               ; scanMask sync address
+	scanOutputLineMask                      ; scan the output line, apply mask where appropriate
+@@skipOutputLine:                         ; skipOutputLine sync address
+	mov   eax,[esi].PureMap@@mlpLeftEdge    ; move (PureEdge*) left edge to eax
+	increment                               ; increment along left edge
+	jc    @@return                          ; if carry set, edge failed to increment, we're done
+	mov   eax,[esi].PureMap@@mlpRightEdge   ; move (PureEdge*) right edge to eax
+	increment                               ; increment along right edge
+	jc    @@return                          ; if carry set, edge failed to increment, we're done
+	inc   [esi].PureMap@@myValue            ; increment y position
+	jmp   @@forever                         ; loop until all edges are completed
+@@return:                                 ; return sync address
+	popad                                   ; restore all general purpose registers
+	pop   ebp                               ; restore old stack frame
+	retn                                    ; return near to caller
+_directMapTexture endp
+_directInitEdge proc near                 ; void initEdge(long edgeType,PureEdge *lpEdge);
+	push  ebp                               ; save old stack frame
+	mov   ebp,esp                           ; create new stack frame
+	push  ebx                               ; save ebx register
+	mov   ecx,dword ptr[ebp+12]             ; move edge ptr to ecx register
+	call  _directGetMinMaxInfo              ; find minimum and maximum vertices
+	cmp   eax,0000h                         ; make sure previous call returned success
+	jne   @@return                          ; if not then return
+	push  dword ptr[ebp+8]                  ; push edge type (-1:leftEdge,1:rightEdge)
+	push  [ecx].PureEdge@@mStartVertex      ; push startVertex
+	call  _directSetupEdge                  ; now setup the edge
+	add   esp,06h                           ; readjust the stack
+@@return:                                 ; return label
+	pop   ebx                               ; restore ebx register
+	pop   ebp                               ; restore old stack frame
+	retn                                    ; return to caller
+_directInitEdge endp
+_directSetupEdge proc near                              ; long setupEge(long edgeType,int startVertex);
+LOCAL nextVertex:WORD,startVertex:WORD,xDestWidth:WORD,yDestHeight:DWORD=LocalLength
+	push  ebp                                       ; save old stack frame
+	mov   ebp,esp                                   ; create new stack frame
+	sub   esp,LocalLength                           ; make room for local variables
+	mov   bx,word ptr[ebp+10]                       ; move edge type to bx register
+	mov   [ecx].PureEdge@@mEdgeDirection,bx         ; store edge direction in variable
+	mov  bx,word ptr[ebp+8]                         ; move startVertex to bx register
+	mov  [ecx].PureEdge@@mStartVertex,bx            ; move startVertex into mStartVertex
+	mov  startVertex,bx                             ; move startVertex into startVertex
+@@forever:                                        ; forever loop label
+	mov   bx,startVertex                            ; move startVertex to bx register
+	cmp   bx,[ecx].PureEdge@@mMinVertex             ; is startVertex same as mMinVertex ?
+	je    @@error                                   ; if so then we're all done here
+	add   bx,[ecx].PureEdge@@mEdgeDirection         ; add edge direction to startVertex
+	mov   nextVertex,bx                             ; move result to nextVertex
+	mov   bx,[ecx].PureEdge@@mNumVertexes           ; move number of vertexes to bx register
+	cmp   nextVertex,bx                             ; compare nextVertex to number of vertexes
+	jge   @@zervert                                 ; next vertex is greater eq number of vertexes
+	cmp   nextVertex,00h                            ; compare nextVertex to zero
+	jl    @@adjvert                                 ; nextVertex is less than zero
+	jmp   @@bypass                                  ; jump over next conditonal
+@@zervert:                                        ; handle nextVertex>=number of vertexes
+	mov   nextVertex,00h                            ; set nextVertex to zero
+	jmp   @@bypass                                  ; jump over next conditional
+@@adjvert:                                        ; handle nextVertex<0
+	dec   bx                                        ; decrement value count in bx register
+	mov   nextVertex,bx                             ; set nextVertex to (numVertex-1)
+@@bypass:                                         ; bypass sync address
+	getPoint [ecx].PureEdge@@mlpDstList,nextVertex  ; get mlpDstList[nextVertex]
+	push  bx                                        ; dstList[nextVertex].y() in bx, save it.
+	getPoint [ecx].PureEdge@@mlpDstList,startVertex ; get mlpDstList[startVertex]
+	pop   ax                                        ; restore first x point to ax
+	sub   ax,bx                                     ; now subtract second x point
+	mov   [ecx].PureEdge@@mRemainingScanLines,ax    ; result is mRemainingScanLines
+	cmp   ax,00h                                    ; check scanlines==0
+	je    @@loopNext                                ; if it's zero, continue
+	mov   yDestHeight,eax                           ; set yDestHeight
+	push  nextVertex                                ; save nextVertex value
+	pop   [ecx].PureEdge@@mCurrentEdgeEnd           ; restore it to mCurrentEdgeEnd
+	getPoint [ecx].PureEdge@@mlpSrcList,startVertex ; get mlpSrcList[startVertex]
+	multiply ax,bmData@@mPrecision                  ; multiply mxSource by bmData@@mPrecision
+	mov   [ecx].PureEdge@@mxSource,eax              ; move srcList[startVertex].x() to mxSource
+	multiply bx,bmData@@mPrecision                  ; multiply mySource by bmData@@mPrecision
+	mov   [ecx].PureEdge@@mySource,eax              ; move srcList[startVertex].y() to mySource
+	getPoint [ecx].PureEdge@@mlpSrcList,nextVertex  ; get mlpSrcList[nextVertex]
+	multiply ax,bmData@@mPrecision                  ; ax by bmData@@mPrecision
+	mov   ebx,[ecx].PureEdge@@mxSource              ; mxSource to bx register
+	sub   eax,ebx                                   ; (ie) mlpSrcList[nextVertex].x-mxSource-->eax
+	divide  eax,yDestHeight                           ; divide by yDestHeight, this is mxSourceStep
+	mov   [ecx].PureEdge@@mxSourceStep,eax          ; move eax register into mxSourceStep
+	getPoint [ecx].PureEdge@@mlpSrcList,nextVertex  ; get source point
+	mov   eax,ebx                                   ; move point.y into eax register
+	multiply ax,bmData@@mPrecision                  ; multiply by precision
+	mov   ebx,[ecx].PureEdge@@mySource              ; mySource to bx register
+	sub   eax,ebx                                   ; (ie) mlpSrcList[nextVertex].y-mySource-->eax
+	divide  eax,yDestHeight                           ; divide by yDestHeight, this is mySourceStep
+	mov   [ecx].PureEdge@@mySourceStep,eax          ; move eax register into mySourceStep
+	getPoint [ecx].PureEdge@@mlpDstList,startVertex ; get mlpDstList[startVertex]
+	mov   [ecx].PureEdge@@mxDestLocation,ax         ; mxDestLocation=mDstList[startVertex].x()
+	getPoint [ecx].PureEdge@@mlpDstList,nextVertex  ; get dstList[nextVertex]
+	sub   ax,[ecx].PureEdge@@mxDestLocation         ; get the width of the segment
+	mov   xDestWidth,ax                             ; move the width into xDestWidth
+	cmp   xDestWidth,00h                            ; is the direction negative (ie) left
+	jl    @@negWidth                                ; yes, handle negative direction
+	mov   [ecx].PureEdge@@mxDirection,01h           ; set right direction indicator
+	mov   [ecx].PureEdge@@mxErrorTerm,00h           ; set mxErrorTerm to zero
+	movzx eax,xDestWidth                            ; move xDestWidth to eax zero extend
+	movzx ebx,[ecx].PureEdge@@mRemainingScanLines   ; move mRemainingScanLines to ebx
+	divide  eax,ebx                                   ; eax=xDestWidth.mRemainingScanLines
+	mov   [ecx].PureEdge@@mxStep,ax                 ; move result into mxStep
+	jmp   @@syncOne                                 ; jump over following handler
+@@negWidth:                                       ; handle negative direction
+	mov   [ecx].PureEdge@@mxDirection,-1            ; set left direction indicator
+	neg   xDestWidth                                ; negate the width (ie) make it positive
+	mov   ax,01h                                    ; move one into ax register
+	sub   ax,[ecx].PureEdge@@mRemainingScanLines    ; subtract remaining scan lines from 1
+	mov   [ecx].PureEdge@@mxErrorTerm,ax            ; move result to mxErrorTerm
+	movzx eax,xDestWidth                            ; move xDestWidth to eax zero extend
+	movzx ebx,[ecx].PureEdge@@mRemainingScanLines   ; move mRemainingScanLines to ebx
+	divide  eax,ebx                                   ; eax=xDestWidth/mRemainingScanLines
+	neg   eax                                       ; negate the result
+	mov   [ecx].PureEdge@@mxStep,ax                 ; move result back into mxStep
+@@syncOne:                                        ; synchronization address
+	mov  [ecx].PureEdge@@mxAdjustUp,dx              ; move remainder into mxAdjustUp
+	push [ecx].PureEdge@@mRemainingScanLines        ; save mRemainingScanLines
+	pop  [ecx].PureEdge@@mxAdjustDown               ; restore mRemainingScanLines into mxAdjustDown
+	jmp  @@ok                                       ; jump over forever loop
+@@loopNext:                                       ; forever loop address
+	push  nextVertex                                ; save nextVertex on stack
+	pop   [ecx].PureEdge@@mStartVertex              ; restore into mStartVertex
+	push  nextVertex                                ; save nextVertex on stack
+	pop   startVertex                               ; restore it to local copy of startVertex
+	jmp   @@forever                                 ; continue with loop
+@@error:                                          ; error handler
+	mov   eax,0001h                                 ; set ax register to 01h to indicate failure
+	jmp   @@return                                  ; jump over to return label
+@@ok:                                             ; success handler
+	xor   eax,eax                                   ; clear out eax register to handle success
+@@return:                                         ; return label
+	add   esp,LocalLength                           ; remove local variables from stack
+	pop   ebp                                       ; restore old stack frame
+	retn                                            ; return near to caller
+_directSetupEdge endp
+_directGetMinMaxInfo proc near                          ; long getMinMaxInfo(void)
+LOCAL yMin:WORD,yMax:WORD=LocalLength
+	push  ebp                                       ; save old stack frame
+	mov   ebp,esp                                   ; create new stack frame
+	sub   esp,LocalLength                           ; make room for local variables
+	push  ecx                                       ; save callers ecx register
+	mov   edx,ecx                                   ; move ecx into edx, edx has ptr to PureEdge
+	cmp   [edx].PureEdge@@mNumVertexes,MINVERTEX    ; make sure have at least 3 vertexes
+	jl    @@error                                   ; handle error condition
+	mov   yMin,MINVALUE                             ; start yMin with some low value
+	mov   yMax,MAXVALUE                             ; start yMax with some high value
+	xor   ecx,ecx                                   ; start at index zero
+	mov   eax,[edx].PureEdge@@mlpDstList            ; move address of (Point*) to ebx register
+@@iterator:                                       ; loop top
+	mov   bx,[eax].Point@@y                         ; move point::y to bx register
+	cmp   bx,yMin                                   ; compare with current yMin value
+	jg    @@greater                                 ; point::y greater than current yMin
+@@nexttest:                                       ; if I handle the greater condition, still need to do less
+	cmp   bx,yMax                                   ; compare with current yMax value
+	jl    @@less                                    ; point::y less than current yMax
+	jmp   @@looptest                                ; nuthin, continue with test
+@@greater:                                        ; handle greater condition
+	mov   yMin,bx                                   ; set yMin to bx register
+	mov   [edx].PureEdge@@mMinVertex,cx             ; move index number of vertex to mMinVertex
+	jmp   @@nexttest                                ; go perform next test
+@@less:                                           ; handle less condition
+	mov   yMax,bx                                   ; set yMax to bx register
+	mov   [edx].PureEdge@@mMaxVertex,cx             ; update mMaxVertex with current index
+@@looptest:                                       ; falls through to loop
+	add   eax,04h                                   ; add 4 bytes to eax to address next (Point*)
+	inc   cx                                        ; increment cx register
+	cmp   cx,[edx].PureEdge@@mNumVertexes           ; have we reeached the number of vertexes yet?
+	jl    @@iterator                                ; still more vertexes
+	push  [edx].PureEdge@@mMaxVertex                ; save mMaxVertex
+	pop   [edx].PureEdge@@mStartVertex              ; restore it to mStartVertex
+	jmp   @@ok                                      ; error return sync address
+@@error:                                          ; setup for error return code
+	mov   eax,0001h                                 ; move 01h into ax to indicate error
+	jmp   @@return                                  ; jump to return label
+@@ok:                                             ; setup for success return code
+	xor   eax,eax                                   ; clear out eax register
+@@return:                                         ; return label
+	pop   ecx                                       ; restore callers ecx register
+	add   esp,LocalLength                           ; pop local variables off stack
+	pop   ebp                                       ; restore old stack frame
+	retn                                            ; return near to caller
+_directGetMinMaxInfo endp
+_directSetSrcBitmapInfo proc near ; void setSrcBitmapInfo(WORD width,WORD height,UHUGE *lpBitmapImage)
+	push  ebp                                        ; save old stack frame
+	mov   ebp,esp                                    ; create new stack frame
+	push  eax                                        ; save eax register
+	push  ebx                                        ; save ebx register
+	mov   ax,word ptr[ebp+08h]                       ; move width into ax register
+	mov   bmData@@mSrcWidth,ax                       ; move width into bmData@@mSrcWidth
+	mov   bx,word ptr[ebp+0Ch]                       ; move height into bx register
+	mov   bmData@@mSrcHeight,bx                      ; move height into bx register
+	multiply ax,bx                                   ; multiply (width*height)
+	mov   bmData@@mSrcExtent,eax                     ; (width*height) to mSrcExtent
+	push  dword ptr[ebp+10h]                         ; save lpBitmapImage on stack
+	pop   bmData@@mlpSrcPtr                          ; restore in mlpSrcPtr
+	pop   ebx                                        ; restore ebx register
+	pop   eax                                        ; restore eax register
+	pop   ebp                                        ; restore old stack frame
+	retn                                             ; return near to caller
+_directSetSrcBitmapInfo endp
+_directSetDstBitmapInfo proc near    ; void setDstBitmapInfo(WORD width,WORD height,WORD pitch,UHUGE *lpBitmapImage)
+	push  ebp                                        ; save old stack frame
+	mov   ebp,esp                                    ; create new stack frame
+	push  eax                                        ; save eax register
+	push  ebx                                        ; save ebx register
+	mov   ax,word ptr[ebp+10h]                       ; move pitch into ax register
+	mov   bmData@@mDstPitch,ax                       ; move pitch into mDstPitch
+	mov   ax,word ptr[ebp+08h]                       ; move width into ax register
+	mov   bmData@@mDstWidth,ax                       ; move width into mDstWidth
+	mov   bx,word ptr[ebp+0Ch]                       ; move height into bx register
+	mov   bmData@@mDstHeight,bx                      ; move height into mDstHeight
+	multiply ax,bx                                   ; multiply (width*height)
+	mov   bmData@@mDstExtent,eax                     ; move (width*height) into mDstExtent
+	push  dword ptr[ebp+14h]                         ; save lpBitmapImage on stack
+	pop   bmData@@mlpDstPtr                          ; restore in mlpDstPtr
+	pop   ebx                                        ; restore ebx register
+	pop   eax                                        ; restore eax register
+	pop   ebp                                        ; restore old stack frame
+	retn                                             ; return near to caller
+_directSetDstBitmapInfo endp
+_directSetMaskInfo proc near                             ; void setMaskInfo(WORD useMask,BYTE maskValue)
+	push ebp                                         ; save previous stack frame
+	mov  ebp,esp                                     ; create new frame
+	mov  eax,[ebp+08h]                               ; move useMask into eax register
+	mov  bmData@@mUseMask,al                         ; move useMask into bmData@@mUseMask
+	cmp  eax,0000h                                   ; check to see if we are using the mask
+  je   @@maskEndProc                               ; if we're not using mask, don't set mask value
+	mov  eax,[ebp+0Ch]                               ; move mask value into eax register
+	mov  bmData@@mMaskValue,al                       ; move mask value into bmData@@mMaskValue
+@@maskEndProc:                                     ; end procedure sync address
+	pop ebp                                          ; restore previous stack frame
+  retn                                             ; return near to caller 
+_directSetMaskInfo endp
+public _directMapTexture
+public _directInitEdge
+public _directSetSrcBitmapInfo
+public _directSetDstBitmapInfo
+public _directSetMaskInfo
+end
+

ddraw/TMAP32.INC

@@ -0,0 +1,45 @@
+;********************************************************************************************************
+; FILE:TMAP32.INC
+; FUNCTION: INCLUDE FILE FOR ASM TEXTURE MAPPING (DIRECT DRAW VERSION)
+; AUTHOR:SEAN M. KESSLER
+;********************************************************************************************************
+PureEdge STRUC
+	PureEdge@@mEdgeDirection      	DW      ?
+	PureEdge@@mRemainingScanLines 	DW      ?
+	PureEdge@@mCurrentEdgeEnd     	DW      ?
+	PureEdge@@mxSource            	DD      ?
+	PureEdge@@mySource           	  DD      ?
+	PureEdge@@mxSourceStep        	DD      ?
+	PureEdge@@mySourceStep        	DD      ?
+	PureEdge@@mxDestLocation      	DW      ?
+	PureEdge@@mxStep              	DW      ?
+	PureEdge@@mxDirection        	  DW      ?
+	PureEdge@@mxErrorTerm         	DW      ?
+	PureEdge@@mxAdjustUp          	DW      ?
+	PureEdge@@mxAdjustDown        	DW      ?
+	PureEdge@@mMaxVertex          	DW      ?
+	PureEdge@@mMinVertex          	DW      ?
+	PureEdge@@mStartVertex        	DW      ?
+	PureEdge@@mNumVertexes        	DW      ?
+	PureEdge@@mlpSrcList          	DD      NEAR PTR ?
+	PureEdge@@mlpDstList          	DD      NEAR PTR ?
+PureEdge ENDS
+PureMap STRUC
+  PureMap@@mBitmapIndex           DD      ?
+	PureMap@@mxSource	      				DD      ?
+	PureMap@@mySource     	      	DD      ?
+	PureMap@@mDestWidth   	      	DD      ?
+	PureMap@@mxSourceStep 	      	DD      ?
+	PureMap@@mySourceStep 	      	DD      ?
+	PureMap@@mxDest       	      	DW      ?
+	PureMap@@mxDestMax    	      	DW      ?
+	PureMap@@myValue      	      	DW      ?
+	PureMap@@mlpLeftEdge  	      	DD      NEAR PTR ?
+	PureMap@@mlpRightEdge 	      	DD      NEAR PTR ?
+PureMap ENDS
+MathCache STRUC
+	MathCache@@mCacheOne            DD ?
+	MathCache@@mCacheTwo            DD ?
+  MathCache@@mCacheVal            DD ?
+MathCache ENDS
+

ddraw/TRIEDGE.HPP

@@ -0,0 +1,462 @@
+#ifndef _DDRAW_TRIEDGE_HPP_
+#define _DDRAW_TRIEDGE_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+
+class DirectTriEdge
+{
+public:
+  DirectTriEdge(void);
+	DirectTriEdge(int x0,int y0,int x1,int y1,int x2,int y2,int u0,int v0,int u1,int v1,int u2,int v2);
+	DirectTriEdge(const DirectTriEdge &someDirectTriEdge);
+	virtual ~DirectTriEdge();
+	DirectTriEdge &operator=(const DirectTriEdge &someDirectTriEdge);
+	BOOL operator==(const DirectTriEdge &someDirectTriEdge)const;
+	int dxLeft(void)const;
+	void dxLeft(int dxLeft);
+	int dxRight(void)const;
+	void dxRight(int dxRight);
+	int duLeft(void)const;
+	void duLeft(int duLeft);
+	int duRight(void)const;
+	void duRight(int duRight);
+	int dvLeft(void)const;
+	void dvLeft(int dvLeft);
+	int dvRight(void)const;
+	void dvRight(int dvRight);
+	int xLeft(void)const;
+	void xLeft(int xLeft);
+	int xRight(void)const;
+	void xRight(int xRight);
+	int vLeft(void)const;
+	void vLeft(int vLeft);
+	int vRight(void)const;
+	void vRight(int vRight);
+	int uLeft(void)const;
+	void uLeft(int uLeft);
+	int uRight(void)const;
+	void uRight(int uRight);
+	int x0(void)const;
+	void x0(int x0);
+	int y0(void)const;
+	void y0(int y0);
+	int x1(void)const;
+	void x1(int x1);
+	int y1(void)const;
+	void y1(int y1);
+	int x2(void)const;
+	void x2(int x2);
+	int y2(void)const;
+	void y2(int y2);
+	int u0(void)const;
+	void u0(int u0);
+	int v0(void)const;
+	void v0(int v0);
+	int u1(void)const;
+	void u1(int u1);
+	int v1(void)const;
+	void v1(int v1);
+	int u2(void)const;
+	void u2(int u2);
+	int v2(void)const;
+	void v2(int v2);
+private:
+  int mDXLeft;
+	int mDXRight;
+	int mDULeft;
+	int mDURight;
+	int mDVLeft;
+	int mDVRight;
+  int mxLeft;
+	int mxRight;
+	int mvLeft;
+	int mvRight;
+	int muLeft;
+	int muRight;
+  int mx0;
+	int my0;
+	int mx1;
+	int my1;
+	int mx2;
+	int my2;
+	int mu0;
+	int mv0;
+	int mu1;
+	int mv1;
+	int mu2;
+	int mv2;
+};
+
+inline
+DirectTriEdge::DirectTriEdge(void)
+: mx0(0), my0(0), mx1(0), my1(0), mx2(0), my2(0), mu0(0), mv0(0), mu1(0), mv1(0), mu2(0), mv2(0),
+  mxLeft(0), mxRight(0), mvLeft(0), mvRight(0), muLeft(0), muRight(0), mDXLeft(0), mDXRight(0),
+	mDULeft(0), mDURight(0), mDVLeft(0), mDVRight(0)
+{
+}
+
+inline
+DirectTriEdge::DirectTriEdge(int x0,int y0,int x1,int y1,int x2,int y2,int u0,int v0,int u1,int v1,int u2,int v2)
+: mx0(x0), my0(y0), mx1(x1), my1(y1), mx2(x2), my2(y2), mu0(u0), mv0(v0), mu1(u1), mv1(v1), mu2(u2), mv2(v2)
+{
+}
+
+inline
+DirectTriEdge::DirectTriEdge(const DirectTriEdge &someDirectTriEdge)
+{
+  *this=someDirectTriEdge;
+}
+
+inline
+DirectTriEdge::~DirectTriEdge()
+{
+}
+
+inline
+DirectTriEdge &DirectTriEdge::operator=(const DirectTriEdge &someDirectTriEdge)
+{
+  x0(someDirectTriEdge.x0());
+	y0(someDirectTriEdge.y0());
+	x1(someDirectTriEdge.x1());
+	y1(someDirectTriEdge.y1());
+	x2(someDirectTriEdge.x2());
+	y2(someDirectTriEdge.y2());
+	u0(someDirectTriEdge.u0());
+	v0(someDirectTriEdge.v0());
+	u1(someDirectTriEdge.u1());
+	v1(someDirectTriEdge.v1());
+	u2(someDirectTriEdge.u2());
+	v2(someDirectTriEdge.v2());
+	xLeft(someDirectTriEdge.xLeft());
+	xRight(someDirectTriEdge.xRight());
+	uLeft(someDirectTriEdge.uLeft());
+	uRight(someDirectTriEdge.uRight());
+	vLeft(someDirectTriEdge.vLeft());
+	vRight(someDirectTriEdge.vRight());
+	dxLeft(someDirectTriEdge.dxLeft());
+	dxRight(someDirectTriEdge.dxRight());
+	duLeft(someDirectTriEdge.duLeft());
+	duRight(someDirectTriEdge.duRight());
+	dvLeft(someDirectTriEdge.dvLeft());
+	dvRight(someDirectTriEdge.dvRight());
+	return *this;
+}
+
+inline
+BOOL DirectTriEdge::operator==(const DirectTriEdge &someDirectTriEdge)const
+{
+  return (x0()==someDirectTriEdge.x0()&&
+	        y0()==someDirectTriEdge.y0()&&
+	        x1()==someDirectTriEdge.x1()&&
+	        y1()==someDirectTriEdge.y1()&&
+	        x2()==someDirectTriEdge.x2()&&
+	        y2()==someDirectTriEdge.y2()&&
+	        u0()==someDirectTriEdge.u0()&&
+	        v0()==someDirectTriEdge.v0()&&
+	        u1()==someDirectTriEdge.u1()&&
+	        v1()==someDirectTriEdge.v1()&&
+	        u2()==someDirectTriEdge.u2()&&
+	        v2()==someDirectTriEdge.v2()&&
+					xLeft()==someDirectTriEdge.xLeft()&&
+					xRight()==someDirectTriEdge.xRight()&&
+					uLeft()==someDirectTriEdge.uLeft()&&
+					uRight()==someDirectTriEdge.uRight()&&
+					vLeft()==someDirectTriEdge.vLeft()&&
+					vRight()==someDirectTriEdge.vRight()&&
+					dxLeft()==someDirectTriEdge.dxLeft()&&
+					dxRight()==someDirectTriEdge.dxRight()&&
+					duLeft()==someDirectTriEdge.duLeft()&&
+					duRight()==someDirectTriEdge.duRight()&&
+					dvLeft()==someDirectTriEdge.dvLeft()&&
+					dvRight()==someDirectTriEdge.dvRight());
+}
+
+inline
+int DirectTriEdge::xLeft(void)const
+{
+  return mxLeft;
+}
+
+inline
+void DirectTriEdge::xLeft(int xLeft)
+{
+  mxLeft=xLeft;
+}
+
+inline
+int DirectTriEdge::xRight(void)const
+{
+  return mxRight;
+}
+
+inline
+void DirectTriEdge::xRight(int xRight)
+{
+  mxRight=xRight;
+}
+
+inline
+int DirectTriEdge::vLeft(void)const
+{
+  return mvLeft;
+}
+
+inline
+void DirectTriEdge::vLeft(int vLeft)
+{
+  mvLeft=vLeft;
+}
+
+inline
+int DirectTriEdge::vRight(void)const
+{
+  return mvRight;
+}
+
+inline
+void DirectTriEdge::vRight(int vRight)
+{
+  mvRight=vRight;
+}
+
+inline
+int DirectTriEdge::uLeft(void)const
+{
+  return muLeft;
+}
+
+inline
+void DirectTriEdge::uLeft(int uLeft)
+{
+  muLeft=uLeft;
+}
+
+inline
+int DirectTriEdge::uRight(void)const
+{
+  return muRight;
+}
+
+inline
+void DirectTriEdge::uRight(int uRight)
+{
+  muRight=uRight;
+}
+
+inline
+int DirectTriEdge::x0(void)const
+{
+  return mx0;
+}
+
+inline
+void DirectTriEdge::x0(int x0)
+{
+  mx0=x0;
+}
+
+inline
+int DirectTriEdge::y0(void)const
+{
+  return my0;
+}
+
+inline
+void DirectTriEdge::y0(int y0)
+{
+  my0=y0;
+}
+
+inline
+int DirectTriEdge::x1(void)const
+{
+  return mx1;
+}
+
+inline
+void DirectTriEdge::x1(int x1)
+{
+  mx1=x1;
+}
+
+inline
+int DirectTriEdge::y1(void)const
+{
+  return my1;
+}
+
+inline
+void DirectTriEdge::y1(int y1)
+{
+  my1=y1;
+}
+
+inline
+int DirectTriEdge::x2(void)const
+{
+  return mx2;
+}
+
+inline
+void DirectTriEdge::x2(int x2)
+{
+  mx2=x2;
+}
+
+inline
+int DirectTriEdge::y2(void)const
+{
+  return my2;
+}
+
+inline
+void DirectTriEdge::y2(int y2)
+{
+  my2=y2;
+}
+
+inline
+int DirectTriEdge::u0(void)const
+{
+  return mu0;
+}
+
+inline
+void DirectTriEdge::u0(int u0)
+{
+  mu0=u0;
+}
+
+inline
+int DirectTriEdge::v0(void)const
+{
+  return mv0;
+}
+
+inline
+void DirectTriEdge::v0(int v0)
+{
+  mv0=v0;
+}
+
+inline
+int DirectTriEdge::u1(void)const
+{
+  return mu1;
+}
+
+inline
+void DirectTriEdge::u1(int u1)
+{
+  mu1=u1;
+}
+
+inline
+int DirectTriEdge::v1(void)const
+{
+  return mv1;
+}
+
+inline
+void DirectTriEdge::v1(int v1)
+{
+  mv1=v1;
+}
+
+inline
+int DirectTriEdge::u2(void)const
+{
+  return mu2;
+}
+
+inline
+void DirectTriEdge::u2(int u2)
+{
+  mu2=u2;
+}
+
+inline
+int DirectTriEdge::v2(void)const
+{
+  return mv2;
+}
+
+inline
+void DirectTriEdge::v2(int v2)
+{
+  mv2=v2;
+}
+
+inline
+int DirectTriEdge::dxLeft(void)const
+{
+  return mDXLeft;
+}
+
+inline
+void DirectTriEdge::dxLeft(int dxLeft)
+{
+  mDXLeft=dxLeft;
+}
+
+inline
+int DirectTriEdge::dxRight(void)const
+{
+  return mDXRight;
+}
+
+inline
+void DirectTriEdge::dxRight(int dxRight)
+{
+  mDXRight=dxRight;
+}
+
+inline
+int DirectTriEdge::duLeft(void)const
+{
+  return mDULeft;
+}
+
+inline
+void DirectTriEdge::duLeft(int duLeft)
+{
+  mDULeft=duLeft;
+}
+
+inline
+int DirectTriEdge::duRight(void)const
+{
+  return mDURight;
+}
+
+inline
+void DirectTriEdge::duRight(int duRight)
+{
+  mDURight=duRight;
+}
+
+inline
+int DirectTriEdge::dvLeft(void)const
+{
+  return mDVLeft;
+}
+
+inline
+void DirectTriEdge::dvLeft(int dvLeft)
+{
+  mDVLeft=dvLeft;
+}
+
+inline
+int DirectTriEdge::dvRight(void)const
+{
+  return mDVRight;
+}
+
+inline
+void DirectTriEdge::dvRight(int dvRight)
+{
+  mDVRight=dvRight;
+}
+#endif

ddraw/TRIMAP32.SAF

@@ -0,0 +1,332 @@
+;********************************************************************************************************
+; MODULE: TRIMAP32.ASM                                               DATE: FEBRUARY 11, 1999
+; AUTHOR: SEAN M. KESSLER                                            
+; TARGET: 32 BIT TARGET																							 
+; FUNCTION : TEXTURE MAPPING TRIANGLES
+;********************************************************************************************************
+SMART
+.386
+.MODEL FLAT
+.DATA
+bmData@@mSrcWidth      DD ?
+bmData@@mSrcHeight     DD ?
+bmData@@mSrcExtent     DD ?
+bmData@@mlpSrcPtr      DD ?
+bmData@@mDstWidth      DD ?
+bmData@@mDstPitch      DD ?
+bmData@@mDstHeight     DD ?
+bmData@@mDstExtent     DD ?
+bmData@@mlpDstPtr      DD ?
+bmData@@mlpDstIndexPtr DD ?
+.LALL
+INCLUDE ..\COMMON\COMMON.INC
+INCLUDE ..\DDRAW\TRIMAP32.INC
+INCLUDE ..\DDRAW\UTIL32.INC
+.CODE
+
+roundEAX MACRO
+LOCAL @@return
+  mov edx,eax                     ; copy eax to edx
+	and edx,7FFh                    ; get remainder to edx register
+	shr eax,0Bh                     ; get whole number to eax register
+	cmp edx,400h                    ; if remainder>1024 then increment eax
+	jle @@return                    ; ... otherwise return
+	inc eax                         ; increment value in eax
+@@return:
+ENDM
+
+scanline MACRO
+	mov ecx,[esi].DirectTriEdge@@mxRight             ; move mxRight into ecx
+	sub ecx,[esi].DirectTriEdge@@mxLeft              ; subtract out mxLeft, this is dx
+	cmp ecx,0000h                                    ; compare dx to zero
+	je @@scanlineLoopEnd                             ; if dx is zero then don't scan the line
+	mov eax,[esi].DirectTriEdge@@muRight             ; move muRight into eax 
+	sub eax,[esi].DirectTriEdge@@muLeft              ; subtract out muLeft
+	shl eax,0Bh                                      ; multiply this by 2048
+	divide eax,ecx                                   ; divide by dx, this is du
+	mov du,eax                                       ; store du into local variable
+	mov eax,[esi].DirectTriEdge@@mvRight             ; move mvRight into eax
+	sub eax,[esi].DirectTriEdge@@mvLeft              ; subtract out mvLeft
+	shl eax,0Bh                                      ; multiply this by 2048
+	divide eax,ecx                                   ; divide by dx, this is dv
+	mov dv,eax                                       ; store dv into local variable
+	mov eax,[esi].DirectTriEdge@@muLeft              ; move muLeft into eax
+	mov ui,eax                                       ; muLeft is initial value for ui
+	mov eax,[esi].DirectTriEdge@@mvLeft              ; move mvLeft into eax
+	mov vi,eax                                       ; mvLeft is initial value for vi
+	mov eax,[esi].DirectTriEdge@@mxLeft              ; move mxLeft into eax
+	mov x,eax                                        ; mxLeft is initial value for x
+@@scanlineLoop:                                    ; scanline loop sync address
+  mov eax,[esi].DirectTriEdge@@mxRight             ; move mxRight into eax
+	cmp x,eax                                        ; compare x to mxRight
+	jg @@scanlineLoopEnd                             ; if x>mxRight then we're done with the scanline
+  getSrcDataByte                                   ; get source byte at [ui][vi] to cl register
+	setDstDataByte                                   ; set destination byte at [x][y],cl
+	incrementScan                                    ; advance along the scanline
+	jmp @@scanlineLoop                               ; continue execution
+@@scanlineLoopEnd:                                 ; end scanline sync address
+ENDM
+
+incrementScan MACRO                                ; advance along the scanline
+  mov eax,ui                                       ; move ui to eax
+	shl eax,0Bh																			 ; multiply by 2048
+	add eax,du                                       ; add in du
+	shr eax,0Bh                                      ; divide by 2048
+	mov ui,eax                                       ; update ui
+	mov eax,vi                                       ; move vi to eax
+	shl eax,0Bh                                      ; multiply by 2048
+	add eax,dv                                       ; add in dv
+	shr eax,0Bh                                      ; divide by 2048
+	mov vi,eax                                       ; update vi
+	inc x                                            ; increment x
+ENDM
+
+increment MACRO
+	mov eax,[esi].DirectTriEdge@@mxLeft              ; move mxLeft into eax
+	shl eax,0Bh																			 ; multiply by 2048
+	add eax,[esi].DirectTriEdge@@mDXLeft						 ; add in the delta
+	roundEAX                                         ; adjust and round the value
+	mov [esi].DirectTriEdge@@mxLeft,eax              ; this is new mxLeft
+	mov eax,[esi].DirectTriEdge@@mxRight             ; move mxRight into eax
+	shl eax,0Bh                                      ; multiply by 2048
+	add eax,[esi].DirectTriEdge@@mDXRight            ; add in the delta
+	roundEAX                                         ; adjust and round the value
+	mov [esi].DirectTriEdge@@mxRight,eax             ; this is new mxRight
+	mov eax,[esi].DirectTriEdge@@muLeft              ; move muLeft into eax
+	shl eax,0Bh                                      ; multiply by 2048
+	add eax,[esi].DirectTriEdge@@mDULeft						 ; add in the delta
+	roundEAX                                         ; adjust and round the value
+	mov [esi].DirectTriEdge@@muLeft,eax							 ; this is new muLeft
+	mov eax,[esi].DirectTriEdge@@muRight						 ; move muRight into eax 
+	shl eax,0Bh																			 ; multiply by 2048
+	add eax,[esi].DirectTriEdge@@mDURight						 ; add in the delta
+	roundEAX                                         ; adjust and round the value
+	mov [esi].DirectTriEdge@@muRight,eax						 ; this is new muRight
+	mov eax,[esi].DirectTriEdge@@mvLeft							 ; move mvLeft into eax
+	shl eax,0Bh																			 ; multiply by 2048
+	add eax,[esi].DirectTriEdge@@mDVLeft						 ; add in the delta
+	roundEAX                                         ; adjust and round the value
+	mov [esi].DirectTriEdge@@mvLeft,eax							 ; this is new mvLeft
+	mov eax,[esi].DirectTriEdge@@mvRight						 ; move mvRight into eax
+	shl eax,0Bh																			 ; multiply by 2048
+	add eax,[esi].DirectTriEdge@@mDVRight						 ; add in the delta
+	roundEAX                                         ; adjust and round the value
+	mov [esi].DirectTriEdge@@mvRight,eax						 ; this is new mvRight
+	inc y							                               ; increment y
+ENDM
+
+initialize MACRO
+	mov eax,[esi].DirectTriEdge@@my2                 ; move my2 into eax
+	sub eax,[esi].DirectTriEdge@@my0								 ; eax has (y2-y0)
+	mov [esi].DirectTriEdge@@mDY,eax								 ; move (y2-y0) into mDY variable
+	mov eax,[esi].DirectTriEdge@@mx2                 ; move x2 into eax
+	sub eax,[esi].DirectTriEdge@@mx0  							 ; eax has (x2-x0)
+	shl eax,0Bh																			 ; multiply result by 2048 for precision
+	divide eax,[esi].DirectTriEdge@@mDY              ; eax has (x2-x0)/(y2-y0) 
+	mov [esi].DirectTriEdge@@mDXLeft,eax						 ; this is mDXLeft
+	mov eax,[esi].DirectTriEdge@@mx1                 ; move x1 into eax
+	sub eax,[esi].DirectTriEdge@@mx0	  						 ; eax has (x1-x0)
+	shl eax,0Bh																			 ; multiply result by 2048 for precision
+	divide eax,[esi].DirectTriEdge@@mDY							 ; eax has (x1-x0)/(y2-y0)
+	mov [esi].DirectTriEdge@@mDXRight,eax						 ; this is mDXRight
+  mov eax,[esi].DirectTriEdge@@mu2                 ; move u2 into eax
+	sub eax,[esi].DirectTriEdge@@mu0								 ; eax has (u2-u0)
+	shl eax,0Bh																			 ; multiply result by 2048 for precision
+	divide eax,[esi].DirectTriEdge@@mDY              ; eax has (u2-u0)/(y2-y0)
+	mov [esi].DirectTriEdge@@mDULeft,eax             ; this is mDULeft
+	mov eax,[esi].DirectTriEdge@@mu1                 ; move u1 into eax
+	sub eax,[esi].DirectTriEdge@@mu0                 ; eax has (u1-u0)
+	shl eax,0Bh																			 ; multiply result by 2048 for precision
+	divide eax,[esi].DirectTriEdge@@mDY              ; eax has (u1-u0)/(y2-y0)
+	mov [esi].DirectTriEdge@@mDURight,eax            ; this is mDURight
+	mov eax,[esi].DirectTriEdge@@mv2                 ; move v2 into eax
+	sub eax,[esi].DirectTriEdge@@mv0                 ; eax has (v2-v0)
+	shl eax,0Bh                                      ; multiply result by 2048 for precision
+	divide eax,[esi].DirectTriEdge@@mDY              ; eax has (v2-v0)/(y2-y0)
+	mov [esi].DirectTriEdge@@mDVLeft,eax             ; this is mDVLeft
+  mov eax,[esi].DirectTriEdge@@mv1                 ; move v1 into eax
+	sub eax,[esi].DirectTriEdge@@mv0                 ; eax has (v1-v0)
+	shl eax,0Bh                                      ; multiply result by 2048 for precision
+	divide eax,[esi].DirectTriEdge@@mDY              ; eax has (v1-v0)/(y2-y0)
+	mov [esi].DirectTriEdge@@mDVRight,eax            ; this is mDVRight
+	mov eax,[esi].DirectTriEdge@@mx0                 ; move x0 into eax
+	mov [esi].DirectTriEdge@@mxLeft,eax              ; mxLeft=x0
+	mov [esi].DirectTriEdge@@mxRight,eax             ; mxRight=x0
+	mov eax,[esi].DirectTriEdge@@mu0                 ; move u0 into eax
+	mov [esi].DirectTriEdge@@muLeft,eax              ; muLeft=u0
+	mov [esi].DirectTriEdge@@muRight,eax             ; muRight=u0
+	mov eax,[esi].DirectTriEdge@@mv0                 ; move v0 into eax
+	mov [esi].DirectTriEdge@@mvLeft,eax              ; mvLeft=v0
+	mov [esi].DirectTriEdge@@mvRight,eax             ; mvRight=v0
+ENDM
+
+if 0
+initialize MACRO
+	mov eax,[esi].DirectTriEdge@@my2                 ; move my2 into eax
+	sub eax,[esi].DirectTriEdge@@my0								 ; eax has (y2-y0)
+	mov [esi].DirectTriEdge@@mDY,eax								 ; move (y2-y0) into mDY variable
+	mov eax,[esi].DirectTriEdge@@mx2                 ; move x2 into eax
+	sub eax,[esi].DirectTriEdge@@mx0  							 ; eax has (x2-x0)
+	shl eax,0Bh																			 ; multiply result by 2048 for precision
+	divide eax,[esi].DirectTriEdge@@mDY              ; eax has (x2-x0)/(y2-y0) 
+	mov [esi].DirectTriEdge@@mDXLeft,eax						 ; this is mDXLeft
+	mov eax,[esi].DirectTriEdge@@mx1                 ; move x1 into eax
+	sub eax,[esi].DirectTriEdge@@mx0	  						 ; eax has (x1-x0)
+	shl eax,0Bh																			 ; multiply result by 2048 for precision
+	divide eax,[esi].DirectTriEdge@@mDY							 ; eax has (x1-x0)/(y2-y0)
+	mov [esi].DirectTriEdge@@mDXRight,eax						 ; this is mDXRight
+  mov eax,[esi].DirectTriEdge@@mu2                 ; move u2 into eax
+	sub eax,[esi].DirectTriEdge@@mu0								 ; eax has (u2-u0)
+	shl eax,0Bh																			 ; multiply result by 2048 for precision
+	divide eax,[esi].DirectTriEdge@@mDY              ; eax has (u2-u0)/(y2-y0)
+	mov [esi].DirectTriEdge@@mDULeft,eax             ; this is mDULeft
+	mov eax,[esi].DirectTriEdge@@mu1                 ; move u1 into eax
+	sub eax,[esi].DirectTriEdge@@mu0                 ; eax has (u1-u0)
+	shl eax,0Bh																			 ; multiply result by 2048 for precision
+	divide eax,[esi].DirectTriEdge@@mDY              ; eax has (u1-u0)/(y2-y0)
+	mov [esi].DirectTriEdge@@mDURight,eax            ; this is mDURight
+	mov eax,[esi].DirectTriEdge@@mv2                 ; move v2 into eax
+	sub eax,[esi].DirectTriEdge@@mv0                 ; eax has (v2-v0)
+	shl eax,0Bh                                      ; multiply result by 2048 for precision
+	divide eax,[esi].DirectTriEdge@@mDY              ; eax has (v2-v0)/(y2-y0)
+	mov [esi].DirectTriEdge@@mDVLeft,eax             ; this is mDVLeft
+  mov eax,[esi].DirectTriEdge@@mv1                 ; move v1 into eax
+	sub eax,[esi].DirectTriEdge@@mv0                 ; eax has (v1-v0)
+	shl eax,0Bh                                      ; multiply result by 2048 for precision
+	divide eax,[esi].DirectTriEdge@@mDY              ; eax has (v1-v0)/(y2-y0)
+	mov [esi].DirectTriEdge@@mDVRight,eax            ; this is mDVRight
+	mov eax,[esi].DirectTriEdge@@mx0                 ; move x0 into eax
+	mov [esi].DirectTriEdge@@mxLeft,eax              ; mxLeft=x0
+	mov [esi].DirectTriEdge@@mxRight,eax             ; mxRight=x0
+	mov eax,[esi].DirectTriEdge@@mu0                 ; move u0 into eax
+	mov [esi].DirectTriEdge@@muLeft,eax              ; muLeft=u0
+	mov [esi].DirectTriEdge@@muRight,eax             ; muRight=u0
+	mov eax,[esi].DirectTriEdge@@mv0                 ; move v0 into eax
+	mov [esi].DirectTriEdge@@mvLeft,eax              ; mvLeft=v0
+	mov [esi].DirectTriEdge@@mvRight,eax             ; mvRight=v0
+ENDM
+endif
+
+
+getSrcDataByte MACRO                               ; BYTE getSrcDataByte (ui,vi)
+LOCAL @@continue
+  mov ebx,vi                                       ; move column into ebx
+	cmp ebx,bmData@@mSrcWidth                        ; compare column to width
+	jge @@continue                                   ; if column greater than width, return
+	mov eax,ui                                       ; move row into eax
+	cmp eax,bmData@@mSrcHeight                       ; compare row to height
+	jge @@continue                                   ; if row greater than height, return
+	imul eax,bmData@@mSrcWidth                       ; multiply (row*width)->eax
+	add eax,bmData@@mSrcWidth                        ; add in the width
+	mov edx,bmData@@mSrcExtent                       ; move bitmap extent to edx
+	sub edx,eax                                      ; subtract (row*width)+width from extent
+	add edx,vi                                       ; now add in the column
+	mov ebx,bmData@@mlpSrcPtr                        ; move bitmap pointer into ebx
+	mov cl,byte ptr[ebx+edx]                         ; set the byte
+@@continue:
+ENDM
+if 0
+setDstDataByte MACRO												       ; setDstDataByte x,y,cl
+  mov ebx,y                                        ; move column into ebx
+	cmp ebx,bmData@@mDstWidth                        ; compare column to width
+	jge @@continue                                   ; if column greater than width, return
+	mov eax,x                                        ; move row into eax
+	cmp eax,bmData@@mDstHeight                       ; compare row to height
+	jge @@continue                                   ; if row greater than height, return
+	imul eax,bmData@@mDstWidth                       ; multiply (row*width)->eax
+	add eax,bmData@@mDstWidth                        ; add in the width
+	mov edx,bmData@@mDstExtent                       ; move bitmap extent to edx
+	sub edx,eax                                      ; subtract (row*width)+width from extent
+	add edx,y                                       ; now add in the column
+	mov ebx,bmData@@mlpDstPtr                        ; move bitmap pointer into ebx
+	mov byte ptr[ebx+edx],cl												 ; set the byte
+@@continue:
+ENDM
+endif
+
+setDstDataByte MACRO												       ; setDstDataByte x,y,cl
+  mov ebx,x                                        ; move column into ebx
+	cmp ebx,bmData@@mDstWidth                        ; compare column to width
+	jge @@continue                                   ; if column greater than width, return
+	mov eax,y                                        ; move row into eax
+	cmp eax,bmData@@mDstHeight                       ; compare row to height
+	jge @@continue                                   ; if row greater than height, return
+	imul eax,bmData@@mDstWidth                       ; multiply (row*width)->eax
+	add eax,bmData@@mDstWidth                        ; add in the width
+	mov edx,bmData@@mDstExtent                       ; move bitmap extent to edx
+	sub edx,eax                                      ; subtract (row*width)+width from extent
+	add edx,x                                       ; now add in the column
+	mov ebx,bmData@@mlpDstPtr                        ; move bitmap pointer into ebx
+	mov byte ptr[ebx+edx],cl												 ; set the byte
+@@continue:
+ENDM
+
+
+
+_directTriSetSrcBitmapInfo proc near ; void setSrcBitmapInfo(WORD width,WORD height,UHUGE *lpBitmapImage)
+	push  ebp                                        ; save old stack frame
+	mov   ebp,esp                                    ; create new stack frame
+	push  eax                                        ; save eax register
+	push  ebx                                        ; save ebx register
+	mov   eax,dword ptr[ebp+08h]                     ; move width into eax register
+	mov   bmData@@mSrcWidth,eax                      ; move width into bmData@@mSrcWidth
+	mov   ebx,dword ptr[ebp+0Ch]                     ; move height into ebx register
+	mov   bmData@@mSrcHeight,ebx                     ; move height into ebx register
+	imul eax,ebx                                     ; multiply width*height, result to eax
+	mov   bmData@@mSrcExtent,eax                     ; (width*height) to mSrcExtent
+	push  dword ptr[ebp+10h]                         ; save lpBitmapImage on stack
+	pop   bmData@@mlpSrcPtr                          ; restore in mlpSrcPtr
+	pop   ebx                                        ; restore ebx register
+	pop   eax                                        ; restore eax register
+	pop   ebp                                        ; restore old stack frame
+	retn                                             ; return near to caller
+_directTriSetSrcBitmapInfo endp
+_directTriSetDstBitmapInfo proc near    ; void setDstBitmapInfo(WORD width,WORD height,WORD pitch,UHUGE *lpBitmapImage)
+	push  ebp                                        ; save old stack frame
+	mov   ebp,esp                                    ; create new stack frame
+	push  eax                                        ; save eax register
+	push  ebx                                        ; save ebx register
+	mov   eax,dword ptr[ebp+10h]                     ; move pitch into eax register
+	mov   bmData@@mDstPitch,eax                      ; move pitch into mDstPitch
+	mov   eax,dword ptr[ebp+08h]                     ; move width into eeax register
+	mov   bmData@@mDstWidth,eax                      ; move width into mDstWidth
+	mov   ebx,dword ptr[ebp+0Ch]                     ; move height into ebx register
+	mov   bmData@@mDstHeight,ebx                     ; move height into mDstHeight
+	imul  eax,ebx                                    ; multiply width*height, result to eax
+	mov   bmData@@mDstExtent,eax                     ; move (width*height) into mDstExtent
+	push  dword ptr[ebp+14h]                         ; save lpBitmapImage on stack
+	pop   bmData@@mlpDstPtr                          ; restore in mlpDstPtr
+	pop   ebx                                        ; restore ebx register
+	pop   eax                                        ; restore eax register
+	pop   ebp                                        ; restore old stack frame
+	retn                                             ; return near to caller
+_directTriSetDstBitmapInfo endp
+
+_directTriMapTexture proc near                     ; void directTriMapTexture(DirectTriEdge *pEdge)
+LOCAL y:DWORD,x:DWORD,du:DWORD,dv:DWORD,ui:DWORD,vi:DWORD=LocalLength ; local variables for proc
+  push ebp                                         ; save prior stack frame
+	mov  ebp,esp                                     ; create new frame
+	sub esp,LocalLength                              ; make room for local variables
+	pushad                                           ; save all general purpose registers
+	mov esi,[ebp+08h]                                ; move pEdge to esi register
+	initialize                                       ; initialize the edge
+	mov eax,[esi].DirectTriEdge@@my0                 ; move y0 into eax
+	mov y,eax                                        ; initialize y with y0 
+@@verticalLoop:                                    ; beginning of vertical loop
+	mov ecx,[esi].DirectTriEdge@@my1                 ; move y1 into ecx
+	cmp y,ecx                                        ; compare y to y1
+	jg @@verticalLoopEnd                             ; if y>y1 then we're done
+	scanline                                         ; perform scanline on the horizontal
+	increment                                        ; increment along the vertical
+	jmp @@verticalLoop                               ; continue execution
+@@verticalLoopEnd:                                 ; end loop sync address
+  popad                                            ; restore all general purpose registers
+	add esp,LocalLength                              ; remove local variables from frame
+	pop  ebp                                         ; restore prior stack frame
+	retn                                             ; return near to caller
+_directTriMapTexture endp
+
+public _directTriSetSrcBitmapInfo
+public _directTriSetDstBitmapInfo
+public _directTriMapTexture
+END

ddraw/UTIL32.INC

@@ -0,0 +1,16 @@
+;********************************************************************************************************
+; FILE:UTIL32.INC
+; FUNCTION: INCLUDE FILE FOR MATH UTIL MACROS (DIRECT DRAW VERSION)
+; AUTHOR:SEAN M. KESSLER
+;********************************************************************************************************
+divide MACRO varOne,varTwo
+	mov    eax,varOne               ; move varOne into eax register
+	cdq                             ; convert doubleword in eax to quadword at edx:eax
+	idiv   varTwo                   ; divide eax/varTwo result to eax, remainder to edx
+ENDM
+multiply MACRO varOne,varTwo
+	movzx  eax,varOne               ; move varOne into eax register
+	movzx  edx,varTwo               ; move varTwo into ebx register
+	imul   eax,edx                  ; perform multiply, result to eax
+ENDM
+

ddraw/ddraw.001

@@ -0,0 +1,239 @@
+# Microsoft Developer Studio Project File - Name="ddraw" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 5.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+
+CFG=ddraw - Win32 Release
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "ddraw.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "ddraw.mak" CFG="ddraw - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "ddraw - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "ddraw - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE 
+
+# Begin Project
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "ddraw - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir ".\Release"
+# PROP BASE Intermediate_Dir ".\Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir ".\Release"
+# PROP Intermediate_Dir ".\Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+
+!ELSEIF  "$(CFG)" == "ddraw - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir ".\Debug"
+# PROP BASE Intermediate_Dir ".\Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ".\msvcobj"
+# PROP Intermediate_Dir ".\msvcobj"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /Zp1 /MTd /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /YX /FD /c
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib ddraw.lib c:\parts\mssdk\lib\dxguid.lib /nologo /subsystem:windows /debug /machine:I386
+
+!ENDIF 
+
+# Begin Target
+
+# Name "ddraw - Win32 Release"
+# Name "ddraw - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90"
+# Begin Source File
+
+SOURCE=.\devenum.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\direct3d.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\draw.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\drawsfc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\dspenum.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Main.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Mainwnd.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Exe\mscommon.lib
+# End Source File
+# Begin Source File
+
+SOURCE=..\Exe\msengine.lib
+# End Source File
+# Begin Source File
+
+SOURCE=.\palette.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\texture.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Tmap32.asm
+
+!IF  "$(CFG)" == "ddraw - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "ddraw - Win32 Debug"
+
+# Begin Custom Build
+IntDir=.\.\msvcobj
+InputPath=.\Tmap32.asm
+InputName=Tmap32
+
+"$(IntDir)\$(InputName).obj" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	c:\parts\tasm32\tasm32 /zi  /c  /ml  /m3 $(InputName).asm\
+ $(IntDir)\$(InputName).obj
+
+# End Custom Build
+
+!ENDIF 
+
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
+# Begin Source File
+
+SOURCE=.\bltfx.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Ddraw.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\devdesc.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\devenum.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\device3d.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\direct3d.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\draw.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\drawsfc.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\dspenum.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\error.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\mainwnd.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\palette.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\pixform.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\rowinfo.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\sfccaps.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\sfcdesc.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\surface.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\texture.hpp
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project

ddraw/ddraw.dsp

@@ -0,0 +1,239 @@
+# Microsoft Developer Studio Project File - Name="ddraw" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+
+CFG=ddraw - Win32 Release
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "ddraw.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "ddraw.mak" CFG="ddraw - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "ddraw - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "ddraw - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "ddraw - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir ".\Release"
+# PROP BASE Intermediate_Dir ".\Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir ".\Release"
+# PROP Intermediate_Dir ".\Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+
+!ELSEIF  "$(CFG)" == "ddraw - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir ".\Debug"
+# PROP BASE Intermediate_Dir ".\Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ".\msvcobj"
+# PROP Intermediate_Dir ".\msvcobj"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /Zp1 /MTd /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /YX /FD /c
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib ddraw.lib c:\parts\mssdk\lib\dxguid.lib /nologo /subsystem:windows /debug /machine:I386
+
+!ENDIF 
+
+# Begin Target
+
+# Name "ddraw - Win32 Release"
+# Name "ddraw - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90"
+# Begin Source File
+
+SOURCE=.\devenum.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\direct3d.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\draw.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\drawsfc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\dspenum.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Main.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Mainwnd.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\palette.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\texture.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Tmap32.asm
+
+!IF  "$(CFG)" == "ddraw - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "ddraw - Win32 Debug"
+
+# Begin Custom Build
+IntDir=.\msvcobj
+InputPath=.\Tmap32.asm
+InputName=Tmap32
+
+"$(IntDir)\$(InputName).obj" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	d:\parts\tasm32\tasm32 /zi  /c  /ml  /m3 $(InputName).asm  $(IntDir)\$(InputName).obj
+
+# End Custom Build
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\Exe\mscommon.lib
+# End Source File
+# Begin Source File
+
+SOURCE=..\Exe\msengine.lib
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
+# Begin Source File
+
+SOURCE=.\bltfx.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Ddraw.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\devdesc.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\devenum.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\device3d.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\direct3d.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\draw.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\drawsfc.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\dspenum.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\error.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\mainwnd.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\palette.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\pixform.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\rowinfo.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\sfccaps.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\sfcdesc.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\surface.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\texture.hpp
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project

dialog/DIALOG.BAK

@@ -0,0 +1,380 @@
+# Microsoft Developer Studio Generated NMAKE File, Format Version 4.20
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+!IF "$(CFG)" == ""
+CFG=dialog - Win32 Debug
+!MESSAGE No configuration specified.  Defaulting to dialog - Win32 Debug.
+!ENDIF 
+
+!IF "$(CFG)" != "dialog - Win32 Release" && "$(CFG)" != "dialog - Win32 Debug"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE on this makefile
+!MESSAGE by defining the macro CFG on the command line.  For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "Dialog.mak" CFG="dialog - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "dialog - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "dialog - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE 
+NULL=nul
+!ENDIF 
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "dialog - Win32 Debug"
+CPP=cl.exe
+
+!IF  "$(CFG)" == "dialog - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+OUTDIR=.\Release
+INTDIR=.\Release
+
+ALL : "$(OUTDIR)\Dialog.lib"
+
+CLEAN : 
+	-@erase "$(INTDIR)\Dlgtmpl.obj"
+	-@erase "$(INTDIR)\Dyndlg.obj"
+	-@erase "$(INTDIR)\Stdtmpl.obj"
+	-@erase "$(OUTDIR)\Dialog.lib"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+CPP_PROJ=/nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS"\
+ /Fp"$(INTDIR)/Dialog.pch" /YX /Fo"$(INTDIR)/" /c 
+CPP_OBJS=.\Release/
+CPP_SBRS=.\.
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/Dialog.bsc" 
+BSC32_SBRS= \
+	
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/Dialog.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)\Dlgtmpl.obj" \
+	"$(INTDIR)\Dyndlg.obj" \
+	"$(INTDIR)\Stdtmpl.obj"
+
+"$(OUTDIR)\Dialog.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "dialog - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "dialog__"
+# PROP BASE Intermediate_Dir "dialog__"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "msvcobj"
+# PROP Intermediate_Dir "msvcobj"
+# PROP Target_Dir ""
+OUTDIR=.\msvcobj
+INTDIR=.\msvcobj
+
+ALL : "..\exe\msdialog.lib"
+
+CLEAN : 
+	-@erase "$(INTDIR)\Dlgtmpl.obj"
+	-@erase "$(INTDIR)\Dyndlg.obj"
+	-@erase "$(INTDIR)\Stdtmpl.obj"
+	-@erase "..\exe\msdialog.lib"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /Zp1 /MTd /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /Fp"..\exe\msvc42.pch" /YX"windows.h" /c
+CPP_PROJ=/nologo /Zp1 /MTd /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D\
+ "__FLAT__" /D "STRICT" /Fp"..\exe\msvc42.pch" /YX"windows.h" /Fo"$(INTDIR)/" /c\
+ 
+CPP_OBJS=.\msvcobj/
+CPP_SBRS=.\.
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/Dialog.bsc" 
+BSC32_SBRS= \
+	
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\exe\msdialog.lib"
+LIB32_FLAGS=/nologo /out:"..\exe\msdialog.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)\Dlgtmpl.obj" \
+	"$(INTDIR)\Dyndlg.obj" \
+	"$(INTDIR)\Stdtmpl.obj"
+
+"..\exe\msdialog.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ENDIF 
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+################################################################################
+# Begin Target
+
+# Name "dialog - Win32 Release"
+# Name "dialog - Win32 Debug"
+
+!IF  "$(CFG)" == "dialog - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "dialog - Win32 Debug"
+
+!ENDIF 
+
+################################################################################
+# Begin Source File
+
+SOURCE=.\Stdtmpl.cpp
+
+!IF  "$(CFG)" == "dialog - Win32 Release"
+
+DEP_CPP_STDTM=\
+	{$(INCLUDE)}"\.\Dlgitem.hpp"\
+	{$(INCLUDE)}"\.\Dlgtmpl.hpp"\
+	{$(INCLUDE)}"\.\Dyndlg.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\Common\Dwindow.hpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	
+
+"$(INTDIR)\Stdtmpl.obj" : $(SOURCE) $(DEP_CPP_STDTM) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "dialog - Win32 Debug"
+
+DEP_CPP_STDTM=\
+	{$(INCLUDE)}"\.\Dlgitem.hpp"\
+	{$(INCLUDE)}"\.\Dlgtmpl.hpp"\
+	{$(INCLUDE)}"\.\Dyndlg.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\Common\Dwindow.hpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	
+
+"$(INTDIR)\Stdtmpl.obj" : $(SOURCE) $(DEP_CPP_STDTM) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Dyndlg.cpp
+
+!IF  "$(CFG)" == "dialog - Win32 Release"
+
+DEP_CPP_DYNDL=\
+	{$(INCLUDE)}"\.\Dlgitem.hpp"\
+	{$(INCLUDE)}"\.\Dlgtmpl.hpp"\
+	{$(INCLUDE)}"\.\Dyndlg.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\Common\Dwindow.hpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Widestr.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	
+
+"$(INTDIR)\Dyndlg.obj" : $(SOURCE) $(DEP_CPP_DYNDL) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "dialog - Win32 Debug"
+
+DEP_CPP_DYNDL=\
+	{$(INCLUDE)}"\.\Dlgitem.hpp"\
+	{$(INCLUDE)}"\.\Dlgtmpl.hpp"\
+	{$(INCLUDE)}"\.\Dyndlg.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\Common\Dwindow.hpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Widestr.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	
+
+"$(INTDIR)\Dyndlg.obj" : $(SOURCE) $(DEP_CPP_DYNDL) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Dlgtmpl.cpp
+
+!IF  "$(CFG)" == "dialog - Win32 Release"
+
+DEP_CPP_DLGTM=\
+	{$(INCLUDE)}"\.\Dlgitem.hpp"\
+	{$(INCLUDE)}"\.\Dlgtmpl.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Widestr.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Dlgtmpl.obj" : $(SOURCE) $(DEP_CPP_DLGTM) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "dialog - Win32 Debug"
+
+DEP_CPP_DLGTM=\
+	{$(INCLUDE)}"\.\Dlgitem.hpp"\
+	{$(INCLUDE)}"\.\Dlgtmpl.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Widestr.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Dlgtmpl.obj" : $(SOURCE) $(DEP_CPP_DLGTM) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+# End Target
+# End Project
+################################################################################

dialog/DIALOG.DSW

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

dialog/DIALOG.PLG

@@ -0,0 +1,27 @@
+--------------------Configuration: dialog - Win32 Debug--------------------
+Begining build with project "C:\work\DIALOG\dialog.dsp", at root.
+Active configuration is Win32 (x86) Static Library (based on Win32 (x86) Static Library)
+
+Project's tools are:
+			"32-bit C/C++ Compiler for 80x86" with flags "/nologo /Zp1 /MTd /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /Fp"..\exe\msvc42.pch" /YX"windows.h" /Fo".\msvcobj/" /Fd".\msvcobj/" /FD /c "
+			"Browser Database Maker" with flags "/nologo /o".\msvcobj/dialog.bsc" "
+			"Library Manager" with flags "/nologo /out:"..\exe\msdialog.lib" "
+			"Custom Build" with flags ""
+			"<Component 0xa>" with flags ""
+
+Creating temp file "C:\WINDOWS\TEMP\RSPC1E1.TMP" with contents </nologo /Zp1 /MTd /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /Fp"..\exe\msvc42.pch" /YX"windows.h" /Fo".\msvcobj/" /Fd".\msvcobj/" /FD /c 
+"C:\work\DIALOG\Dlgtmpl.cpp"
+"C:\work\DIALOG\Dyndlg.cpp"
+"C:\work\DIALOG\Stdtmpl.cpp"
+>
+Creating command line "cl.exe @C:\WINDOWS\TEMP\RSPC1E1.TMP" 
+Creating command line "link.exe -lib /nologo /out:"..\exe\msdialog.lib"  .\msvcobj\Dlgtmpl.obj .\msvcobj\Dyndlg.obj .\msvcobj\Stdtmpl.obj" 
+Compiling...
+Dlgtmpl.cpp
+Dyndlg.cpp
+Stdtmpl.cpp
+Creating library...
+
+
+
+msdialog.lib - 0 error(s), 0 warning(s)

dialog/DLGITEM.HPP

@@ -0,0 +1,155 @@
+#ifndef _DIALOG_DIALOGITEMTEMPLATE_HPP_
+#define _DIALOG_DIALOGITEMTEMPLATE_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_RECTANGLE_HPP_
+#include <common/rect.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+
+class DialogItemTemplate : private DLGITEMTEMPLATE
+{
+public:
+	DialogItemTemplate(void);
+	DialogItemTemplate(const DialogItemTemplate &someDialogItemTemplate);
+	~DialogItemTemplate();
+	DialogItemTemplate &operator=(const DialogItemTemplate &someDialogItemTemplate);
+	WORD operator==(const DialogItemTemplate &someDialogItemTemplate)const;
+	String className(void)const;
+	void className(const String &className);
+	String titleText(void)const;
+	void titleText(const String &titleText);
+	DWORD style(void)const;
+	void style(DWORD style);
+	DWORD extendedStyle(void)const;
+	void extendedStyle(DWORD extendedStyle);
+	Rect posRect(void)const;
+	void posRect(const Rect &posRect);
+	WORD itemID(void)const;
+  void itemID(WORD itemID);
+private:
+	String mClassName;
+  String mTitleText;
+};
+
+inline
+DialogItemTemplate::DialogItemTemplate(void)
+{
+	style(0);
+	extendedStyle(0);
+	posRect(Rect(0,0,0,0));
+  itemID(0);
+}
+
+inline
+DialogItemTemplate::DialogItemTemplate(const DialogItemTemplate &someDialogItemTemplate)
+{
+	*this=someDialogItemTemplate;
+}
+
+inline
+DialogItemTemplate::~DialogItemTemplate()
+{
+}
+
+inline
+DialogItemTemplate &DialogItemTemplate::operator=(const DialogItemTemplate &someDialogItemTemplate)
+{
+	style(someDialogItemTemplate.style());
+	extendedStyle(someDialogItemTemplate.extendedStyle());
+	posRect(someDialogItemTemplate.posRect());
+	itemID(someDialogItemTemplate.itemID());
+	className(someDialogItemTemplate.className());
+	titleText(someDialogItemTemplate.titleText());
+	return *this;
+}
+
+inline
+WORD DialogItemTemplate::operator==(const DialogItemTemplate &someDialogItemTemplate)const
+{
+	return (style()==someDialogItemTemplate.style()&&
+				 extendedStyle()==someDialogItemTemplate.extendedStyle()&&
+				 posRect()==someDialogItemTemplate.posRect()&&
+				 itemID()==someDialogItemTemplate.itemID()&&
+				 className()==someDialogItemTemplate.className()&&
+         titleText()==someDialogItemTemplate.titleText());
+}
+
+inline
+DWORD DialogItemTemplate::style(void)const
+{
+  return DLGITEMTEMPLATE::style;
+}
+
+inline
+void DialogItemTemplate::style(DWORD style)
+{
+	DLGITEMTEMPLATE::style=style;
+}
+
+inline
+DWORD DialogItemTemplate::extendedStyle(void)const
+{
+	return DLGITEMTEMPLATE::dwExtendedStyle;
+}
+
+inline
+void DialogItemTemplate::extendedStyle(DWORD extendedStyle)
+{
+  DLGITEMTEMPLATE::dwExtendedStyle=extendedStyle;
+}
+
+inline
+Rect DialogItemTemplate::posRect(void)const
+{
+	return Rect(DLGITEMTEMPLATE::x,DLGITEMTEMPLATE::y,DLGITEMTEMPLATE::cx,DLGITEMTEMPLATE::cy);
+}
+
+inline
+void DialogItemTemplate::posRect(const Rect &posRect)
+{
+	DLGITEMTEMPLATE::x=posRect.left();
+	DLGITEMTEMPLATE::y=posRect.top();
+	DLGITEMTEMPLATE::cx=posRect.right();
+	DLGITEMTEMPLATE::cy=posRect.bottom();
+}
+
+inline
+WORD DialogItemTemplate::itemID(void)const
+{
+	return DLGITEMTEMPLATE::id;
+}
+
+inline
+void DialogItemTemplate::itemID(WORD itemID)
+{
+	DLGITEMTEMPLATE::id=itemID;
+}
+
+inline
+String DialogItemTemplate::className(void)const
+{
+	return mClassName;
+}
+
+inline
+void DialogItemTemplate::className(const String &className)
+{
+  mClassName=className;
+}
+
+inline
+String DialogItemTemplate::titleText(void)const
+{
+	return mTitleText;
+}
+
+inline
+void DialogItemTemplate::titleText(const String &titleText)
+{
+	mTitleText=titleText;
+}
+#endif

dialog/DLGTMPL.CPP

@@ -0,0 +1,56 @@
+#include <common/widestr.hpp>
+#include <dialog/dlgtmpl.hpp>
+
+DialogTemplate::operator DLGTEMPLATE *(void)
+{
+	DLGTEMPLATE *lpDLGTEMPLATE=0;
+	DLGITEMTEMPLATE *lpDLGITEMTEMPLATE;
+	BYTE *lpCharByte;
+	DWORD sizeData;
+
+	if(!itemCount())return lpDLGTEMPLATE;
+  sizeData=MaxTemplateBytes;
+	mItemData.size(sizeData,GMEM_FIXED|GMEM_ZEROINIT);
+	lpDLGTEMPLATE=(DLGTEMPLATE*)((BYTE*)&mItemData[0]);
+	::memcpy(lpDLGTEMPLATE,&((DLGTEMPLATE&)*this),sizeof(DLGTEMPLATE));
+	lpCharByte=((BYTE*)lpDLGTEMPLATE)+sizeof(DLGTEMPLATE);
+	*((WORD*)lpCharByte)=0x0000;  // no menu
+	lpCharByte+=sizeof(WORD);
+	if(className().isNull()){*((WORD*)lpCharByte)=0x0000;lpCharByte+=sizeof(WORD);}
+	else lpCharByte=copyString(lpCharByte,className());
+  if(titleText().isNull()){*((WORD*)lpCharByte)=0x0000;lpCharByte+=sizeof(WORD);}  
+	else lpCharByte=copyString(lpCharByte,titleText());
+	if(style()&DS_SETFONT)
+	{
+		*((WORD*)lpCharByte)=pointSize();
+		lpCharByte+=sizeof(WORD);
+    lpCharByte=copyString(lpCharByte,typeFace());
+  }
+	lpCharByte=alignBoundary(lpCharByte);
+	lpDLGITEMTEMPLATE=(DLGITEMTEMPLATE*)lpCharByte;
+	for(short itemIndex=0;itemIndex<itemCount();itemIndex++)
+	{
+		DialogItemTemplate dlgItem(mDlgItems[itemIndex]);
+    if(dlgItem.className().isNull())continue;
+		::memcpy(lpDLGITEMTEMPLATE,&dlgItem,sizeof(DLGITEMTEMPLATE));
+		lpCharByte=((BYTE*)lpDLGITEMTEMPLATE)+sizeof(DLGITEMTEMPLATE);
+		lpCharByte=copyString(lpCharByte,dlgItem.className());
+    lpCharByte=copyString(lpCharByte,dlgItem.titleText());
+		*((WORD*)lpCharByte)=0;
+		lpCharByte+=sizeof(WORD);
+    lpCharByte=alignBoundary(lpCharByte);
+    lpDLGITEMTEMPLATE=(DLGITEMTEMPLATE*)lpCharByte;
+	}
+	return lpDLGTEMPLATE;
+}
+
+BYTE *DialogTemplate::copyString(BYTE *lpCharByte,const String &someString)const
+{
+	WideString wideString(someString);
+	if(!wideString.size())return lpCharByte;
+	for(short itemIndex=0;itemIndex<wideString.size();itemIndex++)
+		((WORD*)lpCharByte)[itemIndex]=(WORD)wideString.operator[](itemIndex);
+	lpCharByte+=wideString.size()*sizeof(WORD);
+	return lpCharByte;
+}
+

dialog/DLGTMPL.HPP

@@ -0,0 +1,228 @@
+#ifndef _DIALOG_DIALOGTEMPLATE_HPP_
+#define _DIALOG_DIALOGTEMPLATE_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_RECTANGLE_HPP_
+#include <common/rect.hpp>
+#endif
+#ifndef _COMMON_GLOBALDATA_HPP_
+#include <common/gdata.hpp>
+#endif
+#ifndef _COMMON_BLOCK_HPP_
+#include <common/block.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _DIALOG_DIALOGITEMTEMPLATE_HPP_
+#include <dialog/dlgitem.hpp>
+#endif
+
+class DialogTemplate : private DLGTEMPLATE
+{
+public:
+	DialogTemplate(void);
+	DialogTemplate(const DialogTemplate &someDialogTemplate);
+	~DialogTemplate();
+	DialogTemplate &operator=(const DialogTemplate &someDialogTemplate);
+	WORD operator==(const DialogTemplate &someDialogTemplate)const;
+  operator DLGTEMPLATE *(void);
+	DialogTemplate &operator+=(const DialogItemTemplate &someDialogItemTemplate);
+	DWORD style(void)const;
+	void style(DWORD style);
+	DWORD extendedStyle(void)const;
+	void extendedStyle(DWORD extendedStyle);
+	Rect posRect(void)const;
+	void posRect(const Rect &posRect);
+	WORD itemCount(void)const;
+	String className(void)const;
+	void className(const String &className);
+	String titleText(void)const;
+	void titleText(const String &titleText);
+	String typeFace(void)const;
+	void typeFace(const String &typeFace);
+	WORD pointSize(void)const;
+	void pointSize(WORD pointSize);
+private:
+  enum{MaxTemplateBytes=16384};
+	void itemCount(WORD itemCount);
+	BYTE *alignBoundary(BYTE *lpCharByte)const;
+  BYTE *copyString(BYTE *lpCharByte,const String &someString)const;
+	Block<DialogItemTemplate> mDlgItems;
+	GlobalData<BYTE> mItemData;
+  WORD mPointSize;
+	String mClassName;
+	String mTitleText;
+  String mTypeFace;
+};
+
+inline
+DialogTemplate::DialogTemplate(void)
+{
+	style(0);
+	extendedStyle(0);
+	itemCount(0);
+	posRect(Rect(0,0,0,0));
+  pointSize(0);
+}
+
+inline
+DialogTemplate::DialogTemplate(const DialogTemplate &someDialogTemplate)
+{
+  pointSize(0);
+  *this=someDialogTemplate;
+}
+
+inline
+DialogTemplate::~DialogTemplate()
+{
+}
+
+inline
+DialogTemplate &DialogTemplate::operator=(const DialogTemplate &someDialogTemplate)
+{
+	style(someDialogTemplate.style());
+	extendedStyle(someDialogTemplate.extendedStyle());
+	itemCount(someDialogTemplate.itemCount());
+	className(someDialogTemplate.className());
+  titleText(someDialogTemplate.titleText());
+	posRect(someDialogTemplate.posRect());
+	pointSize(someDialogTemplate.pointSize());
+  typeFace(someDialogTemplate.typeFace());
+  return *this;
+}
+
+inline
+WORD DialogTemplate::operator==(const DialogTemplate &someDialogTemplate)const
+{
+	return (style()==someDialogTemplate.style()&&
+					extendedStyle()==someDialogTemplate.extendedStyle()&&
+					itemCount()==someDialogTemplate.itemCount()&&
+					className()==someDialogTemplate.className()&&
+          titleText()==someDialogTemplate.titleText()&&
+					posRect()==someDialogTemplate.posRect()&&
+					pointSize()==someDialogTemplate.pointSize()&&
+          typeFace()==someDialogTemplate.typeFace());
+}
+
+inline
+DialogTemplate &DialogTemplate::operator+=(const DialogItemTemplate &someDialogItemTemplate)
+{
+	mDlgItems.insert(&someDialogItemTemplate);
+	itemCount(itemCount()+1);
+  return *this;
+}
+
+inline
+DWORD DialogTemplate::style(void)const
+{
+	return DLGTEMPLATE::style;
+}
+
+inline
+void DialogTemplate::style(DWORD style)
+{
+	DLGTEMPLATE::style=style;
+}
+
+inline
+DWORD DialogTemplate::extendedStyle(void)const
+{
+	return DLGTEMPLATE::dwExtendedStyle;
+}
+
+inline
+void DialogTemplate::extendedStyle(DWORD extendedStyle)
+{
+  DLGTEMPLATE::dwExtendedStyle=extendedStyle;
+}
+
+inline
+WORD DialogTemplate::itemCount(void)const
+{
+  return DLGTEMPLATE::cdit;
+}
+
+inline
+void DialogTemplate::itemCount(WORD itemCount)
+{
+  DLGTEMPLATE::cdit=itemCount;
+}
+
+inline
+Rect DialogTemplate::posRect(void)const
+{
+  return Rect(DLGTEMPLATE::x,DLGTEMPLATE::y,DLGTEMPLATE::cx,DLGTEMPLATE::cy);
+}
+
+inline
+void DialogTemplate::posRect(const Rect &posRect)
+{
+	DLGTEMPLATE::x=posRect.left();
+	DLGTEMPLATE::y=posRect.top();
+	DLGTEMPLATE::cx=posRect.right();
+	DLGTEMPLATE::cy=posRect.bottom();
+}
+
+inline
+String DialogTemplate::className(void)const
+{
+	return mClassName;
+}
+
+inline
+void DialogTemplate::className(const String &className)
+{
+	mClassName=className;
+}
+
+inline
+String DialogTemplate::titleText(void)const
+{
+	return mTitleText;
+}
+
+inline
+void DialogTemplate::titleText(const String &titleText)
+{
+	mTitleText=titleText;
+}
+
+inline
+String DialogTemplate::typeFace(void)const
+{
+	return mTypeFace;
+}
+
+inline
+void DialogTemplate::typeFace(const String &typeFace)
+{
+  mTypeFace=typeFace;
+}
+
+inline
+WORD DialogTemplate::pointSize(void)const
+{
+	return mPointSize;
+}
+
+inline
+void DialogTemplate::pointSize(WORD pointSize)
+{
+  mPointSize=pointSize;
+}
+
+inline
+BYTE *DialogTemplate::alignBoundary(BYTE *lpCharByte)const
+{
+	WORD *lpWORD=((WORD*)lpCharByte);
+	ULONG align;
+
+	align=(ULONG)lpWORD;
+	align+=3;
+	align>>=2;
+	align<<=2;
+	return (BYTE*)align;
+}
+#endif

dialog/DYNDLG.BAK

@@ -0,0 +1,85 @@
+#ifndef _DIALOG_DYNAMICDIALOG_HPP_
+#define _DIALOG_DYNAMICDIALOG_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_DWINDOW_HPP_
+#include <common/dwindow.hpp>
+#endif
+#ifndef _COMMON_CALLBACK_HPP_
+#include <common/callback.hpp>
+#endif
+#ifndef _DIALOG_DIALOGITEMTEMPLATE_HPP_
+#include <dialog/dlgitem.hpp>
+#endif
+#ifndef _DIALOG_DIALOGTEMPLATE_HPP_
+#include <dialog/dlgtmpl.hpp>
+#endif
+
+class DynamicDialog : public DWindow
+{
+public:
+  enum DialogType{ModalDialog,ModelessDialog};
+	DynamicDialog(void);
+	virtual ~DynamicDialog();
+	void createDialog(HWND hParentWnd,DialogTemplate &someDialogTemplate,DialogType typeDialog=ModalDialog);
+	void createDialog(DialogTemplate &someDialogTemplate,DialogType typeDialog=ModalDialog);
+protected:
+	virtual WORD dlgCommand(DWORD commandID,CallbackData &someCallbackData);
+	virtual void dlgInitDialog(CallbackData &someCallbackData);
+	virtual void dlgDestroyDialog(CallbackData &someCallbackData);
+private:
+  DynamicDialog(const DynamicDialog &someDynamicDialog);
+  CallbackData::ReturnType initDialogHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType closeHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType destroyHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType dialogCodeHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType commandHandler(CallbackData &someCallbackData);
+	Callback<DynamicDialog> mInitDialogHandler;
+	Callback<DynamicDialog> mCloseHandler;
+	Callback<DynamicDialog> mDestroyHandler;
+	Callback<DynamicDialog> mDialogCodeHandler;
+	Callback<DynamicDialog> mCommandHandler;
+};
+
+inline
+DynamicDialog::DynamicDialog(void)
+: mDestroyHandler(this,&DynamicDialog::destroyHandler),
+	mInitDialogHandler(this,&DynamicDialog::initDialogHandler),
+	mCloseHandler(this,&DynamicDialog::closeHandler),
+	mDialogCodeHandler(this,&DynamicDialog::dialogCodeHandler),
+	mCommandHandler(this,&DynamicDialog::commandHandler)
+{
+	insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	insertHandler(VectorHandler::InitDialogHandler,&mInitDialogHandler);
+	insertHandler(VectorHandler::CloseHandler,&mCloseHandler);
+	insertHandler(VectorHandler::DialogCodeHandler,&mDialogCodeHandler);
+	insertHandler(VectorHandler::CommandHandler,&mCommandHandler);
+}
+
+inline
+DynamicDialog::DynamicDialog(const DynamicDialog &someDynamicDialog)
+: mDestroyHandler(this,&DynamicDialog::destroyHandler),
+	mInitDialogHandler(this,&DynamicDialog::initDialogHandler),
+	mCloseHandler(this,&DynamicDialog::closeHandler),
+	mDialogCodeHandler(this,&DynamicDialog::dialogCodeHandler),
+	mCommandHandler(this,&DynamicDialog::commandHandler)
+{
+	insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	insertHandler(VectorHandler::InitDialogHandler,&mInitDialogHandler);
+  insertHandler(VectorHandler::CloseHandler,&mCloseHandler);
+  insertHandler(VectorHandler::DialogCodeHandler,&mDialogCodeHandler);
+	insertHandler(VectorHandler::CommandHandler,&mCommandHandler);
+}
+
+inline
+DynamicDialog::~DynamicDialog()
+{
+	removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	removeHandler(VectorHandler::InitDialogHandler,&mInitDialogHandler);
+	removeHandler(VectorHandler::CloseHandler,&mCloseHandler);
+	removeHandler(VectorHandler::DialogCodeHandler,&mDialogCodeHandler);
+	removeHandler(VectorHandler::CommandHandler,&mCommandHandler);
+}
+#endif
+

dialog/DYNDLG.CPP

@@ -0,0 +1,104 @@
+#include <dialog/dyndlg.hpp>
+#include <common/widestr.hpp>
+
+DynamicDialog::DynamicDialog(void)
+{
+  mDestroyHandler.setCallback(this,&DynamicDialog::destroyHandler);
+	mInitDialogHandler.setCallback(this,&DynamicDialog::initDialogHandler);
+	mCloseHandler.setCallback(this,&DynamicDialog::closeHandler);
+	mDialogCodeHandler.setCallback(this,&DynamicDialog::dialogCodeHandler);
+	mCommandHandler.setCallback(this,&DynamicDialog::commandHandler);
+	insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	insertHandler(VectorHandler::InitDialogHandler,&mInitDialogHandler);
+	insertHandler(VectorHandler::CloseHandler,&mCloseHandler);
+	insertHandler(VectorHandler::DialogCodeHandler,&mDialogCodeHandler);
+	insertHandler(VectorHandler::CommandHandler,&mCommandHandler);
+}
+
+DynamicDialog::DynamicDialog(const DynamicDialog &someDynamicDialog)
+{
+  mDestroyHandler.setCallback(this,&DynamicDialog::destroyHandler);
+	mInitDialogHandler.setCallback(this,&DynamicDialog::initDialogHandler);
+	mCloseHandler.setCallback(this,&DynamicDialog::closeHandler);
+	mDialogCodeHandler.setCallback(this,&DynamicDialog::dialogCodeHandler);
+	mCommandHandler.setCallback(this,&DynamicDialog::commandHandler);
+	insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	insertHandler(VectorHandler::InitDialogHandler,&mInitDialogHandler);
+  insertHandler(VectorHandler::CloseHandler,&mCloseHandler);
+  insertHandler(VectorHandler::DialogCodeHandler,&mDialogCodeHandler);
+	insertHandler(VectorHandler::CommandHandler,&mCommandHandler);
+}
+
+DynamicDialog::~DynamicDialog()
+{
+	removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	removeHandler(VectorHandler::InitDialogHandler,&mInitDialogHandler);
+	removeHandler(VectorHandler::CloseHandler,&mCloseHandler);
+	removeHandler(VectorHandler::DialogCodeHandler,&mDialogCodeHandler);
+	removeHandler(VectorHandler::CommandHandler,&mCommandHandler);
+}
+
+void DynamicDialog::createDialog(HWND hParent,DialogTemplate &someDialogTemplate,DialogType typeDialog)
+{
+	HINSTANCE hInstance((HINSTANCE)::GetWindowLong(hParent,GWL_HINSTANCE));
+	if(ModalDialog==typeDialog)::DialogBoxIndirectParam(hInstance,(DLGTEMPLATE*)someDialogTemplate,hParent,DWindow::DlgProc,(LONG)(LPSTR)(DWindow*)this);
+  else if(!isValid())::CreateDialogIndirectParam(hInstance,(DLGTEMPLATE*)someDialogTemplate,hParent,DWindow::DlgProc,(LONG)(LPSTR)(DWindow*)this);
+}
+
+void DynamicDialog::createDialog(DialogTemplate &someDialogTemplate,DialogType typeDialog)
+{
+	if(ModalDialog==typeDialog)::DialogBoxIndirectParam(processInstance(),(DLGTEMPLATE*)someDialogTemplate,(HWND)0,DWindow::DlgProc,(LONG)(LPSTR)(DWindow*)this);
+  else if(!isValid())::CreateDialogIndirectParam(processInstance(),(DLGTEMPLATE*)someDialogTemplate,(HWND)0,DWindow::DlgProc,(LONG)(LPSTR)(DWindow*)this); 
+}
+
+CallbackData::ReturnType DynamicDialog::closeHandler(CallbackData &/*someCallbackData*/)
+{
+	destroy();
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType DynamicDialog::destroyHandler(CallbackData &someCallbackData)
+{
+  dlgDestroyDialog(someCallbackData);
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType DynamicDialog::initDialogHandler(CallbackData &someCallbackData)
+{
+	return dlgInitDialog(someCallbackData);
+}
+
+CallbackData::ReturnType DynamicDialog::commandHandler(CallbackData &someCallbackData)
+{
+  WORD cmdReturn(dlgCommand(someCallbackData.wmCommandID(),someCallbackData));
+	if(IDCANCEL==someCallbackData.wmCommandID()&&!cmdReturn)endDialog(FALSE); 
+	else if(IDOK==someCallbackData.wmCommandID()&&!cmdReturn)endDialog(TRUE);
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType DynamicDialog::dialogCodeHandler(CallbackData &someCallbackData)
+{
+  return dlgCode(someCallbackData);
+}
+
+// *** virtuals
+
+WORD DynamicDialog::dlgCommand(DWORD /*commandID*/,CallbackData &/*someCallbackData*/)
+{
+  return FALSE;
+}
+
+WORD DynamicDialog::dlgCode(CallbackData &/*someCallbackData*/)
+{
+  return DLGC_WANTTAB;
+}
+
+BOOL DynamicDialog::dlgInitDialog(CallbackData &/*someCallbackData*/)
+{
+  return TRUE;
+}
+
+void DynamicDialog::dlgDestroyDialog(CallbackData &/*someCallbackData*/)
+{
+}
+

dialog/DYNDLG.HPP

@@ -0,0 +1,46 @@
+#ifndef _DIALOG_DYNAMICDIALOG_HPP_
+#define _DIALOG_DYNAMICDIALOG_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_DWINDOW_HPP_
+#include <common/dwindow.hpp>
+#endif
+#ifndef _COMMON_CALLBACK_HPP_
+#include <common/callback.hpp>
+#endif
+#ifndef _DIALOG_DIALOGITEMTEMPLATE_HPP_
+#include <dialog/dlgitem.hpp>
+#endif
+#ifndef _DIALOG_DIALOGTEMPLATE_HPP_
+#include <dialog/dlgtmpl.hpp>
+#endif
+
+class DynamicDialog : public DWindow
+{
+public:
+  enum DialogType{ModalDialog,ModelessDialog};
+	DynamicDialog(void);
+	virtual ~DynamicDialog();
+	void createDialog(HWND hParentWnd,DialogTemplate &someDialogTemplate,DialogType typeDialog=ModalDialog);
+	void createDialog(DialogTemplate &someDialogTemplate,DialogType typeDialog=ModalDialog);
+protected:
+	virtual WORD dlgCommand(DWORD commandID,CallbackData &someCallbackData);
+	virtual WORD dlgCode(CallbackData &someCallbackData);
+	virtual BOOL dlgInitDialog(CallbackData &someCallbackData);
+	virtual void dlgDestroyDialog(CallbackData &someCallbackData);
+private:
+  DynamicDialog(const DynamicDialog &someDynamicDialog);
+  CallbackData::ReturnType initDialogHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType closeHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType destroyHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType dialogCodeHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType commandHandler(CallbackData &someCallbackData);
+	Callback<DynamicDialog> mInitDialogHandler;
+	Callback<DynamicDialog> mCloseHandler;
+	Callback<DynamicDialog> mDestroyHandler;
+	Callback<DynamicDialog> mDialogCodeHandler;
+	Callback<DynamicDialog> mCommandHandler;
+};
+#endif
+

dialog/Dialog.001

@@ -0,0 +1,114 @@
+# Microsoft Developer Studio Project File - Name="dialog" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 5.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=dialog - Win32 Release
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "dialog.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "dialog.mak" CFG="dialog - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "dialog - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "dialog - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+
+!IF  "$(CFG)" == "dialog - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir ".\Release"
+# PROP BASE Intermediate_Dir ".\Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir ".\Release"
+# PROP Intermediate_Dir ".\Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ELSEIF  "$(CFG)" == "dialog - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir ".\dialog__"
+# PROP BASE Intermediate_Dir ".\dialog__"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ".\msvcobj"
+# PROP Intermediate_Dir ".\msvcobj"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /Zp1 /MTd /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /Fp"..\exe\msvc42.pch" /YX"windows.h" /FD /c
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\exe\msdialog.lib"
+
+!ENDIF 
+
+# Begin Target
+
+# Name "dialog - Win32 Release"
+# Name "dialog - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90"
+# Begin Source File
+
+SOURCE=.\Dlgtmpl.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Dyndlg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Stdtmpl.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
+# Begin Source File
+
+SOURCE=.\Dlgitem.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Dlgtmpl.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Dyndlg.hpp
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project

dialog/Dialog.dsp

@@ -0,0 +1,120 @@
+# Microsoft Developer Studio Project File - Name="dialog" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=dialog - Win32 Release
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "Dialog.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "Dialog.mak" CFG="dialog - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "dialog - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "dialog - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "dialog - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir ".\Release"
+# PROP BASE Intermediate_Dir ".\Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir ".\Release"
+# PROP Intermediate_Dir ".\Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MT /GX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /YX /FD /c
+# ADD BASE RSC /l 0x409
+# ADD RSC /l 0x409
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ELSEIF  "$(CFG)" == "dialog - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir ".\dialog__"
+# PROP BASE Intermediate_Dir ".\dialog__"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ".\msvcobj"
+# PROP Intermediate_Dir ".\msvcobj"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /Gz /MTd /Zi /Od /D "_DEBUG" /D "__FLAT__" /D "STRICT" /D "WIN32" /D "_WINDOWS" /Fp"..\exe\msvc42.pch" /YX"windows.h" /FD /c
+# ADD BASE RSC /l 0x409
+# ADD RSC /l 0x409
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\exe\msdialog.lib"
+
+!ENDIF 
+
+# Begin Target
+
+# Name "dialog - Win32 Release"
+# Name "dialog - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90"
+# Begin Source File
+
+SOURCE=.\Dlgtmpl.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Dyndlg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Stdtmpl.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
+# Begin Source File
+
+SOURCE=.\Dlgitem.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Dlgtmpl.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Dyndlg.hpp
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project

dialog/Dialog.mak

@@ -0,0 +1,380 @@
+# Microsoft Developer Studio Generated NMAKE File, Format Version 4.20
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+!IF "$(CFG)" == ""
+CFG=dialog - Win32 Debug
+!MESSAGE No configuration specified.  Defaulting to dialog - Win32 Debug.
+!ENDIF 
+
+!IF "$(CFG)" != "dialog - Win32 Release" && "$(CFG)" != "dialog - Win32 Debug"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE on this makefile
+!MESSAGE by defining the macro CFG on the command line.  For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "Dialog.mak" CFG="dialog - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "dialog - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "dialog - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE 
+NULL=nul
+!ENDIF 
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "dialog - Win32 Debug"
+CPP=cl.exe
+
+!IF  "$(CFG)" == "dialog - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+OUTDIR=.\Release
+INTDIR=.\Release
+
+ALL : "$(OUTDIR)\Dialog.lib"
+
+CLEAN : 
+	-@erase "$(INTDIR)\Dlgtmpl.obj"
+	-@erase "$(INTDIR)\Dyndlg.obj"
+	-@erase "$(INTDIR)\Stdtmpl.obj"
+	-@erase "$(OUTDIR)\Dialog.lib"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+CPP_PROJ=/nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS"\
+ /Fp"$(INTDIR)/Dialog.pch" /YX /Fo"$(INTDIR)/" /c 
+CPP_OBJS=.\Release/
+CPP_SBRS=.\.
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/Dialog.bsc" 
+BSC32_SBRS= \
+	
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/Dialog.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)\Dlgtmpl.obj" \
+	"$(INTDIR)\Dyndlg.obj" \
+	"$(INTDIR)\Stdtmpl.obj"
+
+"$(OUTDIR)\Dialog.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "dialog - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "dialog__"
+# PROP BASE Intermediate_Dir "dialog__"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "msvcobj"
+# PROP Intermediate_Dir "msvcobj"
+# PROP Target_Dir ""
+OUTDIR=.\msvcobj
+INTDIR=.\msvcobj
+
+ALL : "..\exe\msdialog.lib"
+
+CLEAN : 
+	-@erase "$(INTDIR)\Dlgtmpl.obj"
+	-@erase "$(INTDIR)\Dyndlg.obj"
+	-@erase "$(INTDIR)\Stdtmpl.obj"
+	-@erase "..\exe\msdialog.lib"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /Zp1 /MTd /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /Fp"..\exe\msvc42.pch" /YX"windows.h" /c
+CPP_PROJ=/nologo /Zp1 /MTd /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D\
+ "__FLAT__" /D "STRICT" /Fp"..\exe\msvc42.pch" /YX"windows.h" /Fo"$(INTDIR)/" /c\
+ 
+CPP_OBJS=.\msvcobj/
+CPP_SBRS=.\.
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/Dialog.bsc" 
+BSC32_SBRS= \
+	
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\exe\msdialog.lib"
+LIB32_FLAGS=/nologo /out:"..\exe\msdialog.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)\Dlgtmpl.obj" \
+	"$(INTDIR)\Dyndlg.obj" \
+	"$(INTDIR)\Stdtmpl.obj"
+
+"..\exe\msdialog.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ENDIF 
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+################################################################################
+# Begin Target
+
+# Name "dialog - Win32 Release"
+# Name "dialog - Win32 Debug"
+
+!IF  "$(CFG)" == "dialog - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "dialog - Win32 Debug"
+
+!ENDIF 
+
+################################################################################
+# Begin Source File
+
+SOURCE=.\Stdtmpl.cpp
+
+!IF  "$(CFG)" == "dialog - Win32 Release"
+
+DEP_CPP_STDTM=\
+	{$(INCLUDE)}"\.\Dlgitem.hpp"\
+	{$(INCLUDE)}"\.\Dlgtmpl.hpp"\
+	{$(INCLUDE)}"\.\Dyndlg.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\Common\Dwindow.hpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	
+
+"$(INTDIR)\Stdtmpl.obj" : $(SOURCE) $(DEP_CPP_STDTM) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "dialog - Win32 Debug"
+
+DEP_CPP_STDTM=\
+	{$(INCLUDE)}"\.\Dlgitem.hpp"\
+	{$(INCLUDE)}"\.\Dlgtmpl.hpp"\
+	{$(INCLUDE)}"\.\Dyndlg.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\Common\Dwindow.hpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	
+
+"$(INTDIR)\Stdtmpl.obj" : $(SOURCE) $(DEP_CPP_STDTM) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Dyndlg.cpp
+
+!IF  "$(CFG)" == "dialog - Win32 Release"
+
+DEP_CPP_DYNDL=\
+	{$(INCLUDE)}"\.\Dlgitem.hpp"\
+	{$(INCLUDE)}"\.\Dlgtmpl.hpp"\
+	{$(INCLUDE)}"\.\Dyndlg.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\Common\Dwindow.hpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Widestr.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	
+
+"$(INTDIR)\Dyndlg.obj" : $(SOURCE) $(DEP_CPP_DYNDL) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "dialog - Win32 Debug"
+
+DEP_CPP_DYNDL=\
+	{$(INCLUDE)}"\.\Dlgitem.hpp"\
+	{$(INCLUDE)}"\.\Dlgtmpl.hpp"\
+	{$(INCLUDE)}"\.\Dyndlg.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\Common\Dwindow.hpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Widestr.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	
+
+"$(INTDIR)\Dyndlg.obj" : $(SOURCE) $(DEP_CPP_DYNDL) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Dlgtmpl.cpp
+
+!IF  "$(CFG)" == "dialog - Win32 Release"
+
+DEP_CPP_DLGTM=\
+	{$(INCLUDE)}"\.\Dlgitem.hpp"\
+	{$(INCLUDE)}"\.\Dlgtmpl.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Widestr.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Dlgtmpl.obj" : $(SOURCE) $(DEP_CPP_DLGTM) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "dialog - Win32 Debug"
+
+DEP_CPP_DLGTM=\
+	{$(INCLUDE)}"\.\Dlgitem.hpp"\
+	{$(INCLUDE)}"\.\Dlgtmpl.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Widestr.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Dlgtmpl.obj" : $(SOURCE) $(DEP_CPP_DLGTM) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+# End Target
+# End Project
+################################################################################

dialog/STDTMPL.CPP

@@ -0,0 +1,14 @@
+#ifndef _MSC_VER
+#define _EXPAND_VECTOR_TEMPLATES_
+#define _EXPAND_BLOCK_TEMPLATES_
+#include <common/pvector.hpp>
+#include <common/pvector.tpp>
+#include <common/block.hpp>
+#include <common/block.tpp>
+#include <common/callback.hpp>
+#include <common/callback.tpp>
+#include <dialog/dyndlg.hpp>
+
+typedef Block<DialogItemTemplate> g;
+#endif
+

docs/ABBOTT.TXT

@@ -0,0 +1,20 @@
+Tuesday July 14, 1998
+
+This morning as I was leaving the house for work I found Abbott on the
+front lawn.  He was dead.  He was not visibly bruised and I could see
+no signs that he had been in a fight, except for a trickle of blood on
+his front lip.  I suppose he might have been hit by a car and managed
+to work his way back onto the property where he just layed down and died.
+I suppose it might also have been something he ate, though it would have
+to be some potent poison for it to kill him in such a short period of
+time, I had just seen him the night before.  Needless to say, I am
+very upset about Abbotts death.  Moreso that it comes a year and seven
+months after Costello (his brother) passed away.  I took that pretty hard
+as well.  This is the last chapter of my tale of the two kittens that
+strolled onto the back deck in the summer months of 1996.  I loved them
+both and cherished them and I can only hope that they are together in
+heaven chasing down mice and romping around.  I love you Abbott and I
+love you Costello.  I will never know where you came from or why you were
+both taken so early in life.
+
+