I know about 10/distance, but I don’t know how to make it noticeably smaller the farther it is.
The most I have is local size = 10/((part1.Position - pos).Magnitude).
(pos being the raycast result pos, part1 is the origin)

UnitRay is the position you shot the ray towards except with exactly 1 magnitude (you can use Vector3.Unit to turn any vector into an unit vector) LookVector is the part’s CFrame.LookVector and DefSize is the biggest size possible you want as a Vector3.

You might have to tweak things a bit as this will be a bit too linear and hard to notice but Vector3:Dot returns a number so you should be able to do a lot with it.

This is because the rays arent too far away from eachother, you can try mapping the numbers you get to a more suitable range by multiplying them and subtracting the lowest amount you can get possible

this would make it smaller as you look away from the object, dot products are positive when the two vectors point in the same direction, 0 when one points at a right angle, and negative when the vectors point away from each other. Wolfire explains this by using dot products to calculate line-of-sight.

Your distance calculation is correct, more scaling may be what you need. When using it as a divisor you end up getting smaller and smaller results, the scaling factor will drop off instead of turning negative.

if you want linear scaling (with a minimum) you could use this local scale = math.max(0.1, 10 - magnitude)

Also the example you’ve provided might have some randomness added to it as there are smaller circles closer to middle than some larger ones etc. so after getting scaling properly you could try adding some randomness via math.random().

Well I tried it and it does kinda work, but its either really small or really big(up to 10) so I changed the max to 1 and now its only small. they are all pretty much the same size, the only thing that changes the size is putting the part farther away

Ah I think I misunderstood what you wanted. I think it would help to post the script you are working with. @TheFirepc_TRofical was correct the dot product can get you smaller sizes as the rays hit farther from the center.

local part1 = script.Parent
-- axis: center line of cone
-- angle: angle from center to edge of cone
-- returns: a random unit vector inside the cone, evenly distributed along the partial surface of a unit sphere.
for i = 1,100 do
local function RandomCone(axis: Vector3, angle: number)
local cosAngle = math.cos(angle)
local z = 1 - math.random()*(1 - cosAngle)
local phi = math.random()*math.pi*2
local r = math.sqrt(1 - z*z)
local x = r * math.cos(phi)
local y = r * math.sin(phi)
local vec = Vector3.new(x, y, z)
if axis.Z > 0.9999 then
return vec
elseif axis.Z < -0.9999 then
return -vec
end
local orth = Vector3.zAxis:Cross(axis)
local rot = math.acos(axis:Dot(Vector3.zAxis))
return CFrame.fromAxisAngle(orth, rot) * vec
end
local function GetPartsInFrontRay(start)
local params = RaycastParams.new()
params.FilterDescendantsInstances = {start}
params.FilterType = Enum.RaycastFilterType.Blacklist
local vector = part1.CFrame.LookVector
--local origin = part1.Position
---- origin can be your lookvector, it doesn't matter too much, it just needs to be a position
--local Spread = 5 -- in studs, large amound so you know it more noticable
----local mouseposition = player:GetMouse.Hit.Position -- get the position of the mouse's position in 3d space
--local mouseposition = part1.CFrame.LookVector
--local offset = Vector3.new(math.random(-Spread,Spread),math.random(-Spread,Spread),math.random(-Spread,Spread))
--mouseposition = mouseposition + offset -- add the offset to the end position ( in this case the mouse position)
--local Direction = (mouseposition - origin).Unit -- direction
--local rayresult = workspace:Raycast(origin,direction*100,raycastparams) -- all together now, cast the ray!
-- angle of the cone, i.e. the largest angle off the firing axis you could be
local SPREAD = math.rad(15)
-- speed of the bullet (can also be random if you want)
--part1.AssemblyLinearVelocity = RandomCone(part1.CFrame.LookVector, SPREAD)
local ray = workspace:Raycast(start.Position, RandomCone(part1.CFrame.LookVector, SPREAD) * 150, params)
if ray and ray.Instance then
return ray.Instance,ray.Normal,ray.Position
end
end
local part,normal,pos = GetPartsInFrontRay(part1)
if part then
warn(part.Name)
local water = game.ReplicatedStorage.water:Clone()
water.Parent = workspace
water.CFrame = CFrame.new(pos, pos+normal)
water.WeldConstraint.Part1 = part
local size = 10/((part1.Position - pos).Magnitude)
local DefSize = 1
--local size = DefSize * pos.Unit:Dot(part1.CFrame.LookVector)
water.Size = Vector3.new(size,size,0.1)
else
print("ugh")
end
end

The part im working on is a bit down, right under if part then

untested, this may not work at all but if it does work hopefully it will be what you want

you can calculate the max distance as the edge length of your cone with the height being the distance of a raycast going straight through the center of said cone

local D = Distance/MaxDistance
local MinSize = 1
local MaxSize = 5
local Size = -MaxSize * D*(D-2) + MinSize;

if you are having issues just swap min and max size to reverse it. And there can be as much scaling as you like? at the edge of your cone, it will be the min size and at the center, it will be the max so just play around with the values

Do you want the size of the parts to scale as they are initially created, based on the angle of their direction vector to the RandomCone’s axis vector?

Or do you want the size of the parts to scale when their raycast hits something, based on the distance between their hit Position and the hit Position of a raycast cast along the cone’s central axis?