Just to be clear im reffering to point lights here like a lamp and not spot lights like a flash light.
Point lights do have a direction you just calculate it on the shader.
What you pass to the shader is its position.
lightDirection = normalize( input.position - lightPosition );
That is typically done in the pixel shader because the direction from the light to the pixel is needed on a pixel by pixel basis for comparision against the interpolated surface normal of pixel for the current triangle.
A sufficiently distant light positions to any pixel is basically omni directional which is why many shaders just take a direction to represent a very distant light source like the sun.
The steps broken down further are as so...
Typically you rotate your pixel position in the vertex shader then set that to another variable.
float3 pos = mul(input.position, World);
output.Position3D = pos.xyz;
One that wont be set to homogenous space when passed to the pixel shader.
float4 Position : SV_Position;
float4 Color : Color0;
float2 TexureCoordinateA : TEXCOORD0;
float3 Position3D : TEXCOORD1;
float3 Normal3D : TEXCOORD2;
//float3 Tangent3D : NORMAL1;
//float3 BiTangent3D : NORMAL2;
Also you pass the light position at the start of your draw then do the first calculation shown typically in the pixel shader but you could do a cheap version possibly less accurate on the vertex shader.
The normal of your model is doted against that to determine if the pixel is backface or not to the light as well as the magnitude of diffuse intensity. This ranges from zero to 1 (negatives need to be clamped or saturated);
The below are common shader calculations the light is represented as L
float3 N = input.Normal3D;
float3 L = normalize(WorldLightPosition - input.Position3D);
float3 C = normalize(CameraPosition - input.Position3D);
float diffuse = saturate(dot(N, L)) * DiffuseAmt; // dot(N, L) is the important part it is the magnitude of the angle between surface normal to the surfaceToLight normal it ranges from 0 to 1 negative vals are NA.
float reflectionTheta = dot(C, reflect(-L, N)); // this is the magnitude of the reflection to your eye ranges from 0 to 1 as negatives should be occluded.
float IsFrontFaceToLight = sign(saturate(dot(L, N))); // 1 is Frontface 0 is Backface the light to surface normal relation.
float4 texelColor = tex2D(TextureSamplerA, input.TexureCoordinateA) * input.Color;
The pixel position distance to the lightPosition determines the depth for the shadow as well.
Using a shadow cube has some pitfalls. If that is the route you are going...
Then i highly suggest you read the below issue there is at least 2 or 3 gotchas when using a render target cube...
I still have a runnable test project at the bottom of this issue as well.
This is from when i was testing and it has a single point light in the shader though im not going to claim this is the best or even a good way to do it. It was done as a proof of concept test.
Markus and pumpkin were a lot of help getting that to work.
Here is a pic from a later test that shows the point light in teal as a cube.
The cube itself was used to draw the shadow map onto for debuging so you can see little dark areas on it which is actually the depth map monochrome then with teal shading to represent the most distant depths beyond some set limit.