コード例 #1
0
        private static Material[] BuildMaterialsBlendModes(string shaderName)
        {
            var shader    = P3dShader.Load(shaderName);
            var materials = new Material[P3dShader.BLEND_MODE_COUNT];

            for (var blend = 0; blend < P3dShader.BLEND_MODE_COUNT; blend++)
            {
                materials[blend] = P3dShader.Build(shader, 0, (P3dBlendMode)blend);
            }

            return(materials);
        }
コード例 #2
0
ファイル: P3dBlit.cs プロジェクト: rynduse/Runner
        public static void Normal(RenderTexture rendertexture, Texture texture)
        {
            if (cachedNormalSet == false)
            {
                cachedNormal    = P3dShader.BuildMaterial("Hidden/Paint in 3D/Normal");
                cachedNormalSet = true;
            }

            cachedNormal.SetTexture(P3dShader._Texture, texture);

            P3dHelper.Blit(rendertexture, cachedNormal);
        }
コード例 #3
0
ファイル: P3dBlit.cs プロジェクト: rynduse/Runner
        public static void Premultiply(RenderTexture rendertexture, Texture texture, Color tint)
        {
            if (cachedPremultiplySet == false)
            {
                cachedPremultiply    = P3dShader.BuildMaterial("Hidden/Paint in 3D/Premultiply");
                cachedPremultiplySet = true;
            }

            cachedPremultiply.SetTexture(P3dShader._Texture, texture);
            cachedPremultiply.SetColor(P3dShader._Color, tint);

            P3dHelper.Blit(rendertexture, cachedPremultiply);
        }
コード例 #4
0
        public static Material[] BuildMaterialsBlendModes(string shaderName)
        {
            var shader    = P3dShader.Load(shaderName);
            var materials = new Material[P3dBlendMode.COUNT];

            for (var index = 0; index < P3dBlendMode.COUNT; index++)
            {
                var material = P3dShader.Build(shader);

                P3dShader.BuildBlendMode(material, index);

                materials[index] = material;
            }

            return(materials);
        }
コード例 #5
0
ファイル: P3dBlit.cs プロジェクト: rynduse/Runner
        public static void Texture(RenderTexture rendertexture, Mesh mesh, int submesh, Texture texture, P3dCoord coord)
        {
            if (cachedTextureSet == false)
            {
                cachedTexture    = P3dShader.BuildMaterial("Hidden/Paint in 3D/Texture");
                cachedTextureSet = true;
            }

            P3dHelper.BeginActive(rendertexture);

            cachedTexture.SetTexture(P3dShader._Buffer, texture);
            cachedTexture.SetVector(P3dShader._BufferSize, new Vector2(texture.width, texture.height));

            P3dHelper.Draw(cachedTexture, mesh, Matrix4x4.identity, submesh, coord);

            P3dHelper.EndActive();
        }
コード例 #6
0
ファイル: P3dBlit.cs プロジェクト: rynduse/Runner
        public static void White(RenderTexture rendertexture, Mesh mesh, int submesh, P3dCoord coord)
        {
            P3dHelper.BeginActive(rendertexture);

            if (mesh != null)
            {
                if (cachedWhiteSet == false)
                {
                    cachedWhite    = P3dShader.BuildMaterial("Hidden/Paint in 3D/White");
                    cachedWhiteSet = true;
                }

                GL.Clear(true, true, Color.black);

                P3dHelper.Draw(cachedWhite, mesh, Matrix4x4.identity, submesh, coord);
            }
            else
            {
                GL.Clear(true, true, Color.white);
            }

            P3dHelper.EndActive();
        }
コード例 #7
0
        public static Material[] BuildMaterialsBlendModes(string shaderName, string keyword = null)
        {
            var shader    = P3dShader.Load(shaderName);
            var materials = new Material[P3dBlendMode.COUNT];

            for (var index = 0; index < P3dBlendMode.COUNT; index++)
            {
                var material = P3dShader.Build(shader);

                P3dShader.BuildBlendMode(material, index);

                materials[index] = material;
            }

            if (string.IsNullOrEmpty(keyword) == false)
            {
                for (var index = 0; index < P3dBlendMode.COUNT; index++)
                {
                    materials[index].EnableKeyword(keyword);
                }
            }

            return(materials);
        }
コード例 #8
0
ファイル: P3dCommandDecal.cs プロジェクト: MikeMnD/Bath-Bomb
 static P3dCommandDecal()
 {
     cachedSpotMaterials = P3dShader.BuildMaterialsBlendModes("Hidden/Paint in 3D/Decal");
     cachedLineMaterials = P3dShader.BuildMaterialsBlendModes("Hidden/Paint in 3D/Decal", "P3D_LINE");
     cachedQuadMaterials = P3dShader.BuildMaterialsBlendModes("Hidden/Paint in 3D/Decal", "P3D_QUAD");
 }
コード例 #9
0
        private void BakeOverlap()
        {
            var desc          = new RenderTextureDescriptor(1024, 1024, RenderTextureFormat.ARGB32, 0);
            var renderTexture = P3dHelper.GetRenderTexture(desc);

            if (overlapMaterial == null)
            {
                overlapMaterial = P3dShader.BuildMaterial("Hidden/Paint in 3D/Overlap");
            }

            overlapMaterial.SetVector(P3dShader._Coord, P3dHelper.IndexToVector(coord));

            var oldActive = RenderTexture.active;

            RenderTexture.active = renderTexture;

            GL.Clear(true, true, Color.black);

            overlapMaterial.SetPass(0);

            Graphics.DrawMeshNow(mesh, Matrix4x4.identity, submesh);

            foreach (var obj in Selection.objects)
            {
                var otherMesh = obj as Mesh;

                if (otherMesh != null && otherMesh != mesh)
                {
                    Graphics.DrawMeshNow(otherMesh, Matrix4x4.identity, submesh);
                }
            }

            RenderTexture.active = oldActive;

            overlapTex = P3dHelper.GetReadableCopy(renderTexture);

            P3dHelper.ReleaseRenderTexture(renderTexture);

            var utilizationCount = 0;
            var overlapCount     = 0;

            for (var y = 0; y < overlapTex.height; y++)
            {
                for (var x = 0; x < overlapTex.width; x++)
                {
                    var pixel = overlapTex.GetPixel(x, y);

                    if (pixel.r > 0.0f)
                    {
                        if (pixel.r > 1.5 / 255.0f)
                        {
                            pixel = Color.red;

                            overlapCount += 1;
                        }
                        else
                        {
                            pixel = Color.gray;
                        }

                        utilizationCount += 1;

                        overlapTex.SetPixel(x, y, pixel);
                    }
                }
            }

            var total = overlapTex.width * overlapTex.height * 0.01f;

            utilizationPercent = utilizationCount / total;
            overlapPercent     = overlapCount / total;

            overlapTex.Apply();
        }
コード例 #10
0
        private static Material BuildMaterial(string shaderName)
        {
            var shader = P3dShader.Load(shaderName);

            return(P3dShader.Build(shader));
        }
コード例 #11
0
 static P3dCommandSphere()
 {
     cachedSpotMaterial = P3dShader.BuildMaterial("Hidden/Paint in 3D/Sphere");
     cachedLineMaterial = P3dShader.BuildMaterial("Hidden/Paint in 3D/Sphere", "P3D_LINE");
     cachedQuadMaterial = P3dShader.BuildMaterial("Hidden/Paint in 3D/Sphere", "P3D_QUAD");
 }
コード例 #12
0
 static P3dCommandReplace()
 {
     cachedMaterial = P3dShader.BuildMaterial("Hidden/Paint in 3D/Replace");
 }
コード例 #13
0
 static P3dCommandFill()
 {
     cachedMaterials = P3dShader.BuildMaterialsBlendModes("Hidden/Paint in 3D/Fill");
 }
コード例 #14
0
 public static void BuildMaterial(ref Material material, ref int materialHash, string path, string keyword = null)
 {
     material     = P3dShader.BuildMaterial(path, keyword);
     materialHash = P3dSerialization.TryRegister(material);
 }
コード例 #15
0
 static P3dCommandFill()
 {
     cachedMaterial = P3dShader.BuildMaterial("Hidden/Paint in 3D/Fill");
 }
コード例 #16
0
        private void Bake(RenderTexture temporary, int width, int height, RenderTextureFormat format, int scale)
        {
            if (bakedPixels == null)
            {
                bakedPixels = new List <bool>();
            }
            else
            {
                bakedPixels.Clear();
            }

            baked     = true;
            bakedMesh = mesh;
            bakedSize = new Vector2Int(width, height);

            if (cachedMaterial == null)
            {
                cachedMaterial = P3dShader.BuildMaterial("Hidden/Paint in 3D/White");
            }

            cachedMaterial.SetVector(P3dShader._Channel, P3dHelper.IndexToVector((int)PaintableTexture.Coord));

            // Write to temp RenderTexture
            var oldActive     = RenderTexture.active;
            var renderTexture = temporary;

            if (temporary == null)
            {
                var desc = new RenderTextureDescriptor(width, height, format, 0);

                renderTexture = P3dHelper.GetRenderTexture(desc);
            }

            RenderTexture.active = renderTexture;

            GL.Clear(true, true, Color.black);

            cachedMaterial.SetPass(0);

            Graphics.DrawMeshNow(mesh, Matrix4x4.identity, PaintableTexture.Slot.Index);

            RenderTexture.active = oldActive;

            // Get readable copy
            var readable = P3dHelper.GetReadableCopy(renderTexture);

            if (temporary == null)
            {
                P3dHelper.ReleaseRenderTexture(renderTexture);
            }

            // Run through pixels to count total and build binary mask
            bakedPixels.Capacity = width * height;

            total = 0;

            for (var y = 0; y < height; y++)
            {
                for (var x = 0; x < width; x++)
                {
                    if (readable.GetPixel(x, y).r > 0.5f)
                    {
                        bakedPixels.Add(true);

                        total += scale;
                    }
                    else
                    {
                        bakedPixels.Add(false);
                    }
                }
            }

            // Clean up
            P3dHelper.Destroy(readable);
        }