コード例 #1
0
ファイル: Draw.cs プロジェクト: samuelhegner/Flocking_Unity2D
        [OvldGenCallTarget] public static void Sphere([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
                                                      [OvldDefault(nameof(SphereRadiusSpace))] ThicknessSpace spaceRadius,
                                                      Vector3 pos,
                                                      [OvldDefault(nameof(SphereRadius))] float radius,
                                                      [OvldDefault(nameof(Color))] Color color)
        {
            Material mat = ShapesMaterialUtils.matSphere[blendMode];

            ApplyGlobalProperties(mat);
            mat.SetColor(ShapesMaterialUtils.propColor, color);
            mat.SetFloat(ShapesMaterialUtils.propRadius, radius);
            mat.SetInt(ShapesMaterialUtils.propRadiusSpace, (int)spaceRadius);
            DrawMesh(pos, Quaternion.identity, ShapesMeshUtils.SphereMesh, mat);
        }
コード例 #2
0
        [OvldGenCallTarget] public static void Cuboid([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
                                                      [OvldDefault(nameof(CuboidSizeSpace))] ThicknessSpace sizeSpace,
                                                      Vector3 pos,
                                                      [OvldDefault("Quaternion.identity")] Quaternion rot,
                                                      Vector3 size,
                                                      [OvldDefault(nameof(Color))] Color color)
        {
            Material mat = ShapesMaterialUtils.matCuboid[blendMode];

            mat.SetColor(ShapesMaterialUtils.propColor, color);
            mat.SetVector(ShapesMaterialUtils.propSize, size);
            mat.SetInt(ShapesMaterialUtils.propSizeSpace, (int)sizeSpace);
            DrawMesh(pos, rot, ShapesMeshUtils.CuboidMesh, mat);
        }
コード例 #3
0
        static string GetShaderBlendMode(this ShapesBlendMode blendMode)
        {
            switch (blendMode)
            {
            case ShapesBlendMode.Opaque:         return("One Zero");

            case ShapesBlendMode.Transparent:    return("SrcAlpha OneMinusSrcAlpha");

            case ShapesBlendMode.Additive:       return("One One");

            case ShapesBlendMode.Multiplicative: return("DstColor Zero");

            default:                             throw new ArgumentOutOfRangeException(nameof(blendMode), blendMode, null);
            }
        }
コード例 #4
0
ファイル: Draw.cs プロジェクト: samuelhegner/Flocking_Unity2D
        static void DiscCore(ShapesBlendMode blendMode, ThicknessSpace spaceRadius, ThicknessSpace spaceThickness, bool hollow, bool sector, Vector3 pos, Quaternion rot, float radius, float thickness, Color colorInnerStart, Color colorOuterStart, Color colorInnerEnd, Color colorOuterEnd, DashStyle dashStyle = null, float angleRadStart = 0f, float angleRadEnd = 0f, ArcEndCap arcEndCaps = ArcEndCap.None)
        {
            if (sector && Mathf.Abs(angleRadEnd - angleRadStart) < 0.0001f)
            {
                return;
            }
            Material mat = ShapesMaterialUtils.GetDiscMaterial(hollow, sector)[blendMode];

            ApplyGlobalProperties(mat);
            mat.SetFloat(ShapesMaterialUtils.propRadius, radius);
            mat.SetInt(ShapesMaterialUtils.propRadiusSpace, (int)spaceRadius);
            mat.SetInt(ShapesMaterialUtils.propAlignment, (int)Draw.DiscGeometry);
            if (hollow)
            {
                mat.SetInt(ShapesMaterialUtils.propThicknessSpace, (int)spaceThickness);
                mat.SetFloat(ShapesMaterialUtils.propThickness, thickness);
                mat.SetInt(ShapesMaterialUtils.propScaleMode, (int)ScaleMode);
            }

            if (sector)
            {
                mat.SetFloat(ShapesMaterialUtils.propAngStart, angleRadStart);
                mat.SetFloat(ShapesMaterialUtils.propAngEnd, angleRadEnd);
                if (hollow)
                {
                    mat.SetFloat(ShapesMaterialUtils.propRoundCaps, (int)arcEndCaps);
                }
            }

            mat.SetColor(ShapesMaterialUtils.propColor, colorInnerStart);
            mat.SetColor(ShapesMaterialUtils.propColorOuterStart, colorOuterStart);
            mat.SetColor(ShapesMaterialUtils.propColorInnerEnd, colorInnerEnd);
            mat.SetColor(ShapesMaterialUtils.propColorOuterEnd, colorOuterEnd);

            bool dashed = dashStyle?.size > 0f;

            mat.SetFloat(ShapesMaterialUtils.propDashSize, dashed ? dashStyle.GetNetAbsoluteSize(true, thickness) : 0);
            if (dashed)
            {
                mat.SetInt(ShapesMaterialUtils.propDashType, (int)dashStyle.type);
                mat.SetInt(ShapesMaterialUtils.propDashSpace, (int)dashStyle.space);
                mat.SetInt(ShapesMaterialUtils.propDashSnap, (int)dashStyle.snap);
                mat.SetFloat(ShapesMaterialUtils.propDashOffset, dashStyle.offset);
                mat.SetFloat(ShapesMaterialUtils.propDashSpacing, dashStyle.GetNetAbsoluteSpacing(true, thickness));
            }

            DrawMesh(pos, rot, ShapesMeshUtils.QuadMesh, mat);
        }
コード例 #5
0
        [OvldGenCallTarget] public static void Polyline([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
                                                        PolylinePath path,
                                                        [OvldDefault("false")] bool closed,
                                                        [OvldDefault(nameof(PolylineGeometry))] PolylineGeometry geometry,
                                                        [OvldDefault(nameof(PolylineJoins))] PolylineJoins joins,
                                                        [OvldDefault(nameof(LineThickness))] float thickness,
                                                        [OvldDefault(nameof(LineThicknessSpace))] ThicknessSpace thicknessSpace,
                                                        [OvldDefault(nameof(Color))] Color color)
        {
            if (path.EnsureMeshIsReadyToRender(closed, joins, out Mesh mesh) == false)
            {
                return;                 // no points defined in the mesh
            }
            switch (path.Count)
            {
            case 0:
                Debug.LogWarning("Tried to draw polyline with no points");
                return;

            case 1:
                Debug.LogWarning("Tried to draw polyline with only one point");
                return;
            }

            Material matPolyLine = ShapesMaterialUtils.GetPolylineMat(joins)[blendMode];

            ApplyGlobalProperties(matPolyLine);
            matPolyLine.SetFloat(ShapesMaterialUtils.propThickness, thickness);
            matPolyLine.SetFloat(ShapesMaterialUtils.propThicknessSpace, (int)thicknessSpace);
            matPolyLine.SetColor(ShapesMaterialUtils.propColor, color);
            matPolyLine.SetInt(ShapesMaterialUtils.propAlignment, (int)geometry);
            matPolyLine.SetInt(ShapesMaterialUtils.propScaleMode, (int)ScaleMode);
            if (joins == PolylineJoins.Miter)
            {
                DrawMesh(Vector3.zero, Quaternion.identity, mesh, matPolyLine);
            }
            else
            {
                Material matPolyLineJoins = ShapesMaterialUtils.GetPolylineJoinsMat(joins)[blendMode];
                ApplyGlobalProperties(matPolyLineJoins);
                matPolyLineJoins.SetFloat(ShapesMaterialUtils.propThickness, thickness);
                matPolyLineJoins.SetFloat(ShapesMaterialUtils.propThicknessSpace, (int)thicknessSpace);
                matPolyLineJoins.SetColor(ShapesMaterialUtils.propColor, color);
                matPolyLineJoins.SetInt(ShapesMaterialUtils.propAlignment, (int)geometry);
                matPolyLineJoins.SetInt(ShapesMaterialUtils.propScaleMode, (int)ScaleMode);
                DrawTwoSubmeshes(Vector3.zero, Quaternion.identity, mesh, matPolyLine, matPolyLineJoins);
            }
        }
コード例 #6
0
 [OvldGenCallTarget] static void Triangle([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
                                          Vector3 a,
                                          Vector3 b,
                                          Vector3 c,
                                          [OvldDefault(nameof(Color))] Color colorA,
                                          [OvldDefault(nameof(Color))] Color colorB,
                                          [OvldDefault(nameof(Color))] Color colorC)
 {
     using (new IMDrawer(mpbTriangle, ShapesMaterialUtils.matTriangle[blendMode], ShapesMeshUtils.TriangleMesh[0])) {
         mpbTriangle.a.Add(a);
         mpbTriangle.b.Add(b);
         mpbTriangle.c.Add(c);
         mpbTriangle.color.Add(colorA);
         mpbTriangle.colorB.Add(colorB);
         mpbTriangle.colorC.Add(colorC);
     }
 }
コード例 #7
0
        [OvldGenCallTarget] public static void Cone([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
                                                    [OvldDefault(nameof(ConeSizeSpace))] ThicknessSpace sizeSpace,
                                                    Vector3 pos,
                                                    [OvldDefault("Quaternion.identity")] Quaternion rot,
                                                    float radius,
                                                    float length,
                                                    [OvldDefault("true")] bool fillCap,
                                                    [OvldDefault(nameof(Color))] Color color)
        {
            Material mat = ShapesMaterialUtils.matCone[blendMode];

            mat.SetColor(ShapesMaterialUtils.propColor, color);
            mat.SetFloat(ShapesMaterialUtils.propRadius, radius);
            mat.SetFloat(ShapesMaterialUtils.propLength, length);
            mat.SetInt(ShapesMaterialUtils.propSizeSpace, (int)sizeSpace);
            DrawMesh(pos, rot, fillCap ? ShapesMeshUtils.ConeMesh : ShapesMeshUtils.ConeMeshUncapped, mat);
        }
コード例 #8
0
        public static IEnumerable <string> GetPassRenderStates(this ShapesBlendMode blendMode)
        {
            yield return("Cull Off");

            if (blendMode.ZWrite() == false)
            {
                yield return("ZWrite Off");
            }
            if (blendMode.AlphaToMask())
            {
                yield return("AlphaToMask On");
            }
            if (blendMode.HasSpecialBlendMode())
            {
                yield return($"Blend {blendMode.GetShaderBlendMode()}");
            }
        }
コード例 #9
0
        [OvldGenCallTarget] public static void Triangle([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
                                                        Vector3 a,
                                                        Vector3 b,
                                                        Vector3 c,
                                                        [OvldDefault(nameof(Color))] Color colorA,
                                                        [OvldDefault(nameof(Color))] Color colorB,
                                                        [OvldDefault(nameof(Color))] Color colorC)
        {
            Material mat = ShapesMaterialUtils.matTriangle[blendMode];

            mat.SetVector(ShapesMaterialUtils.propA, a);
            mat.SetVector(ShapesMaterialUtils.propB, b);
            mat.SetVector(ShapesMaterialUtils.propC, c);
            mat.SetColor(ShapesMaterialUtils.propColor, colorA);
            mat.SetColor(ShapesMaterialUtils.propColorB, colorB);
            mat.SetColor(ShapesMaterialUtils.propColorC, colorC);
            DrawMesh(Vector3.zero, Quaternion.identity, ShapesMeshUtils.TriangleMesh, mat);
        }
コード例 #10
0
        [OvldGenCallTarget] static void Cone([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
                                             [OvldDefault(nameof(ConeSizeSpace))] ThicknessSpace sizeSpace,
                                             Vector3 pos,
                                             [OvldDefault("Quaternion.identity")] Quaternion rot,
                                             float radius,
                                             float length,
                                             [OvldDefault("true")] bool fillCap,
                                             [OvldDefault(nameof(Color))] Color color)
        {
            Mesh mesh = fillCap ? ShapesMeshUtils.ConeMesh[(int)DetailLevel] : ShapesMeshUtils.ConeMeshUncapped[(int)DetailLevel];

            using (new IMDrawer(mpbCone, ShapesMaterialUtils.matCone[blendMode], mesh, pos, rot)) {
                mpbCone.color.Add(color);
                mpbCone.radius.Add(radius);
                mpbCone.length.Add(length);
                mpbCone.sizeSpace.Add((float)sizeSpace);
            }
        }
コード例 #11
0
        [OvldGenCallTarget] public static void Rectangle([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
                                                         [OvldDefault("false")] bool hollow,
                                                         [OvldDefault("Vector3.zero")] Vector3 pos,
                                                         [OvldDefault("Quaternion.identity")] Quaternion rot,
                                                         Rect rect,
                                                         [OvldDefault(nameof(Color))] Color color,
                                                         [OvldDefault("0f")] float thickness          = 0f,
                                                         [OvldDefault("default")] Vector4 cornerRadii = default)
        {
            bool rounded = ShapesMath.MaxComp(cornerRadii) >= 0.0001f;

            // positive vibes only
            if (rect.width < 0)
            {
                rect.x -= rect.width *= -1;
            }
            if (rect.height < 0)
            {
                rect.y -= rect.height *= -1;
            }

            if (hollow && thickness * 2 >= Mathf.Min(rect.width, rect.height))
            {
                hollow = false;
            }
            Material mat = ShapesMaterialUtils.GetRectMaterial(hollow, rounded)[blendMode];

            ApplyGlobalProperties(mat);
            mat.SetColor(ShapesMaterialUtils.propColor, color);
            mat.SetVector(ShapesMaterialUtils.propRect, rect.ToVector4());
            if (rounded)
            {
                mat.SetVector(ShapesMaterialUtils.propCornerRadii, cornerRadii);
            }
            if (hollow)
            {
                mat.SetFloat(ShapesMaterialUtils.propThickness, thickness);
                mat.SetInt(ShapesMaterialUtils.propScaleMode, (int)ScaleMode);
            }

            DrawMesh(pos, rot, ShapesMeshUtils.QuadMesh, mat);
        }
コード例 #12
0
        [OvldGenCallTarget] static void Polyline([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
                                                 PolylinePath path,
                                                 [OvldDefault("false")] bool closed,
                                                 [OvldDefault(nameof(PolylineGeometry))] PolylineGeometry geometry,
                                                 [OvldDefault(nameof(PolylineJoins))] PolylineJoins joins,
                                                 [OvldDefault(nameof(LineThickness))] float thickness,
                                                 [OvldDefault(nameof(LineThicknessSpace))] ThicknessSpace thicknessSpace,
                                                 [OvldDefault(nameof(Color))] Color color)
        {
            if (path.EnsureMeshIsReadyToRender(closed, joins, out Mesh mesh) == false)
            {
                return;                 // no points defined in the mesh
            }
            switch (path.Count)
            {
            case 0:
                Debug.LogWarning("Tried to draw polyline with no points");
                return;

            case 1:
                Debug.LogWarning("Tried to draw polyline with only one point");
                return;
            }

            void ApplyToMpb(MpbPolyline mpb)
            {
                mpb.thickness.Add(thickness);
                mpb.thicknessSpace.Add((int)thicknessSpace);
                mpb.color.Add(color);
                mpb.alignment.Add((int)geometry);
                mpb.scaleMode.Add((int)ScaleMode);
            }

            using (new IMDrawer(mpbPolyline, ShapesMaterialUtils.GetPolylineMat(joins)[blendMode], mesh, 0))
                ApplyToMpb(mpbPolyline);

            if (joins.HasJoinMesh())
            {
                using (new IMDrawer(mpbPolylineJoins, ShapesMaterialUtils.GetPolylineJoinsMat(joins)[blendMode], mesh, 1))
                    ApplyToMpb(mpbPolylineJoins);
            }
        }
コード例 #13
0
 [OvldGenCallTarget] static void Quad([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
                                      Vector3 a,
                                      Vector3 b,
                                      Vector3 c,
                                      [OvldDefault("a + ( c - b )")] Vector3 d,
                                      [OvldDefault(nameof(Color))] Color colorA,
                                      [OvldDefault(nameof(Color))] Color colorB,
                                      [OvldDefault(nameof(Color))] Color colorC,
                                      [OvldDefault(nameof(Color))] Color colorD)
 {
     using (new IMDrawer(mpbQuad, ShapesMaterialUtils.matQuad[blendMode], ShapesMeshUtils.QuadMesh[0])) {
         mpbQuad.a.Add(a);
         mpbQuad.b.Add(b);
         mpbQuad.c.Add(c);
         mpbQuad.d.Add(d);
         mpbQuad.color.Add(colorA);
         mpbQuad.colorB.Add(colorB);
         mpbQuad.colorC.Add(colorC);
         mpbQuad.colorD.Add(colorD);
     }
 }
コード例 #14
0
        [OvldGenCallTarget] public static void Quad([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
                                                    Vector3 a,
                                                    Vector3 b,
                                                    Vector3 c,
                                                    [OvldDefault("a + ( c - b )")] Vector3 d,
                                                    [OvldDefault(nameof(Color))] Color colorA,
                                                    [OvldDefault(nameof(Color))] Color colorB,
                                                    [OvldDefault(nameof(Color))] Color colorC,
                                                    [OvldDefault(nameof(Color))] Color colorD)
        {
            Material mat = ShapesMaterialUtils.matQuad[blendMode];

            mat.SetVector(ShapesMaterialUtils.propA, a);
            mat.SetVector(ShapesMaterialUtils.propB, b);
            mat.SetVector(ShapesMaterialUtils.propC, c);
            mat.SetVector(ShapesMaterialUtils.propD, d);
            mat.SetColor(ShapesMaterialUtils.propColor, colorA);
            mat.SetColor(ShapesMaterialUtils.propColorB, colorB);
            mat.SetColor(ShapesMaterialUtils.propColorC, colorC);
            mat.SetColor(ShapesMaterialUtils.propColorD, colorD);
            DrawMesh(Vector3.zero, Quaternion.identity, ShapesMeshUtils.QuadMesh, mat);
        }
コード例 #15
0
ファイル: Draw.cs プロジェクト: samuelhegner/Flocking_Unity2D
        [OvldGenCallTarget] public static void Line([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
                                                    [OvldDefault(nameof(LineGeometry))] LineGeometry geometry,
                                                    [OvldDefault(nameof(LineEndCaps))] LineEndCap endCaps,
                                                    [OvldDefault(nameof(LineThicknessSpace))] ThicknessSpace thicknessSpace,
                                                    Vector3 start,
                                                    Vector3 end,
                                                    [OvldDefault(nameof(Color))] Color colorStart,
                                                    [OvldDefault(nameof(Color))] Color colorEnd,
                                                    [OvldDefault(nameof(LineThickness))] float thickness,
                                                    [OvldDefault(nameof(LineDashStyle))] DashStyle dashStyle = null)
        {
            Material mat = ShapesMaterialUtils.GetLineMat(geometry, endCaps)[blendMode];

            ApplyGlobalProperties(mat);
            mat.SetColor(ShapesMaterialUtils.propColor, colorStart);
            mat.SetColor(ShapesMaterialUtils.propColorEnd, colorEnd);
            mat.SetVector(ShapesMaterialUtils.propPointStart, start);
            mat.SetVector(ShapesMaterialUtils.propPointEnd, end);
            mat.SetFloat(ShapesMaterialUtils.propThickness, thickness);
            mat.SetInt(ShapesMaterialUtils.propAlignment, (int)geometry);
            mat.SetInt(ShapesMaterialUtils.propThicknessSpace, (int)thicknessSpace);
            mat.SetInt(ShapesMaterialUtils.propScaleMode, (int)ScaleMode);
            bool dashed = dashStyle?.size > 0f;

            mat.SetFloat(ShapesMaterialUtils.propDashSize, dashed ? dashStyle.GetNetAbsoluteSize(true, thickness) : 0);
            if (dashed)
            {
                if (geometry != LineGeometry.Volumetric3D)
                {
                    mat.SetInt(ShapesMaterialUtils.propDashType, (int)dashStyle.type);
                }
                mat.SetInt(ShapesMaterialUtils.propDashSpace, (int)dashStyle.space);
                mat.SetInt(ShapesMaterialUtils.propDashSnap, (int)dashStyle.snap);
                mat.SetFloat(ShapesMaterialUtils.propDashOffset, dashStyle.offset);
                mat.SetFloat(ShapesMaterialUtils.propDashSpacing, dashStyle.GetNetAbsoluteSpacing(true, thickness));
            }

            DrawMesh(Vector3.zero, Quaternion.identity, ShapesMeshUtils.GetLineMesh(geometry, endCaps), mat);
        }
コード例 #16
0
        static void DiscCore(ShapesBlendMode blendMode, ThicknessSpace spaceRadius, ThicknessSpace spaceThickness, bool hollow, bool sector, Vector3 pos, Quaternion rot, float radius, float thickness, Color colorInnerStart, Color colorOuterStart, Color colorInnerEnd, Color colorOuterEnd, DashStyle dashStyle = null, float angleRadStart = 0f, float angleRadEnd = 0f, ArcEndCap arcEndCaps = ArcEndCap.None)
        {
            if (sector && Mathf.Abs(angleRadEnd - angleRadStart) < 0.0001f)
            {
                return;
            }
            Material mat = ShapesMaterialUtils.GetDiscMaterial(hollow, sector)[blendMode];

            ApplyGlobalProperties(mat);
            mat.SetFloat(ShapesMaterialUtils.propRadius, radius);
            mat.SetInt(ShapesMaterialUtils.propRadiusSpace, (int)spaceRadius);
            mat.SetInt(ShapesMaterialUtils.propAlignment, (int)Draw.DiscGeometry);
            if (hollow)
            {
                mat.SetInt(ShapesMaterialUtils.propThicknessSpace, (int)spaceThickness);
                mat.SetFloat(ShapesMaterialUtils.propThickness, thickness);
                mat.SetInt(ShapesMaterialUtils.propScaleMode, (int)ScaleMode);
            }

            if (sector)
            {
                mat.SetFloat(ShapesMaterialUtils.propAngStart, angleRadStart);
                mat.SetFloat(ShapesMaterialUtils.propAngEnd, angleRadEnd);
                if (hollow)
                {
                    mat.SetFloat(ShapesMaterialUtils.propRoundCaps, (int)arcEndCaps);
                }
            }

            mat.SetColor(ShapesMaterialUtils.propColor, colorInnerStart);
            mat.SetColor(ShapesMaterialUtils.propColorOuterStart, colorOuterStart);
            mat.SetColor(ShapesMaterialUtils.propColorInnerEnd, colorInnerEnd);
            mat.SetColor(ShapesMaterialUtils.propColorOuterEnd, colorOuterEnd);

            ApplyDashSettings(mat, dashStyle, thickness);

            DrawMesh(pos, rot, ShapesMeshUtils.QuadMesh, mat);
        }
コード例 #17
0
        public ShaderBuilder(string name, ShapesBlendMode blendMode, RenderPipeline rp)
        {
            this.blendMode  = blendMode;
            this.shaderName = name;

            using (Scope($"Shader \"Shapes/{name} {blendMode.ToString()}\"")) {
                using (Scope("Properties")) {
                    AppendLine("[Enum(UnityEngine.Rendering.CompareFunction)] _ZTest (\"Z Test\", int) = 4");
                    AppendLine("_ZOffsetFactor (\"Z Offset Factor\", Float ) = 0");
                    AppendLine("_ZOffsetUnits (\"Z Offset Units\", int ) = 0");

                    AppendLine("[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp (\"Stencil Comparison\", int) = 8");
                    AppendLine("[Enum(UnityEngine.Rendering.StencilOp)] _StencilOpPass (\"Stencil Operation Pass\", int) = 0");
                    AppendLine("_StencilID (\"Stencil ID\", int) = 0");
                    AppendLine("_StencilReadMask (\"Stencil Read Mask\", int) = 255");
                    AppendLine("_StencilWriteMask (\"Stencil Write Mask\", int) = 255");
                    if (name == "Texture")
                    {
                        AppendLine("_MainTex (\"Texture\", 2D) = \"white\" {}");
                    }
                }

                using (Scope("SubShader")) {
                    using (Scope("Tags")) {                        // subshader tags
                        AppendLines(rp.GetSubshaderTags());
                        AppendLines(blendMode.GetSubshaderTags());
                    }

                    AppendPass(ShaderPassType.Render, rp);
                    if (rp != RenderPipeline.Legacy)
                    {
                        AppendPass(ShaderPassType.DepthOnly, rp);
                    }
                    AppendPass(ShaderPassType.Picking, rp);
                    AppendPass(ShaderPassType.Selection, rp);
                }
            }
        }
コード例 #18
0
        static void DiscCore(ShapesBlendMode blendMode, ThicknessSpace spaceRadius, ThicknessSpace spaceThickness, bool hollow, bool sector, Vector3 pos, Quaternion rot, float radius, float thickness, Color colorInnerStart, Color colorOuterStart, Color colorInnerEnd, Color colorOuterEnd, DashStyle dashStyle = null, float angleRadStart = 0f, float angleRadEnd = 0f, ArcEndCap arcEndCaps = ArcEndCap.None)
        {
            if (sector && Mathf.Abs(angleRadEnd - angleRadStart) < 0.0001f)
            {
                return;
            }

            using (new IMDrawer(mpbDisc, ShapesMaterialUtils.GetDiscMaterial(hollow, sector)[blendMode], ShapesMeshUtils.QuadMesh[0], pos, rot)) {
                MetaMpb.ApplyDashSettings(mpbDisc, dashStyle, thickness);
                mpbDisc.radius.Add(radius);
                mpbDisc.radiusSpace.Add((int)spaceRadius);
                mpbDisc.alignment.Add((int)Draw.DiscGeometry);
                mpbDisc.thicknessSpace.Add((int)spaceThickness);
                mpbDisc.thickness.Add(thickness);
                mpbDisc.scaleMode.Add((int)ScaleMode);
                mpbDisc.angStart.Add(angleRadStart);
                mpbDisc.angEnd.Add(angleRadEnd);
                mpbDisc.roundCaps.Add((int)arcEndCaps);
                mpbDisc.color.Add(colorInnerStart);
                mpbDisc.colorOuterStart.Add(colorOuterStart);
                mpbDisc.colorInnerEnd.Add(colorInnerEnd);
                mpbDisc.colorOuterEnd.Add(colorOuterEnd);
            }
        }
コード例 #19
0
        [OvldGenCallTarget] public static void RegularPolygon([OvldDefault(nameof(BlendMode))] ShapesBlendMode blendMode,
                                                              [OvldDefault(nameof(RegularPolygonRadiusSpace))] ThicknessSpace spaceRadius,
                                                              [OvldDefault(nameof(RegularPolygonThicknessSpace))] ThicknessSpace spaceThickness,
                                                              Vector3 pos,
                                                              [OvldDefault("Quaternion.identity")] Quaternion rot,
                                                              [OvldDefault(nameof(RegularPolygonSideCount))] int sideCount,
                                                              [OvldDefault(nameof(RegularPolygonRadius))] float radius,
                                                              [OvldDefault(nameof(RegularPolygonThickness))] float thickness,
                                                              [OvldDefault(nameof(Color))] Color color,
                                                              bool hollow,
                                                              [OvldDefault("0f")] float roundness,
                                                              [OvldDefault("0f")] float angle,
                                                              [OvldDefault(nameof(PolygonShapeFill))] ShapeFill fill)
        {
            Material mat = ShapesMaterialUtils.matRegularPolygon[blendMode];

            ApplyGlobalProperties(mat);
            mat.SetFloat(ShapesMaterialUtils.propRadius, radius);
            mat.SetInt(ShapesMaterialUtils.propRadiusSpace, (int)spaceRadius);
            mat.SetInt(ShapesMaterialUtils.propAlignment, (int)Draw.RegularPolygonGeometry);
            mat.SetInt(ShapesMaterialUtils.propSides, Mathf.Max(3, sideCount));
            mat.SetFloat(ShapesMaterialUtils.propAng, angle);
            mat.SetFloat(ShapesMaterialUtils.propRoundness, roundness);

            mat.SetInt(ShapesMaterialUtils.propHollow, hollow.AsInt());
            if (hollow)
            {
                mat.SetInt(ShapesMaterialUtils.propThicknessSpace, (int)spaceThickness);
                mat.SetFloat(ShapesMaterialUtils.propThickness, thickness);
                mat.SetInt(ShapesMaterialUtils.propScaleMode, (int)ScaleMode);
            }

            TryApplyFillAndColor(mat, fill, color);

            DrawMesh(pos, rot, ShapesMeshUtils.QuadMesh, mat);
        }
コード例 #20
0
        public static void GenerateShadersAndMaterials()
        {
            int                     blendModeCount = System.Enum.GetNames(typeof(ShapesBlendMode)).Length;
            const string            CORE_SUFFIX    = " Core";
            IEnumerable <TextAsset> shaderCores    = ShapesIO.LoadAllAssets <TextAsset>(ShapesIO.CoreShaderFolder);
            IEnumerable <string>    shaderNames    = shaderCores.Select(x => x.name.Substring(0, x.name.Length - CORE_SUFFIX.Length));

            // generate all shaders
            foreach (string name in shaderNames)
            {
                for (int i = 0; i < blendModeCount; i++)
                {
                    ShapesBlendMode blendMode      = (ShapesBlendMode)i;
                    string          path           = $"{ShapesIO.GeneratedShadersFolder}/{name} {blendMode}.shader";
                    string          shaderContents = new ShaderBuilder(name, blendMode).shader;
                    File.WriteAllText(path, shaderContents);
                }
            }

            // reimport all assets to load newly generated shaders
            AssetDatabase.Refresh(ImportAssetOptions.Default);

            // generate all materials
            foreach (string name in shaderNames)
            {
                for (int i = 0; i < blendModeCount; i++)
                {
                    ShapesBlendMode blendMode         = (ShapesBlendMode)i;
                    string          nameWithBlendMode = ShapesMaterials.GetMaterialName(name, blendMode.ToString());
                    Shader          shader            = Shader.Find($"Shapes/{nameWithBlendMode}");
                    if (shader == null)
                    {
                        Debug.LogError("missing shader " + $"Shapes/{nameWithBlendMode}");
                        continue;
                    }


                    if (ShaderBuilder.shaderKeywords.ContainsKey(name))
                    {
                        // create all permutations
                        MultiCompile[] multis = ShaderBuilder.shaderKeywords[name];
                        List <string>  keywordPermutations = new List <string>();
                        foreach (IEnumerable <string> perm in GetPermutations(multis.Select(m => m.Enumerate())))
                        {
                            IEnumerable <string> validKeywords = perm.Where(p => string.IsNullOrEmpty(p) == false);
                            string kws = $" [{string.Join( "][", validKeywords )}]";
                            if (kws.Contains("[]"))                                // this means it has no permutations
                            {
                                kws = "";
                            }
                            TryCreateMaterial(nameWithBlendMode + kws, validKeywords);
                        }
                    }
                    else
                    {
                        TryCreateMaterial(nameWithBlendMode);
                    }

                    Material TryCreateMaterial(string fullMaterialName, IEnumerable <string> keywords = null)
                    {
                        string   savePath = $"{ShapesIO.GeneratedMaterialsFolder}/{fullMaterialName}.mat";
                        Material mat      = AssetDatabase.LoadAssetAtPath <Material>(savePath);

                        void TrySetKeywords()
                        {
                            if (keywords != null)
                            {
                                foreach (string keyword in keywords)
                                {
                                    mat.EnableKeyword(keyword);
                                }
                            }
                        }

                        if (mat != null)
                        {
                            EditorUtility.SetDirty(mat);
                            mat.hideFlags = HideFlags.HideInInspector;
                            TrySetKeywords();
                        }
                        else
                        {
                            Debug.Log("creating material " + savePath);
                            mat = new Material(shader)
                            {
                                enableInstancing = true, hideFlags = HideFlags.HideInInspector
                            };
                            TrySetKeywords();
                            AssetDatabase.CreateAsset(mat, savePath);
                        }

                        return(mat);
                    }
                }
            }

            AssetDatabase.Refresh(ImportAssetOptions.Default);
        }
コード例 #21
0
 static string Queue(this ShapesBlendMode blendMode) => blendMode == ShapesBlendMode.Opaque ? "AlphaTest" : "Transparent";
コード例 #22
0
        void DrawShapes()
        {
            Vector2 center    = position.size / 2;
            float   fitRadius = Mathf.Min(position.width, position.height) / 2 - 8;

            // set doot positions
            float t = (float)EditorApplication.timeSinceStartup / 2;

            foreach (Doot doot in doots)
            {
                float   ang = doot.angSpeed * t * ShapesMath.TAU + doot.angOffset;
                Vector2 dir = ShapesMath.AngToDir(ang);
                doot.pos = dir * (fitRadius * doot.radialOffset);
            }

            // mouse doot~
            Vector2 mouseRawPos    = Event.current.mousePosition - center;
            float   maxRadius      = fitRadius * DOOT_MAX_RADIUS;
            Vector2 mouseTargetPos = Vector2.ClampMagnitude(mouseRawPos, maxRadius);

            doots[0].pos = Vector2.Lerp(doots[0].pos, mouseTargetPos, mouseDootT);
            bool mouseOver = mouseOverWindow == this;

            mouseDootT = Mathf.Lerp(mouseDootT, mouseOver ? 1f : 0f, 0.05f);


            // save state
            Matrix4x4       prevMtx                = Draw.Matrix;
            ShapesBlendMode prevBlendMode          = Draw.BlendMode;
            ThicknessSpace  prevDiscRadiusSpace    = Draw.DiscRadiusSpace;
            ThicknessSpace  prevLineThicknessSpace = Draw.LineThicknessSpace;
            LineGeometry    prevLineGeometry       = Draw.LineGeometry;
            ThicknessSpace  prevRingThicknessSpace = Draw.RingThicknessSpace;

            // draw setup
            Draw.Matrix             = Matrix4x4.TRS(new Vector3(center.x, center.y, 1f), Quaternion.identity, Vector3.one);
            Draw.BlendMode          = ShapesBlendMode.Transparent;
            Draw.DiscRadiusSpace    = ThicknessSpace.Meters;
            Draw.LineThicknessSpace = ThicknessSpace.Meters;
            Draw.LineGeometry       = LineGeometry.Flat2D;
            Draw.RingThicknessSpace = ThicknessSpace.Meters;

            // Drawing
            Draw.RingGradientRadial(Vector3.zero, fitRadius, fitRadius * 0.1f, Color.black, new Color(0, 0, 0, 0));
            Draw.Disc(Vector3.zero, fitRadius, Color.black);

            // edge noodles
            const int noodCount = 64;

            for (int i = 0; i < noodCount; i++)
            {
                float   tDir = i / ((float)noodCount);
                float   tAng = ShapesMath.TAU * tDir;
                Vector2 dir  = ShapesMath.AngToDir(tAng);
                if (Mathf.Abs(dir.y) > 0.75f)
                {
                    continue;
                }
                Vector2 root          = dir * fitRadius;
                float   distToNearest = float.MaxValue;
                for (int j = 0; j < doots.Length; j++)
                {
                    distToNearest = Mathf.Min(distToNearest, Vector2.Distance(doots[j].pos, root));
                }
                float distMod       = Mathf.InverseLerp(fitRadius * 0.5f, fitRadius * 0.1f, distToNearest);
                float noodMaxOffset = fitRadius * (1 + 0.1f * distMod);
                Draw.Line(root, dir * noodMaxOffset, fitRadius * Mathf.Lerp(0.07f, 0.04f, distMod));
            }

            // ring
            Draw.Ring(Vector3.zero, fitRadius, fitRadius * 0.0125f, colMain);

            // connecting lines
            for (int i = 0; i < doots.Length; i++)
            {
                Vector2 a = doots[i].pos;
                for (int j = i; j < doots.Length; j++)
                {
                    Vector2 b          = doots[j].pos;
                    float   dist       = Vector2.Distance(a, b);
                    float   rangeValue = Mathf.InverseLerp(fitRadius * 1f, fitRadius * 0.02f, dist);
                    if (rangeValue > 0)
                    {
                        Color col = Color.Lerp(colFade, colMain, rangeValue);
                        Draw.Line(a, b, fitRadius * 0.015f * rangeValue, LineEndCap.Round, col);
                    }
                }
            }

            // doots~
            foreach (Doot doot in doots)
            {
                Draw.BlendMode = ShapesBlendMode.Transparent;
                Draw.Disc(doot.pos, fitRadius * 0.025f, Color.black);
                Draw.Disc(doot.pos, fitRadius * 0.015f, colMain);
                Draw.BlendMode = ShapesBlendMode.Additive;
                Color innerColor = colMain;
                innerColor.a = 0.25f;
                Color outerColor = Color.clear;
                Draw.DiscGradientRadial(doot.pos, fitRadius * 0.18f, innerColor, outerColor);
            }

            Draw.BlendMode = ShapesBlendMode.Multiplicative;
            Draw.DiscGradientRadial(Vector3.zero, fitRadius * 0.5f, Color.black, Color.clear);


            // restore state
            Draw.Matrix             = prevMtx;
            Draw.BlendMode          = prevBlendMode;
            Draw.DiscRadiusSpace    = prevDiscRadiusSpace;
            Draw.LineThicknessSpace = prevLineThicknessSpace;
            Draw.LineGeometry       = prevLineGeometry;
            Draw.RingThicknessSpace = prevRingThicknessSpace;
        }
コード例 #23
0
 static bool HasSpecialBlendMode(this ShapesBlendMode blendMode) => blendMode != ShapesBlendMode.Opaque;
コード例 #24
0
 public static string BlendShaderDefine(this ShapesBlendMode blendMode) => blendMode.ToString().ToUpper();
コード例 #25
0
 public Material this[ShapesBlendMode type] => materials[(int)type];
コード例 #26
0
 static string RenderType(this ShapesBlendMode blendMode) => blendMode == ShapesBlendMode.Opaque ? "TransparentCutout" : "Transparent";
コード例 #27
0
 static bool AlphaToMask(this ShapesBlendMode blendMode) => blendMode == ShapesBlendMode.Opaque;
コード例 #28
0
 static bool ZWrite(this ShapesBlendMode blendMode) => blendMode == ShapesBlendMode.Opaque;