// Use this for initialization
    void Start()
    {
        // Script References
        shipGraphics = GetComponent<ShipGraphics>();
        shipPhysicsScript = GetComponent<ShipPhysicsScript>();

        // Component Variables
        cam = GetComponentInChildren<Camera>();
        body = GetComponent<Rigidbody>();
        model = transform.Find("Model").gameObject;
        capsuleCollider = GetComponentInChildren<CapsuleCollider>();
        boxCollider = GetComponentInChildren<BoxCollider>();
        lockSound = GetComponent<AudioSource>();

        // Control Variables
        mouseSensitivity = 8.0f;
        //mouseThreshold = 8.0f;
        //buttonSensitivity = 0.05f;
        //buttonThreshold = 0.05f;

        horTranslation = 0.0f;
        verTranslation = 0.0f;

        enemyNoLock = (Material)Resources.Load("Crosshair");
        enemyLock = (Material)Resources.Load("Crosshair_Enemy");

        trackedObject = null;
        trackingResults = null;
        shootWaitTime = 0.0f;
        targetTime = 0.0f;
        hits = 0;
    }
Esempio n. 2
1
 void Init(bool ForceNewMat = false)
 {
     if (spriteRenderer == null)
     {
         spriteRenderer = GetComponent<MeshRenderer>();
     }
     if (MaterialRef == null)
     {
         MaterialRef = (Material)Resources.Load("Materials/SpriteRepeat", typeof(Material));
     }
     if (materialInstance == null || ForceNewMat)
     {
         if (!Application.isPlaying)
         {
             materialInstance = new Material(MaterialRef);
             spriteRenderer.sharedMaterial = materialInstance;
         }
         else
             materialInstance = spriteRenderer.sharedMaterial;
     }
     if (materialInstance.mainTexture != TextureToRepeat)
     {
         materialInstance.mainTexture = TextureToRepeat;
     }
     FitScale();
 }
	// Use this for initialization
	void Start ()
	{		
//		storedScreenWidth = Screen.width;
//		storedScreenHeight = Screen.height;
//		myRT = new RenderTexture(Screen.width, Screen.height, 24);
		
		storedScreenWidth = 1024;
		storedScreenHeight = 1024;
		myRT = new RenderTexture(1024, 1024, 24);
		
		myRT.format = RenderTextureFormat.ARGB32;
		myRT.filterMode = FilterMode.Point;
		myRT.isPowerOfTwo = false;
		myRT.isCubemap = false;
		myRT.Create();
		
		mat = new Material (
		"Shader \"Hidden/Invert\" {" +
		"SubShader {" +
		" Pass {" +
		" ZTest Always Cull Off ZWrite Off" +
		" SetTexture [_RenderTexy] { combine texture }" +
		" }" +
		"}" +
		"}"
		);
	}
Esempio n. 4
0
    public void ChangeFloorMaterial(Material material)
    {
        ChangeMaterial (Cell_Floor.GetChild (0), material);

        //ChangeMaterial (Cell_StairsDown.GetChild (0), material);
        //ChangeMaterial (Cell_StairsUp.GetChild (0), material);
    }
Esempio n. 5
0
	// Use this for initialization
	void Start () {
        mesh = screen.GetComponent<MeshRenderer>();
        if (mesh != null)
        {
            mat = mesh.material;
        }
	}
Esempio n. 6
0
	protected void SetGenericMaterialProperty(Material destination, string property_name, object value)
	{
		try{

			ShaderUtil.ShaderPropertyType type = GetPropertyType(destination, property_name);
			switch(type)
			{
			case ShaderUtil.ShaderPropertyType.Color:
				destination.SetColor(property_name, value.UnityBridgeObjectToColor());
				break;
			case ShaderUtil.ShaderPropertyType.Range:
			case ShaderUtil.ShaderPropertyType.Float:
				destination.SetFloat(property_name, value.UnityBridgeObjectToFloat());
				break;
			case ShaderUtil.ShaderPropertyType.Vector:
				destination.SetVector(property_name, value.UnityBridgeObjectToVector());
				break;
			case ShaderUtil.ShaderPropertyType.TexEnv:
				destination.SetTexture(property_name, TextureManager.Instance.ResolveMap( destination.name + "_" + property_name, value));
				break;
			default:
				Debug.Log("Unknown shader type " + type.ToString());
				break;
			}

		}
		catch(KeyNotFoundException e)
		{
			Debug.Log(e.Message);
		}
	}
Esempio n. 7
0
	void Start () 
	{
	
		mainLight = GetComponent<Light>();
		skyMat = RenderSettings.skybox;

	}
Esempio n. 8
0
		protected override Batch GetNewInstanceOfBatch(Material material, BlendMode blendMode,
			int numberOfQuadsToAdd)
		{
			if ((material.Shader as ShaderWithFormat).Format.Is3D)
				throw new BatchRenderer2DCannotBeUsedToRender3D(); //ncrunch: no coverage
			return new Batch2D(material, blendMode, numberOfQuadsToAdd);
		}
    void Awake()
    {
        if (camera==null) {
            Debug.LogError("SetupForGrassRendering script (at "+gameObject.name+") - can't find camera component !");
            return;
        }

        if ((useCustomDepthShader) && (SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.Depth))) {
            shad=Shader.Find("GrassRenderDepth"); // our simple depth rendering shader (rely on native z-depth buffer and don't render into color channels)
        } else {
            shad=Shader.Find("Hidden/Camera-DepthTexture"); // unity's render depth - probably slower as it renders everything into color buffer
        }
        if (!shad) {
            // we've got no shader ? Make simple one (handles native z-buffer for Opaque RenderType only)
            Material mat=new Material("Shader \"RenderDepth\" {SubShader { Tags { \"RenderType\"=\"Opaque\"} \n Pass { ColorMask 0 }}}");
            shad=mat.shader;
        }
        SetupTexture();
        GameObject go=new GameObject("GrassDepthCamera");
        go.AddComponent(typeof(Camera));
        go.transform.parent=transform;
        myCam=go.camera;
        SetupParams();

        teleportTresholdSqr = teleportTreshold * teleportTreshold;
    }
Esempio n. 10
0
    void OnEnable()
    {
        if (blitMaterial == null)
            blitMaterial = new Material(Shader.Find("Custom/SteamVR_BlitFlip"));

        camera = GetComponent<Camera>();
    }
Esempio n. 11
0
	// Use this for initialization
	void Start () {
        classpic = transform.FindChild("pic").renderer.material;
        switch (name)
        {
            case "圣骑士": myclass= CardClass.kpaladin;
                break;
            case "德鲁伊": myclass= CardClass.kdruid;
                break;
            case "战士": myclass= CardClass.kwarrior;
                break;
            case "术士": myclass= CardClass.kwarlock;
                break;

            case "法师": myclass= CardClass.kmage;
                break;
            case "潜行者": myclass= CardClass.krogue;
                break;
            case "牧师": myclass= CardClass.kpriest;
                break;
            case "猎人": myclass= CardClass.khunter;
                break;

            case "萨满祭司": myclass= CardClass.kshama;
                break;

        }
	}
Esempio n. 12
0
 void OnDisable()
 {
     if (apply) {
         DestroyImmediate (apply);
         apply = null;
     }
 }
 public void SetMaterial(string name, Material material)
 {
     if (name == "Material")
     {
         MaterialInstance.Material = material;
     }
 }
Esempio n. 14
0
    private void SetColorSpace(Material material)
    {
        switch (ColorSpace)
        {
            case TOD_ColorSpaceType.Auto:
                if (QualitySettings.activeColorSpace == UnityEngine.ColorSpace.Linear)
                {
                    material.EnableKeyword("LINEAR");
                    material.DisableKeyword("GAMMA");
                }
                else
                {
                    material.DisableKeyword("LINEAR");
                    material.EnableKeyword("GAMMA");
                }
                break;

            case TOD_ColorSpaceType.Linear:
                material.EnableKeyword("LINEAR");
                material.DisableKeyword("GAMMA");
                break;

            case TOD_ColorSpaceType.Gamma:
                material.DisableKeyword("LINEAR");
                material.EnableKeyword("GAMMA");
                break;
        }
    }
Esempio n. 15
0
 void CreateMaterials()
 {
     if (!apply) {
         apply = new Material (bloomShader);
         apply.hideFlags = HideFlags.DontSave;
     }
 }
Esempio n. 16
0
 Color ensureMaxTextContrast(Material material, TextMesh textMesh)
 {
     float red = Math.Abs(1-material.color.r);
     float green = Math.Abs(1-material.color.g);
     float blue = Math.Abs(1-material.color.b);
     return new Color (red, green, blue);
 }
Esempio n. 17
0
    private void SetColorRange(Material material)
    {
        switch (ColorRange)
        {
            case TOD_ColorRangeType.Auto:
                if (Components.Camera && Components.Camera.HDR)
                {
                    material.EnableKeyword("HDR");
                    material.DisableKeyword("LDR");
                }
                else
                {
                    material.DisableKeyword("HDR");
                    material.EnableKeyword("LDR");
                }
                break;

            case TOD_ColorRangeType.HDR:
                material.EnableKeyword("HDR");
                material.DisableKeyword("LDR");
                break;

            case TOD_ColorRangeType.LDR:
                material.DisableKeyword("HDR");
                material.EnableKeyword("LDR");
                break;
        }
    }
    public void ManualUpdate(Mesh mesh, Material outerMaterial, float outerScale)
    {
        if (Corona != null)
        {
            if (MeshFilter == null) MeshFilter = gameObject.AddComponent<MeshFilter>();

            if (MeshRenderer == null) MeshRenderer = gameObject.AddComponent<MeshRenderer>();

            if (MeshFilter.sharedMesh != mesh)
            {
                SgtHelper.BeginStealthSet(MeshFilter);
                {
                    MeshFilter.sharedMesh = mesh;
                }
                SgtHelper.EndStealthSet();
            }

            if (MeshRenderer.sharedMaterial != outerMaterial)
            {
                SgtHelper.BeginStealthSet(MeshRenderer);
                {
                    MeshRenderer.sharedMaterial = outerMaterial;
                }
                SgtHelper.EndStealthSet();
            }

            SgtHelper.SetLocalScale(transform, outerScale);
        }
    }
Esempio n. 19
0
    private IEnumerator Flash()
    {
        if (isFlashing)
        {
            yield break;
        }
        isFlashing = true;

        this.originalMaterial = GetComponent<Renderer>().material;
        if (!this.originalMaterial.HasProperty("_Emission"))
        {
            Debug.LogWarning("Doesnt have emission, can't flash " + gameObject);
            yield break;
        }

        this.originalColor = this.originalMaterial.GetColor("_Emission");
        this.originalMaterial.SetColor("_Emission", Color.white);

        for (float f = 0.0f; f <= 1.0f; f += 0.08f)
        {
            Color lerped = Color.Lerp(Color.white, this.originalColor, f);
            this.originalMaterial.SetColor("_Emission", lerped);
            yield return null;
        }

        this.originalMaterial.SetColor("_Emission", this.originalColor);
        isFlashing = false;
    }
Esempio n. 20
0
	void Start () {
//		mat = transform.FindChild ("WaterPoweredSawmillUpload").FindChild ("Floor").GetComponent<renderer> ();
		mat = transform.parent.FindChild("Material").GetComponent<Renderer>().sharedMaterials[0];

		//TODO
		//get those shared Material and change them as color changed.
	}
	static void CustomGraphicsBlit(RenderTexture src, RenderTexture dst, Material mat, int pass) {
		RenderTexture.active = dst;
		
		mat.SetTexture("_MainTex", src);
		
		GL.PushMatrix();
		GL.LoadOrtho();
		
		mat.SetPass(pass);
		
		GL.Begin(GL.QUADS);
		
		GL.MultiTexCoord2(0, 0.0f, 0.0f);
		GL.Vertex3(0.0f, 0.0f, 3.0f); // BL
		
		GL.MultiTexCoord2(0, 1.0f, 0.0f);
		GL.Vertex3(1.0f, 0.0f, 2.0f); // BR
		
		GL.MultiTexCoord2(0, 1.0f, 1.0f);
		GL.Vertex3(1.0f, 1.0f, 1.0f); // TR
		
		GL.MultiTexCoord2(0, 0.0f, 1.0f);
		GL.Vertex3(0.0f, 1.0f, 0.0f); // TL
		
		GL.End();
		GL.PopMatrix();
	}
Esempio n. 22
0
    void Awake()
    {
        //create walking ground
        plane = GameObject.CreatePrimitive(PrimitiveType.Plane);
        scale = (int)gridWorldSize.x/10; // scaling the plane gives an 10*scale x 10*scale (x-axis x z-axis) plane, set to 50
        plane.transform.localScale = new Vector3 (scale, 1, scale); //scales only in x and z dimensions
        grass = Resources.Load ("Materials/TL_Grass_01/U5_Material/TL_Grass_01_U5") as Material;
        plane.GetComponent<Renderer> ().material = grass;
        plane.layer = 11;

        //set borders
        walls.Add ((GameObject) Resources.Load("Borders/Walls/wall1"));
        walls.Add ((GameObject) Resources.Load("Borders/Walls/wall2"));
        walls.Add ((GameObject) Resources.Load("Borders/Walls/wall3"));
        walls.Add ((GameObject) Resources.Load("Borders/Walls/wall4"));
        for (int i =0; i< walls.Count; i++) {
            Instantiate (walls[i], walls[i].transform.position, walls[i].transform.rotation);
        }

        //choose skybox
        skyboxes.Add ((Material) Resources.Load("Skyboxes/skybox1"));
        skyboxes.Add ((Material) Resources.Load("Skyboxes/skybox2"));
        skyboxes.Add ((Material) Resources.Load("Skyboxes/skybox3"));
        skyboxes.Add ((Material) Resources.Load("Skyboxes/skybox4"));
        skyboxes.Add ((Material) Resources.Load("Skyboxes/skybox5"));
        int randomskybox = Random.Range (0, skyboxes.Count+1);
        if (randomskybox != skyboxes.Count) {
            RenderSettings.skybox = skyboxes [randomskybox];
        }
        RenderSettings.fog = true;

        //create roads and trees
        roadbuilder = GetComponent<GenerateRoads>();
        roadbuilder.Generate ();
    }
    public void ReplaceSelectedMaterials(Material mat, Material replacement)
    {
        pb_Editor editor = pb_Editor.instance;

            pb_Object[] pbs = FindObjectsOfType(typeof(pb_Object)) as pb_Object[];
            // Cycle through every ProBuilder Object
            foreach(pb_Object pb in pbs)
            {
                bool addToSelection = false;

                foreach(pb_Face f in pb.faces)
                {
                    if(f.material == mat)
                    {
                        addToSelection = true;

                        f.SetMaterial(rmat);

                        pb.AddToFaceSelection(f);
                    }
                }

                pb.Refresh();

                if(addToSelection)
                    editor.AddToSelection(pb.gameObject);
            }

            SceneView.RepaintAll();
    }
    static void DoStuff()
    {
        Object[] activeGOs = Selection.GetFiltered(typeof(Texture2D), SelectionMode.Assets);
        Debug.Log("Matching selection: " + activeGOs);

        foreach (Texture2D t in activeGOs){
            string path = AssetDatabase.GetAssetPath(t);
            path = path.Remove(path.LastIndexOf("/") + 1);

            string materialPath = path + t.name +"Mat.mat";

            Material material = AssetDatabase.LoadAssetAtPath(materialPath, typeof(Material)) as Material;

            if (material == null) {
                material = new Material (Shader.Find("VertexLit"));
                material.mainTexture = t;

                Debug.Log("Creating material: " + materialPath);
                AssetDatabase.CreateAsset(material, materialPath);
                EditorUtility.SetDirty(material);
            }
        }

        AssetDatabase.SaveAssets();
        AssetDatabase.Refresh();
    }
    void Awake()
    {
		if (!Application.isPlaying)
			return;

		fadeMaterial = new Material(Shader.Find("Oculus/Unlit Transparent Color"));
    }
Esempio n. 26
0
	void OnEnable()
	{
		if (overlayMaterial == null)
		{
			overlayMaterial = new Material(Shader.Find("Custom/SteamVR_Overlay"));
		}
	}
Esempio n. 27
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="name">name</param>
 /// <param name="description">description</param>
 /// <param name="price">price</param>
 /// <param name="material">material</param>
 /// <param name="manufacturer">manufacturer</param>
 /// <param name="age">age</param>
 public Watch(string name, string description, double price, Material material, string manufacturer, int age)
     : base(name, description, price)
 {
     this.material = material;
     this.manufacturer = manufacturer;
     this.age = age;
 }
Esempio n. 28
0
    public Material Bake()
    {
        Camera camera = transform.FindChild("Camera").camera;
        RenderTexture render_texture = new RenderTexture(256, 256, 24, RenderTextureFormat.Default, RenderTextureReadWrite.Default);
        render_texture.useMipMap = true;
        render_texture.filterMode = FilterMode.Trilinear;
        render_texture.mipMapBias = -0.5f;
        camera.targetTexture = render_texture;

        transform.FindChild("Title").gameObject.layer = LayerMask.NameToLayer("Active Card Render Texture");
        transform.FindChild("Rules").gameObject.layer = LayerMask.NameToLayer("Active Card Render Texture");

        Transform tile_mesh = transform.FindChild("Tile_base").FindChild("default");
        Material material = new Material(tile_mesh.renderer.material);
        material.mainTexture = render_texture;

        camera.Render();

        transform.FindChild("Title").gameObject.layer = LayerMask.NameToLayer("Card Render Texture");
        transform.FindChild("Rules").gameObject.layer = LayerMask.NameToLayer("Card Render Texture");

        Material return_material = new Material(multiply);
        return_material.mainTexture = render_texture;

        return return_material;
    }
    public void Start()
    {
        fxRes = GetComponent<IndieEffects>();
        blurMat = new Material(shader);

        previousViewProjectionMatrix = fxRes.DepthCam.camera.projectionMatrix * fxRes.DepthCam.camera.worldToCameraMatrix;
    }
Esempio n. 30
0
	private void Awake() {
		Instance = this;
		renderer = GetComponent<Renderer>();
		targetMat = new Material(renderer.material);
		targetMat.color = Color.clear;
		renderer.sharedMaterial = targetMat;
	}
 public static GameObject GenerateOutline(GameObject geometry, float lineWidth, Material material)
 {
     Vector2[] vertices = GetVertices(geometry.GetComponent <Collider2D>());
     print("Vertices " + vertices.Length);
     return(GenerateOutline(vertices, geometry.transform, lineWidth, material));
 }
Esempio n. 32
0
	public override void OnInspectorGUI()
	{
		MegaWire mod = (MegaWire)target;

		undoManager.CheckUndo();

		EditorGUIUtility.LookLikeControls();

		MegaWire.DisableAll = EditorGUILayout.Toggle("Disable All", MegaWire.DisableAll);

		if ( GUILayout.Button("Rebuild") )
		{
			mod.Rebuild = true;
			mod.RebuildWire();
		}

		mod.warmPhysicsTime = EditorGUILayout.FloatField("Warm Physics Time", mod.warmPhysicsTime);
		if ( GUILayout.Button("Run Physics") )
		{
			mod.RunPhysics(mod.warmPhysicsTime);
		}

		if ( GUILayout.Button("Open Select Window") )
		{
		}

		if ( GUILayout.Button("Add Wire") )
		{
			MegaWireConnectionDef last = mod.connections[mod.connections.Count - 1];
			MegaWireConnectionDef cdef = new MegaWireConnectionDef();
			cdef.inOffset = last.inOffset;
			cdef.outOffset = last.outOffset;
			cdef.radius = last.radius;
			mod.connections.Add(cdef);
			mod.RebuildWire();
			mod.Rebuild = true;
		}

		mod.Enabled = EditorGUILayout.Toggle("Enabled", mod.Enabled);

		bool ShowWire = EditorGUILayout.Toggle("Show Wire", mod.ShowWire);
		if ( ShowWire != mod.ShowWire )
		{
			mod.ShowWire = ShowWire;
			mod.SetWireVisible(ShowWire);
		}
		// Lod params
		mod.disableOnDistance = EditorGUILayout.BeginToggleGroup("Disable On Dist", mod.disableOnDistance);
		mod.disableDist = EditorGUILayout.FloatField("Disable Dist", mod.disableDist);
		EditorGUILayout.EndToggleGroup();

		mod.disableOnNotVisible = EditorGUILayout.Toggle("Disable On InVisible", mod.disableOnNotVisible);

		// Physics data
		mod.showphysics = EditorGUILayout.Foldout(mod.showphysics, "Physics Params");

		if ( mod.showphysics )
		{
			EditorGUILayout.BeginVertical("box");

			int points = EditorGUILayout.IntSlider("Masses", mod.points, 2, 20);
			if ( points != mod.points )
			{
				mod.points = points;
				mod.RebuildWire();
			}

			float Mass = EditorGUILayout.FloatField("Mass", mod.Mass);
			if ( Mass != mod.Mass )
			{
				mod.Mass = Mass;
				mod.RebuildWire();
			}

			float massrnd = EditorGUILayout.FloatField("Mass Random", mod.massRand);
			if ( massrnd != mod.massRand )
			{
				mod.massRand = massrnd;
				mod.RebuildWire();
			}

			float spring = EditorGUILayout.FloatField("Spring", mod.spring);
			if ( spring != mod.spring )
			{
				mod.spring = spring;
				mod.RebuildWire();
			}

			float damp = EditorGUILayout.FloatField("Damp", mod.damp);
			if ( damp != mod.damp )
			{
				mod.damp = damp;
				mod.RebuildWire();
			}

			float stretch = EditorGUILayout.FloatField("Stretch", mod.stretch);
			if ( stretch != mod.stretch )
			{
				mod.stretch = stretch;
				mod.ChangeStretch(stretch);
			}

			mod.gravity = EditorGUILayout.Vector3Field("Gravity", mod.gravity);
			mod.airdrag = EditorGUILayout.Slider("Aero Drag", mod.airdrag, 0.0f, 1.0f);

			// These require a rebuild
			bool lencon = EditorGUILayout.Toggle("Length Constraints", mod.lengthConstraints);
			if ( lencon != mod.lengthConstraints )
			{
				mod.lengthConstraints = lencon;
				mod.RebuildWire();
			}

			bool stiff = EditorGUILayout.BeginToggleGroup("Stiff Springs", mod.stiffnessSprings);
			if ( stiff != mod.stiffnessSprings )
			{
				mod.stiffnessSprings = stiff;
				mod.RebuildWire();
			}

			float stiffrate = EditorGUILayout.FloatField("Stiff Rate", mod.stiffrate);
			if ( stiffrate != mod.stiffrate )
			{
				mod.stiffrate = stiffrate;
				mod.RebuildWire();
			}

			float stiffdamp = EditorGUILayout.FloatField("Stiff Damp", mod.stiffdamp);
			if ( stiffdamp != mod.stiffdamp )
			{
				mod.stiffdamp = stiffdamp;
				mod.RebuildWire();
			}
			EditorGUILayout.EndToggleGroup();

			mod.doCollisions = EditorGUILayout.BeginToggleGroup("Do Collisions", mod.doCollisions);
			mod.floor = EditorGUILayout.FloatField("Floor", mod.floor);
			EditorGUILayout.EndToggleGroup();

			mod.showWindParams = EditorGUILayout.Foldout(mod.showWindParams, "Wind Params");
			if ( mod.showWindParams )
			{
				mod.wind = (MegaWireWind)EditorGUILayout.ObjectField("Wind Src", mod.wind, typeof(MegaWireWind), true);
				MegaWire.windDir = EditorGUILayout.Vector3Field("Wind Dir", MegaWire.windDir);
				MegaWire.windFrc = EditorGUILayout.FloatField("Wind Frc", MegaWire.windFrc);
				mod.windEffect = EditorGUILayout.FloatField("Wind Effect", mod.windEffect);
			}

			mod.showPhysicsAdv = EditorGUILayout.Foldout(mod.showPhysicsAdv, "Advanced Params");
			if ( mod.showPhysicsAdv )
			{
				mod.timeStep = EditorGUILayout.FloatField("Time Step", mod.timeStep);
				mod.fudge = EditorGUILayout.FloatField("Time Mult", mod.fudge);
				mod.startTime = EditorGUILayout.FloatField("Start Time", mod.startTime);
				mod.awakeTime = EditorGUILayout.FloatField("Awake Time", mod.awakeTime);
				mod.frameWait = EditorGUILayout.IntField("Frame Wait", mod.frameWait);
				mod.frameNum = EditorGUILayout.IntField("Frame Num", mod.frameNum);

				mod.iters = EditorGUILayout.IntSlider("Constraint Iters", mod.iters, 1, 8);
			}

			EditorGUILayout.EndVertical();
		}

		// Meshing options
		mod.showmeshparams = EditorGUILayout.Foldout(mod.showmeshparams, "Mesh Params");
		if ( mod.showmeshparams )
		{
			EditorGUILayout.BeginVertical("box");

			Material mat = (Material)EditorGUILayout.ObjectField("Material", mod.material, typeof(Material), true);
			if ( mat != mod.material )
			{
				mod.material = mat;
				for ( int i = 0; i < mod.spans.Count; i++ )
				{
					mod.spans[i].renderer.sharedMaterial = mat;
				}
			}
			mod.strandedMesher.sides = EditorGUILayout.IntSlider("Sides", mod.strandedMesher.sides, 2, 32);
			mod.strandedMesher.segments = EditorGUILayout.IntSlider("Segments", mod.strandedMesher.segments, 1, 64);
			mod.strandedMesher.SegsPerUnit = EditorGUILayout.FloatField("Segs Per Unit", mod.strandedMesher.SegsPerUnit);
			mod.strandedMesher.strands = EditorGUILayout.IntSlider("Strands", mod.strandedMesher.strands, 1, 8);
			mod.strandedMesher.offset = EditorGUILayout.FloatField("Offset", mod.strandedMesher.offset);
			mod.strandedMesher.strandRadius = EditorGUILayout.FloatField("Strand Radius", mod.strandedMesher.strandRadius);

			mod.strandedMesher.Twist = EditorGUILayout.FloatField("Twist", mod.strandedMesher.Twist);
			mod.strandedMesher.TwistPerUnit = EditorGUILayout.FloatField("Twist Per Unit", mod.strandedMesher.TwistPerUnit);

			bool genuv = EditorGUILayout.BeginToggleGroup("Gen UV", mod.strandedMesher.genuv);
			if ( genuv != mod.strandedMesher.genuv )
			{
				mod.strandedMesher.genuv = genuv;
				mod.builduvs = true;
			}

			float uvtwist = EditorGUILayout.FloatField("UV Twist", mod.strandedMesher.uvtwist);
			if ( uvtwist != mod.strandedMesher.uvtwist )
			{
				mod.strandedMesher.uvtwist = uvtwist;
				mod.builduvs = true;
			}
			
			float uvtilex = EditorGUILayout.FloatField("UV Tile X", mod.strandedMesher.uvtilex);
			if ( uvtilex != mod.strandedMesher.uvtilex )
			{
				mod.strandedMesher.uvtilex = uvtilex;
				mod.builduvs = true;
			}

			float uvtiley = EditorGUILayout.FloatField("UV Tile Y", mod.strandedMesher.uvtiley);
			if ( uvtiley != mod.strandedMesher.uvtiley )
			{
				mod.strandedMesher.uvtiley = uvtiley;
				mod.builduvs = true;
			}
			EditorGUILayout.EndToggleGroup();

			mod.strandedMesher.linInterp = EditorGUILayout.Toggle("Linear Interp", mod.strandedMesher.linInterp);
			mod.strandedMesher.calcBounds = EditorGUILayout.Toggle("Calc Bounds", mod.strandedMesher.calcBounds);
			mod.strandedMesher.calcTangents = EditorGUILayout.Toggle("Calc Tangents", mod.strandedMesher.calcTangents);
		
			int vcount = mod.GetVertexCount();
			EditorGUILayout.LabelField("Vertex Count: " + vcount);
			EditorGUILayout.EndVertical();
		}

		mod.showconnections = EditorGUILayout.Foldout(mod.showconnections, "Connections");

		if ( mod.showconnections )
		{
			for ( int i = 0; i < mod.connections.Count; i++ )
			{
				MegaWireConnectionDef con = mod.connections[i];
				EditorGUILayout.BeginVertical("box");

				float radius = EditorGUILayout.FloatField("Radius", con.radius);
				if ( radius != con.radius )
				{
					con.radius = radius;
				}

				Vector3 outOffset = EditorGUILayout.Vector3Field("Out Offset", con.outOffset);
				if ( outOffset != con.outOffset )
				{
					con.outOffset = outOffset;

					mod.Rebuild = true;
				}

				Vector3 inOffset = EditorGUILayout.Vector3Field("In Offset", con.inOffset);
				if ( inOffset != con.inOffset )
				{
					con.inOffset = inOffset;
					mod.Rebuild = true;
				}

				if ( GUILayout.Button("Delete") )
				{
					if ( mod.connections.Count > 1 )
					{
						mod.connections.RemoveAt(i);
						mod.RebuildWire();
						mod.Rebuild = true;
					}
				}

				EditorGUILayout.EndVertical();
			}
		}

		bool hidespans = EditorGUILayout.Toggle("Hide Spans", mod.hidespans);
		if ( hidespans != mod.hidespans )
		{
			mod.hidespans = hidespans;
			mod.SetHidden(mod.hidespans);
			EditorApplication.RepaintHierarchyWindow();
		}

		mod.displayGizmo = EditorGUILayout.BeginToggleGroup("Show Gizmos", mod.displayGizmo);
		mod.gizmoColor = EditorGUILayout.ColorField("Gizmo Color", mod.gizmoColor);
		EditorGUILayout.EndToggleGroup();

		mod.showAttach = EditorGUILayout.Foldout(mod.showAttach, "Span Connections");

		if ( mod.showAttach )
		{
			EditorGUILayout.BeginVertical("Box");
			for ( int i = 0; i < mod.spans.Count; i++ )
			{
				if ( i > 0 )
					EditorGUILayout.Separator();

				EditorGUILayout.BeginHorizontal();
				EditorGUILayout.LabelField("Start", GUILayout.MaxWidth(40.0f));
				for ( int c = 0; c < mod.spans[i].connections.Count; c++ )
				{
					bool active = EditorGUILayout.Toggle(mod.spans[i].connections[c].constraints[0].active, GUILayout.MaxWidth(10.0f));
					if ( active != mod.spans[i].connections[c].constraints[0].active )
						mod.spans[i].connections[c].SetEndConstraintActive(0, active, 2.0f);
				}
				EditorGUILayout.EndHorizontal();

				EditorGUILayout.BeginHorizontal();
				EditorGUILayout.LabelField("End", GUILayout.MaxWidth(40.0f));
				for ( int c = 0; c < mod.spans[i].connections.Count; c++ )
				{
					bool active = EditorGUILayout.Toggle(mod.spans[i].connections[c].constraints[1].active, GUILayout.MaxWidth(10.0f));
					if ( active != mod.spans[i].connections[c].constraints[1].active )
						mod.spans[i].connections[c].SetEndConstraintActive(1, active, 2.0f);
				}
				EditorGUILayout.EndHorizontal();
			}
			EditorGUILayout.EndVertical();
		}

		if ( GUI.changed )
			EditorUtility.SetDirty(target);

		undoManager.CheckDirty();
	}
Esempio n. 33
0
        // Draw the specified Image.
        private static void DrawSprite(Texture tex, Rect drawArea, Vector4 padding, Rect outer, Rect inner, Rect uv,
                                       Color color, Material mat)
        {
            // Create the texture rectangle that is centered inside rect.
            Rect outerRect = drawArea;

            outerRect.width  = Mathf.Abs(outer.width);
            outerRect.height = Mathf.Abs(outer.height);

            if (outerRect.width > 0f)
            {
                float f = drawArea.width / outerRect.width;
                outerRect.width  *= f;
                outerRect.height *= f;
            }

            if (drawArea.height > outerRect.height)
            {
                outerRect.y += (drawArea.height - outerRect.height) * 0.5f;
            }
            else if (outerRect.height > drawArea.height)
            {
                float f = drawArea.height / outerRect.height;
                outerRect.width  *= f;
                outerRect.height *= f;
            }

            if (drawArea.width > outerRect.width)
            {
                outerRect.x += (drawArea.width - outerRect.width) * 0.5f;
            }

            // Draw the background
            EditorGUI.DrawTextureTransparent(outerRect, null, ScaleMode.ScaleToFit, outer.width / outer.height);

            // Draw the Image
            GUI.color = color;

            Rect paddedTexArea = new Rect(
                outerRect.x + outerRect.width * padding.x,
                outerRect.y + outerRect.height * padding.w,
                outerRect.width - (outerRect.width * (padding.z + padding.x)),
                outerRect.height - (outerRect.height * (padding.w + padding.y))
                );

            if (mat == null)
            {
                GL.sRGBWrite = QualitySettings.activeColorSpace == ColorSpace.Linear;
                GUI.DrawTextureWithTexCoords(paddedTexArea, tex, uv, true);
                GL.sRGBWrite = false;
            }
            else
            {
                // NOTE: There is an issue in Unity that prevents it from clipping the drawn preview
                // using BeginGroup/EndGroup, and there is no way to specify a UV rect...
                EditorGUI.DrawPreviewTexture(paddedTexArea, tex, mat);
            }

            // Draw the border indicator lines
            GUI.BeginGroup(outerRect);
            {
                tex       = contrastTexture;
                GUI.color = Color.white;

                if (inner.xMin != outer.xMin)
                {
                    float x = (inner.xMin - outer.xMin) / outer.width * outerRect.width - 1;
                    DrawTiledTexture(new Rect(x, 0f, 1f, outerRect.height), tex);
                }

                if (inner.xMax != outer.xMax)
                {
                    float x = (inner.xMax - outer.xMin) / outer.width * outerRect.width - 1;
                    DrawTiledTexture(new Rect(x, 0f, 1f, outerRect.height), tex);
                }

                if (inner.yMin != outer.yMin)
                {
                    // GUI.DrawTexture is top-left based rather than bottom-left
                    float y = (inner.yMin - outer.yMin) / outer.height * outerRect.height - 1;
                    DrawTiledTexture(new Rect(0f, outerRect.height - y, outerRect.width, 1f), tex);
                }

                if (inner.yMax != outer.yMax)
                {
                    float y = (inner.yMax - outer.yMin) / outer.height * outerRect.height - 1;
                    DrawTiledTexture(new Rect(0f, outerRect.height - y, outerRect.width, 1f), tex);
                }
            }

            GUI.EndGroup();
        }
Esempio n. 34
0
File: Text3D.cs Progetto: yrest/urho
		/// <summary>
		/// Set material.
		/// </summary>
		private void SetMaterial (Material material)
		{
			Runtime.ValidateRefCounted (this);
			Text3D_SetMaterial (handle, (object)material == null ? IntPtr.Zero : material.Handle);
		}
 public static void MakePreviewAndDescription(this Material material, int descriptionLength, int previewLength)
 {
     var (preview, description) = MakePreviewAndDescription(material.Text, descriptionLength, previewLength);
     material.Description = description;
     material.Preview = preview;
 }
Esempio n. 36
0
 private void Start()
 {
     material = GetComponent <SpriteRenderer>().material;
 }
        private bool InitializeGPUSkinDeform()
        {
            bool succeeded = true;

            try
            {
                m_gpuBoneTexWidth    = m_boneCount;
                m_gpuBoneTexHeight   = 3;
                m_gpuVertexTexWidth  = Mathf.CeilToInt(Mathf.Sqrt(m_vertexCount));
                m_gpuVertexTexHeight = Mathf.CeilToInt(m_vertexCount / ( float )m_gpuVertexTexWidth);

                // gpu skin deform material
                m_gpuSkinDeformMat = new Material(Shader.Find("Hidden/Amplify Motion/GPUSkinDeform"))
                {
                    hideFlags = HideFlags.DontSave
                };

                // bone matrix texture
                m_gpuBones            = new Texture2D(m_gpuBoneTexWidth, m_gpuBoneTexHeight, TextureFormat.RGBAFloat, false, true);
                m_gpuBones.hideFlags  = HideFlags.DontSave;
                m_gpuBones.name       = "AM-" + m_obj.name + "-Bones";
                m_gpuBones.filterMode = FilterMode.Point;

                m_gpuBoneData = new Color[m_gpuBoneTexWidth * m_gpuBoneTexHeight];

                UpdateBonesGPU();

                // vertex bone index/weight textures
                TextureFormat boneIDWFormat = TextureFormat.RHalf;
                boneIDWFormat = (m_weightCount == 2) ? TextureFormat.RGHalf : boneIDWFormat;
                boneIDWFormat = (m_weightCount == 4) ? TextureFormat.RGBAHalf : boneIDWFormat;

                m_gpuBoneIndices            = new Texture2D(m_gpuVertexTexWidth, m_gpuVertexTexHeight, boneIDWFormat, false, true);
                m_gpuBoneIndices.hideFlags  = HideFlags.DontSave;
                m_gpuBoneIndices.name       = "AM-" + m_obj.name + "-Bones";
                m_gpuBoneIndices.filterMode = FilterMode.Point;
                m_gpuBoneIndices.wrapMode   = TextureWrapMode.Clamp;

                BoneWeight[] meshBoneWeights = m_renderer.sharedMesh.boneWeights;
                Color[]      boneIndices     = new Color[m_gpuVertexTexWidth * m_gpuVertexTexHeight];

                for (int v = 0; v < m_vertexCount; v++)
                {
                    int x      = v % m_gpuVertexTexWidth;
                    int y      = v / m_gpuVertexTexWidth;
                    int offset = y * m_gpuVertexTexWidth + x;

                    BoneWeight boneWeight = meshBoneWeights[v];
                    boneIndices[offset] = new Vector4(boneWeight.boneIndex0, boneWeight.boneIndex1, boneWeight.boneIndex2, boneWeight.boneIndex3);
                }
                m_gpuBoneIndices.SetPixels(boneIndices);
                m_gpuBoneIndices.Apply();

                // base vertex textures
                m_gpuBaseVertices = new Texture2D[m_weightCount];
                for (int w = 0; w < m_weightCount; w++)
                {
                    m_gpuBaseVertices[w]            = new Texture2D(m_gpuVertexTexWidth, m_gpuVertexTexHeight, TextureFormat.RGBAFloat, false, true);
                    m_gpuBaseVertices[w].hideFlags  = HideFlags.DontSave;
                    m_gpuBaseVertices[w].name       = "AM-" + m_obj.name + "-BaseVerts";
                    m_gpuBaseVertices[w].filterMode = FilterMode.Point;
                }

                List <Color[]> baseVertices = new List <Color[]>(m_weightCount);
                for (int w = 0; w < m_weightCount; w++)
                {
                    baseVertices.Add(new Color[m_gpuVertexTexWidth * m_gpuVertexTexHeight]);
                }

                for (int v = 0; v < m_vertexCount; v++)
                {
                    int x      = v % m_gpuVertexTexWidth;
                    int y      = v / m_gpuVertexTexWidth;
                    int offset = y * m_gpuVertexTexWidth + x;

                    for (int w = 0; w < m_weightCount; w++)
                    {
                        baseVertices[w][offset] = m_baseVertices[v * m_weightCount + w];
                    }
                }
                for (int w = 0; w < m_weightCount; w++)
                {
                    m_gpuBaseVertices[w].SetPixels(baseVertices[w]);
                    m_gpuBaseVertices[w].Apply();
                }

                // create output/target vertex render textures
                m_gpuPrevVertices            = new RenderTexture(m_gpuVertexTexWidth, m_gpuVertexTexHeight, 0, RenderTextureFormat.ARGBFloat, RenderTextureReadWrite.Linear);
                m_gpuPrevVertices.hideFlags  = HideFlags.DontSave;
                m_gpuPrevVertices.name       = "AM-" + m_obj.name + "-PrevVerts";
                m_gpuPrevVertices.filterMode = FilterMode.Point;
                m_gpuPrevVertices.wrapMode   = TextureWrapMode.Clamp;
                m_gpuPrevVertices.Create();

                m_gpuCurrVertices            = new RenderTexture(m_gpuVertexTexWidth, m_gpuVertexTexHeight, 0, RenderTextureFormat.ARGBFloat, RenderTextureReadWrite.Linear);
                m_gpuCurrVertices.hideFlags  = HideFlags.DontSave;
                m_gpuCurrVertices.name       = "AM-" + m_obj.name + "-CurrVerts";
                m_gpuCurrVertices.filterMode = FilterMode.Point;
                m_gpuCurrVertices.wrapMode   = TextureWrapMode.Clamp;
                m_gpuCurrVertices.Create();

                // assign local material constants
                m_gpuSkinDeformMat.SetTexture("_AM_BONE_TEX", m_gpuBones);
                m_gpuSkinDeformMat.SetTexture("_AM_BONE_INDEX_TEX", m_gpuBoneIndices);
                for (int w = 0; w < m_weightCount; w++)
                {
                    m_gpuSkinDeformMat.SetTexture("_AM_BASE_VERTEX" + w + "_TEX", m_gpuBaseVertices[w]);
                }

                // assign global shader constants
                Vector4 boneTexelSize   = new Vector4(1.0f / m_gpuBoneTexWidth, 1.0f / m_gpuBoneTexHeight, m_gpuBoneTexWidth, m_gpuBoneTexHeight);
                Vector4 vertexTexelSize = new Vector4(1.0f / m_gpuVertexTexWidth, 1.0f / m_gpuVertexTexHeight, m_gpuVertexTexWidth, m_gpuVertexTexHeight);

                m_gpuSkinDeformMat.SetVector("_AM_BONE_TEXEL_SIZE", boneTexelSize);
                m_gpuSkinDeformMat.SetVector("_AM_BONE_TEXEL_HALFSIZE", boneTexelSize * 0.5f);
                m_gpuSkinDeformMat.SetVector("_AM_VERTEX_TEXEL_SIZE", vertexTexelSize);
                m_gpuSkinDeformMat.SetVector("_AM_VERTEX_TEXEL_HALFSIZE", vertexTexelSize * 0.5f);

                // assign vertex x/y offsets packed into second uv channel
                Vector2[] indexCoords = new Vector2[m_vertexCount];
                for (int v = 0; v < m_vertexCount; v++)
                {
                    int   x      = v % m_gpuVertexTexWidth;
                    int   y      = v / m_gpuVertexTexWidth;
                    float x_norm = (x / ( float )m_gpuVertexTexWidth) + vertexTexelSize.x * 0.5f;
                    float y_norm = (y / ( float )m_gpuVertexTexHeight) + vertexTexelSize.y * 0.5f;
                    indexCoords[v] = new Vector2(x_norm, y_norm);
                }
                m_clonedMesh.uv2 = indexCoords;
            }
            catch (Exception)
            {
                succeeded = false;
            }
            return(succeeded);
        }
Esempio n. 38
0
    }//end evaluate

    void Update()
    {
        if (fade > 0)
        {
            fade -= Time.deltaTime * .75f;
        } //fade print successful message
        tappos = new Vector3(-1, -1, -1);//initialize tap position
        Vector3 tp = new Vector3(0, 0, 0);//initialize touch position

        if (Input.touchCount > 0)//check for touch
        {
            for (int i = 0; i < Input.touchCount; i++)
            {
                if (Input.touches[i].phase == TouchPhase.Ended)
                {
                    tappos = Input.touches[i].position;
                }
                tp = Input.touches[i].position;
            }
        }

        if (state == 6)
        {
            if (pw != null) //remove trickle effect upon entering results screen
            {
                Destroy(pw.tri.gameObject);
                Destroy(pw.gameObject);
            }
        }

        spraying = false;                                                   //reinitialize spraying bool
        Rect areatank = new Rect(w * .015f, h * .3f, w * .725f, h * .675f); //tank clickable area


        if (state != pstate && state == 0)
        {
            f5.empty = true;
        }//reinitialize last flow effect upon entering first state

        if (state == -1)//splash state
        {
            if (sptimer > 0)
            {
                sptimer -= Time.deltaTime;
            }
            else
            {
                state = 0;
            }
        }

        if (state == 5)//delay before evaluating trial data and moving to final results screen
        {
            delay -= Time.deltaTime;
            if (delay <= 0)
            {
                Evaluate();
                SaveData();
                state = 6;
            }
        }
        if (state == 6) //go to jar camera while on results state
        {
            c_cam = 1;
        }
        else
        {
            c_cam = 0;
        }

        if (state == 3) //fill tank with water
        {
            if (pw == null)
            {
                GameObject go = (GameObject)Instantiate(wt, wt.transform.position, wt.transform.rotation);
                go.SetActive(true);
                pw = go.GetComponent <PourWater>();
                if (layers.Length >= 1)
                {
                    pw.sf = layers[layers.Length - 1].sf;
                }
                else
                {
                    pw.sf = emptysf;
                }
            }
            if (water.type != 5)
            {
                water.type = 5;
            }
            if (pw.tri != null)
            {
                if (pw.tri.stop)
                {
                    if (water.linetop < ef.linetop)
                    {
                        water.linetop += Time.deltaTime * 1.25f;
                        if (water.linetop > ef.linetop)
                        {
                            water.linetop = ef.linetop;
                        }
                    }
                }
            }
        }

        if (state == 7) //raise/lower water level
        {
            if (Input.GetMouseButton(0))
            {
                if (_lower.Contains(mp))
                {
                    held = 3;
                }
                if (_raise.Contains(mp))
                {
                    held = 4;
                }
            }
            if (tp != Vector3.zero)
            {
                if (_lower.Contains(tp))
                {
                    held = 3;
                }
                if (_raise.Contains(tp))
                {
                    held = 4;
                }
            }
        }

        if (state == 1)//fade pump while raising/lowering tube
        {
            pump.color = new Color(1, 1, 1, .25f);
            if (Input.GetMouseButtonDown(0))
            {
                if (_lower.Contains(mp))
                {
                    held = 1;
                }
                if (_raise.Contains(mp))
                {
                    held = 2;
                }
            }
            if (tp != Vector3.zero)
            {
                if (_lower.Contains(tp))
                {
                    held = 1;
                }
                if (_raise.Contains(tp))
                {
                    held = 2;
                }
            }
            if (!sipR.enabled)
            {
                sipR.enabled = true;
            }
        }
        else
        {
            pump.color = Color.white;
        }

        if (held == 1)//raise/lower pump
        {
            if (!Input.GetMouseButton(0) && tp == Vector3.zero)
            {
                held = 0;
            }
            else
            {
                Vector3 scale = siphon.transform.localScale;
                scale.y += Time.deltaTime * 1.5f;
                if (scale.y > 8f)
                {
                    scale.y = 8f;
                }
                siphon.transform.localScale = scale;
            }
        }
        if (held == 2)
        {
            if (!Input.GetMouseButton(0) && tp == Vector3.zero)
            {
                held = 0;
            }
            else
            {
                Vector3 scale = siphon.transform.localScale;
                scale.y -= Time.deltaTime * 1.5f;
                if (scale.y < 0)
                {
                    scale.y = 0;
                }
                siphon.transform.localScale = scale;
            }
        }
        if (held == 3)//raise/lower fill level
        {
            if (!Input.GetMouseButton(0) && tp == Vector3.zero)
            {
                held = 0;
            }
            else
            {
                ef.linetop -= Time.deltaTime;
                held        = 0;
            }
        }
        if (held == 4)
        {
            if (!Input.GetMouseButton(0) && tp == Vector3.zero)
            {
                held = 0;
            }
            else
            {
                ef.linetop += Time.deltaTime;
                held        = 0;
            }
        }
        if ((Input.GetMouseButton(0) || tp != Vector3.zero) && state == 0)//spray material if current material either hasn't been placed or is the most recently placed
        {
            if ((areatank.Contains(mp) || areatank.Contains(tp)) && spraytype > 0)
            {
                //USE SUPER FILL
                spraying = true;
                if (layers.Length == 0)
                {
                    layers         = new Mlayer[1];
                    layers[0]      = new Mlayer();
                    layers[0].type = spraytype;
                    GameObject go = (GameObject)Instantiate(sf.gameObject, sf.transform.position, sf.transform.rotation);
                    go.SetActive(true);
                    layers[0].sf    = go.GetComponent <SuperFill>();
                    layers[0].sf.aq = this;
                    Material[] mt = new Material[2];
                    mt[0] = fmats[spraytype - 1];
                    mt[1] = tmats[spraytype - 1];
                    layers[0].sf.GetComponent <Renderer>().materials = mt;
                    layers[0].sf.name = 0.ToString();
                }
                else
                {
                    bool has = false;
                    for (int i = 0; i < layers.Length; i++)
                    {
                        if (layers[i].type == spraytype)
                        {
                            has = true;
                        }
                    }
                    if (has)
                    {
                        if (layers[layers.Length - 1].type == spraytype)
                        {
                            layers[layers.Length - 1].sf.getClosestPoint();

                            if (layers.Length > 1)
                            {
                                layers[layers.Length - 1].amount = layers[layers.Length - 1].sf.newVertices[69].y - layers[layers.Length - 2].sf.newVertices[69].y;
                            }
                            else
                            {
                                layers[layers.Length - 1].amount = layers[layers.Length - 1].sf.newVertices[69].y;
                            }
                        }
                    }
                    else
                    {
                        Mlayer[] temp = new Mlayer[layers.Length + 1];
                        for (int i = 0; i < layers.Length; i++)
                        {
                            temp[i] = layers[i];
                        }
                        temp[temp.Length - 1]      = new Mlayer();
                        temp[temp.Length - 1].type = spraytype;
                        GameObject go = (GameObject)Instantiate(sf.gameObject, sf.transform.position, sf.transform.rotation);
                        go.SetActive(true);
                        temp[temp.Length - 1].sf    = go.GetComponent <SuperFill>();
                        temp[temp.Length - 1].sf.aq = this;
                        Material[] mt = new Material[2];
                        mt[0] = fmats[spraytype - 1];
                        mt[1] = tmats[spraytype - 1];
                        temp[temp.Length - 1].sf.GetComponent <Renderer>().materials = mt;
                        temp[temp.Length - 1].sf.newVertices        = temp[temp.Length - 2].sf.newVertices;
                        temp[temp.Length - 1].sf.ps                 = temp[temp.Length - 2].sf;
                        temp[temp.Length - 1].sf.name               = (temp.Length - 1).ToString();
                        temp[temp.Length - 1].sf.transform.position = new Vector3(temp[temp.Length - 1].sf.transform.position.x, temp[temp.Length - 1].sf.transform.position.y, temp[temp.Length - 1].sf.ps.transform.position.z + .0001f);
                        layers = temp;
                    }
                }
            }
        }
        for (int i = 0; i < cams.Length; i++)//set active camera
        {
            if (i == c_cam)
            {
                cams[i].enabled = true;
            }
            else
            {
                cams[i].enabled = false;
            }
        }

        pstate = state;//reset pstate
    }
Esempio n. 39
0
    public static IEnumerator SplitMesh(this GameObject obj, bool destroy = true, int max_triangle = 1000)
    {
        if (obj.GetComponent <MeshFilter>() == null || obj.GetComponent <SkinnedMeshRenderer>() == null)
        {
            yield return(null);
        }

        if (obj.GetComponent <Collider>())
        {
            obj.GetComponent <Collider>().enabled = false;
        }

        Mesh M = new Mesh();

        if (obj.GetComponent <MeshFilter>())
        {
            M = obj.GetComponent <MeshFilter>().mesh;
        }
        else if (obj.GetComponent <SkinnedMeshRenderer>())
        {
            M = obj.GetComponent <SkinnedMeshRenderer>().sharedMesh;
        }

        Material[] materials = new Material[0];
        if (obj.GetComponent <MeshRenderer>())
        {
            materials = obj.GetComponent <MeshRenderer>().materials;
        }
        else if (obj.GetComponent <SkinnedMeshRenderer>())
        {
            materials = obj.GetComponent <SkinnedMeshRenderer>().materials;
        }

        Vector3[] verts    = M.vertices;
        Vector3[] normals  = M.normals;
        Vector2[] uvs      = M.uv;
        int       triangle = 0;

        for (int submesh = 0; submesh < M.subMeshCount; submesh++)
        {
            int[] indices = M.GetTriangles(submesh);

            for (int i = 0; i < indices.Length; i += 4)
            {
                Vector3[] newVerts   = new Vector3[4];
                Vector3[] newNormals = new Vector3[4];
                Vector2[] newUvs     = new Vector2[4];
                for (int n = 0; n < 4; n++)
                {
                    int index = indices[i + n];
                    newVerts[n]   = verts[index];
                    newUvs[n]     = uvs[index];
                    newNormals[n] = normals[index];
                }

                Mesh mesh = new Mesh();
                mesh.vertices = newVerts;
                mesh.normals  = newNormals;
                mesh.uv       = newUvs;

                mesh.triangles = new int[] { 0, 1, 2, 2, 1, 0, 1, 2, 3, 3, 2, 1 };

                GameObject GO = new GameObject("Quad " + (i / 4));
                //GO.layer = LayerMask.NameToLayer("Particle");
                GO.transform.position = obj.transform.position;
                GO.transform.rotation = obj.transform.rotation;
                GO.AddComponent <MeshRenderer>().material = materials[submesh];
                GO.AddComponent <MeshFilter>().mesh       = mesh;
                GO.AddComponent <BoxCollider>();
                Vector3 explosionPos = new Vector3(obj.transform.position.x + Random.Range(-0.5f, 0.5f), obj.transform.position.y + Random.Range(0f, 0.5f), obj.transform.position.z + Random.Range(-0.5f, 0.5f));
                GO.AddComponent <Rigidbody>().AddExplosionForce(Random.Range(300, 500), explosionPos, 5);
                GameObject.Destroy(GO, 5 + Random.Range(0.0f, 5.0f));

                triangle++;
                if (triangle > max_triangle)
                {
                    break;
                }
            }
            if (triangle > max_triangle)
            {
                break;
            }
        }

        yield return(null);

        if (destroy == true)
        {
            GameObject.Destroy(obj);
        }
    }
 public override void Init(NotesStruct notesStruct, ChartStruct chartStruct, Material shinyMaterial = null, int noteNumber = 0)
 {
     base.Init(notesStruct, chartStruct, shinyMaterial, noteNumber);
     NoteNumber = noteNumber;
 }
	Material CreateUnlitMaterial (Color col) {
		var mat = new Material (Shader.Find ("Unlit/Color"));
		mat.color = col;
		return mat;
	}
Esempio n. 42
0
    public override void OnInspectorGUI()
    {
        DrawDefaultInspector();

        EditorGUILayout.Separator();

        if (GUILayout.Button("Toggle Mesh Outline"))
        {
            Skin2D.showMeshOutline = !Skin2D.showMeshOutline;
        }

        EditorGUILayout.Separator();

        if (skin.skinnedMeshRenderer.sharedMesh != null && GUILayout.Button("Save as Prefab"))
        {
            skin.SaveAsPrefab();
        }

        EditorGUILayout.Separator();

        if (skin.skinnedMeshRenderer.sharedMesh != null && GUILayout.Button("Recalculate Bone Weights"))
        {
            skin.RecalculateBoneWeights();
        }

        EditorGUILayout.Separator();
        handleColor = EditorGUILayout.ColorField("Handle Color", handleColor);
        changedBaseSelectDistance = EditorGUILayout.Slider("Handle Size", baseSelectDistance, 0, 1);
        if (baseSelectDistance != changedBaseSelectDistance)
        {
            baseSelectDistance = changedBaseSelectDistance;
            EditorUtility.SetDirty(this);
            SceneView.RepaintAll();
        }

        if (skin.skinnedMeshRenderer.sharedMesh != null && GUILayout.Button("Create Control Points"))
        {
            skin.CreateControlPoints(skin.skinnedMeshRenderer);
        }

        if (skin.skinnedMeshRenderer.sharedMesh != null && GUILayout.Button("Reset Control Points"))
        {
            skin.ResetControlPointPositions();
        }

        if (skin.points != null && skin.controlPoints != null && skin.controlPoints.Length > 0 &&
            selectedIndex != -1 && GUILayout.Button("Reset Selected Control Point"))
        {
            skin.controlPoints[selectedIndex].ResetPosition();
            skin.points.SetPoint(skin.controlPoints[selectedIndex]);
        }

        if (GUILayout.Button("Remove Control Points"))
        {
            skin.RemoveControlPoints();
        }

        EditorGUILayout.Separator();

        if (skin.skinnedMeshRenderer.sharedMesh != null && GUILayout.Button("Generate Mesh Asset"))
        {
            #if UNITY_EDITOR
            // Check if the Meshes directory exists, if not, create it.
            if (!Directory.Exists("Assets/Meshes"))
            {
                AssetDatabase.CreateFolder("Assets", "Meshes");
                AssetDatabase.Refresh();
            }
            Mesh mesh = new Mesh();
            mesh.name      = skin.skinnedMeshRenderer.sharedMesh.name.Replace(".SkinnedMesh", ".Mesh");;
            mesh.vertices  = skin.skinnedMeshRenderer.sharedMesh.vertices;
            mesh.triangles = skin.skinnedMeshRenderer.sharedMesh.triangles;
            mesh.normals   = skin.skinnedMeshRenderer.sharedMesh.normals;
            mesh.uv        = skin.skinnedMeshRenderer.sharedMesh.uv;
            mesh.uv2       = skin.skinnedMeshRenderer.sharedMesh.uv2;
            mesh.bounds    = skin.skinnedMeshRenderer.sharedMesh.bounds;
            ScriptableObjectUtility.CreateAsset(mesh, "Meshes/" + skin.gameObject.name + ".Mesh");
                        #endif
        }

        if (skin.skinnedMeshRenderer.sharedMaterial != null && GUILayout.Button("Generate Material Asset"))
        {
            #if UNITY_EDITOR
            Material material = new Material(skin.skinnedMeshRenderer.sharedMaterial);
            material.CopyPropertiesFromMaterial(skin.skinnedMeshRenderer.sharedMaterial);
            skin.skinnedMeshRenderer.sharedMaterial = material;
            if (!Directory.Exists("Assets/Materials"))
            {
                AssetDatabase.CreateFolder("Assets", "Materials");
                AssetDatabase.Refresh();
            }
            AssetDatabase.CreateAsset(material, "Assets/Materials/" + material.mainTexture.name + ".mat");
            Debug.Log("Created material " + material.mainTexture.name + " for " + skin.gameObject.name);
                        #endif
        }
    }
Esempio n. 43
0
 public Sphere(Vec3 center, double radius, Material material)
 {
     Center   = center;
     Radius   = radius;
     Material = material;
 }
    public static GameObject GenerateOutline(Vector2[] vertices, Transform parent, float lineWidth, Material material)
    {
        // Create line prefab
        LineRenderer linePrefab = new GameObject().AddComponent <LineRenderer>();

        linePrefab.transform.name  = "Line";
        linePrefab.useWorldSpace   = false;
        linePrefab.positionCount   = 0;
        linePrefab.material        = material;
        linePrefab.loop            = true;
        linePrefab.widthMultiplier = lineWidth;
        linePrefab.startWidth      = linePrefab.endWidth = lineWidth;

        // Create first line
        LineRenderer line = Instantiate(linePrefab.gameObject, parent).GetComponent <LineRenderer>();

        // This vector3 gets added to each line position, so it sits in front of the mesh
        // Change the -0.1f to a positive number and it will sit behind the mesh
        Vector3 bringFoward = new Vector3(0f, 0f, -0.1f);

        //2DVertices to 3DPoints
        Vector3[] points = new Vector3[vertices.Length];
        for (int i = 0; i < vertices.Length; i++)
        {
            points[i] = ((Vector3)vertices[i]) + bringFoward;
        }

        //Fill points in line
        line.positionCount = vertices.Length;
        line.SetPositions(points);

        return(line.gameObject);
    }
Esempio n. 45
0
 private void blitQuad(RenderTexture src, RenderTexture dest, Material material, int pass)
 {
     blitQuad(new Rect(0f, 0f, 1f, 1f), src, dest, material, pass);
 }
Esempio n. 46
0
 // Use this for initialization
 void Start()
 {
     mat = new Material(Shader.Find("Hidden/OutlineCameraEffect"));
 }
Esempio n. 47
0
    public static void ChangeAlpha(Material material, float alphaVal)
    {
        Color oldColor = material.color;

        material.color = new Color(oldColor.r, oldColor.g, oldColor.b, alphaVal);
    }
Esempio n. 48
0
 public virtual void SetTileMaterial(Material tileMaterial)
 {
     Options.tileMaterial = tileMaterial;
 }
Esempio n. 49
0
    void Update()
    {
        if (this.gameObject.GetComponent <Image> () != null)
        {
            if (CanvasImage == null)
            {
                CanvasImage = this.gameObject.GetComponent <Image> ();
            }
        }
        if ((ShaderChange == 0) && (ForceMaterial != null))
        {
            ShaderChange = 1;
            if (tempMaterial != null)
            {
                DestroyImmediate(tempMaterial);
            }
            if (this.gameObject.GetComponent <SpriteRenderer>() != null)
            {
                this.GetComponent <Renderer>().sharedMaterial = ForceMaterial;
            }
            else if (this.gameObject.GetComponent <Image>() != null)
            {
                CanvasImage.material = ForceMaterial;
            }
            ForceMaterial.hideFlags = HideFlags.None;
            ForceMaterial.shader    = Shader.Find(shader);
            ActiveChange            = false;
        }
        if ((ForceMaterial == null) && (ShaderChange == 1))
        {
            if (tempMaterial != null)
            {
                DestroyImmediate(tempMaterial);
            }
            tempMaterial           = new Material(Shader.Find(shader));
            tempMaterial.hideFlags = HideFlags.None;
            if (this.gameObject.GetComponent <SpriteRenderer>() != null)
            {
                this.GetComponent <Renderer>().sharedMaterial = tempMaterial;
            }
            else if (this.gameObject.GetComponent <Image>() != null)
            {
                CanvasImage.material = tempMaterial;
            }
            ShaderChange = 0;
        }

#if UNITY_EDITOR
        string dfname = "";
        if (this.gameObject.GetComponent <SpriteRenderer>() != null)
        {
            dfname = this.GetComponent <Renderer>().sharedMaterial.shader.name;
        }
        if (this.gameObject.GetComponent <Image>() != null)
        {
            Image img = this.gameObject.GetComponent <Image>();
            if (img.material == null)
            {
                dfname = "Sprites/Default";
            }
        }
        if (dfname == "Sprites/Default")
        {
            ForceMaterial.shader    = Shader.Find(shader);
            ForceMaterial.hideFlags = HideFlags.None;
            if (this.gameObject.GetComponent <SpriteRenderer>() != null)
            {
                this.GetComponent <Renderer>().sharedMaterial = ForceMaterial;
            }
            else if (this.gameObject.GetComponent <Image>() != null)
            {
                Image img = this.gameObject.GetComponent <Image>();
                if (img.material == null)
                {
                    CanvasImage.material = ForceMaterial;
                }
            }
        }
#endif
        if (ActiveChange)
        {
            if (this.gameObject.GetComponent <SpriteRenderer>() != null)
            {
                this.GetComponent <Renderer>().sharedMaterial.SetFloat("_Alpha", 1 - _Alpha);
                this.GetComponent <Renderer>().sharedMaterial.SetFloat("_Offset", _Offset);
                if (_2DxFX.ActiveShadow && AddShadow)
                {
                    this.GetComponent <Renderer>().shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On;
                    if (ReceivedShadow)
                    {
                        this.GetComponent <Renderer>().receiveShadows             = true;
                        this.GetComponent <Renderer>().sharedMaterial.renderQueue = 2450;
                        this.GetComponent <Renderer>().sharedMaterial.SetInt("_Z", 1);
                    }
                    else
                    {
                        this.GetComponent <Renderer>().receiveShadows             = false;
                        this.GetComponent <Renderer>().sharedMaterial.renderQueue = 3000;
                        this.GetComponent <Renderer>().sharedMaterial.SetInt("_Z", 0);
                    }
                }
                else
                {
                    this.GetComponent <Renderer>().shadowCastingMode          = UnityEngine.Rendering.ShadowCastingMode.Off;
                    this.GetComponent <Renderer>().receiveShadows             = false;
                    this.GetComponent <Renderer>().sharedMaterial.renderQueue = 3000;
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_Z", 0);
                }

                if (BlendMode == 0) // Normal
                {
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_BlendOp", (int)UnityEngine.Rendering.BlendOp.Add);
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
                }
                if (BlendMode == 1) // Additive
                {
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_BlendOp", (int)UnityEngine.Rendering.BlendOp.Add);
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
                }
                if (BlendMode == 2) // Darken
                {
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_BlendOp", (int)UnityEngine.Rendering.BlendOp.ReverseSubtract);
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.DstColor);
                }
                if (BlendMode == 3) // Lighten
                {
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_BlendOp", (int)UnityEngine.Rendering.BlendOp.Max);
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
                }
                if (BlendMode == 4) // Linear Burn
                {
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_BlendOp", (int)UnityEngine.Rendering.BlendOp.ReverseSubtract);
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
                }
                if (BlendMode == 5) // Linear Dodge
                {
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_BlendOp", (int)UnityEngine.Rendering.BlendOp.Max);
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
                }
                if (BlendMode == 6) // Multiply
                {
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_BlendOp", (int)UnityEngine.Rendering.BlendOp.Add);
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.DstColor);
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
                }
                if (BlendMode == 7) // Soft Aditive
                {
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_BlendOp", (int)UnityEngine.Rendering.BlendOp.Add);
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusDstColor);
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
                }
                if (BlendMode == 8) // 2x Multiplicative
                {
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_BlendOp", (int)UnityEngine.Rendering.BlendOp.ReverseSubtract);
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.DstAlpha);
                    this.GetComponent <Renderer>().sharedMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.DstColor);
                }
                this.GetComponent <SpriteRenderer>().sprite.texture.mipMapBias = -10;
                this.GetComponent <SpriteRenderer>().sprite.texture.filterMode = FilterMode.Point;
            }
            else if (this.gameObject.GetComponent <Image>() != null)
            {
                CanvasImage.material.SetFloat("_Alpha", _Alpha);
                CanvasImage.material.SetFloat("_Offset", _Offset);
            }
        }
    }
Esempio n. 50
0
 private void Start()
 {
     _renderer       = GetComponent <SkinnedMeshRenderer>();
     InitialMaterial = _renderer.material;
 }
	private void Awake()
	{
        material = new Material(Shader);
        material.SetTexture("_BlendTex", Frost);
        material.SetTexture("_BumpMap", FrostNormals);
	}
Esempio n. 52
0
    public static void MakeTransparent(Material material, float alphaVal)
    {
        Color oldColor = material.color;

        material.color = new Color(oldColor.r, oldColor.g, oldColor.b, alphaVal);
    }
Esempio n. 53
0
 public GeometryModel3D MakeGeometryModel(Geometry3D geom, Material mat)
 {
     return(new GeometryModel3D(geom, mat));
 }
Esempio n. 54
0
 public static bool GetSubMesh(SectionLayer __instance, ref LayerSubMesh __result, Material material)
 {
     if (allThreads2.TryGetValue(CurrentThread, out ThreadInfo threadInfo))
     {
         Func <object[], object> safeFunction = parameters => __instance.GetSubMesh((Material)parameters[0]);
         threadInfo.safeFunctionRequest = new object[] { safeFunction, new object[] { material } };
         mainThreadWaitHandle.Set();
         threadInfo.eventWaitStart.WaitOne();
         __result = (LayerSubMesh)threadInfo.safeFunctionResult;
         return(false);
     }
     return(true);
 }
 public void SetMaterial(Material material)
 {
     generatedList[0].GetComponent <MeshRenderer>().material = material;
 }
Esempio n. 56
0
 public EF_GridData(float cellWidth, float cellHeight, int gridRows, int gridCollumns, bool drawAllTiles, bool useXYCoords, Material validMaterial, Material occupiedMaterial)
 {
     m_cellWidth        = cellWidth;
     m_cellHeight       = cellHeight;
     m_gridRows         = gridRows;
     m_gridCollumns     = gridCollumns;
     m_drawAllTiles     = drawAllTiles;
     m_useXYCoords      = useXYCoords;
     m_validMaterial    = validMaterial;
     m_occupiedMaterial = occupiedMaterial;
 }
Esempio n. 57
0
    public void spawn()
    {
        oldPosition = oldPosition + offset;
        if (Random.Range(0, 100) > gapChance && gapCount == 0 && upMin == 0 && directionCount == 0)
        {
            Instantiate(gap, oldPosition + up + Vector3.down * .5f, Quaternion.identity, platforms);
            gapCount = 3;
            return;
        }
        if (gapCount > 0)
        {
            gapCount--;
        }
        if (chance >= 50)
        {
            chance -= gameManager.difficulter / 100f;
        }
        if (bombChance >= 70)
        {
            bombChance -= gameManager.difficulter / 100f;
        }
        if (upChance >= 60)
        {
            upChance -= gameManager.difficulter / 100f;
        }
        if (gapChance >= 60)
        {
            gapChance -= gameManager.difficulter / 100f;
        }
        bombRandom = (int)Random.Range(-2, 3);
        if (bombRandom == 0)
        {
            bombRandom++;
        }

        if (Random.Range(0, 100) > starChance)
        {
            starsLeft = 3;
        }

        if (Random.Range(0, 100) > chance && upMin == 0 && gapCount == 0)
        {
            changeDirection();
            directionCount = 3;
        }
        if (directionCount > 0)
        {
            directionCount--;
        }
        if (direction == 'x')
        {
            heightSetterOffset = Vector3.left * (transform.localScale.x);
            bombOffset         = new Vector3(0, 0.5f, bombRandom);
        }
        else if (direction == 'z')
        {
            heightSetterOffset = Vector3.back * (transform.localScale.x);
            bombOffset         = new Vector3(bombRandom, 0.5f, 0);
        }



        bool shouldSpawnHeightSetter = false;

        if (Random.Range(0, 100) > upChance && upMin == 0 && gapCount == 0 && directionCount == 0)
        {
            up                      = new Vector3(0, currentHeight, 0);
            currentHeight          += 2f;
            upMin                   = 3;
            shouldSpawnHeightSetter = true;
        }

        if (upMin > 0)
        {
            upMin--;
        }



        GameObject platformCreated = Instantiate(platform, oldPosition + up, Quaternion.identity, platforms);

        gameManager.setPlatformColor(platformCreated);
        if (shouldSpawnHeightSetter && gapCount == 0)
        {
            GameObject heightSetterCreated = Instantiate(heightSetter, oldPosition + heightSetterOffset + up, Quaternion.identity, heightSetters);
            platformCreated.GetComponent <FallAndDestroy> ().heightSetter = heightSetterCreated.gameObject;
        }
        if (Random.Range(0, 100) > bombChance && upMin < 4 && !shouldSpawnHeightSetter && directionCount != 2 && gapCount != 2)
        {
            GameObject bombCreated = Instantiate(bomb, oldPosition + up + bombOffset, Quaternion.identity, bombs);
            platformCreated.GetComponent <FallAndDestroy> ().bomb = bombCreated.gameObject;
        }
        if (starsLeft > 0)
        {
            GameObject starCreated = Instantiate(star, oldPosition + up + Vector3.up, starQuaternion, stars);
            platformCreated.GetComponent <FallAndDestroy> ().star = starCreated.gameObject;
            starsLeft--;
        }
        if (Random.Range(0, 100) > cloudChance)
        {
            GameObject cloudCreated      = Instantiate(cloud, oldPosition + up + Vector3.up * 7 + (bombOffset + Vector3.down * 0.5f + Vector3.left * 2) * 3f, Quaternion.identity, clouds);
            Vector3    cloudCreatedScale = cloudCreated.transform.localScale;
            cloudCreated.transform.localScale = new Vector3(cloudCreatedScale.x * Random.Range(.8f, 1.2f), cloudCreatedScale.y * Random.Range(.8f, 1.2f), cloudCreatedScale.z * Random.Range(.8f, 1.2f));
            platformCreated.GetComponent <FallAndDestroy> ().cloud = cloudCreated.gameObject;
            cloudCreated.GetComponent <Rigidbody> ().AddExplosionForce(Random.Range(-300f, -100f), cloudCreated.transform.position, 100f);
        }

        if (Random.Range(0, 100) > platform2Chance)
        {
            GameObject platform2Created = Instantiate(platform2, oldPosition + up + bombOffset * -3f + Vector3.left, platform2Quaternion, platforms2);
            gameManager.setPlatformColor(platform2Created);
            Material material = platform2Created.GetComponent <Renderer> ().material;
            int      r        = Random.Range(-10, 10);
            material.SetColor("_Color", new Color(material.color.r + r, material.color.g, material.color.b));
            Vector3 platform2CreatedScale = platform2Created.transform.localScale;
            platform2Created.transform.localScale = new Vector3(platform2CreatedScale.x * Random.Range(.1f, 3f), platform2CreatedScale.y * Random.Range(.2f, 5f), platform2CreatedScale.z * Random.Range(.2f, 5f));
            platformCreated.GetComponent <FallAndDestroy> ().platform2 = platform2Created.gameObject;
        }

        if (Random.Range(0, 100) > platform2Chance)
        {
            GameObject platform3Created = Instantiate(platform3, oldPosition + up + bombOffset * -3f + Vector3.left, platform3Quaternion, platforms3);
            gameManager.setPlatformColor(platform3Created);
            Material material = platform3Created.GetComponent <Renderer> ().material;
            int      r        = Random.Range(-10, 10);
            material.SetColor("_Color", new Color(material.color.r + r, material.color.g, material.color.b));
            float   scale = Random.Range(.1f, 3f);
            Vector3 platform3CreatedScale = platform3Created.transform.localScale;
            platform3Created.transform.localScale = new Vector3(platform3CreatedScale.x * scale, platform3CreatedScale.y * Random.Range(.2f, 5f), platform3CreatedScale.z * scale);
            platform3Created.transform.position  += Vector3.down * platform3Created.transform.localScale.y;
            platformCreated.GetComponent <FallAndDestroy> ().platform3 = platform3Created.gameObject;
        }

        if (Random.Range(0, 100) > platform2Chance)
        {
            GameObject platform4Created = Instantiate(platform4, oldPosition + up + bombOffset * -3f + Vector3.left, platform3Quaternion, platforms4);
            gameManager.setPlatformColor(platform4Created);
            Material material = platform4Created.GetComponent <Renderer> ().material;
            int      r        = Random.Range(-10, 10);
            material.SetColor("_Color", new Color(material.color.r + r, material.color.g, material.color.b));
            float   scale = Random.Range(.5f, 5f);
            Vector3 platform4CreatedScale = platform4Created.transform.localScale;
            platform4Created.transform.localScale = new Vector3(platform4CreatedScale.x * scale, platform4CreatedScale.y * scale, platform4CreatedScale.z * scale);
            platform4Created.transform.position  += Vector3.down * platform4Created.transform.localScale.y;
            platformCreated.GetComponent <FallAndDestroy> ().platform4 = platform4Created.gameObject;
        }

        if (Random.Range(0, 100) > healthChance && starsLeft == 0)
        {
            GameObject healthCreated = Instantiate(health, oldPosition + up + Vector3.up * 1.5f, Quaternion.identity, healths);
            platformCreated.GetComponent <FallAndDestroy> ().health = healthCreated.gameObject;
        }
    }
Esempio n. 58
0
 void Awake()
 {
     mat = GetComponent <TilemapRenderer>().material;
 }
        public static void CreateTextMeshProObjectPerform()
        {
            Object target = Selection.activeObject;

            // Make sure the selection is a texture.
            if (target == null || target.GetType() != typeof(Texture2D))
            {
                return;
            }

            Texture2D sourceTex = target as Texture2D;

            // Get the path to the selected texture.
            string filePathWithName         = AssetDatabase.GetAssetPath(sourceTex);
            string fileNameWithExtension    = Path.GetFileName(filePathWithName);
            string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(filePathWithName);
            string filePath = filePathWithName.Replace(fileNameWithExtension, "");

            // Check if Sprite Asset already exists
            TMP_SpriteAsset spriteAsset = AssetDatabase.LoadAssetAtPath(filePath + fileNameWithoutExtension + ".asset", typeof(TMP_SpriteAsset)) as TMP_SpriteAsset;
            bool            isNewAsset  = spriteAsset == null ? true : false;

            if (isNewAsset)
            {
                // Create new Sprite Asset using this texture
                spriteAsset = ScriptableObject.CreateInstance <TMP_SpriteAsset>();
                AssetDatabase.CreateAsset(spriteAsset, filePath + fileNameWithoutExtension + ".asset");

                // Compute the hash code for the sprite asset.
                spriteAsset.hashCode = TMP_TextUtilities.GetSimpleHashCode(spriteAsset.name);

                // Assign new Sprite Sheet texture to the Sprite Asset.
                spriteAsset.spriteSheet    = sourceTex;
                spriteAsset.spriteInfoList = GetSpriteInfo(sourceTex);

                // Create new default material for sprite asset.
                Shader   shader   = Shader.Find("TMPro/Sprite");
                Material material = new Material(shader);
                material.SetTexture(ShaderUtilities.ID_MainTex, spriteAsset.spriteSheet);

                spriteAsset.material = material;
                material.hideFlags   = HideFlags.HideInHierarchy;
                AssetDatabase.AddObjectToAsset(material, spriteAsset);
            }
            else
            {
                spriteAsset.spriteInfoList = UpdateSpriteInfo(spriteAsset);

                // Make sure the sprite asset already contains a default material
                if (spriteAsset.material == null)
                {
                    // Create new default material for sprite asset.
                    Shader   shader   = Shader.Find("TMPro/Sprite");
                    Material material = new Material(shader);
                    material.SetTexture(ShaderUtilities.ID_MainTex, spriteAsset.spriteSheet);

                    spriteAsset.material = material;
                    material.hideFlags   = HideFlags.HideInHierarchy;
                    AssetDatabase.AddObjectToAsset(material, spriteAsset);
                }
            }

            // Get the Sprites contained in the Sprite Sheet
            EditorUtility.SetDirty(spriteAsset);

            //spriteAsset.sprites = sprites;

            // Set source texture back to Not Readable.
            //texImporter.isReadable = false;


            AssetDatabase.SaveAssets();

            AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(spriteAsset));  // Re-import font asset to get the new updated version.

            //AssetDatabase.Refresh();
        }
Esempio n. 60
0
 public void SelectObjects(List <GameObject> intersecting)
 {
     foreach (GameObject g in intersecting)
     {
         Material[] copy;
         if (g.transform.parent != null && (g.transform.parent.gameObject.CompareTag("One") || g.transform.parent.gameObject.CompareTag("Two")))
         {
             if (g.transform.parent.gameObject.GetComponent <Renderer>().materials.Length > 1)
             {
                 RemoveObjects(g.transform.parent.gameObject);
                 continue;
             }
             copy = (Material[])g.transform.parent.gameObject.GetComponent <Renderer>().materials.Clone();
             Material[] n = new Material[copy.Length + 1];
             int        i = 0;
             foreach (Material m in copy)
             {
                 n[i] = m;
                 i   += 1;
             }
             n[i] = newMaterialRef;
             g.transform.parent.gameObject.GetComponent <Renderer>().materials = n;
             Debug.Log("Done " + n.Length);
         }
         // else if(g.transform.parent!=null && g.transform.parent.parent!= null && (g.transform.parent.gameObject.CompareTag("Four")))
         // {
         //     if(g.transform.parent.parent.gameObject.GetComponent<Renderer>().materials.Length>1)
         //     {
         //         RemoveObjects(g.transform.parent.parent.gameObject);
         //         continue;
         //     }
         //     copy=(Material[])g.transform.parent.parent.gameObject.GetComponent<Renderer>().materials.Clone();
         //     Material[] n=new Material[copy.Length+1];
         //     int i=0;
         //     foreach(Material m in copy)
         //     {
         //         n[i]=m;
         //         i+=1;
         //     }
         //     n[i]=newMaterialRef;
         //     g.transform.parent.parent.gameObject.GetComponent<Renderer>().materials=n;
         //     Debug.Log("Done "+n.Length);
         // }
         else
         {
             if (g.gameObject.GetComponent <Renderer>().materials.Length > 1)
             {
                 RemoveObjects(g);
                 continue;
             }
             copy = (Material[])g.gameObject.GetComponent <Renderer>().materials.Clone();
             Debug.Log(copy.Length);
             Material[] n = new Material[copy.Length + 1];
             int        i = 0;
             foreach (Material m in copy)
             {
                 n[i] = m;
                 i   += 1;
             }
             n[i] = newMaterialRef;
             g.gameObject.GetComponent <Renderer>().materials = n;
             Debug.Log("Done " + n.Length);
         }
     }
 }