コード例 #1
0
        bool HasSelectedTransparentAsset()
        {
            if (serializedObject.isEditingMultipleObjects)
            {
                UnityEngine.Object[] renderers = (UnityEngine.Object[])targets;
                for (int i = 0; i < renderers.Length; i++)
                {
                    renderer = renderers [i] as SVGRenderer;
                    if (renderer.vectorGraphics != null && renderer.vectorGraphics.format != SVGAssetFormat.Opaque)
                    {
                        return(true);
                    }
                }
            }
            else
            {
                SVGRenderer renderer = target as SVGRenderer;
                if (renderer.vectorGraphics != null && renderer.vectorGraphics.format != SVGAssetFormat.Opaque)
                {
                    return(true);
                }
            }

            return(false);
        }
コード例 #2
0
 protected static void RemoveSVGRenderer()
 {
     if (_renderer != null)
     {
         _renderer.vectorGraphics = null;
         GameObject.Destroy(_renderer.gameObject);
         _renderer = null;
     }
 }
コード例 #3
0
        // Code that runs on entering the state.
        public override void OnEnter()
        {
            var go = Fsm.GetOwnerDefaultTarget(gameObject);

            sprite = go.GetComponent <SVGImporter.SVGRenderer> ();

            sprite.color = color.Value;
            Finish();
        }
コード例 #4
0
        void OnDisable()
        {
            if (svgRenderer == null)
            {
                svgRenderer = GetComponent <SVGRenderer>();
            }

            svgRenderer.onVectorGraphicsChanged -= OnVectorGraphicsChanged;
        }
コード例 #5
0
 void RemoveSVGRenderer()
 {
     if (_editorRenderer != null)
     {
         _editorRenderer.vectorGraphics = null;
         DestroyImmediate(_editorRenderer.gameObject);
         _editorRenderer = null;
         //Debug.Log("Remove SVG Renderer");
     }
 }
コード例 #6
0
        void OnEnable()
        {
            if (svgRenderer == null)
            {
                svgRenderer = GetComponent <SVGRenderer>();
            }

            svgRenderer.onVectorGraphicsChanged += OnVectorGraphicsChanged;
            UpdateCollider();
        }
コード例 #7
0
        void OnEnable()
        {
            vectorGraphics      = serializedObject.FindProperty("_vectorGraphics");
            color               = serializedObject.FindProperty("_color");
            transparentMaterial = serializedObject.FindProperty("_transparentMaterial");
            opaqueMaterial      = serializedObject.FindProperty("_opaqueMaterial");
            type           = serializedObject.FindProperty("_type");
            sortingLayerID = serializedObject.FindProperty("_sortingLayerID");
//            sortingLayerName = serializedObject.FindProperty("_sortingLayerName");
            sortingOrder           = serializedObject.FindProperty("_sortingOrder");
            overrideSorter         = serializedObject.FindProperty("_overrideSorter");
            overrideSorterChildren = serializedObject.FindProperty("_overrideSorterChildren");

            if (serializedObject.isEditingMultipleObjects)
            {
                SVGRenderer renderer     = (SVGRenderer)target;
                Renderer    meshRenderer = renderer.GetComponent <Renderer>();
                if (meshRenderer != null)
                {
                    //UnityEditor.EditorUtility.SetSelectedWireframeHidden(meshRenderer, true);
                    EditorUtility.SetSelectedRenderState(meshRenderer, EditorSelectedRenderState.Wireframe);
                }
            }
            else
            {
                UnityEngine.Object[] renderers = (UnityEngine.Object[])targets;
                SVGRenderer          renderer;
                if (renderers != null && renderers.Length > 0)
                {
                    for (int i = 0; i < renderers.Length; i++)
                    {
                        renderer = renderers [i] as SVGRenderer;
                        if (renderer == null)
                        {
                            continue;
                        }
                        MeshRenderer meshRenderer = renderer.GetComponent <MeshRenderer>();
                        if (meshRenderer != null)
                        {
                            EditorUtility.SetSelectedRenderState(meshRenderer, EditorSelectedRenderState.Wireframe);
                            //EditorUtility.SetSelectedWireframeHidden(meshRenderer, true);
                        }
                    }
                }
            }
        }
コード例 #8
0
        public static GameObject DropSVGAssetToSceneToCreateGO(SVGAsset asset, Vector3 position)
        {
            GameObject go = new GameObject(asset.name);

            Undo.RegisterCreatedObjectUndo(go, "Create SVG Renderer");
            //Vector3 destination = Camera.current.ScreenToWorldPoint(new Vector3(mousePosition.x, scenePosition.height - mousePosition.y, 0f));
            //destination.z = 0f;
            go.transform.position = position;
            SVGRenderer renderer = go.AddComponent <SVGRenderer>();

            renderer.vectorGraphics = asset;
            if (asset.generateCollider)
            {
                go.AddComponent <SVGCollider2D>();
            }
            Selection.activeGameObject = go;
            return(go);
        }
コード例 #9
0
ファイル: Trigger.cs プロジェクト: freelancerDevelop/spy.io
    public void OnTriggerEnter2D(Collider2D other)
    {
        if (other.gameObject.tag == "Player")
        {
            GameLoop myGL = other.gameObject.transform.parent.gameObject.transform.parent.gameObject.GetComponent <GameLoop> ();

            if (myGL.pv.isMine == true)
            {
                // Make building transparent
                thisSvg = this.gameObject.GetComponent <SVGImporter.SVGRenderer> ();

                thisSvg.color = transparent;
            }

            // If not me
            if (myGL.pv.isMine == false)
            {
            }
        }
    }
コード例 #10
0
 void CreateSVGRenderer()
 {
     _editorRenderer = editorRenderer;
 }
コード例 #11
0
 protected virtual void Awake()
 {
     svgRenderer = GetComponent <SVGRenderer>();
 }
コード例 #12
0
        public override void OnInspectorGUI()
        {
            serializedObject.Update();
            EditorGUI.BeginChangeCheck();
            EditorGUILayout.PropertyField(vectorGraphics, new GUIContent("Vector Graphics"));
            EditorGUILayout.PropertyField(color, new GUIContent("Color"));

            if (!transparentMaterial.hasMultipleDifferentValues && !opaqueMaterial.hasMultipleDifferentValues)
            {
                if (transparentMaterial.objectReferenceValue != opaqueMaterial.objectReferenceValue)
                {
                    EditorGUI.showMixedValue = true;

                    Material material = EditorGUILayout.ObjectField("material", null, typeof(Material), false) as Material;
                    if (material != null)
                    {
                        transparentMaterial.objectReferenceValue = material;
                        opaqueMaterial.objectReferenceValue      = material;
                    }

                    EditorGUI.showMixedValue = false;
                }
                else
                {
                    Material oldMaterial = transparentMaterial.objectReferenceValue as Material;
                    Material material    = EditorGUILayout.ObjectField("material", oldMaterial, typeof(Material), false) as Material;
                    if (oldMaterial != material)
                    {
                        transparentMaterial.objectReferenceValue = material;
                        opaqueMaterial.objectReferenceValue      = material;
                    }
                }
            }

            EditorGUILayout.PropertyField(type, new GUIContent("Image Type"));
            if (type.hasMultipleDifferentValues || (SVGRenderer.Type)type.enumValueIndex == SVGRenderer.Type.Sliced)
            {
                RectTransform rectTransform = ((SVGRenderer)target).GetComponent <RectTransform>();
                if (rectTransform == null)
                {
                    EditorGUILayout.HelpBox("To use the sliced image type, you need to add RectTransform component first.", MessageType.Warning);
                }
            }

            materialsFoldout = EditorGUILayout.Foldout(materialsFoldout, "Advanced Materials");
            if (materialsFoldout)
            {
                EditorGUI.indentLevel++;
                EditorGUILayout.PropertyField(transparentMaterial, new GUIContent("Transparent"));
                EditorGUILayout.PropertyField(opaqueMaterial, new GUIContent("Opaque"));
                if (HasSelectedTransparentAsset())
                {
                    OpaqueMaterialHelpBox();
                }
                EditorGUI.indentLevel--;
            }

            sortingLayerFoldout = EditorGUILayout.Foldout(sortingLayerFoldout, "Sorting");
            if (sortingLayerFoldout)
            {
                EditorGUI.indentLevel++;
                EditorGUILayout.LabelField("Unity Sorter", EditorStyles.boldLabel);
                MethodInfo sortingLayerField = typeof(EditorGUILayout).GetMethod("SortingLayerField",
                                                                                 BindingFlags.Static | BindingFlags.NonPublic,
                                                                                 System.Type.DefaultBinder,
                                                                                 new System.Type[] { typeof(GUIContent), typeof(SerializedProperty), typeof(GUIStyle), typeof(GUIStyle) },
                                                                                 null
                                                                                 );
                if (sortingLayerField != null)
                {
                    sortingLayerField.Invoke(null, new System.Object[] { new GUIContent("Sorting Layer"), sortingLayerID, EditorStyles.popup, EditorStyles.label });
                }
                EditorGUILayout.PropertyField(sortingOrder);
                if (!HasSelectedTransparentAsset())
                {
                    SortingMaterialHelpBox();
                }
                EditorGUILayout.Space();
                EditorGUILayout.LabelField("SVG Sorter", EditorStyles.boldLabel);
                EditorGUILayout.PropertyField(overrideSorter);
                if (overrideSorter.hasMultipleDifferentValues || overrideSorter.boolValue)
                {
                    EditorGUILayout.PropertyField(overrideSorterChildren, new GUIContent("Override Children", "Override sorting order in all children."));
                }
                EditorGUI.indentLevel--;
            }

            if (EditorGUI.EndChangeCheck())
            {
                serializedObject.ApplyModifiedProperties();
                for (int i = 0; i < serializedObject.targetObjects.Length; i++)
                {
                    SVGRenderer svgRenderer = serializedObject.targetObjects[i] as SVGRenderer;
                    if (svgRenderer != null)
                    {
                        svgRenderer.UpdateRenderer();
                    }
                }
            }
        }
コード例 #13
0
 public override void Reset()
 {
     gameObject = null;
     color      = null;
     sprite     = null;
 }
コード例 #14
0
        protected virtual void UpdateCollider()
        {
            if (svgRenderer == null)
            {
                svgRenderer = GetComponent <SVGRenderer>();
            }
            if (polygonCollider2D == null)
            {
                polygonCollider2D = GetComponent <PolygonCollider2D>();
            }

            if (svgRenderer.vectorGraphics == null || svgRenderer.vectorGraphics.colliderShape == null || svgRenderer.vectorGraphics.colliderShape.Length == 0)
            {
                polygonCollider2D.pathCount = 0;
                polygonCollider2D.points    = null;
            }
            else
            {
                SVGPath[] colliderShape = svgRenderer.vectorGraphics.colliderShape;
                polygonCollider2D.pathCount = 0;

                if (_quality < 1f)
                {
                    Bounds bounds     = svgRenderer.vectorGraphics.bounds;
                    float  finQuality = _quality;
                    if (finQuality < 0.001f)
                    {
                        finQuality = 0.001f;
                    }

                    precision = Mathf.Max(bounds.size.x, bounds.size.y) / finQuality;
                    if (precision < 0.001f)
                    {
                        precision = 0.001f;
                    }
                    precision *= 0.05f;
                }

                List <Vector2[]> optimisedPaths = new List <Vector2[]>();
                Vector2[]        points;

                for (int i = 0; i < colliderShape.Length; i++)
                {
                    if (_quality < 1f)
                    {
                        points = SVGBezier.Optimise(colliderShape[i].points, precision);
                    }
                    else
                    {
                        points = (Vector2[])colliderShape[i].points.Clone();
                    }

                    //bool clockwiseWinding = SVGGeomUtils.IsWindingClockWise(points);
                    if (_offset != 0f)
                    {
                        points = SVGGeomUtils.OffsetVerts(points, _offset);
                    }

                    if (points != null && points.Length > 2)
                    {
                        optimisedPaths.Add(points);
                    }
                }

                if (optimisedPaths.Count > 0)
                {
                    polygonCollider2D.pathCount = optimisedPaths.Count;
                    for (int i = 0; i < optimisedPaths.Count; i++)
                    {
                        polygonCollider2D.SetPath(i, optimisedPaths[i]);
                    }
                }
            }
        }