void CheckBox::DrawElement(C4FacetEx &cgo)
{
// left side: check facet (squared)
int x0 = rcBounds.x + cgo.TargetX;
int y0 = rcBounds.y + cgo.TargetY;
GetRes()->fctCheckbox.GetPhase(fChecked + 2*!fEnabled).DrawX(cgo.Surface, x0, y0, rcBounds.Hgt, rcBounds.Hgt);
// right of it: checkbox text
CStdFont *pUseFont = pFont ? pFont : &(GetRes()->TextFont);
int32_t yOff; float fZoom;
if (pUseFont->GetLineHeight() <= rcBounds.Hgt)
{
yOff = Max<int32_t>(rcBounds.Hgt - pUseFont->GetLineHeight(), 0)/2;
fZoom = 1.0f;
}
else
{
yOff = 0;
fZoom = (float) rcBounds.Hgt / Max(pUseFont->GetLineHeight(), 1);
}
lpDDraw->TextOut(sCaption.getData(), *pUseFont, fZoom, cgo.Surface, x0 + rcBounds.Hgt + C4GUI_CheckBoxLabelSpacing, y0 + yOff, fEnabled ? dwEnabledClr : dwDisabledClr, ALeft, true);
// selection marker
if ((fMouseOn && IsInActiveDlg(false)) || HasDrawFocus())
{
lpDDraw->SetBlitMode(C4GFXBLIT_ADDITIVE);
GetRes()->fctButtonHighlight.DrawX(cgo.Surface, x0+rcBounds.Hgt*1/4, y0+rcBounds.Hgt*1/4, rcBounds.Hgt*1/2, rcBounds.Hgt*1/2);
lpDDraw->ResetBlitMode();
}
}
double ummcase0
(
char pre, /* type prefix */
int M, int N, int K, /* problem sizes to time */
int mb, int nb, int kb, /* 0: variable NB, else fixed cpp macro of NB */
int lda, int ldb, int ldc, /* leading dims */
int muladd, int lat, /* muladd and latency settings */
int mu, int nu, int ku, /* unrolling factors */
char *fnam, /* file name to compile */
char *MCC, char *MMFLAGS, /* NULL : use defaults, else comp to use */
char *outnam /* output name */
)
{
char ln[512];
int i;
double mf;
if (!FileExists(outnam))
{
if (pre == 'c' || pre == 'z')
i = sprintf(ln, "make cmmucase mmrout=../CASES/%s csC=2 ", fnam);
else i = sprintf(ln, "make mmucase mmrout=../CASES/%s ", fnam);
if (MCC) i += sprintf(ln+i, "MCC=\"%s\" MMFLAGS=\"%s\" ", MCC, MMFLAGS);
i += sprintf(ln+i, "casnam=%s ", outnam);
i += sprintf(ln+i, "pre=%c muladd=%d lat=%d M=%d N=%d K=%d mb=%d nb=%d kb=%d mu=%d nu=%d ku=%d lda=%d ldb=%d ldc=%d ",
pre, muladd, lat, M, N, K, mb, nb, kb, mu, nu, ku,
lda, ldb, ldc);
i += sprintf(ln+i, "\n");
fprintf(stdout, "%s", ln);
if (system(ln) != 0) return(-1.0);
}
mf = GetRes(outnam);
if (mf == NO_RESULTS) mf = -1.0;
return(mf);
}
void ScrollBar::DrawElement(C4FacetEx &cgo)
{
// do scrolling
// not quite perfect; but there's no OnIdle, and it's be a bit of overkill starting a timer
if (fTopDown && fScrolling && iScrollPos>0)
{ --iScrollPos; OnPosChanged(); }
if (fBottomDown && fScrolling)
{
if (iScrollPos < GetMaxScroll()) { ++iScrollPos; OnPosChanged(); }
}
// draw bar
ScrollBarFacets &rUseGfx = pCustomGfx ? *pCustomGfx : GetRes()->sfctScroll;
DynBarFacet bar = rUseGfx.barScroll;
if (fTopDown) bar.fctBegin = rUseGfx.fctScrollDTop;
if (fBottomDown) bar.fctEnd = rUseGfx.fctScrollDBottom;
if (fHorizontal)
DrawHBarByVGfx(cgo, bar);
else
DrawVBar(cgo, bar);
// draw scroll pin
if (fScrolling && HasPin())
if (fHorizontal)
rUseGfx.fctScrollPin.Draw(cgo.Surface, cgo.TargetX+rcBounds.x+C4GUI_ScrollArrowWdt+iScrollPos, cgo.TargetY+rcBounds.y);
else
rUseGfx.fctScrollPin.Draw(cgo.Surface, cgo.TargetX+rcBounds.x, cgo.TargetY+rcBounds.y+C4GUI_ScrollArrowHgt+iScrollPos);
}
void D3D11Context::Resize() {
LostBackbuffer();
int width;
int height;
GetRes(hWnd_, width, height);
swapChain_->ResizeBuffers(0, width, height, DXGI_FORMAT_UNKNOWN, 0);
GotBackbuffer();
}
size_t DuiResProviderFiles::GetRawBufferSize( LPCTSTR strType,UINT uID )
{
CDuiStringT strPath=GetRes(strType,uID);
if(strPath.IsEmpty()) return 0;
WIN32_FIND_DATA wfd;
HANDLE hf=FindFirstFile(strPath,&wfd);
if(INVALID_HANDLE_VALUE==hf) return 0;
FindClose(hf);
return wfd.nFileSizeLow;
}
/*************************************************
Function: main
Description: 主函数
Calls: scanf printf
Called By: 编译器
Input: 无
Output: 无
Return: 0
*************************************************/
int main(void)
{
double a, b, c, d, x;
printf("enter the a,b,c,d:\n");
scanf("%lf%lf%lf%lf", &a, &b, &c, &d);
printf("enter the evaluated x:\n");
scanf("%lf", &x);
// printf("the result is : %lf", GetRes(-5, 3, 6, 2, 1.5));
printf("the result is : %lf", GetRes(a, b, c, d, x));
}
bool CheckBox::GetStandardCheckBoxSize(int *piWdt, int *piHgt, const char *szForCaptionText, CStdFont *pUseFont)
{
// get needed text size
if (!pUseFont) pUseFont = &(GetRes()->TextFont);
int32_t iWdt=100, iHgt=32;
pUseFont->GetTextExtent(szForCaptionText, iWdt, iHgt, true);
// check box height equals text height
// add check box plus indent
if (piWdt) *piWdt = iWdt + iHgt + C4GUI_CheckBoxLabelSpacing;
if (piHgt) *piHgt = iHgt;
return true;
}
CDuiImgBase * DuiResProviderFiles::LoadImage( LPCTSTR strType,UINT uID )
{
if(!HasResource(strType,uID)) return NULL;
CDuiImgBase * pImg=GetImageDecoder()->CreateDuiImage(strType);
if(pImg)
{
CDuiStringT strPath=GetRes(strType,uID);
if(!pImg->LoadFromFile(strPath))
{
GetImageDecoder()->DestoryDuiImage(pImg);
pImg=NULL;
}
}
return pImg;
}
BOOL DuiResProviderFiles::GetRawBuffer( LPCTSTR strType,UINT uID,LPVOID pBuf,size_t size )
{
CDuiStringT strPath=GetRes(strType,uID);
if(strPath.IsEmpty()) return FALSE;
FILE *f=_tfopen(strPath,_T("rb"));
if(!f) return FALSE;
size_t len=_filelength(_fileno(f));
if(len>size)
{
SetLastError(ERROR_INSUFFICIENT_BUFFER);
fclose(f);
return FALSE;
}
BOOL bRet=(len==fread(pBuf,1,len,f));
fclose(f);
return bRet;
}
bool RCFile::Read()
{
resFile.Reset();
resFile.Add(new FileHeader()); // add the 32 byte header into the resource database
Resource *res;
try
{
while (!lexer.AtEof() && (res = GetRes()))
resFile.Add(res);
}
catch (std::runtime_error *e)
{
Errors::Error(e->what());
delete e;
return false;
}
return true;
}
void D3D9_Resize(HWND window) {
// This should only be called from the emu thread.
int xres, yres;
GetRes(xres, yres);
bool w_changed = pp.BackBufferWidth != xres;
bool h_changed = pp.BackBufferHeight != yres;
if (device && (w_changed || h_changed)) {
DX9::fbo_shutdown();
pp.BackBufferWidth = xres;
pp.BackBufferHeight = yres;
HRESULT hr = device->Reset(&pp);
if (FAILED(hr)) {
ERROR_LOG_REPORT(G3D, "Unable to reset device: %s", DXGetErrorStringA(hr));
PanicAlert("Unable to reset D3D9 device: %s", DXGetErrorStringA(hr));
}
DX9::fbo_init(d3d);
}
}
void D3D9Context::Resize() {
// This should only be called from the emu thread.
int xres, yres;
GetRes(hWnd, xres, yres);
bool w_changed = pp.BackBufferWidth != xres;
bool h_changed = pp.BackBufferHeight != yres;
if (device && (w_changed || h_changed)) {
DX9::fbo_shutdown();
pp.BackBufferWidth = xres;
pp.BackBufferHeight = yres;
HRESULT hr = device->Reset(&pp);
if (FAILED(hr)) {
// Had to remove DXGetErrorStringA calls here because dxerr.lib is deprecated and will not link with VS 2015.
ERROR_LOG_REPORT(G3D, "Unable to reset D3D device");
PanicAlert("Unable to reset D3D9 device");
}
DX9::fbo_init(d3d);
}
}
void Screen::DrawToolTip(const char *szTip, C4FacetEx &cgo, int32_t x, int32_t y)
{
CStdFont *pUseFont = &(GetRes()->TooltipFont);
StdStrBuf sText;
pUseFont->BreakMessage(szTip, Min<int32_t>(C4GUI_MaxToolTipWdt, Max<int32_t>(cgo.Wdt, 50)), &sText, true);
// get tooltip rect
int32_t tWdt,tHgt;
if (pUseFont->GetTextExtent(sText.getData(), tWdt, tHgt, true))
{
tWdt+=6; tHgt+=4;
int32_t tX, tY;
if (y < cgo.Y+cgo.TargetY+tHgt+5) tY = Min<int32_t>(y+5, cgo.TargetY+cgo.Hgt-tHgt); else tY = y-tHgt-5;
tX = BoundBy<int32_t>(x-tWdt/2, cgo.TargetX+cgo.X, cgo.TargetX+cgo.Wdt-tWdt);
// draw tooltip box
lpDDraw->DrawBoxDw(cgo.Surface, tX,tY,tX+tWdt-1,tY+tHgt-2, C4GUI_ToolTipBGColor);
lpDDraw->DrawFrameDw(cgo.Surface, tX,tY,tX+tWdt-1,tY+tHgt-1, C4GUI_ToolTipFrameColor);
// draw tooltip
lpDDraw->TextOut(sText.getData(), *pUseFont, 1.0f, cgo.Surface, tX+3,tY+1, C4GUI_ToolTipColor, ALeft);
// while there's a tooltip, redraw the bg, because it might overlap
Game.GraphicsSystem.InvalidateBg();
}
}
HBITMAP DuiResProviderFiles::LoadBitmap( LPCTSTR strType,UINT uID )
{
CDuiStringT strPath=GetRes(strType,uID);
if(strPath.IsEmpty()) return NULL;
return (HBITMAP)::LoadImage(NULL, strPath, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION | LR_LOADFROMFILE);
}
bool D3D9Context::Init(HINSTANCE hInst, HWND wnd, std::string *error_message) {
bool windowed = true;
hWnd = wnd;
DIRECT3DCREATE9EX g_pfnCreate9ex;
hD3D9 = LoadLibrary(TEXT("d3d9.dll"));
if (!hD3D9) {
ELOG("Missing d3d9.dll");
*error_message = "D3D9.dll missing - try reinstalling DirectX.";
return false;
}
int d3dx_version = LoadD3DX9Dynamic();
if (!d3dx_version) {
*error_message = "D3DX DLL not found! Try reinstalling DirectX.";
return false;
}
g_pfnCreate9ex = (DIRECT3DCREATE9EX)GetProcAddress(hD3D9, "Direct3DCreate9Ex");
has9Ex = (g_pfnCreate9ex != NULL) && IsVistaOrHigher();
if (has9Ex) {
HRESULT result = g_pfnCreate9ex(D3D_SDK_VERSION, &d3dEx);
d3d = d3dEx;
if (FAILED(result)) {
FreeLibrary(hD3D9);
*error_message = "D3D9Ex available but context creation failed. Try reinstalling DirectX.";
return false;
}
} else {
d3d = Direct3DCreate9(D3D_SDK_VERSION);
if (!d3d) {
FreeLibrary(hD3D9);
*error_message = "Failed to create D3D9 context. Try reinstalling DirectX.";
return false;
}
}
D3DCAPS9 d3dCaps;
D3DDISPLAYMODE d3ddm;
if (FAILED(d3d->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm))) {
*error_message = "GetAdapterDisplayMode failed";
d3d->Release();
return false;
}
adapterId = D3DADAPTER_DEFAULT;
if (FAILED(d3d->GetDeviceCaps(adapterId, D3DDEVTYPE_HAL, &d3dCaps))) {
*error_message = "GetDeviceCaps failed (???)";
d3d->Release();
return false;
}
HRESULT hr;
if (FAILED(hr = d3d->CheckDeviceFormat(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
d3ddm.Format,
D3DUSAGE_DEPTHSTENCIL,
D3DRTYPE_SURFACE,
D3DFMT_D24S8))) {
if (hr == D3DERR_NOTAVAILABLE) {
*error_message = "D24S8 depth/stencil not available";
d3d->Release();
return false;
}
}
DWORD dwBehaviorFlags = D3DCREATE_MULTITHREADED | D3DCREATE_FPU_PRESERVE;
if (d3dCaps.VertexProcessingCaps != 0)
dwBehaviorFlags |= D3DCREATE_HARDWARE_VERTEXPROCESSING;
else
dwBehaviorFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
int xres, yres;
GetRes(hWnd, xres, yres);
memset(&pp, 0, sizeof(pp));
pp.BackBufferWidth = xres;
pp.BackBufferHeight = yres;
pp.BackBufferFormat = d3ddm.Format;
pp.MultiSampleType = D3DMULTISAMPLE_NONE;
pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
pp.Windowed = windowed;
pp.hDeviceWindow = wnd;
pp.EnableAutoDepthStencil = true;
pp.AutoDepthStencilFormat = D3DFMT_D24S8;
pp.PresentationInterval = (g_Config.bVSync) ? D3DPRESENT_INTERVAL_ONE : D3DPRESENT_INTERVAL_IMMEDIATE;
if (has9Ex) {
if (windowed && IsWin7OrLater()) {
// This new flip mode gives higher performance.
// TODO: This makes it slower?
//pp.BackBufferCount = 2;
//pp.SwapEffect = D3DSWAPEFFECT_FLIPEX;
}
hr = d3dEx->CreateDeviceEx(adapterId, D3DDEVTYPE_HAL, wnd, dwBehaviorFlags, &pp, NULL, &deviceEx);
device = deviceEx;
} else {
hr = d3d->CreateDevice(adapterId, D3DDEVTYPE_HAL, wnd, dwBehaviorFlags, &pp, &device);
}
if (FAILED(hr)) {
*error_message = "Failed to create D3D device";
d3d->Release();
return false;
}
device->BeginScene();
DX9::pD3Ddevice = device;
DX9::pD3DdeviceEx = deviceEx;
if (!DX9::CompileShaders(*error_message)) {
*error_message = "Unable to compile shaders: " + *error_message;
device->EndScene();
device->Release();
d3d->Release();
DX9::pD3Ddevice = nullptr;
DX9::pD3DdeviceEx = nullptr;
device = nullptr;
UnloadD3DXDynamic();
return false;
}
DX9::fbo_init(d3d);
if (deviceEx && IsWin7OrLater()) {
// TODO: This makes it slower?
//deviceEx->SetMaximumFrameLatency(1);
}
return true;
}
bool D3D11Context::Init(HINSTANCE hInst, HWND wnd, std::string *error_message) {
hWnd_ = wnd;
LoadD3D11Error result = LoadD3D11();
HRESULT hr = E_FAIL;
std::vector<std::string> adapterNames;
std::string chosenAdapterName;
if (result == LoadD3D11Error::SUCCESS) {
std::vector<IDXGIAdapter *> adapters;
int chosenAdapter = 0;
IDXGIFactory * pFactory = nullptr;
ptr_CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&pFactory);
IDXGIAdapter *pAdapter;
for (UINT i = 0; pFactory->EnumAdapters(i, &pAdapter) != DXGI_ERROR_NOT_FOUND; i++) {
adapters.push_back(pAdapter);
DXGI_ADAPTER_DESC desc;
pAdapter->GetDesc(&desc);
std::string str = ConvertWStringToUTF8(desc.Description);
adapterNames.push_back(str);
if (str == g_Config.sD3D11Device) {
chosenAdapter = i;
}
}
chosenAdapterName = adapterNames[chosenAdapter];
hr = CreateTheDevice(adapters[chosenAdapter]);
for (int i = 0; i < (int)adapters.size(); i++) {
adapters[i]->Release();
}
}
if (FAILED(hr)) {
const char *defaultError = "Your GPU does not appear to support Direct3D 11.\n\nWould you like to try again using Direct3D 9 instead?";
I18NCategory *err = GetI18NCategory("Error");
std::wstring error;
if (result == LoadD3D11Error::FAIL_NO_COMPILER) {
error = ConvertUTF8ToWString(err->T("D3D11CompilerMissing", "D3DCompiler_47.dll not found. Please install. Or press Yes to try again using Direct3D9 instead."));
} else if (result == LoadD3D11Error::FAIL_NO_D3D11) {
error = ConvertUTF8ToWString(err->T("D3D11Missing", "Your operating system version does not include D3D11. Please run Windows Update.\n\nPress Yes to try again using Direct3D9 instead."));
}
error = ConvertUTF8ToWString(err->T("D3D11NotSupported", defaultError));
std::wstring title = ConvertUTF8ToWString(err->T("D3D11InitializationError", "Direct3D 11 initialization error"));
bool yes = IDYES == MessageBox(hWnd_, error.c_str(), title.c_str(), MB_ICONERROR | MB_YESNO);
if (yes) {
// Change the config to D3D9 and restart.
g_Config.iGPUBackend = (int)GPUBackend::DIRECT3D9;
g_Config.sFailedGPUBackends.clear();
g_Config.Save("save_d3d9_fallback");
W32Util::ExitAndRestart();
}
return false;
}
if (FAILED(device_->QueryInterface(__uuidof (ID3D11Device1), (void **)&device1_))) {
device1_ = nullptr;
}
if (FAILED(context_->QueryInterface(__uuidof (ID3D11DeviceContext1), (void **)&context1_))) {
context1_ = nullptr;
}
#ifdef _DEBUG
if (SUCCEEDED(device_->QueryInterface(__uuidof(ID3D11Debug), (void**)&d3dDebug_))) {
if (SUCCEEDED(d3dDebug_->QueryInterface(__uuidof(ID3D11InfoQueue), (void**)&d3dInfoQueue_))) {
d3dInfoQueue_->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_CORRUPTION, true);
d3dInfoQueue_->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_ERROR, true);
d3dInfoQueue_->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_WARNING, true);
}
}
#endif
draw_ = Draw::T3DCreateD3D11Context(device_, context_, device1_, context1_, featureLevel_, hWnd_, adapterNames);
SetGPUBackend(GPUBackend::DIRECT3D11, chosenAdapterName);
bool success = draw_->CreatePresets(); // If we can run D3D11, there's a compiler installed. I think.
_assert_msg_(G3D, success, "Failed to compile preset shaders");
int width;
int height;
GetRes(hWnd_, width, height);
// Obtain DXGI factory from device (since we used nullptr for pAdapter above)
IDXGIFactory1* dxgiFactory = nullptr;
IDXGIDevice* dxgiDevice = nullptr;
IDXGIAdapter* adapter = nullptr;
hr = device_->QueryInterface(__uuidof(IDXGIDevice), reinterpret_cast<void**>(&dxgiDevice));
if (SUCCEEDED(hr)) {
hr = dxgiDevice->GetAdapter(&adapter);
if (SUCCEEDED(hr)) {
hr = adapter->GetParent(__uuidof(IDXGIFactory1), reinterpret_cast<void**>(&dxgiFactory));
DXGI_ADAPTER_DESC desc;
adapter->GetDesc(&desc);
adapter->Release();
}
dxgiDevice->Release();
}
// DirectX 11.0 systems
DXGI_SWAP_CHAIN_DESC sd;
ZeroMemory(&sd, sizeof(sd));
sd.BufferCount = 1;
sd.BufferDesc.Width = width;
sd.BufferDesc.Height = height;
sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sd.BufferDesc.RefreshRate.Numerator = 60;
sd.BufferDesc.RefreshRate.Denominator = 1;
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
sd.OutputWindow = hWnd_;
sd.SampleDesc.Count = 1;
sd.SampleDesc.Quality = 0;
sd.Windowed = TRUE;
hr = dxgiFactory->CreateSwapChain(device_, &sd, &swapChain_);
dxgiFactory->MakeWindowAssociation(hWnd_, DXGI_MWA_NO_ALT_ENTER);
dxgiFactory->Release();
GotBackbuffer();
return true;
}
HICON DuiResProviderFiles::LoadIcon( LPCTSTR strType,UINT uID ,int cx/*=0*/,int cy/*=0*/)
{
CDuiStringT strPath=GetRes(strType,uID);
if(strPath.IsEmpty()) return NULL;
return (HICON)::LoadImage(NULL, strPath, IMAGE_ICON, cx, cy, LR_LOADFROMFILE);
}
