public Terrain(Device device, String texture, int pitch, Renderer renderer)
 {
     HeightMap = new System.Drawing.Bitmap(@"Data/Textures/"+texture);
     WaterShader = new WaterShader(device);
     TerrainShader = new TerrainShader(device);
     _width = HeightMap.Width-1;
     _height = HeightMap.Height-1;
     _pitch = pitch;
     _terrainTextures = new ShaderResourceView[4];
     _terrainTextures[0] = new Texture(device, "Sand.png").TextureResource;
     _terrainTextures[1] = new Texture(device, "Grass.png").TextureResource;
     _terrainTextures[2] = new Texture(device, "Ground.png").TextureResource;
     _terrainTextures[3] = new Texture(device, "Rock.png").TextureResource;
     _reflectionClippingPlane = new Vector4(0.0f, 1.0f, 0.0f, 0.0f);
     _refractionClippingPlane = new Vector4(0.0f, -1.0f, 0.0f, 0.0f);
     _noClippingPlane = new Vector4(0.0f, 1.0f, 0.0f, 10000);
     _reflectionTexture = new RenderTexture(device, renderer.ScreenSize);
     _refractionTexture = new RenderTexture(device, renderer.ScreenSize);
     _renderer = renderer;
     _bitmap = new Bitmap(device,_refractionTexture.ShaderResourceView,renderer.ScreenSize, new Vector2I(100, 100), 0);
     _bitmap.Position = new Vector2I(renderer.ScreenSize.X - 100, 0);
     _bitmap2 = new Bitmap(device, _reflectionTexture.ShaderResourceView, renderer.ScreenSize, new Vector2I(100, 100), 0);
     _bitmap2.Position = new Vector2I(renderer.ScreenSize.X - 100, 120);
     _bumpMap = _renderer.TextureManager.Create("OceanWater.png");
     _skydome = new ObjModel(device, "skydome.obj", renderer.TextureManager.Create("Sky.png"));
     BuildBuffers(device);
     WaveTranslation = new Vector2(0,0);
 }

	/// <summary>
	/// 
	/// </summary>
	void Awake()
	{

		m_Transform = transform;

		// the muzzleflash is meant to use the 'Particles/Additive'
		// (unity default) shader which has the 'TintColor' property
		m_Color = renderer.material.GetColor("_TintColor");
		m_Color.a = 0.0f;

		m_ForceShow = false;

		// if a light is present in the prefab we will cache and use it
		m_Light = light;
		if (m_Light != null)
		{
			m_LightIntensity = m_Light.intensity;
			m_Light.intensity = 0.0f;
		}

		m_Renderer = renderer;
		if (m_Renderer != null)
			m_Material = renderer.material;

	}

	// Use this for initialization
	void Start () 
	{
		index = 0;
		_renderer = GetComponent<Renderer> ();
		//renderer.enabled=true;

	}

 void EntersFog()
 {
     smoke = GameObject.Find ("Smoke");
     smokeRenderer = smoke.GetComponent<Renderer> ();
     smokeRenderer.enabled = true;
     player.purityEnabled = true;
 }

 void Start()
 {
     rend = GetComponent<Renderer>();
     rend.enabled = true;
     hookStartPos = this.transform.position;
     lineStartPos = line.transform.position;
 }

    public static Bounds GetBounds(Renderer r)
    {
        if (r is SkinnedMeshRenderer) {
            SkinnedMeshRenderer smr = r as SkinnedMeshRenderer;
            Mesh mesh = smr.sharedMesh;

            Vector3[] vertices = mesh.vertices;
            if (vertices.Length <= 0) {
                return r.bounds;
            }
            int idx = 0;
            Vector3 min, max;
            min = max = r.transform.TransformPoint (vertices [idx++]);

            for (int i = idx; i < vertices.Length; i++) {
                Vector3 v = vertices [i];
                Vector3 V = r.transform.TransformPoint (v);
                for (int n = 0; n < 3; n++) {
                    if (V [n] > max [n])
                        max [n] = V [n];
                    if (V [n] < min [n])
                        min [n] = V [n];
                }
            }

            Bounds b = new Bounds ();;
            b.SetMinMax (min, max);
            return b;

        } else {
            return r.bounds;
        }
    }

    void Start()
    {
        rend = GetComponentInChildren<Renderer>();
        //skammekrog = false;

        //mouse = GameObject.Find("CylinderMouse");
    }

    //    private Item m_item;
    private void Start()
    {
        m_sphereCollider = this.GetComponent<SphereCollider>();
        m_renderer = this.GetComponent<Renderer>();

        //m_item = new Item(itemName, itemDesc, itemID, itemType);
    }

    // Use this for initialization
    void Start()
    {
        quad = transform.Find("Quad");
        quadRenderer = quad.renderer;

        UvProjector.ProjectUvs(new Transform[]{quad}, cameraAnchor, Camera.main);
    }

 void Awake()
 {
     s_moneycalc = money.GetComponent<moneycalc>();
     renderer = gameObject.GetComponent<Renderer>();
     go_GUI = GameObject.Find("GUI");
     s_selecttower = go_GUI.GetComponent<selecttower>();
 }

        /// <summary>
        /// Constructs a new instance.
        /// </summary>
        /// <param name="width">The width of the backing store in pixels.</param>
        /// <param name="height">The height of the backing store in pixels.</param>
        /// <param name="renderer">GWEN renderer.</param>
        public TextRenderer(int width, int height, Renderer.OpenTK renderer)
        {
            if (width <= 0)
                throw new ArgumentOutOfRangeException("width");
            if (height <= 0)
                throw new ArgumentOutOfRangeException("height");
            if (GraphicsContext.CurrentContext == null)
                throw new InvalidOperationException("No GraphicsContext is current on the calling thread.");

            bmp = new Bitmap(width, height, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
            gfx = Graphics.FromImage(bmp);

            // NOTE:    TextRenderingHint.AntiAliasGridFit looks sharper and in most cases better
            //          but it comes with a some problems.
            //
            //          1.  Graphic.MeasureString and format.MeasureCharacterRanges 
            //              seem to return wrong values because of this.
            //
            //          2.  While typing the kerning changes in random places in the sentence.
            // 
            //          Until 1st problem is fixed we should use TextRenderingHint.AntiAlias...  :-(

            gfx.TextRenderingHint = TextRenderingHint.AntiAlias;
            gfx.Clear(Color.Transparent);
            texture = new Texture(renderer) {Width = width, Height = height};
        }

    //for moving object based on gaze coordinates from tracker
    //based on resolution of window
    //receives object, renderer, bounds script, and data script
    //returns vector3 position in world coordinates
    public Vector3 positionObjectWithRendererBoundsData(GameObject theObject, Renderer theRenderer, Bounds theBounds, GazeDataManager theData) {
        //verify the gaze data
        if (theData.gazeCoords != null) {
            //convert gaze coords to screen coords
            Point2D screenCoords = DataUtilities.gazePointToWindowPoint(theData.gazeCoords);

            //convert window coords to viewport coords
            Point2D viewCoords = DataUtilities.windowPointToViewPoint(screenCoords);
            Vector3 viewVector = new Vector3((float)viewCoords.X, (float)(viewCoords.Y), 0);

            //check bounds
            //use the object with the outermost bounds and a renderer to make the check
            Vector3 boundsVector = theBounds.checkBoundsForRenderer(theRenderer, viewVector);

            //convert viewport vector to world position vector
            Vector3 worldPos = Camera.main.ViewportToWorldPoint(boundsVector);
            worldPos.z = theObject.transform.position.z; //maintain z position for object

            //return new world position
            return worldPos;

        }
        //error
        else {
            //Debug.Log("[GazeMove] Null gaze data, " + theObject.name + " cannot be positioned");
            return Vector3.zero;
        }
    } //end function

 public void SetBright(Renderer[] brightItem,int brightIndex)
 {
     for (int i=0; i<7; i++) {
         ((Renderer)brightItem.GetValue (i)).material.color = new Color(((Renderer)brightItem.GetValue (i)).material.color.r,((Renderer)brightItem.GetValue (i)).material.color.g,((Renderer)brightItem.GetValue (i)).material.color.b,.5f);
     }
     ((Renderer)brightItem.GetValue (brightIndex-1)).material.color = new Color(((Renderer)brightItem.GetValue (brightIndex-1)).material.color.r,((Renderer)brightItem.GetValue (brightIndex-1)).material.color.g,((Renderer)brightItem.GetValue (brightIndex-1)).material.color.b,1f);
 }

	// Use this for initialization
	void Start () {
		_renderer = GetComponent<Renderer>();
		_renderer.material.shader = Shader.Find("MK/MKGlow/Transparent/DiffuseRim");



	}

    // Use this for initialization
    void Start()
    {
        rend = GetComponent<Renderer> ();

        clipRange = rend.material.GetFloat ("_ClipRange");
        range = rend.material.GetVector ("_Range").x;
    }

 // Use this for initialization
 void Start()
 {
     rend = GetComponent<Renderer>();
     pl = GameObject.FindGameObjectWithTag("Player");
     Physics2D.IgnoreCollision(GetComponent<Collider2D>(), pl.GetComponent<Collider2D>());
     Physics2D.IgnoreCollision(GetComponent<Collider2D>(), pl.GetComponent<CircleCollider2D>());
 }

	void Awake()
	{
		mytransform = transform;
		myrenderer = GetComponent<Renderer>();
		size = Vector2.one * 0.25f;
		gameObject.active = false;
	}

	void Start()
	{
		instance = this;
		popRend = GameObject.Find ("ControlPadPop2").GetComponent<Renderer>();

		//lev 1
		if(LevelFinishedController.instance.getLevel() == FloorInstructions.instance.firstLightLevel)
		{
			transform.position = offScreen;
			popRend.material.mainTexture = Resources.Load("PopTextures/HighFivePop") as Texture;
		}
		/*
		//lev 2
		else if(LevelFinishedController.instance.getLevel() == FloorInstructions.instance.firstTriggerLevel)
		{
			transform.position = triggerLev;
			popRend.material.mainTexture = Resources.Load("PopTextures/SwitchPop") as Texture;
		}
		//lev 3
		else if(LevelFinishedController.instance.getLevel() == FloorInstructions.instance.firstZapLevel)
		{
			transform.position = zapLev;
			popRend.material.mainTexture = Resources.Load("PopTextures/ControlePadZap") as Texture;
		}
		//lev 4
		else if(LevelFinishedController.instance.getLevel() == FloorInstructions.instance.firstDecoyLevel)
		{
			transform.position = decoyLev;
			popRend.material.mainTexture = Resources.Load("PopTextures/ControlePadDecoy") as Texture;
		}
		*/
	}

        public override void Draw(Renderer renderer)
        {
            if (!isVisible) return;
            if (AnimatedTexture == null)
            {
                base.Draw(renderer);
                return;
            }

            Main.renderer.Draw(bg, new Rectangle((int)position.X, (int)position.Y, (int)Size.X, (int)Size.Y),
                Color.White * 0.95f * globalopacity);
            if (IsIn(InputEngine.curMouse.X,InputEngine.curMouse.Y) && !IsFading)
            {
                if (Utilities.Tools.IsRunningOnMono())
                {
                    Main.renderer.Draw(mono_fbo, new Rectangle(0, 0, Main.WindowWidth, Main.WindowHeight), Color.White);
                }
                else
                {
                    DrawStencilView();
                    Main.renderer.BeginUnscaled();
                }
            }
            else
            {
                Main.renderer.Draw(CurTexture, new Rectangle((int)position.X, (int)position.Y, (int)Size.X, (int)Size.Y),
                    new Color(255, 255, 175) * textopacity * globalopacity);
            }
        }

    void Start()
    {
        player = GetComponent<Player>();
		audioSource = GetComponent<AudioSource>();
		quadRenderer = GetComponentInChildren<Renderer>();
		startColor = quadRenderer.material.color;

        victoryText.text = "";
        health = 100;
     	
		if(winCount == null) {
			winCount = new int[2];
			winCount[0] = 0;
			winCount[1] = 0;
		}

        deadNow = false;
        if (winCount[player.number] > 0)
        {

            winCountText.text = winCount[player.number].ToString();
            winCountText.text += winCount[player.number] == 1 ? " WIN" : " WINS";
            winCountText.gameObject.SetActive(true);
        }
        Debug.Log("Player " + player.number + "win count = " + winCount[player.number]);
    }