自学教程：C++ GHOST_ASSERT函数代码示例

GHOST_TSuccessGHOST_DisplayManagerX11::getNumDisplaySettings(		GHOST_TUns8 display,		GHOST_TInt32& numSettings) const{#ifdef WITH_X11_XF86VMODE	int majorVersion, minorVersion;	XF86VidModeModeInfo **vidmodes;	Display *dpy = m_system->getXDisplay();	GHOST_ASSERT(display < 1, "Only single display systems are currently supported./n");	if (dpy == NULL)		return GHOST_kFailure;	majorVersion = minorVersion = 0;	if (!XF86VidModeQueryVersion(dpy, &majorVersion, &minorVersion)) {		fprintf(stderr, "Error: XF86VidMode extension missing!/n");		return GHOST_kFailure;	}	if (XF86VidModeGetAllModeLines(dpy, DefaultScreen(dpy), &numSettings, &vidmodes)) {		XFree(vidmodes);	}#else	/* We only have one X11 setting at the moment. */	GHOST_ASSERT(display < 1, "Only single display systems are currently supported./n");	numSettings = 1;#endif	return GHOST_kSuccess;}

GHOST_TSuccessGHOST_DisplayManagerX11::getDisplaySetting(		GHOST_TUns8 display,		GHOST_TInt32 index,		GHOST_DisplaySetting& setting) const{	Display *dpy = m_system->getXDisplay();	if (dpy == NULL)		return GHOST_kFailure;	(void)display;#ifdef WITH_X11_XF86VMODE	int majorVersion, minorVersion;	GHOST_ASSERT(display < 1, "Only single display systems are currently supported./n");	majorVersion = minorVersion = 0;	if (XF86VidModeQueryVersion(dpy, &majorVersion, &minorVersion)) {		XF86VidModeModeInfo **vidmodes;		int numSettings;		if (XF86VidModeGetAllModeLines(dpy, DefaultScreen(dpy), &numSettings, &vidmodes)) {			GHOST_ASSERT(index < numSettings, "Requested setting outside of valid range./n");			setting.xPixels = vidmodes[index]->hdisplay;			setting.yPixels = vidmodes[index]->vdisplay;			setting.bpp = DefaultDepth(dpy, DefaultScreen(dpy));			setting.frequency = calculate_rate(vidmodes[index]);			XFree(vidmodes);			return GHOST_kSuccess;		}	}	else {		fprintf(stderr, "Warning: XF86VidMode extension missing!/n");		/* fallback to non xf86vmode below */	}#endif  /* WITH_X11_XF86VMODE */	GHOST_ASSERT(display < 1, "Only single display systems are currently supported./n");	GHOST_ASSERT(index < 1, "Requested setting outside of valid range./n");	(void)index;	setting.xPixels  = DisplayWidth(dpy, DefaultScreen(dpy));	setting.yPixels = DisplayHeight(dpy, DefaultScreen(dpy));	setting.bpp = DefaultDepth(dpy, DefaultScreen(dpy));	setting.frequency = 60.0f;	return GHOST_kSuccess;}

void GHOST_EventManager::disposeEvents(){	while (m_handled_events.empty() == false) {		GHOST_ASSERT(m_handled_events[0], "invalid event");		delete m_handled_events[0];		m_handled_events.pop_front();	}	while (m_events.empty() == false) {		GHOST_ASSERT(m_events[0], "invalid event");		delete m_events[0];		m_events.pop_front();	}}

GHOST_TSuccess GHOST_WindowManager::beginFullScreen(GHOST_IWindow *window,		bool /*stereoVisual*/){	GHOST_TSuccess success = GHOST_kFailure;	GHOST_ASSERT(window, "GHOST_WindowManager::beginFullScreen(): invalid window");	GHOST_ASSERT(window->getValid(), "GHOST_WindowManager::beginFullScreen(): invalid window");	if (!getFullScreen()) {		m_fullScreenWindow = window;		m_activeWindowBeforeFullScreen = getActiveWindow();		setActiveWindow(m_fullScreenWindow);		m_fullScreenWindow->beginFullScreen();		success = GHOST_kSuccess;	}	return success;}

GHOST_TSuccess GHOST_DisplayManagerWin32::getDisplaySetting(GHOST_TUns8 display, GHOST_TInt32 index, GHOST_DisplaySetting& setting) const{	GHOST_ASSERT((display==kMainDisplay), "GHOST_DisplayManagerWin32::getDisplaySetting(): only main display is supported");	GHOST_TSuccess success;	DEVMODE dm;	if (::EnumDisplaySettings(NULL, index, &dm)) {#ifdef GHOST_DEBUG		printf("display mode: width=%d, height=%d, bpp=%d, frequency=%d/n", dm.dmPelsWidth, dm.dmPelsHeight, dm.dmBitsPerPel, dm.dmDisplayFrequency);#endif // GHOST_DEBUG		setting.xPixels		= dm.dmPelsWidth;		setting.yPixels		= dm.dmPelsHeight;		setting.bpp			= dm.dmBitsPerPel;		/* When you call the EnumDisplaySettings function, the dmDisplayFrequency member		 * may return with the value 0 or 1. These values represent the display hardware's		 * default refresh rate. This default rate is typically set by switches on a display 		 * card or computer motherboard, or by a configuration program that does not use 		 * Win32 display functions such as ChangeDisplaySettings. 		 */		/* First, we tried to explicitly set the frequency to 60 if EnumDisplaySettings		 * returned 0 or 1 but this doesn't work since later on an exact match will		 * be searched. And this will never happen if we change it to 60. Now we rely		 * on the default h/w setting.		 */		setting.frequency = dm.dmDisplayFrequency;		success = GHOST_kSuccess;	}	else {		success = GHOST_kFailure;	}	return success;}

GHOST_TSuccess GHOST_System::beginFullScreen(const GHOST_DisplaySetting& setting, GHOST_IWindow **window,                                             const bool stereoVisual, const bool alphaBackground, const GHOST_TUns16 numOfAASamples){	GHOST_TSuccess success = GHOST_kFailure;	GHOST_ASSERT(m_windowManager, "GHOST_System::beginFullScreen(): invalid window manager");	if (m_displayManager) {		if (!m_windowManager->getFullScreen()) {			m_displayManager->getCurrentDisplaySetting(GHOST_DisplayManager::kMainDisplay, m_preFullScreenSetting);			//GHOST_PRINT("GHOST_System::beginFullScreen(): activating new display settings/n");			success = m_displayManager->setCurrentDisplaySetting(GHOST_DisplayManager::kMainDisplay, setting);			if (success == GHOST_kSuccess) {				//GHOST_PRINT("GHOST_System::beginFullScreen(): creating full-screen window/n");				success = createFullScreenWindow((GHOST_Window **)window, setting, stereoVisual, alphaBackground, numOfAASamples);				if (success == GHOST_kSuccess) {					m_windowManager->beginFullScreen(*window, stereoVisual);				}				else {					m_displayManager->setCurrentDisplaySetting(GHOST_DisplayManager::kMainDisplay, m_preFullScreenSetting);				}			}		}	}	if (success == GHOST_kFailure) {		GHOST_PRINT("GHOST_System::beginFullScreen(): could not enter full-screen mode/n");	}	return success;}

GHOST_IWindow *GHOST_SystemCarbon::createWindow(		const STR_String& title,		GHOST_TInt32 left,		GHOST_TInt32 top,		GHOST_TUns32 width,		GHOST_TUns32 height,		GHOST_TWindowState state,		GHOST_TDrawingContextType type,		bool stereoVisual,		const GHOST_TUns16 numOfAASamples,		const GHOST_TEmbedderWindowID parentWindow){	GHOST_IWindow *window = 0;	window = new GHOST_WindowCarbon(title, left, top, width, height, state, type);	if (window) {		if (window->getValid()) {			// Store the pointer to the window			GHOST_ASSERT(m_windowManager, "m_windowManager not initialized");			m_windowManager->addWindow(window);			m_windowManager->setActiveWindow(window);			pushEvent(new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowSize, window));		}		else {			GHOST_PRINT("GHOST_SystemCarbon::createWindow(): window invalid/n");			delete window;			window = 0;		}	}	else {		GHOST_PRINT("GHOST_SystemCarbon::createWindow(): could not create window/n");	}	return window;}

void GHOST_WindowCarbon::setTitle(const STR_String& title){    GHOST_ASSERT(getValid(), "GHOST_WindowCarbon::setTitle(): window invalid")    Str255 title255;    gen2mac(title, title255);	::SetWTitle(m_windowRef, title255);}

GHOST_TSuccess GHOST_DisplayManagerCarbon::setCurrentDisplaySetting(GHOST_TUns8 display, const GHOST_DisplaySetting& setting){	GHOST_ASSERT((display==kMainDisplay), "GHOST_DisplayManagerCarbon::setCurrentDisplaySetting(): only main display is supported");#ifdef GHOST_DEBUG	printf("GHOST_DisplayManagerCarbon::setCurrentDisplaySetting(): requested settings:/n");	printf("  setting.xPixels=%d/n", setting.xPixels);	printf("  setting.yPixels=%d/n", setting.yPixels);	printf("  setting.bpp=%d/n", setting.bpp);	printf("  setting.frequency=%d/n", setting.frequency);#endif // GHOST_DEBUG	CFDictionaryRef displayModeValues = ::CGDisplayBestModeForParametersAndRefreshRate(		m_displayIDs[display],		(size_t)setting.bpp,		(size_t)setting.xPixels,		(size_t)setting.yPixels,		(CGRefreshRate)setting.frequency,		NULL);#ifdef GHOST_DEBUG	printf("GHOST_DisplayManagerCarbon::setCurrentDisplaySetting(): switching to:/n");	printf("  setting.xPixels=%d/n", getValue(displayModeValues, kCGDisplayWidth));	printf("  setting.yPixels=%d/n", getValue(displayModeValues, kCGDisplayHeight));	printf("  setting.bpp=%d/n", getValue(displayModeValues, kCGDisplayBitsPerPixel));	printf("  setting.frequency=%d/n", getValue(displayModeValues, kCGDisplayRefreshRate));#endif // GHOST_DEBUG	CGDisplayErr err = ::CGDisplaySwitchToMode(m_displayIDs[display], displayModeValues);        	return err == CGDisplayNoErr ? GHOST_kSuccess : GHOST_kFailure;}

voidGHOST_SystemSDL::addDirtyWindow(GHOST_WindowSDL *bad_wind){	GHOST_ASSERT((bad_wind != NULL), "addDirtyWindow() NULL ptr trapped (window)");	m_dirty_windows.push_back(bad_wind);}

void GHOST_EventManager::disposeEvents(){	while (m_events.size() > 0) {		GHOST_ASSERT(m_events[0], "invalid event");		delete m_events[0];		m_events.pop_front();	}}

GHOST_SystemCarbon::GHOST_SystemCarbon() :	m_modifierMask(0){	m_displayManager = new GHOST_DisplayManagerCarbon();	GHOST_ASSERT(m_displayManager, "GHOST_SystemCarbon::GHOST_SystemCarbon(): m_displayManager==0/n");	m_displayManager->initialize();	UnsignedWide micros;	::Microseconds(&micros);	m_start_time = UnsignedWideToUInt64(micros) / 1000;	m_ignoreWindowSizedMessages = false;}

GHOST_TSuccessGHOST_DisplayManagerSDL::getDisplaySetting(GHOST_TUns8 display,        GHOST_TInt32 index,        GHOST_DisplaySetting& setting) const{    GHOST_ASSERT(display < 1, "Only single display systems are currently supported./n");    int i;    SDL_Rect **vidmodes;    /* NULL is passed in here to get the modes for the current bit depth.     * Other bit depths may be possible; in that case, an SDL_PixelFormat struct     * should be passed in. To get a complete profile, all possible bit depths     * would need to be iterated over. - z0r */    vidmodes = SDL_ListModes(NULL, SDL_HWSURFACE | SDL_OPENGL |                             SDL_FULLSCREEN | SDL_HWPALETTE);    if (!vidmodes) {        fprintf(stderr, "Could not get available video modes: %s./n",                SDL_GetError());        return GHOST_kFailure;    }    for (i = 0; vidmodes[i]; i++);    GHOST_ASSERT(index < i, "Requested setting outside of valid range./n");    setting.xPixels = vidmodes[index]->w;    setting.yPixels = vidmodes[index]->h;    SDL_Surface *surf;    surf = SDL_GetVideoSurface();    if (surf == NULL) {        fprintf(stderr, "Getting display setting: %s/n", SDL_GetError());        /* Just guess the bit depth */        setting.bpp = 32;    } else {        setting.bpp = surf->format->BitsPerPixel;    }    /* Just guess the frequency :( */    setting.frequency = 60;    return GHOST_kSuccess;}

GHOST_TSuccess GHOST_EventManager::pushEvent(GHOST_IEvent* event){	GHOST_TSuccess success;	GHOST_ASSERT(event, "invalid event");	if (m_events.size() < m_events.max_size()) {		m_events.push_front(event);		success = GHOST_kSuccess;	}	else {		success = GHOST_kFailure;	}	return success;}

GHOST_TSuccessGHOST_DisplayManager::findMatch(		GHOST_TUns8 display,		const GHOST_DisplaySetting& setting,		GHOST_DisplaySetting& match) const{	GHOST_TSuccess success = GHOST_kSuccess;	GHOST_ASSERT(m_settingsInitialized, "GHOST_DisplayManager::findMatch(): m_settingsInitialized=false");	int criteria[4] = {		(int)setting.xPixels,		(int)setting.yPixels,		(int)setting.bpp,		(int)setting.frequency	};	int capabilities[4];	double field, score;	double best = 1e12; // A big number	int found = 0;	// Look at all the display modes	for (int i = 0; (i < (int)m_settings[display].size()); i++) {		// Store the capabilities of the display device		capabilities[0] = m_settings[display][i].xPixels;		capabilities[1] = m_settings[display][i].yPixels;		capabilities[2] = m_settings[display][i].bpp;		capabilities[3] = m_settings[display][i].frequency;		// Match against all the fields of the display settings		score = 0;		for (int j = 0; j < 4; j++) {			field = capabilities[j] - criteria[j];			score += field * field;		}		if (score < best) {			found = i;			best = score;		}	}		match = m_settings[display][found];		GHOST_PRINT("GHOST_DisplayManager::findMatch(): settings of match:/n");	GHOST_PRINT("  setting.xPixels=" << match.xPixels << "/n");	GHOST_PRINT("  setting.yPixels=" << match.yPixels << "/n");	GHOST_PRINT("  setting.bpp=" << match.bpp << "/n");	GHOST_PRINT("  setting.frequency=" << match.frequency << "/n");	return success;}

void GHOST_NDOFManager::sendButtonEvent(NDOF_ButtonT button, bool press, GHOST_TUns64 time, GHOST_IWindow *window){	GHOST_ASSERT(button > NDOF_BUTTON_NONE && button < NDOF_BUTTON_LAST,	             "rogue button trying to escape NDOF manager");	GHOST_EventNDOFButton *event = new GHOST_EventNDOFButton(time, window);	GHOST_TEventNDOFButtonData *data = (GHOST_TEventNDOFButtonData *) event->getData();	data->action = press ? GHOST_kPress : GHOST_kRelease;	data->button = button;#ifdef DEBUG_NDOF_BUTTONS	printf("%s %s/n", ndof_button_names[button], press ? "pressed" : "released");#endif	m_system.pushEvent(event);}