public void ChangeColor(Color colorToEdit)
        {
            currentColor = colorToEdit;
            savedColor   = colorToEdit;
            prevColor    = colorToEdit;

            aValue = currentColor.a * 255f;
            rValue = currentColor.r * 255f;
            gValue = currentColor.g * 255f;
            bValue = currentColor.b * 255f;

            aText = aValue.ToString("F0");
            rText = rValue.ToString("F0");
            gText = gValue.ToString("F0");
            bText = bValue.ToString("F0");

            currentHSVColor = new HSBColor(currentColor);
            prevHSVColor    = new HSBColor(currentColor);

            GenerateTextures();
            rainbow        = MaterialUtils.GenerateRainbowGradient(120, 20);
            aTexture       = MaterialUtils.GenerateGradientTexture(100, 20, Color.black, Color.white);
            colorField     = MaterialUtils.GenerateColorField(colorFieldSize, colorFieldSize, currentHSVColor.ToColor());
            WindowPosition = new Rect(Screen.width / 2 - 100, Screen.height / 2f, 210, 100);
            showWindow     = true;
        }
 public UIFloatModifierWindow(EffectFloatModifier mod, bool show) : base((EffectModifier)mod, show)
 {
     floatMod   = mod;
     floatNames = MaterialUtils.FindValidShaderProperties(floatMod.GetMaterial(), WaterfallMaterialPropertyType.Float).ToArray();
     floatIndex = floatNames.ToList().FindIndex(x => x == floatMod.floatName);
     GenerateCurveThumbs(mod);
 }
        void Start()
        {
            if (m_ToolType == null)
            {
                m_GradientButton.gameObject.SetActive(false);
            }

            tooltipAlignment = TextAlignment.Center;

            m_GradientButton.hoverEnter += OnBackgroundHoverEnter; // Display the foreground button actions
            m_GradientButton.hoverExit  += OnActionButtonHoverExit;
            m_GradientButton.click      += OnBackgroundButtonClick;

            m_FrameRenderer.SetBlendShapeWeight(1, 0f);
            m_CloseInsetMeshRenderer.SetBlendShapeWeight(0, 100f);
            m_CloseInsetMaskMeshRenderer.SetBlendShapeWeight(0, 100f);

            m_CloseButton.hoverEnter += OnBackgroundHoverEnter; // Display the foreground button actions
            m_CloseButton.hoverExit  += OnActionButtonHoverExit;
            m_CloseButton.click      += OnSecondaryButtonClicked;
            m_CloseButtonContainerCanvasGroup.alpha = 0f;

            // These materials have already been cloned when instantiating this button
            m_InsetMaterial      = m_InsetMeshRenderer.sharedMaterial;
            m_CloseInsetMaterial = m_CloseInsetMeshRenderer.sharedMaterial;
            // These materials have NOT been cloned when instantiating this button
            m_MaskMaterial            = MaterialUtils.GetMaterialClone(m_MaskRenderer);
            m_CloseButtonMaskMaterial = MaterialUtils.GetMaterialClone(m_CloseInsetMaskMeshRenderer);

            m_InsetMaterial.SetInt(k_MaterialStencilRefProperty, stencilRef);
            m_MaskMaterial.SetInt(k_MaterialStencilRefProperty, stencilRef);
            m_CloseInsetMaterial.SetInt(k_MaterialStencilRefProperty, stencilRef);
            m_CloseButtonMaskMaterial.SetInt(k_MaterialStencilRefProperty, stencilRef);
        }
Exemple #4
0
        public static NetInfo.Node CreateDCNode(NetInfo.Node template, NetInfo netInfo)
        {
            Log.Debug("CreateDCNode called for " + netInfo?.name);
            var material = MaterialUtils.ContinuesMedianMaterial(netInfo);
            var mesh     = MaterialUtils.ContinuesMedianMesh(netInfo);

            mesh = mesh?.CutOutRoadSides();
            mesh?.Elevate();
            if (mesh == null || material == null)
            {
                return(null);
            }

            mesh.name     += "_DC";
            material.name += "_DC";
            NetInfo.Node node = Copy(template);
            node.m_mesh          = node.m_nodeMesh = mesh;
            node.m_material      = node.m_nodeMaterial = material;
            node.m_directConnect = true;
            node.m_connectGroup  = NetInfo.ConnectGroup.DoubleTrain;

            Log.Debug("CreateDCNode sucessful for " + netInfo?.name);
            node.m_nodeMesh.DumpMesh($"DC mesh for {netInfo.name}");
            return(node);
        }
Exemple #5
0
        public override void Setup(AssetData listData)
        {
            base.Setup(listData);

            m_PreviewCoroutine        = null;
            m_VisibilityCoroutine     = null;
            m_AutoHidePreview         = false;
            icon.transform.localScale = Vector3.one;

            // First time setup
            if (!m_Setup)
            {
                // Cube material might change, so we always instance it
                MaterialUtils.GetMaterialClone(m_Cube);

                m_Handle.dragStarted += OnDragStarted;
                m_Handle.dragging    += OnDragging;
                m_Handle.dragEnded   += OnDragEnded;

                m_Handle.hoverStarted += OnHoverStarted;
                m_Handle.hoverEnded   += OnHoverEnded;

                m_Handle.getDropObject = GetDropObject;

                m_Setup = true;
            }

            InstantiatePreview();

            m_Text.text = listData.name;
        }
Exemple #6
0
    public override void init()
    {
        //空子弹可以优化的 不用加到client数组里!
        if (this.isNullBullet)
        {
            this._transform.SetParent(this.scene.bulletLayer, false);
            return;
        }
        if (this._fightEntity.data.ContainsKey("scale"))
        {
            this.scale = Convert.ToSingle(this._fightEntity.data["scale"]);
        }
        base.init();
        this._transform.SetParent(this.scene.bulletLayer, false);
        ViewUtils.changeColor(this.gameObject, ViewConstant.SHIP_SHADER_NAME, (Dictionary <string, object>)ViewConstant.shipConfig[((ClientPlayerEntity)this.bulletEntity.ownerPlayer).shipId]);
        for (int i = 0, len = this._particles.Count; i < len; i++)
        {
            this._particles[i].reset();
        }
        this.changeView(true);

        Color color = MaterialUtils.cloneColor(((ClientPlayerEntity)this.bulletEntity.ownerPlayer).getTeamColor(2));

        color.a = 0.5f;
        ViewUtils.changeColorMaterial(this.gameObject, ViewConstant.EFFECT_SHADER_NAME, color);
    }
Exemple #7
0
        void Start()
        {
            if (!m_EditorWindowCapture)
            {
                m_EditorWindowCapture = GetComponent <EditorWindowCapture>();
            }

            if (!m_RawImage)
            {
                m_RawImage = GetComponent <RawImage>();
            }

            if (m_RawImage)
            {
                // Texture comes in flipped, so it's necessary to correct it
                var rect = m_RawImage.uvRect;
                rect.height      *= -1f;
                m_RawImage.uvRect = rect;
            }

            if (!m_RawImage && !m_Material)
            {
                var renderer = GetComponent <Renderer>();
                m_Material = MaterialUtils.GetMaterialClone(renderer);
            }

            if (m_Material)
            {
                // Texture comes in flipped, so it's necessary to correct it
                var scale = m_Material.mainTextureScale;
                scale.y *= -1f;
                m_Material.mainTextureScale = scale;
            }
        }
Exemple #8
0
 void Awake()
 {
     m_ScrollLineRenderer.SetVertexCount(4);
     m_ScrollLineRenderer.useWorldSpace = true;
     m_ScrollLineRenderer.SetWidth(0f, 0f);
     m_HintLineMaterial = MaterialUtils.GetMaterialClone(m_MeshRenderer);
 }
Exemple #9
0
        void SetupCustomButtonMaterials(Graphic[] graphics, MainMenuFace face)
        {
            const string topGradientProperty    = "_ColorTop";
            const string bottomGradientProperty = "_ColorBottom";
            Material     materialClone          = null;

            foreach (var graphic in graphics)
            {
                // Assign face gradient to custom buttons on a given face (Settings face: locomotion, snapping, etc)
                var material = graphic.material;
                if (material.HasProperty(topGradientProperty))
                {
                    if (materialClone == null)
                    {
                        // Only clone the material if a material with a matching property is found in this custom-button/sub-menu
                        materialClone = MaterialUtils.GetMaterialClone(graphic);
                        m_MaterialsToCleanup.Add(materialClone);
                        materialClone.SetColor(topGradientProperty, face.gradientPair.a);
                        if (materialClone.HasProperty(bottomGradientProperty))
                        {
                            materialClone.SetColor(bottomGradientProperty, face.gradientPair.b);
                        }
                    }

                    graphic.material = materialClone;
                }
            }
        }
Exemple #10
0
 void Awake()
 {
     m_TopHighlightMaterial = MaterialUtils.GetMaterialClone(m_TopHighlightRenderer);
     m_TopHighlightMaterial.SetColor(k_TopColorProperty, UnityBrandColorScheme.sessionGradient.a);
     m_TopHighlightMaterial.SetColor(k_BottomColorProperty, UnityBrandColorScheme.sessionGradient.b);
     m_TopHighlightMaterial.SetFloat(k_AlphaProperty, 0f); // hide the highlight initially
 }
Exemple #11
0
        public override void Setup(FolderData listData)
        {
            base.Setup(listData);

            // First time setup
            if (m_CubeRenderer == null)
            {
                // Cube material might change for hover state, so we always instance it
                m_CubeRenderer = m_Cube.GetComponent <Renderer>();
                m_NormalColor  = m_CubeRenderer.sharedMaterial.color;
                MaterialUtils.GetMaterialClone(m_CubeRenderer);

                m_ExpandArrow.dragEnded += ToggleExpanded;
                m_Cube.dragStarted      += SelectFolder;
                m_Cube.dragEnded        += ToggleExpanded;

                m_Cube.hoverStarted += OnHoverStarted;
                m_Cube.hoverEnded   += OnHoverEnded;
            }

            m_CubeTransform = m_Cube.transform;
            m_Text.text     = listData.name;

            // HACK: We need to kick the canvasRenderer to update the mesh properly
            m_Text.gameObject.SetActive(false);
            m_Text.gameObject.SetActive(true);

            m_ExpandArrow.gameObject.SetActive(listData.children != null);
            m_Hovering = false;
        }
        public override void Setup(FolderData listData, bool firstTime = true)
        {
            base.Setup(listData, firstTime);

            if (firstTime)
            {
                // Cube material might change for hover state, so we always instance it
                m_CubeRenderer = m_Cube.GetComponent <Renderer>();
                m_NormalColor  = m_CubeRenderer.sharedMaterial.color;
                MaterialUtils.GetMaterialClone(m_CubeRenderer);

                m_ExpandArrow.pointerUp += ToggleExpanded;
                m_Cube.pointerDown      += SelectFolder;
                m_Cube.pointerUp        += ToggleExpanded;

                m_Cube.hoverStarted += OnHoverStarted;
                m_Cube.hoverEnded   += OnHoverEnded;
            }

            m_CubeTransform = m_Cube.transform;
            m_Text.text     = listData.name;

            m_ExpandArrow.gameObject.SetActive(listData.children != null);
            m_Hovering = false;
        }
Exemple #13
0
        void Awake()
        {
            m_OriginalIconSprite                  = m_Icon.sprite;
            m_ButtonMaterial                      = MaterialUtils.GetMaterialClone(m_ButtonMeshRenderer);
            m_OriginalLocalScale                  = transform.localScale;
            m_OriginalIconLocalPosition           = m_IconContainer.localPosition;
            m_OriginalContentContainerLocalScale  = m_ContentContainer.localScale;
            m_HighlightContentContainerLocalScale = new Vector3(m_OriginalContentContainerLocalScale.x, m_OriginalContentContainerLocalScale.y, m_OriginalContentContainerLocalScale.z * m_HighlightZScaleMultiplier);
            m_IconHighlightedLocalPosition        = m_OriginalIconLocalPosition + Vector3.forward * m_IconHighlightedLocalZOffset;
            m_IconPressedLocalPosition            = m_OriginalIconLocalPosition + Vector3.back * m_IconHighlightedLocalZOffset;

            m_Icon.color = m_NormalContentColor;
#if INCLUDE_TEXT_MESH_PRO
            m_Text.color = m_NormalContentColor;

            // Clears/resets any non-sprite content(text) from being displayed if a sprite was set on this button
            if (m_OriginalIconSprite)
            {
                SetContent(m_OriginalIconSprite, m_AlternateIconSprite);
            }
            else if (!string.IsNullOrEmpty(m_Text.text))
            {
                SetContent(m_Text.text);
            }
#endif
        }
Exemple #14
0
        protected override void Setup()
        {
            base.Setup();

            m_TextMaterial        = Instantiate(m_TextMaterial);
            m_ExpandArrowMaterial = Instantiate(m_ExpandArrowMaterial);
            m_LockIconMaterial    = Instantiate(m_LockIconMaterial);
            m_UnlockIconMaterial  = Instantiate(m_UnlockIconMaterial);

            m_BottomDropZoneMaterial    = MaterialUtils.GetMaterialClone(m_BottomDropZone.GetComponent <Renderer>());
            m_BottomDropZoneStartHeight = m_BottomDropZone.transform.localScale.z;
            m_TopDropZoneMaterial       = MaterialUtils.GetMaterialClone(m_TopDropZone.GetComponent <Renderer>());
            var color = m_TopDropZoneMaterial.color;

            m_DropZoneAlpha                = color.a;
            color.a                        = 0;
            m_TopDropZoneMaterial.color    = color;
            m_BottomDropZoneMaterial.color = color;

            var dropZones = new[] { m_BottomDropZone, m_TopDropZone };

            foreach (var dropZone in dropZones)
            {
                dropZone.canDrop           = CanDrop;
                dropZone.receiveDrop       = RecieveDrop;
                dropZone.dropHoverStarted += DropHoverStarted;
                dropZone.dropHoverEnded   += DropHoverEnded;
            }

            m_BottomDropZone.gameObject.SetActive(false);             // Don't block scroll interaction
        }
Exemple #15
0
        public override void Setup(AssetData listData, bool firstTime)
        {
            base.Setup(listData, firstTime);

            m_PreviewCoroutine        = null;
            m_VisibilityCoroutine     = null;
            m_AutoHidePreview         = false;
            icon.transform.localScale = Vector3.one;

            // First time setup
            if (!m_Setup)
            {
                // Cube material might change, so we always instance it
                MaterialUtils.GetMaterialClone(m_Cube);

                m_Handle.dragStarted += OnDragStarted;
                m_Handle.dragging    += OnDragging;
                m_Handle.dragging    += OnDraggingFeedForward;
                m_Handle.dragEnded   += OnDragEnded;

                m_Handle.hoverStarted += OnHoverStarted;
                m_Handle.hoverEnded   += OnHoverEnded;

                m_Handle.getDropObject = GetDropObject;

                AssetDropUtils.AssignmentDependencies.TryGetValue(data.type, out m_AssignmentDependencyTypes);

                m_Setup = true;
            }

            InstantiatePreview();

            m_Text.text = listData.name;
        }
Exemple #16
0
        void Start()
        {
            if (this.IsSharedUpdater(this) && m_Preferences == null)
            {
                m_Preferences = new Preferences();

                // Share one preferences object across all instances
                foreach (var linkedObject in linkedObjects)
                {
                    ((SelectionTool)linkedObject).m_Preferences = m_Preferences;
                }
            }

            m_NormalRayColor      = this.GetDefaultRayColor(rayOrigin);
            m_MultiselectRayColor = m_NormalRayColor;
            m_MultiselectRayColor = MaterialUtils.HueShift(m_MultiselectRayColor, k_MultiselectHueShift);

            tooltipTarget = ObjectUtils.CreateEmptyGameObject("SelectionTool Tooltip Target", rayOrigin).transform;
            tooltipTarget.localPosition = k_TooltipPosition;
            tooltipTarget.localRotation = k_TooltipRotation;

            m_BlockSelectCube = ObjectUtils.Instantiate(m_BlockSelectCube, transform);
            m_BlockSelectCube.SetActive(false);
            m_BlockSelectCubeRenderer = m_BlockSelectCube.GetComponent <Renderer>();

            m_BlockSelectSphere = ObjectUtils.Instantiate(m_BlockSelectSphere, transform);
            m_BlockSelectSphere.SetActive(false);

            InputUtils.GetBindingDictionaryFromActionMap(m_ActionMap, m_Controls);
        }
Exemple #17
0
        private void InitializePreviewObjects(CustomMaterial customMaterial, Transform transform)
        {
            if (customMaterial.GameObject)
            {
                materialObject = CreatePreviewMaterial(customMaterial.GameObject, transform);

                if (materialObject)
                {
                    // Fix irregular model scales (in most cases)
                    foreach (Transform child in materialObject.GetComponentsInChildren <Transform>(false))
                    {
                        if (child)
                        {
                            child.localScale    = Vector3.one;
                            child.localPosition = Vector3.zero;
                        }
                    }

                    materialObject.transform.localScale = new Vector3(10f, 37.5f, 75f);
                    if (customMaterial.Descriptor.ReplaceMesh)
                    {
                        // Account for custom mesh scale being weird in previews
                        materialObject.transform.localScale *= 0.025f;
                    }

                    Renderer renderer = materialObject.gameObject?.GetComponentInChildren <Renderer>();
                    MaterialUtils.SetMaterialsColor(renderer?.materials, colorManager.GetObstacleEffectColor());
                }
            }
        }
        public virtual IEnumerator Start()
        {
            // In standalone play-mode usage, attempt to get the TrackedObjectInput
            if (trackedObjectInput == null && m_PlayerInput)
            {
                trackedObjectInput = m_PlayerInput.GetActions <TrackedObject>();
            }

            List <Renderer> renderers = new List <Renderer>();

            while (renderers.Count == 0)
            {
                yield return(null);

                foreach (var meshRoot in m_ProxyMeshRoots)
                {
                    // Only add models of the device and not anything else that is spawned underneath the hand (e.g. menu button, cone/ray)
                    renderers.AddRange(meshRoot.GetComponentsInChildren <Renderer>());
                }
            }

            foreach (var r in renderers)
            {
                m_Materials.AddRange(MaterialUtils.CloneMaterials(r));
            }

            // Move controllers up into EVR range, so they render properly over our UI (e.g. manipulators)
            foreach (var m in m_Materials)
            {
                m.renderQueue = k_RendererQueue;
            }
        }
 public UIColorModifierWindow(EffectColorModifier mod, bool show) : base((EffectModifier)mod, show)
 {
     colorMod   = mod;
     colorName  = colorMod.colorName;
     colorNames = MaterialUtils.FindValidShaderProperties(colorMod.GetMaterial(), WaterfallMaterialPropertyType.Color).ToArray();
     colorIndex = colorNames.ToList().FindIndex(x => x == colorMod.colorName);
     GenerateCurveThumbs(mod);
 }
        public void GenerateTextures()
        {
            rTexture = MaterialUtils.GenerateGradientTexture(100, 20, new Color(0.0f, currentColor.g, currentColor.b, 1.0f), new Color(1.0f, currentColor.g, currentColor.b, 1.0f));
            gTexture = MaterialUtils.GenerateGradientTexture(100, 20, new Color(currentColor.r, 0f, currentColor.b, 1.0f), new Color(currentColor.r, 1f, currentColor.b, 1.0f));
            bTexture = MaterialUtils.GenerateGradientTexture(100, 20, new Color(currentColor.r, currentColor.g, 0f, 1.0f), new Color(currentColor.r, currentColor.g, 1f, 1.0f));

            swatch = MaterialUtils.GenerateColorTexture(60, 20, currentColor);
        }
 void SetMaterial()
 {
     _material = Instantiate(GetComponent <Renderer>().material);
     MaterialUtils.Emission(_material, true);
     _material.color = _baseColor;
     _material.SetColor("_EmissionColor", _flashColor);
     GetComponent <Renderer>().material = _material;
 }
Exemple #22
0
    public static void uniqueMaterialWithClickableEmission(MeshInstance mesh, out SpatialMaterial material)
    {
        // copy the material to be able to set different seedssss
        material = (SpatialMaterial)mesh.GetSurfaceMaterial(0).Duplicate(true);
        MaterialUtils.setClickableEmission(material);

        mesh.SetSurfaceMaterial(0, material);
    }
Exemple #23
0
    void SetColoredBeatValues(BoxColor color)
    {
        //Left 90 degrees
        switch (color)
        {
        case BoxColor.Red:
            xOffset = -xOffsetRef;
            //if (hitDir == Direction.Left) hitDir = Direction.Right; //Not Needed as Default for Horizontal is Direction.Right

            MaterialUtils.ChangeMaterialColor(beatMat, gm.diffuseColors[0]);
            MaterialUtils.ChangeMaterialEmission(beatMat, gm.emissiveColors[0], gm.emissiveIntensities[0]);

            MaterialUtils.ChangeMaterialColor(markerMat, gm.diffuseColors[0]);
            MaterialUtils.ChangeMaterialEmission(markerMat, gm.emissiveColors[0], gm.emissiveIntensities[0]);
            break;

        case BoxColor.Yellow:
            xOffset = -xOffsetRef;
            //if (hitDir == Direction.Left) hitDir = Direction.Right; //Not Needed as Default for Horizontal is Direction.Right

            MaterialUtils.ChangeMaterialColor(beatMat, gm.diffuseColors[3]);
            MaterialUtils.ChangeMaterialEmission(beatMat, gm.emissiveColors[3], gm.emissiveIntensities[3]);

            MaterialUtils.ChangeMaterialColor(markerMat, gm.diffuseColors[3]);
            MaterialUtils.ChangeMaterialEmission(markerMat, gm.emissiveColors[3], gm.emissiveIntensities[3]);
            break;

        case BoxColor.Blue:
            xOffset = xOffsetRef;
            if (hitDir == Direction.Right)
            {
                hitDir = Direction.Left;
            }

            MaterialUtils.ChangeMaterialColor(beatMat, gm.diffuseColors[1]);
            MaterialUtils.ChangeMaterialEmission(beatMat, gm.emissiveColors[1], gm.emissiveIntensities[1]);

            MaterialUtils.ChangeMaterialColor(markerMat, gm.diffuseColors[1]);
            MaterialUtils.ChangeMaterialEmission(markerMat, gm.emissiveColors[1], gm.emissiveIntensities[1]);


            break;

        case BoxColor.Green:
            xOffset = xOffsetRef;
            if (hitDir == Direction.Right)
            {
                hitDir = Direction.Left;
            }

            MaterialUtils.ChangeMaterialColor(beatMat, gm.diffuseColors[2]);
            MaterialUtils.ChangeMaterialEmission(beatMat, gm.emissiveColors[2], gm.emissiveIntensities[2]);

            MaterialUtils.ChangeMaterialColor(markerMat, gm.diffuseColors[2]);
            MaterialUtils.ChangeMaterialEmission(markerMat, gm.emissiveColors[2], gm.emissiveIntensities[2]);
            break;
        }
    }
Exemple #24
0
        private void Awake()
        {
            viewerScale                = 1;
            m_LineRenderer             = GetComponent <VRLineRenderer>();
            m_LineRendererMeshRenderer = m_LineRenderer.GetComponent <MeshRenderer>();
            m_BlinkMaterial            = MaterialUtils.GetMaterialClone(m_RoomScaleRenderer);

            foreach (var renderer in m_LocatorRoot.GetComponentsInChildren <Renderer>())
            {
                renderer.sharedMaterial = m_BlinkMaterial;
            }

            if (!m_ToolPoint)
            {
                m_ToolPoint = transform;
            }

            m_RoomScaleTransform               = m_RoomScaleRenderer.transform;
            m_RoomScaleTransform.parent        = m_LocatorRoot;
            m_RoomScaleTransform.localPosition = Vector3.zero;
            m_RoomScaleTransform.localRotation = Quaternion.identity;

            m_Transform = transform;

            m_LineRenderer.SetVertexCount(m_LineSegmentCount);
            m_LineRenderer.useWorldSpace = true;

            m_MotionSpheres = new Transform[m_MotionSphereCount];
            for (int i = 0; i < m_MotionSphereCount; i++)
            {
                var sphere = ((GameObject)Instantiate(m_MotionIndicatorSphere, m_ToolPoint.position, m_ToolPoint.rotation)).transform;
                m_MotionSpheres[i] = sphere;
                sphere.SetParent(m_Transform, false);
                sphere.name = "motion-sphere-" + i;
                sphere.gameObject.SetActive(false);

                var sphereRenderer = sphere.GetComponent <MeshRenderer>();
                if (m_MotionSpheresMaterial == null)                 // Only one material clone is needed
                {
                    m_MotionSpheresMaterial = MaterialUtils.GetMaterialClone(sphereRenderer);
                }

                sphereRenderer.sharedMaterial = m_MotionSpheresMaterial;
            }
            m_MotionSphereOriginalScale = m_MotionSpheres[0].localScale;
            m_CurveLengthEstimate       = 1.0f;
            m_MotionSphereOffset        = 0.0f;

            m_RingTransform = m_RingRenderer.transform;
            m_RingTransformOriginalScale = m_RingTransform.localScale;
            m_TubeTransform = m_TubeRenderer.transform;
            m_TubeTransformOriginalScale = m_TubeTransform.localScale;
            m_TubeTransformHiddenScale   = new Vector3(m_TubeTransform.localScale.x, 0.0001f, m_TubeTransform.localScale.z);

            ShowLine(false);

            showValidTargetIndicator = true;
        }
 public static Material CalculateMaterial(Material material, ushort nodeID, ushort segmentID)
 {
     if (ShouldHideCrossing(nodeID, segmentID))
     {
         NetInfo netInfo = segmentID.ToSegment().Info;
         material = MaterialUtils.HideCrossings(material, null, netInfo, lod: false);
     }
     return(material);
 }
 public static Mesh CalculateMesh(Mesh mesh, ushort nodeID, ushort segmentID)
 {
     if (ShouldContinueMedian(nodeID, segmentID))
     {
         NetInfo netInfo = segmentID.ToSegment().Info;
         mesh = MaterialUtils.ContinuesMedian(mesh, netInfo, false);
     }
     return(mesh);
 }
        protected void DrawColorField()
        {
            GUILayout.BeginVertical();
            GUILayout.Space(4);
            Rect tRect = GUILayoutUtility.GetRect(120, 20, GUILayout.Width(sliderWidth));

            GUI.DrawTexture(tRect, swatch);
            GUILayout.Space(4);
            tRect = GUILayoutUtility.GetRect(150, 20, GUILayout.Width(sliderWidth));
            GUI.DrawTexture(tRect, rainbow);
            hueValue        = GUILayout.HorizontalSlider(hueValue, 0f, 1f, GUILayout.Width(sliderWidth));
            currentHSVColor = new HSBColor(hueValue, currentHSVColor.s, currentHSVColor.b);
            tRect           = GUILayoutUtility.GetRect(colorFieldSize, colorFieldSize, GUILayout.Width(colorFieldSize));
            GUI.DrawTexture(tRect, colorField);

            var eventType = Event.current.type;

            if (eventType == EventType.Repaint)
            {
                if (Input.GetMouseButtonDown(0))
                {
                    Vector2 screenPoint = GUIUtility.GUIToScreenPoint(Event.current.mousePosition);
                    Rect    screenRect  = GUIUtility.GUIToScreenRect(tRect);


                    if (tRect.Contains(Event.current.mousePosition))
                    {
                        int   x       = (int)Mathf.Clamp(Event.current.mousePosition.x - tRect.xMin, 0, sliderWidth);
                        int   y       = colorFieldSize - (int)Mathf.Clamp(Event.current.mousePosition.y - tRect.yMin, 0, sliderWidth);
                        Color sampled = ((Texture2D)colorField).GetPixel(x, y);
                        Utils.Log($"Color picked at {x}, {y} is {sampled}");
                        currentHSVColor = new HSBColor(sampled);
                        currentColor    = new Color(sampled.r, sampled.g, sampled.b, currentColor.a);
                        aValue          = currentColor.a * 255f;
                        rValue          = currentColor.r * 255f;
                        gValue          = currentColor.g * 255f;
                        bValue          = currentColor.b * 255f;

                        aText = aValue.ToString("F0");
                        rText = rValue.ToString("F0");
                        gText = gValue.ToString("F0");
                        bText = bValue.ToString("F0");
                    }
                }
            }

            GUILayout.EndVertical();
            GUILayout.Space(4);



            if (!currentHSVColor.ToColor().Equals(prevHSVColor.ToColor()))
            {
                colorField   = MaterialUtils.GenerateColorField(colorFieldSize, colorFieldSize, currentHSVColor.ToColor());
                prevHSVColor = currentHSVColor;
            }
        }
Exemple #28
0
        void Awake()
        {
            m_RayMaterial            = MaterialUtils.GetMaterialClone(m_LineRenderer.GetComponent <MeshRenderer>());
            m_ConeTransform          = m_Cone.transform;
            m_OriginalConeLocalScale = m_ConeTransform.localScale;

            rayVisible  = true;
            coneVisible = true;
        }
        public UIColorFromLightModifierWindow(EffectColorFromLightModifier mod, bool show) : base((EffectModifier)mod, show)
        {
            colorMod   = mod;
            colorNames = MaterialUtils.FindValidShaderProperties(colorMod.GetMaterial(), WaterfallMaterialPropertyType.Color).ToArray();
            colorIndex = colorNames.ToList().FindIndex(x => x == colorMod.colorName);

            lightNames = colorMod.parentEffect.parentModule.GetComponentsInChildren <Light>().Select(x => x.transform.name).ToArray();
            lightIndex = lightNames.ToList().FindIndex(x => x == colorMod.lightTransformName);
        }
Exemple #30
0
    private void Start()
    {
        if (generateRandomMaterial)
        {
            randomMaterial = MaterialUtils.CreateMaterialWithRandomColor($"{gameObject.name}_material");
        }

        Generate();
    }