public static void Build()
{
ReadCommandLine();
if (Directory.Exists(folderPath))
{
Directory.Delete(folderPath, true);
}
if (Directory.Exists(k_TmpPath))
{
Directory.Delete(k_TmpPath, true);
}
Directory.CreateDirectory(folderPath);
Directory.CreateDirectory(k_TmpPath);
IBundleBuildParameters buildParams = new BundleBuildParameters(EditorUserBuildSettings.activeBuildTarget, BuildTargetGroup.Unknown, folderPath);
buildParams.TempOutputFolder = k_TmpPath;
IBundleBuildContent buildContent = new BundleBuildContent(ContentBuildInterface.GenerateAssetBundleBuilds());
IBundleBuildResults results;
List <IBuildTask> taskList = DefaultBuildTasks.Create(DefaultBuildTasks.Preset.AssetBundleBuiltInShaderExtraction) as List <IBuildTask>;
taskList.Add(new RefreshAssetDatabase());
// we add a callback after generating information about how to build each bundle
ContentPipeline.BuildCallbacks.PostPackingCallback += PostPackingCallback;
ReturnCode exitCode = ContentPipeline.BuildAssetBundles(buildParams, buildContent, out results, taskList);
Debug.Log("Building completed with " + exitCode);
}
public void BuildPipeline_AssetBundleBuild_WritesLinkXMLFile()
{
IBundleBuildParameters buildParameters = GetBuildParameters();
buildParameters.WriteLinkXML = true;
IBundleBuildContent buildContent = GetBundleContent();
IBundleBuildResults results;
ReturnCode exitCode = ContentPipeline.BuildAssetBundles(buildParameters, buildContent, out results);
Assert.AreEqual(ReturnCode.Success, exitCode);
var assemblies = new HashSet <Assembly>();
var types = new HashSet <Type>();
foreach (var writeResult in results.WriteResults)
{
foreach (var type in writeResult.Value.includedTypes)
{
assemblies.Add(type.Assembly);
types.Add(type);
}
}
var xml = LinkXMLGeneratorTests.ReadLinkXML(buildParameters.GetOutputFilePathForIdentifier("link.xml"), out int assemblyCount, out int typeCount);
Assert.AreEqual(assemblyCount, assemblies.Count);
Assert.AreEqual(typeCount, types.Count);
foreach (var t in types)
{
LinkXMLGeneratorTests.AssertTypePreserved(xml, t);
}
}
public GameObject RunPipeline()
{
if (!RoadNetworkSourceExists())
{
return(null);
}
var pipeline = new ContentPipeline();
GameObject generatedObjects;
try
{
generatedObjects = roadNetworkSource == RoadNetworkSource.OpenDrive
? RunOpenDrivePipeline(pipeline)
: RunSplineBasedRoadNetworkPipeline(pipeline);
}
catch
{
pipeline.Dispose();
throw;
}
pipeline.Dispose();
return(generatedObjects);
}
/// <summary>
/// SBP构建
/// </summary>
/// <returns>The build pipeline.</returns>
ReturnCode ScriptableBuildPipeline()
{
var buildContent = GetBundleContent(); //new BundleBuildContent(ContentBuildInterface.GenerateAssetBundleBuilds());
var buildParams = new BundleBuildParameters(settings.buildTarget, settings.buildGroup, settings.outputPath);
if (settings.compressionType == CompressionType.None)
{
buildParams.BundleCompression = BuildCompression.DefaultUncompressed;
}
else if (settings.compressionType == CompressionType.Lzma)
{
buildParams.BundleCompression = BuildCompression.DefaultLZMA;
}
else if (settings.compressionType == CompressionType.Lz4 || settings.compressionType == CompressionType.Lz4HC)
{
buildParams.BundleCompression = BuildCompression.DefaultLZ4;
}
IBundleBuildResults results;
ReturnCode exitCode;
exitCode = ContentPipeline.BuildAssetBundles(buildParams, buildContent, out results);
return(exitCode);
}
internal ReturnCode RefreshBuild(AddressableAssetsBuildContext buildContext)
{
var settings = buildContext.settings;
var context = new AddressablesDataBuilderInput(settings);
var buildTarget = context.Target;
var buildTargetGroup = context.TargetGroup;
var buildParams = new AddressableAssetsBundleBuildParameters(settings, m_BundleToAssetGroup, buildTarget,
buildTargetGroup, settings.buildSettings.bundleBuildPath);
var builtinShaderBundleName =
settings.DefaultGroup.Name.ToLower().Replace(" ", "").Replace('\\', '/').Replace("//", "/") +
"_unitybuiltinshaders.bundle";
var buildTasks = RuntimeDataBuildTasks(builtinShaderBundleName);
buildTasks.Add(m_ExtractData);
IBundleBuildResults buildResults;
var exitCode = ContentPipeline.BuildAssetBundles(buildParams, new BundleBuildContent(m_AllBundleInputDefs),
out buildResults, buildTasks, buildContext);
using (var progressTracker = new UnityEditor.Build.Pipeline.Utilities.ProgressTracker())
{
progressTracker.UpdateTask("Generating Addressables Locations");
GenerateLocationListsTask.Run(buildContext, m_ExtractData.WriteData);
}
return(exitCode);
}
public static void Build(Setting setting)
{
if (setting == null)
{
return;
}
var path = setting.BuildInfo.OutputPath;
if (!Path.IsPathRooted(path))
{
path = Path.GetFullPath(Path.Combine(Application.dataPath, "..", path));
}
var buildContent = new BundleBuildContent(ContentBuildInterface.GenerateAssetBundleBuilds());
var buildParam = new BundleBuildParameters(setting.BuildInfo.Target, setting.BuildInfo.TargetGroup, path);
buildParam.ScriptOptions = ScriptCompilationOptions.None;
buildParam.BundleCompression = UnityEngine.BuildCompression.LZ4;
var settingContext = new LibCraftopiaSetting(setting);
var tasks = BuildPipeline.CreatPipeline();
var code = ContentPipeline.BuildAssetBundles(buildParam, buildContent, out var result, tasks, settingContext);
if (code < 0)
{
UnityEngine.Debug.LogError("Build failed");
}
}
/// <summary>
/// The BundleBuildContent class contains information about all of the Assets you want to build into the BuildMap
/// Assets are referenced to by a GUID object, and the Addresses can be obtained and modified by using a GUID to
/// refer to each asset and identify its Address
/// </summary>
/// <param name="outputPath"></param>
/// <param name="compressionMode"></param>
/// <param name="buildTarget"></param>
/// <param name="buildGroup"></param>
/// <param name="results"></param>
/// <returns></returns>
public static ReturnCode BuildAssetBundles(string outputPath, CompressionType compressionMode, BuildTarget buildTarget, BuildTargetGroup buildGroup, out IBundleBuildResults results)
{
BundleBuildContent buildContent = new BundleBuildContent(ContentBuildInterface.GenerateAssetBundleBuilds());
// Go through assets content and set their address to its filename
for (int i = 0; i < buildContent.Assets.Count; ++i)
{
GUID g = buildContent.Assets[i];
// Get the current address as the full filepath and change it to just be the filename
buildContent.Addresses[g] = Path.GetFileNameWithoutExtension(buildContent.Addresses[g]);
}
BundleBuildParameters buildParams = new BundleBuildParameters(buildTarget, buildGroup, outputPath);
switch (compressionMode)
{
case CompressionType.None:
buildParams.BundleCompression = BuildCompression.Uncompressed;
break;
case CompressionType.Lz4:
buildParams.BundleCompression = BuildCompression.LZ4;
break;
default:
buildParams.BundleCompression = BuildCompression.LZMA;
break;
}
return(ContentPipeline.BuildAssetBundles(buildParams, buildContent, out results));
}
public IEnumerator BuildPipeline_AssetBundleBuild_DoesNotResetUnsavedScene()
{
Scene s = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene);
yield return(null);
EditorSceneManager.SaveScene(s, k_ScenePath);
GameObject.CreatePrimitive(PrimitiveType.Cube);
EditorSceneManager.MarkSceneDirty(s);
GameObject objectWeAdded = GameObject.Find("Cube");
Assert.IsNotNull(objectWeAdded, "No object before entering playmode");
Assert.AreEqual("testScene", SceneManager.GetActiveScene().name);
IBundleBuildParameters buildParameters = GetBuildParameters();
IBundleBuildContent buildContent = GetBundleContent();
IBundleBuildResults results;
ReturnCode exitCode = ContentPipeline.BuildAssetBundles(buildParameters, buildContent, out results);
Assert.AreEqual(ReturnCode.UnsavedChanges, exitCode);
Assert.AreEqual("testScene", SceneManager.GetActiveScene().name);
objectWeAdded = GameObject.Find("Cube");
Assert.IsNotNull(objectWeAdded, "No object after entering playmode");
EditorSceneManager.SaveScene(s, k_ScenePath);
}
public void BuildAssetBundles_WithCache_Succeeds()
{
IBundleBuildParameters buildParameters = GetBuildParameters();
IBundleBuildContent buildContent = GetBundleContent(true);
ReturnCode exitCode = ContentPipeline.BuildAssetBundles(buildParameters, buildContent, out IBundleBuildResults results);
Assert.AreEqual(ReturnCode.Success, exitCode);
}
GameObject RunOpenDrivePipeline(ContentPipeline pipeline)
{
var parentObject = new GameObject("Placed Road Objects");
// if (useEcsRoadNetwork)
// {
// pipeline.RunGenerator<RoadNetworkDescriptionToEcsSystem, RoadNetworkDescriptionToEcsSystemParameters>(new RoadNetworkDescriptionToEcsSystemParameters()
// {
// roadNetworkDescription = roadNetworkDescription
// });
// pipeline.RunGenerator<GeneratePolygonsFromEcsSystem, PolygonSystemFromEcsParameters>(new PolygonSystemFromEcsParameters()
// {
// minimumPolygonArea = MinimumPolygonArea,
// extensionDistance = ExtensionDistance,
// processingScheme = processingScheme
// });
// }
// else
// {
pipeline.RunGenerator <PlacementPathsFromPolygonsSystem, PolygonSystemParameters>(new PolygonSystemParameters()
{
roadNetworkDescription = roadNetworkDescription,
minimumPolygonArea = MinimumPolygonArea,
extensionDistance = ExtensionDistance,
outermostLaneType = BorderLaneType
});
// }
pipeline.RunGenerator <MeshFromPolygonsSystem, MeshFromPolygonsParameters>(new MeshFromPolygonsParameters()
{
Material = roadMaterial,
Parent = parentObject.transform,
UVMultiplier = uvMultiplier
});
if (createRoadMesh)
{
pipeline.RunGenerator <MeshFromPolygonsSystem, MeshFromPolygonsParameters>(new MeshFromPolygonsParameters()
{
Material = roadMaterial,
Parent = parentObject.transform,
UVMultiplier = uvMultiplier
});
}
if (drawRoadOutline)
{
pipeline.RunGenerator <PolygonDrawingSystem, PolygonDrawingParameters>(new PolygonDrawingParameters
{
parent = parentObject.transform
});
}
ExecutePlacementAlgorithms(pipeline, parentObject);
return(parentObject);
}
static ReturnCode WriteSceneBundles(BundleBuildParameters parameters, string[] scenes)
{
var bundles = new AssetBundleBuild[1];
bundles[0].assetBundleName = "scenes.bundle";
bundles[0].assetNames = scenes;
var content = new BundleBuildContent(bundles);
return(ContentPipeline.BuildAssetBundles(parameters, content, out var result));
}
internal ReturnCode CreateCatalogBundle(string filepath, string jsonText, AddressablesDataBuilderInput builderInput)
{
if (string.IsNullOrEmpty(filepath) || string.IsNullOrEmpty(jsonText) || builderInput == null)
{
throw new ArgumentException("Unable to create catalog bundle (null arguments).");
}
// A bundle requires an actual asset
var tempFolderName = "TempCatalogFolder";
var tempFolderPath = Path.Combine(AddressableAssetSettingsDefaultObject.kDefaultConfigFolder, tempFolderName);
var tempFilePath = Path.Combine(tempFolderPath, Path.GetFileName(filepath).Replace(".bundle", ".json"));
if (!WriteFile(tempFilePath, jsonText, builderInput.Registry))
{
throw new Exception("An error occured during the creation of temporary files needed to bundle the content catalog.");
}
AssetDatabase.Refresh();
var bundleBuildContent = new BundleBuildContent(new[]
{
new AssetBundleBuild()
{
assetBundleName = Path.GetFileName(filepath),
assetNames = new[] { tempFilePath },
addressableNames = new string[0]
}
});
var buildTasks = new List <IBuildTask>
{
new CalculateAssetDependencyData(),
new GenerateBundlePacking(),
new GenerateBundleCommands(),
new WriteSerializedFiles(),
new ArchiveAndCompressBundles()
};
var buildParams = new BundleBuildParameters(builderInput.Target, builderInput.TargetGroup, Path.GetDirectoryName(filepath));
var retCode = ContentPipeline.BuildAssetBundles(buildParams, bundleBuildContent, out IBundleBuildResults result, buildTasks);
if (Directory.Exists(tempFolderPath))
{
Directory.Delete(tempFolderPath, true);
builderInput.Registry.RemoveFile(tempFilePath);
}
if (File.Exists(filepath))
{
builderInput.Registry.AddFile(filepath);
}
return(retCode);
}
GameObject RunSplineBasedRoadNetworkPipeline(ContentPipeline pipeline)
{
var parentObject = new GameObject("Placed Road Objects");
var roadObject = new GameObject("Road");
var networkToMesh = splineBasedRoadNetwork.GetComponent <RoadPathNetworkToMesh>();
networkToMesh.generateRoadMesh = createRoadMesh;
networkToMesh.GenerateRoadMesh(pipeline, roadObject);
ExecutePlacementAlgorithms(pipeline, parentObject);
roadObject.transform.parent = parentObject.transform;
return(parentObject);
}
private void Apply(InstancedModel model)
{
if (model == null || Texture == null)
{
return;
}
var random = new Random(Seed);
var transforms = new List <Matrix>();
var texture = ContentPipeline.LoadContent <Texture2DContent>(Texture.Filename, new Microsoft.Xna.Framework.Content.Pipeline.TextureImporter());
texture.ConvertBitmapType(typeof(PixelBitmapContent <float>));
var map = (PixelBitmapContent <float>)texture.Mipmaps[0];
for (int z = 0; z < map.Height; z++)
{
for (int x = 0; x < map.Width; ++x)
{
var probability = map.GetPixel(x, z) * Density * 0.0001 * Step * Step;
var count = (int)Math.Floor(probability);
if (random.NextDouble() < probability - count)
{
count++;
}
for (int i = 0; i < count; ++i)
{
var xx = random.NextDouble();
var zz = random.NextDouble();
Matrix transform = new Matrix();
transform.M11 = transform.M33 = HorizontalScale.Min + (float)random.NextDouble() * (HorizontalScale.Max - HorizontalScale.Min);
transform.M22 = VerticalScale.Min + (float)random.NextDouble() * (VerticalScale.Max - VerticalScale.Min);
transform.M44 = 1;
if (RandomizeRotation)
{
Matrix rotation;
Matrix.CreateRotationY((float)random.NextDouble() * MathHelper.Pi * 2, out rotation);
Matrix.Multiply(ref transform, ref rotation, out transform);
}
transform.M41 = (x * Step) + (float)(xx * Step);
transform.M43 = (z * Step) + (float)(zz * Step);
transforms.Add(transform);
}
}
}
model.SetInstanceTransforms(transforms.ToArray());
}
public static byte[] Compile(string effectCode)
{
using (var stream = new FileStream(Path.Combine(Path.GetTempPath(), Path.GetTempFileName()), FileMode.Create))
{
var writer = new StreamWriter(stream);
writer.Write(effectCode);
writer.Flush();
stream.Seek(0, SeekOrigin.Begin);
return(ContentPipeline.LoadContent <CompiledEffectContent>(stream
, new Microsoft.Xna.Framework.Content.Pipeline.EffectImporter()
, new EffectProcessor()).GetEffectCode());
}
}
public void BuildAssetBundles_WhenBuildLogProvided_DoesNotCreatePerformanceLogReport()
{
IBundleBuildParameters buildParameters = GetBuildParameters();
IBundleBuildContent buildContent = GetBundleContent();
IBundleBuildResults results;
var taskList = DefaultBuildTasks.Create(DefaultBuildTasks.Preset.AssetBundleCompatible);
ContentPipeline.BuildAssetBundles(buildParameters, buildContent, out results, taskList, new BuildLog());
string tepBuildLog = buildParameters.GetOutputFilePathForIdentifier("buildlogtep.json");
FileAssert.DoesNotExist(tepBuildLog);
}
public void BuildAssetBundles_WhenNoBuildInContextLog_CreatesPerformanceLogReport()
{
IBundleBuildParameters buildParameters = GetBuildParameters();
IBundleBuildContent buildContent = GetBundleContent();
IBundleBuildResults results;
buildParameters.Group = EditorUserBuildSettings.selectedBuildTargetGroup;
ContentPipeline.BuildAssetBundles(buildParameters, buildContent, out results);
string tepBuildLog = buildParameters.GetOutputFilePathForIdentifier("buildlogtep.json");
FileAssert.Exists(tepBuildLog);
}
public void CreateRoadFromInspector()
{
if (roadBuilderParameters.parentObject != null)
{
DestroyImmediate(roadBuilderParameters.parentObject);
}
var parentObject = new GameObject("Road Mesh");
using (var pipeline = new ContentPipeline())
{
GenerateRoadMesh(pipeline, parentObject);
}
}
/// <summary> 指定されたアセットバンドルをビルド </summary>
public BuildResult Build(string outputPath, AssetBundleBuild[] buildMap)
{
var buildTargetGroup = BuildPipeline.GetBuildTargetGroup(BuildTarget);
var buildParams = new BundleBuildParameters(BuildTarget, buildTargetGroup, outputPath)
{
BundleCompression = BuildCompression.LZ4,
};
var buildContent = new BundleBuildContent(buildMap);
var tasks = DefaultBuildTasks.Create(DefaultBuildTasks.Preset.AssetBundleBuiltInShaderExtraction);
var exitCode = ContentPipeline.BuildAssetBundles(buildParams, buildContent, out var results, tasks);
return(new BuildResult(exitCode, results));
}
public static void Build()
{
var buildContent = new BundleBuildContent(ContentBuildInterface.GenerateAssetBundleBuilds());
var buildParams = new CustomBuildParameters(EditorUserBuildSettings.activeBuildTarget, EditorUserBuildSettings.selectedBuildTargetGroup, "Assets/StreamingAssets");
// set three different Assetbundles to be the different compression options available
buildParams.m_PerBundleCompression.Add("textures", BuildCompression.LZMA);
buildParams.m_PerBundleCompression.Add("objects", BuildCompression.LZ4);
buildParams.m_PerBundleCompression.Add("prefabs", BuildCompression.Uncompressed);
buildParams.BundleCompression = BuildCompression.LZMA;
IBundleBuildResults results;
ReturnCode exitCode = ContentPipeline.BuildAssetBundles(buildParams, buildContent, out results);
Debug.Log("Building per bundle completed with " + exitCode);
}
/// <summary>
/// Loads an asset.
/// </summary>
/// <param name="asset">The Asset.</param>
/// <param name="type">The Type.</param>
/// <returns>IContent.</returns>
private IContent Load(string asset, Type type)
{
IContent data;
if (QueryCache(asset, type, out data))
{
return(data);
}
if (!File.Exists(Path.Combine(RootPath, asset)))
{
throw new ContentLoadException("Asset not found.");
}
data = ContentPipeline.ProcessDatatype(Path.Combine(RootPath, asset), type);
ApplyCache(asset, data);
return(data);
}
static ReturnCode WriteRenderPipelineBundles(BundleBuildParameters parameters)
{
var srp = UnityEngine.Rendering.GraphicsSettings.defaultRenderPipeline;
if (srp == null)
{
return(ReturnCode.SuccessNotRun);
}
var bundles = new AssetBundleBuild[1];
bundles[0].assetBundleName = "renderpipeline.bundle";
bundles[0].assetNames = new[] { AssetDatabase.GetAssetPath(UnityEngine.Rendering.GraphicsSettings.defaultRenderPipeline) };
bundles[0].addressableNames = new[] { "DefaultRenderPipeline" };
var content = new BundleBuildContent(bundles);
return(ContentPipeline.BuildAssetBundles(parameters, content, out var result));
}
static ReturnCode WriteResourcesBundles(BundleBuildParameters parameters)
{
// Resources loading path handling has a few rules:
// - Paths are relative to resources folder
// - Paths are lowercase
// - Paths have extensions removed
// So "C:\Project\Assets\MyGame\Resources\SO\SomeAsset.asset" becomes "so\someAsset"
// On the loading side, all paths passed in have ToLower() run on them.
var assetPaths = GetResourcesAssetPaths();
var bundles = new AssetBundleBuild[]
{
new AssetBundleBuild()
{
assetBundleName = "resources.bundle",
assetNames = assetPaths.Select(x => x.ToString()).ToArray(),
addressableNames = assetPaths.Select(x =>
{
const string k_Folder = "/resources/";
const int k_FolderLength = 11;
// Hack for PostProcessing stack
var shader = AssetDatabase.LoadAssetAtPath <Shader>(x.ToString());
if (shader != null)
{
return(shader.name.ToLower());
}
var path = x.ChangeExtension("").ToString().ToLower();
var index = path.ToLower().LastIndexOf(k_Folder);
if (index > -1)
{
path = path.Substring(index + k_FolderLength);
}
return(path);
}).ToArray()
}
};
var content = new BundleBuildContent(bundles);
return(ContentPipeline.BuildAssetBundles(parameters, content, out var result));
}
/// <summary>
/// Initializes a new ContentManager.
/// </summary>
public ContentManager()
{
RootPath = Path.Combine(Environment.CurrentDirectory, "Content");
ContentVerifier = new ContentVerifier();
ContentPipeline = new ContentPipeline();
if (!Directory.Exists(RootPath))
{
Directory.CreateDirectory(RootPath);
}
_contentCache = new Dictionary <string, IContent>();
_batchList = new List <IBatch>();
//add build in factories
ContentPipeline.Attach(new AudioSourceFactory());
ContentPipeline.Attach(new TextFileFactory());
ContentPipeline.Attach(new ScriptFileFactory());
ContentPipeline.Attach(new Texture2DFactory());
ContentPipeline.Attach(new AudioEffectFactory());
}
internal ReturnCode RefreshBuild(AddressableAssetsBuildContext buildContext)
{
var settings = buildContext.Settings;
var context = new AddressablesDataBuilderInput(settings);
var buildTarget = context.Target;
var buildTargetGroup = context.TargetGroup;
var buildParams = new AddressableAssetsBundleBuildParameters(settings, m_BundleToAssetGroup, buildTarget,
buildTargetGroup, settings.buildSettings.bundleBuildPath);
var builtinShaderBundleName =
settings.DefaultGroup.Name.ToLower().Replace(" ", "").Replace('\\', '/').Replace("//", "/") +
"_unitybuiltinshaders.bundle";
var buildTasks = RuntimeDataBuildTasks(builtinShaderBundleName);
buildTasks.Add(m_ExtractData);
IBundleBuildResults buildResults;
var exitCode = ContentPipeline.BuildAssetBundles(buildParams, new BundleBuildContent(m_AllBundleInputDefs),
out buildResults, buildTasks, buildContext);
return exitCode;
}
public void GenerateRoadMesh(
ContentPipeline pipeline,
GameObject parentObject,
RoadConditionConfiguration roadConditionConfig = null)
{
Profiler.BeginSample("GenerateRoadMesh");
m_RoadPathNetwork = GetComponent <RoadPathNetwork>();
materialParams.parentObject = parentObject;
roadBuilderParameters.parentObject = parentObject;
debugDrawingParameters.parentObject = parentObject;
cameraPathParameters.parentObject = parentObject;
roadBuilderParameters.baseRandomSeed = baseRandomSeed;
var roadPathParams = new RoadPathNetworkToEcsParameters {
network = m_RoadPathNetwork
};
// TODO: Validate roadBuilderParameter inputs
pipeline.RunGenerator <RoadPathNetworkToEcsSystem, RoadPathNetworkToEcsParameters>(roadPathParams);
pipeline.RunGenerator <RoadBuilderSystem, RoadBuilderParameters>(roadBuilderParameters);
if (generateRoadMesh)
{
pipeline.RunGenerator <AssembleMeshSystem, RoadMaterialParameters>(materialParams);
}
pipeline.RunGenerator <CreateRoadEdgePathsSystem>();
pipeline.RunGenerator <CameraPathSystem, CameraPathParameters>(cameraPathParameters);
pipeline.RunGenerator <DebugDrawingSystem, DebugDrawingParameters>(debugDrawingParameters);
#if HDRP_PRESENT
manholeCoverPlacementParameters.parentObject = parentObject;
manholeCoverPlacementParameters.baseRandomSeed = roadBuilderParameters.baseRandomSeed;
pipeline.RunGenerator <ManholeCoverPlacementSystem, ManholeCoverPlacementParameters>(manholeCoverPlacementParameters);
#endif
parentObject.AddComponent <RoadConditionAssigner>();
Profiler.EndSample();
}
public static void Build()
{
var buildContent = new BundleBuildContent(ContentBuildInterface.GenerateAssetBundleBuilds());
var buildParams = new CustomBuildParameters(EditorUserBuildSettings.activeBuildTarget, EditorUserBuildSettings.selectedBuildTargetGroup, "Assets/StreamingAssets");
// This is a part of the CustomBuildParameters class that override the outputFolder on a per AssetBundle basic
buildParams.m_PerBundleBuildFolder.Add("textures", "Assets/StreamingAssets/OtherFolder");
// This is a part of the CustomBuildParameters class that ignores the outputFolder, and gives a direct location, including the filename. On a per AssetBundle basic
buildParams.m_PerBundleAbsolutePath.Add("prefabs", Application.dataPath.Substring(0, Application.dataPath.Length - 6) + "myPrefabObjects.ab");
buildParams.BundleCompression = BuildCompression.LZMA;
List <IBuildTask> taskList = DefaultBuildTasks.Create(DefaultBuildTasks.Preset.AssetBundleBuiltInShaderExtraction) as List <IBuildTask>;
//taskList.Add( new MoveAssetBundles() ); // no longer needed from "1.2.3-preview" as can use
taskList.Add(new RefreshAssetDatabase());
IBundleBuildResults results;
ReturnCode exitCode = ContentPipeline.BuildAssetBundles(buildParams, buildContent, out results, taskList);
Debug.Log("Building per bundle completed with " + exitCode);
}
/// <summary>
/// Loads an asset.
/// </summary>
/// <typeparam name="T">The Type.</typeparam>
/// <param name="asset">The Asset.</param>
/// <returns>T.</returns>
public T Load <T>(string asset) where T : IContent
{
//make the path valid if not
asset = asset.Replace("/", @"\");
//query content cache first.
T data;
if (QueryCache(asset, out data))
{
return(data);
}
if (!File.Exists(Path.Combine(RootPath, asset)))
{
throw new ContentLoadException("Asset not found.");
}
data = ContentPipeline.ProcessDatatype <T>(Path.Combine(RootPath, asset));
ApplyCache(asset, data);
return(data);
}
public static void Build()
{
Clear();
var Mods = ModsEditor.GetMods();
int length = Mods.Length;
for (int i = 0; i < length; i++)
{
var ModInfo = ModsEditor.GetModInfo(Mods[i]);
var ModOutPutFolder = OutPutFolder + "/" + ModInfo.PackageName;
Directory.CreateDirectory(ModOutPutFolder);
//生成ModInfo文件
using (StreamWriter sw = File.CreateText(ModOutPutFolder + "/" + ModInfo.PackageName + ".json"))
{
sw.Write(JsonConvert.SerializeObject(ModInfo));
}
//Windows64版本构建
//构建参数
var param = new BundleBuildParameters(BuildTarget.StandaloneWindows64, BuildTargetGroup.Standalone, ModOutPutFolder);
param.BundleCompression = BuildCompression.LZ4;
//填入资源
var content = new BundleBuildContent(new AssetBundleBuild[] { GetAllAssets(ModInfo, "winmod") });
IBundleBuildResults results;
//构建包
ReturnCode code = ContentPipeline.BuildAssetBundles(param, content, out results);
if (code != ReturnCode.Success)
{
if (code == ReturnCode.Canceled)
{
return;//如果取消，直接返回
}
Debug.LogError("构建失败！错误原因：" + code.ToString());
}
}
}
public static ReturnCode BuildAssetBundles(string outputPath, CompressionType compressionMode, BuildTarget buildTarget, BuildTargetGroup buildGroup, out IBundleBuildResults results)
{
BundleBuildContent buildContent = new BundleBuildContent(ContentBuildInterface.GenerateAssetBundleBuilds());
BundleBuildParameters buildParams = new BundleBuildParameters(buildTarget, buildGroup, outputPath);
SetupBuildCacheServer(buildParams);
switch (compressionMode)
{
case CompressionType.None:
buildParams.BundleCompression = BuildCompression.Uncompressed;
break;
case CompressionType.Lz4:
buildParams.BundleCompression = BuildCompression.LZ4;
break;
default:
buildParams.BundleCompression = BuildCompression.LZMA;
break;
}
return(ContentPipeline.BuildAssetBundles(buildParams, buildContent, out results));
}
