private void UpdateShaderParameters(RenderTexture t, ComputeBuffer myLock)
{
uint zf, zw;
if (t == null)
{
t = _outputRT;
}
_kernelsLoaded = _shader.HasKernel("WriteDepth") && _shader.HasKernel("Clear");
if (!_kernelsLoaded)
{
Debug.LogError("Shader Kernel compilation error");
return;
}
_materialToShareTexture.SetTexture(_textureName, t);
_clearKernel = _shader.FindKernel("Clear");
_writeDepthKernel = _shader.FindKernel("WriteDepth");
//_shader.SetBuffer(_clearKernel, "Depth", d);
_shader.SetTexture(_clearKernel, "Result", t);
_shader.SetBuffer(_clearKernel, "lock", myLock);
//_shader.SetBuffer(_writeDepthKernel, "Depth", d);
_shader.SetBuffer(_writeDepthKernel, "lock", myLock);
_shader.SetTexture(_writeDepthKernel, "Result", t);
_shader.SetTexture(_writeDepthKernel, "DepthTexture", depth);
_shader.SetTexture(_writeDepthKernel, "AlbedoTexture", albedo);
_shader.GetKernelThreadGroupSizes(_clearKernel, out _xf, out _yf, out zf);
_shader.GetKernelThreadGroupSizes(_writeDepthKernel, out _xw, out _yw, out zw);
}
private void UpdateShaderParameters(RenderTexture t, ComputeBuffer d, List <ComputeBuffer> d0, ComputeBuffer m)
{
uint zf, zd, zw;
if (t == null)
{
t = _outputRT;
}
_kernelsLoaded = _shader.HasKernel("WriteDepth") && _shader.HasKernel("DisplaceAlbedo") && _shader.HasKernel("Clear");
if (!_kernelsLoaded)
{
Debug.LogError("Shader Kernel compilation error");
return;
}
_materialToShareTexture.SetTexture(_textureName, t);
_clearKernel = _shader.FindKernel("Clear");
_writeDepthKernel = _shader.FindKernel("WriteDepth");
_displaceKernel = _shader.FindKernel("DisplaceAlbedo");
_shader.SetBuffer(_clearKernel, "Depth", d);
_shader.SetBuffer(_clearKernel, "Depth0[0]", d0[0]);
_shader.SetBuffer(_clearKernel, "Depth0[1]", d0[1]);
_shader.SetBuffer(_clearKernel, "Depth0[2]", d0[2]);
_shader.SetBuffer(_clearKernel, "Depth0[3]", d0[3]);
_shader.SetBuffer(_clearKernel, "MutexBuffer", m);
_shader.SetTexture(_clearKernel, "Result", t);
_shader.SetBuffer(_writeDepthKernel, "Depth", d);
_shader.SetBuffer(_writeDepthKernel, "Depth0[0]", d0[0]);
_shader.SetBuffer(_writeDepthKernel, "Depth0[1]", d0[1]);
_shader.SetBuffer(_writeDepthKernel, "Depth0[2]", d0[2]);
_shader.SetBuffer(_writeDepthKernel, "Depth0[3]", d0[3]);
_shader.SetBuffer(_writeDepthKernel, "MutexBuffer", m);
_shader.SetTexture(_writeDepthKernel, "Result", t);
_shader.SetTexture(_writeDepthKernel, "DepthTexture", depth);
_shader.SetTexture(_writeDepthKernel, "AlbedoTexture", albedo);
_shader.SetBuffer(_displaceKernel, "Depth", d);
_shader.SetBuffer(_displaceKernel, "Depth0[0]", d0[0]);
_shader.SetBuffer(_displaceKernel, "Depth0[1]", d0[1]);
_shader.SetBuffer(_displaceKernel, "Depth0[2]", d0[2]);
_shader.SetBuffer(_displaceKernel, "Depth0[3]", d0[3]);
_shader.SetBuffer(_displaceKernel, "MutexBuffer", m);
_shader.SetTexture(_displaceKernel, "Result", t);
_shader.SetTexture(_displaceKernel, "DepthTexture", depth);
_shader.SetTexture(_displaceKernel, "AlbedoTexture", albedo);
_shader.GetKernelThreadGroupSizes(_clearKernel, out _xf, out _yf, out zf);
_shader.GetKernelThreadGroupSizes(_writeDepthKernel, out _xw, out _yw, out zw);
_shader.GetKernelThreadGroupSizes(_displaceKernel, out _xd, out _yd, out zd);
}
public CustomComputeKernel(ComputeShader cs, string kn)
{
string kernelNameWithChannelsOrder = kn + (ComputeInfo.channelsOrder == ComputeInfo.ChannelsOrder.NHWC ? "_NHWC" : "_NCHW");
if (!cs.HasKernel(kernelNameWithChannelsOrder) && !cs.HasKernel(kn))
{
throw new ArgumentException($"Kernel {kn} and {kernelNameWithChannelsOrder} are both missing");
}
shader = cs;
kernelName = cs.HasKernel(kernelNameWithChannelsOrder)?kernelNameWithChannelsOrder:kn;
kernelIndex = shader.FindKernel(kernelName);
shader.GetKernelThreadGroupSizes(kernelIndex, out threadGroupSizeX, out threadGroupSizeY, out threadGroupSizeZ);
}
public ComputeKernel(ComputeShader shader, string name)
{
if (!shader.HasKernel(name))
{
throw new ArgumentException("The shader doesn't contain a kernel with this name.", nameof(name));
}
Id = shader.FindKernel(name);
Shader = shader;
}
static bool TryGetKernel(string kernelName, ref ComputeShader cs, ref int kernelID)
{
if (!cs.HasKernel(kernelName))
{
Debug.LogError(kernelName + " kernel not found in " + cs.name + "!");
return(false);
}
kernelID = cs.FindKernel(kernelName);
return(true);
}
/// <summary>
/// ComputeShaderを介してシミュレート
/// </summary>
void Simulation()
{
ComputeShader cs = particleCS;
int kernelID = -1;
int threadGroupSize = Mathf.CeilToInt(maxObjectNum / SIMULATION_BLOCK_SIZE);
if (cs.HasKernel("MainCS"))
{
kernelID = cs.FindKernel("MainCS");
cs.SetFloat("_Time", Time.time);
cs.SetBuffer(kernelID, "_ParticleDataBufferR", _particleBuf);
cs.SetBuffer(kernelID, "_ParticleDataBuffer", _particleBuf);
cs.Dispatch(kernelID, threadGroupSize, 1, 1);
}
}
private void Initialize()
{
if (shader == null)
{
Debug.LogError("Shader is null");
}
if (!shader.HasKernel(kernalName))
{
Debug.LogError("No Kernel in this shader", shader);
}
kernalIndex = shader.FindKernel(kernalName);
foreach (ComputeBase computeBase in computeBases)
{
computeBase.Initialize(shader, kernalIndex);
}
}
private void PrepareShaderForRendering()
{
Debug.Assert(shaderForRayCasting != null);
Debug.Assert(shaderForRayCasting.HasKernel(SHADER_KERNEL_NAME));
// Find the main functiona that will be used for dispatch and setting the data.
kernelIndexOfMain = shaderForRayCasting.FindKernel(SHADER_KERNEL_NAME);
// Returns the thread group sizes from compute shader code "[numthreads(32, 32, 1)]".
shaderForRayCasting.GetKernelThreadGroupSizes(kernelIndexOfMain,
out threadsPerThreadGroup.x,
out threadsPerThreadGroup.y,
out threadsPerThreadGroup.z);
Debug.Assert(
threadsPerThreadGroup.x == THREAD_PER_GROUP &&
threadsPerThreadGroup.y == THREAD_PER_GROUP &&
threadsPerThreadGroup.z == 1, "Incorrect thread group values");
}
public static int HasKernel(IntPtr l)
{
int result;
try
{
ComputeShader computeShader = (ComputeShader)LuaObject.checkSelf(l);
string name;
LuaObject.checkType(l, 2, out name);
bool b = computeShader.HasKernel(name);
LuaObject.pushValue(l, true);
LuaObject.pushValue(l, b);
result = 2;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
public override void Render(ScriptableRenderContext context, Camera[] cameras)
{
base.Render(context, cameras);
var cmd = new CommandBuffer();
cmd.ClearRenderTarget(true, true, Color.yellow);
if (_shader != null && _shader.HasKernel(KernelName))
{
int index = _shader.FindKernel("CSMain");
var target = new RenderTargetIdentifier(BuiltinRenderTextureType.CurrentActive);
cmd.SetComputeTextureParam(_shader, index, "Result", target);
cmd.DispatchCompute(_shader, index, _width, _height, 1);
}
context.ExecuteCommandBuffer(cmd);
context.Submit();
}
public static int FindKernelOrWarn(this ComputeShader compute, string kernalName, ref bool IsReady)
{
if (IsReady)
{
if (compute.HasKernel(kernalName))
{
int kernel = compute.FindKernel(kernalName);
IsReady = true;
return(kernel);
}
else
{
IsReady = false;
Logging.Warning("{0}: Can't find Compute Shader Kernel of name {1}", EXTNAME, kernalName);
return(-1);
}
}
else
{
Logging.Log("{0}: Not attempting to find Kernel - caller was not ready state!", EXTNAME);
return(-1);
}
}
public static int TryFindKernel(this ComputeShader shader, string name)
{
return(shader.HasKernel(name) ? shader.FindKernel(name) : -1);
}
public static int FindKernel(this ComputeShader comp, string name)
{
return(comp.HasKernel(name) ? comp.FindKernel(name) : -1);
}
