#include <Checkerboard.h>

Collaboration diagram for Checkerboard:

Public Member Functions
	Checkerboard (float xSize, float ySize, size_t xSquares, size_t ySquares)

void	setDarkColor (const float *dark)

void	setLightColor (const float *light)

const float *	getSize ()

void	computeVertices (std::vector< float > &vertices, std::vector< float > &normals, std::vector< float > &colors)

Private Attributes
const float *	_darkColor = checkerboardDark

const float *	_lightColor = checkerboardLight

float	_size [2]

size_t	_squares [2]

Detailed Description

Definition at line 15 of file Checkerboard.h.

Constructor & Destructor Documentation

Checkerboard::Checkerboard	(	float	xSize,
		float	ySize,
		size_t	xSquares,
		size_t	ySquares
	)

Construct a new checkerboard at the origin

Parameters

xSize	: width, meters
ySize	: height, meters
xSquares	: number of squares along x (must be at least 1)
ySquares	: number of squares along y (must be at least 2)

Definition at line 17 of file Checkerboard.cpp.

References _size, and _squares.

                                             {
   _size[0] = xSize;
   _size[1] = ySize;
   _squares[0] = xSquares;
   _squares[1] = ySquares;
   //  computeVertices();
 }

Member Function Documentation

void Checkerboard::computeVertices	(	std::vector< float > &	vertices,
		std::vector< float > &	normals,
		std::vector< float > &	colors
	)

Update the checkerboard vertices for the current sizees

Definition at line 29 of file Checkerboard.cpp.

References _darkColor, _lightColor, _size, and _squares.

                                                              {
   // 3 channels, n*m squares, 2 triangles, 3 vertices per triangle
   size_t dataSize = 3 * _squares[0] * _squares[1] * 3 * 2;
   vertices.clear();
   normals.clear();
   colors.clear();
   vertices.reserve(dataSize);
   normals.reserve(dataSize);
   colors.reserve(dataSize);
 
   const float xStep = _size[0] / (float)_squares[0];
   const float yStep = _size[1] / (float)_squares[1];
 
   for (size_t i = 0; i < _squares[0]; i++) {
     for (size_t j = 0; j < _squares[1]; j++) {
       // add normals and color
       const float* squareColor = (i + j) % 2 ? _darkColor : _lightColor;
       for (size_t k = 0; k < 6; k++) {
         for (size_t m = 0; m < 3; m++) {
           colors.push_back(squareColor[m]);
           normals.push_back(m == 2 ? 1 : 0);
         }
       }
 
       const float xStart = xStep * i;
       const float yStart = yStep * j;
 
       // tri 1
       vertices.push_back(xStart);
       vertices.push_back(yStart);
       vertices.push_back(0);
 
       vertices.push_back(xStart);
       vertices.push_back(yStart + yStep);
       vertices.push_back(0);
 
       vertices.push_back(xStart + xStep);
       vertices.push_back(yStart);
       vertices.push_back(0);
 
       // tri 2
       vertices.push_back(xStart);
       vertices.push_back(yStart + yStep);
       vertices.push_back(0);
 
       vertices.push_back(xStart + xStep);
       vertices.push_back(yStart + yStep);
       vertices.push_back(0);
 
       vertices.push_back(xStart + xStep);
       vertices.push_back(yStart);
       vertices.push_back(0);
     }
   }
 }

   Here is the caller graph for this function: