bool StWinHandles::registerClass(const StStringUtfWide& theName, WNDPROC theProc) { HINSTANCE aModule = GetModuleHandleW(NULL); WNDCLASSW aClass; stMemZero(&aClass, sizeof(aClass)); // redraw on resize, and request own DC for window aClass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; aClass.lpfnWndProc = theProc; aClass.cbClsExtra = 0; aClass.cbWndExtra = 0; aClass.hInstance = aModule; aClass.hIcon = LoadIconW(aModule, L"A"); aClass.hCursor = LoadCursor(NULL, IDC_ARROW); aClass.hbrBackground = NULL; aClass.lpszMenuName = NULL; aClass.lpszClassName = theName.toCString(); if(RegisterClassW(&aClass) == 0) { stError(StString("WinAPI: Failed to register window class '") + theName.toUtf8() + "'"); return false; } return true; }
// function create GUI window bool StWindowImpl::create() { myKeysState.reset(); // replace default XError handler to ignore some errors XSetErrorHandler(stXErrorHandler); myInitState = STWIN_INITNOTSTART; // X-server implementation // create window on unix systems throw X-server int dummy; // open a connection to the X server StXDisplayH stXDisplay = new StXDisplay(); if(!stXDisplay->isOpened()) { stXDisplay.nullify(); stError("X, could not open display"); myInitState = STWIN_ERROR_X_OPENDISPLAY; return false; } myMaster.stXDisplay = stXDisplay; Display* hDisplay = stXDisplay->hDisplay; #if defined(ST_HAVE_EGL) myMaster.hRC = new StWinGlrc(eglGetDisplay(hDisplay), attribs.IsGlDebug, attribs.GlDepthSize); if(!myMaster.hRC->isValid()) { myMaster.close(); mySlave.close(); myInitState = STWIN_ERROR_X_GLRC_CREATE; return false; } XVisualInfo aVisInfo; aVisInfo.visualid = 0; if (eglGetConfigAttrib(myMaster.hRC->getDisplay(), myMaster.hRC->getConfig(), EGL_NATIVE_VISUAL_ID, (EGLint* )&aVisInfo.visualid) != EGL_TRUE) { myMaster.close(); mySlave.close(); myInitState = STWIN_ERROR_X_GLRC_CREATE; return false; } int aNbVisuals = 0; stXDisplay->hVisInfo = XGetVisualInfo(hDisplay, VisualIDMask, &aVisInfo, &aNbVisuals); #else // GLX // make sure OpenGL's GLX extension supported if(!glXQueryExtension(hDisplay, &dummy, &dummy)) { myMaster.close(); stError("X, server has no OpenGL GLX extension"); myInitState = STWIN_ERROR_X_NOGLX; return false; } int anAttribsBuff[] = { GLX_STEREO, attribs.IsGlStereo ? True : False, GLX_X_RENDERABLE, True, GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT, GLX_RENDER_TYPE, GLX_RGBA_BIT, GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR, GLX_RED_SIZE, 8, GLX_GREEN_SIZE, 8, GLX_BLUE_SIZE, 8, GLX_ALPHA_SIZE, 0, GLX_DEPTH_SIZE, attribs.GlDepthSize, GLX_STENCIL_SIZE, 0, GLX_DOUBLEBUFFER, True, //GLX_SAMPLE_BUFFERS, 1, //GLX_SAMPLES, 4, None }; // FBConfigs were added in GLX version 1.3 int aGlxMajor = 0; int aGlxMinor = 0; const bool hasFBCfg = glXQueryVersion(hDisplay, &aGlxMajor, &aGlxMinor) && ((aGlxMajor == 1 && aGlxMinor >= 3) || (aGlxMajor > 1)); int aFBCount = 0; GLXFBConfig* aFBCfgList = NULL; if(hasFBCfg) { aFBCfgList = glXChooseFBConfig(hDisplay, DefaultScreen(hDisplay), anAttribsBuff, &aFBCount); } if(aFBCfgList == NULL && hasFBCfg && attribs.IsGlStereo) { ST_ERROR_LOG("X, no Quad Buffered visual"); anAttribsBuff[1] = False; aFBCfgList = glXChooseFBConfig(hDisplay, DefaultScreen(hDisplay), anAttribsBuff, &aFBCount); } if(aFBCfgList != NULL && aFBCount >= 1) { stXDisplay->FBCfg = aFBCfgList[0]; stXDisplay->hVisInfo = glXGetVisualFromFBConfig(hDisplay, stXDisplay->FBCfg); } else { // try to use glXChooseVisual... pointless? int aDblBuff[] = { GLX_RGBA, GLX_DEPTH_SIZE, attribs.GlDepthSize, GLX_DOUBLEBUFFER, None }; if(attribs.IsGlStereo) { // find an appropriate visual int aQuadBuff[] = { GLX_RGBA, GLX_DEPTH_SIZE, attribs.GlDepthSize, GLX_DOUBLEBUFFER, GLX_STEREO, None }; stXDisplay->hVisInfo = glXChooseVisual(hDisplay, DefaultScreen(hDisplay), aQuadBuff); if(stXDisplay->hVisInfo == NULL) { ST_ERROR_LOG("X, no Quad Buffered visual"); stXDisplay->hVisInfo = glXChooseVisual(hDisplay, DefaultScreen(hDisplay), aDblBuff); if(stXDisplay->hVisInfo == NULL) { myMaster.close(); stError("X, no RGB visual with depth buffer"); myInitState = STWIN_ERROR_X_NORGB; return false; } } } else { // find an appropriate visual // find an OpenGL-capable RGB visual with depth buffer stXDisplay->hVisInfo = glXChooseVisual(hDisplay, DefaultScreen(hDisplay), aDblBuff); if(stXDisplay->hVisInfo == NULL) { myMaster.close(); stError("X, no RGB visual with depth buffer"); myInitState = STWIN_ERROR_X_NORGB; return false; } } } XFree(aFBCfgList); #endif if(attribs.Slave != StWinSlave_slaveOff) { // just copy handle mySlave.stXDisplay = stXDisplay; } // create an X window with the selected visual XSetWindowAttributes aWinAttribsX = createDefaultAttribs(stXDisplay); updateChildRect(); Window aParentWin = (Window )myParentWin; if(aParentWin == 0 && !attribs.IsNoDecor) { aWinAttribsX.override_redirect = False; myMaster.hWindow = XCreateWindow(hDisplay, stXDisplay->getRootWindow(), myRectNorm.left(), myRectNorm.top(), myRectNorm.width(), myRectNorm.height(), 0, stXDisplay->getDepth(), InputOutput, stXDisplay->getVisual(), CWBorderPixel | CWColormap | CWEventMask | CWOverrideRedirect, &aWinAttribsX); if(myMaster.hWindow == 0) { myMaster.close(); stError("X, XCreateWindow failed for Master"); myInitState = STWIN_ERROR_X_CREATEWIN; return false; } aParentWin = myMaster.hWindow; XSetStandardProperties(hDisplay, myMaster.hWindow, myWindowTitle.toCString(), myWindowTitle.toCString(), None, NULL, 0, NULL); // setup WM_CLASS in sync with .desktop StartupWMClass entity // to ensure Window Manager would show an propriate icon for application XClassHint* aClassHint = XAllocClassHint(); if(aClassHint != NULL) { StString aName = StProcess::getProcessName(); StString aClass("sView"); // const_cast should be harmless here and it seems to be just broken signature of XClassHint structure aClassHint->res_name = const_cast<char* >(aName.toCString()); aClassHint->res_class = const_cast<char* >(aClass.toCString()); XSetClassHint(hDisplay, myMaster.hWindow, aClassHint); XFree(aClassHint); } } aWinAttribsX.override_redirect = True; // GL window always undecorated myMaster.hWindowGl = XCreateWindow(hDisplay, (aParentWin != 0) ? aParentWin : stXDisplay->getRootWindow(), 0, 0, myRectNorm.width(), myRectNorm.height(), 0, stXDisplay->getDepth(), InputOutput, stXDisplay->getVisual(), CWBorderPixel | CWColormap | CWEventMask | CWOverrideRedirect, &aWinAttribsX); if(myMaster.hWindowGl == 0) { myMaster.close(); stError("X, XCreateWindow failed for Master"); myInitState = STWIN_ERROR_X_CREATEWIN; return false; } XSetStandardProperties(hDisplay, myMaster.hWindowGl, "master window", "master window", None, NULL, 0, NULL); if(attribs.Slave != StWinSlave_slaveOff) { aWinAttribsX.event_mask = NoEventMask; // we do not parse any events to slave window! aWinAttribsX.override_redirect = True; // slave window always undecorated mySlave.hWindowGl = XCreateWindow(hDisplay, stXDisplay->getRootWindow(), getSlaveLeft(), getSlaveTop(), getSlaveWidth(), getSlaveHeight(), 0, stXDisplay->getDepth(), InputOutput, stXDisplay->getVisual(), CWBorderPixel | CWColormap | CWEventMask | CWOverrideRedirect, &aWinAttribsX); if(mySlave.hWindowGl == 0) { myMaster.close(); mySlave.close(); stError("X, XCreateWindow failed for Slave"); myInitState = STWIN_ERROR_X_CREATEWIN; return false; } XSetStandardProperties(hDisplay, mySlave.hWindowGl, "slave window", "slave window", None, NULL, 0, NULL); } int isGlCtx = myMaster.glCreateContext(attribs.Slave != StWinSlave_slaveOff ? &mySlave : NULL, myRectNorm, attribs.GlDepthSize, attribs.IsGlStereo, attribs.IsGlDebug); if(isGlCtx != STWIN_INIT_SUCCESS) { myMaster.close(); mySlave.close(); myInitState = isGlCtx; return false; } myGlContext = new StGLContext(myResMgr); if(!myGlContext->stglInit()) { myMaster.close(); mySlave.close(); stError("Critical error - broken GL context!\nInvalid OpenGL driver?"); myInitState = STWIN_ERROR_X_GLRC_CREATE; return false; } // handle close window event if(myMaster.hWindow != 0) { XSetWMProtocols(hDisplay, myMaster.hWindow, &(stXDisplay->wndDestroyAtom), 1); } // Announce XDND support myMaster.setupXDND(); // Initialize XRandr events reception if(XRRQueryExtension(hDisplay, &myMaster.xrandrEventBase, &dummy)) { XRRSelectInput(hDisplay, stXDisplay->getRootWindow(), RRScreenChangeNotifyMask | RRCrtcChangeNotifyMask | RROutputPropertyNotifyMask); myMaster.isRecXRandrEvents = true; } else { myMaster.isRecXRandrEvents = false; } // request the X window to be displayed on the screen if(attribs.Slave != StWinSlave_slaveOff) { // request the X window to be displayed on the screen if(!attribs.IsSlaveHidden && (!isSlaveIndependent() || myMonitors.size() > 1)) { XMapWindow(hDisplay, mySlave.hWindowGl); //XIfEvent(hDisplay, &myXEvent, stXWaitMapped, (char* )mySlave.hWindowGl); } // always hise mouse cursor on slave window mySlave.setupNoCursor(); } if(!attribs.IsHidden) { if(myMaster.hWindow != 0) { XMapWindow(hDisplay, myMaster.hWindow); //XIfEvent(hDisplay, &myXEvent, stXWaitMapped, (char* )myMaster.hWindow); } XMapWindow(hDisplay, myMaster.hWindowGl); //XIfEvent(hDisplay, &myXEvent, stXWaitMapped, (char* )myMaster.hWindowGl); } // setup default icon if((Window )myParentWin == 0) { XpmCreatePixmapFromData(hDisplay, myMaster.hWindow, (char** )sview_xpm, &myMaster.iconImage, &myMaster.iconShape, NULL); XWMHints anIconHints; anIconHints.flags = IconPixmapHint | IconMaskHint; anIconHints.icon_pixmap = myMaster.iconImage; anIconHints.icon_mask = myMaster.iconShape; XSetWMHints(hDisplay, myMaster.hWindow, &anIconHints); } // we need this call to go around bugs if(!attribs.IsFullScreen && myMaster.hWindow != 0) { XMoveResizeWindow(hDisplay, myMaster.hWindow, myRectNorm.left(), myRectNorm.top(), myRectNorm.width(), myRectNorm.height()); } // flushes the output buffer, most client apps needn't use this cause buffer is automatically flushed as needed by calls to XNextEvent()... XFlush(hDisplay); myMonitors.registerUpdater(true); myIsUpdated = true; myInitState = STWIN_INIT_SUCCESS; return true; }
bool StWindowImpl::onAndroidInitWindow() { myIsPaused = false; if(myParentWin->getWindow() == NULL) { return false; } if(!myMaster.hRC.isNull()) { myMaster.hWindowGl = myParentWin->getWindow(); EGLint anEglErr = eglGetError(); (void )anEglErr; EGLint aFormat = 0; if(eglGetConfigAttrib(myMaster.hRC->getDisplay(), myMaster.hRC->getConfig(), EGL_NATIVE_VISUAL_ID, &aFormat) == EGL_FALSE) { anEglErr = eglGetError(); } ANativeWindow_setBuffersGeometry(myMaster.hWindowGl, 0, 0, aFormat); myMaster.eglSurface = eglCreateWindowSurface(myMaster.hRC->getDisplay(), myMaster.hRC->getConfig(), myMaster.hWindowGl, NULL); if(myMaster.eglSurface == NULL) { anEglErr = eglGetError(); } // bind the rendering context to the window if(!myMaster.hRC->makeCurrent(myMaster.eglSurface)) { myMaster.close(); mySlave.close(); myInitState = STWIN_ERROR_X_GLRC_CREATE; stError("Critical error - broken EGL context!"); return false; } const EGLint aWidth = ANativeWindow_getWidth (myMaster.hWindowGl); const EGLint aHeight = ANativeWindow_getHeight(myMaster.hWindowGl); const bool isResized = myRectNorm.width() != aWidth || myRectNorm.height() != aHeight; myRectNorm.left() = 0; myRectNorm.top() = 0; myRectNorm.right() = myRectNorm.left() + aWidth; myRectNorm.bottom() = myRectNorm.top() + aHeight; myRectFull = myRectNorm; myInitState = STWIN_INIT_SUCCESS; if(isResized) { myStEvent.Size.init(getEventTime(), myRectNorm.width(), myRectNorm.height(), myForcedAspect); signals.onResize->emit(myStEvent.Size); } return true; } myMaster.hRC = new StWinGlrc(eglGetDisplay(EGL_DEFAULT_DISPLAY), attribs.IsGlDebug, attribs.GlDepthSize, attribs.GlStencilSize); if(!myMaster.hRC->isValid()) { myMaster.close(); mySlave.close(); myInitState = STWIN_ERROR_X_GLRC_CREATE; return false; } myMaster.hWindowGl = myParentWin->getWindow(); myInitState = myMaster.glCreateContext(NULL, myRectNorm, attribs.GlDepthSize, attribs.GlStencilSize, attribs.IsGlStereo, attribs.IsGlDebug); if(myInitState != STWIN_INIT_SUCCESS) { return false; } EGLint aWidth = 0, aHeight = 0; if(myMaster.hWindowGl != NULL) { aWidth = ANativeWindow_getWidth (myMaster.hWindowGl); aHeight = ANativeWindow_getHeight(myMaster.hWindowGl); } else if(myMaster.eglSurface != EGL_NO_SURFACE) { eglQuerySurface(myMaster.hRC->getDisplay(), myMaster.eglSurface, EGL_WIDTH, &aWidth); eglQuerySurface(myMaster.hRC->getDisplay(), myMaster.eglSurface, EGL_HEIGHT, &aHeight); } myRectNorm.left() = 0; myRectNorm.top() = 0; myRectNorm.right() = myRectNorm.left() + aWidth; myRectNorm.bottom() = myRectNorm.top() + aHeight; myRectFull = myRectNorm; myGlContext = new StGLContext(myResMgr); if(!myGlContext->stglInit()) { myMaster.close(); mySlave.close(); stError("Critical error - broken GL context!\nInvalid OpenGL driver?"); myInitState = STWIN_ERROR_X_GLRC_CREATE; return false; } myInitState = STWIN_INIT_SUCCESS; return true; }
bool StApplication::open() { if(!myWindow.isNull()) { return true; } StSettings aGlobalSettings(myResMgr, "sview"); if(!mySwitchTo.isNull()) { myRendId = mySwitchTo->getRendererId(); myWindow = mySwitchTo; mySwitchTo.nullify(); aGlobalSettings.saveString(ST_SETTING_RENDERER, myRendId); aGlobalSettings.saveBool (ST_SETTING_RENDERER_AUTO, false); } else { if(myRenderers.isEmpty()) { myWindow = new StWindow(myResMgr, myWinParent); myWindow->setMessagesQueue(myMsgQueue); myWindow->params.VSyncMode = params.VSyncMode; } else { bool isAuto = myRendId.isEqualsIgnoreCase(ST_SETTING_AUTO_VALUE); if(!isAuto) { for(size_t anIter = 0; anIter < myRenderers.size(); ++anIter) { StHandle<StWindow> aWin = myRenderers[anIter]; if(myRendId == aWin->getRendererId()) { myWindow = aWin; aGlobalSettings.saveString(ST_SETTING_RENDERER, myRendId); aGlobalSettings.saveBool (ST_SETTING_RENDERER_AUTO, isAuto); break; } } if(myWindow.isNull()) { stError(StString("Output with id '" + myRendId + "' is not found.")); isAuto = true; } } if(isAuto) { // autodetection aGlobalSettings.saveString(ST_SETTING_RENDERER, ST_SETTING_AUTO_VALUE); aGlobalSettings.saveBool (ST_SETTING_RENDERER_AUTO, isAuto); myWindow = myRenderers[0]; if(!myDevices.isEmpty()) { StHandle<StOutDevice> aBestDev = myDevices[0]; for(size_t aDevIter = 0; aDevIter < myDevices.size(); ++aDevIter) { const StHandle<StOutDevice>& aDev = myDevices[aDevIter]; if(aDev->Priority > aBestDev->Priority) { aBestDev = aDev; } } for(size_t anIter = 0; anIter < myRenderers.size(); ++anIter) { const StHandle<StWindow>& aWin = myRenderers[anIter]; if(aBestDev->PluginId == aWin->getRendererId()) { myWindow = aWin; myWindow->setDevice(aBestDev->DeviceId); break; } } } } } myWindow->setTitle(myTitle); } // synchronize devices enumeration const StString aPluginId = myWindow->getRendererId(); const StString aDeviceId = myWindow->getDeviceId(); for(size_t aDevIter = 0; aDevIter < myDevices.size(); ++aDevIter) { const StHandle<StOutDevice>& aDev = myDevices[aDevIter]; if(aPluginId == aDev->PluginId && aDeviceId == aDev->DeviceId) { params.ActiveDevice->setValue((int32_t )aDevIter); break; } } // setup GL options before window creation const StWinAttr anAttribs[] = { StWinAttr_GlDebug, (StWinAttr )myGlDebug, StWinAttr_NULL }; myWindow->setAttributes(anAttribs); myIsOpened = myWindow->create(); if(myIsOpened) { // connect slots myWindow->signals.onRedraw = stSlot(this, &StApplication::doDrawProxy); myWindow->signals.onClose = stSlot(this, &StApplication::doClose); myWindow->signals.onPause = stSlot(this, &StApplication::doPause); myWindow->signals.onResize = stSlot(this, &StApplication::doResize); myWindow->signals.onAction = stSlot(this, &StApplication::doAction); myWindow->signals.onKeyDown = stSlot(this, &StApplication::doKeyDown); myWindow->signals.onKeyUp = stSlot(this, &StApplication::doKeyUp); myWindow->signals.onKeyHold = stSlot(this, &StApplication::doKeyHold); myWindow->signals.onMouseDown = stSlot(this, &StApplication::doMouseDown); myWindow->signals.onMouseUp = stSlot(this, &StApplication::doMouseUp); myWindow->signals.onTouch = stSlot(this, &StApplication::doTouch); myWindow->signals.onGesture = stSlot(this, &StApplication::doGesture); myWindow->signals.onScroll = stSlot(this, &StApplication::doScroll); myWindow->signals.onFileDrop = stSlot(this, &StApplication::doFileDrop); myWindow->signals.onNavigate = stSlot(this, &StApplication::doNavigate); } return myIsOpened; }
void StAndroidGlue::threadEntry() { if(myJavaVM->AttachCurrentThread(&myThJniEnv, NULL) < 0) { ST_ERROR_LOG("Failed to attach working thread to Java VM"); return; } THE_ANDROID_GLUE = this; StMessageBox::setCallback(msgBoxCallback); myConfig = AConfiguration_new(); AConfiguration_fromAssetManager(myConfig, myActivity->assetManager); updateMonitors(); printConfig(); ALooper* aLooper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS); ALooper_addFd(aLooper, myMsgRead, LooperId_MAIN, ALOOPER_EVENT_INPUT, NULL, &myCmdPollSource); myLooper = aLooper; pthread_mutex_lock(&myMutex); myIsRunning = true; pthread_cond_broadcast(&myCond); pthread_mutex_unlock(&myMutex); // try to load stereo APIs /**jclass aJClass_Real3D = myThJniEnv->FindClass("com/lge/real3d/Real3D"); if(aJClass_Real3D != NULL) { jmethodID aJMet_isStereoDisplayAvailable = myThJniEnv->GetStaticMethodID(aJClass_Real3D, "isStereoDisplayAvailable", "(Landroid/content/Contex;)Z"); postMessage("com.lge.real3d.Real3D !!!"); } jclass aJClass_HTC = myThJniEnv->FindClass("com/htc/view/DisplaySetting"); if(aJClass_HTC != NULL) { jmethodID aJMet_isStereoDisplayAvailable = myThJniEnv->GetStaticMethodID(aJClass_HTC, "setStereoscopic3DFormat", "(Landroid/view/Surface;I)Z"); postMessage("com.htc.view.DisplaySetting !!!"); } jclass aJClass_Sharp = myThJniEnv->FindClass("jp/co/sharp/android/stereo3dlcd/SurfaceController"); if(aJClass_Sharp != NULL) { jmethodID aJMet_setStereoView = myThJniEnv->GetMethodID(aJClass_Sharp, "setStereoView", "(Z)V"); postMessage("jp.co.sharp.android.stereo3dlcd !!!"); }*/ createApplication(); if(!myApp.isNull()) { if(!myApp->open()) { stError("Error: application can not be executed!"); } myApp->exec(); } else { stError("Error: no application to execute!"); } myApp.nullify(); // application is done but we are waiting for destroying event... bool isFirstWait = true; for(; !myToDestroy; ) { if(isFirstWait) { postExit(); isFirstWait = false; } StAndroidPollSource* aSource = NULL; int aNbEvents = 0; ALooper_pollAll(-1, NULL, &aNbEvents, (void** )&aSource); if(aSource != NULL) { aSource->process(this, aSource); } } freeSavedState(); pthread_mutex_lock(&myMutex); if(myInputQueue != NULL) { AInputQueue_detachLooper(myInputQueue); } AConfiguration_delete(myConfig); pthread_cond_broadcast(&myCond); pthread_mutex_unlock(&myMutex); myThJniEnv = NULL; StMessageBox::setCallback(NULL); THE_ANDROID_GLUE = NULL; myJavaVM->DetachCurrentThread(); }
bool StDXManager::init(const HWND theWinHandle, const int theSizeX, const int theSizeY, const bool theFullscreen, const StMonitor& theMonitor, const StDXAdapterClass theAdapter) { const StString anAdapterStr = theMonitor.getName().subString(0, 12); if(!initDxLib()) { stError("StDXManager, Direct3DCreate9 failed!"); return false; } const UINT aD3dAdaptersNb = getAdapterCount(); UINT anAdapterId = UINT(-1); UINT anAdapterVendor = UINT(-1); D3DADAPTER_IDENTIFIER9 anAdapterInfo; for(UINT anAdapterIter = 0; anAdapterIter < aD3dAdaptersNb; ++anAdapterIter) { getAdapterIdentifier(anAdapterIter, 0, &anAdapterInfo); switch(theAdapter) { case ST_DX_ADAPTER_AMD: { if(anAdapterInfo.VendorId != ST_DX_VENDOR_AMD) { continue; } anAdapterVendor = anAdapterIter; break; } case ST_DX_ADAPTER_NVIDIA: { if(anAdapterInfo.VendorId != ST_DX_VENDOR_NVIDIA) { continue; } anAdapterVendor = anAdapterIter; break; } case ST_DX_ADAPTER_ANY: default: break; } if(anAdapterStr == StString(anAdapterInfo.DeviceName)) { anAdapterId = anAdapterIter; break; } } if(theAdapter != ST_DX_ADAPTER_ANY) { if(anAdapterId == UINT(-1) && anAdapterVendor != UINT(-1)) { anAdapterId = anAdapterVendor; } if(anAdapterId == UINT(-1)) { return false; } } if(anAdapterId == UINT(-1)) { // the default adapter is the primary display adapter anAdapterId = D3DADAPTER_DEFAULT; } // setup the present parameters if(getAdapterDisplayMode(anAdapterId, &myCurrMode) == D3D_OK) { myD3dParams.BackBufferFormat = myCurrMode.Format; myRefreshRate = myCurrMode.RefreshRate; } myD3dParams.Windowed = !theFullscreen; // is windowed? myD3dParams.BackBufferWidth = theSizeX; myD3dParams.BackBufferHeight = theSizeY; myD3dParams.hDeviceWindow = theWinHandle; // create the Video Device myD3dDevice = createAqbsDevice(anAdapterId, theWinHandle, myD3dParams); if(myD3dDevice == NULL) { HRESULT isOK = myD3dLib->CreateDevice(anAdapterId, D3DDEVTYPE_HAL, // the HAL (hardware accelerated layer) uses your 3d accelerator card theWinHandle, ST_D3D_DEVICE_FLAGS, &myD3dParams, &myD3dDevice); if(isOK < 0) { return false; } } // this normalizes the normal values (this is important for how lighting effects your models) ///myD3dDevice->SetRenderState(D3DRS_NORMALIZENORMALS, TRUE); ST_DEBUG_LOG("Direct3D9, Created StDXManager device (WxH= " + theSizeX + "x"+ theSizeY + ")"); return myD3dDevice != NULL; }