Exemple #1
0
bool CWizDatabase::UpdateAttachments(const std::deque<WIZDOCUMENTATTACHMENTDATAEX>& arrayAttachment)
{
    if (arrayAttachment.empty())
        return true;

    __int64 nVersion = -1;

    bool bHasError = false;

    std::deque<WIZDOCUMENTATTACHMENTDATAEX>::const_iterator it;
    for (it = arrayAttachment.begin(); it != arrayAttachment.end(); it++)
    {
        const WIZDOCUMENTATTACHMENTDATAEX& data = *it;

        Q_EMIT processLog("attachment: " + data.strName);

        if (!UpdateAttachment(data))
        {
            bHasError = true;
        }

        nVersion = std::max<__int64>(nVersion, data.nVersion);
    }

    if (!bHasError)
    {
        SetObjectVersion(WIZDOCUMENTATTACHMENTDATAEX::ObjectName(), nVersion);
    }

    return !bHasError;
}
Exemple #2
0
//------------------------------------------------------------------------
void CVehiclePartEntityAttachment::SetAttachmentEntity(EntityId entityId)
{
	DetachAttachment();

	IEntity* pEntity = gEnv->pEntitySystem->GetEntity(entityId);

	if (!pEntity)
		return;

	m_attachmentId = entityId;
	m_pVehicle->GetEntity()->AttachChild(pEntity);

	UpdateAttachment();

	m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_AlwaysUpdate);
}
Exemple #3
0
/**
 * This is called recursively for all children of the root Node
 */
inline int UpdateNodesAndAttachments( Node& node,
                                      int parentFlags,
                                      BufferIndex updateBufferIndex,
                                      ResourceManager& resourceManager,
                                      RenderQueue& renderQueue,
                                      Layer& currentLayer,
                                      Shader* defaultShader,
                                      int inheritedDrawMode )
{
  Layer* layer = &currentLayer;

  // Short-circuit for invisible nodes
  if ( !node.IsVisible( updateBufferIndex ) )
  {
    return 0;
  }

  // If the node was not previously visible
  BufferIndex previousBuffer = updateBufferIndex ? 0u : 1u;
  if ( !node.IsVisible( previousBuffer ) )
  {
    // The node was skipped in the previous update; it must recalculate everything
    node.SetAllDirtyFlags();
  }

  // Some dirty flags are inherited from parent
  int nodeDirtyFlags( node.GetDirtyFlags() | ( parentFlags & InheritedDirtyFlags ) );

  if ( node.GetInheritedShader() == NULL )
  {
    nodeDirtyFlags |= ShaderFlag;
  }

  int cumulativeDirtyFlags = nodeDirtyFlags;

  if ( node.IsLayer() )
  {
    // all childs go to this layer
    layer = node.GetLayer();

    // assume layer is clean to begin with
    layer->SetReuseRenderers( updateBufferIndex, true );

    // Layers do not inherit the DrawMode from their parents
    inheritedDrawMode = DrawMode::NORMAL;
  }
  DALI_ASSERT_DEBUG( NULL != layer );

  UpdateNodeShader( node, nodeDirtyFlags, defaultShader );

  UpdateNodeOpacity( node, nodeDirtyFlags, updateBufferIndex );

  UpdateNodeGeometry( node, nodeDirtyFlags, updateBufferIndex );

  UpdateNodeTransformValues( node, nodeDirtyFlags, updateBufferIndex );

  // Setting STENCIL will override OVERLAY, if that would otherwise have been inherited.
  inheritedDrawMode |= node.GetDrawMode();

  if ( node.HasAttachment() )
  {
    /*
     * Add renderables for the children into the current Layer
     */
    RenderableAttachment* renderable = UpdateAttachment( node.GetAttachment(),
                                                         node,
                                                         updateBufferIndex,
                                                         resourceManager,
                                                         nodeDirtyFlags );


    if( NULL != renderable )
    {
      // Update the world matrix after renderable update; the ScaleForSize property should now be calculated
      UpdateNodeWorldMatrix( node, *renderable, nodeDirtyFlags, updateBufferIndex );

      // The attachment is ready to render, so it is added to a set of renderables.
      AddRenderableToLayer( *layer, *renderable, updateBufferIndex, inheritedDrawMode );
    }
  }
  else if( node.IsObserved() )
  {
    // This node is being used as a property input for an animation, constraint,
    // camera or bone. Ensure it's matrix is updated
    UpdateNodeWorldMatrix( node, nodeDirtyFlags, updateBufferIndex );
  }

  // if any child node has moved or had its sort modifier changed, layer is not clean and old frame cannot be reused
  // also if node has been deleted, dont reuse old render items
  if( nodeDirtyFlags & RenderableUpdateFlags )
  {
    layer->SetReuseRenderers( updateBufferIndex, false );
  }

  // recurse children
  NodeContainer& children = node.GetChildren();
  const NodeIter endIter = children.End();
  for ( NodeIter iter = children.Begin(); iter != endIter; ++iter )
  {
    Node& child = **iter;
    cumulativeDirtyFlags |=UpdateNodesAndAttachments( child,
                                                      nodeDirtyFlags,
                                                      updateBufferIndex,
                                                      resourceManager,
                                                      renderQueue,
                                                      *layer,
                                                      defaultShader,
                                                      inheritedDrawMode );
  }

  return cumulativeDirtyFlags;
}
Exemple #4
0
//------------------------------------------------------------------------
void CVehiclePartEntityAttachment::SetLocalTM(const Matrix34 &localTM)
{
	m_localTM = VALIDATE_MAT(localTM);

	UpdateAttachment();
}
Exemple #5
0
//------------------------------------------------------------------------
void CVehiclePartEntityAttachment::Update(const float frameTime)
{
	CVehiclePartBase::Update(frameTime);

	UpdateAttachment();
}