[gladius]

Bueno, el día de ayer estuve creando stocks para trabajar con vectores, rectas en el espacio y planos.

Si es bien recibido continuaré con otros stocks más complicados. Puede ser que algunos no les parezcan útiles o que puedan ser sacados a partir de otros, pero yo creo que está bien.

Si quiere que haga algún ejemplo, me dicen y lo agrego.

PHP Code:

#include <xs>....

/* 
bool:get_intersection_plane_and_line(Float:flVec1Line[3], Float:flVec2Line[3], Float:flVecPlane[4]) 

Las partes involucradas es un plano y una recta en el espacio.
Tenemos 2 puntos de la recta(e.g. start y end) y calculamos su Vector Director 
con la dirección correcta por donde va la recta. (Puede ser cualquier punto de la recta)

Tenemos un plano y es determinada por cada valor del vector (flVecPlane[0]x + flVecPlane[1]y + flVecPlane[2]z + flVecPlane[4]
sabiendo eso obtenemos su normal que es el vector de los valores A, B y C. N = (flVecPlane[0], flVecPlane[1], flVecPlane[2])

Y se compara si el Vector Director es igual a la Normal del Plano.
*/
stock Float:get_intersection_plane_and_line(Float:flVec1Line[3], Float:flVec2Line[3], Float:flVecPlane[4]) 
{
    new Float:flVecDir[3]
    xs_vec_sub(flVec2Line, flVec1Line, flVecDir)

    if(get_vec_line_and_plane_parallel(flVecDir, flVecPlane)) 
    {
        return false
    }
    return true
}

stock Float:get_intersection_two_planes(Float:flVecPlane1[4], Float:flVecPlane2[4]) 
{
    if(get_vec_planes_parallel(flVecPlane1 , flVecPlane2))
    {
        return false
    }
    return true
}

stock Float:get_intersection_two_lines(Float:flVec1Line1[3], Float:flVec2Line1[3], Float:flVec1Line2[3], Float:flVec2Line2[3]) 
{
    new Float:flVecDir1[3], Float:flVecDir2[3]
    xs_vec_sub(flVec2Line1, flVec1Line1, flVecDir1)
    xs_vec_sub(flVec2Line2, flVec1Line2, flVecDir2)
    
    new Float:flVecLine1Line2[3] 
    xs_vec_sub(flVec1Line2, flVec1Line1, flVecLine1Line2)
    
    new Float:flVecDirCross[3] 
    xs_vec_cross(flVecDir1, flVecDir2, flVecDirCross) 

    if(xs_vec_dot(flVecDirCross, flVecLine1Line2))
    {
        return true
    }
    return false
}

stock Float:get_plane_by_points(Float:flVecPoint1[3], Float:flVecPoint2[3], Float:flVecPoint3[3], Float:flVecPlane[4]) 
{
    new Float:flVecPoint1Point2[3], Float:flVecPoint1Point3[3]
    xs_vec_sub(flVecPoint1, flVecPoint2, flVecPoint1Point2)
    xs_vec_sub(flVecPoint1, flVecPoint3, flVecPoint1Point3)
    
    new Float:flVecDirCross[3] 
    xs_vec_cross(flVecPoint1Point2, flVecPoint1Point3, flVecDirCross) 
    
    xs_vec_copy(flVecDirCross, flVecPlane)
    flVecPlane[3] = -(xs_vec_dot(flVecDirCross, flVecPoint1))
}

stock Float:get_dist_point_and_plane(Float:flVecPoint1[3], Float:flVecPlane[4]) 
{
    return (xs_vec_dot(flVecPoint1, flVecPlane) + flVecPlane[3]) / xs_vec_len(flVecPlane)
}

stock Float:get_dist_planes(Float:flVecPlane1[4], Float:flVecPlane2[4]) 
{
    new Float:flVecPlane1Plane2[3]
    xs_vec_sub(flVecPlane1, flVecPlane2, flVecPlane1Plane2)
    
    if(get_vec_planes_parallel(flVecPlane1, flVecPlane2, true)
    {
        return (flVecPlane1[3] - flVecPlane2[3]) / floatsqroot(xs_vec_len(flVecPlane1Plane2))
    }
    return 0;
}

stock Float:get_dist_points(Float:flVecPoint1[3], Float:flVecPoint2[3]) 
{
    new Float:flVecPoint1Point2[3]
    xs_vec_sub(flVecPoint2, flVecPoint1, flVecPoint1Point2)
    
    return floatsqroot(xs_vec_len(flVecPoint1Point2))
}

stock Float:get_dist_point_and_line(Float:flVecPoint[3], Float:flVec1Line[3], Float:flVec2Line[3]) 
{ 
    new Float:flVecDir[3]
    xs_vec_sub(flVec2Line, flVec1Line, flVecDir)
    
    new Float:flVecPointLine[3] 
    xs_vec_sub(flVecPoint, flVec1Line, flVecPointLine)
    
    new Float:flVecDirCross[3] 
    xs_vec_cross(flVecDir1, flVecPointLine, flVecDirCross) 
        
    return xs_vec_len(flVecDirCross) / xs_vec_len(flVecDir1) 
}

stock Float:get_dist_two_lines(Float:flVec1Line1[3], Float:flVec2Line1[3], Float:flVec1Line2[3], Float:flVec2Line2[3]) 
{ 
    new Float:flVecDir1[3], Float:flVecDir2[3]
    xs_vec_sub(flVec2Line1, flVec1Line1, flVecDir1)
    xs_vec_sub(flVec2Line2, flVec1Line2, flVecDir2)
    
    new Float:flVecLine1Line2[3] 
    xs_vec_sub(flVec1Line2, flVec1Line1, flVecLine1Line2)
    
    new Float:flVecDirCross[3] 
    if(get_vec_lines_parallel(flVecDir1, vecDir2)) 
    {         
        xs_vec_cross(flVecLine1Line2, flVecDir1, flVecDirCross) 
        
        return xs_vec_len(flVecDirCross) / xs_vec_len(flVecDir1) 
    } 
    xs_vec_cross(flVecDir1, flVecDir2, flVecDirCross) 
    
    new Float: flDet = fabs(get_line_determinant_order3(flVecLine1Line2, flVecDir1, flVecDir2))
    
    return flDet / xs_vec_len(flVecDirCross)
}

stock bool:get_vec_lines_parallel(Float:flVecLine1[3], Float:flVecLine2[3])
{
    xs_vec_set(flVecLine1, fabs(flVecLine1[0]), fabs(flVecLine1[1]), fabs(flVecLine1[2]))
    xs_vec_set(flVecLine2, fabs(flVecLine2[0]), fabs(flVecLine2[1]), fabs(flVecLine2[2]))
    
    return (xs_vec_equal(flVecLine1, flVecLine2)
}

stock bool:get_vec_line_and_plane_parallel(Float:flVecLine[3], Float:flVecPlane[4])
{
    new flVecNormal[3]
    get_vec_normal_plane(flVecPlane, flVecNormal);
    
    if(xs_vec_dot(flVecNormal, flVecLine))
    {
        return true
    }
    return false
}

/* 
bool:get_vec_planes_parallel(Float:flVecPlane1[4], Float:flVecPlane2[4], nocoincident = false)

Para obtener la intersección de estas se verifica que los cocientes entre sus componentes homólogas son iguales. (A1/A2, B1/B2, C1/C2)
*/
stock bool:get_vec_planes_parallel(Float:flVecPlane1[4], Float:flVecPlane2[4], nocoincident = false)
{
    new Float:flVecPlanesDiv[3]
    xs_vec_set(flVecPlanesDiv, fabs(flVecPlane1[0]/flVecPlane2[0]), fabs(flVecPlane1[1]/flVecPlane2[1]), fabs(flVecPlane1[2]/flVecPlane2[2]))
    
    if(nocoincident)
    {
        return (get_vec_equal(flVecPlanesDiv) && flVecPlane1[3] != flVecPlane2[3])
    }
    return get_vec_equal(flVecPlanesDiv) && flVecPlane1[3]
}

stock get_vec_normal_point(Float:flVecPoint[3], Float:flVecNormalPoint[3])
{
    new Float:flInvLen = 1.0 / floatsqroot(xs_vec_len(flVecPoint))
    xs_vec_mul_scalar(flVecPoint, flInvLen, flVecNormalPoint)
}

stock get_vec_normal_plane(Float:flVecPlane[4], Float:flVecNormalPoint[3])
{
    xs_vec_copy(flVecPlane, flVecNormalPoint)
}

stock get_line_determinant_order3(Float:flVecPoint1[3], Float:flVecPoint2[3], Float:flVecPoint3[3])
{
    new Float:flFirstDiagonal = (flVecPoint1[0] * flVecPoint2[1] * flVecPoint3[2])
    flFirstDiagonal+= (flVecPoint1[1] * flVecPoint2[2] * flVecPoint3[0])
    flFirstDiagonal+= (flVecPoint1[2] * flVecPoint2[0] * flVecPoint3[1])
    
    new Float:flSecondDiagonal = (flVecPoint1[2] * flVecPoint2[1] * flVecPoint3[0])
    flSecondDiagonal+= (flVecPoint1[1] * flVecPoint2[0] * flVecPoint3[2])
    flSecondDiagonal+= (flVecPoint1[0] * flVecPoint2[2] * flVecPoint3[1])
    
    return flFirstDiagonal - flSecondDiagonal;
}

stock get_vec_equal(Float:flVecPoint[3])
{
    if(flVecPoint[0] == flVecPoint[1] && flVecPoint[0] == flVecPoint[2])
    {
        return true;
    }
    return false;
} 


Si necesitan otras funciones relacionadas con vectores me avisan para ayudarles y si es posible agregarlas acá.