Sign in to follow this  
capn_midnight

3H-GDC m.II **** The results are in ****

Recommended Posts

Just wanted to wish all the participants the best of luck.

I offered up one of the prizes, but in reality the real prize is in taking pleasure from programming, and carving out a place for yourself in the world, doing something you love to do.

No prize can top that! (ok... perhaps TWO years of GD.Net could top that... [wink])

Share this post


Link to post
Share on other sites
OK, so I don't see there having been much discussion on the theme yet... any ideas on that?

Also, is it OK to basically rip code from samples - I'm really just thinking of a few of the ones that come with the DirectX SDK, which everybody that is using that platform will have access to no problems?

-Mezz

Share this post


Link to post
Share on other sites
Quote:
Original post by Mezz
OK, so I don't see there having been much discussion on the theme yet... any ideas on that?

Also, is it OK to basically rip code from samples - I'm really just thinking of a few of the ones that come with the DirectX SDK, which everybody that is using that platform will have access to no problems?

-Mezz

I'm going to say no. All non-API code should be written by you, unless it is the shared code base here in the thread.

Remember, you must post your code base by 11:59PM TONIGHT by the server clock in order for it to be considered.

Share this post


Link to post
Share on other sites
First, where do we post our basecode? This thread, I'm assuming, but not sure. I had a second question but a quick read-through of your rules answered it for me.

Share this post


Link to post
Share on other sites
Quote:
Original post by Samith
First, where do we post our basecode? This thread, I'm assuming, but not sure. I had a second question but a quick read-through of your rules answered it for me.

yes, this thread.

Share this post


Link to post
Share on other sites
Ok then, this will be my basecode (it should compile just fine, the input isn't tied in with the code, but it's not too hard to tie in (make sure you call ShowForeground and SetFocus before creating the input object or the device acquire can fail):

Libraries needed: OpenGL32.lib glu32.lib dxguid.lib dinput.lib dinput8.lib

Input.h
#ifndef H_INPUT
#define H_INPUT

#include <dinput.h>
#include "glheaders.h"
#include "point.h"

class Input
{
public:
explicit Input() : mouse_x(), mouse_y() { Init(); }
~Input();

void Update();
Point2d<long> mousePos() const { return Point2d<long>(mouse_x, mouse_y); }
bool leftUp() const { return !mouse_data.rgbButtons[0] && last_mouse.rgbButtons[0]; }
bool rightUp() const { return !mouse_data.rgbButtons[1] && last_mouse.rgbButtons[1]; }
bool leftDown() const { return mouse_data.rgbButtons[0] && !last_mouse.rgbButtons[0]; }
bool rightDown() const { return mouse_data.rgbButtons[1] && !last_mouse.rgbButtons[1]; }
bool rightClick() const { return mouse_data.rgbButtons[1]; }
bool leftClick() const { return mouse_data.rgbButtons[0]; }
float xDrag() const { if(rightClick()) return xMove(); else return 0.0f; }
float yDrag() const { if(rightClick()) return yMove(); else return 0.0f; }
float xMove() const { return static_cast<float>(mouse_data.lX); }
float yMove() const { return static_cast<float>(mouse_data.lY); }
float xMouse() const { return static_cast<float>(mouse_x); }
float yMouse() const { return static_cast<float>(mouse_y); }
char key(const char c) const { return keys[c]; }
char keyDown(const char c) const { return (keys[c] && !last_keys[c]); }
char keyUp(const char c) const { return (!keys[c] && last_keys[c]); }

private:
bool Init();
void KillInput();

char last_keys[256];
char keys[256];
DIMOUSESTATE last_mouse;
DIMOUSESTATE mouse_data;
long mouse_x;
long mouse_y;

LPDIRECTINPUT8 lpdi;
LPDIRECTINPUTDEVICE8 keyboard_device;
LPDIRECTINPUTDEVICE8 mouse_device;
};

#endif






Input.cpp
#include "input.h"

Input::~Input()
{
KillInput();
}

bool Input::Init()
{
HWND hWnd = GetForegroundWindow();

for(int i = 0; i < sizeof(keys); i++) {
keys[i] = 0;
last_keys[i] = 0;
}

lpdi = 0;
keyboard_device = 0;
mouse_device = 0;

HRESULT hr = DirectInput8Create(GetModuleHandle(0),
DIRECTINPUT_VERSION,
IID_IDirectInput8,
reinterpret_cast<LPVOID*>(&lpdi),
0);
if(FAILED(hr)) {
MessageBox(0, "DirectInput8Create() failed miserably.", "IT CAN'T BE, BUT IT IS!", MB_OK);
return false;
}
hr = lpdi->CreateDevice(GUID_SysKeyboard, &keyboard_device, 0);
if(FAILED(hr)) {
MessageBox(0, "createdevice", ".", MB_OK);
KillInput();
return false;
}
hr = keyboard_device->SetDataFormat(&c_dfDIKeyboard);
if(FAILED(hr)) {
MessageBox(0, "setdataformat", ".", MB_OK);
KillInput();
return false;
}
hr = keyboard_device->SetCooperativeLevel(hWnd, DISCL_FOREGROUND | DISCL_NONEXCLUSIVE);
if(FAILED(hr)) {
MessageBox(0, "set co-op level failed", ".", MB_OK);
KillInput();
return false;
}
if(keyboard_device) {
hr = keyboard_device->Acquire();
if(FAILED(hr)) {
MessageBox(0, "initial keyboard acquire", "!", MB_OK);
KillInput();
return false;
}
}

hr = lpdi->CreateDevice(GUID_SysMouse, &mouse_device, 0);
if(FAILED(hr)) {
KillInput();
return false;
}
hr = mouse_device->SetDataFormat(&c_dfDIMouse);
if(FAILED(hr)) {
KillInput();
return false;
}
hr = mouse_device->SetCooperativeLevel(hWnd, DISCL_FOREGROUND | DISCL_EXCLUSIVE);
if(FAILED(hr)) {
KillInput();
return false;
}

/*DIPROPDWORD dipdw;
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = DIPROPAXISMODE_ABS;
hr = mouse_device->SetProperty(DIPROP_AXISMODE, &dipdw.diph);
if(FAILED(hr)) {
KillInput();
return false;
}*/


if(mouse_device) {
if(FAILED(mouse_device->Acquire())) {
MessageBox(0, "initial mouse acquire", "!", MB_OK);
KillInput();
return false;
}
}
return true;
}

void Input::KillInput()
{
if(keyboard_device) keyboard_device->Unacquire();
if(keyboard_device) keyboard_device->Release();

if(mouse_device) mouse_device->Unacquire();
if(mouse_device) mouse_device->Release();
if(lpdi) lpdi->Release();
}

void Input::Update()
{
HRESULT hr = 0;
for(int i = 0; i < sizeof(keys); i++) {
last_keys[i] = keys[i];
}

hr = keyboard_device->GetDeviceState(sizeof(keys), static_cast<LPVOID>(&keys));
if(FAILED(hr))
{
if(FAILED(keyboard_device->Acquire())) {
MessageBox(0, "Keyboard died.", "F1 F1!", MB_OK);
PostQuitMessage(0);
return;
}
keyboard_device->GetDeviceState(256, static_cast<LPVOID>(&keys));
}

last_mouse = mouse_data;
hr = mouse_device->GetDeviceState(sizeof(mouse_data), static_cast<LPVOID>(&mouse_data));
if(FAILED(hr))
{
if(FAILED(mouse_device->Acquire())) {
MessageBox(0, "Mouse died.", "F1 F1!", MB_OK);
PostQuitMessage(0);
return;
}
mouse_device->GetDeviceState(sizeof(mouse_data), static_cast<LPVOID>(&mouse_data));
}
mouse_x += mouse_data.lX;
mouse_y += mouse_data.lY;
if(mouse_x > 800) mouse_x = 800;
if(mouse_x < 0) mouse_x = 0;
if(mouse_y > 600) mouse_y = 600;
if(mouse_y < 0) mouse_y = 0;
}






Window.h

#ifndef H_WINDOW
#define H_WINDOW

#define WIN32_LEAN_AND_MEAN

#include <windows.h>
#include <string>
#include "glheaders.h"

class OGLWindow
{
public:
OGLWindow();
OGLWindow(int, int, int, bool, WNDPROC);
~OGLWindow();

HWND GetHWND() const { return hWnd; }
HDC GetHDC() const { return hDC; }
int GetWidth() const { return current_width; }
int GetHeight() const { return current_height; }
int GetBits() const { return current_bits; }
bool GetFullscreen() const { return current_fullscreen; }

void SetWidth(int w) { width = w; }
void SetHeight(int h) { height = h; }
void SetBits(int b) { bits = b; }
void SetFullscreen(bool f) { fullscreen = f; }

bool BuildWindow();

private:
HDC hDC;
HGLRC hRC;
HWND hWnd;
WNDPROC WndPrc;

int width;
int height;
int bits;
bool fullscreen;

int current_width;
int current_height;
int current_bits;
bool current_fullscreen;

bool SetupOpenGL();
bool SetFS(bool&);
void KillWindow();
void InitGL();
};

#endif






Window.cpp
#include <memory>
#include "window.h"

OGLWindow::OGLWindow() : width(), height(), bits(), fullscreen(), WndPrc()
{
}

OGLWindow::OGLWindow(int w, int h, int b, bool f, WNDPROC wp) : width(w), height(h), bits(b), fullscreen(f), WndPrc(wp)
{
hDC = 0;
hRC = 0;
if(!BuildWindow()) {
MessageBox(0, "build window", "s", MB_OK);
}
}

OGLWindow::~OGLWindow()
{
KillWindow();
}

void OGLWindow::InitGL()
{
glViewport(0, 0, width, height);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClearDepth(1.0);
glDepthFunc(GL_LESS);
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);

glMatrixMode(GL_PROJECTION);
glLoadIdentity();

glOrtho(0.0f, (float)width, (float)height, 0.0f, -4.0f, 4.0f);

glMatrixMode(GL_MODELVIEW);
}

bool OGLWindow::SetFS(bool& fs)
{
DEVMODE dmScreenSettings;
std::uninitialized_fill_n(&dmScreenSettings, 1, DEVMODE());
dmScreenSettings.dmSize=sizeof(dmScreenSettings);
dmScreenSettings.dmPelsWidth = width;
dmScreenSettings.dmPelsHeight = height;
dmScreenSettings.dmBitsPerPel = bits;
dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;

if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL) {
if (MessageBox(NULL,"No fullscreen for this mode!","YOUR FAULT",MB_YESNO|MB_ICONEXCLAMATION)==IDYES) {
fs=false;
}
else {
return false;
}
}

return true;
}

bool OGLWindow::SetupOpenGL()
{
unsigned int PixelFormat;
static PIXELFORMATDESCRIPTOR pfd= // pfd Tells Windows How We Want Things To Be
{
sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor
1, // Version Number
PFD_DRAW_TO_WINDOW | // Format Must Support Window
PFD_SUPPORT_OPENGL | // Format Must Support OpenGL
PFD_DOUBLEBUFFER, // Must Support Double Buffering
PFD_TYPE_RGBA, // Request An RGBA Format
current_bits, // Select Our Color Depth
0, 0, 0, 0, 0, 0, // Color Bits Ignored
0, // No Alpha Buffer
0, // Shift Bit Ignored
0, // No Accumulation Buffer
0, 0, 0, 0, // Accumulation Bits Ignored
16, // 16Bit Z-Buffer (Depth Buffer)
0, // No Stencil Buffer
0, // No Auxiliary Buffer
PFD_MAIN_PLANE, // Main Drawing Layer
0, // Reserved
0, 0, 0 // Layer Masks Ignored
};

if (!(hDC=GetDC(hWnd))) {
KillWindow();
MessageBox(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return false;
}

if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd))) {
KillWindow();
MessageBox(NULL,"Can't Find A Suitable PixelFormat.","PIXELS ARE EVERYTHING",MB_OK|MB_ICONEXCLAMATION);
return false;
}

if(!SetPixelFormat(hDC,PixelFormat,&pfd)) {
KillWindow();
MessageBox(NULL,"Can't Set The PixelFormat.","OH LORDY",MB_OK|MB_ICONEXCLAMATION);
return false;
}

if (!(hRC=wglCreateContext(hDC))) {
KillWindow();
MessageBox(NULL,"Can't Create A GL Rendering Context.","UNGODLY ERROR",MB_OK|MB_ICONEXCLAMATION);
return false;
}

if(!wglMakeCurrent(hDC,hRC)) {
KillWindow();
MessageBox(NULL,"Can't Activate The GL Rendering Context.","HORRIBLE ERROR",MB_OK|MB_ICONEXCLAMATION);
return false;
}

InitGL();
return true;
}

bool OGLWindow::BuildWindow()
{
DWORD dwExStyle = 0;
DWORD dwStyle = 0;
WNDCLASSEX wndclassx;
RECT WndRect;
WndRect.left = static_cast<long>(0);
WndRect.right = static_cast<long>(width);
WndRect.top = static_cast<long>(0);
WndRect.bottom = static_cast<long>(height);

HINSTANCE hInstance = GetModuleHandle(0);

wndclassx.cbSize = sizeof(wndclassx);
wndclassx.style = CS_HREDRAW | CS_VREDRAW;
wndclassx.lpfnWndProc = WndPrc;
wndclassx.cbClsExtra = 0;
wndclassx.cbWndExtra = 0;
wndclassx.hInstance = hInstance;
wndclassx.hCursor = LoadCursor(0, IDC_ARROW);
wndclassx.hIcon = LoadIcon(0, IDI_WINLOGO);
wndclassx.hIconSm = LoadIcon(0, IDI_WINLOGO);
wndclassx.hbrBackground = 0;
wndclassx.lpszClassName = "^_^";
wndclassx.lpszMenuName = 0;

if(!RegisterClassEx(&wndclassx)) {
MessageBox(0, "RegisterClassEx() failed :-(", "HORRIBLE ERROR!", MB_OK);
return false;
}

if(fullscreen) {
if(!(SetFS(fullscreen))) {
return false;
}
}
if(fullscreen) { // still fullscreen?
dwExStyle = WS_EX_APPWINDOW;
dwStyle = WS_POPUP;
ShowCursor(true);
} else {
dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
dwStyle = WS_CAPTION | WS_SYSMENU;
}

AdjustWindowRectEx(&WndRect, dwStyle, 0, dwExStyle);

hWnd = CreateWindowEx(dwExStyle,
"^_^",
"^_^",
dwStyle | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
CW_USEDEFAULT,
CW_USEDEFAULT,
WndRect.right - WndRect.left,
WndRect.bottom - WndRect.top,
0,
0,
hInstance,
0);

if(!(SetupOpenGL())) {
return false;
}

current_width = width;
current_height = height;
current_bits = bits;
current_fullscreen = fullscreen;

return true;
}

void OGLWindow::KillWindow()
{
HINSTANCE hInstance = GetModuleHandle(0);

if(current_fullscreen) {
ChangeDisplaySettings(0,0);
ShowCursor(true);
}

if (hRC)
{
if (!wglMakeCurrent(0, 0)) {
MessageBox(NULL,"Release Of DC And RC Failed.", "AWFUL", MB_OK | MB_ICONINFORMATION);
}

if (!wglDeleteContext(hRC)) {
MessageBox(NULL,"Release Rendering Context Failed.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
}
hRC=0;
}

if (hDC && !ReleaseDC(hWnd, hDC)) {
MessageBox(NULL,"Release Device Context Failed.", "OH NO", MB_OK | MB_ICONINFORMATION);
hDC=0;
}

if (hWnd && !DestroyWindow(hWnd)) {
MessageBox(NULL,"Could Not Release hWnd.", "SOMETHING'S WRONG", MB_OK | MB_ICONINFORMATION);
hWnd=0;
}

if (!UnregisterClass("^_^", hInstance)) {
MessageBox(NULL,"Could Not Unregister Class.", "YOU BROKE MY PROGRAM", MB_OK | MB_ICONINFORMATION);
hInstance=0;
}
}






Main.cpp
#include <memory>
#include "window.h"

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
int active;
int done;

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE prevInstance, PSTR szCmdLine, int iCmdShow)
{
active = 0;
done = 0;
MSG msg;
std::auto_ptr<OGLWindow> wnd(new OGLWindow(800, 600, 32, 0, WndProc));

ShowWindow(wnd->GetHWND(), iCmdShow);
UpdateWindow(wnd->GetHWND());

while(!done)
{
SwapBuffers(wnd->GetHDC());

if(PeekMessage(&msg,0,0,0,PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}

return msg.wParam;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
switch(iMsg)
{
case WM_ACTIVATE:
if(LOWORD(wParam) == WA_INACTIVE)
active = 0;
else
active = 1;
return 0;
case WM_CLOSE:
done = 1;
PostQuitMessage(0);
return 0;
}
return DefWindowProc(hWnd, iMsg, wParam, lParam);
}






Point.h (the only math-base stuff I'll have)
#ifndef H_POINT
#define H_POINT

#include <limits>

template<typename T> class Point2d
{
public:
template<typename U> Point2d(U nx, U ny) : x_val(nx), y_val(ny) { }
template<typename U> Point2d(U nx) : x_val(nx), y_val() { }
template<typename U> void operator=(const Point2d<U>& rhs) { x_val = rhs.x(); y_val = rhs.y(); }
Point2d() : x_val(), y_val() { }
~Point2d() {}

template<typename U> void operator+=(const Point2d<U>& rhs) { x_val += rhs.x(); y_val += rhs.y(); }
template<typename U> void operator-=(const Point2d<U>& rhs) { x_val += rhs.x(); y_val += rhs.y(); }
template<typename U> void operator*=(const U& rhs) { x_val *= rhs; y_val *= rhs; }
template<typename U> void operator/=(const U& rhs) { x_val /= rhs; y_val /= rhs; }

friend const bool operator==(const Point2d& lhs, const Point2d& rhs);
friend const bool operator!=(const Point2d& lhs, const Point2d& rhs);
friend const Point2d operator*(const Point2d& lhs, const T& rhs);
friend const Point2d operator/(const Point2d& lhs, const T& rhs);
friend const Point2d operator*(const T& lhs, const Point2d& rhs);
friend const Point2d operator/(const T& lhs, const Point2d& rhs);
friend const Point2d operator+(const Point2d& lhs, const Point2d& rhs);
friend const Point2d operator-(const Point2d& lhs, const Point2d& rhs);

T x() { return x_val; }
T y() { return y_val; }
void reset() { x_val -= x_val; y_val -= y_val; }
void set(T& nx, T& ny) { x_val = nx; y_val = ny; }
void set_x(T& nx) { x_val = nx; }
void set_y(T& ny) { y_val = ny; }
private:
T x_val;
T y_val;
};

template<typename T> const bool operator==(const Point2d<T>& lhs, const Point2d<T>& rhs)
{
return ((rhs.x() - lhs.x()) <= std::numeric_limits<T>::epsilon()) &&
((rhs.y() - lhs.y()) <= std::numeric_limits<T>::epsilon());
}

template<typename T> const bool operator!=(const Point2d<T>& lhs, const Point2d<T>& rhs)
{
return (!(lhs == rhs));
}

template<typename T> const Point2d<T> operator*(const Point2d<T>& lhs, const T& rhs)
{
return Point2d<T>(lhs.x() * rhs, lhs.y() * T);
}

template<typename T> const Point2d<T> operator/(const Point2d<T>& lhs, const T& rhs)
{
return Point2d<T>(lhs.x() / rhs, lhs.y() / rhs);
}

template<typename T> const Point2d<T> operator*(const T& lhs, const Point2d<T>& rhs)
{ return rhs*lhs; }

template<typename T> const Point2d<T> operator/(const T& lhs, const Point2d<T>& rhs)
{ return rhs/lhs; }


template<typename T> const Point2d<T> operator+(const Point2d<T>& lhs, const Point2d<T>& rhs)
{
return Point2d<T>(lhs.x() + rhs.x(), lhs.y() + rhs.y());
}

template<typename T> const Point2d<T> operator-(const Point2d<T>& lhs, const Point2d<T>& rhs)
{
return Point2d<T>(lhs.x() - rhs.x(), lhs.y() - rhs.y());
}

#endif






glheaders.h
#ifndef H_GLHEADERS
#define H_GLHEADERS

#include <windows.h>
#include <gl.h>
#include <glu.h>

#endif


Share this post


Link to post
Share on other sites
Here's my basecode (which may or may not have errors :[ ). I wasn't sure if font or texture code would be allowed yet so I didn't write any. I'm assuming d3d9.h, windows.h, and tchar.h are included.

Gamedev is being whiney about the source so I'll try splitting it over two posts.


Edit: The rest is in the next post. Don't know why I couldn't put it in one :[.


header file:


class DirectXBase
{
public:

DirectXBase(HINSTANCE);
~DirectXBase();

// creation and deletion
BOOL Init(BOOL windowed, int BPP, int Width, int Height);
void Shutdown(void);

INT Run();

// Accessors
LPDIRECT3DDEVICE9 GetDevice(){return m_pd3dDevice;}

// generic window handler
static LRESULT CALLBACK DispatchWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
if (message == WM_NCCREATE)
{
CREATESTRUCT* cs = (CREATESTRUCT*)lParam;
SetWindowLongPtr(hWnd, GWLP_USERDATA, (LONG_PTR)cs->lpCreateParams);

return TRUE;
}
else
{
DirectXBase *app = (DirectXBase*)GetWindowLongPtr(hWnd, GWLP_USERDATA);

if (app!=NULL)
return app->WndProc(hWnd, message, wParam, lParam);
else
return DefWindowProc(hWnd, message, wParam, lParam);
}
}

// class window handler
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

private:
BOOL bWindowed; // window mode
int iBpp; // color depth
int iWidth; // window width
int iHeight; // window height

HWND hWnd; // device window
HINSTANCE hInst;// application instance

// Direct3D objects
LPDIRECT3D9 m_pD3D;
LPDIRECT3DDEVICE9 m_pd3dDevice;

// intialization flag
BOOL bInit;

// windowing functions
ATOM RegisterClass(HINSTANCE);
BOOL InitInstance();

// happy text
char szWindowClass[32];
char szTitle[32];
};





[Edited by - DukeAtreides076 on July 22, 2005 8:26:06 PM]

Share this post


Link to post
Share on other sites
Heres the rest(source file):


#include "StdAfx.h"
#include ".\directxbase.h"

DirectXBase::DirectXBase(HINSTANCE hInstance)
{
bInit = FALSE;

// Set pointers to NULL in case something goes wrong
m_pd3dDevice = NULL;
m_pD3D = NULL;

hWnd = NULL;
hInst = hInstance;

strcpy(szWindowClass,"dxsample");
strcpy(szTitle,"3Hour Compo");
}

DirectXBase::~DirectXBase(void)
{
}

BOOL DirectXBase::Init(BOOL windowed, int BPP, int Width, int Height)
{
// Return Value: TRUE if succeeded, else FALSE

bWindowed = windowed;
iBpp = BPP;
iWidth = Width;
iHeight = Height;

// set up the window
RegisterClass(hInst);

// Perform application initialization:
if (!InitInstance ())
{
bInit = FALSE;
return FALSE;
}

// start up Direct3d
if( NULL == ( m_pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
return FALSE;

// fill up the present parameters
D3DPRESENT_PARAMETERS d3dpp;

ZeroMemory( &d3dpp, sizeof(d3dpp) );
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.Windowed = bWindowed;
d3dpp.hDeviceWindow = hWnd;

// stencil depth and things
// Uncomment for depth stencil
d3dpp.EnableAutoDepthStencil = FALSE;
//d3dpp.EnableAutoDepthStencil = TRUE;
//d3dpp.AutoDepthStencilFormat = D3DFMT_D24X8;


// Dont wait for the vertical retrace
d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;

// check if its running windowed or fullscreen
if (bWindowed)
{
// we dont need to do much here
d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
d3dpp.Windowed = TRUE;
}
else
{
// initial setup
d3dpp.Windowed = FALSE;

// get the color depth
if (iBpp == 32 || iBpp == 24)
d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;
else if (iBpp == 16)
d3dpp.BackBufferFormat = D3DFMT_R5G6B5;
else return FALSE;

// set the requested size
d3dpp.BackBufferHeight = iHeight;
d3dpp.BackBufferWidth = iWidth;

// now we need to check if the display mode is supported
D3DDISPLAYMODE d3ddm;
BOOL bSupported=FALSE;

// loop through the available adapter modes
UINT count=m_pD3D->GetAdapterModeCount(D3DADAPTER_DEFAULT, d3dpp.BackBufferFormat);

for(UINT i=0; i<count; i++)
{
if( FAILED(m_pD3D->EnumAdapterModes(D3DADAPTER_DEFAULT,
d3dpp.BackBufferFormat,
i, &d3ddm)))
return FALSE;

// check and see if it matches our settings
if (d3ddm.Height == d3dpp.BackBufferHeight &&
d3ddm.Width == d3dpp.BackBufferWidth)
{
bSupported = TRUE; // its a match, break out of the loop
break;
}
}

// Check for hardware support
if(FAILED( m_pD3D->CheckDeviceType(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
d3dpp.BackBufferFormat,
d3dpp.BackBufferFormat,
d3dpp.Windowed)))

return FALSE;

if(!bSupported) // we didnt find the right mode, call fails
return FALSE;
}



// Create the device
if( FAILED( m_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&d3dpp, &m_pd3dDevice ) ) )
return FALSE;

bInit = TRUE;
return bInit;
}

void DirectXBase::Shutdown()
{
// release devices kthx~
if( m_pd3dDevice != NULL) // safe release everything
m_pd3dDevice->Release();
if( m_pD3D != NULL)
m_pD3D->Release();
}


BOOL DirectXBase::Run()
{
// check if we have been initialized
if (!bInit)
return FALSE;

MSG msg;

// Run the message pump
while (TRUE)
{
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
if (msg.message == WM_QUIT)
break;

//if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
//{
TranslateMessage(&msg);
DispatchMessage(&msg);
//}
}

// DO STUFF HERE
/////////////////////////////////////////////////////

// Clear
m_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,0,255), 1.0f, 0 );
// Begin the scene
m_pd3dDevice->BeginScene();

// DRAW TEH STUFF~~
/////////////////////////////////////////////////////

// End the scene
m_pd3dDevice->EndScene();

// oMFG PRESENTS
m_pd3dDevice->Present( NULL, NULL, NULL, NULL );
}

return (int) msg.wParam;
}

// PURPOSE: Registers the window class.
ATOM DirectXBase::RegisterClass(HINSTANCE hInstance)
{
WNDCLASSEX wcex;

wcex.cbSize = sizeof(WNDCLASSEX);

wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = (WNDPROC)DispatchWndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = LoadIcon(hInstance, IDI_APPLICATION);
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wcex.lpszMenuName = NULL;
wcex.lpszClassName = szWindowClass;
wcex.hIconSm = LoadIcon(wcex.hInstance, IDI_APPLICATION);

return RegisterClassEx(&wcex);
}

BOOL DirectXBase::InitInstance()
{
hWnd = CreateWindow(szWindowClass, szTitle, WS_POPUP|WS_CAPTION|WS_MINIMIZEBOX|WS_SYSMENU,
0, 0, iWidth, iHeight, NULL, NULL, hInst, this);

if (!hWnd)
{
return FALSE;
}

ShowWindow(hWnd, SW_SHOW);
UpdateWindow(hWnd);

RECT r = {0,0,iWidth,iHeight};

AdjustWindowRect(&r, WS_POPUP|WS_CAPTION|WS_MINIMIZEBOX , FALSE);

SetWindowPos(hWnd, NULL, 0, 0, r.right, r.bottom, SWP_NOOWNERZORDER);

// No clue why I need this here, but it works
SetWindowText(hWnd, szTitle);

return TRUE;
}

LRESULT CALLBACK DirectXBase::WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
PAINTSTRUCT ps;
HDC hdc;

switch (message)
{
case WM_KEYDOWN:
// OMFG SOMEBUODY PUSHED A BUTTON?~!!?

// QUIT
if (wParam == VK_ESCAPE)
PostQuitMessage(0);
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
EndPaint(hWnd, &ps);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}


Share this post


Link to post
Share on other sites
please explain rule 12 for me, i still dont get it after i've asked what others on irc think. What happens when someone wins, chooses a price other than GDNet+ (we can choose if we win in a category with the 'or' word in it?) and isnt already a GDNet+ member?

oh and please update the prices before the contest starts


T2k

Share this post


Link to post
Share on other sites
Quote:
Original post by T2k
please explain rule 12 for me, i still dont get it after i've asked what others on irc think. What happens when someone wins, chooses a price other than GDNet+ (we can choose if we win in a category with the 'or' word in it?) and isnt already a GDNet+ member?

oh and please update the prices before the contest starts


T2k

It means that, if you take the GDNet+, then you might post the game on the showcase.

Share this post


Link to post
Share on other sites
As per rule 3... I still haven't seen any discussion on the theme or similar. I'd be interested to have this finalised at least an hour or two before the contest starts so there is time to figure out what we might do, so we can spend the 3 hours producing code & art rather than attempting to come up with an idea that fits the theme.

-Mezz

Share this post


Link to post
Share on other sites
Quote:
Original post by Mezz
As per rule 3... I still haven't seen any discussion on the theme or similar. I'd be interested to have this finalised at least an hour or two before the contest starts so there is time to figure out what we might do, so we can spend the 3 hours producing code & art rather than attempting to come up with an idea that fits the theme.

-Mezz


as per Michael Tanczos' suggestion
Quote:
Original post by Michael Tanczos
A thought.. perhaps announce a simple theme to void out those who have pre-existing projects but basically anything goes otherwise.

I have a simple theme in mind, I will announce it Sunday morning.

Share this post


Link to post
Share on other sites
Quote:
Original post by DerAnged
Eastern time by GDNet's clock? For me it reads 10:31:42 which is the same as my time(central), is there something I'm missing here?

It starts at 1PM central time, unless I'm missing something.

Share this post


Link to post
Share on other sites
The time on forum posts reads what it is where it thinks you are located, I'm guessing, since mine is reading ~5pm and that's the time here.

-Mezz

Share this post


Link to post
Share on other sites
Quote:
Original post by DerAnged
I know(btw eastern = GMT-5, cental = -6), but why does the server time for me read central time not eastern, but he said eastern time by the gdnet server clocks.

So it starts at two for us then? Heh, good to know

Share this post


Link to post
Share on other sites
Quote:
Original post by Samith
Quote:
Original post by DerAnged
I know(btw eastern = GMT-5, cental = -6), but why does the server time for me read central time not eastern, but he said eastern time by the gdnet server clocks.

So it starts at noon for us then? Heh, good to know


Where are you located?

It starts at 2 here.

Also, SDL is acceptable, what about sdl_ttf(true type fonts) and sdl_image(other image types besides bmp)?

Share this post


Link to post
Share on other sites
Quote:
Original post by DerAnged
Where are you located?

It starts at 2 here.

Also, SDL is acceptable, what about sdl_ttf(true type fonts) and sdl_image(other image types besides bmp)?

I know, I messed up my math :p (3-1 = ZERO!)

And if sdl_ttf is allowed, can I use my font class? I know that capn said only an input manager, rendering frame, and sound manager were allowed...but...font classes don't really affect gameplay. I'll post the code so other people can use it too (assuming it's allowed).

"Color" is just a struct with four floats, r, g, b, and a. It's the only thing defined in "util_classes.h"

font.h
#ifndef H_FONT
#define H_FONT

#include <string>
#include <sstream>
#include "glheaders.h"
#include "util_classes.h"

class Font
{
public:
Font();
~Font();

void BuildFont(const char* face, int size, int wgt);
void Newline();
float getLength(std::string str);
float getSize() { return size; }

void setPosition(const float x, const float y) { xScreen = x; yScreen = y; xMod=0.0f; }
void setColor(float r, float g, float b, float a) { color.r=r; color.g=g; color.b=b; color.a=a; }
void setColor(const Color& c) { color = c; }
void setFontFace(const char* face);
void setFontSize(float newSize);
void DeleteFont();

template<typename T> Font& operator<<(const T& t) {
oss << t;
s = oss.str();

glDisable(GL_DEPTH_TEST);

glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(0, 800, 600, 0, -1, 1);

glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();

glBindTexture(GL_TEXTURE_2D, 0);
glColor4f(color.r, color.g, color.b, color.a);

glRasterPos2f(xScreen+xMod, yScreen);

glPushAttrib(GL_LIST_BIT);
glListBase(base);
glCallLists(s.length(), GL_UNSIGNED_BYTE, s.c_str());
glPopAttrib();

glColor4f(1.0f, 1.0f, 1.0f, 1.0f);

glMatrixMode(GL_PROJECTION);
glPopMatrix();

glMatrixMode(GL_MODELVIEW);
glPopMatrix();

glEnable(GL_DEPTH_TEST);

for(unsigned int i = 0; i < s.length(); i++) {
xMod += abcf[s[i]].abcfA;
xMod += abcf[s[i]].abcfB;
xMod += abcf[s[i]].abcfC;
}

s.clear();
oss.str("");
return *this;
}

private:
std::ostringstream oss;
std::string s;
std::string fontname;
float size;
int weight;
unsigned int base; // base for displaylist
float xScreen, yScreen;
Color color;
float xMod; // so you know how much to add to the xScreen so you don't constantly draw

ABCFLOAT abcf[256];
};

#endif



font.cpp
#include "font.h"

Font::Font() : fontname(""), base(0),
xScreen(0.0f), yScreen(0.0f),
color(), xMod(0.0f)
{
}

Font::~Font()
{
DeleteFont();
}

void Font::BuildFont(const char* face, int size1, int wgt)
{
fontname = face;
size = size1;
weight = wgt;
HFONT font;
HDC hDC;
base = glGenLists(256);

hDC = wglGetCurrentDC();

font = CreateFont(-size*1.4f,
0,
0,
0,
weight,
false,
false,
false,
ANSI_CHARSET,
OUT_TT_PRECIS,
CLIP_DEFAULT_PRECIS,
ANTIALIASED_QUALITY,
FF_DONTCARE|DEFAULT_PITCH,
fontname.c_str());

SelectObject(hDC, font);

wglUseFontBitmaps(hDC, 0, 256, base);

if(GetCharABCWidthsFloat(hDC, 0, 255, abcf) == 0)
{
MessageBox(0, "GetCharABCWidthsFloat() failed like no other.", "omg", MB_OK);
}
}

float Font::getLength(std::string str)
{
float length = 0.0f;
for(unsigned int i = 0; i < str.length(); i++)
{
length += abcf[str[i]].abcfA;
length += abcf[str[i]].abcfB;
length += abcf[str[i]].abcfC;
}
return length;
}

void Font::Newline()
{
yScreen += size;
xMod = 0.0f;
}

void Font::setFontSize(float newSize)
{
DeleteFont();

BuildFont(fontname.c_str(), newSize, weight);
}

void Font::setFontFace(const char *face)
{
DeleteFont();

BuildFont(face, size, weight);
}

void Font::DeleteFont()
{
glDeleteLists(base, 256);
}



usage

Font* font = new Font();
font->BuildFont("Courier New", 16, 700); // font name, size, and boldness (1000 is most, 0 is none)

font->setColor(1.0f, 1.0f, 1.0f, 1.0f);
font->setPosition(x, y) // must call this every time before hand, it resets the position
*font << "Hello " << 1.6f;

OUTPUT:
Hello 1.6


Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

Sign in to follow this