Cryengine V : Разбор основ (5 стр)

void CPlayer::RaycastView()
{
  int hit = 0;
  Vec3 origin = m_pView->GetViewWorldPosition();
  Vec3 dir = m_pView->GetViewWorldDirection();
  ray_hit rayHit;

  const int physSkipNum = 1;
  IPhysicalEntity* physSkip[physSkipNum];
  physSkip[0] = GetEntity()->GetPhysics();

  unsigned int flags = rwi_stop_at_pierceable | rwi_colltype_any | rwi_ignore_back_faces;

  float RayMaxDistance = 100.0f;

  hit = gEnv->pPhysicalWorld->RayWorldIntersection(origin, dir*RayMaxDistance, entity_query_flags::ent_all, flags, &rayHit, 1, physSkip, physSkipNum);
  if (hit)
  {
    IPersistantDebug* debug = gEnv->pGame->GetIGameFramework()->GetIPersistantDebug();
    debug->Begin("TestAddDirection", false);

    Vec3 lineStart = origin;
    Vec3 lineEnd = rayHit.pt;
    float timeOut = 4.0f;

    debug->AddLine(lineStart, lineEnd, ColorF(1.0f, 0.0f, 0.0f), timeOut);
  }
}

#include "StdAfx.h"
#include "MyFlowNode.h"

#include "FlowNodes/Helpers/FlowBaseNode.h"

REGISTER_FLOW_NODE("MyFlowNodes:MyFlowNode", CFlowNode_MyName);

CFlowNode_MyName::CFlowNode_MyName(SActivationInfo* pActInfo)
{
  // This means from now on you will get ProcessEvent calls with eFE_Update event.
  // To be removed again from this list call the same function with false as the second parameter.
  // Frequency: you will get 1 ProcessEvent(eFE_Updated) call per Game update call.
  pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true);
};

IFlowNodePtr CFlowNode_MyName::Clone(SActivationInfo *pActInfo)
{
  return new CFlowNode_MyName(pActInfo);
};

void  CFlowNode_MyName::GetMemoryUsage(ICrySizer* pSizer) const
{
  pSizer->AddObject(this, sizeof(*this));
}

void CFlowNode_MyName::GetConfiguration(SFlowNodeConfig& config)
{
  // name - Do not use the underscore character '_' in port names

  static const SInputPortConfig in_config[] = {
    InputPortConfig<int>("someInput", _HELP("useful help text"),0, _UICONFIG("v_min=0, v_max=10")),
    InputPortConfig<int>("someInput2", _HELP("useful help text2"),0, _UICONFIG("enum_int:Relaxed=0,Alert=1,Combat=2,Crouch=3")),
    InputPortConfig<string>("someInput2", _HELP("useful help text2"),0, _UICONFIG("enum_string:antohska,kartosha,dolbaejka")),
    { 0 }
  };
  static const SOutputPortConfig out_config[] = {
    OutputPortConfig<int>("alertness", _HELP("useful help text")),
    { 0 }
  };

  config.sDescription = _HELP("A description of this flow node");
  config.pInputPorts = in_config;
  config.pOutputPorts = out_config;
  config.SetCategory(EFLN_APPROVED);
}

void CFlowNode_MyName::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
{
  switch (event)
  {
  // *** Call per Game update call.
  case  eFE_Update: 
  {
    //static int g = 0;
    //
    //// Send event to FG output port 
    //TFlowInputData output;
    //output.Set<int>(g++);
    //output.SetUserFlag(true);
    //ActivateOutput(pActInfo, 0, output);
    break;
  }
  // *** If one or more input ports have been activated.
  case eFE_Activate:
  {
    if (IsPortActive(pActInfo, eInputPort_SomeInput0))
    {
      TFlowInputData* inputValue = pActInfo->GetInputPort(eInputPort_SomeInput0);
      int* value = inputValue->GetPtr<int>();

      // TODO : 
      if (value)
      {
        // increment and return
        TFlowInputData output;
        output.Set<int>(*value++);
        output.SetUserFlag(true);
        ActivateOutput(pActInfo, eOutputPorts_Alertness, output);
      }
    } 
    else if (IsPortActive(pActInfo, eInputPort_SomeInput1))
    {
      TFlowInputData* inputValue = pActInfo->GetInputPort(eInputPort_SomeInput1);
      int* value = inputValue->GetPtr<int>();

      // TODO : 
      if (value)
      {
        // multiply by 2 and return
        TFlowInputData output;
        output.Set<int>((*value) * 2);
        output.SetUserFlag(true);
        ActivateOutput(pActInfo, eOutputPorts_Alertness, output);
      }
    }
    else if (IsPortActive(pActInfo, eInputPort_SomeInput2))
    {
      TFlowInputData* inputValue = pActInfo->GetInputPort(eInputPort_SomeInput2);
      string* value = inputValue->GetPtr<string>();
      

      // TODO : 
      if (value)
      {
        // return selected string len
        TFlowInputData output;
        output.Set<int>(value->length());
        output.SetUserFlag(true);
        ActivateOutput(pActInfo, eOutputPorts_Alertness, output);
      }
    }

    break;
  }
  default:
    break;
  };
}

enum ETextureFlags
{
  FT_NOMIPS                  = BIT(0),  // TR: don't allocate or use any mip-maps (even if they exist)
  FT_TEX_NORMAL_MAP          = BIT(1),  // T: indicator that a texture contains normal vectors (used for tracking statistics, debug messages and the default texture)
  FT_TEX_WAS_NOT_PRE_TILED   = BIT(2),  // REMOVE
  FT_USAGE_DEPTHSTENCIL      = BIT(3),  // R: use as depth-stencil render-target
  FT_USAGE_ALLOWREADSRGB     = BIT(4),  // TR: allows the renderer to cast the texture-format to a sRGB type if available
  FT_FILESINGLE              = BIT(5),  // T: suppress loading of additional files like _DDNDIF (faster, RC can tag the file for that)
  FT_TEX_FONT                = BIT(6),  // T: indicator that a texture contains font glyphs (used solely for tracking statistics!)
  FT_HAS_ATTACHED_ALPHA      = BIT(7),  // T: indicator that the texture has another texture attached (see FT_ALPHA)
  FT_USAGE_UNORDERED_ACCESS  = BIT(8),  // R: allow write-only UAVs for the texture object
  FT______________________   = BIT(9),  // UNUSED
  FT_USAGE_MSAA              = BIT(10), // R: use as MSAA render-target
  FT_FORCE_MIPS              = BIT(11), // TR: always allocate mips (even if normally this would be optimized away)
  FT_USAGE_RENDERTARGET      = BIT(12), // R: use as render-target
  FT_USAGE_DYNAMIC           = BIT(13), // R: indicator that the textures are provided by a generator (scaleform, procedual, ...)
  FT_STAGE_READBACK          = BIT(14), // R: allow read-back of the texture contents by the CPU through a persistent staging texture (otherwise the staging is dynamic)
  FT_STAGE_UPLOAD            = BIT(15), // R: allow up-load of the texture contents by the CPU through a persistent staging texture (otherwise the staging is dynamic)
  FT_DONT_RELEASE            = BIT(16), // TR: texture will not be freed automatically when ref counter goes to 0. Use ReleaseForce() to free the texture.
  FT_ASYNC_PREPARE           = BIT(17), // T: run the streaming preparation of this texture asynchronously
  FT_DONT_STREAM             = BIT(18), // T: prevent progressive streaming-in/out of the texture, it's fully loaded or not at all
  FT_______________________  = BIT(19), // UNUSED
  FT_FAILED                  = BIT(20), // TR: indicator that the allocation of the texture failed the last time it has been tried, for render-targets this is fatal
  FT_FROMIMAGE               = BIT(21), // T: indicator that the textures originates from disk
  FT_STATE_CLAMP             = BIT(22), // T: set the sampling mode to clamp in the corresponding sampler-state
  FT_USAGE_ATLAS             = BIT(23), // R: indicator that the texture's contents form an atlas or flip-book (used solely for tracking statistics!)
  FT_ALPHA                   = BIT(24), // T: indicator that this is a texture attached to another one (see FT_HAS_ATTACHED_ALPHA)
  FT_REPLICATE_TO_ALL_SIDES  = BIT(25), // T: Replicate single texture to all cube-map sides on allocation and on file-load
  FT_KEEP_LOWRES_SYSCOPY     = BIT(26), // ?: keep low res copy in system memory for voxelization on CPU
  FT_SPLITTED                = BIT(27), // T: indicator that the texture is available splitted on disk
  FT_STREAMED_PREPARE        = BIT(28), // REMOVE
  FT________________________ = BIT(29), // UNUSED
  FT_COMPOSITE               = BIT(30), // T: indicator that a texture is a composition (array) of texture slices
  FT_USAGE_UAV_RWTEXTURE     = BIT(31), // R: enable RW usage for the UAV, otherwise UAVs are write-only (see FT_USAGE_UNORDERED_ACCESS)
};