public override float?GetMaterialFloatPropertyValueOriginal(object data, Material material, string propertyName, GameObject go)
 {
     if (data is ObjectData objectData)
     {
         var chaControl = go.GetComponentInParent <ChaControl>();
         return(MaterialEditorPlugin.GetCharaController(chaControl).GetMaterialFloatPropertyValueOriginal(objectData.Slot, objectData.ObjectType, material, propertyName, go));
     }
     else
     {
         return(GetSceneController().GetMaterialFloatPropertyValueOriginal((int)data, material, propertyName));
     }
 }
 public override void RemoveMaterialFloatProperty(object data, Material material, string propertyName, GameObject go)
 {
     if (data is ObjectData objectData)
     {
         var chaControl = go.GetComponentInParent <ChaControl>();
         MaterialEditorPlugin.GetCharaController(chaControl).RemoveMaterialFloatProperty(objectData.Slot, objectData.ObjectType, material, propertyName, go);
     }
     else
     {
         GetSceneController().RemoveMaterialFloatProperty((int)data, material, propertyName);
     }
 }
 public override void RemoveMaterialShaderRenderQueue(object data, Material material, GameObject go)
 {
     if (data is ObjectData objectData)
     {
         var chaControl = go.GetComponentInParent <ChaControl>();
         MaterialEditorPlugin.GetCharaController(chaControl).RemoveMaterialShaderRenderQueue(objectData.Slot, objectData.ObjectType, material, go);
     }
     else
     {
         GetSceneController().RemoveMaterialShaderRenderQueue((int)data, material);
     }
 }
 public override void SetMaterialTextureScale(object data, Material material, string propertyName, Vector2 value, GameObject go)
 {
     if (data is ObjectData objectData)
     {
         var chaControl = go.GetComponentInParent <ChaControl>();
         MaterialEditorPlugin.GetCharaController(chaControl).SetMaterialTextureScale(objectData.Slot, objectData.ObjectType, material, propertyName, value, go);
     }
     else
     {
         GetSceneController().SetMaterialTextureScale((int)data, material, propertyName, value);
     }
 }
 public override void RemoveRendererProperty(object data, Renderer renderer, RendererProperties property, GameObject go)
 {
     if (data is ObjectData objectData)
     {
         var chaControl = go.GetComponentInParent <ChaControl>();
         MaterialEditorPlugin.GetCharaController(chaControl).RemoveRendererProperty(objectData.Slot, objectData.ObjectType, renderer, property, go);
     }
     else
     {
         GetSceneController().RemoveRendererProperty((int)data, renderer, property);
     }
 }
 public override int?GetMaterialShaderRenderQueueOriginal(object data, Material material, GameObject go)
 {
     if (data is ObjectData objectData)
     {
         var chaControl = go.GetComponentInParent <ChaControl>();
         return(MaterialEditorPlugin.GetCharaController(chaControl).GetMaterialShaderRenderQueueOriginal(objectData.Slot, objectData.ObjectType, material, go));
     }
     else
     {
         return(GetSceneController().GetMaterialShaderRenderQueueOriginal((int)data, material));
     }
 }
 public override string GetRendererPropertyValueOriginal(object data, Renderer renderer, RendererProperties property, GameObject go)
 {
     if (data is ObjectData objectData)
     {
         var chaControl = go.GetComponentInParent <ChaControl>();
         return(MaterialEditorPlugin.GetCharaController(chaControl).GetRendererPropertyValueOriginal(objectData.Slot, objectData.ObjectType, renderer, property, go));
     }
     else
     {
         return(GetSceneController().GetRendererPropertyValueOriginal((int)data, renderer, property));
     }
 }
        internal override void RemoveMaterialFloatProperty(int slot, Material material, string propertyName, GameObject gameObject)
        {
            var chaControl = gameObject.GetComponent <ChaControl>();

            if (chaControl != null)
            {
                MaterialEditorPlugin.GetCharaController(chaControl).RemoveMaterialFloatProperty(slot, material, propertyName, gameObject);
            }
            else
            {
                GetSceneController().RemoveMaterialFloatProperty(slot, material, propertyName);
            }
        }
        internal override void SetMaterialTextureScale(int slot, Material material, string propertyName, Vector2 value, GameObject gameObject)
        {
            var chaControl = gameObject.GetComponent <ChaControl>();

            if (chaControl != null)
            {
                MaterialEditorPlugin.GetCharaController(chaControl).SetMaterialTextureScale(slot, material, propertyName, value, gameObject);
            }
            else
            {
                GetSceneController().SetMaterialTextureScale(slot, material, propertyName, value);
            }
        }
        internal override void SetMaterialTexture(int slot, Material material, string propertyName, string filePath, GameObject gameObject)
        {
            var chaControl = gameObject.GetComponent <ChaControl>();

            if (chaControl != null)
            {
                MaterialEditorPlugin.GetCharaController(chaControl).SetMaterialTextureFromFile(slot, material, propertyName, filePath, gameObject, true);
            }
            else
            {
                GetSceneController().SetMaterialTextureFromFile(slot, material, propertyName, filePath, true);
            }
        }
        internal override void RemoveMaterialShaderRenderQueue(int slot, Material material, GameObject gameObject)
        {
            var chaControl = gameObject.GetComponent <ChaControl>();

            if (chaControl != null)
            {
                MaterialEditorPlugin.GetCharaController(chaControl).RemoveMaterialShaderRenderQueue(slot, material, gameObject);
            }
            else
            {
                GetSceneController().RemoveMaterialShaderRenderQueue(slot, material);
            }
        }
        internal override int?GetMaterialShaderRenderQueueOriginal(int slot, Material material, GameObject gameObject)
        {
            var chaControl = gameObject.GetComponent <ChaControl>();

            if (chaControl != null)
            {
                return(MaterialEditorPlugin.GetCharaController(chaControl).GetMaterialShaderRenderQueueOriginal(slot, material, gameObject));
            }
            else
            {
                return(GetSceneController().GetMaterialShaderRenderQueueOriginal(slot, material));
            }
        }
        internal override void SetMaterialShaderName(int slot, Material material, string value, GameObject gameObject)
        {
            var chaControl = gameObject.GetComponent <ChaControl>();

            if (chaControl != null)
            {
                MaterialEditorPlugin.GetCharaController(chaControl).SetMaterialShader(slot, material, value, gameObject);
            }
            else
            {
                GetSceneController().SetMaterialShader(slot, material, value);
            }
        }
        internal override void MaterialPasteEdits(int slot, Material material, GameObject gameObject)
        {
            var chaControl = gameObject.GetComponent <ChaControl>();

            if (chaControl != null)
            {
                MaterialEditorPlugin.GetCharaController(chaControl).MaterialPasteEdits(slot, material, gameObject);
            }
            else
            {
                GetSceneController().MaterialPasteEdits(slot, material);
            }
        }
        internal override void RemoveRendererProperty(int slot, Renderer renderer, RendererProperties property, GameObject gameObject)
        {
            var chaControl = gameObject.GetComponent <ChaControl>();

            if (chaControl != null)
            {
                MaterialEditorPlugin.GetCharaController(chaControl).RemoveRendererProperty(slot, renderer, property, gameObject);
            }
            else
            {
                GetSceneController().RemoveRendererProperty(slot, renderer, property);
            }
        }
        internal override float?GetMaterialFloatPropertyValueOriginal(int slot, Material material, string propertyName, GameObject gameObject)
        {
            var chaControl = gameObject.GetComponent <ChaControl>();

            if (chaControl != null)
            {
                return(MaterialEditorPlugin.GetCharaController(chaControl).GetMaterialFloatPropertyValueOriginal(slot, material, propertyName, gameObject));
            }
            else
            {
                return(GetSceneController().GetMaterialFloatPropertyValueOriginal(slot, material, propertyName));
            }
        }
        internal override string GetRendererPropertyValueOriginal(int slot, Renderer renderer, RendererProperties property, GameObject gameObject)
        {
            var chaControl = gameObject.GetComponent <ChaControl>();

            if (chaControl != null)
            {
                return(MaterialEditorPlugin.GetCharaController(chaControl).GetRendererPropertyValueOriginal(slot, renderer, property, gameObject));
            }
            else
            {
                return(GetSceneController().GetRendererPropertyValueOriginal(slot, renderer, property));
            }
        }
Exemple #18
0
        internal static void CopyClothesPostfix(TMP_Dropdown[] ___ddCoordeType, Toggle[] ___tglKind)
        {
            List <int> copySlots = new List <int>();

            for (int i = 0; i < Enum.GetNames(typeof(ChaFileDefine.ClothesKind)).Length; i++)
            {
                if (___tglKind[i].isOn)
                {
                    copySlots.Add(i);
                }
            }

            MaterialEditorPlugin.GetCharaController(MakerAPI.GetCharacterControl())?.ClothingCopiedEvent(___ddCoordeType[1].value, ___ddCoordeType[0].value, copySlots);
        }
 internal override void AddMaterialColorProperty(ObjectType objectType, int coordinateIndex, int slot, string materialName, string propertyName, Color value, Color valueOriginal, GameObject gameObject) =>
 MaterialEditorPlugin.GetCharaController(MakerAPI.GetCharacterControl()).AddMaterialColorProperty(objectType, coordinateIndex, slot, materialName, propertyName, value, valueOriginal, gameObject);
        private static void ChangeClothesTopAsyncPostfix(ChaControl __instance, ref IEnumerator __result)
        {
            var controller = MaterialEditorPlugin.GetCharaController(__instance);

            if (controller != null)
            {
                var original = __result;
                __result = new[] { original, Postfix() }.GetEnumerator();
            }

            IEnumerator Postfix()
            {
                var bodyAlphaMask = Traverse.Create(__instance).Property("texBodyAlphaMask").GetValue() as Texture;

                if (__instance.rendBody.sharedMaterials.Length > 1 && bodyAlphaMask != null)
                {
                    for (int i = 0; i < __instance.rendBody.sharedMaterials.Length; i++)
                    {
                        var mat = __instance.rendBody.sharedMaterials[i];
                        mat.SetTexture(ChaShader._AlphaMask, bodyAlphaMask);
                    }
                }

                var braAlphaMask = Traverse.Create(__instance).Property("texBraAlphaMask").GetValue() as Texture;

                if (__instance.rendBra != null && braAlphaMask != null)
                {
                    for (int j = 0; j < 2; j++)
                    {
                        if (__instance.rendBra[j] != null && __instance.rendBra[j].materials.Length > 1)
                        {
                            for (int i = 0; i < __instance.rendBra[j].materials.Length; i++)
                            {
                                var mat = __instance.rendBra[j].materials[i];
                                if (mat != null)
                                {
                                    mat.SetTexture(ChaShader._AlphaMask, braAlphaMask);
                                }
                            }
                        }
                    }
                }

                if (__instance.rendInner != null && __instance.texInnerAlphaMask != null)
                {
                    for (int j = 0; j < 2; j++)
                    {
                        if (__instance.rendInner[j] != null && __instance.rendInner[j].materials.Length > 1)
                        {
                            for (int i = 0; i < __instance.rendInner[j].materials.Length; i++)
                            {
                                var mat = __instance.rendInner[j].materials[i];
                                if (mat != null)
                                {
                                    mat.SetTexture(ChaShader._AlphaMask, __instance.texInnerAlphaMask);
                                }
                            }
                        }
                    }
                }
                yield break;
            }
        }
Exemple #21
0
 internal static void ChangeCoordinateTypePrefix(ChaControl __instance) => MaterialEditorPlugin.GetCharaController(__instance)?.CoordinateChangeEvent();
 internal static void AccessoryTransferHook() => MaterialEditorPlugin.GetCharaController(MakerAPI.GetCharacterControl()).CustomClothesOverride = true;
 private static void CopyAcsHook() => MaterialEditorPlugin.GetCharaController(MakerAPI.GetCharacterControl()).CustomClothesOverride = true;
 private static void Head_RendSkinTexture(ChaControl ___human) => MaterialEditorPlugin.GetCharaController(___human).RefreshBodyEdits();
 private static void HairCustomEdit_ChangeHair_Side(ChaControl ___human) => MaterialEditorPlugin.GetCharaController(___human).ChangeHairEvent((int)Character.HAIR_TYPE.SIDE);
 private static void WearCustomEdit_ChangeOnWear(Character.WEAR_TYPE wear, ChaControl ___human) => MaterialEditorPlugin.GetCharaController(___human).ChangeCustomClothesEvent((int)wear);
Exemple #27
0
 internal static void UncensorSelectorHookStudio(ChaControl chaControl)
 {
     chaControl.StartCoroutine(MaterialEditorPlugin.GetCharaController(chaControl).LoadData(false, false, false));
 }
        /// <summary>
        /// Exports the UV map(s) of the SkinnedMeshRenderer or MeshRenderer
        /// </summary>
        public static void ExportUVMaps(Renderer rend)
        {
            bool   openedFile   = false;
            Shader shader       = Shader.Find("Hidden/Internal-Colored");
            var    lineMaterial = new Material(shader);

            lineMaterial.hideFlags = HideFlags.HideAndDontSave;
            lineMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
            lineMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
            lineMaterial.SetInt("_Cull", (int)UnityEngine.Rendering.CullMode.Off);
            lineMaterial.SetInt("_ZWrite", 0);

            Mesh mr;

            if (rend is MeshRenderer meshRenderer)
            {
                mr = meshRenderer.GetComponent <MeshFilter>().mesh;
            }
            else if (rend is SkinnedMeshRenderer skinnedMeshRenderer)
            {
                mr = skinnedMeshRenderer.sharedMesh;
            }
            else
            {
                return;
            }

            for (int x = 0; x < mr.subMeshCount; x++)
            {
                var tris = mr.GetTriangles(x);
                var uvs  = mr.uv;

                const int size           = 4096;
                var       _renderTexture = RenderTexture.GetTemporary(size, size);
                var       lineColor      = Color.black;
                Graphics.SetRenderTarget(_renderTexture);
                GL.PushMatrix();
                GL.LoadOrtho();
                //GL.LoadPixelMatrix(); // * 2 - 1, maps differently.
                GL.Clear(false, true, Color.clear);

                lineMaterial.SetPass(0);
                GL.Begin(GL.LINES);
                GL.Color(lineColor);

                for (var i = 0; i < tris.Length; i += 3)
                {
                    var v  = uvs[tris[i]];
                    var n1 = uvs[tris[i + 1]];
                    var n2 = uvs[tris[i + 2]];

                    GL.Vertex(v);
                    GL.Vertex(n1);

                    GL.Vertex(v);
                    GL.Vertex(n2);

                    GL.Vertex(n1);
                    GL.Vertex(n2);
                }
                GL.End();

                GL.PopMatrix();
                Graphics.SetRenderTarget(null);

                var png = MaterialEditorPlugin.GetT2D(_renderTexture);
                RenderTexture.ReleaseTemporary(_renderTexture);

                string filename = Path.Combine(MaterialEditorPlugin.ExportPath, $"{rend.NameFormatted()}_{x}.png");
                File.WriteAllBytes(filename, png.EncodeToPNG());
                Object.DestroyImmediate(png);
                MaterialEditorPlugin.Logger.LogInfo($"Exported {filename}");
                if (!openedFile)
                {
                    CC.OpenFileInExplorer(filename);
                }
                openedFile = true;
            }
        }
 internal override string GetMaterialFloatPropertyValueOriginal(ObjectType objectType, int coordinateIndex, int slot, string materialName, string propertyName) =>
 MaterialEditorPlugin.GetCharaController(MakerAPI.GetCharacterControl()).GetMaterialFloatPropertyValueOriginal(objectType, coordinateIndex, slot, materialName, propertyName);
 internal override void RemoveMaterialFloatProperty(ObjectType objectType, int coordinateIndex, int slot, string materialName, string propertyName, GameObject gameObject) =>
 MaterialEditorPlugin.GetCharaController(MakerAPI.GetCharacterControl()).RemoveMaterialFloatProperty(objectType, coordinateIndex, slot, materialName, propertyName, gameObject);