Web alhem.net

Grid.cpp

Go to the documentation of this file.

/*
Copyright (C) 2004  Anders Hedstrom

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 for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
#include <stdincl.h>
#include <math.h>

#include "client.h"
#include "mandel.h"
#include "Globals.h"
#include "events/Facing.h"
#include "events/Position.h"
#include "Grid.h"


Grid::Grid()
:m_x(640)
,m_y(480)
,m_base(40)
,m_hbase( (int)(cos(2 * M_PI * 30 / 360) * (double)m_base) )
,m_left(0)
,m_right(0)
,m_top(0)
,m_bottom(0)
,m_w(0)
,m_h(0)
,m_riktning(-1)
,m_xpos(-1)
,m_ypos(-1)
{
        ReCalculate();
        for (double d = 0; d < 360; d++)
        {
                m_sin[(int)d] = sin(2 * M_PI * d / 360);
        }
}


Grid::~Grid()
{
}


void Grid::ReCalculate()
{
        double hstep = cos(2 * M_PI * 30 / 360);

DEB(
  for (double h = 0; h <= 180; h += 45)
        {
    printf("cos(%.0f) = %f\n", h, cos(2 * M_PI * h / 360));
                printf("sin(%.0f) = %f\n", h, sin(2 * M_PI * h / 360));
        })
        m_hbase = (int)(hstep * (double)m_base);

        m_w = ((m_x - m_base/2) / 2) / m_base;
        m_w = m_w * 2 + 1;

        m_h = (m_y / 2) / m_hbase;
        m_h = m_h * 2 + 1;

        while (m_x / 2 + m_left * m_base >= 0)
        {
                m_left--;
        }
        while (m_x / 2 + m_right * m_base < m_x)
        {
                m_right++;
        }
#define MAX_ELEVATION 255
        while (m_y / 2 + m_top * m_hbase >= 0 - MAX_ELEVATION)
        {
                m_top--;
        }
        while (m_y / 2 + m_bottom * m_hbase < m_y + MAX_ELEVATION)
        {
                m_bottom++;
        }
DEB(
  printf("Resolution %d x %d with a base of %d gives\n",m_x,m_y,m_base);
        printf(" base = %d\n",m_hbase);
        printf(" width = %d\n",m_w);
        printf(" height = %d\n",m_h);
        printf(" X %d..%d\n",m_left,m_right);
        printf(" Y %d..%d\n",m_top,m_bottom);)
}


void Grid::SetSize(int x,int y)
{
        m_x = x;
        m_y = y;
        ReCalculate();
}


void Grid::SetBase(int b)
{
        m_base = b;
        ReCalculate();
}


int Grid::GetBase()
{
        return m_base;
}


int Grid::GetWidth()
{
        return m_w;
}


int Grid::GetHeight()
{
        return m_h;
}


void Grid::GetXY(int x,int y,int *cx,int *cy,int *elevation)
{
        // center is at [0,0]
        // 
        //   0,0 1,0 2,0 3,0
        //     0,1 1,1 2,1 3,1
        //   0,2 1,2 2,2 3,2
        //     0,3 1,3 2,3 3,3
        //

        *cx = m_x / 2 + x * m_base;
        if (y % 2)
        {
                *cx = *cx + m_base / 2;
        }
        *cy = m_y / 2 + y * m_hbase;

        // hojdjustering
/*
        *elevation = 0;
        double dist = sqrt(x * x + y * y);
        if (!x && !y)
        {
                *elevation = -20;
        }
        if ((x == 2 || x == 3) && (y == 2 || y == 3))
        {
                *elevation = 10;
        }
        if (dist > 4)
        {
                *elevation = -dist * 2;
        }
*/
        *elevation = mandel_color(x,y);
}


int Grid::GetHBase()
{
        return m_hbase;
}


double Grid::Sin(int x)
{
        return m_sin[x % 360];
}


void Grid::SetDirection(Event::Facing *e)
{
        m_riktning = e -> GetRiktning();
}


void Grid::SetPosition(Event::Position *e)
{
        m_xpos = e -> GetX();
        m_ypos = e -> GetY();
}

---