void Camera::ResetCameraToLight()
{
	// Reset camera.
	DirectX::XMFLOAT3 target = DirectX::XMFLOAT3(0, 0, 0);
	DirectX::XMFLOAT3 position = DirectX::XMFLOAT3(25.0f, 100.0f, 50.0f);

	UpdatePosition(position);
	UpdateTarget(target);

	m_upVector = DirectX::XMFLOAT3(-25.0f, 100.0f, -50.0f);
	DirectX::XMStoreFloat3(&m_upVector, DirectX::XMVector3Normalize(DirectX::XMLoadFloat3(&m_upVector)));

	m_look = DirectX::XMFLOAT3(-25.0f, -100.0f, -50.0f);
	DirectX::XMStoreFloat3(&m_look, DirectX::XMVector3Normalize(DirectX::XMLoadFloat3(&m_look)));

	m_right = DirectX::XMFLOAT3(25.0f, 0.0f, -50.0f);
	DirectX::XMStoreFloat3(&m_right, DirectX::XMVector3Normalize(DirectX::XMLoadFloat3(&m_right)));

	// Projection data.
	float aspectRatio = (float)GLOBAL::GetInstance().MAX_SCREEN_WIDTH / (float)GLOBAL::GetInstance().MAX_SCREEN_HEIGHT;
	UpdateAspectRatio(aspectRatio);
	UpdateFieldOfView(3.141592f * 0.25f);
	UpdateClippingPlanes(0.1f, 1000.0f);
	UpdateViewMatrix();
	UpdateProjectionMatrix(true);

	GraphicsEngine::SetLightViewAndProjection(GetViewMatrix(), GetProjectionMatrix());
}
Пример #2
0
void PolyDataObject::ObjectAddedToScene()
{
    connect( GetManager(), SIGNAL(ReferenceObjectChanged()), this, SLOT(OnReferenceChanged()) );
    connect( GetManager(), SIGNAL(ReferenceTransformChanged()), this, SLOT(OnReferenceChanged()) );
    connect( GetManager(), SIGNAL(CursorPositionChanged()), this, SLOT(OnCursorPositionChanged()) );
    connect( GetManager(), SIGNAL(StartCursorInteraction()), this, SLOT(OnStartCursorInteraction()) );
    connect( GetManager(), SIGNAL(EndCursorInteraction()), this, SLOT(OnEndCursorInteraction()) );
    m_referenceToPolyTransform->Identity();
    m_referenceToPolyTransform->Concatenate( GetWorldTransform() );
    m_referenceToPolyTransform->Concatenate( GetManager()->GetInverseReferenceTransform() );
    UpdateCuttingPlane();
    UpdateClippingPlanes();
}
Пример #3
0
void Master::Init(char* filename) {

  // Local clipping planes
  float clipNear = 0.0;
  float clipFar = 0.0;

  // Local synchronization server port
  int synchronizationPort = 0;

  // Local user interface server port
  int userInterfacePort = 0;


#ifdef SAGE

  // Connect to SAGE

  // SAGE configuration
  _sageConfig.init("VRA.conf");
  _sageConfig.setAppName("VRA");
  _sageConfig.rank = 0;
  _sageConfig.nodeNum = (_communicator -> GetNumberOfNodes()) -1;
  _sageConfig.master = true;
  _sageConfig.rendering = false;

  // Initialize SAGE
  _sageInf.init(_sageConfig);

#endif


  // Read configuration file from disk

  // File pointer
  FILE* fptr = NULL;

  // Attempt to open file
  if ((fptr = fopen(filename, "r")) == NULL) {
    fprintf(stderr, 
            "Master: Can not read display configuration file %s\n.", 
            filename);
    return;
  }

  // Read user interface port
  fscanf(fptr, "%d", &userInterfacePort);

  // Read synchronization port
  fscanf(fptr, "%d", &synchronizationPort);

  // Read near and far clipping planes
  fscanf(fptr, "%f %f", &clipNear, &clipFar);

  // Assign all clipping planes
  for (int i = 0 ; i < _numberOfSlaves ; i++) {
    _clippingPlanes[i][0] = clipNear;
    _clippingPlanes[i][1] = clipFar;
  }

  // Read total display size
  fscanf(fptr, "%d %d", &_totalDisplayWidth, &_totalDisplayHeight);

  // Read vertical field of view
  fscanf(fptr, "%f", &_vFOV);

  // Read and assign viewport and normalize coordinates for each node
  for (int i = 0 ; i < _numberOfSlaves ; i++) {

    // Read viewport and normalized coordinates
    fscanf(fptr, "%d %d %d %d %f %f %f %f",
           &_viewport[i][0], &_viewport[i][1],
           &_viewport[i][2], &_viewport[i][3],
           &_displayPercentages[i][0], &_displayPercentages[i][1],
           &_displayPercentages[i][2], &_displayPercentages[i][3]);

    // Assign display size based on viewport
    _displaySize[i][0] = _viewport[i][2];
    _displaySize[i][1] = _viewport[i][3];

    // Read and interpret full screen flag
    int flag = 0;
    fscanf(fptr, "%d", &flag);
    if (flag == 0) {
      _fullScreenFlag[i] = false;
    }
    else {
      _fullScreenFlag[i] = true;
    }

  }

  // Read number of datasets in dataset list
  fscanf(fptr, "%d", &_numberOfDatasets);

  // Allocate memory for dataset list dataset file name
  _datasetListFile = new char*[_numberOfDatasets];
  for (int i = 0 ; i < _numberOfDatasets ; i++) {
    _datasetListFile[i] = new char[1024];
  }

  // Allocate memory for dataset list dataset name
  _datasetListName = new char*[_numberOfDatasets];
  for (int i = 0 ; i < _numberOfDatasets ; i++) {
    _datasetListName[i] = new char[1024];
  }

  // Allocate memory for dataset list dataset prefix
  _datasetListPrefix = new char*[_numberOfDatasets];
  for (int i = 0 ; i < _numberOfDatasets ; i++) {
    _datasetListPrefix[i] = new char[1024];
  }

  // Read dataset list
  for (int i = 0 ; i < _numberOfDatasets ; i++) {
    fscanf(fptr, 
           "%s %s %s", 
           _datasetListName[i], 
           _datasetListPrefix[i], 
           _datasetListFile[i]);
  }

  // Close file
  fclose(fptr);


  // Calculate frustums

  // Setup frustum calculator
  FrustumCalculator frustumCalculator;
  frustumCalculator.SetDisplayWidth(_totalDisplayWidth);
  frustumCalculator.SetDisplayHeight(_totalDisplayHeight);
  frustumCalculator.SetNearClippingPlane(clipNear);
  frustumCalculator.SetVerticalFieldOfView(_vFOV);

  // Calculate frustum for each node
  for (int i = 0 ; i < _numberOfSlaves ; i++) {
    frustumCalculator.SetPercentage(_displayPercentages[i]);
    frustumCalculator.CalculateFrustum();
    frustumCalculator.GetFrustum(_frustum[i]);
  }

  // Calculate full frustum for entire display
  frustumCalculator.GetFullFrustum(&_totalDisplayFrustum[0],
                                   &_totalDisplayFrustum[1],
                                   &_totalDisplayFrustum[2],
                                   &_totalDisplayFrustum[3]);
  _totalDisplayFrustum[4] = clipNear; 
  _totalDisplayFrustum[5] = clipFar;


  // Initialize and register observer with synchronizer server
  _progressObserver = new SynchronizerServerConcreteCommand(this);
  _synchronizationServer.SetProgressObserver(_progressObserver);
  if (_progressObserver == NULL) {
    fprintf(stderr, 
            "Master: Error creating SynchronizerServerConcreteCommand.\n");
  }

  // Initialize synchronization server
  _synchronizationServer.Init(synchronizationPort);


  // Initialize slaves

  // Get name of master node
  char hostname[128];
  _communicator -> GetMasterNodeName(hostname);

  // Send display size to slaves
  for (int i = 0 ; i < _numberOfSlaves ; i++) {
    UpdateDisplaySize(i+1, _displaySize[i][0], _displaySize[i][1],
                      _fullScreenFlag[i], hostname, synchronizationPort,
                      _displayPercentages[i][0], _displayPercentages[i][1],
                      _displayPercentages[i][2], _displayPercentages[i][3]);
    _communicator -> Barrier();
  }

  // Send clipping planes to slaves
  for (int i = 0 ; i < _numberOfSlaves ; i++) {
    UpdateClippingPlanes(i+1, _clippingPlanes[i][0], _clippingPlanes[i][1]);  
    _communicator -> Barrier();
  }

  // Send frustums to slaves
  for (int i = 0 ; i < _numberOfSlaves ; i++) {
    UpdateFrustum(i+1, _frustum[i][0], _frustum[i][1],
                  _frustum[i][2], _frustum[i][3]);
    _communicator -> Barrier();
  }

  // Send viewports to slaves
  for (int i = 0 ; i < _numberOfSlaves ; i++) {
    UpdateViewport(i+1, _viewport[i][0], _viewport[i][1],
                   _viewport[i][2], _viewport[i][3]);
    _communicator -> Barrier();
  }

  // Turn axis on
  UpdateAxisOn();
  _communicator -> Barrier();

  // Set axis position
  UpdateAxisPosition(_totalDisplayFrustum[0] + 0.5,
                     _totalDisplayFrustum[2] + 0.5,
                     0.0);
  _communicator -> Barrier();

  // Turn on bounding box
  UpdateBoundingBoxOn();
  _communicator -> Barrier();

  // Turn off brick box
  UpdateBrickBoxOff();
  _communicator -> Barrier();

  // Initialize user interface server
  _userInterfaceServer.Init(userInterfacePort);

}