public ProbeArray(ProbeArray probeArray)
{
mProbeArray = API.iplProbeArrayRetain(probeArray.mProbeArray);
}
public void Save(SerializedData dataAsset)
{
var serializedObject = new SerializedObject(mContext);
API.iplStaticMeshSave(mStaticMesh, serializedObject.Get());
serializedObject.WriteToFile(dataAsset);
}
public override void Destroy()
{
API.iplFMODTerminate();
}
public void Release()
{
API.iplProbeBatchRelease(ref mProbeBatch);
mContext = null;
}
public void RemoveFromScene(Scene scene)
{
API.iplStaticMeshRemove(mStaticMesh, scene.Get());
scene.NotifyRemoveObject();
}
public int GetNumProbes()
{
return(API.iplProbeArrayGetNumProbes(mProbeArray));
}
public ProbeBatch(Context context)
{
mContext = context;
API.iplProbeBatchCreate(context.Get(), out mProbeBatch);
}
public SerializedObject(SerializedObject serializedObject)
{
mSerializedObject = API.iplSerializedObjectRetain(serializedObject.Get());
}
public UIntPtr GetSize()
{
return(API.iplSerializedObjectGetSize(mSerializedObject));
}
public void SaveOBJ(string fileBaseName)
{
API.iplSceneSaveOBJ(mScene, fileBaseName);
}
public void Commit()
{
API.iplSceneCommit(mScene);
}
public Scene(Scene scene)
{
mContext = scene.mContext;
mScene = API.iplSceneRetain(scene.mScene);
}
public override void SetReverbSource(Source reverbSource)
{
API.iplFMODSetReverbSource(reverbSource.Get());
}
public override void SetHRTF(IntPtr hrtf)
{
API.iplFMODSetHRTF(hrtf);
}
public void Release()
{
API.iplProbeArrayRelease(ref mProbeArray);
}
public IntPtr GetData()
{
return(API.iplSerializedObjectGetData(mSerializedObject));
}
public void GenerateProbes(Scene scene, ProbeGenerationParams probeGenerationParams)
{
API.iplProbeArrayGenerateProbes(mProbeArray, scene.Get(), ref probeGenerationParams);
}
public void AddProbeArray(ProbeArray probeArray)
{
API.iplProbeBatchAddProbeArray(mProbeBatch, probeArray.Get());
}
public Sphere GetProbe(int index)
{
return(API.iplProbeArrayGetProbe(mProbeArray, index));
}
public void Commit()
{
API.iplProbeBatchCommit(mProbeBatch);
}
public ProbeBatch(ProbeBatch probeBatch)
{
mContext = probeBatch.mContext;
mProbeBatch = API.iplProbeBatchRetain(probeBatch.mProbeBatch);
}
public void RemoveData(BakedDataIdentifier identifier)
{
API.iplProbeBatchRemoveData(mProbeBatch, ref identifier);
}
public void AddToScene(Scene scene)
{
API.iplStaticMeshAdd(mStaticMesh, scene.Get());
scene.NotifyAddObject();
}
public UIntPtr GetDataSize(BakedDataIdentifier identifier)
{
return(API.iplProbeBatchGetDataSize(mProbeBatch, ref identifier));
}
public StaticMesh(StaticMesh staticMesh)
{
mContext = staticMesh.mContext;
mStaticMesh = API.iplStaticMeshRetain(staticMesh.mStaticMesh);
}
public ProbeArray(Context context)
{
API.iplProbeArrayCreate(context.Get(), out mProbeArray);
}
static void BakeThread()
{
sTotalObjects = sTasks.Length;
for (var i = 0; i < sTotalObjects; ++i)
{
sCurrentObjectIndex = i;
if (sTasks[i].identifier.type == BakedDataType.Pathing)
{
sCurrentObjectName = "pathing";
}
else if (sTasks[i].identifier.variation == BakedDataVariation.Reverb)
{
sCurrentObjectName = "reverb";
}
else
{
sCurrentObjectName = sTasks[i].name;
}
Debug.Log(string.Format("START: Baking effect for {0}.", sCurrentObjectName));
var probeBatches = sTasks[i].probeBatches;
sTotalProbeBatches = probeBatches.Length;
for (var j = 0; j < sTotalProbeBatches; ++j)
{
sCurrentProbeBatchIndex = j;
if (sCancel)
{
return;
}
if (probeBatches[j] == null)
{
Debug.LogWarning(string.Format("{0}: Probe Batch at index {1} is null.", sCurrentObjectName, j));
continue;
}
if (probeBatches[j].GetNumProbes() == 0)
{
Debug.LogWarning(string.Format("{0}: Probe Batch {1} has no probes, skipping.", sCurrentObjectName, sTasks[i].probeBatchNames[j]));
continue;
}
var probeBatch = new ProbeBatch(SteamAudioManager.Context, sTasks[i].probeBatchAssets[j]);
var simulationSettings = SteamAudioManager.GetSimulationSettings(true);
if (sTasks[i].identifier.type == BakedDataType.Reflections)
{
var bakeParams = new ReflectionsBakeParams {
};
bakeParams.scene = SteamAudioManager.CurrentScene.Get();
bakeParams.probeBatch = probeBatch.Get();
bakeParams.sceneType = simulationSettings.sceneType;
bakeParams.identifier = sTasks[i].identifier;
bakeParams.flags = 0;
bakeParams.numRays = simulationSettings.maxNumRays;
bakeParams.numDiffuseSamples = simulationSettings.numDiffuseSamples;
bakeParams.numBounces = SteamAudioSettings.Singleton.bakingBounces;
bakeParams.simulatedDuration = simulationSettings.maxDuration;
bakeParams.savedDuration = simulationSettings.maxDuration;
bakeParams.order = simulationSettings.maxOrder;
bakeParams.numThreads = simulationSettings.numThreads;
bakeParams.rayBatchSize = simulationSettings.rayBatchSize;
bakeParams.irradianceMinDistance = SteamAudioSettings.Singleton.bakingIrradianceMinDistance;
bakeParams.bakeBatchSize = 1;
if (SteamAudioSettings.Singleton.bakeConvolution)
{
bakeParams.flags = bakeParams.flags | ReflectionsBakeFlags.BakeConvolution;
}
if (SteamAudioSettings.Singleton.bakeParametric)
{
bakeParams.flags = bakeParams.flags | ReflectionsBakeFlags.BakeParametric;
}
if (simulationSettings.sceneType == SceneType.RadeonRays)
{
bakeParams.openCLDevice = SteamAudioManager.OpenCLDevice;
bakeParams.radeonRaysDevice = SteamAudioManager.RadeonRaysDevice;
bakeParams.bakeBatchSize = SteamAudioSettings.Singleton.bakingBatchSize;
}
API.iplReflectionsBakerBake(SteamAudioManager.Context.Get(), ref bakeParams, sProgressCallback, IntPtr.Zero);
}
else
{
var bakeParams = new PathBakeParams {
};
bakeParams.scene = SteamAudioManager.CurrentScene.Get();
bakeParams.probeBatch = probeBatch.Get();
bakeParams.identifier = sTasks[i].identifier;
bakeParams.numSamples = SteamAudioSettings.Singleton.bakingVisibilitySamples;
bakeParams.radius = SteamAudioSettings.Singleton.bakingVisibilityRadius;
bakeParams.threshold = SteamAudioSettings.Singleton.bakingVisibilityThreshold;
bakeParams.visRange = SteamAudioSettings.Singleton.bakingVisibilityRange;
bakeParams.pathRange = SteamAudioSettings.Singleton.bakingPathRange;
bakeParams.numThreads = SteamAudioManager.Singleton.NumThreadsForCPUCorePercentage(SteamAudioSettings.Singleton.bakedPathingCPUCoresPercentage);
API.iplPathBakerBake(SteamAudioManager.Context.Get(), ref bakeParams, sProgressCallback, IntPtr.Zero);
}
if (sCancel)
{
Debug.Log("CANCELLED: Baking.");
return;
}
// Don't flush the writes to disk just yet, because we can only do it from the main thread.
probeBatches[j].probeDataSize = probeBatch.Save(sTasks[i].probeBatchAssets[j], false);
var dataSize = (int)probeBatch.GetDataSize(sTasks[i].identifier);
probeBatches[j].AddOrUpdateLayer(sTasks[i].gameObject, sTasks[i].identifier, dataSize);
if (sTasks[i].identifier.type == BakedDataType.Reflections)
{
switch (sTasks[i].identifier.variation)
{
case BakedDataVariation.Reverb:
(sTasks[i].component as SteamAudioListener).UpdateBakedDataStatistics();
break;
case BakedDataVariation.StaticSource:
(sTasks[i].component as SteamAudioBakedSource).UpdateBakedDataStatistics();
break;
case BakedDataVariation.StaticListener:
(sTasks[i].component as SteamAudioBakedListener).UpdateBakedDataStatistics();
break;
}
}
}
Debug.Log(string.Format("COMPLETED: Baking effect for {0}.", sCurrentObjectName));
}
sStatus = BakeStatus.Complete;
}
public override void Initialize(IntPtr context, IntPtr defaultHRTF, SimulationSettings simulationSettings)
{
API.iplFMODInitialize(context);
API.iplFMODSetHRTF(defaultHRTF);
API.iplFMODSetSimulationSettings(simulationSettings);
}
