[Emp`]

Originally Posted by ConnorMcLeod Engine module won't be auto-loaded by a public function (forward).

I was only commenting on:

Though I would think it would say something like the function is not used in the compiler output

Most likely the module is being loaded by another plugin.

[ConnorMcLeod]

My post was for bad bud

[epic .]

This is a very good TUT

[ConnorMcLeod]

Sticked, even if it is indexed in arkshine sticked thread, i think it is usefull to have it under our eyes !!

[dFF]

I have some confuse about Engine vs Fakemeta on playing with origins on custom entity.

Here is the test code:

Spoiler

PHP Code:

#include < amxmodx >
#include < fakemeta >
#include < engine >

new Float:origin[ 3 ]

new const szClass[ ] = "custom"
new const szClass2[ ] = "custom2"

new const szModel[ ] = "models/w_m4a1.mdl"
new const szModel2[ ] = "models/w_ak47.mdl"

public plugin_precache()
{
    precache_model( szModel )
    precache_model( szModel2 )
}

public plugin_init()
{
    register_clcmd( "cr_custom", "cr_custom" )
    
    register_think( szClass, "custom_think" )
    register_think( szClass2, "custom_think2" )
}

public cr_custom( id )
{
    new iEnt = create_entity( "info_target" )
    assert iEnt
    
    entity_set_string( iEnt, EV_SZ_classname, szClass )
    entity_get_vector( id, EV_VEC_origin, origin )
    entity_set_origin( iEnt, origin )
    entity_set_model( iEnt, szModel )
    entity_set_float( iEnt, EV_FL_nextthink, get_gametime() + 0.1 )
    
    iEnt = create_entity( "info_target" ) // create_entity best that EngFunc_CreateNamedEntity + AllocString
    assert iEnt
    
    set_pev( iEnt, pev_classname, szClass2 ) // Confuse for me: set_pev_string only for allocate string !?
    pev( id, pev_origin, origin )
    engfunc( EngFunc_SetOrigin, iEnt, origin )
    engfunc( EngFunc_SetModel, iEnt, szModel2 )
    set_pev( iEnt, pev_nextthink, get_gametime() + 0.1 )
}

public custom_think( iEnt )
{
    if( is_valid_ent( iEnt ) )
    {
        entity_get_vector( iEnt, EV_VEC_origin, origin )
        origin[ 2 ] += 5.0
        entity_set_origin( iEnt, origin )
        
        entity_set_float( iEnt, EV_FL_nextthink, get_gametime() + 0.1 )
    }
}

public custom_think2( iEnt )
{
    if( pev_valid( iEnt ) )
    {
        pev( iEnt, pev_origin, origin )
        origin[ 2 ] += 5.0
        engfunc( EngFunc_SetOrigin, iEnt, origin )
        
        set_pev( iEnt, pev_nextthink, get_gametime() + 0.1 )
    }
} 


here is the profile test: (test during ~30 seconds)

Spoiler

date: Mon Jul 30 22:26:26 2012 map: de_dust2
type |                             name |      calls | time / min / max
-------------------------------------------------------------------
   n |                   precache_model |          2 | 0.001004 / 0.000421 / 0.000583
   n |                   register_clcmd |          1 | 0.000008 / 0.000008 / 0.000008
   n |                   register_think |          2 | 0.000010 / 0.000003 / 0.000008
   n |                    create_entity |          2 | 0.000030 / 0.000004 / 0.000026
   n |                entity_set_string |          1 | 0.000004 / 0.000004 / 0.000004
   n |                entity_get_vector |        122 | 0.000395 / 0.000002 / 0.000156
   n |                entity_set_origin |        122 | 0.000726 / 0.000004 / 0.000010
   n |                 entity_set_model |          1 | 0.000012 / 0.000012 / 0.000012
   n |                     get_gametime |        244 | 0.000232 / 0.000001 / 0.000001
   n |                 entity_set_float |        122 | 0.000151 / 0.000001 / 0.000001
   n |                          set_pev |        123 | 0.000163 / 0.000001 / 0.000003
   n |                              pev |        122 | 0.000273 / 0.000002 / 0.000003
   n |                          engfunc |        123 | 0.000466 / 0.000003 / 0.000015
   n |                     is_valid_ent |        121 | 0.000196 / 0.000001 / 0.000002
   n |                        pev_valid |        121 | 0.000180 / 0.000001 / 0.000012
   p |                        cr_custom |          1 | 0.000016 / 0.000016 / 0.000016
   p |                     custom_think |        121 | 0.001218 / 0.000006 / 0.000384
   p |                    custom_think2 |        121 | 0.000890 / 0.000006 / 0.000151
   p |                      plugin_init |          1 | 0.000005 / 0.000005 / 0.000005
   p |                  plugin_precache |          1 | 0.000007 / 0.000007 / 0.000007
1 natives, 0 public callbacks, 5 function calls were not executed.

not sure if test code is the best, but seem the fakemeta natives is a little fast that engine, like on natives:
pev_valid - is_valid_ent
EngFunc_SetOrigin - entity_set_origin

not sure if i have right, so wait to anybody clarify this confuse for me. What is best variant to use origins (get/set) on custom entity (who call very fast), engine or fakemeta ?

[Arkshine]

Don't trust too much the profiler...

Engine is slightly faster because it generally contains less code. But in your example, even if engine is should be faster, you won't see any significant change and you should not bother about performance here, therefore you should use the way you prefer.

[dFF]

Ok, thank you for reply. Also if anybody still have minor confusion can see the natives source.

Spoiler

Engine:

int is_ent_valid(int iEnt)
{
    if (iEnt < 1 || iEnt > gpGlobals->maxEntities) 
        return 0;

    if (iEnt <= gpGlobals->maxClients)
    {
        if (!MF_IsPlayerIngame(iEnt))
        {
            return 0;
        }
    } else {
        if (FNullEnt(INDEXENT(iEnt)))
        {
            return 0;
        }
    }

    return 1;
}

static cell AMX_NATIVE_CALL is_valid_ent(AMX *amx, cell *params)
{
    return is_ent_valid(params[1]);
}

static cell AMX_NATIVE_CALL entity_set_origin(AMX *amx, cell *params)
{
    int iEnt = params[1];

    CHECK_ENTITY_SIMPLE(iEnt);
    
    edict_t *pEnt = INDEXENT2(iEnt);
    cell *vVector = MF_GetAmxAddr(amx, params[2]);
    REAL fX = amx_ctof(vVector[0]);
    REAL fY = amx_ctof(vVector[1]);
    REAL fZ = amx_ctof(vVector[2]);
    Vector vOrigin = Vector(fX, fY, fZ);

    SET_SIZE(pEnt, pEnt->v.mins, pEnt->v.maxs);
    SET_ORIGIN(pEnt, vOrigin);

    return 1;
}

Spoiler

Fakemeta:

// pev_valid
static cell AMX_NATIVE_CALL amx_pev_valid(AMX *amx, cell *params)
{
    int idx = static_cast<int>(params[1]);

    edict_t *e = INDEXENT(idx);

    if (FNullEnt(e))
        return 0;

    if (e->pvPrivateData)
        return 2;

    return 1;
}

#define CHECK_ENTITY(x) if (x != 0 && (FNullEnt(INDEXENT_NEW(x)) || x < 0 || x > gpGlobals->maxEntities)) return 0;

static cell AMX_NATIVE_CALL engfunc(AMX *amx, cell *params)
{
    .... some code ....
    // pfnSetOrigin
    case    EngFunc_SetOrigin:            // void )                (edict_t *e, const float *rgflOrigin);
        cRet = MF_GetAmxAddr(amx,params[2]);
        index = cRet[0];
        CHECK_ENTITY(index);
        cRet = MF_GetAmxAddr(amx,params[3]);
        Vec1[0]=amx_ctof(cRet[0]);
        Vec1[1]=amx_ctof(cRet[1]);
        Vec1[2]=amx_ctof(cRet[2]);
        (*g_engfuncs.pfnSetOrigin)(INDEXENT2(index),Vec1);
        return 1;
}

[ConnorMcLeod]

The main thing is to not use 3 natives with FM when another module native can do the same.
But when 2 natives from different modules do the same thing, it doesn't really matter.

[codeplus]

hey Thanks

[greenac]

tasks are not suitable for profiling it seems