vcglib/wrap/gl/shot.h

/****************************************************************************
* VCGLib                                                            o o     *
* Visual and Computer Graphics Library                            o     o   *
*                                                                _   O  _   *
* Copyright(C) 2004                                                \/)\/    *
* Visual Computing Lab                                            /\/|      *
* ISTI - Italian National Research Council                           |      *
*                                                                    \      *
* All rights reserved.                                                      *
*                                                                           *
* This program is free software; you can redistribute it and/or modify      *   
* it under the terms of the GNU General Public License as published by      *
* the Free Software Foundation; either version 2 of the License, or         *
* (at your option) any later version.                                       *
*                                                                           *
* This program is distributed in the hope that it will be useful,           *
* but WITHOUT ANY WARRANTY; without even the implied warranty of            *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
* GNU General Public License (http://www.gnu.org/licenses/gpl.txt)          *
* for more details.                                                         *
*                                                                           *
****************************************************************************/
/****************************************************************************
  History
$Log: not supported by cvs2svn $
Revision 1.12  2006/12/18 16:02:57  matteodelle
minor eroor correction on variable names

Revision 1.11  2006/12/18 15:26:24  callieri
added a function to approximate a far plane value given a shot and the mesh bbox

Revision 1.10  2006/12/18 14:28:07  matteodelle
*** empty log message ***

Revision 1.9  2006/12/18 09:46:39  callieri
camera+shot revamp: changed field names to something with more sense, cleaning of various functions, correction of minor bugs/incongruences, removal of the infamous reference in shot.

Revision 1.8  2006/01/11 16:06:25  matteodelle
*** empty log message ***


Revision 1.8  2005/01/11 17:06:30  dellepiane
FromTrackball() coorected (similarity->Extrinsics

Revision 1.7  2005/11/25 10:33:33  spinelli
shot.camera  -> shot.Intrinsics
shot.similarity.Matrix() -> shot.Extrinsics.Matrix()

Revision 1.6  2005/02/22 11:15:01  ganovelli
added vcg namespace

Revision 1.5  2005/02/11 11:43:09  tommyfranken
FromTrackball() corrected

Revision 1.4  2004/12/15 18:45:06  tommyfranken
*** empty log message ***

Revision 1.3  2004/11/03 09:41:57  ganovelli
added FromTrackball and fixed include names (Poiint to point)

Revision 1.2  2004/10/05 19:04:45  ganovelli
changed from classes to functions

Revision 1.1  2004/09/15 22:59:13  ganovelli
creation

Revision 1.2  2004/09/06 21:41:30  ganovelli
*** empty log message ***

Revision 1.1  2004/09/03 13:01:51  ganovelli
creation

****************************************************************************/


#ifndef __VCGLIB_GLSHOT
#define __VCGLIB_GLSHOT

// include vcg stuff
#include <vcg/space/point2.h>
#include <vcg/space/point3.h>
#include <vcg/math/similarity.h>

#include <vcg/math/shot.h>

// include wrap stuff
#include <wrap/gui/trackball.h>
#include <wrap/gl/math.h>
#include <wrap/gl/camera.h>

template <class ShotType>
struct GlShot {

	typedef typename ShotType::ScalarType ScalarType;
	typedef GlCamera<typename ShotType::CameraType> GlCameraType;

/// returns the OpenGL 4x4 MODELVIEW matrix that describes the shot position and orientation (extrinsics)
static void MatrixGL(ShotType & shot,vcg::Matrix44<ScalarType> & m) 
{
	m = shot.GetWorldToExtrinsicsMatrix();
}

/// set the OpenGL MODELVIEW matrix to match the shot (extrinsics)
static void TransformGL(vcg::Shot<ScalarType> & shot)
{
	vcg::Matrix44<ScalarType> m;
	MatrixGL(shot,m);
	glMultMatrix(m);
}

/// set the OpenGL PROJECTION and MODELVIEW matrix to match camera+shot. requires near and far plane
static void SetView(vcg::Shot<ScalarType> & shot, ScalarType nearDist, ScalarType farDist)
{
	assert(glGetError() == 0);
	glMatrixMode(GL_PROJECTION);
	glPushMatrix();
	glLoadIdentity();

	assert(glGetError() == 0);
	GlCameraType::TransformGL(shot.Intrinsics, nearDist, farDist); // apply camera/projection transformation
	assert(glGetError() == 0);

	glMatrixMode(GL_MODELVIEW);
	glPushMatrix();
	glLoadIdentity();

	GlShot<ShotType>::TransformGL(shot);	// apply similarity/modelview transformation
	assert(glGetError() == 0);
}

/// restore the previous OpenGL modelview and projection state. to be called AFTER a SetView
static void	UnsetView()
{
	glPushAttrib(GL_TRANSFORM_BIT);
	glMatrixMode(GL_MODELVIEW);
	glPopMatrix();
	glMatrixMode(GL_PROJECTION);
	glPopMatrix();
	glPopAttrib();
}

/// given a shot and the mesh bounding box, returns an approximate far plane distance
/// distance is always approximated by excess
static ScalarType GetFarPlane(vcg::Shot<ScalarType> & shot, vcg::Box3<ScalarType> bbox)
{
	ScalarType farDist;

	vcg::Point3<ScalarType> farcorner;
    vcg::Point3<ScalarType> campos = shot.Extrinsics.Tra();
	 
	 if (abs(campos.X() - bbox.max.X()) > abs(campos.X() - bbox.min.X()))
		 farcorner.X() = bbox.max.X();
	 else
		 farcorner.X() = bbox.min.X();

	 if (abs(campos.Y() - bbox.max.Y()) > abs(campos.Y() - bbox.min.Y()))
		 farcorner.Y() = bbox.max.Y();
	 else
		 farcorner.Y() = bbox.min.Y();

	 if (abs(campos.Z() - bbox.max.Z()) > abs(campos.Z() - bbox.min.Z()))
		 farcorner.Z() = bbox.max.Z();
	 else
		 farcorner.Z() = bbox.min.Z();

	 farDist = (campos - farcorner).Norm();

	return farDist;
}


/// given a shot and the mesh bounding box, return near and far plane (exact)
static void GetNearFarPlanes(vcg::Shot<ScalarType> & shot, vcg::Box3<ScalarType> bbox, ScalarType &nr, ScalarType &fr)
{
  vcg::Point3<ScalarType> zaxis = shot.Axis(2); 
  ScalarType offset = zaxis * shot.GetViewPoint();
  bool first = true;
  for(int i = 0; i < 8; i++) {
    vcg::Point3<ScalarType> c = bbox.P(i);
    ScalarType d = -(zaxis * c - offset);
    if(first || d < nr) { 
      nr = d;
      first = false;
    }
    if(first || d > fr) { 
      fr = d;
      first = false;
    }
  }
}



static void SetSubView(vcg::Shot<ScalarType> & shot,
					   vcg::Point2<ScalarType> p1,
					   vcg::Point2<ScalarType> p2)
{
	glMatrixMode(GL_PROJECTION);
	glPushMatrix();
	glLoadIdentity();
	assert(glGetError() == 0);
	GlCameraType::SetSubView(shot.Intrinsics,p1,0,1000,p2);
	assert(glGetError() == 0);
	glMatrixMode(GL_MODELVIEW);
	glPushMatrix();
	glLoadIdentity();
	GlShot<ShotType>::TransformGL(shot);							// apply similarity/modelview transformation
	assert(glGetError() == 0);
}


	
/**********************************
DEFINE SHOT FROM TRACKBALL
Adds to a given shot the trackball transformations.
After this operation the trackball should be resetted, to avoid
multiple apply of the same transformation.
***********************************/
static void FromTrackball(const vcg::Trackball & tr, 
						  vcg::Shot<ScalarType> & sShot, 
						  vcg::Shot<ScalarType> & shot )
{
	vcg::Point3<ScalarType>		cen; cen.Import(tr.center);
	vcg::Point3<ScalarType>		tra; tra.Import(tr.track.tra);
	vcg::Matrix44<ScalarType>	trM; trM.FromMatrix(tr.track.Matrix());

	vcg::Point3<ScalarType>		vp = Inverse(trM)*(sShot.GetViewPoint()-cen) +cen +tra;

	shot.SetViewPoint(vp);
	shot.Extrinsics.SetRot(sShot.Extrinsics.Rot()*trM);
//	shot.Extrinsics.sca	=	sShot.Extrinsics.sca*(ScalarType)tr.track.sca;
}
};
#endif