menudisplay.cpp

Blood 2全套源码

{
	// Get the new renderer structure
	RMode newMode=GetRendererModeStruct(nRendererIndex, nResolutionIndex);

	// If the current renderer is the same as the one we are changing to, then don't set the renderer!
	RMode currentMode;
	if (m_pClientDE->GetRenderMode(&currentMode) == LT_OK)
	{	
		if (IsRendererEqual(&newMode, &currentMode))
		{
			return DFALSE;
		}
	}

	// Set the renderer mode
	m_pClientDE->SetRenderMode(&newMode);

	// Set the menu resolution size
	if (newMode.m_Width < 512 || newMode.m_Height < 384)
	{
		m_pMainMenus->SetLowResolution(DTRUE);
	}
	else
	{
		m_pMainMenus->SetLowResolution(DFALSE);
	}

	// Write the renderer information to the autoexec.cfg file
	char szTemp[256];
	sprintf(szTemp, "++RenderDll %s\0", newMode.m_RenderDLL);
	m_pClientDE->RunConsoleString(szTemp);

	sprintf(szTemp, "++CardDesc %s\0", newMode.m_InternalName);
	m_pClientDE->RunConsoleString(szTemp);

	sprintf(szTemp, "++screenwidth %d\0", newMode.m_Width);
	m_pClientDE->RunConsoleString(szTemp);

	sprintf(szTemp, "++screenheight %d\0", newMode.m_Height);
	m_pClientDE->RunConsoleString(szTemp);

	sprintf(szTemp, "++screendepth %d\0", newMode.m_BitDepth);
	m_pClientDE->RunConsoleString(szTemp);

	return DTRUE;
}

// Gets a RMode structure based on a renderer index and a resolution index
RMode CMenuDisplay::GetRendererModeStruct(int nRendererIndex, int nResolutionIndex)
{
	// Copy the renderer information from the renderer structure to the temporary RMode structure
	RMode mode;
	mode.m_bHardware=m_rendererArray[nRendererIndex].m_bHardware;	
	
	_mbscpy((unsigned char*)mode.m_RenderDLL, (const unsigned char*)m_rendererArray[nRendererIndex].m_renderDll);
	_mbscpy((unsigned char*)mode.m_InternalName, (const unsigned char*)m_rendererArray[nRendererIndex].m_internalName);
	_mbscpy((unsigned char*)mode.m_Description, (const unsigned char*)m_rendererArray[nRendererIndex].m_description);

	MenuDisplayResolution resolution=m_rendererArray[nRendererIndex].m_resolutionArray[nResolutionIndex];
	mode.m_Width=resolution.m_dwWidth;
	mode.m_Height=resolution.m_dwHeight;
	mode.m_BitDepth=resolution.m_dwBitDepth;

	mode.m_pNext=DNULL;

	return mode;
}

// Returns TRUE if two renderers are the same
DBOOL CMenuDisplay::IsRendererEqual(RMode *pRenderer1, RMode *pRenderer2)
{
	assert(pRenderer1);
	assert(pRenderer2);

	if (_mbsicmp((const unsigned char*)pRenderer1->m_RenderDLL, (const unsigned char*)pRenderer2->m_RenderDLL) != 0)
	{
		return DFALSE;
	}
	
	if (_mbsicmp((const unsigned char*)pRenderer1->m_InternalName, (const unsigned char*)pRenderer2->m_InternalName) != 0)
	{
		return DFALSE;
	}
	
	if (_mbsicmp((const unsigned char*)pRenderer1->m_Description, (const unsigned char*)pRenderer2->m_Description) != 0)
	{
		return DFALSE;
	}
	
	if (pRenderer1->m_Width != pRenderer2->m_Width)
	{
		return DFALSE;
	}

	if (pRenderer1->m_Height != pRenderer2->m_Height)
	{
		return DFALSE;
	}

	if (pRenderer1->m_BitDepth != pRenderer2->m_BitDepth)
	{
		return DFALSE;
	}

	return DTRUE;
}

// Called when the menu loses focus
void CMenuDisplay::OnFocus(DBOOL bFocus)
{
	HCONSOLEVAR	hVar;
	int curMO, oldMO;
	DBOOL bSet;

	// Set the render mode if we are losing focus
	if (!bFocus && m_pRendererCtrl && m_pResolutionCtrl)
	{
		hVar = m_pClientDE->GetConsoleVar("MipmapOffset");
		oldMO = (int)m_pClientDE->GetVarValueFloat (hVar);

		UpdateData();

		// Save the global detail setting
		SaveDetailSetting();		

		bSet = SetRenderer(m_pRendererCtrl->GetSelIndex(), m_pResolutionCtrl->GetSelIndex());

		// If we didn't switch resolutions and the mipmap offset changed, rebind textures.
		if(!bSet)
		{
			hVar = m_pClientDE->GetConsoleVar("MipmapOffset");
			curMO = (int)m_pClientDE->GetVarValueFloat (hVar);
			if(curMO != oldMO)
			{
				m_pClientDE->RunConsoleString("RebindTextures");
			}
		}
	}
	else
	{
		// The current render mode
		RMode currentMode;
		m_pClientDE->GetRenderMode(&currentMode);		

		// Set the renderer controls so that they match the currently selected renderer
		unsigned int n;
		for (n=0; n < m_rendererArray.GetSize(); n++)
		{
			unsigned int i;
			for (i=0; i < m_rendererArray[n].m_resolutionArray.GetSize(); i++)
			{
				RMode mode=GetRendererModeStruct(n, i);

				if (IsRendererEqual(&currentMode, &mode))
				{
					// Set the renderer index
					m_pRendererCtrl->SetSelIndex(n);

					// Setup the resolution control
					SetupResolutionCtrl();

					// Set the resolution index
					m_pResolutionCtrl->SetSelIndex(i);
				}
			}
		}
	}
}

// Returns the currently selected resolution
MenuDisplayResolution CMenuDisplay::GetCurrentSelectedResolution()
{
	int nRendererIndex=m_pRendererCtrl->GetSelIndex();
	int nResolutionIndex=m_pResolutionCtrl->GetSelIndex();

	return m_rendererArray[nRendererIndex].m_resolutionArray[nResolutionIndex];
}

// Set the resolution for the resolution control.  If it cannot be found the
// next highest resolution is selected.
void CMenuDisplay::SetCurrentCtrlResolution(MenuDisplayResolution resolution)
{
	int nCurrentRenderer=m_pRendererCtrl->GetSelIndex();

	// Go through the resolutions searching for a match
	unsigned int i;
	for (i=0; i < m_rendererArray[nCurrentRenderer].m_resolutionArray.GetSize(); i++)
	{
		MenuDisplayResolution searchRes=m_rendererArray[nCurrentRenderer].m_resolutionArray[i];

		if (resolution.m_dwWidth == searchRes.m_dwWidth &&
			resolution.m_dwHeight == searchRes.m_dwHeight &&
			resolution.m_dwBitDepth == searchRes.m_dwBitDepth)
		{
			m_pResolutionCtrl->SetSelIndex(i);
			return;
		}
	}
	
	// Since an exact match wasn't found, set it to the next highest resolution	
	for (i=0; i < m_rendererArray[nCurrentRenderer].m_resolutionArray.GetSize(); i++)
	{
		MenuDisplayResolution searchRes=m_rendererArray[nCurrentRenderer].m_resolutionArray[i];

		if (resolution.m_dwWidth > searchRes.m_dwWidth ||
			resolution.m_dwHeight > searchRes.m_dwHeight &&
			resolution.m_dwBitDepth == searchRes.m_dwBitDepth)
		{
			if (i > 0)
			{
				m_pResolutionCtrl->SetSelIndex(i-1);
			}
			else
			{
				m_pResolutionCtrl->SetSelIndex(0);
			}
			return;
		}
	}
}

// Saves the global detail level
void CMenuDisplay::SaveDetailSetting()
{
	char szConsole[256];
	switch (m_nDetailLevel)
	{
	case 0:
		{
			sprintf(szConsole, "+GlobalDetail %d", DETAIL_LOW);
			break;
		}
	case 1:
		{
			sprintf(szConsole, "+GlobalDetail %d", DETAIL_MEDIUM);
			break;
		}
	case 2:
		{
			sprintf(szConsole, "+GlobalDetail %d", DETAIL_HIGH);
			break;
		}
	}

	m_pClientDE->RunConsoleString(szConsole);
	g_pBloodClientShell->MenuSetDetail();
}

// Override the left control
void CMenuDisplay::OnLeft()
{
	// Get the current resolution
	MenuDisplayResolution currentResolution=GetCurrentSelectedResolution();

	CMenuBase::OnLeft();

	// If the renderer control is selected, rebuild the resolutions control
	if (GetCurrentItem() == m_pRendererCtrl)
	{
		SetupResolutionCtrl();

		// Set the resolution for the control
		SetCurrentCtrlResolution(currentResolution);
	}
}

// Override the right control
void CMenuDisplay::OnRight()
{
	// Get the current resolution
	MenuDisplayResolution currentResolution=GetCurrentSelectedResolution();

	CMenuBase::OnRight();

	// If the renderer control is selected, rebuild the resolutions control
	if (GetCurrentItem() == m_pRendererCtrl)
	{
		SetupResolutionCtrl();

		// Set the resolution for the control
		SetCurrentCtrlResolution(currentResolution);
	}
}

DDWORD CMenuDisplay::OnCommand(DDWORD dwCommand, DDWORD dwParam1, DDWORD dwParam2)
{
	return 0;
}