#include "screen/ScreenDome.h"

using namespace projection;
using namespace gmtl;

/**
 * Constructor.
 *
 * @param pScreen Screen data.
 */
ScreenDome::ScreenDome(Screen* pScreen) : ScreenShape(pScreen)
{
    m_radius = 1.0;
    m_elevResolution = 16;
    m_azimResolution = 16;
    m_subdiv = 4;
    m_bFullDome = false;
}

/**
 * Destructor.
 */
ScreenDome::~ScreenDome()
{
}

/**
 * Set radius of the dome screen.
 *
 * @param radius Radius of the dome screen.
 */
void ScreenDome::setRadius(double radius)
{
    if (m_radius != radius)
    {
	    m_radius = radius;
	    notifyRedraw();
    }
}

/**
 * Set elevation resolution of the dome screen.
 *
 * @param resolution Elevation resolution of the dome screen.
 */
void ScreenDome::setElevResolution(unsigned int resolution)
{
	m_elevResolution = resolution;
	notifyRedraw();
}

/**
 * Set azimuth resolution of the dome screen.
 *
 * @param resolution Azimuth resolution of the dome screen.
 */
void ScreenDome::setAzimResolution(unsigned int resolution)
{
	m_azimResolution = resolution;
	notifyRedraw();
}

/**
 * Retrieve azimuth resolution of the dome screen.
 *
 * @return Azimuth resolution of the dome screen.
 */
void ScreenDome::setSubdivision(unsigned int subdiv)
{
	m_subdiv = subdiv;
	notifyRedraw();
}

/**
 * Select full dome or half dome.
 *
 * @param bFullDome True to select a full dome, False to select a half dome.
 */
void ScreenDome::setFullDome(bool bFullDome)
{
    m_bFullDome = bFullDome;
	notifyRedraw();
}

/**
 * Retrieve bounding box of the screen shape.
 *
 * @param min One corner of the screen shape.
 * @param max Another corner of the screen shape.
 */
void ScreenDome::getBoundingBox(gmtl::Vec3f& min, gmtl::Vec3f& max)
{
	min.set(-m_radius, -m_radius, 0.0);
	max.set(m_radius, m_radius, m_radius);
}

/**
 * Restore the screen shape from XML data.
 *
 * @param element Parent XML element of the screen shape data.
 */
bool ScreenDome::initFromDOMElement(const QDomElement& element)
{
    // don't notify redrawing by each restoring step
	if (!element.isNull())
	{
		m_radius = element.attribute("radius").toFloat();
		m_elevResolution = element.attribute("elevResolution").toInt();
		m_azimResolution = element.attribute("azimResolution").toInt();
		m_subdiv = element.attribute("subdivision").toInt();
		m_bFullDome= element.attribute("fullDome")=="true";
        // if change
        notifyRedraw();
	}

	return true;	// todo: secure this function and return false on any critical error
}

/**
 * Store the current screen shape as XML data.
 *
 * @param name XML node name of the data.
 * @param doc XML document to store the data.
 * @return Current screen shape data as XML data.
 */
QDomElement ScreenDome::domElement(const QString& name, QDomDocument& doc) const
{
	QDomElement de = doc.createElement(name);
	de.setAttribute("name", getName());
	de.setAttribute("radius", m_radius);
	de.setAttribute("elevResolution", m_elevResolution);
	de.setAttribute("azimResolution", m_azimResolution);
	de.setAttribute("subdivision", m_subdiv);
    de.setAttribute("fullDome", m_bFullDome?"true":"false");

	return de;
}

/**
 * Draw the shape model in inherited class.
 *
 * @param bFrame True to draw a wire frame mesh. False to draw as a polygon model.
 */
void ScreenDome::drawShape(bool bFrame)
{
    if (!bFrame)
    {
        // draw as a polygon model
        double azimDelta = Math::PI / m_azimResolution / m_subdiv;
	    double elevDelta = Math::PI / 2.0 / m_elevResolution / m_subdiv;
        if (m_bFullDome) azimDelta *= 2.0;
        for (unsigned int elevCount=0; elevCount<m_elevResolution*m_subdiv; ++elevCount)
	    {
		    glBegin(GL_QUAD_STRIP);
            for (unsigned int azimCount=0; azimCount<=m_azimResolution*m_subdiv; ++azimCount)
		    {
			    double nx, ny, nz;
			    nx = cos(-azimDelta*azimCount) * cos(elevDelta*elevCount);
			    ny = sin(elevDelta*elevCount);
			    nz = sin(-azimDelta*azimCount) * cos(elevDelta*elevCount);
			    glNormal3d(-nx, -ny, -nz);
			    glVertex3d(m_radius * nx, m_radius * ny, m_radius * nz);
			    nx = cos(-azimDelta*azimCount) * cos(elevDelta*(elevCount+1));
			    ny = sin(elevDelta*(elevCount+1));
			    nz = sin(-azimDelta*azimCount) * cos(elevDelta*(elevCount+1));
			    glNormal3d(-nx, -ny, -nz);
			    glVertex3d(m_radius * nx, m_radius * ny, m_radius * nz);
		    }
		    glEnd();
        }
    }
    else
    {
        // draw as a wire frame model

        double azimDelta = Math::PI / m_azimResolution / m_subdiv;
	    double elevDelta = Math::PI / 2.0 / m_elevResolution / m_subdiv;
        if (m_bFullDome) azimDelta *= 2.0;
        for (unsigned int elevCount=0; elevCount<m_elevResolution; ++elevCount)
	    {
            for (unsigned int azimCount=0; azimCount<m_azimResolution; ++azimCount)
		    {
                int subElevCount, subAzimCount;
                glBegin(GL_POLYGON);
                for (subElevCount=0; subElevCount<m_subdiv; ++subElevCount) {
                    double nx, ny, nz;
			        nx = cos(-azimDelta*azimCount*m_subdiv) * cos(elevDelta*(elevCount*m_subdiv+subElevCount));
			        ny = sin(elevDelta*(elevCount*m_subdiv+subElevCount));
			        nz = sin(-azimDelta*azimCount*m_subdiv) * cos(elevDelta*(elevCount*m_subdiv+subElevCount));
			        glNormal3d(-nx, -ny, -nz);
			        glVertex3d(m_radius * nx, m_radius * ny, m_radius * nz);
                }
                for (subAzimCount=0; subAzimCount<m_subdiv; ++subAzimCount) {
                    double nx, ny, nz;
			        nx = cos(-azimDelta*(azimCount*m_subdiv+subAzimCount)) * cos(elevDelta*(elevCount+1)*m_subdiv);
			        ny = sin(elevDelta*(elevCount+1)*m_subdiv);
			        nz = sin(-azimDelta*(azimCount*m_subdiv+subAzimCount)) * cos(elevDelta*(elevCount+1)*m_subdiv);
			        glNormal3d(-nx, -ny, -nz);
			        glVertex3d(m_radius * nx, m_radius * ny, m_radius * nz);
                }
                for (subElevCount=0; subElevCount<m_subdiv; ++subElevCount) {
                    double nx, ny, nz;
			        nx = cos(-azimDelta*(azimCount+1)*m_subdiv) * cos(elevDelta*((elevCount+1)*m_subdiv-subElevCount));
			        ny = sin(elevDelta*((elevCount+1)*m_subdiv-subElevCount));
			        nz = sin(-azimDelta*(azimCount+1)*m_subdiv) * cos(elevDelta*((elevCount+1)*m_subdiv-subElevCount));
			        glNormal3d(-nx, -ny, -nz);
			        glVertex3d(m_radius * nx, m_radius * ny, m_radius * nz);
                }
                for (subAzimCount=0; subAzimCount<m_subdiv; ++subAzimCount) {
                    double nx, ny, nz;
			        nx = cos(-azimDelta*((azimCount+1)*m_subdiv-subAzimCount)) * cos(elevDelta*elevCount*m_subdiv);
			        ny = sin(elevDelta*elevCount*m_subdiv);
			        nz = sin(-azimDelta*((azimCount+1)*m_subdiv-subAzimCount)) * cos(elevDelta*elevCount*m_subdiv);
			        glNormal3d(-nx, -ny, -nz);
			        glVertex3d(m_radius * nx, m_radius * ny, m_radius * nz);
                }
                glEnd();
		    }
        }
    }
}