Commits

Alex Szpakowski committed 2c582f1

Renamed all cases of FSAA to the more accurately-named MSAA. The FSAA names (canvas:getFSAA, t.window.fsaa, etc.) still exist for now, for backwards-compatibility.

  • Participants
  • Parent commits 76dc365

Comments (0)

Files changed (16)

src/modules/graphics/Graphics.cpp

 	{"texturesize", Graphics::LIMIT_TEXTURE_SIZE},
 	{"multicanvas", Graphics::LIMIT_MULTI_CANVAS},
 	{"canvasfsaa", Graphics::LIMIT_CANVAS_FSAA},
+	{"canvasmsaa", Graphics::LIMIT_CANVAS_MSAA},
 };
 
 StringMap<Graphics::SystemLimit, Graphics::LIMIT_MAX_ENUM> Graphics::systemLimits(Graphics::systemLimitEntries, sizeof(Graphics::systemLimitEntries));

src/modules/graphics/Graphics.h

 		LIMIT_POINT_SIZE,
 		LIMIT_TEXTURE_SIZE,
 		LIMIT_MULTI_CANVAS,
-		LIMIT_CANVAS_FSAA,
+		LIMIT_CANVAS_FSAA, // For backward-compatibility. TODO: remove!
+		LIMIT_CANVAS_MSAA,
 		LIMIT_MAX_ENUM
 	};
 

src/modules/graphics/opengl/Canvas.cpp

 	}
 }
 
-Canvas::Canvas(int width, int height, Format format, int fsaa)
+Canvas::Canvas(int width, int height, Format format, int msaa)
 	: fbo(0)
     , resolve_fbo(0)
 	, texture(0)
-    , fsaa_buffer(0)
+    , msaa_buffer(0)
 	, depth_stencil(0)
 	, format(format)
-    , fsaa_samples(fsaa)
-	, fsaa_dirty(false)
+    , msaa_samples(msaa)
+	, msaa_dirty(false)
 {
 	this->width = width;
 	this->height = height;
 	unloadVolatile();
 }
 
-bool Canvas::createFSAAFBO(GLenum internalformat)
+bool Canvas::createMSAAFBO(GLenum internalformat)
 {
 	// Create our FBO without a texture.
 	status = strategy->createFBO(fbo, 0);
 	}
 
 	// Create and attach the MSAA buffer for our FBO.
-	if (strategy->createMSAABuffer(width, height, fsaa_samples, internalformat, fsaa_buffer))
+	if (strategy->createMSAABuffer(width, height, msaa_samples, internalformat, msaa_buffer))
 		status = GL_FRAMEBUFFER_COMPLETE;
 	else
 		status = GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
 	if (status != GL_FRAMEBUFFER_COMPLETE)
 	{
 		// Clean up.
-		strategy->deleteFBO(fbo, 0, fsaa_buffer);
+		strategy->deleteFBO(fbo, 0, msaa_buffer);
 		strategy->deleteFBO(resolve_fbo, 0, 0);
-		fbo = fsaa_buffer = resolve_fbo = 0;
-		fsaa_samples = 0;
+		fbo = msaa_buffer = resolve_fbo = 0;
+		msaa_samples = 0;
 	}
 
 	if (current != this)
 bool Canvas::loadVolatile()
 {
 	fbo = depth_stencil = texture = 0;
-	resolve_fbo = fsaa_buffer = 0;
+	resolve_fbo = msaa_buffer = 0;
 	status = GL_FRAMEBUFFER_COMPLETE;
 
 	// glTexImage2D is guaranteed to error in this case.
 		glGetIntegerv(GL_MAX_SAMPLES, &max_samples);
 	}
 
-	if (fsaa_samples > max_samples)
-		fsaa_samples = max_samples;
+	if (msaa_samples > max_samples)
+		msaa_samples = max_samples;
 
-	// Try to create a FSAA FBO if requested.
-	bool fsaasuccess = false;
-	if (fsaa_samples > 1)
-		fsaasuccess = createFSAAFBO(internalformat);
+	// Try to create a MSAA FBO if requested.
+	bool msaasuccess = false;
+	if (msaa_samples > 1)
+		msaasuccess = createMSAAFBO(internalformat);
 
-	// On failure (or no requested FSAA), fall back to a regular FBO.
-	if (!fsaasuccess)
+	// On failure (or no requested MSAA), fall back to a regular FBO.
+	if (!msaasuccess)
 		status = strategy->createFBO(fbo, texture);
 
 	if (status != GL_FRAMEBUFFER_COMPLETE)
 
 	clear(Color(0, 0, 0, 0));
 
-	fsaa_dirty = (fsaa_buffer != 0);
+	msaa_dirty = (msaa_buffer != 0);
 
 	return true;
 }
 
 void Canvas::unloadVolatile()
 {
-	strategy->deleteFBO(fbo, depth_stencil, fsaa_buffer);
+	strategy->deleteFBO(fbo, depth_stencil, msaa_buffer);
 	strategy->deleteFBO(resolve_fbo, 0, 0);
 
 	gl.deleteTexture(texture);
 
 	fbo = depth_stencil = texture = 0;
-	resolve_fbo = fsaa_buffer = 0;
+	resolve_fbo = msaa_buffer = 0;
 
 	for (size_t i = 0; i < attachedCanvases.size(); i++)
 		attachedCanvases[i]->release();
 	else if (screenHasSRGB)
 		glDisable(GL_FRAMEBUFFER_SRGB);
 
-	if (fsaa_buffer != 0)
-		fsaa_dirty = true;
+	if (msaa_buffer != 0)
+		msaa_dirty = true;
 }
 
 void Canvas::startGrab(const std::vector<Canvas *> &canvases)
 		if ((int) canvases.size() + 1 > gl.getMaxRenderTargets())
 			throw love::Exception("This system can't simultaniously render to %d canvases.", canvases.size()+1);
 
-		if (fsaa_samples != 0)
-			throw love::Exception("Multi-canvas rendering is not supported with FSAA.");
+		if (msaa_samples != 0)
+			throw love::Exception("Multi-canvas rendering is not supported with MSAA.");
 	}
 
 	for (size_t i = 0; i < canvases.size(); i++)
 		if (canvases[i]->getTextureFormat() != format)
 			throw love::Exception("All canvas arguments must have the same texture format.");
 
-		if (canvases[i]->getFSAA() != 0)
-			throw love::Exception("Multi-canvas rendering is not supported with FSAA.");
+		if (canvases[i]->getMSAA() != 0)
+			throw love::Exception("Multi-canvas rendering is not supported with MSAA.");
 
 		if (!canvaseschanged && canvases[i] != attachedCanvases[i])
 			canvaseschanged = true;
 	if (current != this)
 		strategy->bindFBO(previous);
 
-	if (fsaa_buffer != 0)
-		fsaa_dirty = true;
+	if (msaa_buffer != 0)
+		msaa_dirty = true;
 }
 
 bool Canvas::checkCreateStencil()
 	if (current != this)
 		strategy->bindFBO(fbo);
 
-	bool success = strategy->createStencil(width, height, fsaa_samples, depth_stencil);
+	bool success = strategy->createStencil(width, height, msaa_samples, depth_stencil);
 
 	if (current && current != this)
 		strategy->bindFBO(current->fbo);
 	GLubyte *pixels  = new GLubyte[size];
 
 	// Our texture is attached to 'resolve_fbo' when we use MSAA.
-	if (fsaa_samples > 1 && (GLEE_VERSION_3_0 || GLEE_ARB_framebuffer_object))
+	if (msaa_samples > 1 && (GLEE_VERSION_3_0 || GLEE_ARB_framebuffer_object))
 		glBindFramebuffer(GL_READ_FRAMEBUFFER, resolve_fbo);
-	else if (fsaa_samples > 1 && GLEE_EXT_framebuffer_multisample)
+	else if (msaa_samples > 1 && GLEE_EXT_framebuffer_multisample)
 		glBindFramebufferEXT(GL_READ_FRAMEBUFFER, resolve_fbo);
 	else
 		strategy->bindFBO(fbo);
 	resolveMSAA();
 
 	// Our texture is attached to 'resolve_fbo' when we use MSAA.
-	if (fsaa_samples > 1 && (GLEE_VERSION_3_0 || GLEE_ARB_framebuffer_object))
+	if (msaa_samples > 1 && (GLEE_VERSION_3_0 || GLEE_ARB_framebuffer_object))
 		glBindFramebuffer(GL_READ_FRAMEBUFFER, resolve_fbo);
-	else if (fsaa_samples > 1 && GLEE_EXT_framebuffer_multisample)
+	else if (msaa_samples > 1 && GLEE_EXT_framebuffer_multisample)
 		glBindFramebufferEXT(GL_READ_FRAMEBUFFER, resolve_fbo);
 	else if (current != this)
 		strategy->bindFBO(fbo);
 
 bool Canvas::resolveMSAA()
 {
-	if (resolve_fbo == 0 || fsaa_buffer == 0)
+	if (resolve_fbo == 0 || msaa_buffer == 0)
 		return false;
 
-	if (!fsaa_dirty)
+	if (!msaa_dirty)
 		return true;
 
 	GLuint previous = 0;
 	strategy->bindFBO(previous);
 
 	if (current != this)
-		fsaa_dirty = false;
+		msaa_dirty = false;
 
 	return true;
 }

src/modules/graphics/opengl/Canvas.h

 		FORMAT_MAX_ENUM
 	};
 
-	Canvas(int width, int height, Format format = FORMAT_NORMAL, int fsaa = 0);
+	Canvas(int width, int height, Format format = FORMAT_NORMAL, int msaa = 0);
 	virtual ~Canvas();
 
 	// Implements Volatile.
 		return format;
 	}
 
-	inline int getFSAA() const
+	inline int getMSAA() const
 	{
-		return fsaa_samples;
+		return msaa_samples;
 	}
 
 	bool resolveMSAA();
 
 private:
 
-	bool createFSAAFBO(GLenum internalformat);
+	bool createMSAAFBO(GLenum internalformat);
 
 	static Format getSizedFormat(Format format);
 	static void convertFormat(Format format, GLenum &internalformat, GLenum &externalformat, GLenum &type);
 	GLuint resolve_fbo;
 
 	GLuint texture;
-	GLuint fsaa_buffer;
+	GLuint msaa_buffer;
 	GLuint depth_stencil;
 
 	Format format;
 
 	std::vector<Canvas *> attachedCanvases;
 
-	int fsaa_samples;
-	bool fsaa_dirty;
+	int msaa_samples;
+	bool msaa_dirty;
 
 	void setupGrab();
 	void drawv(const Matrix &t, const Vertex *v);

src/modules/graphics/opengl/Graphics.cpp

 	return new ParticleSystem(texture, size);
 }
 
-Canvas *Graphics::newCanvas(int width, int height, Canvas::Format format, int fsaa)
+Canvas *Graphics::newCanvas(int width, int height, Canvas::Format format, int msaa)
 {
 	if (!Canvas::isFormatSupported(format))
 	{
 	while (GL_NO_ERROR != glGetError())
 		/* clear opengl error flag */;
 
-	Canvas *canvas = new Canvas(width, height, format, fsaa);
+	Canvas *canvas = new Canvas(width, height, format, msaa);
 	GLenum err = canvas->getStatus();
 
 	// everything ok, return canvas (early out)
 	case Graphics::LIMIT_MULTI_CANVAS:
 		limit = (double) gl.getMaxRenderTargets();
 		break;
-	case Graphics::LIMIT_CANVAS_FSAA:
+	case Graphics::LIMIT_CANVAS_FSAA: // For backward-compatibility.
+	case Graphics::LIMIT_CANVAS_MSAA:
 		if (GLEE_VERSION_3_0 || GLEE_ARB_framebuffer_object
 			|| GLEE_EXT_framebuffer_multisample)
 		{

src/modules/graphics/opengl/Graphics.h

 
 	ParticleSystem *newParticleSystem(Texture *texture, int size);
 
-	Canvas *newCanvas(int width, int height, Canvas::Format format = Canvas::FORMAT_NORMAL, int fsaa = 0);
+	Canvas *newCanvas(int width, int height, Canvas::Format format = Canvas::FORMAT_NORMAL, int msaa = 0);
 
 	Shader *newShader(const Shader::ShaderSources &sources);
 

src/modules/graphics/opengl/wrap_Canvas.cpp

 	return 1;
 }
 
-int w_Canvas_getFSAA(lua_State *L)
+int w_Canvas_getMSAA(lua_State *L)
 {
 	Canvas *canvas = luax_checkcanvas(L, 1);
-	lua_pushinteger(L, canvas->getFSAA());
+	lua_pushinteger(L, canvas->getMSAA());
 	return 1;
 }
 
 	{ "getPixel", w_Canvas_getPixel },
 	{ "clear", w_Canvas_clear },
 	{ "getFormat", w_Canvas_getFormat },
-	{ "getFSAA", w_Canvas_getFSAA },
+	{ "getMSAA", w_Canvas_getMSAA },
+	{ "getFSAA", w_Canvas_getMSAA }, // For backward-compatibility. TODO: remove!
 
 	// Deprecated since 0.9.1.
 	{ "getType", w_Canvas_getFormat },

src/modules/graphics/opengl/wrap_Canvas.h

 int w_Canvas_getPixel(lua_State * L);
 int w_Canvas_clear(lua_State *L);
 int w_Canvas_getFormat(lua_State *L);
-int w_Canvas_getFSAA(lua_State *L);
+int w_Canvas_getMSAA(lua_State *L);
 extern "C" int luaopen_canvas(lua_State *L);
 
 } // opengl

src/modules/graphics/opengl/wrap_Graphics.cpp

 	int width       = luaL_optint(L, 1, instance->getWidth());
 	int height      = luaL_optint(L, 2, instance->getHeight());
 	const char *str = luaL_optstring(L, 3, "normal");
-	int fsaa        = luaL_optint(L, 4, 0);
+	int msaa        = luaL_optint(L, 4, 0);
 
 	Canvas::Format format;
 	if (!Canvas::getConstant(str, format))
 
 	Canvas *canvas = nullptr;
 	luax_catchexcept(L,
-		[&](){ canvas = instance->newCanvas(width, height, format, fsaa); }
+		[&](){ canvas = instance->newCanvas(width, height, format, msaa); }
 	);
 
 	if (canvas == nullptr)

src/modules/window/Window.cpp

 	: fullscreen(false)
 	, fstype(Window::FULLSCREEN_TYPE_NORMAL)
 	, vsync(true)
-	, fsaa(0)
+	, msaa(0)
 	, resizable(false)
 	, minwidth(1)
 	, minheight(1)
 	{"fullscreentype", SETTING_FULLSCREEN_TYPE},
 	{"vsync", SETTING_VSYNC},
 	{"fsaa", SETTING_FSAA},
+	{"msaa", SETTING_MSAA},
 	{"resizable", SETTING_RESIZABLE},
 	{"minwidth", SETTING_MIN_WIDTH},
 	{"minheight", SETTING_MIN_HEIGHT},

src/modules/window/Window.h

 		SETTING_FULLSCREEN,
 		SETTING_FULLSCREEN_TYPE,
 		SETTING_VSYNC,
-		SETTING_FSAA,
+		SETTING_FSAA, // For backward-compatibility. TODO: remove!
+		SETTING_MSAA,
 		SETTING_RESIZABLE,
 		SETTING_MIN_WIDTH,
 		SETTING_MIN_HEIGHT,
 	bool fullscreen; // = false
 	Window::FullscreenType fstype; // = FULLSCREEN_TYPE_NORMAL
 	bool vsync; // = true
-	int fsaa; // = 0
+	int msaa; // = 0
 	bool resizable; // = false
 	int minwidth; // = 1
 	int minheight; // = 1

src/modules/window/sdl/Window.cpp

 		wflags &= testflags;
 
 		if (sdlflags != wflags || width != curMode.width || height != curMode.height
-			|| f.display != curdisplay || f.fsaa != curMode.settings.fsaa)
+			|| f.display != curdisplay || f.msaa != curMode.settings.msaa)
 		{
 			SDL_DestroyWindow(window);
 			window = 0;
 		created = false;
 
 		// In Windows and Linux, some GL attributes are set on window creation.
-		setWindowGLAttributes(f.fsaa, f.sRGB);
+		setWindowGLAttributes(f.msaa, f.sRGB);
 
 		const char *title = windowTitle.c_str();
 		int pos = f.centered ? centeredpos : uncenteredpos;
 
 		window = SDL_CreateWindow(title, pos, pos, width, height, sdlflags);
 
-		if (!window && f.fsaa > 0)
+		if (!window && f.msaa > 0)
 		{
-			// FSAA might have caused the failure, disable it and try again.
+			// MSAA might have caused the failure, disable it and try again.
 			SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 0);
 			SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 0);
 
 			window = SDL_CreateWindow(title, pos, pos, width, height, sdlflags);
-			f.fsaa = 0;
+			f.msaa = 0;
 		}
 
 		// Make sure the window keeps any previously set icon.
 
 	SDL_RaiseWindow(window);
 
-	if (!setContext(f.fsaa, f.vsync, f.sRGB))
+	if (!setContext(f.msaa, f.vsync, f.sRGB))
 		return false;
 
 	created = true;
 	return true;
 }
 
-bool Window::setContext(int fsaa, bool vsync, bool sRGB)
+bool Window::setContext(int msaa, bool vsync, bool sRGB)
 {
-	// We would normally only need to recreate the context if FSAA changes or
+	// We would normally only need to recreate the context if MSAA changes or
 	// SDL_GL_MakeCurrent is unsuccessful, but in Windows MakeCurrent can
 	// sometimes claim success but the context will actually be trashed.
 	if (context)
 	}
 
 	// Make sure the proper attributes are set.
-	setWindowGLAttributes(fsaa, sRGB);
+	setWindowGLAttributes(msaa, sRGB);
 
 	context = SDL_GL_CreateContext(window);
 
-	if (!context && fsaa > 0)
+	if (!context && msaa > 0)
 	{
-		// FSAA might have caused the failure, disable it and try again.
+		// MSAA might have caused the failure, disable it and try again.
 		SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 0);
 		SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 0);
 		context = SDL_GL_CreateContext(window);
 	// Set vertical synchronization.
 	SDL_GL_SetSwapInterval(vsync ? 1 : 0);
 
-	// Verify FSAA setting.
+	// Verify MSAA setting.
 	int buffers;
 	int samples;
 	SDL_GL_GetAttribute(SDL_GL_MULTISAMPLEBUFFERS, &buffers);
 	SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &samples);
 
 	// Don't fail because of this, but issue a warning.
-	if ((!buffers && fsaa) || (samples != fsaa))
+	if ((!buffers && msaa) || (samples != msaa))
 	{
-		std::cerr << "Warning, FSAA setting failed! (Result: buffers: " << buffers << ", samples: " << samples << ")" << std::endl;
-		fsaa = (buffers > 0) ? samples : 0;
+		std::cerr << "Warning, MSAA setting failed! (Result: buffers: " << buffers << ", samples: " << samples << ")" << std::endl;
+		msaa = (buffers > 0) ? samples : 0;
 	}
 
-	curMode.settings.fsaa = fsaa;
+	curMode.settings.msaa = msaa;
 	curMode.settings.vsync = SDL_GL_GetSwapInterval() != 0;
 
 	return true;
 }
 
-void Window::setWindowGLAttributes(int fsaa, bool /* sRGB */) const
+void Window::setWindowGLAttributes(int msaa, bool /* sRGB */) const
 {
 	// Set GL window attributes.
 	SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
 	SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 1);
 	SDL_GL_SetAttribute(SDL_GL_RETAINED_BACKING, 0);
 
-	// FSAA.
-	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, (fsaa > 0) ? 1 : 0);
-	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, (fsaa > 0) ? fsaa : 0);
+	// MSAA.
+	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, (msaa > 0) ? 1 : 0);
+	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, (msaa > 0) ? msaa : 0);
 
 	/* FIXME: Enable this code but make sure to try to re-create the window and
 	 * context with this disabled, if creation fails with it enabled.

src/modules/window/sdl/Window.h

 
 private:
 
-	bool setContext(int fsaa, bool vsync, bool sRGB);
-	void setWindowGLAttributes(int fsaa, bool sRGB) const;
+	bool setContext(int msaa, bool vsync, bool sRGB);
+	void setWindowGLAttributes(int msaa, bool sRGB) const;
 
 	// Update the saved window settings based on the window's actual state.
 	void updateSettings(const WindowSettings &newsettings);

src/modules/window/wrap_Window.cpp

 
 	settings.fullscreen = luax_boolflag(L, 3, settingName(Window::SETTING_FULLSCREEN), false);
 	settings.vsync = luax_boolflag(L, 3, settingName(Window::SETTING_VSYNC), true);
-	settings.fsaa = luax_intflag(L, 3, settingName(Window::SETTING_FSAA), 0);
+	settings.msaa = luax_intflag(L, 3, settingName(Window::SETTING_MSAA), 0);
 	settings.resizable = luax_boolflag(L, 3, settingName(Window::SETTING_RESIZABLE), false);
 	settings.minwidth = luax_intflag(L, 3, settingName(Window::SETTING_MIN_WIDTH), 1);
 	settings.minheight = luax_intflag(L, 3, settingName(Window::SETTING_MIN_HEIGHT), 1);
 	settings.highdpi = luax_boolflag(L, 3, settingName(Window::SETTING_HIGHDPI), false);
 	settings.sRGB = luax_boolflag(L, 3, settingName(Window::SETTING_SRGB), false);
 
+	// For backward-compatibility. TODO: remove!
+	int fsaa = luax_intflag(L, 3, settingName(Window::SETTING_FSAA), 0);
+	if (fsaa > settings.msaa) settings.msaa = fsaa;
+
 	// Display index is 1-based in Lua and 0-based internally.
 	settings.display--;
 
 	luax_pushboolean(L, settings.vsync);
 	lua_setfield(L, -2, settingName(Window::SETTING_VSYNC));
 
-	lua_pushinteger(L, settings.fsaa);
-	lua_setfield(L, -2, settingName(Window::SETTING_FSAA));
+	lua_pushinteger(L, settings.msaa);
+	lua_setfield(L, -2, settingName(Window::SETTING_MSAA));
+
+	lua_pushinteger(L, settings.msaa);
+	lua_setfield(L, -2, settingName(Window::SETTING_FSAA)); // For backward-compatibility. TODO: remove!
 
 	luax_pushboolean(L, settings.resizable);
 	lua_setfield(L, -2, settingName(Window::SETTING_RESIZABLE));

src/scripts/boot.lua

 			fullscreentype = "normal",
 			display = 1,
 			vsync = true,
-			fsaa = 0,
+			msaa = 0,
+			fsaa = 0, -- For backward-compatibility. TODO: remove!
 			borderless = false,
 			resizable = false,
 			centered = true,
 			fullscreen = c.window.fullscreen,
 			fullscreentype = c.window.fullscreentype,
 			vsync = c.window.vsync,
-			fsaa = c.window.fsaa,
+			fsaa = c.window.fsaa, -- For backward-compatibility. TODO: remove!
+			msaa = c.window.msaa,
 			resizable = c.window.resizable,
 			minwidth = c.window.minwidth,
 			minheight = c.window.minheight,

src/scripts/boot.lua.h

 	0x3d, 0x20, 0x22, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x22, 0x2c, 0x0a,
 	0x09, 0x09, 0x09, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x20, 0x3d, 0x20, 0x31, 0x2c, 0x0a,
 	0x09, 0x09, 0x09, 0x76, 0x73, 0x79, 0x6e, 0x63, 0x20, 0x3d, 0x20, 0x74, 0x72, 0x75, 0x65, 0x2c, 0x0a,
-	0x09, 0x09, 0x09, 0x66, 0x73, 0x61, 0x61, 0x20, 0x3d, 0x20, 0x30, 0x2c, 0x0a,
+	0x09, 0x09, 0x09, 0x6d, 0x73, 0x61, 0x61, 0x20, 0x3d, 0x20, 0x30, 0x2c, 0x0a,
+	0x09, 0x09, 0x09, 0x66, 0x73, 0x61, 0x61, 0x20, 0x3d, 0x20, 0x30, 0x2c, 0x20, 0x2d, 0x2d, 0x20, 0x46, 0x6f, 
+	0x72, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x2d, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 
+	0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x20, 0x54, 0x4f, 0x44, 0x4f, 0x3a, 0x20, 0x72, 0x65, 0x6d, 0x6f, 
+	0x76, 0x65, 0x21, 0x0a,
 	0x09, 0x09, 0x09, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x3d, 0x20, 0x66, 0x61, 
 	0x6c, 0x73, 0x65, 0x2c, 0x0a,
 	0x09, 0x09, 0x09, 0x72, 0x65, 0x73, 0x69, 0x7a, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0x66, 0x61, 0x6c, 
 	0x09, 0x09, 0x09, 0x76, 0x73, 0x79, 0x6e, 0x63, 0x20, 0x3d, 0x20, 0x63, 0x2e, 0x77, 0x69, 0x6e, 0x64, 0x6f, 
 	0x77, 0x2e, 0x76, 0x73, 0x79, 0x6e, 0x63, 0x2c, 0x0a,
 	0x09, 0x09, 0x09, 0x66, 0x73, 0x61, 0x61, 0x20, 0x3d, 0x20, 0x63, 0x2e, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 
-	0x2e, 0x66, 0x73, 0x61, 0x61, 0x2c, 0x0a,
+	0x2e, 0x66, 0x73, 0x61, 0x61, 0x2c, 0x20, 0x2d, 0x2d, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x62, 0x61, 0x63, 0x6b, 
+	0x77, 0x61, 0x72, 0x64, 0x2d, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 
+	0x2e, 0x20, 0x54, 0x4f, 0x44, 0x4f, 0x3a, 0x20, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x21, 0x0a,
+	0x09, 0x09, 0x09, 0x6d, 0x73, 0x61, 0x61, 0x20, 0x3d, 0x20, 0x63, 0x2e, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 
+	0x2e, 0x6d, 0x73, 0x61, 0x61, 0x2c, 0x0a,
 	0x09, 0x09, 0x09, 0x72, 0x65, 0x73, 0x69, 0x7a, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0x63, 0x2e, 0x77, 
 	0x69, 0x6e, 0x64, 0x6f, 0x77, 0x2e, 0x72, 0x65, 0x73, 0x69, 0x7a, 0x61, 0x62, 0x6c, 0x65, 0x2c, 0x0a,
 	0x09, 0x09, 0x09, 0x6d, 0x69, 0x6e, 0x77, 0x69, 0x64, 0x74, 0x68, 0x20, 0x3d, 0x20, 0x63, 0x2e, 0x77, 0x69,