Shorten Raycast - Line Renderer

here is a thought, you can use the "slope" (well in unity it easier to use an angle) of the line between those two to get a direction. then rotate Vector3.fwd*5 by that direction. Its basically aligning a shorter vector between the ball and hit target point.

1. Get the Y-angle between the two points.

2. Convert it to a Quaternion(man i hate these things)

3. Multiply the product of Quaternion and the balls fwd vector by 5.

4. use it in the Line Direction code.

so we can use

 PSEUDO code
 a = Vector3.Angle(ballPos, hitpos) 
 and q = Quetrion.Euler (0,a,0);
 lineDirection = q*ballpos.fwd*5;

this way the line direction will always have an "length" of 5.

citation : http://quiz.uprm.edu/visual3d/manual/coor_sys/slope_line.html

http://en.wikipedia.org/wiki/Quaternion (again, I still hate these things)

Update: I overlooked some details, ported and tested you code and got it working

 var ballRadius = 0.49;
 var contactPointSize = 0.1;
 var rayLength : float = 30;
 var direction = player.transform.TransformDirection(-Vector3.forward);
  
 var hit : RaycastHit;
 Physics.Raycast(transform.position, direction, hit, rayLength);
 var newDirection = new Vector3();
  
 newDirection = Vector3(hit.normal.x, hit.normal.y, hit.normal.z);
 newDirection *= -1;
 var hitPos = hit.collider.transform.position;
  
 lineDirection.SetPosition(0, hit.collider.transform.position);
  
 var deflection = Vector3((newDirection.x * rayLength), hitPos.y, (newDirection.z * rayLength));
 deflection = (deflection -hitPos).normalized * 5 + hitPos;
 var newDeflec = (hitPos + deflection) / 2;  //probably don't need this.
  
 lineDirection.SetPosition(1, deflection);
 
     

I have no idea why the other versions of this code messed up for you. division screws up because it transforms based on zero as i said earlier in the comments below(when you wanted to transform it based on hitpos). when calculating the length of deflection(magnitude), remember to subtract hitpos or you will get the distance between deflection and zero instead. also on Quaternion's still hate them.

Here we use the RayCastHit.point if applicable, or the point maxRayLength in that direction if no hit occurs.

This technique should allow you to find the right endpoint for your second LineRenderer.

     var direction: Vector3; //value should be derived from previous collision
     var lineStart: Vector3; //value should be derived from previous collision
     var maxRayLength: float =  5;
     var lineEnd: Vector3; 
     var hit:RaycastHit;
     if(Physics.Raycast(lineStart, direction, hit, maxRayLength)) {
         lineEnd = hit.point;
     }    
     else {
         //assumes direction is of length 1, change to direction.normalized if required.
         lineEnd = lineStart + (direction * maxRayLength); 
     }

     //the following for illustrative purposes only:
     var lr:LineRenderer = gameObject.GetComponent(LineRenderer);
     lr.useWorldSpace = true;
     lr.SetPosition(0,lineStart);
     lr.SetPosition(1,lineEnd);
 
     Debug.DrawRay(lineStart, lineEnd - lineStart, Color.red, 1.0f);        
     

Update:

Here is a more complete implementation. The results illustrated can be achieved by placing this script on a GameObject, and then assigning some with LineRenderers to lr1 and lr2.

 var lr2:LineRenderer;
 var lr1:LineRenderer;
 var direction:Vector3 = new Vector3(1,1,0);
 var rayLength : float = 30;
 var guideLength:float = 5;
 
 function Update () {
     var initialPosition: Vector3 = transform.position;
     var impactPoint: Vector3;
     var guideEndPoint: Vector3;
     var hit:RaycastHit;
     
     if (!Physics.Raycast(initialPosition, direction, hit, rayLength)) {
         // handle a miss
         Debug.DrawRay(initialPosition, direction.normalized * rayLength, Color.blue, 1.0f, true);    
         lr1.enabled = false;
         lr2.enabled = false;
         return; 
     }
 
     impactPoint = hit.point;
     guideEndPoint = impactPoint + ( -hit.normal * guideLength );
     
     //draw rays for IDE
     Debug.DrawRay(initialPosition, impactPoint - initialPosition, Color.green, 1.0f, true);    
     Debug.DrawRay(impactPoint, guideEndPoint - impactPoint, Color.red, 1.0f, true);    
     
     //draw lineRenderers for GameScreen
     lr1.enabled = true;
     lr2.enabled = true;
     lr1.SetPosition(0, initialPosition);
     lr1.SetPosition(1, impactPoint);
     lr2.SetPosition(0, impactPoint);
     lr2.SetPosition(1, guideEndPoint);
 }

If you want to draw a line of fixed length from a known starting position and following some fixed direction then you can compute the two end points like this:

 // Code snippet
 
 var separation : Vector3 = transform.position - player.transform.position;
 
 var tangent : Vector3 = Vector3.Normalize(separation) * lineLength;
 
 var start : Vector3 = transform.position;
 var end : Vector3 = start + tangent;

To give you a little more of a hint, I've created a Unity scene and some script code that shows just how to do this. Take a look here for details: the computation of the line you care about is all in the "TargetBall" script/