Raised This Month: $ Target: $400
 0% 

Solved Line僕ine intersection


Post New Thread Reply   
 
Thread Tools Display Modes
Author Message
CrazY.
Veteran Member
Join Date: May 2015
Location: SP, Brazil
Old 07-03-2019 , 14:31   Re: Line僕ine intersection
Reply With Quote #1

Sure. Red laser is the first line, blue is the second line. As you can see, the lines aren't intersected but the code is returning true.




PHP Code:
#include <amxmodx>
#include <beams>
#include <engine>
#include <xs>

new const SPR_LASERBEAM[] = "sprites/laserbeam.spr";

enum
{
    
pitch// x
    
yaw// y
    
roll // z
};

enum (<<= 1)
{
    
INTERSECT_YX 1,
    
INTERSECT_XZ,
    
INTERSECT_ZY,
};

const 
INTERSECT_NONE 0;
const 
INTERSECT_YX = (1<<0);
const 
INTERSECT_XZ = (1<<1);
const 
INTERSECT_ZY = (1<<2);
const 
INTERSECT_3D = (INTERSECT_YX INTERSECT_XZ INTERSECT_ZY);

new const 
DIMENSIONS[][] = 
{
    { 
yawpitch },
    { 
rollyaw },
    { 
pitchroll }
};

new 
g_beam1g_beam2;

public 
plugin_init()
{
    
register_plugin("env_beam""1.0""CrazY.");
    
register_clcmd("say /beam""cmd_beam");

    
g_beam1 Beam_Create(SPR_LASERBEAM10.0);
    
Beam_SetColor(g_beam1Float:{150.00.00.0});
    
Beam_SetFrame(g_beam110.0);
    
Beam_SetScrollRate(g_beam1255.0);
    
Beam_SetBrightness(g_beam1200.0);
    
Beam_SetType(g_beam1BEAM_POINTS);

    
g_beam2 Beam_Create(SPR_LASERBEAM10.0);
    
Beam_SetColor(g_beam2Float:{0.00.0150.0});
    
Beam_SetFrame(g_beam210.0);
    
Beam_SetScrollRate(g_beam2255.0);
    
Beam_SetBrightness(g_beam2200.0);
    
Beam_SetType(g_beam2BEAM_POINTS);

    
set_task(1.0"task_beam", .flags="b");
}

public 
plugin_precache()
{
    
precache_model(SPR_LASERBEAM);
}

public 
cmd_beam(id)
{
    
show_menu_beam(id);
    return 
PLUGIN_HANDLED;
}

show_menu_beam(id)
{
    new 
menu menu_create("env_beam""menu_beam");

    
menu_additem(menu"Set start pos (beam1)");
    
menu_additem(menu"Set end pos (beam1)^n");
    
menu_additem(menu"Set start pos (beam2)");
    
menu_additem(menu"Set end pos (beam2)");

    
menu_display(idmenu);
}

public 
menu_beam(idmenuitem)
{
    
menu_destroy(menu);

    new 
Float:origin[3];
    
entity_get_vector(idEV_VEC_originorigin);
    
    switch (
item)
    {
        case 
0:
        {
            
Beam_SetStartPos(g_beam1origin);
            
Beam_RelinkBeam(g_beam1);
            
show_menu_beam(id);
        }
        case 
1:
        {
            
Beam_SetEndPos(g_beam1origin);
            
Beam_RelinkBeam(g_beam1);
            
show_menu_beam(id);
        }
        case 
2:
        {
            
Beam_SetStartPos(g_beam2origin);
            
Beam_RelinkBeam(g_beam2);
            
show_menu_beam(id);
        }
        case 
3:
        {
            
Beam_SetEndPos(g_beam2origin);
            
Beam_RelinkBeam(g_beam2);
            
show_menu_beam(id);
        }
    }

    return 
PLUGIN_HANDLED;
}

public 
task_beam()
{
    new 
Float:b1_start_pos[3], Float:b1_end_pos[3];
    new 
Float:b2_start_pos[3], Float:b2_end_pos[3];

    
Beam_GetStartPos(g_beam1b1_start_pos);
    
Beam_GetEndPos(g_beam1b1_end_pos);

    
Beam_GetStartPos(g_beam2b2_start_pos);
    
Beam_GetEndPos(g_beam2b2_end_pos);

    if (
DoesVectorsIntersect(b1_start_posb1_end_posb2_start_posb2_end_pos) & INTERSECT_3D)
        
client_print(0print_center"intersect = TRUE");
    else
        
client_print(0print_center"intersect = FALSE");
}

DoesVectorsIntersect(const Float:fV1Init[3], const Float:fV1Final[3], const Float:fV2Init[3], const Float:fV2Final[3], Float:fPoint[3] = {0.00.00.0})
{
    new 
Float:fFactorV1[3], Float:fFactorV2[3], g_return;
    
    for(new 
Float:Xi3i++)
    {
          
fFactorV1[i] = (fV1Final[DIMENSIONS[i][0]] - fV1Init[DIMENSIONS[i][0]]) / (fV1Final[DIMENSIONS[i][1]] - fV1Init[DIMENSIONS[i][1]]);
          
fFactorV2[i] = (fV2Final[DIMENSIONS[i][0]] - fV2Init[DIMENSIONS[i][0]]) / (fV2Final[DIMENSIONS[i][1]] - fV2Init[DIMENSIONS[i][1]]);
          
          
= ((fV2Final[DIMENSIONS[i][0]] - fV1Final[DIMENSIONS[i][0]]) + (fFactorV2[i] * fV2Final[DIMENSIONS[i][1]]) - (fFactorV1[i] * fV1Final[DIMENSIONS[i][1]])) / (fFactorV2[i] - fFactorV1[i]);
          if(((
fFactorV1[i] * (fV1Final[DIMENSIONS[i][1]] - X) + fV1Final[DIMENSIONS[i][0]])) == (fFactorV2[i] * (fV2Final[DIMENSIONS[i][1]] - X) + fV2Final[DIMENSIONS[i][0]]))
           {
                   
fPoint[DIMENSIONS[i][1]] = X;
                   switch( 
)
                   {
                          case 
0g_return |= INTERSECT_YX;
                          case 
2g_return |= INTERSECT_XZ;
                          case 
1g_return |= INTERSECT_ZY;
                   }
           }

           
    }
    return 
g_return;
}

/*public static bool ClosestPointsOnTwoLines(out Vector3 closestPointLine1, out Vector3 closestPointLine2, Vector3 linePoint1, Vector3 lineVec1, Vector3 linePoint2, Vector3 lineVec2){
 
        closestPointLine1 = Vector3.zero;
        closestPointLine2 = Vector3.zero;
 
        float a = Vector3.Dot(lineVec1, lineVec1);
        float b = Vector3.Dot(lineVec1, lineVec2);
        float e = Vector3.Dot(lineVec2, lineVec2);
 
        float d = a*e - b*b;
 
        //lines are not parallel
        if(d != 0.0f){
 
            Vector3 r = linePoint1 - linePoint2;
            float c = Vector3.Dot(lineVec1, r);
            float f = Vector3.Dot(lineVec2, r);
 
            float s = (b*f - c*e) / d;
            float t = (a*f - c*b) / d;
 
            closestPointLine1 = linePoint1 + lineVec1 * s;
            closestPointLine2 = linePoint2 + lineVec2 * t;
 
            return true;
        }
 
        else{
            return false;
        }
    }    */

/*intersection(Float:vec1_start[3], Float:vec1_end[3], Float:vec2_start[3], Float:vec2_end[3])
{
    new Float:factorA[3], Float:factorB[3], ret, Float:num;

    for (new axis = 0; axis < 3; axis++)
    {
        factorA[axis] = (vec1_end[DIMENSIONS[axis][0]] - vec1_start[DIMENSIONS[axis][0]]) / (vec1_end[DIMENSIONS[axis][1]] - vec1_start[DIMENSIONS[axis][1]]);
        factorB[axis] = (vec2_end[DIMENSIONS[axis][0]] - vec2_start[DIMENSIONS[axis][0]]) / (vec2_end[DIMENSIONS[axis][1]] - vec2_start[DIMENSIONS[axis][1]]);
        num = ((vec2_end[DIMENSIONS[axis][0]] - vec1_end[DIMENSIONS[axis][0]]) + (factorB[axis] * vec2_end[DIMENSIONS[axis][1]]) - (factorA[axis] * vec1_end[DIMENSIONS[axis][1]])) / (factorB[axis] - factorA[axis]);
    
        if (((factorA[axis] * (vec1_end[DIMENSIONS[axis][1]] - num) + vec1_end[DIMENSIONS[axis][0]])) == ((factorB[axis] * (vec2_end[DIMENSIONS[axis][1]] - num) + vec2_end[DIMENSIONS[axis][0]])))
        {
            switch (axis)
            {
                case pitch: ret |= INTERSECT_YX;
                case yaw: ret |= INTERSECT_XZ;
                case roll: ret |= INTERSECT_ZY;
            }
        }
    }

    return ret;
}*/

/*DoesVectorsIntersect(const Float:fV1Init[3], const Float:fV1Final[3], const Float:fV2Init[3], const Float:fV2Final[3], Float:fPoint[3])
{
    new Float:fFactorV1[3], Float:fFactorV2[3], g_return;
    
    for(new Float:X, i; i < 3; i++)
    {
          fFactorV1[i] = (fV1Final[iaDimensions[i][0]] - fV1Init[iaDimensions[i][0]]) / (fV1Final[iaDimensions[i][1]] - fV1Init[iaDimensions[i][1]]);
          fFactorV2[i] = (fV2Final[iaDimensions[i][0]] - fV2Init[iaDimensions[i][0]]) / (fV2Final[iaDimensions[i][1]] - fV2Init[iaDimensions[i][1]]);
          
          X = ((fV2Final[iaDimensions[i][0]] - fV1Final[iaDimensions[i][0]]) + (fFactorV2[i] * fV2Final[iaDimensions[i][1]]) - (fFactorV1[i] * fV1Final[iaDimensions[i][1]])) / (fFactorV2[i] - fFactorV1[i]);
          if(((fFactorV1[i] * (fV1Final[iaDimensions[i][1]] - X) + fV1Final[iaDimensions[i][0]])) == (fFactorV2[i] * (fV2Final[iaDimensions[i][1]] - X) + fV2Final[iaDimensions[i][0]]))
           {
                   fPoint[iaDimensions[i][1]] = X;
                   switch( i )
                   {
                          case 0: g_return |= VECTORS_INTERSECT_YX;
                          case 2: g_return |= VECTORS_INTERSECT_XZ;
                          case 1: g_return |= VECTORS_INTERSECT_ZY;
                   }
           }

           
    }
    return g_return;
}*/ 
Quote:
BTW if You noticed the function doesn't return true it returns bitsum values
Yea, true I meant VECTORS_INTERSECT_3D.
__________________









Last edited by CrazY.; 07-03-2019 at 14:32.
CrazY. is offline
Reply



Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off

Forum Jump


All times are GMT -4. The time now is 17:21.


Powered by vBulletin®
Copyright ©2000 - 2024, vBulletin Solutions, Inc.
Theme made by Freecode