| 3D C/C++ tutorials - Software rendering - Simple software renderer |
| Home Resources OpenGL Software rendering Ray tracing Downloads |
|
3D C/C++ tutorials -> Software rendering -> Simple software renderer
Use for personal or educational purposes only. Commercial and other profit uses strictly prohibited. Exploitation of content on a website or in a publication prohibited.
To compile and run these tutorials some or all of these libraries are required: FreeImage 3.16.0, GLEW 1.11.0, GLUT 3.7.6 / GLUT for Dev-C++, GLM 0.9.5.4
simple_software_renderer_multithreading_v1.h
// ----------------------------------------------------------------------------------------------------------------------------
#include <windows.h>
#ifndef WM_MOUSWHEEL
#define WM_MOUSWHEEL 0x020A
#endif
#include "string.h"
#include "glmath.h"
#include <FreeImage.h> // http://freeimage.sourceforge.net/
#pragma comment(lib, "FreeImage.lib")
#pragma comment(lib, "winmm.lib")
#pragma warning(disable : 4996)
// ----------------------------------------------------------------------------------------------------------------------------
class CTexture
{
private:
FIBITMAP *DIB;
BYTE *Bits;
private:
int Width, Height, Pitch, BPP;
public:
CTexture();
~CTexture();
private:
void SetDefaults();
public:
bool LoadTexture(char *TextureFileName);
void GetColorNearest(float s, float t, float *r, float *g, float *b);
void GetColorBilinear(float s, float t, float *r, float *g, float *b);
void Destroy();
};
// ----------------------------------------------------------------------------------------------------------------------------
class CCamera
{
public:
vec3 X, Y, Z, Position, Reference;
public:
mat4x4 ViewMatrix, ProjectionMatrix, ViewProjectionMatrix;
public:
CCamera();
~CCamera();
public:
void Look(const vec3 &Position, const vec3 &Reference, bool RotateAroundReference = false);
void Move(const vec3 &Movement);
vec3 OnKeys(BYTE Keys, float FrameTime);
void OnMouseMove(int dx, int dy);
void OnMouseWheel(float zDelta);
void SetPerspective(float fovy, float aspect, float n, float f);
private:
void CalculateViewMatrix();
};
// ----------------------------------------------------------------------------------------------------------------------------
class CVertex
{
public:
vec3 Position;
vec3 Color;
vec2 TexCoord;
vec3 Normal;
};
// ----------------------------------------------------------------------------------------------------------------------------
class CObject
{
public:
CTexture Texture;
public:
CVertex *Vertices;
int VerticesCount;
public:
vec3 Min, Max;
public:
CObject();
~CObject();
private:
void SetDefaults();
public:
bool Load(char *Directory, char *ObjFileName);
void Translate(const vec3 &Translation);
void Scale(float ScaleFactor);
void Rotate(float Angle, const vec3 &Axis);
void Destroy();
private:
bool ReadSource(char *Directory, char *FileName, char **Source, long &Length);
bool ParseMtl(char *Directory, char *MtlFileName);
void GetMinMax();
};
// ----------------------------------------------------------------------------------------------------------------------------
class CLight
{
public:
vec3 Position;
vec3 Ambient;
vec3 Diffuse;
float ConstantAttenuation;
float LinearAttenuation;
float QuadraticAttenuation;
};
// ----------------------------------------------------------------------------------------------------------------------------
class CFragment
{
public:
float x, y, z, w, r, g, b, s, t;
};
// ----------------------------------------------------------------------------------------------------------------------------
class CEdge
{
public:
CFragment *Fragment1, *Fragment2;
public:
float dx, dy, dz, dw, dr, dg, db, ds, dt;
public:
void Set(CFragment *Fragment1, CFragment *Fragment2);
private:
void CalculateDiffs();
};
// ----------------------------------------------------------------------------------------------------------------------------
class CSpan
{
public:
CFragment *Fragment1, *Fragment2;
public:
float dx, dy, dz, dw, dr, dg, db, ds, dt;
public:
void Set(CFragment *Fragment1, CFragment *Fragment2);
private:
void CalculateDiffs();
};
// ----------------------------------------------------------------------------------------------------------------------------
#define NONE 0x00
#define CULL_FACE_FRONT 0x01
#define CULL_FACE_BACK 0x02
#define ANTI_ALIASING_2X2 0x03
#define ANTI_ALIASING_3X3 0x04
#define ANTI_ALIASING_4X4 0x05
// ----------------------------------------------------------------------------------------------------------------------------
#define THREAD_SLEEP_TIME 0
// ----------------------------------------------------------------------------------------------------------------------------
class CThreadData
{
public:
HANDLE Thread;
DWORD Id;
void *SoftwareGL;
int ThreadId, Function;
bool ThreadIsRunning;
};
// ----------------------------------------------------------------------------------------------------------------------------
class CSoftwareGL
{
private:
int Width, Height;
private:
BYTE *AntiAliasingColorBuffer;
int AntiAliasingColorBufferWidth, AntiAliasingColorBufferHeight;
private:
BYTE *StandardColorBuffer;
int StandardColorBufferWidth, StandardColorBufferHeight;
BITMAPINFO StandardColorBufferInfo;
private:
BYTE *ColorBuffer;
int ColorBufferWidth, ColorBufferHeight;
private:
USHORT *DepthBuffer;
int DepthBufferWidth, DepthBufferHeight;
private:
int AntiAliasing;
mat4x4 ModelViewProjectionMatrix;
CLight *Light;
int CullFace;
bool BilinearTextureFiltering;
CTexture *Texture;
private:
CVertex *Vertices;
int FirstIndex, LastIndex;
private:
CThreadData *ThreadsData;
int ThreadsCount;
public:
CSoftwareGL();
~CSoftwareGL();
public:
int GetAntiAliasing();
void SetAntiAliasing(int AntiAliasing);
int GetCullFace();
void SetCullFace(int CullFace);
bool GetBilinearTextureFiltering();
void SetBilinearTextureFiltering(bool BilinearTextureFiltering);
public:
int GetThreadsCount();
public:
void Clear();
void LoadModelViewProjectionMatrix(const mat4x4 &ModelViewProjectionMatrix);
void BindLight(CLight *Light);
void BindTexture(CTexture *Texture);
void DrawTriangles(CVertex *Vertices, int FirstIndex, int Count);
private:
void RunFunctionMultiThreadedAndWaitForCompletion(int Function);
bool ThreadsAreRunning();
static DWORD WINAPI ThreadProc(LPVOID lpParam);
void DrawTriangles(int ThreadId);
void ClipTriangle(CFragment *Fragments, int ThreadId, int ClipPlane = 1);
void RasterizeTriangle(CFragment *Fragments, int ThreadId);
void DrawSpansBetweenEdges(CEdge *Edge1, CEdge *Edge2, int ThreadId);
void DrawSpan(CSpan *Span, int y);
void BlitAntiAliasingColorBuffer2x2(int Line);
void BlitAntiAliasingColorBuffer3x3(int Line);
void BlitAntiAliasingColorBuffer4x4(int Line);
public:
void Viewport(int Width, int Height);
void SwapBuffers(HDC hDC);
};
// ----------------------------------------------------------------------------------------------------------------------------
class CSoftwareGLRenderer : public CSoftwareGL
{
private:
int LastX, LastY, LastClickedX, LastClickedY;
private:
CCamera Camera;
private:
CTexture Texture;
private:
CVertex *Vertices;
private:
CObject Object[3];
private:
int RenderObject;
private:
bool Lighting, Texturing;
private:
CLight Light;
public:
CSoftwareGLRenderer();
~CSoftwareGLRenderer();
public:
bool Init();
void Render(float FrameTime);
void Resize(int Width, int Height);
void Destroy();
public:
void CheckCameraKeys(float FrameTime);
public:
void OnKeyDown(UINT Key);
void OnLButtonDown(int X, int Y);
void OnLButtonUp(int X, int Y);
void OnMouseMove(int X, int Y);
void OnMouseWheel(short zDelta);
void OnRButtonDown(int X, int Y);
void OnRButtonUp(int X, int Y);
};
// ----------------------------------------------------------------------------------------------------------------------------
class CSoftwareGLView
{
private:
char *Title;
int Width, Height;
HWND hWnd;
HDC hDC;
private:
CSoftwareGLRenderer SoftwareGLRenderer;
public:
CSoftwareGLView();
~CSoftwareGLView();
public:
bool Create(HINSTANCE hInstance, char *Title, int Width, int Height);
void Show(bool Maximized = false);
void MsgLoop();
void Destroy();
public:
void OnKeyDown(UINT Key);
void OnLButtonDown(int X, int Y);
void OnLButtonUp(int X, int Y);
void OnMouseMove(int X, int Y);
void OnMouseWheel(short zDelta);
void OnPaint();
void OnRButtonDown(int X, int Y);
void OnRButtonUp(int X, int Y);
void OnSize(int Width, int Height);
};
// ----------------------------------------------------------------------------------------------------------------------------
LRESULT CALLBACK WndProc(HWND hWnd, UINT uiMsg, WPARAM wParam, LPARAM lParam);
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR sCmdLine, int iShow);
// ----------------------------------------------------------------------------------------------------------------------------
simple_software_renderer_multithreading_v1.cpp
// ----------------------------------------------------------------------------------------------------------------------------
#include "simple_software_renderer_multithreading_v1.h"
// ----------------------------------------------------------------------------------------------------------------------------
CString ErrorLog, ModuleDirectory;
// ----------------------------------------------------------------------------------------------------------------------------
CTexture::CTexture()
{
SetDefaults();
}
CTexture::~CTexture()
{
}
void CTexture::SetDefaults()
{
DIB = NULL;
Bits = NULL;
Width = 0;
Height = 0;
Pitch = 0;
BPP = 0;
}
bool CTexture::LoadTexture(char *TextureFileName)
{
CString FileName = ModuleDirectory + TextureFileName;
CString ErrorText = "Error loading file " + FileName + " -> ";
Destroy();
FREE_IMAGE_FORMAT FIF = FreeImage_GetFileType(FileName);
if(FIF == FIF_UNKNOWN)
{
FIF = FreeImage_GetFIFFromFilename(FileName);
}
if(FIF == FIF_UNKNOWN)
{
ErrorLog.Append(ErrorText + "FIF is FIF_UNKNOWN!" + "\r\n");
return false;
}
if(FreeImage_FIFSupportsReading(FIF))
{
DIB = FreeImage_Load(FIF, FileName);
}
if(DIB == NULL)
{
ErrorLog.Append(ErrorText + "DIB is NULL!" + "\r\n");
return false;
}
Width = FreeImage_GetWidth(DIB);
Height = FreeImage_GetHeight(DIB);
Pitch = FreeImage_GetPitch(DIB);
BPP = FreeImage_GetBPP(DIB);
if(Width == 0 || Height == 0)
{
ErrorLog.Append(ErrorText + "Width or Height is 0!" + "\r\n");
Destroy();
return false;
}
if(BPP != 24 && BPP != 32)
{
ErrorLog.Append(ErrorText + "BPP is not 24 nor 32!" + "\r\n");
Destroy();
return false;
}
BPP /= 8;
Bits = FreeImage_GetBits(DIB);
if(Bits == NULL)
{
ErrorLog.Append(ErrorText + "Bits is NULL!" + "\r\n");
Destroy();
return false;
}
return true;
}
float OD255 = 1.0f / 255.0f;
void CTexture::GetColorNearest(float s, float t, float *r, float *g, float *b)
{
if(Bits != NULL)
{
s -= (int)s;
t -= (int)t;
if(s < 0.0f) s += 1.0f;
if(t < 0.0f) t += 1.0f;
int x = (int)(s * Width), y = (int)(t * Height);
BYTE *A = Bits + Pitch * y + BPP * x;
*b = *A * OD255;
A++;
*g = *A * OD255;
A++;
*r = *A * OD255;
}
else
{
*r = *g = *b = 1.0f;
}
}
void CTexture::GetColorBilinear(float s, float t, float *r, float *g, float *b)
{
if(Bits != NULL)
{
s -= (int)s;
t -= (int)t;
if(s < 0.0f) s += 1.0f;
if(t < 0.0f) t += 1.0f;
float fx = s * Width - 0.5f, fy = t * Height - 0.5f;
if(fx < 0.0f) fx += Width;
if(fy < 0.0f) fy += Height;
int x0 = (int)fx, y0 = (int)fy, x1 = (x0 + 1) % Width, y1 = (y0 + 1) % Height;
BYTE *LineAB = Bits + Pitch * y0;
BYTE *LineCD = Bits + Pitch * y1;
int BPPMx0 = BPP * x0, BPPMx1 = BPP * x1;
BYTE *A = LineAB + BPPMx0;
BYTE *B = LineAB + BPPMx1;
BYTE *C = LineCD + BPPMx1;
BYTE *D = LineCD + BPPMx0;
float u1 = fx - x0, v1 = fy - y0, u0 = 1.0f - u1, v0 = 1.0f - v1;
u0 *= OD255;
u1 *= OD255;
float u0v0 = u0 * v0, u1v0 = u1 * v0, u1v1 = u1 * v1, u0v1 = u0 * v1;
*b = *A * u0v0 + *B * u1v0 + *C * u1v1 + *D * u0v1;
A++; B++; C++; D++;
*g = *A * u0v0 + *B * u1v0 + *C * u1v1 + *D * u0v1;
A++; B++; C++; D++;
*r = *A * u0v0 + *B * u1v0 + *C * u1v1 + *D * u0v1;
}
else
{
*r = *g = *b = 1.0f;
}
}
void CTexture::Destroy()
{
if(DIB != NULL)
{
FreeImage_Unload(DIB);
}
SetDefaults();
}
// ----------------------------------------------------------------------------------------------------------------------------
CCamera::CCamera()
{
X = vec3(1.0f, 0.0f, 0.0f);
Y = vec3(0.0f, 1.0f, 0.0f);
Z = vec3(0.0f, 0.0f, 1.0f);
Position = vec3(0.0f, 0.0f, 5.0f);
Reference = vec3(0.0f, 0.0f, 0.0f);
CalculateViewMatrix();
}
CCamera::~CCamera()
{
}
void CCamera::Look(const vec3 &Position, const vec3 &Reference, bool RotateAroundReference)
{
this->Position = Position;
this->Reference = Reference;
Z = normalize(Position - Reference);
GetXY(Z, X, Y);
if(!RotateAroundReference)
{
this->Reference = this->Position - Z * 0.05f;
}
CalculateViewMatrix();
}
void CCamera::Move(const vec3 &Movement)
{
Position += Movement;
Reference += Movement;
CalculateViewMatrix();
}
vec3 CCamera::OnKeys(BYTE Keys, float FrameTime)
{
float Speed = 5.0f;
if(Keys & 0x40) Speed *= 2.0f;
if(Keys & 0x80) Speed *= 0.5f;
float Distance = Speed * FrameTime;
vec3 Up(0.0f, 1.0f, 0.0f);
vec3 Right = X;
vec3 Forward = cross(Up, Right);
Up *= Distance;
Right *= Distance;
Forward *= Distance;
vec3 Movement = vec3(0.0f);
if(Keys & 0x01) Movement += Forward;
if(Keys & 0x02) Movement -= Forward;
if(Keys & 0x04) Movement -= Right;
if(Keys & 0x08) Movement += Right;
if(Keys & 0x10) Movement += Up;
if(Keys & 0x20) Movement -= Up;
return Movement;
}
void CCamera::OnMouseMove(int dx, int dy)
{
float Sensitivity = 0.25f;
Position -= Reference;
if(dx != 0)
{
float DeltaX = (float)dx * Sensitivity;
X = rotate(X, DeltaX, vec3(0.0f, 1.0f, 0.0f));
Y = rotate(Y, DeltaX, vec3(0.0f, 1.0f, 0.0f));
Z = rotate(Z, DeltaX, vec3(0.0f, 1.0f, 0.0f));
}
if(dy != 0)
{
float DeltaY = (float)dy * Sensitivity;
Y = rotate(Y, DeltaY, X);
Z = rotate(Z, DeltaY, X);
if(Y.y < 0.0f)
{
Z = vec3(0.0f, Z.y > 0.0f ? 1.0f : -1.0f, 0.0f);
Y = cross(Z, X);
}
}
Position = Reference + Z * length(Position);
CalculateViewMatrix();
}
void CCamera::OnMouseWheel(float zDelta)
{
Position -= Reference;
if(zDelta < 0 && length(Position) < 500.0f)
{
Position += Position * 0.1f;
}
if(zDelta > 0 && length(Position) > 0.05f)
{
Position -= Position * 0.1f;
}
Position += Reference;
CalculateViewMatrix();
}
void CCamera::SetPerspective(float fovy, float aspect, float n, float f)
{
ProjectionMatrix = perspective(fovy, aspect, n, f);
ViewProjectionMatrix = ProjectionMatrix * ViewMatrix;
}
void CCamera::CalculateViewMatrix()
{
ViewMatrix = mat4x4(X.x, Y.x, Z.x, 0.0f, X.y, Y.y, Z.y, 0.0f, X.z, Y.z, Z.z, 0.0f, -dot(X, Position), -dot(Y, Position), -dot(Z, Position), 1.0f);
ViewProjectionMatrix = ProjectionMatrix * ViewMatrix;
}
// ----------------------------------------------------------------------------------------------------------------------------
CObject::CObject()
{
SetDefaults();
}
CObject::~CObject()
{
}
void CObject::SetDefaults()
{
Vertices = NULL;
VerticesCount = 0;
}
bool CObject::Load(char *Directory, char *ObjFileName)
{
char *ObjSource;
long ObjLength;
Destroy();
if(!ReadSource(Directory, ObjFileName, &ObjSource, ObjLength)) return false;
char *Line, *End = ObjSource + ObjLength;
float x, y, z;
int PositionsCount = 0, TexCoordsCount = 0, NormalsCount = 0, TrianglesCount = 0;
int i1, i2, i3, i4, i5, i6, i7, i8, i9;
int p = 0, tc = 0, n = 0, v = 0;
Line = ObjSource;
while(Line < End)
{
while(Line < End && (*Line == ' ' || *Line == '\t')) Line++;
if(Line[0] == 'm' && Line[1] == 't' && Line[2] == 'l' && Line[3] == 'l' && Line[4] == 'i' && Line[5] == 'b' && (Line[6] == ' ' || Line[6] == '\t'))
{
char *MtlFileName = Line + 6;
while(MtlFileName < End && (*MtlFileName == ' ' || *MtlFileName == '\t')) MtlFileName++;
if(!ParseMtl(Directory, MtlFileName))
{
delete [] ObjSource;
return false;
}
}
else if(sscanf(Line, "v %f %f %f", &x, &y, &z) == 3)
{
PositionsCount++;
}
else if(sscanf(Line, "vt %f %f", &x, &y) == 2)
{
TexCoordsCount++;
}
else if(sscanf(Line, "vn %f %f %f", &x, &y, &z) == 3)
{
NormalsCount++;
}
else if(sscanf(Line, "f %d/%d/%d %d/%d/%d %d/%d/%d", &i1, &i2, &i3, &i4, &i5, &i6, &i7, &i8, &i9) == 9)
{
TrianglesCount++;
}
else if(sscanf(Line, "f %d//%d %d//%d %d//%d", &i1, &i2, &i3, &i4, &i5, &i6) == 6)
{
TrianglesCount++;
}
else if(sscanf(Line, "f %d/%d %d/%d %d/%d", &i1, &i2, &i3, &i4, &i5, &i6) == 6)
{
TrianglesCount++;
}
else if(sscanf(Line, "f %d %d %d", &i1, &i2, &i3) == 3)
{
TrianglesCount++;
}
while(Line < End && *Line != 0) Line++;
while(Line < End && *Line == 0) Line++;
}
if(TrianglesCount == 0)
{
ErrorLog.Append("Error loading file %s!\r\n", ObjFileName);
delete [] ObjSource;
Destroy();
return false;
}
vec3 *Positions = NULL;
vec2 *TexCoords = NULL;
vec3 *Normals = NULL;
if(PositionsCount > 0) Positions = new vec3[PositionsCount];
if(TexCoordsCount > 0) TexCoords = new vec2[TexCoordsCount];
if(NormalsCount > 0) Normals = new vec3[NormalsCount];
VerticesCount = TrianglesCount * 3;
Vertices = new CVertex[VerticesCount];
Line = ObjSource;
while(Line < End)
{
while(Line < End && (*Line == ' ' || *Line == '\t')) Line++;
if(sscanf(Line, "v %f %f %f", &x, &y, &z) == 3)
{
Positions[p++] = vec3(x, y, z);
}
else if(sscanf(Line, "vt %f %f", &x, &y) == 2)
{
TexCoords[tc++] = vec2(x, y);
}
else if(sscanf(Line, "vn %f %f %f", &x, &y, &z) == 3)
{
Normals[n++] = normalize(vec3(x, y, z));
}
else if(sscanf(Line, "f %d/%d/%d %d/%d/%d %d/%d/%d", &i1, &i2, &i3, &i4, &i5, &i6, &i7, &i8, &i9) == 9)
{
Vertices[v].Position = Positions[i1 - 1];
Vertices[v].TexCoord = TexCoords[i2 - 1];
Vertices[v].Normal = Normals[i3 - 1];
v++;
Vertices[v].Position = Positions[i4 - 1];
Vertices[v].TexCoord = TexCoords[i5 - 1];
Vertices[v].Normal = Normals[i6 - 1];
v++;
Vertices[v].Position = Positions[i7 - 1];
Vertices[v].TexCoord = TexCoords[i8 - 1];
Vertices[v].Normal = Normals[i9 - 1];
v++;
}
else if(sscanf(Line, "f %d//%d %d//%d %d//%d", &i1, &i2, &i3, &i4, &i5, &i6) == 6)
{
Vertices[v].Position = Positions[i1 - 1];
Vertices[v].Normal = Normals[i2 - 1];
v++;
Vertices[v].Position = Positions[i3 - 1];
Vertices[v].Normal = Normals[i4 - 1];
v++;
Vertices[v].Position = Positions[i5 - 1];
Vertices[v].Normal = Normals[i6 - 1];
v++;
}
else if(sscanf(Line, "f %d/%d %d/%d %d/%d", &i1, &i2, &i3, &i4, &i5, &i6) == 6)
{
Vertices[v].Position = Positions[i1 - 1];
if(TexCoords != NULL && i1 - 1 < TexCoordsCount) Vertices[v].TexCoord = TexCoords[i1 - 1];
if(TexCoords != NULL && i2 - 1 < TexCoordsCount) Vertices[v].TexCoord = TexCoords[i2 - 1];
if(Normals != NULL && i1 - 1 < NormalsCount) Vertices[v].Normal = Normals[i1 - 1];
if(Normals != NULL && i2 - 1 < NormalsCount) Vertices[v].Normal = Normals[i2 - 1];
v++;
Vertices[v].Position = Positions[i3 - 1];
if(TexCoords != NULL && i3 - 1 < TexCoordsCount) Vertices[v].TexCoord = TexCoords[i3 - 1];
if(TexCoords != NULL && i4 - 1 < TexCoordsCount) Vertices[v].TexCoord = TexCoords[i4 - 1];
if(Normals != NULL && i3 - 1 < NormalsCount) Vertices[v].Normal = Normals[i3 - 1];
if(Normals != NULL && i4 - 1 < NormalsCount) Vertices[v].Normal = Normals[i4 - 1];
v++;
Vertices[v].Position = Positions[i5 - 1];
if(TexCoords != NULL && i5 - 1 < TexCoordsCount) Vertices[v].TexCoord = TexCoords[i5 - 1];
if(TexCoords != NULL && i6 - 1 < TexCoordsCount) Vertices[v].TexCoord = TexCoords[i6 - 1];
if(Normals != NULL && i5 - 1 < NormalsCount) Vertices[v].Normal = Normals[i5 - 1];
if(Normals != NULL && i6 - 1 < NormalsCount) Vertices[v].Normal = Normals[i6 - 1];
v++;
}
else if(sscanf(Line, "f %d %d %d", &i1, &i2, &i3) == 3)
{
Vertices[v].Position = Positions[i1 - 1];
if(TexCoords != NULL && i1 - 1 < TexCoordsCount) Vertices[v].TexCoord = TexCoords[i1 - 1];
if(Normals != NULL && i1 - 1 < NormalsCount) Vertices[v].Normal = Normals[i1 - 1];
v++;
Vertices[v].Position = Positions[i2 - 1];
if(TexCoords != NULL && i2 - 1 < TexCoordsCount) Vertices[v].TexCoord = TexCoords[i2 - 1];
if(Normals != NULL && i2 - 1 < NormalsCount) Vertices[v].Normal = Normals[i2 - 1];
v++;
Vertices[v].Position = Positions[i3 - 1];
if(TexCoords != NULL && i3 - 1 < TexCoordsCount) Vertices[v].TexCoord = TexCoords[i3 - 1];
if(Normals != NULL && i3 - 1 < NormalsCount) Vertices[v].Normal = Normals[i3 - 1];
v++;
}
while(Line < End && *Line != 0) Line++;
while(Line < End && *Line == 0) Line++;
}
delete [] Positions;
delete [] TexCoords;
delete [] Normals;
delete [] ObjSource;
for(int i = 0; i < VerticesCount; i++)
{
Vertices[i].Color = vec3(1.0f);
}
if(NormalsCount == 0)
{
vec3 A, B, Normal;
for(int i = 0; i < VerticesCount; i += 3)
{
int i0 = i, i1 = i + 1, i2 = i + 2;
A = Vertices[i1].Position - Vertices[i0].Position;
B = Vertices[i2].Position - Vertices[i0].Position;
Normal = normalize(cross(A, B));
Vertices[i0].Normal = Normal;
Vertices[i1].Normal = Normal;
Vertices[i2].Normal = Normal;
}
}
GetMinMax();
return true;
}
void CObject::Translate(const vec3 &Translation)
{
for(int i = 0; i < VerticesCount; i++)
{
Vertices[i].Position += Translation;
}
Min += Translation;
Max += Translation;
}
void CObject::Scale(float ScaleFactor)
{
for(int i = 0; i < VerticesCount; i++)
{
Vertices[i].Position *= ScaleFactor;
}
Min *= ScaleFactor;
Max *= ScaleFactor;
}
void CObject::Rotate(float Angle, const vec3 &Axis)
{
mat3x3 RotationMatrix = mat3x3(rotate(Angle, Axis));
for(int i = 0; i < VerticesCount; i++)
{
Vertices[i].Position = RotationMatrix * Vertices[i].Position;
Vertices[i].Normal = RotationMatrix * Vertices[i].Normal;
}
GetMinMax();
}
void CObject::Destroy()
{
Texture.Destroy();
if(Vertices != NULL)
{
delete [] Vertices;
}
SetDefaults();
}
bool CObject::ReadSource(char *Directory, char *FileName, char **Source, long &Length)
{
CString PathFileName = ModuleDirectory + Directory + FileName;
FILE *File;
if((File = fopen(PathFileName, "rb")) == NULL)
{
ErrorLog.Append("Error opening file " + PathFileName + "!\r\n");
return false;
}
fseek(File, 0, SEEK_END);
Length = ftell(File);
fseek(File, 0, SEEK_SET);
*Source = new char[Length + 1];
fread(*Source, 1, Length, File);
(*Source)[Length] = 0;
fclose(File);
for(long i = 0; i < Length; i++)
{
if((*Source)[i] == '\r' || (*Source)[i] == '\n') (*Source)[i] = 0;
}
return true;
}
bool CObject::ParseMtl(char *Directory, char *MtlFileName)
{
char *MtlSource;
long MtlLength;
if(!ReadSource(Directory, MtlFileName, &MtlSource, MtlLength)) return false;
char *Line = MtlSource, *End = MtlSource + MtlLength;
bool Error = false;
while(Line < End)
{
while(Line < End && (*Line == ' ' || *Line == '\t')) Line++;
if(Line[0] == 'm' && Line[1] == 'a' && Line[2] == 'p' && Line[3] == '_' && Line[4] == 'K' && Line[5] == 'a' && (Line[6] == ' ' || Line[6] == '\t'))
{
char *TextureFileName = Line + 6;
while(TextureFileName < End && (*TextureFileName == ' ' || *TextureFileName == '\t')) TextureFileName++;
Error |= !Texture.LoadTexture(CString(Directory) + TextureFileName);
}
while(Line < End && *Line != 0) Line++;
while(Line < End && *Line == 0) Line++;
}
delete [] MtlSource;
return !Error;
}
void CObject::GetMinMax()
{
Min = Max = Vertices[0].Position;
for(int i = 1; i < VerticesCount; i++)
{
if(Min.x > Vertices[i].Position.x) Min.x = Vertices[i].Position.x;
if(Min.y > Vertices[i].Position.y) Min.y = Vertices[i].Position.y;
if(Min.z > Vertices[i].Position.z) Min.z = Vertices[i].Position.z;
if(Max.x < Vertices[i].Position.x) Max.x = Vertices[i].Position.x;
if(Max.y < Vertices[i].Position.y) Max.y = Vertices[i].Position.y;
if(Max.z < Vertices[i].Position.z) Max.z = Vertices[i].Position.z;
}
}
// ----------------------------------------------------------------------------------------------------------------------------
void CEdge::Set(CFragment *Fragment1, CFragment *Fragment2)
{
if(Fragment1->y <= Fragment2->y)
{
this->Fragment1 = Fragment1;
this->Fragment2 = Fragment2;
}
else
{
this->Fragment1 = Fragment2;
this->Fragment2 = Fragment1;
}
CalculateDiffs();
}
void CEdge::CalculateDiffs()
{
dx = Fragment2->x - Fragment1->x;
dy = Fragment2->y - Fragment1->y;
dz = Fragment2->z - Fragment1->z;
dw = Fragment2->w - Fragment1->w;
dr = Fragment2->r - Fragment1->r;
dg = Fragment2->g - Fragment1->g;
db = Fragment2->b - Fragment1->b;
ds = Fragment2->s - Fragment1->s;
dt = Fragment2->t - Fragment1->t;
}
// ----------------------------------------------------------------------------------------------------------------------------
void CSpan::Set(CFragment *Fragment1, CFragment *Fragment2)
{
if(Fragment1->x <= Fragment2->x)
{
this->Fragment1 = Fragment1;
this->Fragment2 = Fragment2;
}
else
{
this->Fragment1 = Fragment2;
this->Fragment2 = Fragment1;
}
CalculateDiffs();
}
void CSpan::CalculateDiffs()
{
dx = Fragment2->x - Fragment1->x;
dy = Fragment2->y - Fragment1->y;
dz = Fragment2->z - Fragment1->z;
dw = Fragment2->w - Fragment1->w;
dr = Fragment2->r - Fragment1->r;
dg = Fragment2->g - Fragment1->g;
db = Fragment2->b - Fragment1->b;
ds = Fragment2->s - Fragment1->s;
dt = Fragment2->t - Fragment1->t;
}
// ----------------------------------------------------------------------------------------------------------------------------
CSoftwareGL::CSoftwareGL()
{
Width = 0;
Height = 0;
AntiAliasingColorBuffer = NULL;
AntiAliasingColorBufferWidth = 0;
AntiAliasingColorBufferHeight = 0;
StandardColorBuffer = NULL;
StandardColorBufferWidth = 0;
StandardColorBufferHeight = 0;
ColorBuffer = NULL;
ColorBufferWidth = 0;
ColorBufferHeight = 0;
DepthBuffer = NULL;
DepthBufferWidth = 0;
DepthBufferHeight = 0;
AntiAliasing = ANTI_ALIASING_2X2;
ModelViewProjectionMatrix = mat4x4(1.0f);
CullFace = CULL_FACE_BACK;
BilinearTextureFiltering = true;
Light = NULL;
Texture = NULL;
SYSTEM_INFO SystemInfo;
GetSystemInfo(&SystemInfo);
ThreadsCount = SystemInfo.dwNumberOfProcessors;
ThreadsData = new CThreadData[ThreadsCount];
for(int i = 0; i < ThreadsCount; i++)
{
ThreadsData[i].SoftwareGL = this;
ThreadsData[i].ThreadId = i;
ThreadsData[i].ThreadIsRunning = false;
ThreadsData[i].Thread = CreateThread(NULL, 0, ThreadProc, &ThreadsData[i], 0, &ThreadsData[i].Id);
SetThreadAffinityMask(ThreadsData[i].Thread, 1 << i);
}
if(THREAD_SLEEP_TIME > 0)
{
timeBeginPeriod(THREAD_SLEEP_TIME);
}
}
CSoftwareGL::~CSoftwareGL()
{
if(AntiAliasingColorBuffer != NULL)
{
delete [] AntiAliasingColorBuffer;
}
if(StandardColorBuffer != NULL)
{
delete [] StandardColorBuffer;
}
if(DepthBuffer != NULL)
{
delete [] DepthBuffer;
}
for(int i = 0; i < ThreadsCount; i++)
{
TerminateThread(ThreadsData[i].Thread, 0);
CloseHandle(ThreadsData[i].Thread);
}
delete [] ThreadsData;
if(THREAD_SLEEP_TIME > 0)
{
timeEndPeriod(THREAD_SLEEP_TIME);
}
}
int CSoftwareGL::GetAntiAliasing()
{
return AntiAliasing;
}
void CSoftwareGL::SetAntiAliasing(int AntiAliasing)
{
if(AntiAliasing == NONE || AntiAliasing == ANTI_ALIASING_2X2 || AntiAliasing == ANTI_ALIASING_3X3 || AntiAliasing == ANTI_ALIASING_4X4)
{
if(this->AntiAliasing != AntiAliasing)
{
this->AntiAliasing = AntiAliasing;
Viewport(Width, Height);
}
}
}
int CSoftwareGL::GetCullFace()
{
return CullFace;
}
void CSoftwareGL::SetCullFace(int CullFace)
{
if(CullFace == NONE || CullFace == CULL_FACE_FRONT || CullFace == CULL_FACE_BACK)
{
this->CullFace = CullFace;
}
}
bool CSoftwareGL::GetBilinearTextureFiltering()
{
return BilinearTextureFiltering;
}
void CSoftwareGL::SetBilinearTextureFiltering(bool BilinearTextureFiltering)
{
this->BilinearTextureFiltering = BilinearTextureFiltering;
}
int CSoftwareGL::GetThreadsCount()
{
return ThreadsCount;
}
void CSoftwareGL::Clear()
{
if(ColorBuffer != NULL)
{
memset(ColorBuffer, 0, ColorBufferWidth * ColorBufferHeight * 3);
}
if(DepthBuffer != NULL)
{
memset(DepthBuffer, 255, DepthBufferWidth * DepthBufferHeight * 2);
}
}
void CSoftwareGL::LoadModelViewProjectionMatrix(const mat4x4 &ModelViewProjectionMatrix)
{
this->ModelViewProjectionMatrix = ModelViewProjectionMatrix;
}
void CSoftwareGL::BindLight(CLight *Light)
{
this->Light = Light;
}
void CSoftwareGL::BindTexture(CTexture *Texture)
{
this->Texture = Texture;
}
void CSoftwareGL::DrawTriangles(CVertex *Vertices, int FirstIndex, int Count)
{
if(ColorBuffer == NULL || DepthBuffer == NULL || Vertices == NULL || FirstIndex < 0 || Count < 3) return;
this->Vertices = Vertices;
this->FirstIndex = FirstIndex;
this->LastIndex = FirstIndex + Count / 3 * 3;
RunFunctionMultiThreadedAndWaitForCompletion(1);
}
void CSoftwareGL::RunFunctionMultiThreadedAndWaitForCompletion(int Function)
{
for(int i = 0; i < ThreadsCount; i++)
{
ThreadsData[i].Function = Function;
ThreadsData[i].ThreadIsRunning = true;
}
while(ThreadsAreRunning())
{
Sleep(THREAD_SLEEP_TIME);
}
}
bool CSoftwareGL::ThreadsAreRunning()
{
bool ThreadsAreRunning = false;
for(int i = 0; i < ThreadsCount; i++)
{
ThreadsAreRunning |= ThreadsData[i].ThreadIsRunning;
}
return ThreadsAreRunning;
}
DWORD WINAPI CSoftwareGL::ThreadProc(LPVOID lpParam)
{
CThreadData *ThreadData = (CThreadData*)lpParam;
CSoftwareGL *SoftwareGL = (CSoftwareGL*)ThreadData->SoftwareGL;
while(1)
{
while(!ThreadData->ThreadIsRunning)
{
Sleep(THREAD_SLEEP_TIME);
}
switch(ThreadData->Function)
{
case 1: SoftwareGL->DrawTriangles(ThreadData->ThreadId); break;
case 2: SoftwareGL->BlitAntiAliasingColorBuffer2x2(ThreadData->ThreadId); break;
case 3: SoftwareGL->BlitAntiAliasingColorBuffer3x3(ThreadData->ThreadId); break;
case 4: SoftwareGL->BlitAntiAliasingColorBuffer4x4(ThreadData->ThreadId); break;
}
ThreadData->ThreadIsRunning = false;
}
return 0;
}
void CSoftwareGL::DrawTriangles(int ThreadId)
{
float *ModelViewProjectionMatrix = &this->ModelViewProjectionMatrix;
// primitive assembly
CFragment Fragments[3];
for(int i = FirstIndex; i < LastIndex; i += 3)
{
CVertex *Vertex = Vertices + i;
CFragment *Fragment = Fragments;
for(int j = 0; j < 3; j++)
{
// vertex shader
Fragment->x = ModelViewProjectionMatrix[0] * Vertex->Position.x + ModelViewProjectionMatrix[4] * Vertex->Position.y + ModelViewProjectionMatrix[8] * Vertex->Position.z + ModelViewProjectionMatrix[12];
Fragment->y = ModelViewProjectionMatrix[1] * Vertex->Position.x + ModelViewProjectionMatrix[5] * Vertex->Position.y + ModelViewProjectionMatrix[9] * Vertex->Position.z + ModelViewProjectionMatrix[13];
Fragment->z = ModelViewProjectionMatrix[2] * Vertex->Position.x + ModelViewProjectionMatrix[6] * Vertex->Position.y + ModelViewProjectionMatrix[10] * Vertex->Position.z + ModelViewProjectionMatrix[14];
Fragment->w = ModelViewProjectionMatrix[3] * Vertex->Position.x + ModelViewProjectionMatrix[7] * Vertex->Position.y + ModelViewProjectionMatrix[11] * Vertex->Position.z + ModelViewProjectionMatrix[15];
Fragment->r = Vertex->Color.r;
Fragment->g = Vertex->Color.g;
Fragment->b = Vertex->Color.b;
Fragment->s = Vertex->TexCoord.s;
Fragment->t = Vertex->TexCoord.t;
if(Light != NULL)
{
vec3 LightDirection;
LightDirection.x = Light->Position.x - Vertex->Position.x;
LightDirection.y = Light->Position.y - Vertex->Position.y;
LightDirection.z = Light->Position.z - Vertex->Position.z;
float LightDistance2 = LightDirection.x * LightDirection.x + LightDirection.y * LightDirection.y + LightDirection.z * LightDirection.z;
float LightDistance = sqrt(LightDistance2);
float NdotLD = (LightDirection.x * Vertex->Normal.x + LightDirection.y * Vertex->Normal.y + LightDirection.z * Vertex->Normal.z) / LightDistance;
if(NdotLD < 0.0f) NdotLD = 0.0f;
float LightAttenuation = 1.0f / (Light->ConstantAttenuation + Light->LinearAttenuation * LightDistance + Light->QuadraticAttenuation * LightDistance2);
Fragment->r *= (Light->Ambient.r + Light->Diffuse.r * NdotLD) * LightAttenuation;
Fragment->g *= (Light->Ambient.g + Light->Diffuse.g * NdotLD) * LightAttenuation;
Fragment->b *= (Light->Ambient.b + Light->Diffuse.b * NdotLD) * LightAttenuation;
}
Vertex++;
Fragment++;
}
// clipping
ClipTriangle(Fragments, ThreadId);
}
}
// ----------------------------------------------------------------------------------------------------------------------------
//
// clipping using homogeneous coordinates
//
// ----------------------------------------------------------------------------------------------------------------------------
//
// c equals the x or y or z coordinate of a fragment
//
// ----------------------------------------------------------------------------------------------------------------------------
//
// a fragment of an edge is in front of or lies on a negative clip plane: - w <= c
//
// a fragment of an edge is behind a negative clip plane: - w > c
//
// to find the intersection of an edge with a negative clip plane we need to find t for which: - w = c
//
// ----------------------------------------------------------------------------------------------------------------------------
//
// w = w1 + (w2 - w1) * t
// c = c1 + (c2 - c1) * t
//
// - w = c
//
// - (w1 + (w2 - w1) * t) = c1 + (c2 - c1) * t
// - w1 - (w2 - w1) * t = c1 + (c2 - c1) * t
// - (w2 - w1) * t = c1 + w1 + (c2 - c1) * t
// - (c2 - c1) * t - (w2 - w1) * t = c1 + w1
// (c2 - c1) * t + (w2 - w1) * t = - c1 - w1
// (c2 - c1 + w2 - w1) * t = - c1 - w1
// t = (- c1 - w1) / (c2 - c1 + w2 - w1)
// t = (c1 + w1) / (- c2 + c1 - w2 + w1)
// t = (c1 + w1) / (c1 - c2 + w1 - w2)
//
// ----------------------------------------------------------------------------------------------------------------------------
//
// a fragment of an edge is in front of or lies on a positive clip plane: c <= w
//
// a fragment of an edge is behind a positive clip plane: c > w
//
// to find the intersection of an edge with a positive clip plane we need to find t for which: c = w
//
// ----------------------------------------------------------------------------------------------------------------------------
//
// c = c1 + (c2 - c1) * t
// w = w1 + (w2 - w1) * t
//
// c = w
//
// c1 + (c2 - c1) * t = w1 + (w2 - w1) * t
// (c2 - c1) * t = w1 - c1 + (w2 - w1) * t
// (c2 - c1) * t - (w2 - w1) * t = w1 - c1
// ((c2 - c1) - (w2 - w1)) * t = w1 - c1
// (c2 - c1 - w2 + w1) * t = w1 - c1
// t = (w1 - c1) / (c2 - c1 - w2 + w1)
// t = (- w1 + c1) / (- c2 + c1 + w2 - w1)
// t = (c1 - w1) / (c1 - c2 - w1 + w2)
//
// ----------------------------------------------------------------------------------------------------------------------------
void CSoftwareGL::ClipTriangle(CFragment *Fragments, int ThreadId, int ClipPlane)
{
if(ClipPlane >= 1 && ClipPlane <= 6)
{
int fifocp, fbcp, fbcpc = 0; // fragment in front of clip plane, fragment behind clip plane, fragments behind clip plane count
// visibility testing
CFragment *Fragment = Fragments;
for(int i = 0; i < 3; i++)
{
bool Visible;
switch(ClipPlane)
{
case 1: Visible = -Fragment->w <= Fragment->x; break;
case 2: Visible = Fragment->x <= Fragment->w; break;
case 3: Visible = -Fragment->w <= Fragment->y; break;
case 4: Visible = Fragment->y <= Fragment->w; break;
case 5: Visible = -Fragment->w <= Fragment->z; break;
case 6: Visible = Fragment->z <= Fragment->w; break;
}
if(Visible)
{
fifocp = i;
}
else
{
fbcp = i;
fbcpc++;
}
Fragment++;
}
// clipping
if(fbcpc == 3)
{
return;
}
else if(fbcpc == 2)
{
CFragment *Fragment1 = Fragments + (fifocp + 1) % 3;
CFragment *Fragment2 = Fragments + (fifocp + 2) % 3;
CFragment *Fragment3 = Fragments + fifocp;
float t1, t2;
switch(ClipPlane)
{
case 1:
t1 = (Fragment1->x + Fragment1->w) / (Fragment1->x - Fragment3->x + Fragment1->w - Fragment3->w);
t2 = (Fragment2->x + Fragment2->w) / (Fragment2->x - Fragment3->x + Fragment2->w - Fragment3->w);
break;
case 2:
t1 = (Fragment1->x - Fragment1->w) / (Fragment1->x - Fragment3->x - Fragment1->w + Fragment3->w);
t2 = (Fragment2->x - Fragment2->w) / (Fragment2->x - Fragment3->x - Fragment2->w + Fragment3->w);
break;
case 3:
t1 = (Fragment1->y + Fragment1->w) / (Fragment1->y - Fragment3->y + Fragment1->w - Fragment3->w);
t2 = (Fragment2->y + Fragment2->w) / (Fragment2->y - Fragment3->y + Fragment2->w - Fragment3->w);
break;
case 4:
t1 = (Fragment1->y - Fragment1->w) / (Fragment1->y - Fragment3->y - Fragment1->w + Fragment3->w);
t2 = (Fragment2->y - Fragment2->w) / (Fragment2->y - Fragment3->y - Fragment2->w + Fragment3->w);
break;
case 5:
t1 = (Fragment1->z + Fragment1->w) / (Fragment1->z - Fragment3->z + Fragment1->w - Fragment3->w);
t2 = (Fragment2->z + Fragment2->w) / (Fragment2->z - Fragment3->z + Fragment2->w - Fragment3->w);
break;
case 6:
t1 = (Fragment1->z - Fragment1->w) / (Fragment1->z - Fragment3->z - Fragment1->w + Fragment3->w);
t2 = (Fragment2->z - Fragment2->w) / (Fragment2->z - Fragment3->z - Fragment2->w + Fragment3->w);
break;
}
Fragment1->x += (Fragment3->x - Fragment1->x) * t1;
Fragment1->y += (Fragment3->y - Fragment1->y) * t1;
Fragment1->z += (Fragment3->z - Fragment1->z) * t1;
Fragment1->w += (Fragment3->w - Fragment1->w) * t1;
Fragment1->r += (Fragment3->r - Fragment1->r) * t1;
Fragment1->g += (Fragment3->g - Fragment1->g) * t1;
Fragment1->b += (Fragment3->b - Fragment1->b) * t1;
Fragment1->s += (Fragment3->s - Fragment1->s) * t1;
Fragment1->t += (Fragment3->t - Fragment1->t) * t1;
Fragment2->x += (Fragment3->x - Fragment2->x) * t2;
Fragment2->y += (Fragment3->y - Fragment2->y) * t2;
Fragment2->z += (Fragment3->z - Fragment2->z) * t2;
Fragment2->w += (Fragment3->w - Fragment2->w) * t2;
Fragment2->r += (Fragment3->r - Fragment2->r) * t2;
Fragment2->g += (Fragment3->g - Fragment2->g) * t2;
Fragment2->b += (Fragment3->b - Fragment2->b) * t2;
Fragment2->s += (Fragment3->s - Fragment2->s) * t2;
Fragment2->t += (Fragment3->t - Fragment2->t) * t2;
ClipTriangle(Fragments, ThreadId, ClipPlane + 1);
}
else if(fbcpc == 1)
{
int if1 = (fbcp + 1) % 3, if2 = (fbcp + 2) % 3;
CFragment *Fragment1 = Fragments + if1;
CFragment *Fragment2 = Fragments + if2;
CFragment *Fragment3 = Fragments + fbcp;
CFragment NewFragments[3];
CFragment *NewFragment1 = NewFragments + if1;
CFragment *NewFragment2 = NewFragments + if2;
CFragment *NewFragment3 = NewFragments + fbcp;
float t1, t2;
switch(ClipPlane)
{
case 1:
t1 = (Fragment3->x + Fragment3->w) / (Fragment3->x - Fragment1->x + Fragment3->w - Fragment1->w);
t2 = (Fragment3->x + Fragment3->w) / (Fragment3->x - Fragment2->x + Fragment3->w - Fragment2->w);
break;
case 2:
t1 = (Fragment3->x - Fragment3->w) / (Fragment3->x - Fragment1->x - Fragment3->w + Fragment1->w);
t2 = (Fragment3->x - Fragment3->w) / (Fragment3->x - Fragment2->x - Fragment3->w + Fragment2->w);
break;
case 3:
t1 = (Fragment3->y + Fragment3->w) / (Fragment3->y - Fragment1->y + Fragment3->w - Fragment1->w);
t2 = (Fragment3->y + Fragment3->w) / (Fragment3->y - Fragment2->y + Fragment3->w - Fragment2->w);
break;
case 4:
t1 = (Fragment3->y - Fragment3->w) / (Fragment3->y - Fragment1->y - Fragment3->w + Fragment1->w);
t2 = (Fragment3->y - Fragment3->w) / (Fragment3->y - Fragment2->y - Fragment3->w + Fragment2->w);
break;
case 5:
t1 = (Fragment3->z + Fragment3->w) / (Fragment3->z - Fragment1->z + Fragment3->w - Fragment1->w);
t2 = (Fragment3->z + Fragment3->w) / (Fragment3->z - Fragment2->z + Fragment3->w - Fragment2->w);
break;
case 6:
t1 = (Fragment3->z - Fragment3->w) / (Fragment3->z - Fragment1->z - Fragment3->w + Fragment1->w);
t2 = (Fragment3->z - Fragment3->w) / (Fragment3->z - Fragment2->z - Fragment3->w + Fragment2->w);
break;
}
NewFragment3->x = Fragment3->x;
NewFragment3->y = Fragment3->y;
NewFragment3->z = Fragment3->z;
NewFragment3->w = Fragment3->w;
NewFragment3->r = Fragment3->r;
NewFragment3->g = Fragment3->g;
NewFragment3->b = Fragment3->b;
NewFragment3->s = Fragment3->s;
NewFragment3->t = Fragment3->t;
NewFragment2->x = Fragment2->x;
NewFragment2->y = Fragment2->y;
NewFragment2->z = Fragment2->z;
NewFragment2->w = Fragment2->w;
NewFragment2->r = Fragment2->r;
NewFragment2->g = Fragment2->g;
NewFragment2->b = Fragment2->b;
NewFragment2->s = Fragment2->s;
NewFragment2->t = Fragment2->t;
Fragment3->x += (Fragment1->x - Fragment3->x) * t1;
Fragment3->y += (Fragment1->y - Fragment3->y) * t1;
Fragment3->z += (Fragment1->z - Fragment3->z) * t1;
Fragment3->w += (Fragment1->w - Fragment3->w) * t1;
Fragment3->r += (Fragment1->r - Fragment3->r) * t1;
Fragment3->g += (Fragment1->g - Fragment3->g) * t1;
Fragment3->b += (Fragment1->b - Fragment3->b) * t1;
Fragment3->s += (Fragment1->s - Fragment3->s) * t1;
Fragment3->t += (Fragment1->t - Fragment3->t) * t1;
NewFragment1->x = Fragment3->x;
NewFragment1->y = Fragment3->y;
NewFragment1->z = Fragment3->z;
NewFragment1->w = Fragment3->w;
NewFragment1->r = Fragment3->r;
NewFragment1->g = Fragment3->g;
NewFragment1->b = Fragment3->b;
NewFragment1->s = Fragment3->s;
NewFragment1->t = Fragment3->t;
NewFragment3->x += (NewFragment2->x - NewFragment3->x) * t2;
NewFragment3->y += (NewFragment2->y - NewFragment3->y) * t2;
NewFragment3->z += (NewFragment2->z - NewFragment3->z) * t2;
NewFragment3->w += (NewFragment2->w - NewFragment3->w) * t2;
NewFragment3->r += (NewFragment2->r - NewFragment3->r) * t2;
NewFragment3->g += (NewFragment2->g - NewFragment3->g) * t2;
NewFragment3->b += (NewFragment2->b - NewFragment3->b) * t2;
NewFragment3->s += (NewFragment2->s - NewFragment3->s) * t2;
NewFragment3->t += (NewFragment2->t - NewFragment3->t) * t2;
ClipTriangle(Fragments, ThreadId, ClipPlane + 1);
ClipTriangle(NewFragments, ThreadId, ClipPlane + 1);
}
else if(fbcpc == 0)
{
ClipTriangle(Fragments, ThreadId, ClipPlane + 1);
}
}
else if(ClipPlane == 7)
{
RasterizeTriangle(Fragments, ThreadId);
}
}
void CSoftwareGL::RasterizeTriangle(CFragment *Fragments, int ThreadId)
{
CFragment *Fragment1 = Fragments, *Fragment2 = Fragment1 + 1, *Fragment3 = Fragment2 + 1;
// projection
Fragment1->w = 1.0f / Fragment1->w;
Fragment1->x *= Fragment1->w;
Fragment1->y *= Fragment1->w;
Fragment2->w = 1.0f / Fragment2->w;
Fragment2->x *= Fragment2->w;
Fragment2->y *= Fragment2->w;
Fragment3->w = 1.0f / Fragment3->w;
Fragment3->x *= Fragment3->w;
Fragment3->y *= Fragment3->w;
// culling
if(CullFace)
{
float a = 0.0f;
a += Fragment1->x * Fragment2->y - Fragment2->x * Fragment1->y;
a += Fragment2->x * Fragment3->y - Fragment3->x * Fragment2->y;
a += Fragment3->x * Fragment1->y - Fragment1->x * Fragment3->y;
switch(CullFace)
{
case CULL_FACE_FRONT:
if(a >= 0.0f) return;
break;
case CULL_FACE_BACK:
if(a <= 0.0f) return;
break;
}
}
// perspective correct z and attribute values interpolation
// http://www.comp.nus.edu.sg/~lowkl/publications/lowk_persp_interp_techrep.pdf
Fragment1->x = (Fragment1->x * 0.5f + 0.5f) * DepthBufferWidth;
Fragment1->y = (Fragment1->y * 0.5f + 0.5f) * DepthBufferHeight;
Fragment1->z = Fragment1->z * Fragment1->w * 0.5f + 0.5f;
Fragment1->r *= Fragment1->w;
Fragment1->g *= Fragment1->w;
Fragment1->b *= Fragment1->w;
Fragment1->s *= Fragment1->w;
Fragment1->t *= Fragment1->w;
Fragment2->x = (Fragment2->x * 0.5f + 0.5f) * DepthBufferWidth;
Fragment2->y = (Fragment2->y * 0.5f + 0.5f) * DepthBufferHeight;
Fragment2->z = Fragment2->z * Fragment2->w * 0.5f + 0.5f;
Fragment2->r *= Fragment2->w;
Fragment2->g *= Fragment2->w;
Fragment2->b *= Fragment2->w;
Fragment2->s *= Fragment2->w;
Fragment2->t *= Fragment2->w;
Fragment3->x = (Fragment3->x * 0.5f + 0.5f) * DepthBufferWidth;
Fragment3->y = (Fragment3->y * 0.5f + 0.5f) * DepthBufferHeight;
Fragment3->z = Fragment3->z * Fragment3->w * 0.5f + 0.5f;
Fragment3->r *= Fragment3->w;
Fragment3->g *= Fragment3->w;
Fragment3->b *= Fragment3->w;
Fragment3->s *= Fragment3->w;
Fragment3->t *= Fragment3->w;
// triangle rasterization
// http://joshbeam.com/articles/triangle_rasterization/
CEdge Edges[3], *Edge1 = Edges, *Edge2 = Edge1 + 1, *Edge3 = Edge2 + 1;
Edge1->Set(Fragment1, Fragment2);
Edge2->Set(Fragment2, Fragment3);
Edge3->Set(Fragment3, Fragment1);
CEdge *LongEdge = Edge1, *ShortEdge1 = Edge2, *ShortEdge2 = Edge3;
if(Edge2->dy > LongEdge->dy)
{
LongEdge = Edge2;
ShortEdge1 = Edge3;
ShortEdge2 = Edge1;
}
if(Edge3->dy > LongEdge->dy)
{
LongEdge = Edge3;
ShortEdge1 = Edge1;
ShortEdge2 = Edge2;
}
DrawSpansBetweenEdges(LongEdge, ShortEdge1, ThreadId);
DrawSpansBetweenEdges(LongEdge, ShortEdge2, ThreadId);
}
void CSoftwareGL::DrawSpansBetweenEdges(CEdge *Edge1, CEdge *Edge2, int ThreadId)
{
if(Edge1->dy == 0.0f || Edge2->dy == 0.0f) return;
int iy1 = (int)Edge2->Fragment1->y, iy2 = (int)Edge2->Fragment2->y;
while(iy1 % ThreadsCount != ThreadId) iy1++;
if(iy2 == DepthBufferHeight) iy2--;
float fy, factor1, factor2, ode1dy = 1.0f / Edge1->dy, ode2dy = 1.0f / Edge2->dy;
CFragment Fragment1, Fragment2;
CSpan Span;
for(int y = iy1; y <= iy2; y += ThreadsCount)
{
fy = y + 0.5f;
factor1 = (fy - Edge1->Fragment1->y) * ode1dy;
if(factor1 < 0.0f || factor1 > 1.0f) continue;
factor2 = (fy - Edge2->Fragment1->y) * ode2dy;
if(factor2 < 0.0f || factor2 > 1.0f) continue;
Fragment1.x = Edge1->Fragment1->x + Edge1->dx * factor1;
Fragment1.y = Edge1->Fragment1->y + Edge1->dy * factor1;
Fragment1.z = Edge1->Fragment1->z + Edge1->dz * factor1;
Fragment1.w = Edge1->Fragment1->w + Edge1->dw * factor1;
Fragment1.r = Edge1->Fragment1->r + Edge1->dr * factor1;
Fragment1.g = Edge1->Fragment1->g + Edge1->dg * factor1;
Fragment1.b = Edge1->Fragment1->b + Edge1->db * factor1;
Fragment1.s = Edge1->Fragment1->s + Edge1->ds * factor1;
Fragment1.t = Edge1->Fragment1->t + Edge1->dt * factor1;
Fragment2.x = Edge2->Fragment1->x + Edge2->dx * factor2;
Fragment2.y = Edge2->Fragment1->y + Edge2->dy * factor2;
Fragment2.z = Edge2->Fragment1->z + Edge2->dz * factor2;
Fragment2.w = Edge2->Fragment1->w + Edge2->dw * factor2;
Fragment2.r = Edge2->Fragment1->r + Edge2->dr * factor2;
Fragment2.g = Edge2->Fragment1->g + Edge2->dg * factor2;
Fragment2.b = Edge2->Fragment1->b + Edge2->db * factor2;
Fragment2.s = Edge2->Fragment1->s + Edge2->ds * factor2;
Fragment2.t = Edge2->Fragment1->t + Edge2->dt * factor2;
Span.Set(&Fragment1, &Fragment2);
DrawSpan(&Span, y);
}
}
void CSoftwareGL::DrawSpan(CSpan *Span, int y)
{
if(Span->dx == 0.0f) return;
int ix1 = (int)Span->Fragment1->x, ix2 = (int)Span->Fragment2->x;
if(ix2 == DepthBufferWidth) ix2--;
float factor, odsdx = 1.0f / Span->dx, z, w, r, g, b, s, t, tr, tg, tb;
USHORT Depth;
int ColorBufferIndex = (ColorBufferWidth * y + ix1) * 3;
int DepthBufferIndex = DepthBufferWidth * y + ix1;
for(int x = ix1; x <= ix2; x++)
{
factor = (x + 0.5f - Span->Fragment1->x) * odsdx;
if(factor >= 0.0f && factor <= 1.0f)
{
z = Span->Fragment1->z + Span->dz * factor;
Depth = (USHORT)(z * 65535.0f);
// depth test
if(Depth <= DepthBuffer[DepthBufferIndex])
{
w = 1.0f / (Span->Fragment1->w + Span->dw * factor);
r = (Span->Fragment1->r + Span->dr * factor) * w;
g = (Span->Fragment1->g + Span->dg * factor) * w;
b = (Span->Fragment1->b + Span->db * factor) * w;
s = (Span->Fragment1->s + Span->ds * factor) * w;
t = (Span->Fragment1->t + Span->dt * factor) * w;
// fragment shader
if(Texture != NULL)
{
if(BilinearTextureFiltering)
{
Texture->GetColorBilinear(s, t, &tr, &tg, &tb);
}
else
{
Texture->GetColorNearest(s, t, &tr, &tg, &tb);
}
r *= tr;
g *= tg;
b *= tb;
}
// writing to buffers
ColorBuffer[ColorBufferIndex++] = /*b <= 0.0f ? 0 : b >= 1.0f ? 255 :*/ (BYTE)(b * 255.0f);
ColorBuffer[ColorBufferIndex++] = /*g <= 0.0f ? 0 : g >= 1.0f ? 255 :*/ (BYTE)(g * 255.0f);
ColorBuffer[ColorBufferIndex++] = /*r <= 0.0f ? 0 : r >= 1.0f ? 255 :*/ (BYTE)(r * 255.0f);
DepthBuffer[DepthBufferIndex++] = Depth;
}
else
{
ColorBufferIndex += 3;
DepthBufferIndex++;
}
}
else
{
ColorBufferIndex += 3;
DepthBufferIndex++;
}
}
}
void CSoftwareGL::BlitAntiAliasingColorBuffer2x2(int ThreadId)
{
int TCM2 = ThreadsCount * 2, AACBWM3 = AntiAliasingColorBufferWidth * 3;
int LineAACB0, LineAACB1, LineSCB;
int xm3;
int LineAACB0Px0, LineAACB0Px1;
int LineAACB1Px0, LineAACB1Px1;
int LineSCBPxD2M3;
float r, g, b;
for(int y = ThreadId * 2; y < AntiAliasingColorBufferHeight; y += TCM2)
{
LineAACB0 = AACBWM3 * y;
LineAACB1 = LineAACB0 + AACBWM3;
LineSCB = StandardColorBufferWidth * y / 2 * 3;
for(int x = 0; x < AntiAliasingColorBufferWidth; x += 2)
{
xm3 = x * 3;
LineAACB0Px0 = LineAACB0 + xm3;
LineAACB0Px1 = LineAACB0Px0 + 3;
LineAACB1Px0 = LineAACB1 + xm3;
LineAACB1Px1 = LineAACB1Px0 + 3;
LineSCBPxD2M3 = LineSCB + x / 2 * 3;
b = AntiAliasingColorBuffer[LineAACB0Px0++];
g = AntiAliasingColorBuffer[LineAACB0Px0++];
r = AntiAliasingColorBuffer[LineAACB0Px0];
b += AntiAliasingColorBuffer[LineAACB0Px1++];
g += AntiAliasingColorBuffer[LineAACB0Px1++];
r += AntiAliasingColorBuffer[LineAACB0Px1];
b += AntiAliasingColorBuffer[LineAACB1Px0++];
g += AntiAliasingColorBuffer[LineAACB1Px0++];
r += AntiAliasingColorBuffer[LineAACB1Px0];
b += AntiAliasingColorBuffer[LineAACB1Px1++];
g += AntiAliasingColorBuffer[LineAACB1Px1++];
r += AntiAliasingColorBuffer[LineAACB1Px1];
StandardColorBuffer[LineSCBPxD2M3++] = (BYTE)(b / 4.0f);
StandardColorBuffer[LineSCBPxD2M3++] = (BYTE)(g / 4.0f);
StandardColorBuffer[LineSCBPxD2M3] = (BYTE)(r / 4.0f);
}
}
}
void CSoftwareGL::BlitAntiAliasingColorBuffer3x3(int ThreadId)
{
int TCM3 = ThreadsCount * 3, AACBWM3 = AntiAliasingColorBufferWidth * 3;
int LineAACB0, LineAACB1, LineAACB2, LineSCB;
int xm3;
int LineAACB0Px0, LineAACB0Px1, LineAACB0Px2;
int LineAACB1Px0, LineAACB1Px1, LineAACB1Px2;
int LineAACB2Px0, LineAACB2Px1, LineAACB2Px2;
int LineSCBPxD3M3;
float r, g, b;
for(int y = ThreadId * 3; y < AntiAliasingColorBufferHeight; y += TCM3)
{
LineAACB0 = AACBWM3 * y;
LineAACB1 = LineAACB0 + AACBWM3;
LineAACB2 = LineAACB1 + AACBWM3;
LineSCB = StandardColorBufferWidth * y;
for(int x = 0; x < AntiAliasingColorBufferWidth; x += 3)
{
xm3 = x * 3;
LineAACB0Px0 = LineAACB0 + xm3;
LineAACB0Px1 = LineAACB0Px0 + 3;
LineAACB0Px2 = LineAACB0Px1 + 3;
LineAACB1Px0 = LineAACB1 + xm3;
LineAACB1Px1 = LineAACB1Px0 + 3;
LineAACB1Px2 = LineAACB1Px1 + 3;
LineAACB2Px0 = LineAACB2 + xm3;
LineAACB2Px1 = LineAACB2Px0 + 3;
LineAACB2Px2 = LineAACB2Px1 + 3;
LineSCBPxD3M3 = LineSCB + x;
b = AntiAliasingColorBuffer[LineAACB0Px0++];
g = AntiAliasingColorBuffer[LineAACB0Px0++];
r = AntiAliasingColorBuffer[LineAACB0Px0];
b += AntiAliasingColorBuffer[LineAACB0Px1++];
g += AntiAliasingColorBuffer[LineAACB0Px1++];
r += AntiAliasingColorBuffer[LineAACB0Px1];
b += AntiAliasingColorBuffer[LineAACB0Px2++];
g += AntiAliasingColorBuffer[LineAACB0Px2++];
r += AntiAliasingColorBuffer[LineAACB0Px2];
b += AntiAliasingColorBuffer[LineAACB1Px0++];
g += AntiAliasingColorBuffer[LineAACB1Px0++];
r += AntiAliasingColorBuffer[LineAACB1Px0];
b += AntiAliasingColorBuffer[LineAACB1Px1++];
g += AntiAliasingColorBuffer[LineAACB1Px1++];
r += AntiAliasingColorBuffer[LineAACB1Px1];
b += AntiAliasingColorBuffer[LineAACB1Px2++];
g += AntiAliasingColorBuffer[LineAACB1Px2++];
r += AntiAliasingColorBuffer[LineAACB1Px2];
b += AntiAliasingColorBuffer[LineAACB2Px0++];
g += AntiAliasingColorBuffer[LineAACB2Px0++];
r += AntiAliasingColorBuffer[LineAACB2Px0];
b += AntiAliasingColorBuffer[LineAACB2Px1++];
g += AntiAliasingColorBuffer[LineAACB2Px1++];
r += AntiAliasingColorBuffer[LineAACB2Px1];
b += AntiAliasingColorBuffer[LineAACB2Px2++];
g += AntiAliasingColorBuffer[LineAACB2Px2++];
r += AntiAliasingColorBuffer[LineAACB2Px2];
StandardColorBuffer[LineSCBPxD3M3++] = (BYTE)(b / 9.0f);
StandardColorBuffer[LineSCBPxD3M3++] = (BYTE)(g / 9.0f);
StandardColorBuffer[LineSCBPxD3M3] = (BYTE)(r / 9.0f);
}
}
}
void CSoftwareGL::BlitAntiAliasingColorBuffer4x4(int ThreadId)
{
int TCM4 = ThreadsCount * 4, AACBWM3 = AntiAliasingColorBufferWidth * 3;
int LineAACB0, LineAACB1, LineAACB2, LineAACB3, LineSCB;
int xm3;
int LineAACB0Px0, LineAACB0Px1, LineAACB0Px2, LineAACB0Px3;
int LineAACB1Px0, LineAACB1Px1, LineAACB1Px2, LineAACB1Px3;
int LineAACB2Px0, LineAACB2Px1, LineAACB2Px2, LineAACB2Px3;
int LineAACB3Px0, LineAACB3Px1, LineAACB3Px2, LineAACB3Px3;
int LineSCBPxD4M3;
float r, g, b;
for(int y = ThreadId * 4; y < AntiAliasingColorBufferHeight; y += TCM4)
{
LineAACB0 = AACBWM3 * y;
LineAACB1 = LineAACB0 + AACBWM3;
LineAACB2 = LineAACB1 + AACBWM3;
LineAACB3 = LineAACB2 + AACBWM3;
LineSCB = StandardColorBufferWidth * y / 4 * 3;
for(int x = 0; x < AntiAliasingColorBufferWidth; x += 4)
{
xm3 = x * 3;
LineAACB0Px0 = LineAACB0 + xm3;
LineAACB0Px1 = LineAACB0Px0 + 3;
LineAACB0Px2 = LineAACB0Px1 + 3;
LineAACB0Px3 = LineAACB0Px2 + 3;
LineAACB1Px0 = LineAACB1 + xm3;
LineAACB1Px1 = LineAACB1Px0 + 3;
LineAACB1Px2 = LineAACB1Px1 + 3;
LineAACB1Px3 = LineAACB1Px2 + 3;
LineAACB2Px0 = LineAACB2 + xm3;
LineAACB2Px1 = LineAACB2Px0 + 3;
LineAACB2Px2 = LineAACB2Px1 + 3;
LineAACB2Px3 = LineAACB2Px2 + 3;
LineAACB3Px0 = LineAACB3 + xm3;
LineAACB3Px1 = LineAACB3Px0 + 3;
LineAACB3Px2 = LineAACB3Px1 + 3;
LineAACB3Px3 = LineAACB3Px2 + 3;
LineSCBPxD4M3 = LineSCB + x / 4 * 3;
b = AntiAliasingColorBuffer[LineAACB0Px0++];
g = AntiAliasingColorBuffer[LineAACB0Px0++];
r = AntiAliasingColorBuffer[LineAACB0Px0];
b += AntiAliasingColorBuffer[LineAACB0Px1++];
g += AntiAliasingColorBuffer[LineAACB0Px1++];
r += AntiAliasingColorBuffer[LineAACB0Px1];
b += AntiAliasingColorBuffer[LineAACB0Px2++];
g += AntiAliasingColorBuffer[LineAACB0Px2++];
r += AntiAliasingColorBuffer[LineAACB0Px2];
b += AntiAliasingColorBuffer[LineAACB0Px3++];
g += AntiAliasingColorBuffer[LineAACB0Px3++];
r += AntiAliasingColorBuffer[LineAACB0Px3];
b += AntiAliasingColorBuffer[LineAACB1Px0++];
g += AntiAliasingColorBuffer[LineAACB1Px0++];
r += AntiAliasingColorBuffer[LineAACB1Px0];
b += AntiAliasingColorBuffer[LineAACB1Px1++];
g += AntiAliasingColorBuffer[LineAACB1Px1++];
r += AntiAliasingColorBuffer[LineAACB1Px1];
b += AntiAliasingColorBuffer[LineAACB1Px2++];
g += AntiAliasingColorBuffer[LineAACB1Px2++];
r += AntiAliasingColorBuffer[LineAACB1Px2];
b += AntiAliasingColorBuffer[LineAACB1Px3++];
g += AntiAliasingColorBuffer[LineAACB1Px3++];
r += AntiAliasingColorBuffer[LineAACB1Px3];
b += AntiAliasingColorBuffer[LineAACB2Px0++];
g += AntiAliasingColorBuffer[LineAACB2Px0++];
r += AntiAliasingColorBuffer[LineAACB2Px0];
b += AntiAliasingColorBuffer[LineAACB2Px1++];
g += AntiAliasingColorBuffer[LineAACB2Px1++];
r += AntiAliasingColorBuffer[LineAACB2Px1];
b += AntiAliasingColorBuffer[LineAACB2Px2++];
g += AntiAliasingColorBuffer[LineAACB2Px2++];
r += AntiAliasingColorBuffer[LineAACB2Px2];
b += AntiAliasingColorBuffer[LineAACB2Px3++];
g += AntiAliasingColorBuffer[LineAACB2Px3++];
r += AntiAliasingColorBuffer[LineAACB2Px3];
b += AntiAliasingColorBuffer[LineAACB3Px0++];
g += AntiAliasingColorBuffer[LineAACB3Px0++];
r += AntiAliasingColorBuffer[LineAACB3Px0];
b += AntiAliasingColorBuffer[LineAACB3Px1++];
g += AntiAliasingColorBuffer[LineAACB3Px1++];
r += AntiAliasingColorBuffer[LineAACB3Px1];
b += AntiAliasingColorBuffer[LineAACB3Px2++];
g += AntiAliasingColorBuffer[LineAACB3Px2++];
r += AntiAliasingColorBuffer[LineAACB3Px2];
b += AntiAliasingColorBuffer[LineAACB3Px3++];
g += AntiAliasingColorBuffer[LineAACB3Px3++];
r += AntiAliasingColorBuffer[LineAACB3Px3];
StandardColorBuffer[LineSCBPxD4M3++] = (BYTE)(b / 16.0f);
StandardColorBuffer[LineSCBPxD4M3++] = (BYTE)(g / 16.0f);
StandardColorBuffer[LineSCBPxD4M3] = (BYTE)(r / 16.0f);
}
}
}
void CSoftwareGL::Viewport(int Width, int Height)
{
this->Width = Width;
this->Height = Height;
if(AntiAliasingColorBuffer != NULL)
{
delete [] AntiAliasingColorBuffer;
AntiAliasingColorBuffer = NULL;
}
if(StandardColorBuffer != NULL)
{
delete [] StandardColorBuffer;
StandardColorBuffer = NULL;
}
if(DepthBuffer != NULL)
{
delete [] DepthBuffer;
DepthBuffer = NULL;
}
if(Width > 0 && Height > 0)
{
if(AntiAliasing)
{
switch(AntiAliasing)
{
case ANTI_ALIASING_2X2:
AntiAliasingColorBufferWidth = Width * 2;
AntiAliasingColorBufferHeight = Height * 2;
break;
case ANTI_ALIASING_3X3:
AntiAliasingColorBufferWidth = Width * 3;
AntiAliasingColorBufferHeight = Height * 3;
break;
case ANTI_ALIASING_4X4:
AntiAliasingColorBufferWidth = Width * 4;
AntiAliasingColorBufferHeight = Height * 4;
break;
}
AntiAliasingColorBuffer = new BYTE[AntiAliasingColorBufferWidth * AntiAliasingColorBufferHeight * 3];
}
StandardColorBufferWidth = Width;
StandardColorBufferHeight = Height;
int WidthMod4 = Width % 4;
if(WidthMod4 > 0)
{
StandardColorBufferWidth += 4 - WidthMod4;
}
StandardColorBuffer = new BYTE[StandardColorBufferWidth * StandardColorBufferHeight * 3];
memset(&StandardColorBufferInfo, 0, sizeof(BITMAPINFO));
StandardColorBufferInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
StandardColorBufferInfo.bmiHeader.biPlanes = 1;
StandardColorBufferInfo.bmiHeader.biBitCount = 24;
StandardColorBufferInfo.bmiHeader.biCompression = BI_RGB;
StandardColorBufferInfo.bmiHeader.biWidth = StandardColorBufferWidth;
StandardColorBufferInfo.bmiHeader.biHeight = StandardColorBufferHeight;
switch(AntiAliasing)
{
case NONE:
DepthBufferWidth = Width;
DepthBufferHeight = Height;
break;
case ANTI_ALIASING_2X2:
DepthBufferWidth = Width * 2;
DepthBufferHeight = Height * 2;
break;
case ANTI_ALIASING_3X3:
DepthBufferWidth = Width * 3;
DepthBufferHeight = Height * 3;
break;
case ANTI_ALIASING_4X4:
DepthBufferWidth = Width * 4;
DepthBufferHeight = Height * 4;
break;
}
DepthBuffer = new USHORT[DepthBufferWidth * DepthBufferHeight];
}
if(AntiAliasing)
{
ColorBuffer = AntiAliasingColorBuffer;
ColorBufferWidth = AntiAliasingColorBufferWidth;
ColorBufferHeight = AntiAliasingColorBufferHeight;
}
else
{
ColorBuffer = StandardColorBuffer;
ColorBufferWidth = StandardColorBufferWidth;
ColorBufferHeight = StandardColorBufferHeight;
}
}
void CSoftwareGL::SwapBuffers(HDC hDC)
{
if(StandardColorBuffer != NULL)
{
if(AntiAliasing)
{
if(AntiAliasingColorBuffer != NULL)
{
switch(AntiAliasing)
{
case ANTI_ALIASING_2X2: RunFunctionMultiThreadedAndWaitForCompletion(2); break;
case ANTI_ALIASING_3X3: RunFunctionMultiThreadedAndWaitForCompletion(3); break;
case ANTI_ALIASING_4X4: RunFunctionMultiThreadedAndWaitForCompletion(4); break;
}
}
}
StretchDIBits(hDC, 0, 0, Width, Height, 0, 0, Width, Height, StandardColorBuffer, &StandardColorBufferInfo, DIB_RGB_COLORS, SRCCOPY);
}
}
// ----------------------------------------------------------------------------------------------------------------------------
CSoftwareGLRenderer::CSoftwareGLRenderer()
{
RenderObject = 3;
Lighting = true;
Texturing = true;
}
CSoftwareGLRenderer::~CSoftwareGLRenderer()
{
}
bool CSoftwareGLRenderer::Init()
{
bool Error = false;
Error |= !Texture.LoadTexture("texture.jpg");
Error |= !Object[0].Load("Models\\Thor\\", "thor.obj");
Error |= !Object[1].Load("Models\\", "Bunny_Medium.obj");
Error |= !Object[2].Load("Models\\", "Dragon_Medium.obj");
if(Error)
{
return false;
}
Object[0].Rotate(-90.0f, vec3(0.0f, 1.0f, 0.0f));
Object[0].Scale(1.75f / (Object[0].Max.y - Object[0].Min.y));
Object[0].Translate(vec3(-(Object[0].Min.x + Object[0].Max.x) / 2.0f, -(Object[0].Min.y + Object[0].Max.y) / 2.0f, -(Object[0].Min.z + Object[0].Max.z) / 2.0f));
Object[1].Rotate(90.0f, vec3(0.0f, 1.0f, 0.0f));
Object[1].Scale(1.75f / (Object[1].Max.y - Object[1].Min.y));
Object[1].Translate(vec3(-(Object[1].Min.x + Object[1].Max.x) / 2.0f, -(Object[1].Min.y + Object[1].Max.y) / 2.0f, -(Object[1].Min.z + Object[1].Max.z) / 2.0f));
Object[2].Rotate(90.0f, vec3(0.0f, 1.0f, 0.0f));
Object[2].Scale(1.75f / (Object[2].Max.y - Object[2].Min.y));
Object[2].Translate(vec3(-(Object[2].Min.x + Object[2].Max.x) / 2.0f, -(Object[2].Min.y + Object[2].Max.y) / 2.0f, -(Object[2].Min.z + Object[2].Max.z) / 2.0f));
Vertices = new CVertex[45];
int v = 0;
Vertices[v].Position = vec3(-0.5f,-0.5f, 0.0f); Vertices[v].Color = vec3(1.0f, 0.0f, 0.0f); Vertices[v].TexCoord = vec2(0.0f, 0.0f); Vertices[v].Normal = vec3( 0.0f, 0.0f, 1.0f); v++;
Vertices[v].Position = vec3( 0.5f,-0.5f, 0.0f); Vertices[v].Color = vec3(0.0f, 1.0f, 0.0f); Vertices[v].TexCoord = vec2(1.0f, 0.0f); Vertices[v].Normal = vec3( 0.0f, 0.0f, 1.0f); v++;
Vertices[v].Position = vec3( 0.0f, 0.5f, 0.0f); Vertices[v].Color = vec3(0.0f, 0.0f, 1.0f); Vertices[v].TexCoord = vec2(0.5f, 1.0f); Vertices[v].Normal = vec3( 0.0f, 0.0f, 1.0f); v++;
Vertices[v].Position = vec3(-0.5f,-0.5f,-0.5f); Vertices[v].Color = vec3(1.0f, 1.0f, 1.0f); Vertices[v].TexCoord = vec2(0.0f, 0.0f); Vertices[v].Normal = vec3(-1.0f, 0.0f, 0.0f); v++;
Vertices[v].Position = vec3(-0.5f,-0.5f, 0.5f); Vertices[v].Color = vec3(1.0f, 1.0f, 0.0f); Vertices[v].TexCoord = vec2(1.0f, 0.0f); Vertices[v].Normal = vec3(-1.0f, 0.0f, 0.0f); v++;
Vertices[v].Position = vec3(-0.5f, 0.5f, 0.5f); Vertices[v].Color = vec3(1.0f, 0.0f, 0.0f); Vertices[v].TexCoord = vec2(1.0f, 1.0f); Vertices[v].Normal = vec3(-1.0f, 0.0f, 0.0f); v++;
Vertices[v].Position = vec3(-0.5f, 0.5f, 0.5f); Vertices[v].Color = vec3(1.0f, 0.0f, 0.0f); Vertices[v].TexCoord = vec2(1.0f, 1.0f); Vertices[v].Normal = vec3(-1.0f, 0.0f, 0.0f); v++;
Vertices[v].Position = vec3(-0.5f, 0.5f,-0.5f); Vertices[v].Color = vec3(1.0f, 0.0f, 1.0f); Vertices[v].TexCoord = vec2(0.0f, 1.0f); Vertices[v].Normal = vec3(-1.0f, 0.0f, 0.0f); v++;
Vertices[v].Position = vec3(-0.5f,-0.5f,-0.5f); Vertices[v].Color = vec3(1.0f, 1.0f, 1.0f); Vertices[v].TexCoord = vec2(0.0f, 0.0f); Vertices[v].Normal = vec3(-1.0f, 0.0f, 0.0f); v++;
Vertices[v].Position = vec3( 0.5f,-0.5f, 0.5f); Vertices[v].Color = vec3(0.0f, 1.0f, 0.0f); Vertices[v].TexCoord = vec2(0.0f, 0.0f); Vertices[v].Normal = vec3( 1.0f, 0.0f, 0.0f); v++;
Vertices[v].Position = vec3( 0.5f,-0.5f,-0.5f); Vertices[v].Color = vec3(0.0f, 1.0f, 1.0f); Vertices[v].TexCoord = vec2(1.0f, 0.0f); Vertices[v].Normal = vec3( 1.0f, 0.0f, 0.0f); v++;
Vertices[v].Position = vec3( 0.5f, 0.5f,-0.5f); Vertices[v].Color = vec3(0.0f, 0.0f, 1.0f); Vertices[v].TexCoord = vec2(1.0f, 1.0f); Vertices[v].Normal = vec3( 1.0f, 0.0f, 0.0f); v++;
Vertices[v].Position = vec3( 0.5f, 0.5f,-0.5f); Vertices[v].Color = vec3(0.0f, 0.0f, 1.0f); Vertices[v].TexCoord = vec2(1.0f, 1.0f); Vertices[v].Normal = vec3( 1.0f, 0.0f, 0.0f); v++;
Vertices[v].Position = vec3( 0.5f, 0.5f, 0.5f); Vertices[v].Color = vec3(0.0f, 0.0f, 0.0f); Vertices[v].TexCoord = vec2(0.0f, 1.0f); Vertices[v].Normal = vec3( 1.0f, 0.0f, 0.0f); v++;
Vertices[v].Position = vec3( 0.5f,-0.5f, 0.5f); Vertices[v].Color = vec3(0.0f, 1.0f, 0.0f); Vertices[v].TexCoord = vec2(0.0f, 0.0f); Vertices[v].Normal = vec3( 1.0f, 0.0f, 0.0f); v++;
Vertices[v].Position = vec3(-0.5f,-0.5f,-0.5f); Vertices[v].Color = vec3(1.0f, 1.0f, 1.0f); Vertices[v].TexCoord = vec2(0.0f, 0.0f); Vertices[v].Normal = vec3( 0.0f, -1.0f, 0.0f); v++;
Vertices[v].Position = vec3( 0.5f,-0.5f,-0.5f); Vertices[v].Color = vec3(0.0f, 1.0f, 1.0f); Vertices[v].TexCoord = vec2(1.0f, 0.0f); Vertices[v].Normal = vec3( 0.0f, -1.0f, 0.0f); v++;
Vertices[v].Position = vec3( 0.5f,-0.5f, 0.5f); Vertices[v].Color = vec3(0.0f, 1.0f, 0.0f); Vertices[v].TexCoord = vec2(1.0f, 1.0f); Vertices[v].Normal = vec3( 0.0f, -1.0f, 0.0f); v++;
Vertices[v].Position = vec3( 0.5f,-0.5f, 0.5f); Vertices[v].Color = vec3(0.0f, 1.0f, 0.0f); Vertices[v].TexCoord = vec2(1.0f, 1.0f); Vertices[v].Normal = vec3( 0.0f, -1.0f, 0.0f); v++;
Vertices[v].Position = vec3(-0.5f,-0.5f, 0.5f); Vertices[v].Color = vec3(1.0f, 1.0f, 0.0f); Vertices[v].TexCoord = vec2(0.0f, 1.0f); Vertices[v].Normal = vec3( 0.0f, -1.0f, 0.0f); v++;
Vertices[v].Position = vec3(-0.5f,-0.5f,-0.5f); Vertices[v].Color = vec3(1.0f, 1.0f, 1.0f); Vertices[v].TexCoord = vec2(0.0f, 0.0f); Vertices[v].Normal = vec3( 0.0f, -1.0f, 0.0f); v++;
Vertices[v].Position = vec3(-0.5f, 0.5f, 0.5f); Vertices[v].Color = vec3(1.0f, 0.0f, 0.0f); Vertices[v].TexCoord = vec2(0.0f, 0.0f); Vertices[v].Normal = vec3( 0.0f, 1.0f, 0.0f); v++;
Vertices[v].Position = vec3( 0.5f, 0.5f, 0.5f); Vertices[v].Color = vec3(0.0f, 0.0f, 0.0f); Vertices[v].TexCoord = vec2(1.0f, 0.0f); Vertices[v].Normal = vec3( 0.0f, 1.0f, 0.0f); v++;
Vertices[v].Position = vec3( 0.5f, 0.5f,-0.5f); Vertices[v].Color = vec3(0.0f, 0.0f, 1.0f); Vertices[v].TexCoord = vec2(1.0f, 1.0f); Vertices[v].Normal = vec3( 0.0f, 1.0f, 0.0f); v++;
Vertices[v].Position = vec3( 0.5f, 0.5f,-0.5f); Vertices[v].Color = vec3(0.0f, 0.0f, 1.0f); Vertices[v].TexCoord = vec2(1.0f, 1.0f); Vertices[v].Normal = vec3( 0.0f, 1.0f, 0.0f); v++;
Vertices[v].Position = vec3(-0.5f, 0.5f,-0.5f); Vertices[v].Color = vec3(1.0f, 0.0f, 1.0f); Vertices[v].TexCoord = vec2(0.0f, 1.0f); Vertices[v].Normal = vec3( 0.0f, 1.0f, 0.0f); v++;
Vertices[v].Position = vec3(-0.5f, 0.5f, 0.5f); Vertices[v].Color = vec3(1.0f, 0.0f, 0.0f); Vertices[v].TexCoord = vec2(0.0f, 0.0f); Vertices[v].Normal = vec3( 0.0f, 1.0f, 0.0f); v++;
Vertices[v].Position = vec3( 0.5f,-0.5f,-0.5f); Vertices[v].Color = vec3(0.0f, 1.0f, 1.0f); Vertices[v].TexCoord = vec2(0.0f, 0.0f); Vertices[v].Normal = vec3( 0.0f, 0.0f, -1.0f); v++;
Vertices[v].Position = vec3(-0.5f,-0.5f,-0.5f); Vertices[v].Color = vec3(1.0f, 1.0f, 1.0f); Vertices[v].TexCoord = vec2(1.0f, 0.0f); Vertices[v].Normal = vec3( 0.0f, 0.0f, -1.0f); v++;
Vertices[v].Position = vec3(-0.5f, 0.5f,-0.5f); Vertices[v].Color = vec3(1.0f, 0.0f, 1.0f); Vertices[v].TexCoord = vec2(1.0f, 1.0f); Vertices[v].Normal = vec3( 0.0f, 0.0f, -1.0f); v++;
Vertices[v].Position = vec3(-0.5f, 0.5f,-0.5f); Vertices[v].Color = vec3(1.0f, 0.0f, 1.0f); Vertices[v].TexCoord = vec2(1.0f, 1.0f); Vertices[v].Normal = vec3( 0.0f, 0.0f, -1.0f); v++;
Vertices[v].Position = vec3( 0.5f, 0.5f,-0.5f); Vertices[v].Color = vec3(0.0f, 0.0f, 1.0f); Vertices[v].TexCoord = vec2(0.0f, 1.0f); Vertices[v].Normal = vec3( 0.0f, 0.0f, -1.0f); v++;
Vertices[v].Position = vec3( 0.5f,-0.5f,-0.5f); Vertices[v].Color = vec3(0.0f, 1.0f, 1.0f); Vertices[v].TexCoord = vec2(0.0f, 0.0f); Vertices[v].Normal = vec3( 0.0f, 0.0f, -1.0f); v++;
Vertices[v].Position = vec3(-0.5f,-0.5f, 0.5f); Vertices[v].Color = vec3(1.0f, 1.0f, 0.0f); Vertices[v].TexCoord = vec2(0.0f, 0.0f); Vertices[v].Normal = vec3( 0.0f, 0.0f, 1.0f); v++;
Vertices[v].Position = vec3( 0.5f,-0.5f, 0.5f); Vertices[v].Color = vec3(0.0f, 1.0f, 0.0f); Vertices[v].TexCoord = vec2(1.0f, 0.0f); Vertices[v].Normal = vec3( 0.0f, 0.0f, 1.0f); v++;
Vertices[v].Position = vec3( 0.5f, 0.5f, 0.5f); Vertices[v].Color = vec3(0.0f, 0.0f, 0.0f); Vertices[v].TexCoord = vec2(1.0f, 1.0f); Vertices[v].Normal = vec3( 0.0f, 0.0f, 1.0f); v++;
Vertices[v].Position = vec3( 0.5f, 0.5f, 0.5f); Vertices[v].Color = vec3(0.0f, 0.0f, 0.0f); Vertices[v].TexCoord = vec2(1.0f, 1.0f); Vertices[v].Normal = vec3( 0.0f, 0.0f, 1.0f); v++;
Vertices[v].Position = vec3(-0.5f, 0.5f, 0.5f); Vertices[v].Color = vec3(1.0f, 0.0f, 0.0f); Vertices[v].TexCoord = vec2(0.0f, 1.0f); Vertices[v].Normal = vec3( 0.0f, 0.0f, 1.0f); v++;
Vertices[v].Position = vec3(-0.5f,-0.5f, 0.5f); Vertices[v].Color = vec3(1.0f, 1.0f, 0.0f); Vertices[v].TexCoord = vec2(0.0f, 0.0f); Vertices[v].Normal = vec3( 0.0f, 0.0f, 1.0f); v++;
Vertices[v].Position = vec3(-0.75f, 0.0f, 0.75f); Vertices[v].Color = vec3(0.0f, 0.0f, 1.0f); Vertices[v].TexCoord = vec2(-0.75f,-0.75f); Vertices[v].Normal = vec3( 0.0f, 1.0f, 0.0f); v++;
Vertices[v].Position = vec3( 0.75f, 0.0f, 0.75f); Vertices[v].Color = vec3(0.0f, 1.0f, 0.0f); Vertices[v].TexCoord = vec2( 0.75f,-0.75f); Vertices[v].Normal = vec3( 0.0f, 1.0f, 0.0f); v++;
Vertices[v].Position = vec3( 0.75f, 0.0f,-0.75f); Vertices[v].Color = vec3(0.0f, 1.0f, 1.0f); Vertices[v].TexCoord = vec2( 0.75f, 0.75f); Vertices[v].Normal = vec3( 0.0f, 1.0f, 0.0f); v++;
Vertices[v].Position = vec3( 0.75f, 0.0f,-0.75f); Vertices[v].Color = vec3(0.0f, 1.0f, 1.0f); Vertices[v].TexCoord = vec2( 0.75f, 0.75f); Vertices[v].Normal = vec3( 0.0f, 1.0f, 0.0f); v++;
Vertices[v].Position = vec3(-0.75f, 0.0f,-0.75f); Vertices[v].Color = vec3(1.0f, 0.0f, 0.0f); Vertices[v].TexCoord = vec2(-0.75f, 0.75f); Vertices[v].Normal = vec3( 0.0f, 1.0f, 0.0f); v++;
Vertices[v].Position = vec3(-0.75f, 0.0f, 0.75f); Vertices[v].Color = vec3(0.0f, 0.0f, 1.0f); Vertices[v].TexCoord = vec2(-0.75f,-0.75f); Vertices[v].Normal = vec3( 0.0f, 1.0f, 0.0f); v++;
Light.Position = Camera.Position;
Light.Ambient = vec3(0.5f);
Light.Diffuse = vec3(0.5f);
Light.ConstantAttenuation = 1.0f;
Light.LinearAttenuation = 0.0f;
Light.QuadraticAttenuation = 0.0f;
return true;
}
void CSoftwareGLRenderer::Render(float FrameTime)
{
Clear();
LoadModelViewProjectionMatrix(Camera.ViewProjectionMatrix);
if(Lighting)
{
Light.Position = Camera.Position;
BindLight(&Light);
}
if(Texturing)
{
switch(RenderObject)
{
case 1: BindTexture(&Texture); break;
case 2: BindTexture(&Texture); break;
case 3: BindTexture(&Object[0].Texture); break;
case 4: BindTexture(&Object[1].Texture); break;
case 5: BindTexture(&Object[2].Texture); break;
}
}
switch(RenderObject)
{
case 1: DrawTriangles(Vertices, 0, 3); break;
case 2: DrawTriangles(Vertices, 3, 42); break;
case 3: DrawTriangles(Object[0].Vertices, 0, Object[0].VerticesCount); break;
case 4: DrawTriangles(Object[1].Vertices, 0, Object[1].VerticesCount); break;
case 5: DrawTriangles(Object[2].Vertices, 0, Object[2].VerticesCount); break;
}
if(Texturing)
{
BindTexture(NULL);
}
if(Lighting)
{
BindLight(NULL);
}
}
void CSoftwareGLRenderer::Resize(int Width, int Height)
{
Viewport(Width, Height);
Camera.SetPerspective(45.0f, (float)Width / (float)Height, 0.125f, 512.0f);
}
void CSoftwareGLRenderer::Destroy()
{
Texture.Destroy();
for(int i = 0; i < 3; i++)
{
Object[i].Destroy();
}
delete [] Vertices;
}
void CSoftwareGLRenderer::CheckCameraKeys(float FrameTime)
{
BYTE Keys = 0x00;
if(GetKeyState('W') & 0x80) Keys |= 0x01;
if(GetKeyState('S') & 0x80) Keys |= 0x02;
if(GetKeyState('A') & 0x80) Keys |= 0x04;
if(GetKeyState('D') & 0x80) Keys |= 0x08;
if(GetKeyState('R') & 0x80) Keys |= 0x10;
if(GetKeyState('F') & 0x80) Keys |= 0x20;
if(GetKeyState(VK_SHIFT) & 0x80) Keys |= 0x40;
if(GetKeyState(VK_CONTROL) & 0x80) Keys |= 0x80;
if(Keys & 0x3F)
{
Camera.Move(Camera.OnKeys(Keys, FrameTime));
}
}
void CSoftwareGLRenderer::OnKeyDown(UINT Key)
{
switch(Key)
{
case VK_F1:
if(GetCullFace() == CULL_FACE_FRONT) SetCullFace(CULL_FACE_BACK);
else if(GetCullFace() == CULL_FACE_BACK) SetCullFace(CULL_FACE_FRONT);
break;
case VK_F2:
SetBilinearTextureFiltering(!GetBilinearTextureFiltering());
break;
case VK_F5:
RenderObject = 1;
break;
case VK_F6:
RenderObject = 2;
break;
case VK_F7:
RenderObject = 3;
break;
case VK_F8:
RenderObject = 4;
break;
case VK_F9:
RenderObject = 5;
break;
case '1':
SetAntiAliasing(NONE);
break;
case '2':
SetAntiAliasing(ANTI_ALIASING_2X2);
break;
case '3':
SetAntiAliasing(ANTI_ALIASING_3X3);
break;
case '4':
SetAntiAliasing(ANTI_ALIASING_4X4);
break;
case 'T':
Texturing = !Texturing;
break;
case 'L':
Lighting = !Lighting;
break;
}
}
void CSoftwareGLRenderer::OnLButtonDown(int X, int Y)
{
LastClickedX = X;
LastClickedY = Y;
}
void CSoftwareGLRenderer::OnLButtonUp(int X, int Y)
{
if(X == LastClickedX && Y == LastClickedY)
{
}
}
void CSoftwareGLRenderer::OnMouseMove(int X, int Y)
{
if(GetKeyState(VK_RBUTTON) & 0x80)
{
Camera.OnMouseMove(LastX - X, LastY - Y);
}
LastX = X;
LastY = Y;
}
void CSoftwareGLRenderer::OnMouseWheel(short zDelta)
{
Camera.OnMouseWheel(zDelta);
}
void CSoftwareGLRenderer::OnRButtonDown(int X, int Y)
{
LastClickedX = X;
LastClickedY = Y;
}
void CSoftwareGLRenderer::OnRButtonUp(int X, int Y)
{
if(X == LastClickedX && Y == LastClickedY)
{
}
}
// ----------------------------------------------------------------------------------------------------------------------------
CSoftwareGLView::CSoftwareGLView()
{
char *moduledirectory = new char[256];
GetModuleFileName(GetModuleHandle(NULL), moduledirectory, 256);
*(strrchr(moduledirectory, '\\') + 1) = 0;
ModuleDirectory = moduledirectory;
delete [] moduledirectory;
}
CSoftwareGLView::~CSoftwareGLView()
{
}
bool CSoftwareGLView::Create(HINSTANCE hInstance, char *Title, int Width, int Height)
{
WNDCLASSEX WndClassEx;
memset(&WndClassEx, 0, sizeof(WNDCLASSEX));
WndClassEx.cbSize = sizeof(WNDCLASSEX);
WndClassEx.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
WndClassEx.lpfnWndProc = WndProc;
WndClassEx.hInstance = hInstance;
WndClassEx.hIcon = LoadIcon(NULL, IDI_APPLICATION);
WndClassEx.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
WndClassEx.hCursor = LoadCursor(NULL, IDC_ARROW);
WndClassEx.lpszClassName = "Win32OpenGLWindow";
if(RegisterClassEx(&WndClassEx) == 0)
{
ErrorLog.Set("RegisterClassEx failed!");
return false;
}
this->Title = Title;
this->Width = Width;
this->Height = Height;
DWORD Style = WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
if((hWnd = CreateWindowEx(WS_EX_APPWINDOW, WndClassEx.lpszClassName, Title, Style, 0, 0, Width, Height, NULL, NULL, hInstance, NULL)) == NULL)
{
ErrorLog.Set("CreateWindowEx failed!");
return false;
}
if((hDC = GetDC(hWnd)) == NULL)
{
ErrorLog.Set("GetDC failed!");
return false;
}
return SoftwareGLRenderer.Init();
}
void CSoftwareGLView::Show(bool Maximized)
{
RECT dRect, wRect, cRect;
GetWindowRect(GetDesktopWindow(), &dRect);
GetWindowRect(hWnd, &wRect);
GetClientRect(hWnd, &cRect);
wRect.right += Width - cRect.right;
wRect.bottom += Height - cRect.bottom;
wRect.right -= wRect.left;
wRect.bottom -= wRect.top;
wRect.left = dRect.right / 2 - wRect.right / 2;
wRect.top = dRect.bottom / 2 - wRect.bottom / 2;
MoveWindow(hWnd, wRect.left, wRect.top, wRect.right, wRect.bottom, FALSE);
ShowWindow(hWnd, Maximized ? SW_SHOWMAXIMIZED : SW_SHOWNORMAL);
}
void CSoftwareGLView::MsgLoop()
{
MSG Msg;
while(GetMessage(&Msg, NULL, 0, 0) > 0)
{
TranslateMessage(&Msg);
DispatchMessage(&Msg);
}
}
void CSoftwareGLView::Destroy()
{
SoftwareGLRenderer.Destroy();
DestroyWindow(hWnd);
}
void CSoftwareGLView::OnKeyDown(UINT Key)
{
switch(Key)
{
case '5':
ShowWindow(hWnd, SW_HIDE);
Width = 400;
Height = 300;
Show();
break;
case '6':
ShowWindow(hWnd, SW_HIDE);
Width = 512;
Height = 384;
Show();
break;
case '7':
ShowWindow(hWnd, SW_HIDE);
Width = 640;
Height = 480;
Show();
break;
case '8':
ShowWindow(hWnd, SW_HIDE);
Width = 800;
Height = 600;
Show();
break;
case '9':
ShowWindow(hWnd, SW_HIDE);
Width = 1024;
Height = 768;
Show();
break;
case '0':
ShowWindow(hWnd, SW_HIDE);
Width = 1280;
Height = 800;
Show();
break;
}
SoftwareGLRenderer.OnKeyDown(Key);
}
void CSoftwareGLView::OnLButtonDown(int X, int Y)
{
SoftwareGLRenderer.OnLButtonDown(X, Y);
}
void CSoftwareGLView::OnLButtonUp(int X, int Y)
{
SoftwareGLRenderer.OnLButtonUp(X, Y);
}
void CSoftwareGLView::OnMouseMove(int X, int Y)
{
SoftwareGLRenderer.OnMouseMove(X, Y);
}
void CSoftwareGLView::OnMouseWheel(short zDelta)
{
SoftwareGLRenderer.OnMouseWheel(zDelta);
}
void CSoftwareGLView::OnPaint()
{
PAINTSTRUCT ps;
BeginPaint(hWnd, &ps);
static DWORD LastFPSTime = GetTickCount(), LastFrameTime = LastFPSTime;
static int FPS = 0;
DWORD Time = GetTickCount();
float FrameTime = (Time - LastFrameTime) * 0.001f;
LastFrameTime = Time;
if(Time - LastFPSTime > 1000)
{
CString Text = Title;
Text.Append(" - %dx%d", Width, Height);
Text.Append(", BTF: "); if(SoftwareGLRenderer.GetBilinearTextureFiltering()) Text.Append("ON"); else Text.Append("OFF");
if(SoftwareGLRenderer.GetAntiAliasing() == NONE) Text.Append(", AA: OFF");
else if(SoftwareGLRenderer.GetAntiAliasing() == ANTI_ALIASING_2X2) Text.Append(", AA: 4x");
else if(SoftwareGLRenderer.GetAntiAliasing() == ANTI_ALIASING_3X3) Text.Append(", AA: 9x");
else if(SoftwareGLRenderer.GetAntiAliasing() == ANTI_ALIASING_4X4) Text.Append(", AA: 16x");
Text.Append(", Threads: %d", SoftwareGLRenderer.GetThreadsCount());
Text.Append(", FPS: %d", FPS);
SetWindowText(hWnd, Text);
LastFPSTime = Time;
FPS = 0;
}
else
{
FPS++;
}
SoftwareGLRenderer.CheckCameraKeys(FrameTime);
SoftwareGLRenderer.Render(FrameTime);
SoftwareGLRenderer.SwapBuffers(hDC);
EndPaint(hWnd, &ps);
InvalidateRect(hWnd, NULL, FALSE);
}
void CSoftwareGLView::OnRButtonDown(int X, int Y)
{
SoftwareGLRenderer.OnRButtonDown(X, Y);
}
void CSoftwareGLView::OnRButtonUp(int X, int Y)
{
SoftwareGLRenderer.OnRButtonUp(X, Y);
}
void CSoftwareGLView::OnSize(int Width, int Height)
{
this->Width = Width;
this->Height = Height;
SoftwareGLRenderer.Resize(Width, Height);
}
// ----------------------------------------------------------------------------------------------------------------------------
CSoftwareGLView SoftwareGLView;
// ----------------------------------------------------------------------------------------------------------------------------
LRESULT CALLBACK WndProc(HWND hWnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
switch(uiMsg)
{
case WM_CLOSE:
PostQuitMessage(0);
break;
case WM_KEYDOWN:
SoftwareGLView.OnKeyDown((UINT)wParam);
break;
case WM_LBUTTONDOWN:
SoftwareGLView.OnLButtonDown(LOWORD(lParam), HIWORD(lParam));
break;
case WM_LBUTTONUP:
SoftwareGLView.OnLButtonUp(LOWORD(lParam), HIWORD(lParam));
break;
case WM_MOUSEMOVE:
SoftwareGLView.OnMouseMove(LOWORD(lParam), HIWORD(lParam));
break;
case WM_MOUSWHEEL:
SoftwareGLView.OnMouseWheel(HIWORD(wParam));
break;
case WM_PAINT:
SoftwareGLView.OnPaint();
break;
case WM_RBUTTONDOWN:
SoftwareGLView.OnRButtonDown(LOWORD(lParam), HIWORD(lParam));
break;
case WM_RBUTTONUP:
SoftwareGLView.OnRButtonUp(LOWORD(lParam), HIWORD(lParam));
break;
case WM_SIZE:
SoftwareGLView.OnSize(LOWORD(lParam), HIWORD(lParam));
break;
default:
return DefWindowProc(hWnd, uiMsg, wParam, lParam);
}
return 0;
}
// ----------------------------------------------------------------------------------------------------------------------------
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR sCmdLine, int iShow)
{
if(SoftwareGLView.Create(hInstance, "Simple software renderer - Multithreading", 800, 600))
{
SoftwareGLView.Show();
SoftwareGLView.MsgLoop();
}
else
{
MessageBox(NULL, ErrorLog, "Error", MB_OK | MB_ICONERROR);
}
SoftwareGLView.Destroy();
return 0;
}
// ----------------------------------------------------------------------------------------------------------------------------
Download
simple_software_renderer.zip (Visual Studio 2008 Professional)
|
|
© 2010 - 2016 Bc. Michal Belanec, michalbelanec (at) centrum (dot) sk
Last update June 25, 2016 OpenGL® is a registered trademark of Silicon Graphics Inc. |