public Logo(LTexture texture)
 {
     this.logo = texture;
     this.curTime = 60;
     this.curFrame = 0;
     this.inToOut = true;
 }

		public LPaper(LTexture background, int x, int y):base(x, y, background.GetWidth(), background.GetHeight()) {
			this.customRendering = true;
			this.SetBackground(background);
			this.SetElastic(true);
			this.SetLocked(true);
			this.SetLayer(100);
		}

		public void DrawWidth(GLEx g, int x, int y) {
			try {
				if (drawTexWidth == null) {
					LImage img = LImage.CreateImage(width, height, true);
					LGraphics gl = img.GetLGraphics();
					for (int i = 0; i < width; i++) {
						gl.SetColor(
								(start.GetRed() * (width - i)) / width
										+ (end.GetRed() * i) / width,
								(start.GetGreen() * (width - i)) / width
										+ (end.GetGreen() * i) / width,
								(start.GetBlue() * (width - i)) / width
										+ (end.GetBlue() * i) / width, alpha);
						gl.DrawLine(i, 0, i, height);
					}
					drawTexWidth = new LTexture(GLLoader.GetTextureData(img),
							Loon.Core.Graphics.Opengl.LTexture.Format.SPEED);
					gl.Dispose();
					gl = null;
				}
				g.DrawTexture(drawTexWidth, x, y);
			} catch (Exception) {
				for (int i = 0; i < width; i++) {
					g.SetColorValue(
							(start.GetRed() * (width - i)) / width
									+ (end.GetRed() * i) / width,
							(start.GetGreen() * (width - i)) / width
									+ (end.GetGreen() * i) / width,
							(start.GetBlue() * (width - i)) / width
									+ (end.GetBlue() * i) / width, alpha);
					g.DrawLine(i + x, y, i + x, y + height);
				}
			}
		}

	public  static LTextureBatch BindBatchCache( int index,
			 LTexture texture) {
		if (texture == null) {
			return null;
		}
		int texId = texture.textureID;
		return BindBatchCache(index, texId, texture);
	}

 public LTextureRegion(LTexture texture, int x, int y, int width, int height)
 {
     if (texture == null)
     {
         throw new Exception("texture cannot be null.");
     }
     this.texture = texture;
     SetRegion(x, y, width, height);
 }

		public Picture(LTexture image, int x, int y) {
			if (image != null) {
				this.SetImage(image);
				this.width = image.GetWidth();
				this.height = image.GetHeight();
			}
			this.SetLocation(x, y);
			this.visible = true;
		}

		public SpriteSheet(LTexture img, int tw, int th, int s, int m) {
			this.width = img.GetWidth();
			this.height = img.GetHeight();
			this.target = img;
			this.tw = tw;
			this.th = th;
			this.margin = m;
			this.spacing = s;
		}

 public OutEffect(LTexture t, RectBox limit, int code)
 {
     this.texture = t;
     this.type = code;
     this.width = t.Width;
     this.height = t.Height;
     this.multiples = 1;
     this.limit = limit;
     this.visible = true;
 }

		public override void CreateUI(GLEx g, int x, int y, LComponent component,
				LTexture[] buttonImage) {
			if (visible && goalPath != null) {
				g.SetLineWidth(lineWidth);
				g.SetColor(color);
				g.Draw(goalPath);
				g.ResetLineWidth();
				g.ResetColor();
			}
		}

		public LControl(int x, int y, LTexture basefile, LTexture dot, int bw,
				int bh, int dw, int dh):base(x, y, bw, bh) {
			this.controlBase = basefile;
			this.controlDot = dot;
			this.baseWidth = bw;
			this.baseHeight = bh;
			this.dotWidth = dw;
			this.dotHeight = dh;
			this.allowDiagonal = true;
			this.CenterOffset();
		}

 public static LTransition NewCross(int c, LTexture texture)
 {
     if (GLEx.Self != null)
     {
         LTransition transition = new LTransition();
         transition.SetTransitionListener(new _Cross(c, texture));
         transition.SetDisplayGameUI(true);
         transition.code = 1;
         return transition;
     }
     return null;
 }

	private void Init(LTexture tex2d, float limit, bool remove, float scale) {
		this.isVisible = true;
		this.expandLimit = limit;
		this.width = tex2d.GetWidth();
		this.height = tex2d.GetHeight();
		this.scaleWidth = (int) (width * scale);
		this.scaleHeight = (int) (height * scale);
		this.loopMaxCount = (MathUtils.Max(scaleWidth, scaleHeight) / 2) + 1;
		this.fractions = new float[(scaleWidth * scaleHeight) * maxElements];
		this.exWidth = (int) (scaleWidth * expandLimit);
		this.exHeigth = (int) (scaleHeight * expandLimit);
		LImage image = tex2d.GetImage().ScaledInstance(scaleWidth, scaleHeight);
		Color[] pixels = image.GetPixels();
		if (image != null) {
			image.Dispose();
			image = null;
		}
		this.size = pixels.Length;
		this.pixmap = new LPixmapData(exWidth, exHeigth, true);
		int no = 0, idx = 0;
        int length = fractions.Length;
		float angle = 0;
		float speed = 0;
		System.Random random = LSystem.random;
		for (int y = 0; y < scaleHeight; y++) {
			for (int x = 0; x < scaleWidth; x++) {
				if (idx + maxElements < length) {
					no = y * scaleWidth + x;
					angle = random.Next(360);
                    speed = 10f / random.Next(30);
					fractions[idx + 0] = x;
					fractions[idx + 1] = y;
					fractions[idx + 2] = (MathUtils.Cos(angle * MathUtils.PI
							/ 180) * speed);
					fractions[idx + 3] = (MathUtils.Sin(angle * MathUtils.PI
							/ 180) * speed);
					fractions[idx + 4] = (pixels[no].PackedValue == 0xff00 ? 0xffffff
							: pixels[no].PackedValue);
					fractions[idx + 5] = x / 6 + random.Next(10);
					idx += maxElements;
				}
			}
		}
		if (remove) {
			if (tex2d != null) {
				tex2d.Destroy();
				tex2d = null;
			}
		}
		this.tmp = tex2d;
		this.StartUsePixelThread();
	}

 public AVGScreen(string initscript, LTexture img)
 {
     if (initscript == null)
     {
         return;
     }
     this.scriptName = initscript;
     if (img != null)
     {
         this.dialogFileName = img.GetFileName();
         this.dialog = img;
     }
 }

 public void SetBackgroundCG(LTexture backgroundCG)
 {
     if (backgroundCG == this.background)
     {
         return;
     }
     if (background != null)
     {
         background.Destroy();
         background = null;
     }
     this.background = backgroundCG;
 }

		public LSelect(LTexture formImage, int x, int y, int width, int height):base(x, y, width, height) {
			if (formImage == null) {
				this.SetBackground(new LTexture(width, height, true, Loon.Core.Graphics.Opengl.LTexture.Format.SPEED));
				this.SetAlpha(0.3F);
			} else {
				this.SetBackground(formImage);
			}
			this.customRendering = true;
			this.selectFlag = 1;
			this.tmpOffset = -(width / 10);
			this.delay = new LTimer(150);
			this.autoAlpha = 0.25F;
			this.isAutoAlpha = true;
            this.SetCursor(XNAConfig.LoadTex(LSystem.FRAMEWORK_IMG_NAME + "creese.png"));
			this.SetElastic(true);
			this.SetLocked(true);
			this.SetLayer(100);
		}

 public LPad(int x, int y, LTexture b, LTexture f, LTexture d, float scale)
     : base(x, y, (int)(f.GetWidth() * scale), (int)(f.GetHeight() * scale))
 {
     this.offsetX = 6 * scale;
     this.offsetY = 6 * scale;
     this.fore = f;
     this.back = b;
     this.dot = d;
     this.dotWidth = (int)(d.GetWidth() * scale);
     this.dotHeight = (int)(d.GetHeight() * scale);
     this.baseWidth = (int)(f.GetWidth() * scale);
     this.baseHeight = (int)(f.GetHeight() * scale);
     this.backWidth = (int)(b.GetWidth() * scale);
     this.backHeight = (int)(b.GetHeight() * scale);
     this.centerX = (baseWidth - dotWidth) / 2 + offsetX;
     this.centerY = (baseHeight - dotHeight) / 2 + offsetY;
     this.scale_pad = scale;
 }

 public SplitEffect(LTexture t, RectBox limit_0, int d)
 {
     this.texture = t;
     this.width = texture.GetWidth();
     this.height = texture.GetHeight();
     this.halfWidth = width / 2;
     this.halfHeight = height / 2;
     this.multiples = 2;
     this.direction = d;
     this.limit = limit_0;
     this.timer = new LTimer(10);
     this.visible = true;
     this.v1 = new Vector2f();
     this.v2 = new Vector2f();
     switch (direction)
     {
         case Config.UP:
         case Config.DOWN:
             special = true;
             {
                 v1.Set(0, 0);
                 v2.Set(halfWidth, 0);
                 break;
             }
         case Config.TLEFT:
         case Config.TRIGHT:
             v1.Set(0, 0);
             v2.Set(halfWidth, 0);
             break;
         case Config.LEFT:
         case Config.RIGHT:
             special = true;
             {
                 v1.Set(0, 0);
                 v2.Set(0, halfHeight);
                 break;
             }
         case Config.TUP:
         case Config.TDOWN:
             v1.Set(0, 0);
             v2.Set(0, halfHeight);
             break;
     }
 }

 public static LTexture LoadTex(string name)
 {
     VaildLoon();
     LTexture texture = (LTexture)CollectionUtils.Get(texCaches, name);
     if (texture == null || texture.isClose)
     {
         try
         {
             LTextureData data = GLLoader.GetTextureData(ResourceManager.GetStream(name));
             data.fileName = name;
             texture = new LTexture(data);
             texture.isExt = true;
         }
         catch (Exception ex)
         {
             Loon.Utils.Debugging.Log.Exception(ex);
         }
         texCaches.Add(name, texture);
     }
     return texture;
 }

 public static LTexture LoadTexture(string fileName, Loon.Core.Graphics.Opengl.LTexture.Format format)
 {
     if (fileName == null)
     {
         return null;
     }
     lock (lazyTextures)
     {
         string key = fileName.Trim().ToLower();
         LTexture texture = (LTexture)CollectionUtils.Get(lazyTextures, key);
         if (texture != null && !texture.isClose)
         {
             texture.refCount++;
             return texture;
         }
         texture = new LTexture(fileName, format);
         texture.lazyName = fileName;
         CollectionUtils.Put(lazyTextures, key, texture);
         return texture;
     }
 }

 public SpriteFont(LTexture tex2d, List<RectBox> gs,
         List<RectBox> crops, List<Char> chars, int line,
         float space, List<float[]> kern, char def)
 {
     this.texture = tex2d;
     this.glyphs = gs;
     this.cropping = crops;
     this.charMap = chars;
     this.lineSpacing = 0;
     this.spacing = 0f;
     this.kerning = kern;
     this.defaultchar = def;
     Int32 max = 0;
     foreach (RectBox rect in glyphs)
     {
         if (max == null || rect.GetHeight() > max)
         {
             max = (int)rect.GetHeight();
         }
     }
     this.maxCharY = max;
 }