VectorCtl.cpp

Go to the documentation of this file.

/*
===========================================================================

Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).  

Doom 3 Source Code 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 3 of the License, or
(at your option) any later version.

Doom 3 Source Code 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 for more details.

You should have received a copy of the GNU General Public License
along with Doom 3 Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/
#include "../../idlib/precompiled.h"
#pragma hdrstop


#include "VectorCtl.h"
#include <math.h>

BEGIN_MESSAGE_MAP(CVectorCtl, CButton)
        //{{AFX_MSG_MAP(idGLWidget)
        ON_WM_LBUTTONDOWN()
        ON_WM_LBUTTONUP()
        ON_WM_MOUSEMOVE()
        //}}AFX_MSG_MAP
END_MESSAGE_MAP()

CVectorCtl::CVectorCtl () :
    m_bBmpCreated (FALSE), 
    m_bImageChange (TRUE),
    m_bBackgroundBitmapUsed (FALSE),
    m_clrDiffuse (DEFAULT_DIFFUSE),
    m_clrAmbient (DEFAULT_AMBIENT),
    m_clrLight (DEFAULT_LIGHT),
    m_clrBackgroundStart (DEFAULT_START_BACKGROUND_COLOR),
    m_clrBackgroundEnd (DEFAULT_END_BACKGROUND_COLOR),
    m_dSpecularExponent (DEFAULT_SPEC_EXP),
    m_bHasFocus (FALSE), 
    m_bSelected (FALSE),
    m_bFrontVector (FALSE),
    m_dSensitivity (20.0),
    m_procVectorChanging (NULL),
    m_procVectorChanged (NULL)
{
    double DefaultVec[3] = DEFAULT_VEC;
    for (int i=0; i<3; i++) {
        m_dVec[i] = DefaultVec[i];
        pCtl[i] = NULL;
    }

        rotationQuat.Set( 0.0f, 0.0f, 0.0f, 1.0f );
        lastPress.Zero();
        radius = 0.6f;
}


CVectorCtl::~CVectorCtl () 
{
    if (m_bBmpCreated) 
        m_dcMem.SelectObject (m_pOldBitmap);
    ClearBackgroundBitmap ();
}

// Owner-drawn control service function:
void CVectorCtl::DrawItem( LPDRAWITEMSTRUCT lpDrawItemStruct )
{
    CDC *pDC = CDC::FromHandle (lpDrawItemStruct->hDC); // Get CDC to draw

    if (!m_bSelected && lpDrawItemStruct->itemState & ODS_SELECTED) {
            // Just got re-selected (user starts a new mouse dragging session)
    } else if (m_bSelected && // Last state was selected
               !(lpDrawItemStruct->itemState & ODS_SELECTED) &&     // New state is NOT selected   
               (lpDrawItemStruct->itemState & ODS_FOCUS) &&         // New state is still in focus
               m_procVectorChanged)     // User asked for a callback
        // User has left the track-ball and asked for a callback.
        m_procVectorChanged ( rotationQuat ); 
          
    m_bHasFocus = lpDrawItemStruct->itemState & ODS_FOCUS;      // Update focus status
    m_bSelected = lpDrawItemStruct->itemState & ODS_SELECTED;   // Update selection status

    if (!m_bBmpCreated)  // 1st time
        InitBitmap (lpDrawItemStruct, pDC);
    if (m_bImageChange) {   // Image has changes - recalc it!
        if (m_procVectorChanging)   // User has specified a callback
            m_procVectorChanging ( rotationQuat ); // Call it!
        BuildImage (lpDrawItemStruct);
        m_bImageChange = FALSE;
    }
    pDC->BitBlt (0,0,m_iWidth, m_iHeight, &m_dcMem, 0, 0, SRCCOPY); // Update screen
}

// Mouse was dragged 
void CVectorCtl::OnMouseDrag (int ixMove, int iyMove)
{
    RotateByXandY (double(-iyMove) / m_dSensitivity,
                   double(ixMove) / m_dSensitivity);
}

// Recalc ball image
void CVectorCtl::BuildImage (LPDRAWITEMSTRUCT lpDrawItemStruct)
{
    int xf, yf;

    for (int x=0; x<m_iWidth; x++)  // Scan all columns
        for (int y=0; y<m_iHeight; y++) {   // Scan all rows
            xf = x-m_iXCenter;  // Find distance from center
            yf = y-m_iYCenter;
            if (xf*xf + yf*yf <= m_iSqrRadius) {    // Point on ball surface
                double vx = double(xf) / double(m_iRadius),
                       vy = double(yf) / double(m_iRadius),
                       vz = sqrt (1.0 - vx*vx - vy*vy);     // Find ball's normal
                m_dcMem.SetPixelV (x,y, CalcLight (vx,vy,vz));
            } 
        }
}

// Normalize a vector to unit size
BOOL CVectorCtl::Normalize ()
{
    double Norm = m_dVec[0] * m_dVec[0] + m_dVec[1] * m_dVec[1] + m_dVec[2] * m_dVec[2];

    if (Norm > EPS) {
        Norm = sqrt (Norm);
        m_dVec[0] /= Norm;
        m_dVec[1] /= Norm;
        m_dVec[2] /= Norm;
        return TRUE;
    } else {    // Reset to defualt vector
        double DefaultVec[3] = DEFAULT_VEC;
        for (int i=0; i<3; i++) 
            m_dVec[i] = DefaultVec[i];
        return FALSE;
    }
}

// Calculate lightning effect for specific pixel on ball's surface
COLORREF CVectorCtl::CalcLight (double dx, double dy, double dz)
{
    double NL = dx * m_dVec[0] + dy * m_dVec[1] + dz * m_dVec[2], 
           RV = 2.0 * NL,
           rx = m_dVec[0] - (dx * RV),
           ry = m_dVec[1] - (dy * RV),
           rz = m_dVec[2] - (dz * RV);

    if (NL < 0.0)   // Diffuse coefficient
        NL = 0.0;

    RV = max (0.0, -rz);
    RV = double(pow (RV, m_dSpecularExponent));

    int  r = int (  double(GetRValue(m_clrDiffuse)) * NL +  // Diffuse
                    double(GetRValue(m_clrLight)) * RV +    // Specular
                    double(GetRValue(m_clrAmbient))),       // Ambient

         g = int (  double(GetGValue(m_clrDiffuse)) * NL +  // Diffuse
                    double(GetGValue(m_clrLight)) * RV +    // Specular
                    double(GetGValue(m_clrAmbient))),       // Ambient    

         b = int (  double(GetBValue(m_clrDiffuse)) * NL +  // Diffuse
                    double(GetBValue(m_clrLight)) * RV +    // Specular
                    double(GetBValue(m_clrAmbient)));       // Ambient

    r = min (255, r);   // Cutoff highlight
    g = min (255, g);
    b = min (255, b);
    return RGB(BYTE(r),BYTE(g),BYTE(b));
}


// Start memory buffer bitmap and measure it
void CVectorCtl::InitBitmap (LPDRAWITEMSTRUCT lpDrawItemStruct, CDC *pDC)
{
    m_iWidth = lpDrawItemStruct->rcItem.right - lpDrawItemStruct->rcItem.left;
    m_iHeight = lpDrawItemStruct->rcItem.bottom - lpDrawItemStruct->rcItem.top;
    m_bmpBuffer.CreateCompatibleBitmap (pDC, m_iWidth, m_iHeight);
    m_bBmpCreated = TRUE;
    m_dcMem.CreateCompatibleDC (pDC);
    m_pOldBitmap = m_dcMem.SelectObject (&m_bmpBuffer);
    SetRadius (max (min (m_iWidth, m_iHeight) - 2, 0) / 2);
    SetCenter (m_iWidth / 2, m_iHeight / 2);
    CreateBackground ();
}

// Set new specular intensity
BOOL CVectorCtl::SetSpecularExponent (double dExp)
{
    if (dExp < 1.0 || dExp > 200.0)
        return FALSE;
    m_dSpecularExponent = dExp;
    Redraw ();
    return TRUE;
}

// Rotate our vector around the X and Y axis
void CVectorCtl::RotateByXandY (double XRot, double YRot)
{   // Angles are in radians

        if (XRot == 0.0 && YRot == 0.0) {
                return;
        }

    double cx = cos(XRot),
           sx = sin(XRot),
           cy = cos(YRot),
           sy = sin(YRot),
           dx = m_dVec[0] * cy + m_dVec[1] * sx * sy + m_dVec[2] * cx * sy,
           dy = m_dVec[1] * cx - m_dVec[2] * sx,
           dz = -m_dVec[0] * sy + m_dVec[1] * sx * cy + m_dVec[2] * cx * cy;

    if (!m_bFrontVector || dz >= 0.0) { // Vector is bounds free
        m_dVec[0] = dx;
        m_dVec[1] = dy;
        m_dVec[2] = dz;
    } else {    // Otherwise, do not allow Z to be negative (light shines from behind)
        m_dVec[2] = 0.0;
        m_dVec[0] = dx;
        m_dVec[1] = dy;
        Normalize ();
    }
    Redraw ();
}

 
void CVectorCtl::UpdateAxisControls ()
{
    CString cs;
    for (int i=0; i<3; i++) 
        if (pCtl[i]) {
            cs.Format ("%+1.5f",m_dVec[i]);
            pCtl[i]->SetWindowText (cs);
        }
}            

void CVectorCtl::SetAxisControl (int nXCtl, int nYCtl, int nZCtl)
{
    pCtl[0] = GetParent()->GetDlgItem(nXCtl);
    pCtl[1] = GetParent()->GetDlgItem(nYCtl);
    pCtl[2] = GetParent()->GetDlgItem(nZCtl);
}

void CVectorCtl::SetRadius (UINT uRadius)
{
    m_iRadius = uRadius;
    m_iSqrRadius = m_iRadius * m_iRadius;
    CreateBackground ();
    Redraw (TRUE);
}


void CVectorCtl::SetCenter (UINT uHorizPos, UINT uVertPos)
{
    m_iXCenter = uHorizPos;
    m_iYCenter = uVertPos;
    CreateBackground ();
    Redraw (TRUE);
}


void CVectorCtl::SetAxis (double d, int nAxis)
{
    if (fabs(d)>=1.0) {
        m_dVec[nAxis]=d > 1.0 ? 1.0 : -1.0;
        m_dVec[(nAxis+1) %3]=m_dVec[(nAxis+2) %3]=0.0;
        Redraw ();
        return;
    } 
    m_dVec[nAxis] = d;
    Normalize ();
    Redraw ();
}

void CVectorCtl::SetVector (double dx, double dy, double dz)
{
    m_dVec[0] = dx;
    m_dVec[1] = dy;
    m_dVec[2] = dz;
    Normalize ();
    Redraw ();
}

void CVectorCtl::SetBackgroundColor (COLORREF clrStart, COLORREF clrEnd)
{
    ClearBackgroundBitmap ();
    m_clrBackgroundStart = clrStart;
    m_clrBackgroundEnd = clrEnd;
    CreateBackground ();
}


BOOL CVectorCtl::SetBackgroundImage (UINT uBackgroundBitmapID)
{
    if (m_bBackgroundBitmapUsed) {
        ClearBackgroundBitmap ();
        CreateBackground ();
    }
    if (!m_bmpBack.LoadBitmap (uBackgroundBitmapID))
        return FALSE;
    m_bBackgroundBitmapUsed = TRUE;
    CreateBackground ();
    return TRUE;
}

void CVectorCtl::CreateBackground ()
{
    if (!m_bBmpCreated)
        return; //  No image yet
    if (!m_bBackgroundBitmapUsed) { // No background used - fill with gradient color
        double r = GetRValue (m_clrBackgroundStart),
               g = GetGValue (m_clrBackgroundStart),
               b = GetBValue (m_clrBackgroundStart), 
               rd = double (GetRValue (m_clrBackgroundEnd) - r) / double (m_iHeight),
               gd = double (GetGValue (m_clrBackgroundEnd) - g) / double (m_iHeight), 
               bd = double (GetBValue (m_clrBackgroundEnd) - b) / double (m_iHeight);
        for (int j=0; j<m_iHeight; j++) {
            for (int i=0; i<m_iWidth; i++)
                m_dcMem.SetPixelV (i,j, RGB (BYTE(r),BYTE(g),BYTE(b)));
            r+=rd; g+=gd; b+=bd;
        }
        Redraw (TRUE);
        return;
    }
    // Bitmap used : tile it in back
    CDC DCtmp;
    BITMAP tmpBitmap;

    m_bmpBack.GetBitmap (&tmpBitmap);
    int iTmpWidth = tmpBitmap.bmWidth,
        iTmpHeight = tmpBitmap.bmHeight;

    DCtmp.CreateCompatibleDC (&m_dcMem);
    m_pOldBitmap = DCtmp.SelectObject (&m_bmpBack);
    
    for (int i=0; i<m_iWidth; i++)
        for (int j=0; j<m_iHeight; j++)
            m_dcMem.SetPixelV (i,j, DCtmp.GetPixel (i % iTmpWidth, j % iTmpHeight));
    DCtmp.SelectObject (m_pOldBitmap);
    Redraw (TRUE);
}    

    
void CVectorCtl::ClearBackgroundBitmap ()
{
    if (!m_bBackgroundBitmapUsed)
        return;
    m_bmpBack.DeleteObject ();
    m_bBackgroundBitmapUsed = FALSE;
}

BOOL CVectorCtl::SetSensitivity (UINT uSens)
{
    if (uSens == 0)
        return FALSE;
    m_dSensitivity = double(uSens);
    return TRUE;
}

void CVectorCtl::Redraw (BOOL bErase) {
    m_bImageChange = TRUE;
    UpdateAxisControls();
    Invalidate (bErase);
}

void CVectorCtl::OnMouseMove(UINT nFlags, CPoint point) {

        if ( CWnd::GetCapture() != this ) {
                return;
        }

        float curX = ( float )( 2 * point.x - 64 ) / 64;
        float curY = ( float )( 2 * point.y - 64 ) / 64;

        idVec3 to( -curX, -curY, 0.0f );
        to.ProjectSelfOntoSphere( radius );
        lastPress.ProjectSelfOntoSphere( radius );

        idVec3 axis;
        axis.Cross( to, lastPress );
        float len = ( lastPress - to ).Length() / ( 2.0f * radius );
        len = idMath::ClampFloat( -1.0f, 1.0f, len );
        float phi = 2.0f * asin ( len ) ;

        axis.Normalize();
        axis *= sin( phi / 2.0f );
        idQuat rot( axis.z, axis.y, axis.x, cos( phi / 2.0f ) );
        rot.Normalize();

        rotationQuat *= rot;
        rotationQuat.Normalize();

        lastPress = to;
        lastPress.z = 0.0f;

        m_dVec = rotationQuat.ToMat3()[2];
        m_dVec.Normalize();
        Redraw();
}

void CVectorCtl::OnLButtonDown(UINT nFlags, CPoint point) {
        float curX = ( float )( 2 * point.x - 64 ) / 64;
        float curY = ( float )( 2 * point.y - 64 ) / 64;
        lastPress.Set( -curX, -curY, 0.0f );
        SetCapture();
}

void CVectorCtl::OnLButtonUp(UINT nFlags, CPoint point) {
        ReleaseCapture();
}