#include "watrplan.h"
#include "linear.h"
#include "proj.h"
void GLI_vSinusEffetOn3DVertex ( MTH3D_tdstVector * p_stVertex3D ) ;
 
/*
 =======================================================================================
  Name        : Camera.cxx
  Description : Camera function -- PC specific version
 =======================================================================================
 */
 
static GLI_tdstCamera *p_stCamAntiBug;
 
void GLI_xAdjustCameraToViewport2 (GLD_tdstDeviceAttributes *p_stDev, GLD_tdstViewportAttributes *p_stVpt, GLI_tdstCamera *p_stCam ) ;
 
void GLI_xCreateCamera ( GLI_tdstCamera **h_stCam , long lCameraMode )
{
    MMG_fn_vAddMemoryInfo (MMG_C_lTypeGLI , MMG_C_lSubTypeCamera , NULL);
    GEO_M_CPAMalloc(*h_stCam,GLI_tdstCamera *,sizeof ( GLI_tdstCamera),E_uwGEONotEnoughtMemory );
    if ( (*h_stCam) == NULL) 
        return;    
    
    (*h_stCam)->lCameraMode = lCameraMode ;
    
    switch ( (*h_stCam) -> lCameraMode )
    {
        case GLI_C_lIsoCamWithDistorsion :
        case GLI_C_lIsoCamWithoutDistorsion :
            (*h_stCam)->xAlphaX = GLI_M_LongToValue ( 1 ) ;
            (*h_stCam)->xAlphaY = GLI_M_LongToValue ( 1 ) ;
            break ;
      
        case GLI_C_lPersCamWithDistorsion :
        case GLI_C_lPersCamWithoutDistorsion :
            (*h_stCam)-> xAlphaX = GLI_M_PIO4 ;
            (*h_stCam)-> xAlphaY = GLI_M_PIO4 ;
            break;
        
        default:
            break;
    }
    
    (*h_stCam)-> xNear = GLI_C_xZClippingNear ;
    (*h_stCam)-> xFar = GLI_M_FloatToValue( 10000.0 ) ;
	(*h_stCam)-> xRatio = GLI_M_Div ((*h_stCam)->xAlphaY , (*h_stCam)->xAlphaX );
   
    return;
}
 
 
 
 
/*
 ----------------------------------------------------------------------------------------
  Description   : Adjust camera parameters to fit with viewport parameters
 ----------------------------------------------------------------------------------------
 */
void GLI_xAdjustCameraToViewport ( GLD_tdhDevice hDevice, GLD_tdhViewport hViewport, GLI_tdstCamera *p_stCam )
{
	/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
    GLD_tdstDeviceAttributes        stDevAttrib;
    GLD_tdstViewportAttributes      stViewAttrib;
	/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
    
	if ( !GLD_bGetDeviceAttributes( hDevice, &stDevAttrib ) )
		return ;
    if ( !GLD_bGetViewportAttributes( hDevice, hViewport, &stViewAttrib ) )
		return;
    
    /* ANTI BUG ------------------------------------------- */
    if (p_stCam == NULL)
		p_stCam = p_stCamAntiBug;
    else
		p_stCamAntiBug = p_stCam;/*  */
    /* ANTI BUG ------------------------------------------- */
    
    GLI_xAdjustCameraToViewport2 (&stDevAttrib, &stViewAttrib, p_stCam) ;
    return;
}                         
 
 
 
 
/*
 ----------------------------------------------------------------------------------------
  Description   : transform 2D position to 3D position
 ----------------------------------------------------------------------------------------
 */
void GLI_vGet3DVertexFromScreenPos 
		( 
			GLD_tdstViewportAttributes	*p_stVpt,
			MTH3D_tdstVector			*p_stPos3D,
			MTH_tdxReal					xRatioX, 
			MTH_tdxReal					xRatioY, 
			MTH_tdxReal					xSize 
		) 
{
	/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
	GLI_tdst2DVertex					stPos2D, stTrans ;
	GLI_tdstSpecificAttributesFor3D		*p_stSpecAttrib3D;
	GLI_tdstCamera						*p_stCam;
	MTH_tdxReal							xScreen;
	MTH3D_tdstVector					stTemp ;
	POS_tdstCompletePosition			stMatrix, stInvMatrix ;
	/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
	stPos2D.xX = p_stVpt->dwWidth * xRatioX ;
	stPos2D.xY = p_stVpt->dwHeight * xRatioY;	
 
	p_stSpecAttrib3D = (GLI_tdstSpecificAttributesFor3D *)p_stVpt->p_vSpecificToXD;
	p_stCam = p_stSpecAttrib3D->p_stCam ;
  
	switch(p_stCam->lCameraMode)
	{
		case GLI_C_lIsoCamWithDistorsion :
		case GLI_C_lIsoCamWithoutDistorsion :
			xScreen = MTH_M_xFloatToReal(0.1f);
			break;
  
		case GLI_C_lPersCamWithDistorsion :
		case GLI_C_lPersCamWithoutDistorsion :
			xScreen = p_stCam->xScreen;
			break ;
	
		default:
			p_stPos3D->xX = p_stPos3D->xY = p_stPos3D->xZ = MTH_M_xFloatToReal(0.0f);
			return;
	}
    stTrans.xX = p_stCam->stTrans.xX;
    stTrans.xY = p_stCam->stTrans.xY;
	if ( xSize != 0.0 ) 
	{
		stTemp.xX = MTH_M_xDiv( MTH_M_xDiv( MTH_M_xSub( MTH_M_xLongToReal(stPos2D.xX), MTH_M_xLongToReal(stTrans.xX)), MTH_M_xFloatToReal(p_stCam->stScale.xX)), MTH_M_xFloatToReal(xSize) );
		stTemp.xY = MTH_M_xDiv( MTH_M_xDiv( MTH_M_xSub( MTH_M_xLongToReal(stPos2D.xY), MTH_M_xLongToReal(stTrans.xY)),MTH_M_xFloatToReal(p_stCam->stScale.xY) ), MTH_M_xFloatToReal(xSize) );
		stTemp.xZ = MTH_M_xMul( xScreen, MTH_M_xDiv( MTH_M_xAdd( MTH_M_xFloatToReal(1.0f), xSize ), xSize) );
	}
	else 
	{
		stTemp.xX = MTH_M_xDiv( MTH_M_xSub( MTH_M_xLongToReal(stPos2D.xX), MTH_M_xLongToReal(stTrans.xX)),MTH_M_xFloatToReal(p_stCam->stScale.xX) ) ;
		stTemp.xY = MTH_M_xDiv( MTH_M_xSub( MTH_M_xLongToReal(stPos2D.xY), MTH_M_xLongToReal(stTrans.xY)),MTH_M_xFloatToReal(p_stCam->stScale.xY) ) ;
		stTemp.xZ = MTH_M_xFloatToReal(0.0f);
	}
  
	/* 
	 * Convertion dans le repere du monde 
	 */
	GLI_xGetCameraMatrix ( p_stCam , &stMatrix );
	POS_fn_vInvertMatrix ( &stInvMatrix , &stMatrix );  
	POS_fn_vMulMatrixVertex ( p_stPos3D , &stInvMatrix , &stTemp );
}
 
 
 
/*
 ----------------------------------------------------------------------------------------
  Description   : Adjust camera parameters to fit with viewport parameters
 ----------------------------------------------------------------------------------------
 */
void GLI_xAdjustCameraToViewport2 (GLD_tdstDeviceAttributes *p_stDev, GLD_tdstViewportAttributes *p_stVpt, GLI_tdstCamera *p_stCam ) {
  /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  GLI_tdxValue					xHeightForAlphaY ;
  GLI_tdxValue					xVptWidthInPix , xVptHeightInPix ;
  GLI_tdxValue					xVptWidthInMeters , xVptHeightInMeters ;
  GLI_tdxValue					xVptRatio , xOOScale;
  GLI_tdstSpecificAttributesFor3D *p_stSpecAttrib3D;
  float							fZ, fOoL, fH;
  /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  
  p_stSpecAttrib3D = (GLI_tdstSpecificAttributesFor3D *) p_stVpt->p_vSpecificToXD;
  
  xVptWidthInPix		= GLI_M_LongToValue ( p_stVpt->dwWidth ) ;
  xVptWidthInMeters	= GLI_M_Mul ( xVptWidthInPix , p_stDev->xPixelDimensionX ) ;
  xVptHeightInPix		= GLI_M_LongToValue ( p_stVpt->dwHeight ) ;
  xVptHeightInMeters	= GLI_M_Mul ( xVptHeightInPix , p_stDev->xPixelDimensionY ) ;
  xVptRatio			= GLI_M_Div ( xVptHeightInMeters , xVptWidthInMeters ) ;
 
  p_stCam->stTrans.xX = (int) p_stVpt->iOffsetPosX + MTH_M_xRealToFloat( GLI_M_Mul ( xVptWidthInPix , GLI_M_FloatToValue ( 0.5f ) ) ) ;
  p_stCam->stTrans.xY = (int) p_stVpt->iOffsetPosY + MTH_M_xRealToFloat( GLI_M_Mul ( xVptHeightInPix, GLI_M_FloatToValue ( 0.5f ) ) ) ;
  
  switch ( p_stCam -> lCameraMode )
  {
		case GLI_C_lIsoCamWithoutDistorsion :
      p_stCam->xScreen = GLI_M_LongToValue ( 0 ) ;
      p_stCam->xAlphaY = p_stCam -> xAlphaX ;
      p_stCam->stScale.xX = MTH_M_xRealToFloat( GLI_M_Neg ( GLI_M_Inv ( GLI_M_Mul ( p_stCam -> xAlphaX , p_stDev->xPixelDimensionX ) ) ) ) ;
      p_stCam->stScale.xY = MTH_M_xRealToFloat( GLI_M_Neg ( GLI_M_Inv ( GLI_M_Mul ( p_stCam -> xAlphaY , p_stDev->xPixelDimensionY ) ) ) ) ;
      
      p_stCam->stNormPlaneUp    .xX = p_stCam->stNormPlaneDown.xX =
        p_stCam->stNormPlaneRight .xY = p_stCam->stNormPlaneLeft.xY =
        p_stCam->stNormPlaneRight .xZ = p_stCam->stNormPlaneLeft.xZ =
        p_stCam->stNormPlaneDown  .xZ = p_stCam->stNormPlaneUp  .xZ = 0.0f;
      p_stCam->stNormPlaneLeft  .xX = -1.0f;
      p_stCam->stNormPlaneRight .xX = +1.0f;
      p_stCam->stNormPlaneUp    .xY = -1.0f;
      p_stCam->stNormPlaneDown  .xY = +1.0f;
      
      xOOScale = -GLI_M_Div ( xVptWidthInPix  , p_stCam -> stScale . xX);
      xOOScale = GLI_M_Mul ( xOOScale , GLI_M_FloatToValue ( 0.5f ) );
      p_stCam -> xDistPlaneRight = xOOScale ;
      p_stCam -> xDistPlaneLeft  = xOOScale ;
      xOOScale = -GLI_M_Div ( xVptHeightInPix , p_stCam -> stScale . xY);
      xOOScale = GLI_M_Mul ( xOOScale , GLI_M_FloatToValue ( 0.5f ) );
      p_stCam -> xDistPlaneUp    = xOOScale ;
      p_stCam -> xDistPlaneDown  = xOOScale ;
			break;
      
    case GLI_C_lIsoCamWithDistorsion :
      p_stCam->xScreen = GLI_M_LongToValue ( 0 ) ;
      p_stCam->stScale.xX = MTH_M_xRealToFloat( GLI_M_Neg ( GLI_M_Div ( xVptWidthInPix , GLI_M_Mul ( GLI_M_Mul ( p_stCam -> xAlphaX , GLI_M_LongToValue ( p_stVpt->dwWidth ) ) , p_stDev->xPixelDimensionX ) ) ) );
      p_stCam->stScale.xY = MTH_M_xRealToFloat( GLI_M_Neg ( GLI_M_Div ( xVptHeightInPix ,GLI_M_Mul ( GLI_M_Mul ( p_stCam -> xAlphaY , GLI_M_LongToValue ( p_stVpt->dwHeight ) ) , p_stDev->xPixelDimensionY ) ) ) ) ;
      
      p_stCam -> stNormPlaneUp    .xX =  p_stCam -> stNormPlaneDown .xX =
        p_stCam -> stNormPlaneRight .xY =  p_stCam -> stNormPlaneLeft .xY =
        p_stCam -> stNormPlaneRight .xZ =  p_stCam -> stNormPlaneLeft .xZ =
        p_stCam -> stNormPlaneDown  .xZ =  p_stCam -> stNormPlaneUp   .xZ = 0.0f;
      p_stCam -> stNormPlaneLeft  .xX = -1.0f;
      p_stCam -> stNormPlaneRight .xX = +1.0f;
      p_stCam -> stNormPlaneUp    .xY = -1.0f;
      p_stCam -> stNormPlaneDown  .xY = +1.0f;
      
      xOOScale = -GLI_M_Div ( xVptWidthInPix  , p_stCam -> stScale . xX);
      xOOScale = GLI_M_Mul ( xOOScale , GLI_M_FloatToValue ( 0.5f ) );
      p_stCam -> xDistPlaneRight = xOOScale ;
      p_stCam -> xDistPlaneLeft  = xOOScale ;
      xOOScale = -GLI_M_Div ( xVptHeightInPix , p_stCam -> stScale . xY);
      xOOScale = GLI_M_Mul ( xOOScale , GLI_M_FloatToValue ( 0.5f ) );
      p_stCam -> xDistPlaneUp    = xOOScale ;
      p_stCam -> xDistPlaneDown  = xOOScale ;
      break ;
 
		case GLI_C_lPersCamWithoutDistorsion :
			p_stCam -> xScreen = GLI_M_Mul 
							( 
								GLI_M_Mul 
								( 
                                    GLI_M_Mul ( GLI_M_LongToValue ( p_stVpt->dwWidth ) ,p_stDev->xPixelDimensionX ) ,
									GLI_M_FloatToValue ( 0.5f ) 
								) ,
								GLI_M_Cotan ( GLI_M_Mul ( p_stCam -> xAlphaX , GLI_M_FloatToValue ( 0.5f ) ) )
							) ;
			p_stCam -> stScale . xX = MTH_M_xRealToFloat
								( 
									GLI_M_Mul 
										(
											GLI_M_Neg ( GLI_M_Inv ( p_stDev->xPixelDimensionX ) ) , 
											GLI_M_Div ( GLI_M_LongToValue(xVptWidthInPix) , GLI_M_LongToValue(p_stVpt->dwWidth) ) 
										) 
								);
      
			xHeightForAlphaY = MTH_M_xRealToFloat
							( 
								GLI_M_Mul 
								(
									GLI_M_Mul ( GLI_M_LongToValue ( 2 ) , p_stCam -> xScreen ) ,
									GLI_M_Tan ( GLI_M_Mul ( GLI_M_FloatToValue ( 0.5f ) , p_stCam -> xAlphaY ) ) 
								) 
							);
			p_stCam->stScale.xY = MTH_M_xRealToFloat( GLI_M_Neg ( GLI_M_Div ( xVptHeightInPix , xHeightForAlphaY ) ) ) ;
 
 
            {
			    fH = (float)((long)(p_stVpt->dwClipRightInPix - p_stVpt->iOffsetPosX) - (long)(p_stVpt->dwWidth / 2));
				fZ = (p_stVpt->dwWidth / 2) / MTH_M_xTan( MTH_M_xMul( p_stCam->xAlphaX , 0.5f));
			    
				fOoL = fZ * fZ + fH * fH;
			    fOoL = MTH_M_xInvSqrt( fOoL );
 
				p_stCam->stNormPlaneLeft.xX = -fZ * fOoL;
				p_stCam->stNormPlaneLeft.xY = 0.0f;
			    p_stCam->stNormPlaneLeft.xZ = -fH * fOoL;
 
				fH = (float)((long)(p_stVpt->dwWidth / 2) - (long)(p_stVpt->dwClipLeftInPix - p_stVpt->iOffsetPosY) );
			    
 				fOoL = fZ * fZ + fH * fH;
			    fOoL = MTH_M_xInvSqrt( fOoL );
 
			    p_stCam->stNormPlaneRight.xX = fZ * fOoL;
				p_stCam->stNormPlaneRight.xY = 0.0f;
			    p_stCam->stNormPlaneRight.xZ = -fH * fOoL;
            }
 
            {
			    fH = (float)((long)(p_stVpt->dwClipBottomInPix - p_stVpt->iOffsetPosY) - (long)(p_stVpt->dwHeight / 2)) ;
				fZ = (p_stVpt->dwHeight / 2) / MTH_M_xTan( MTH_M_xMul( p_stCam->xAlphaY , 0.5f));
			    fOoL = fZ * fZ + fH * fH;
			    fOoL = MTH_M_xInvSqrt( fOoL );
 
				p_stCam->stNormPlaneDown.xX = 0.0f;
			    p_stCam->stNormPlaneDown.xY = -fZ * fOoL;
			    p_stCam->stNormPlaneDown.xZ = -fH * fOoL;
 
			    fH = (float)((long)(p_stVpt->dwHeight / 2) - ((long)p_stVpt->dwClipTopInPix - p_stVpt->iOffsetPosY) ) ;
			    fOoL = fZ * fZ + fH * fH;
			    fOoL = MTH_M_xInvSqrt( fOoL );
 
				p_stCam->stNormPlaneUp.xX = 0.0f;
			    p_stCam->stNormPlaneUp.xY = fZ * fOoL;
			    p_stCam->stNormPlaneUp.xZ = -fH * fOoL;
            }
 
      
			p_stCam -> xDistPlaneUp = 0.0f;
			p_stCam -> xDistPlaneDown = 0.0f;
			p_stCam -> xDistPlaneRight = 0.0f;
			p_stCam -> xDistPlaneLeft = 0.0f;
			break;
      
    
		case GLI_C_lPersCamWithDistorsion :
			p_stCam -> xScreen = GLI_M_Mul ( GLI_M_Mul ( xVptWidthInMeters , GLI_M_FloatToValue ( 0.5f ) ) , GLI_M_Cotan ( GLI_M_Mul ( p_stCam -> xAlphaX , GLI_M_FloatToValue ( 0.5f ) ) ) ) ;
			p_stCam -> xAlphaY = GLI_M_Mul ( GLI_M_LongToValue ( 2 ) , GLI_M_Atan ( GLI_M_Div ( xVptHeightInMeters , GLI_M_Mul ( GLI_M_LongToValue ( 2 ) , p_stCam -> xScreen ) ) ) ) ;
      
			p_stCam -> stScale . xX =  MTH_M_xRealToFloat( GLI_M_Neg ( GLI_M_Inv ( p_stDev->xPixelDimensionX ) ) );
			p_stCam -> stScale . xY =  MTH_M_xRealToFloat( GLI_M_Neg ( GLI_M_Inv ( p_stDev->xPixelDimensionY ) ) ) ;
      
			/* compute norme & disytances of 4 planes of camera*/
			p_stCam -> stNormPlaneLeft  .xZ =  -MTH_M_xSin( MTH_M_xMul( p_stCam -> xAlphaX , 0.5f));
			p_stCam -> stNormPlaneRight .xZ =  p_stCam -> stNormPlaneLeft .xZ;
			p_stCam -> stNormPlaneLeft  .xX = -MTH_M_xCos( MTH_M_xMul( p_stCam -> xAlphaX , 0.5f));
			p_stCam -> stNormPlaneRight .xX = -p_stCam -> stNormPlaneLeft .xX;
			p_stCam -> stNormPlaneRight .xY =  p_stCam -> stNormPlaneLeft .xY = 0.0f;
      
			p_stCam -> stNormPlaneUp    .xZ =  -MTH_M_xSin( MTH_M_xMul( p_stCam -> xAlphaY , 0.65f));
			p_stCam -> stNormPlaneDown  .xZ =  p_stCam -> stNormPlaneUp   .xZ ;
			p_stCam -> stNormPlaneUp    .xY = MTH_M_xCos( MTH_M_xMul( p_stCam -> xAlphaY , 0.65f));
			p_stCam -> stNormPlaneDown  .xY = -p_stCam -> stNormPlaneUp   .xY;
			p_stCam -> stNormPlaneUp    .xX =  p_stCam -> stNormPlaneDown .xX = 0.0f;
			MTH3D_M_vNormalizeVector(&p_stCam -> stNormPlaneDown  , &p_stCam -> stNormPlaneDown  );
      
			p_stCam -> xDistPlaneUp = 0.0f;
			p_stCam -> xDistPlaneDown = 0.0f;
			p_stCam -> xDistPlaneRight = 0.0f;
			p_stCam -> xDistPlaneLeft = 0.0f;
			break ;
    }
    return;
}                         
 
 
/*
 ----------------------------------------------------------------------------------------
  Description   : Adjust the camera to the mirror for an optimized clipping 
 ----------------------------------------------------------------------------------------
 */
ACP_tdxBool GLI_vAdjustCameraToMirror( ACP_tdxHandleOfObject hHandleOfGometricMirror, GEO_tdxHandleToMatrix	hGlobalMatrixOfMirror, GEO_tdxHandleToMatrix	hMatrixOfCamera, struct GLI_tdstCamera_ *pstCamera, GLD_tdstViewportAttributes *p_stVpt,long lDrawModeMask)
{
  MTH3D_tdstVector						  pstPointOfRectangleMirror[4];
  GLI_tdstAligned3DVector		pstAligned3DPointOfRectangleMirror[4];
  GLI_tdstAligned3DVector		pstAligned3DCorrectedPointOfRectangleMirror[5];
  GLI_tdstAligned2DVector		pstAligned2DProjectedPointOfRectangleMirror[5];
  short i,j;
  ACP_tdxIndex	xTempIndexForRectangle;
  float						fXMin,fXMax,fYMin,fYMax;
  float						fXMin1,fXMax1,fYMin1,fYMax1;
  float						xConstantMinForZ;
  float						xConstantDivForZ;
  POS_tdstCompletePosition		stMatrixFromSuperObjectToCamera;
  ACP_tdxBool			bIDrawTheMirrorNormally=TRUE;
  ACP_tdxBool			p_bPointOfMirrorIsBehindCamera[4];
  float					fNear;
 
 
  fXMin1=(float)p_stVpt->dwClipLeftInPix;
  fXMax1=(float)p_stVpt->dwClipRightInPix;
  fYMin1=(float)p_stVpt->dwClipTopInPix;
  fYMax1=(float)p_stVpt->dwClipBottomInPix;
  
 
  xTempIndexForRectangle=hHandleOfGometricMirror->xNbPoints;
  for (j=0;j<4;j++)
  {
    xTempIndexForRectangle--;
    GEO_vGetPointOfObject(hHandleOfGometricMirror,&pstPointOfRectangleMirror[j],xTempIndexForRectangle);
  }
  
  POS_fn_vSetIdentityMatrix(&stMatrixFromSuperObjectToCamera);
  POS_fn_vMulMatrixMatrix(&stMatrixFromSuperObjectToCamera,hMatrixOfCamera,hGlobalMatrixOfMirror);
  
  GLI_xSerialLinearOp (4 ,pstPointOfRectangleMirror,
    pstAligned3DPointOfRectangleMirror ,
    &stMatrixFromSuperObjectToCamera);
 
  fNear = pstCamera->xFar;
  for (j=0;j<4;j++) {
	/* check if There is a Sinus Effect*/
    if ( ( (g_cSinusEffectState == 1) && ((lDrawModeMask & GLI_C_lHasNotSinusEffect) == 0) ) || 
         ( (g_cSinusEffectState == 2) && (lDrawModeMask & GLI_C_lHasNotSinusEffect) ) ||  
         (g_cSinusEffectState == 3) ) 
		GLI_vSinusEffetOn3DVertex((MTH3D_tdstVector *)&pstAligned3DPointOfRectangleMirror[j]) ;
 
	fNear = MTH_M_xMin(fNear,pstAligned3DPointOfRectangleMirror[j].xZ);
 
    if  (MTH_M_bLess(pstAligned3DPointOfRectangleMirror[j].xZ,pstCamera->xNear))
      p_bPointOfMirrorIsBehindCamera[j]=TRUE;	
    else   p_bPointOfMirrorIsBehindCamera[j]=FALSE;
  }
 
  xConstantMinForZ = pstCamera->xNear = MTH_M_xMax(fNear,pstCamera->xNear);
 
  if ((p_bPointOfMirrorIsBehindCamera[0])||
    (p_bPointOfMirrorIsBehindCamera[1])||
    (p_bPointOfMirrorIsBehindCamera[2])||
    (p_bPointOfMirrorIsBehindCamera[3])) bIDrawTheMirrorNormally=FALSE;
  
 
  if (bIDrawTheMirrorNormally)
  {
 
    GLI_xSerialProjection (pstCamera ,4 ,
      pstAligned3DPointOfRectangleMirror ,
      pstAligned2DProjectedPointOfRectangleMirror ) ;
    
    fXMin=fXMax1;
    fXMax=fXMin1;
    fYMin=fYMax1;
    fYMax=fXMin1;
    
    for (j=0;j<4;j++)
    {
      if (MTH_M_bLess(pstAligned2DProjectedPointOfRectangleMirror[j].xX,fXMin)) 	fXMin=pstAligned2DProjectedPointOfRectangleMirror[j].xX;
      if (MTH_M_bGreater(pstAligned2DProjectedPointOfRectangleMirror[j].xX,fXMax)) 	fXMax=pstAligned2DProjectedPointOfRectangleMirror[j].xX;
      if (MTH_M_bLess(pstAligned2DProjectedPointOfRectangleMirror[j].xY,fYMin)) 	fYMin=pstAligned2DProjectedPointOfRectangleMirror[j].xY;
      if (MTH_M_bGreater(pstAligned2DProjectedPointOfRectangleMirror[j].xY,fYMax)) 	fYMax=pstAligned2DProjectedPointOfRectangleMirror[j].xY;
    }
    
    if (MTH_M_bGreater(fXMin,fXMax)) return FALSE;
    if (MTH_M_bGreater(fYMin,fYMax)) return FALSE;
    
    fXMin=MTH_M_xSub(fXMin,MTH_C_ONE);
    fXMax=MTH_M_xAdd(fXMax,MTH_C_ONE);
    fYMin=MTH_M_xSub(fYMin,MTH_C_ONE);
    fYMax=MTH_M_xAdd(fYMax,MTH_C_ONE);
    
    if (MTH_M_bLess(fXMin,fXMin1)) fXMin=fXMin1;
    
    if (MTH_M_bGreater(fXMax,fXMax1)) fXMax=fXMax1;
    
    if (MTH_M_bLess(fYMin,fYMin1)) fYMin=fYMin1;
    
    if (MTH_M_bGreater(fYMax,fYMax1)) fYMax=fYMax1;
    
    
    p_stVpt->dwClipLeftInPix=((long)fXMin);
    p_stVpt->dwClipRightInPix=((long)fXMax);
    p_stVpt->dwClipTopInPix=((long)fYMin);
    p_stVpt->dwClipBottomInPix=((long)fYMax);
 
    
    return TRUE;
  }
  else
  {
    if ((p_bPointOfMirrorIsBehindCamera[0])&&
      (p_bPointOfMirrorIsBehindCamera[1])&&
      (p_bPointOfMirrorIsBehindCamera[2])&&
      (p_bPointOfMirrorIsBehindCamera[3])) return FALSE;
    
    else
    {
      short xNewNbPoints=0;
      
      for (i=0;i<4;i++)
      {
        if (!p_bPointOfMirrorIsBehindCamera[i])
        {
          pstAligned3DCorrectedPointOfRectangleMirror[xNewNbPoints].xX=pstAligned3DPointOfRectangleMirror[i].xX;
          pstAligned3DCorrectedPointOfRectangleMirror[xNewNbPoints].xY=pstAligned3DPointOfRectangleMirror[i].xY;
          pstAligned3DCorrectedPointOfRectangleMirror[xNewNbPoints].xZ=pstAligned3DPointOfRectangleMirror[i].xZ;
          xNewNbPoints++;
        }	
        else
        {
          short xIPlusTemp=(i+1)%4;
          if (!p_bPointOfMirrorIsBehindCamera[xIPlusTemp])
          {
            xConstantDivForZ=
              MTH_M_xDiv(MTH_M_xSub(xConstantMinForZ,pstAligned3DPointOfRectangleMirror[i].xZ),
              pstAligned3DPointOfRectangleMirror[xIPlusTemp].xZ);
            
            pstAligned3DCorrectedPointOfRectangleMirror[xNewNbPoints].xX=
              MTH_M_xAdd(pstAligned3DPointOfRectangleMirror[i].xX,MTH_M_xMul(xConstantDivForZ,
              pstAligned3DPointOfRectangleMirror[xIPlusTemp].xX));
            
            pstAligned3DCorrectedPointOfRectangleMirror[xNewNbPoints].xY=
              MTH_M_xAdd(pstAligned3DPointOfRectangleMirror[i].xY,MTH_M_xMul(xConstantDivForZ,
              pstAligned3DPointOfRectangleMirror[xIPlusTemp].xY));
            
            pstAligned3DCorrectedPointOfRectangleMirror[xNewNbPoints].xZ=xConstantMinForZ;
            xNewNbPoints++;
          }	
          
          xIPlusTemp=(i+3)%4;
          if (!p_bPointOfMirrorIsBehindCamera[xIPlusTemp])
          {
            xConstantDivForZ=
              MTH_M_xDiv(MTH_M_xSub(xConstantMinForZ,pstAligned3DPointOfRectangleMirror[i].xZ),
              pstAligned3DPointOfRectangleMirror[xIPlusTemp].xZ);
            
            pstAligned3DCorrectedPointOfRectangleMirror[xNewNbPoints].xX=
              MTH_M_xAdd(pstAligned3DPointOfRectangleMirror[i].xX,MTH_M_xMul(xConstantDivForZ,
              pstAligned3DPointOfRectangleMirror[xIPlusTemp].xX));
            
            pstAligned3DCorrectedPointOfRectangleMirror[xNewNbPoints].xY=
              MTH_M_xAdd(pstAligned3DPointOfRectangleMirror[i].xY,MTH_M_xMul(xConstantDivForZ,
              pstAligned3DPointOfRectangleMirror[xIPlusTemp].xY));
            
            pstAligned3DCorrectedPointOfRectangleMirror[xNewNbPoints].xZ=xConstantMinForZ;
            xNewNbPoints++;
          }	
        }/* End of if point is behind	*/
        
      }/*End of for i*/
      
      GLI_xSerialProjection (pstCamera ,xNewNbPoints ,
        pstAligned3DCorrectedPointOfRectangleMirror ,
        pstAligned2DProjectedPointOfRectangleMirror ) ;
      
      /*			  g_stCurLLInterface.p_fnSerialSnap2DVertices (pstAligned2DProjectedPointOfRectangleMirror,xNewNbPoints);*/
      
      fXMin=fXMax1;
      fXMax=fXMin1;
      fYMin=fYMax1;
      fYMax=fXMin1;
      
      for (j=0;j<xNewNbPoints;j++)
      {
        if (MTH_M_bLess(pstAligned2DProjectedPointOfRectangleMirror[j].xX,fXMin)) 	fXMin=pstAligned2DProjectedPointOfRectangleMirror[j].xX;
        if (MTH_M_bGreater(pstAligned2DProjectedPointOfRectangleMirror[j].xX,fXMax)) 	fXMax=pstAligned2DProjectedPointOfRectangleMirror[j].xX;
        if (MTH_M_bLess(pstAligned2DProjectedPointOfRectangleMirror[j].xY,fYMin)) 	fYMin=pstAligned2DProjectedPointOfRectangleMirror[j].xY;
        if (MTH_M_bGreater(pstAligned2DProjectedPointOfRectangleMirror[j].xY,fYMax)) 	fYMax=pstAligned2DProjectedPointOfRectangleMirror[j].xY;
      }
      
      if (MTH_M_bGreater(fXMin,fXMax)) return FALSE;
      if (MTH_M_bGreater(fYMin,fYMax)) return FALSE;
      
      fXMin=MTH_M_xSub(fXMin,MTH_C_ONE);
      fXMax=MTH_M_xAdd(fXMax,MTH_C_ONE);
      fYMin=MTH_M_xSub(fYMin,MTH_C_ONE);
      fYMax=MTH_M_xAdd(fYMax,MTH_C_ONE);
      
      if (MTH_M_bLess(fXMin,fXMin1)) fXMin=fXMin1;
      
      if (MTH_M_bGreater(fXMax,fXMax1)) fXMax=fXMax1;
      
      if (MTH_M_bLess(fYMin,fYMin1)) fYMin=fYMin1;
      
      if (MTH_M_bGreater(fYMax,fYMax1)) fYMax=fYMax1;
      
      p_stVpt->dwClipLeftInPix=((long)fXMin);
      p_stVpt->dwClipRightInPix=((long)fXMax);
      p_stVpt->dwClipTopInPix=((long)fYMin);
      p_stVpt->dwClipBottomInPix=((long)fYMax);
 
 
      return TRUE;
      
    }/*End of not all points behind*/
    
      }/*End of not draw normally */
      
      return FALSE; 	  
}