//----------------------------------------------------------------------------
private static void ApplyPKImportSetting(PKFxFxAsset.DependencyDesc dependency, string path)
{
string fExt = Path.GetExtension(path);
if (PKFxManager.IsSupportedTextureExtension(fExt))
{
TextureImporter importer = AssetImporter.GetAtPath(path) as TextureImporter;
bool reimport = false;
if (importer == null)
{
return;
}
if (importer.sRGBTexture != !dependency.m_IsTextureLinear)
{
importer.sRGBTexture = !dependency.m_IsTextureLinear;
reimport = true;
}
if (dependency.m_IsTextureSampler)
{
importer.isReadable = true;
reimport = true;
}
if (reimport)
{
importer.SaveAndReimport();
}
}
}
public override void SetupMeshRenderer(PKFxManagerImpl.SBatchDesc batchDesc, GameObject gameObject, PKFxMeshInstancesRenderer meshRenderer)
{
if (batchDesc.HasMaterialFlag(PKFxManagerImpl.EMaterialFlags.Has_Distortion))
{
gameObject.layer = PKFxManagerImpl.m_DistortionLayer;
}
PKFxFxAsset.DependencyDesc DepDesc = PKFxManager.GetBuiltAsset().m_Dependencies.Find(x => batchDesc.m_MeshAsset.Contains(x.m_Path));
if (DepDesc != null)
{
GameObject meshGO = DepDesc.m_Object as GameObject;
List <Mesh> meshes = new List <Mesh>();
List <Matrix4x4> trans = new List <Matrix4x4>();
MeshFilter meshFilter = meshGO.GetComponent <MeshFilter>();
if (meshFilter != null)
{
meshes.Add(meshFilter.sharedMesh);
trans.Add(meshGO.transform.localToWorldMatrix);
}
if (meshes.Count == 0)
{
MeshFilter[] meshFilters = meshGO.GetComponentsInChildren <MeshFilter>();
if (batchDesc.m_SubMeshID == -1)
{
for (int i = 0; i < meshFilters.Length; ++i)
{
meshes.Add(meshFilters[i].sharedMesh);
trans.Add(meshGO.transform.localToWorldMatrix * meshFilters[i].transform.localToWorldMatrix);
}
}
else if (meshFilters.Length > batchDesc.m_SubMeshID)
{
meshes.Add(meshFilters[batchDesc.m_SubMeshID].sharedMesh);
trans.Add(meshGO.transform.localToWorldMatrix * meshFilters[batchDesc.m_SubMeshID].transform.localToWorldMatrix);
}
}
meshRenderer.m_MeshesImportTransform = trans.ToArray();
meshRenderer.m_Meshes = meshes.ToArray();
}
meshRenderer.m_CastShadow = batchDesc.HasMaterialFlag(PKFxManagerImpl.EMaterialFlags.Has_CastShadow);
}
private static void OnEffectDependencyFound(IntPtr dependencyPath, int useInfoFlags)
{
if (dependencyPath == IntPtr.Zero)
{
return;
}
PKFxFxAsset.DependencyDesc depDesc = new PKFxFxAsset.DependencyDesc();
depDesc.m_Path = PKFxSettings.UnityPackFxPath + "/" + Marshal.PtrToStringAnsi(dependencyPath);
depDesc.m_IsTextureLinear = (useInfoFlags & (int)EUseInfoFlag.IsLinearTexture) != 0;
depDesc.m_IsMeshRenderer = (useInfoFlags & (int)EUseInfoFlag.IsMeshRenderer) != 0;
depDesc.m_IsMeshSampler = (useInfoFlags & (int)EUseInfoFlag.IsMeshSampler) != 0;
depDesc.m_IsTextureSampler = (useInfoFlags & (int)EUseInfoFlag.IsTextureSampler) != 0;
if (depDesc.m_IsMeshRenderer && Path.GetExtension(depDesc.m_Path).CompareTo(".pkmm") == 0)
{
depDesc.m_Path = Path.ChangeExtension(depDesc.m_Path, ".fbx");
}
else
{
depDesc.m_IsMeshRenderer = false;
}
// if possible, add an argument to this callback to tell if the dependency will be used for distortion,
// call PKFxImporter.SRGBEnabledOnTexture to check if the sRGB is enable and log a warning (see in PKFxImporter.InitDependencies)
int idx = m_CurrentlyImportedAsset.m_Dependencies.FindIndex(x => x.m_Path == depDesc.m_Path);
if (idx < 0)
{
m_CurrentlyImportedAsset.m_Dependencies.Add(depDesc);
}
else
{
PKFxFxAsset.DependencyDesc current = m_CurrentlyImportedAsset.m_Dependencies[idx];
current.m_IsTextureLinear = current.m_IsTextureLinear ? true : depDesc.m_IsTextureLinear;
current.m_IsMeshRenderer = current.m_IsMeshRenderer ? true : depDesc.m_IsMeshRenderer;
current.m_IsMeshSampler = current.m_IsMeshSampler ? true : depDesc.m_IsMeshSampler;
current.m_IsTextureSampler = current.m_IsTextureSampler ? true : depDesc.m_IsTextureSampler;
}
}
public static Texture GetTextureLinear(PKFxManagerImpl.SBatchDesc batchDesc)
{
Texture distoTexture = null;
if (batchDesc.m_NormalMap != null)
{
bool isLinear = batchDesc.HasMaterialFlag(PKFxManagerImpl.EMaterialFlags.Has_Distortion);
PKFxFxAsset.DependencyDesc DepDesc = null;
if (!isLinear)
{
return(null);
}
string path = Path.GetDirectoryName(batchDesc.m_NormalMap) + "/" + Path.GetFileNameWithoutExtension(batchDesc.m_NormalMap) + "_linear" + Path.GetExtension(batchDesc.m_NormalMap);
DepDesc = PKFxManager.GetBuiltAsset().m_Dependencies.Find(x => path.Contains(x.m_Path));
if (DepDesc == null)
{
DepDesc = PKFxManager.GetBuiltAsset().m_Dependencies.Find(x => batchDesc.m_NormalMap.Contains(x.m_Path));
}
if (DepDesc != null)
{
distoTexture = DepDesc.m_Object as Texture;
}
if (distoTexture != null)
{
if (batchDesc.m_Type != PKFxManagerImpl.ERendererType.Ribbon)
{
distoTexture.wrapMode = TextureWrapMode.Clamp;
}
}
else
{
Debug.LogError("[PKFX] Error while trying to create linear texture. Try to reimport \"" + batchDesc.m_NormalMap + "\" and check if its format is compatible with Unity.");
}
}
return(distoTexture);
}
internal static void AddSound(PKFxFxAsset.DependencyDesc depDesc)
{
m_Sounds[depDesc.m_Path] = depDesc.m_Object as AudioClip;
}
public override Material ResolveParticleMaterial(PKFxManagerImpl.SBatchDesc batchDesc)
{
Material customMat = TryFindAndInstantiateCustomMaterial(batchDesc);
if (customMat != null)
{
return(customMat);
}
Shader shader = ResolveShader(batchDesc);
Debug.Assert(shader != null);
Material material = new Material(shader);
// Set the diffuse texture:
Texture diffuseTexture = GetTextureDiffuse(batchDesc);
material.mainTexture = diffuseTexture;
// Set the material uniforms:
material.SetInt("_UniformFlags", batchDesc.m_UniformFlags);
// We can stop here if the material is for a mesh particle:
if (batchDesc.m_Type == PKFxManagerImpl.ERendererType.Mesh)
{
return(material);
}
// Set the alpha remap texture
if (batchDesc.m_AlphaRemap != null)
{
string path = Path.GetDirectoryName(batchDesc.m_AlphaRemap) + "/" + Path.GetFileNameWithoutExtension(batchDesc.m_AlphaRemap) + "_linear" + Path.GetExtension(batchDesc.m_AlphaRemap);
PKFxFxAsset.DependencyDesc DepDesc = PKFxManager.GetBuiltAsset().m_Dependencies.Find(x => path.Contains(x.m_Path));
if (DepDesc != null)
{
Texture alphaRemapTexture = DepDesc.m_Object as Texture;
alphaRemapTexture.wrapMode = TextureWrapMode.Clamp;
Debug.Assert(alphaRemapTexture != null);
material.SetTexture("_AlphaMap", alphaRemapTexture);
}
}
// Set the blend mode:
int srcMode = 0;
int dstMode = 0;
// Additive and distortion
if (batchDesc.HasUniformFlag(PKFxManagerImpl.EUniformFlags.Is_Additive) ||
batchDesc.HasUniformFlag(PKFxManagerImpl.EUniformFlags.Is_AdditiveNoAlpha) ||
batchDesc.HasMaterialFlag(PKFxManagerImpl.EMaterialFlags.Has_Distortion))
{
srcMode = (int)UnityEngine.Rendering.BlendMode.One;
dstMode = (int)UnityEngine.Rendering.BlendMode.One;
}
else if (batchDesc.HasUniformFlag(PKFxManagerImpl.EUniformFlags.Is_AdditiveAlphaBlend))
{
srcMode = (int)UnityEngine.Rendering.BlendMode.One;
dstMode = (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha;
}
else // Alpha blended
{
srcMode = (int)UnityEngine.Rendering.BlendMode.SrcAlpha;
dstMode = (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha;
}
material.SetInt("_SrcBlendMode", srcMode);
material.SetInt("_DstBlendMode", dstMode);
if (IsUI(batchDesc.m_UserData))
{
material.SetInt("_ZTestMode", (int)UnityEngine.Rendering.CompareFunction.Always);
}
else
{
material.SetInt("_ZTestMode", (int)UnityEngine.Rendering.CompareFunction.LessEqual);
}
// Set the shader variation:
if (batchDesc.HasMaterialFlag(PKFxManagerImpl.EMaterialFlags.Has_AlphaRemap))
{
material.EnableKeyword("PK_HAS_ALPHA_REMAP");
}
if (batchDesc.HasMaterialFlag(PKFxManagerImpl.EMaterialFlags.Has_AnimBlend))
{
material.EnableKeyword("PK_HAS_ANIM_BLEND");
}
if (batchDesc.HasMaterialFlag(PKFxManagerImpl.EMaterialFlags.Has_Distortion))
{
material.EnableKeyword("PK_HAS_DISTORTION");
}
if (batchDesc.HasMaterialFlag(PKFxManagerImpl.EMaterialFlags.Has_Lighting))
{
material.EnableKeyword("PK_HAS_LIGHTING");
}
if (batchDesc.HasMaterialFlag(PKFxManagerImpl.EMaterialFlags.Has_RibbonComplex))
{
material.EnableKeyword("PK_HAS_RIBBON_COMPLEX");
}
if (batchDesc.HasMaterialFlag(PKFxManagerImpl.EMaterialFlags.Has_Color))
{
material.EnableKeyword("PK_HAS_COLOR");
}
if (batchDesc.HasMaterialFlag(PKFxManagerImpl.EMaterialFlags.Has_Soft) && PKFxSettings.EnableSoftParticles)
{
material.EnableKeyword("PK_HAS_SOFT");
material.SetFloat("_InvSoftnessDistance", batchDesc.m_InvSofnessDistance);
}
// Set the render queue:
material.renderQueue = m_RenderQueue + batchDesc.m_DrawOrder;
return(material);
}
