Unity - Creating light that's visible to a shader but not to the camera/player?

Question

I'm writing a vertex deformation shader that can react to the presence of certain objects. Originally I was passing coordinates to the shader with SetVector, but from my understanding having the CPU set properties on a shader is somewhat expensive. So another idea I had was to have the shader react to light, and do some matrix multiplication to have the shader deform itself based on the intensity of the light hitting it. My question is, how could I approach writing a shader that would react to a light source, when that light would be invisible to the camera/player? In such a scenario I could write a fast & reasonably simple shader that could react to a special light source that would allow it to dynamically react to the light's location and distance. Only, such a light source would need to be invisible to the player, since its just being used as a representation of location and distance (with the added benefit of mixing multiple different sources easily). Or is there some other equally fast better way to do this that I'm not thinking of?

Thanks for the help!

EDIT: Imagine a shader that causes a surface to grow outwards when a certain type of object is near it, and its extrusion distance is proportional to the distance and "intensity" (some float) of the object. If there were several of these objects near the surface then it will form a pattern taking into account all of these nearby objects.

Answer 1

Given your edit and the comments about how you're using your data, you should probably look into packing the relevant object data (position, size, etc) into a Structured Buffer for use in your vertex shader.

Don't let the name fool you, the way to do this is through a compute buffer. https://docs.unity3d.com/ScriptReference/ComputeBuffer.html

To use, you create an array of the types on the cpu, set the buffer data, and then set it for the material.

You have a struct

//This struct exists in your shader AND in your script
struct data {
    float3 position;
    float3 scale
}

Your setup on the CPU

//CPU side
var objects = GameObject.FindGameObjectsWithTag("shaderstuff");
var dataArray[];

/*fill your data array here */

// struct has 2 float3's so it's 24 bytes
var buffer = new ComputeBuffer(dataArray.Length,24);
buffer.SetData(dataArray);
material.SetBuffer("dataStuff",buffer);
material.SetInt("_dataCount",dataArray.Length);

your gpu code

//put this with the rest of your uniforms
StructuredBuffer<data> dataStuff;
uniform int _dataCount;

now you can access your data (in your shaders) as if it were an array.