CEOSSPropertySheet::CEOSSPropertySheet(
UINT nIDCaption,
CEOSSInstrument* pParentWnd)
:CPropertySheet(nIDCaption, pParentWnd, 0),
m_pParent(pParentWnd)
{
m_pCaption[0] = NULL;
FinishConstruction();
}
CEOSSPropertySheet::CEOSSPropertySheet(
LPCTSTR pszCaption,
CEOSSInstrument* pParentWnd)
:CPropertySheet(pszCaption, pParentWnd, 0),
m_pParent(pParentWnd)
{
strcpy(m_pCaption,pszCaption);
FinishConstruction();
}
//////////////////////////////////////////////////////////////////////////////
// DDSurfaceImpl() - constructor 1.
// Create a video memory surface
//////////////////////////////////////////////////////////////////////////////
DDSurfaceImpl( DDDevice* pdddevice,
SurfaceType stype,
PixelFormat* ppf,
PrivatePalette* ppalette,
const WinPoint& size ) :
m_pdddevice(pdddevice),
m_pengine(pdddevice->GetEngine()),
m_stype(stype),
m_ppalette(ppalette),
m_size(size),
m_bSharedMemory(false)
{
m_data.m_ppf = ppf;
Initialize();
_ASSERT( false ); // CREATE A D3D TEXTURE HERE.
// Figure out the DD caps
DWORD caps = DDSCAPS_VIDEOMEMORY;
if (Is3D())
{
caps |= DDSCAPS_3DDEVICE;
}
else
{
if (m_bTextureSize)
{
caps |= DDSCAPS_TEXTURE;
}
else
{
caps |= DDSCAPS_OFFSCREENPLAIN;
}
}
// Create the surface
_ASSERT( false );
// m_data.m_pdds = m_pdddevice->CreateSurface(size, caps, ppf, true);
// Was there enough memory to allocate the surface?
// if( m_data.m_pdds != NULL )
if( m_data.m_pd3dtexture != NULL )
{
// Get the pitch
D3DSURFACE_DESC ddsd;
m_data.m_pd3dtexture->GetLevelDesc( 0, &ddsd );
// DDSDescription ddsd;
// DDCall(m_data.m_pdds->GetSurfaceDesc(&ddsd));
//m_pitch = ddsd.lPitch;
// Do any other common construction tasks
FinishConstruction();
}
}
void CStructure::ConstructionTurn()
{
if (!m_flConstructionTurnTime)
return;
m_flConstructionTurnTime = 0;
if (m_iTurnsToConstruct <= 0)
return;
m_iTurnsToConstruct--;
if (GameData().GetCommandMenu())
SetupMenuButtons();
if (!m_iTurnsToConstruct)
FinishConstruction();
}
CHHMRInst::CHHMRInst(CWnd* Parent, char *inifile) : CISO(inifile)
{
// TRACE("CHHMRInst::CTOR #2\n");
m_pParent = Parent;
FinishConstruction();
}
// CHHMRInst
CHHMRInst::CHHMRInst()
{
// TRACE("CHHMRInst::CTOR #1\n");
m_pParent = NULL;
FinishConstruction();
}
DDSurfaceImpl( DDDevice * pdddevice,
SurfaceType stype,
PixelFormat* ppf,
PrivatePalette* ppalette,
const WinPoint& size,
int pitch,
BYTE* pbits ) :
m_pdddevice(pdddevice),
m_pengine(pdddevice->GetEngine()),
m_stype(stype),
m_ppalette(ppalette),
m_size(size)
{
// initialize
m_pitch = pitch;
m_data.m_ppf = ppf;
Initialize();
// Create a TEXTURE.
IDirect3DDeviceX * pD3DDev = pdddevice->GetD3DDevice()->GetD3DDeviceX();
_ASSERT( pD3DDev != NULL );
// For speed, what we should be doing is creating the texture in D3DPOOL_DEFAULT, then creating a seperate
// texture in D3DPOOL_SYSTEMMEM, and using UpdateTexture to update the VRAM version.
// For now, we create managed so that we can easily copy our texture data into it.
HRESULT hr = pD3DDev->CreateTexture( m_size.X(),
m_size.Y(),
1,
0,
m_data.m_ppf->GetEquivalentD3DFormat(),
D3DPOOL_MANAGED,
&m_data.m_pd3dtexture,
NULL );
DDCall( hr );
// Lock the texture and copy our data in.
D3DLOCKED_RECT lockRect;
hr = m_data.m_pd3dtexture->LockRect( 0, &lockRect, NULL, D3DLOCK_DISCARD );
DDCall( hr );
m_pitch = lockRect.Pitch;
BYTE * pDest = (BYTE*) lockRect.pBits;
for (int y = 0; y < m_size.Y(); y++)
{
memcpy( pDest + y * m_pitch,
pDest + y * pitch,
pitch );
}
// Unlock.
hr = m_data.m_pd3dtexture->UnlockRect( 0 );
DDCall( hr );
// Do any other common construction tasks
FinishConstruction();
// Is the memory writable?
/* MEMORY_BASIC_INFORMATION meminfo;
ZVerify(VirtualQuery(pbits, &meminfo, sizeof(meminfo)) == sizeof(meminfo));
m_bSharedMemory = ( ( meminfo.Protect &
(PAGE_READWRITE | PAGE_EXECUTE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_WRITECOPY) ) != 0 );
// initialize
m_pitch = pitch;
m_data.m_ppf = ppf;
Initialize();
// Figure out the DD caps
DWORD caps = DDSCAPS_SYSTEMMEMORY;
if (Is3D())
{
caps |= DDSCAPS_3DDEVICE;
}
if (m_bTextureSize)
{
caps |= DDSCAPS_TEXTURE;
}
else
{
caps |= DDSCAPS_OFFSCREENPLAIN;
}
// Create the surface
DDSDescription ddsd;
ddsd.dwFlags = DDSD_HEIGHT | DDSD_WIDTH | DDSD_CAPS | DDSD_PIXELFORMAT | DDSD_PITCH;
ddsd.dwWidth = m_size.X();
ddsd.dwHeight = m_size.Y();
ddsd.lPitch = pitch;
ddsd.ddsCaps.dwCaps = caps;
ddsd.ddpfPixelFormat = m_data.m_ppf->GetDDPF();
if( m_bSharedMemory )
{
_ASSERT( false );
// use the passed in memory
ddsd.dwFlags = ddsd.dwFlags | DDSD_LPSURFACE;
ddsd.lpSurface = pbits;
HRESULT hr = m_pdddevice->GetDD()->CreateSurface(&ddsd, &m_data.m_pdds, NULL);
DDCall(hr);
#ifdef _DEBUG
DDSDescription ddsd;
DDCall(m_data.m_pdds->GetSurfaceDesc(&ddsd));
ZAssert(pitch == ddsd.lPitch);
#endif
m_pitch = pitch;
}
else
{
_ASSERT( false );
// Let directx allocate the memory
HRESULT hr = m_pdddevice->GetDD()->CreateSurface(&ddsd, &m_data.m_pdds, NULL);
DDCall(hr);
// Copy the bits over
DDCall(m_data.m_pdds->Lock(NULL, &ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL));
m_pitch = ddsd.Pitch();
ZAssert(pitch <= m_pitch);
for (int y = 0; y < m_size.Y(); y++)
{
memcpy( ddsd.Pointer() + y * m_pitch, pbits + y * pitch, pitch );
}
DDCall(m_data.m_pdds->Unlock(NULL));
}
// Do any other common construction tasks
FinishConstruction();*/
}
