rendered paste body/**************************
* Includes
*
**************************/
#include <cstdio>
#include <windows.h>
#include <gl/gl.h>
#include "Drawer.hpp"
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
/**************************
* Function Declarations
*
**************************/
LRESULT CALLBACK WndProc (HWND hWnd, UINT message,
WPARAM wParam, LPARAM lParam);
void EnableOpenGL (HWND hWnd, HDC *hDC, HGLRC *hRC);
void DisableOpenGL (HWND hWnd, HDC hDC, HGLRC hRC);
/**************************
* WinMain
*
**************************/
int WINAPI WinMain (HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int iCmdShow)
{
WNDCLASS wc;
HWND hWnd;
HDC hDC;
HGLRC hRC;
MSG msg;
BOOL bQuit = FALSE;
float theta = 0.0f;
/* register window class */
wc.style = CS_OWNDC;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon (NULL, IDI_APPLICATION);
wc.hCursor = LoadCursor (NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH) GetStockObject (BLACK_BRUSH);
wc.lpszMenuName = NULL;
wc.lpszClassName = "GLSample";
RegisterClass (&wc);
/* create main window */
hWnd = CreateWindow("GLSample","OpenGL Sample",WS_CAPTION|WS_POPUPWINDOW|WS_VISIBLE,
96,96,800,600,NULL,NULL,hInstance,NULL);
/* enable OpenGL for the window */
EnableOpenGL (hWnd, &hDC, &hRC);
//Drawer(float fScreeMaxX,float fScreenMaxY,float fScreenMinX,float fScreenMinY,
// int iScreenX,int iScreenY,int iPixelSize);
Drawer Simple(0.9f,0.9f,-0.9f,-0.9f,128,128);
float fStartTime = (float)GetTickCount();
int iTime=0;
srand(2);
/* program main loop */
while (!bQuit)
{
/* check for messages */
if (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
{
/* handle or dispatch messages */
if (msg.message == WM_QUIT)
{
bQuit = TRUE;
}
else
{
TranslateMessage (&msg);
DispatchMessage (&msg);
}
}
else
{
Flat(iTime,Simple.iScreenHeight,Simple.iScreenWidth,Simple.grid,0,0);
Rand(iTime,Simple.iScreenHeight,Simple.iScreenWidth,Simple.grid,-32,-32);
/* OpenGL animation code goes here */
glClearColor (0.0f, 0.0f, 0.0f, 0.0f);
glClear (GL_COLOR_BUFFER_BIT);
glPushMatrix ();
//glRotatef (theta, 0.0f, 0.0f, 1.0f);
glRotatef (theta,1.0f,1.0f,0.0f);
//glBegin (GL_LINE_STRIP);
Simple.Draw();
//glEnd ();
glPopMatrix ();
SwapBuffers (hDC);
//theta += 1.0f;
theta = 45.0f;
Sleep (50);
iTime++;
/*
if(iTime%180 == 0)
{
char cBuffer[100];
sprintf(cBuffer,"%f",1000.0f/((GetTickCount() - fStartTime)/180.0f) );
MessageBox(NULL,cBuffer,"Hello",MB_OK);
fStartTime = GetTickCount();
}
*/
}
}
/* shutdown OpenGL */
DisableOpenGL (hWnd, hDC, hRC);
/* destroy the window explcitly */
DestroyWindow (hWnd);
return msg.wParam;
}
/********************
* Window Procedure
*
********************/
LRESULT CALLBACK WndProc (HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam)
{
switch (message)
{
case WM_CREATE:
return 0;
case WM_CLOSE:
PostQuitMessage (0);
return 0;
case WM_DESTROY:
return 0;
case WM_KEYDOWN:
switch (wParam)
{
case VK_ESCAPE:
PostQuitMessage(0);
return 0;
}
return 0;
default:
return DefWindowProc (hWnd, message, wParam, lParam);
}
}
/*******************
* Enable OpenGL
*
*******************/
void EnableOpenGL (HWND hWnd, HDC *hDC, HGLRC *hRC)
{
PIXELFORMATDESCRIPTOR pfd;
int iFormat;
/* get the device context (DC) */
*hDC = GetDC (hWnd);
/* set the pixel format for the DC */
ZeroMemory (&pfd, sizeof (pfd));
pfd.nSize = sizeof (pfd);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW |
PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 24;
pfd.cDepthBits = 16;
pfd.iLayerType = PFD_MAIN_PLANE;
iFormat = ChoosePixelFormat (*hDC, &pfd);
SetPixelFormat (*hDC, iFormat, &pfd);
/* create and enable the render context (RC) */
*hRC = wglCreateContext( *hDC );
wglMakeCurrent( *hDC, *hRC );
}
/******************
* Disable OpenGL
*
******************/
void DisableOpenGL (HWND hWnd, HDC hDC, HGLRC hRC)
{
wglMakeCurrent (NULL, NULL);
wglDeleteContext (hRC);
ReleaseDC (hWnd, hDC);
}
/**********
Header starts
***********/
#ifndef drawer_hpp
#define drawer_hpp
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
class Drawer
{
private:
float fMinX;
float fMinY;
float fHeight;
float fWidth;
float fDistX;
float fDistY;
float iScale;
float jScale;
std::vector<float> distances;
std::vector<float> vertices;
std::vector<float> colors;
public:
int iScreenHeight;
int iScreenWidth;
std::vector<float> grid;
//Constructor
Drawer(float fScreeMaxX,float fScreenMaxY,float fScreenMinX,float fScreenMinY,
int iScreenX,int iScreenY);
//Drawers
void Draw();
};
static const float fRadian = 3.14159265f / 180.0f;
Drawer::Drawer(float fScreenMaxX,float fScreenMaxY,float fScreenMinX,float fScreenMinY,int iScreenX,
int iScreenY)
: distances(iScreenX * iScreenY)
, grid(iScreenX * iScreenY)
, vertices((iScreenX - 1) * iScreenY * 6)
, colors((iScreenX - 1) * iScreenY * 6)
{
fMinX = fScreenMinX;
fMinY = fScreenMinY;
fHeight = fScreenMaxY - fScreenMinY;
fWidth = fScreenMaxX - fScreenMinX;
fDistX = fWidth/iScreenX;
fDistY = fHeight/iScreenY;
iScreenHeight = iScreenX;
iScreenWidth = iScreenY;
iScale = 128./iScreenWidth;
jScale = 128./iScreenHeight;
}
void Drawer::Draw()
{
int i = 0;
glColor3f(0.0f,0.0f,1.0f);
while(i < iScreenHeight - 1)
{
float fResult[2];
int j = 0;
while(j < iScreenWidth) {
fResult[0] = grid[(i + 1) * iScreenWidth + j];
fResult[1] = grid[i * iScreenWidth + j];
int index = (i*iScreenWidth+j)*6;
colors[index + 2] = 0.5 + fResult[0]*5;
colors[index + 5] = 0.5 - fResult[1]*5;
float fX = fMinX + i*fDistX;
float fY = fMinY + j*fDistY;
vertices[index] = fX + fDistX;
vertices[index+1] = fY;
vertices[index+2] = fResult[0];
vertices[index+3] = fX;
vertices[index+4] = fY;
vertices[index+5] = fResult[1];
j++;
}
i++;
}
glVertexPointer(3, GL_FLOAT, 0, &vertices[0]);
glColorPointer(3, GL_FLOAT, 0, &colors[0]);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
for (int i = 0; i < iScreenHeight-1; ++i)
glDrawArrays(GL_TRIANGLE_STRIP, iScreenWidth*i*2, iScreenWidth*2);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
}
void Circular(float fT,int iHeight,int iWidth,std::vector<float> & fGrid,int iCenterX,int iCenterY)
{
fT /= fRadian;
for (int i = 0; i < iHeight; ++i)
{
for (int j = 0; j < iWidth; ++j)
{
float fX = (float)(i - iCenterX)*2.;
float fY = (float)(j - iCenterY)*2.;
float fDistance = sqrt(fX*fX+fY*fY);
float fCircular = cos(fDistance - fT)*0.0125;
float fDamp = fDistance*0.0125;
float fWave = cos (fX+fT)*0.025;
if(fDamp < 0.5f)
fDamp = 0.5f;
fGrid[i * iWidth + j] += fCircular/fDamp;// + fWave;
}
}
}
void Rand(int iT,int iHeight,int iWidth,std::vector<float> & fGrid,int iCenterX,int iCenterY)
{
static int iRand[32];
static int iCoolDown = 0;
if (!iT)
{
int k = 0;
while(k < 32)
iRand[k++] = rand()%4;
}
int iIterator;
int k = 0;
if(!iCoolDown)
{
int iTemp = rand()%16;
iRand[iTemp] = rand()%4;
//iRand[k+1] = iT;
if(iTemp < 4)
iCoolDown = 96;
}
else
{
iRand[16 + (iCoolDown%16)-8] = rand()%4;
iCoolDown--;
}
for (int i = 0; i < iHeight; i++)
{
for (int j = 0; j < iWidth; j++)
{
float fX = (float)(i-iCenterX)/(float)(iHeight);
float fY = (float)(j-iCenterY)/(float)(iWidth);
iIterator = 0;
while( fX < 4 && fY < 4)
{
if(iRand[iIterator] == 0)
{
float fTemp = fX;
fX = fY/2;
fY = fTemp*2;
}
else if(iRand[iIterator] == 1)
{
float fTemp = fY;
fY = cos(fX);
fX = cos(fTemp);
}
else if(iRand[iIterator] == 2)
{
fX = fX*fX;
fY = 1./fY;
}
else if(iRand[iIterator] == 3)
{
float fTemp = fY;
fY = (fY-fX) * fY;
fX = (fX-fTemp) * fX;
}
if(iIterator >= 32)
break;
iIterator++;
}
fGrid[i * iWidth + j] = 0.0625 + (float)(iIterator-32)/128.0f;
}
}
}
void Flat(float fT,int iHeight,int iWidth,std::vector<float> & fGrid,int iCenterX,int iCenterY)
{
for (int i = 0; i < iHeight; ++i)
{
for (int j = 0; j < iWidth; ++j)
{
fGrid[i * iWidth + j] = 0;
}
}
}
#endif