RohanRathi/DeviantMobile-Rohan
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chunk 2: remaining non-audio non-NewImport assets

Browse Source
This commit is contained in:
folkward99
2026-04-06 11:25:19 +03:00
parent 0d11a097d8
commit ed675b9f4a
3742 changed files with 1640416 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

276
Assets/GooglePlayPlugins/com.google.android.appbundle/Editor/Scripts/AssetPackConfig.cs Normal file
View File

@@ -0,0 +1,276 @@
// Copyright 2020 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
namespace Google.Android.AppBundle.Editor
{
/// <summary>
/// Configuration for all asset packs that will be packaged in an Android App Bundle (AAB).
/// </summary>
public class AssetPackConfig
{
/// <summary>
/// Indicates that the assets in an AAB's base module should be split into a separate install-time asset
/// pack. Usually when building a game, some assets are stored in the base module's "assets" directory.
/// Games that run into APK size limits may have previously used the "Split Application Binary"
/// option to create APK Expansion (*.obb) files, however this is unsupported with AABs.
/// If Play Console indicates that the base module exceeds a download size limit, for example 150 MB,
/// enabling this option may resolve the issue. See https://developer.android.com/guide/app-bundle.
/// </summary>
public bool SplitBaseModuleAssets;
/// <summary>
/// Dictionary from asset pack name to <see cref="AssetPack"/> object containing info such as delivery mode.
/// Note: asset pack names must start with a letter and can contain only letters, numbers, and underscores.
/// Note: convenience methods such as <see cref="AddAssetBundle"/> are recommended to more safely add new
/// Asset packs, but this dictionary is available for direct modification for advanced use cases.
/// </summary>
public readonly Dictionary<string, AssetPack> AssetPacks = new Dictionary<string, AssetPack>();
/// <summary>
/// A dictionary containing the subset of <see cref="AssetPacks"/> that are marked for delivery.
/// Note: the returned Dictionary doesn't indicate whether <see cref="SplitBaseModuleAssets"/> is enabled.
/// </summary>
public Dictionary<string, AssetPack> DeliveredAssetPacks
{
get
{
return AssetPacks
.Where(pair => pair.Value.DeliveryMode != AssetPackDeliveryMode.DoNotPackage)
.ToDictionary(pair => pair.Key, pair => pair.Value);
}
}
/// <summary>
/// When asset packs for multiple texture compression formats are present, this specifies the format used
/// when building standalone APKs for Android pre-Lollipop devices.
/// </summary>
public TextureCompressionFormat DefaultTextureCompressionFormat = TextureCompressionFormat.Default;
/// <summary>
/// When asset packs for multiple device tiers are present, this specifies the tier used
/// when building standalone APKs for Android pre-Lollipop devices.
/// </summary>
public DeviceTier DefaultDeviceTier = 0;
/// <summary>
/// Returns true if this configuration includes at least 1 asset pack that may be packaged in an AAB.
/// Return true if <see cref="SplitBaseModuleAssets"/> is enabled, even if there are no other asset packs.
/// </summary>
public bool HasDeliveredAssetPacks()
{
return SplitBaseModuleAssets || DeliveredAssetPacks.Any();
}
/// <summary>
/// Package the specified AssetBundle file in its own <see cref="AssetPack"/> with the specified delivery mode.
/// The name of the created asset pack will match that of the specified AssetBundle file.
/// </summary>
/// <param name="assetBundleFilePath">The path to a single AssetBundle file.</param>
/// <param name="deliveryMode">The <see cref="AssetPackDeliveryMode"/> for the asset pack.</param>
/// <exception cref="ArgumentException">If the asset pack name is invalid.</exception>
/// <exception cref="FileNotFoundException">If the AssetBundle file doesn't exist.</exception>
public void AddAssetBundle(string assetBundleFilePath, AssetPackDeliveryMode deliveryMode)
{
var assetPackName = GetAssetPackName(assetBundleFilePath);
AssetPacks[assetPackName] = new AssetPack
{
DeliveryMode = deliveryMode,
AssetBundleFilePath = assetBundleFilePath
};
}
/// <summary>
/// Package all raw assets in the specified folder in an <see cref="AssetPack"/> with the specified name and
/// using the specified delivery mode.
/// </summary>
/// <param name="assetPackName">The name of the asset pack.</param>
/// <param name="assetsFolderPath">
/// The path to a directory whose files will be directly copied into the asset pack during app bundle creation.
/// </param>
/// <param name="deliveryMode">The <see cref="AssetPackDeliveryMode"/> for the asset pack.</param>
/// <exception cref="ArgumentException">If the <see cref="assetPackName"/> is invalid.</exception>
/// <exception cref="FileNotFoundException">If the <see cref="assetsFolderPath"/> doesn't exist.</exception>
public void AddAssetsFolder(string assetPackName, string assetsFolderPath, AssetPackDeliveryMode deliveryMode)
{
var directoryInfo = new DirectoryInfo(assetsFolderPath);
if (!directoryInfo.Exists)
{
throw new FileNotFoundException("Asset pack directory doesn't exist", assetsFolderPath);
}
CheckAssetPackName(assetPackName);
AssetPacks[assetPackName] = new AssetPack
{
DeliveryMode = deliveryMode,
AssetPackDirectoryPath = assetsFolderPath
};
}
/// <summary>
/// Package the specified raw assets in the specified folders, keyed by <see cref="TextureCompressionFormat"/>,
/// in an <see cref="AssetPack"/> with the specified delivery mode.
/// When using Play Asset Delivery APIs, only the folder for the device's preferred texture compression format
/// will be delivered.
/// </summary>
/// <param name="assetPackName">The name of the asset pack.</param>
/// <param name="compressionFormatToAssetPackDirectoryPath">
/// A dictionary from <see cref="TextureCompressionFormat"/> to the path of directories of files that will be
/// directly copied into the asset pack during app bundle creation.</param>
/// <param name="deliveryMode">The <see cref="AssetPackDeliveryMode"/> for the asset pack.</param>
/// <exception cref="ArgumentException">If the dictionary or asset pack name is invalid.</exception>
public void AddAssetsFolders(
string assetPackName,
IDictionary<TextureCompressionFormat, string> compressionFormatToAssetPackDirectoryPath,
AssetPackDeliveryMode deliveryMode)
{
if (compressionFormatToAssetPackDirectoryPath.Count == 0)
{
throw new ArgumentException("Dictionary should contain at least one path");
}
if (compressionFormatToAssetPackDirectoryPath.All(kvp => kvp.Key != TextureCompressionFormat.Default))
{
throw new ArgumentException("Dictionary should contain at least one Default compression path");
}
CheckAssetPackName(assetPackName);
AssetPacks[assetPackName] = new AssetPack
{
DeliveryMode = deliveryMode,
CompressionFormatToAssetPackDirectoryPath =
new Dictionary<TextureCompressionFormat, string>(compressionFormatToAssetPackDirectoryPath)
};
}
/// <summary>
/// Package the specified AssetBundle files, which vary only by <see cref="TextureCompressionFormat"/>, in an
/// <see cref="AssetPack"/> with the specified delivery mode.
/// When using Play Asset Delivery APIs, only the AssetBundle for the device's preferred texture compression
/// format will be delivered.
/// </summary>
/// <param name="compressionFormatToAssetBundleFilePath">
/// A dictionary from <see cref="TextureCompressionFormat"/> to AssetBundle files.</param>
/// <param name="deliveryMode">The <see cref="AssetPackDeliveryMode"/> for the asset pack.</param>
/// <exception cref="ArgumentException">If the dictionary or asset pack name is invalid.</exception>
/// <exception cref="FileNotFoundException">If any AssetBundle file doesn't exist.</exception>
public void AddAssetBundles(
IDictionary<TextureCompressionFormat, string> compressionFormatToAssetBundleFilePath,
AssetPackDeliveryMode deliveryMode)
{
if (compressionFormatToAssetBundleFilePath.Count == 0)
{
throw new ArgumentException("Dictionary should contain at least one AssetBundle");
}
if (compressionFormatToAssetBundleFilePath.All(kvp => kvp.Key != TextureCompressionFormat.Default))
{
throw new ArgumentException("Dictionary should contain at least one Default compression AssetBundle");
}
var assetPackName = GetAssetPackName(compressionFormatToAssetBundleFilePath.Values.First());
if (compressionFormatToAssetBundleFilePath.Any(kvp => assetPackName != GetAssetPackName(kvp.Value)))
{
throw new ArgumentException("All AssetBundles in the Dictionary must have the same name");
}
AssetPacks[assetPackName] = new AssetPack
{
DeliveryMode = deliveryMode,
CompressionFormatToAssetBundleFilePath =
new Dictionary<TextureCompressionFormat, string>(compressionFormatToAssetBundleFilePath)
};
}
/// <summary>
/// Package the specified raw assets in the specified folders, keyed by <see cref="DeviceTier"/>,
/// in an <see cref="AssetPack"/> with the specified delivery mode.
/// When using Play Asset Delivery APIs, only the AssetBundle for the device's tier will be delivered.
/// </summary>
public void AddAssetsFolders(
string assetPackName,
IDictionary<DeviceTier, string> deviceTierToAssetPackDirectoryPath,
AssetPackDeliveryMode deliveryMode)
{
if (deviceTierToAssetPackDirectoryPath.Count == 0)
{
throw new ArgumentException("Dictionary should contain at least one path");
}
CheckAssetPackName(assetPackName);
AssetPacks[assetPackName] = new AssetPack
{
DeliveryMode = deliveryMode,
DeviceTierToAssetPackDirectoryPath =
new Dictionary<DeviceTier, string>(deviceTierToAssetPackDirectoryPath)
};
}
/// <summary>
/// Package the specified AssetBundle files, which vary only by <see cref="DeviceTier"/>, in an
/// <see cref="AssetPack"/> with the specified delivery mode.
/// When using Play Asset Delivery APIs, only the AssetBundle for the device's tier will be delivered.
/// </summary>
public void AddAssetBundles(
IDictionary<DeviceTier, string> deviceTierToAssetBundleFilePath,
AssetPackDeliveryMode deliveryMode)
{
if (deviceTierToAssetBundleFilePath.Count == 0)
{
throw new ArgumentException("Dictionary should contain at least one AssetBundle");
;
}
var assetPackName = GetAssetPackName(deviceTierToAssetBundleFilePath.Values.First());
if (deviceTierToAssetBundleFilePath.Any(kvp => assetPackName != GetAssetPackName(kvp.Value)))
{
throw new ArgumentException("All AssetBundles in the Dictionary must have the same name");
}
AssetPacks[assetPackName] = new AssetPack
{
DeliveryMode = deliveryMode,
DeviceTierToAssetBundleFilePath =
new Dictionary<DeviceTier, string>(deviceTierToAssetBundleFilePath)
};
}
private static string GetAssetPackName(string assetBundleFilePath)
{
var fileInfo = new FileInfo(assetBundleFilePath);
if (!fileInfo.Exists)
{
throw new FileNotFoundException("AssetBundle file doesn't exist", assetBundleFilePath);
}
var assetPackName = fileInfo.Name;
CheckAssetPackName(assetPackName);
return assetPackName;
}
private static void CheckAssetPackName(string assetPackName)
{
if (!AndroidAppBundle.IsValidModuleName(assetPackName))
{
throw new ArgumentException("Invalid asset pack name: " + assetPackName);
}
}
}
}