See what's going on with flipcode!




This section of the archives stores flipcode's complete Developer Toolbox collection, featuring a variety of mini-articles and source code contributions from our readers.

 

  In-Game Command Console
  Submitted by



Here is my submission for code of the day. It's a class for an in-game command console that I've developed for my current DirectX 3D engine project. You can see the console in action ( along with the rest of the engine ) at http://tatooine.fortunecity.com/falcon/183/stoom2.htm ( shameless plug !!! )

To use call Initialize() once and then call Render() every frame. Call OnChar() when WM_CHAR is received and OnKeyUp() when WM_KEYUP is received.

I must apologise for it not being very portable code. You _WILL_ have to make changes to implement it in your own application. Firstly, it makes use of the D3DFrame library via a global variable g_pFramework which needs to be initialised beforehand. Secondly, it makes use of the MFC classes CSize, CString & CstringList. You may wish/need to a) Replace the framework library functions with your own methods, b) replace CString/CStringList with char * c) replace the entire Render() function to better suit your own needs /application. d) you will need a .bmp containing the background image and a .bmp containing the font - Chars in ascii order of size FONT_WIDTH x FONT_HEIGHT.

You can use this code wherever and for whatever you like, I hope someone finds it useful.

Steve.

Currently browsing [console.zip] (5,010 bytes) - [Console.h] - (1,873 bytes)

#if !defined(AFX_CONSOLE_H__B0C8B741_A776_11D3_A33F_8CED61F5D517__INCLUDED_)
#define AFX_CONSOLE_H__B0C8B741_A776_11D3_A33F_8CED61F5D517__INCLUDED_

#if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 // Console.h : header file // #define STATIC 1 #define UP 2 #define DOWN 4 #define FONT_HEIGHT 16 #define FONT_WIDTH 16 #define DISPLAY_FONT_HEIGHT 8 #define DISPLAY_FONT_WIDTH 8 #define UMAX 16 #define VMAX 32 #define COMP 0.000001 #define FLASH_SPEED 500 #define MAX_SIZE 64 #define XOFF 10 #define YOFF 5

struct console { char *command; // Command char *help; // Optional help test void (*handler)(char *string); // Function hadler };

/* Console prototypes */ void ConsoleCullbackfaces(char * command = NULL); void ConsoleGamma(char* command = NULL);

///////////////////////////////////////////////////////////////////////////// // CConsole window class CConsole : public CWnd { public: CConsole(); virtual ~CConsole(); void OnChar(char key); void OnKeyUp(int key); void FormatLine(char *text,...); void DisplayLine(char *text); void Restore(); void Render(); void Initialize(); void ProccessCommand(); void ProccessTab(); void Close();

bool m_initialised; D3DTLVERTEX m_v[4]; LPDIRECT3DTEXTURE2 m_font, m_background; char *m_BackgroundName, *m_FontName; int m_nLines; CStringList m_text, m_CommandHistory; CString m_InputBuffer; CRect m_size; float m_yOffset; DWORD m_mode; bool m_bCursor; int m_FlashCounter; POSITION m_HistoryPos; int m_CursorPos; int m_TabCount; CString m_PrevInput; CSize m_FontSz;

// Generated message map functions protected: };

#endif // !defined(AFX_CONSOLE_H__B0C8B741_A776_11D3_A33F_8CED61F5D517__INCLUDED_)

Currently browsing [console.zip] (5,010 bytes) - [Console.cpp] - (14,924 bytes)

// Console.cpp : implementation file
//

#include "Console.h"

#ifdef _DEBUG #define new DEBUG_NEW #undef THIS_FILE static char THIS_FILE[] = __FILE__; #endif

/* List of commands the console supports. */ /* Commands are of the form : <Command text><Help text (optional)><handler function> */ struct console CommandList[] = { {"CullBackFaces","...[0/1]", ConsoleCullBackFaces}, {"Gamma","...........[0..100]", ConsoleGamma}, {NULL,NULL,NULL} };

//----------------------------------------------------------------------------- // Function handler for the gamma command void ConsoleGamma(char *command) { if ( command == NULL ) { /* Just display the current value on the console */ theApp.m_console.FormatLine("gamma=%d",theApp.m_GammaVal); return; }

/* Set the new gamma value */ theApp.m_GammaVal = atol(command); theApp.SetGammaCorrection((float)theApp.m_GammaVal / 100.0f ); }

//----------------------------------------------------------------------------- void ConsoleCullBackFaces(char * command) { if ( command != NULL ) { switch ( command[0] ) { case '0': theApp.m_dwFlags &= ~CULL_BACK_FACES; theApp.SetOptions(); return;

case '1': theApp.m_dwFlags |= CULL_BACK_FACES; theApp.SetOptions(); return; } }

/* Toggle */ theApp.m_dwFlags ^= CULL_BACK_FACES; theApp.SetOptions(); }

///////////////////////////////////////////////////////////////////////////// // CConsole CConsole::CConsole() { m_initialised = false; m_FontName = "font4.bmp"; m_BackgroundName = "console2.bmp"; m_mode = DOWN; m_HistoryPos = NULL; m_TabCount = 0; }

CConsole::~CConsole() { m_initialised = false; D3DTextr_DestroyTexture(m_FontName); D3DTextr_DestroyTexture(m_BackgroundName); }

//----------------------------------------------------------------------- // Initialize the console. Call before use or after the render device has changed //----------------------------------------------------------------------- void CConsole::Initialize() { DDSURFACEDESC2 ddsd; HDC hdc;

if ( !g_pFramework || !g_pFramework->GetD3DDevice() || !g_pFramework->GetDirect3D()) return; // Just in case... m_FontSz.cy = DISPLAY_FONT_HEIGHT; m_FontSz.cx = DISPLAY_FONT_WIDTH;

/* Calculate the size of the cosoole ( when fully visible ) */ ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT; g_pFramework->GetBackBuffer()->GetSurfaceDesc(&ddsd); m_size.SetRect(0,0,ddsd.dwWidth,ddsd.dwHeight / 2);

/* The vertices of the quad that will be uses for the background */ m_v[0] = D3DTLVERTEX(D3DVECTOR(0,0,1),1,D3DRGB(1,1,1),D3DRGB(1,1,1),0,0); m_v[1] = D3DTLVERTEX(D3DVECTOR(0,0,0),1,D3DRGB(1,1,1),D3DRGB(1,1,1),0,1); m_v[2] = D3DTLVERTEX(D3DVECTOR((float)ddsd.dwWidth,0,0),1,D3DRGB(1,1,1),D3DRGB(1,1,1),1,1); m_v[3] = D3DTLVERTEX(D3DVECTOR((float)ddsd.dwWidth,0,1),1,D3DRGB(1,1,1),D3DRGB(1,1,1),1,0); m_v[0].color = m_v[1].color= m_v[2].color = m_v[3].color = D3DRGBA(1,1,1,0.8);

/* Load the font "texture" to an off-screen surface*/ D3DTextr_CreateTexture( m_FontName , 0, 0 ); D3DTextr_Restore(m_FontName,g_pFramework->GetD3DDevice()); m_font = D3DTextr_GetTexture(m_FontName); DDSetColorKey(D3DTextr_GetSurface(m_FontName),RGB(0,0,0));

/* Load the background image to an off-screen surface */ D3DTextr_CreateTexture( m_BackgroundName , 0, 0 ); D3DTextr_Restore( m_BackgroundName,g_pFramework->GetD3DDevice()); m_background = D3DTextr_GetTexture( m_BackgroundName);

/* Number of visible lines */ m_nLines = (int)(((float)((ddsd.dwHeight) / 2.0) - YOFF - YOFF ) / m_FontSz.cy ) - 1; /* Create a blank empty text buffer */ for ( int i = m_text.GetCount(); i < m_nLines; i++ ) m_text.AddHead("");

/* Initialize some other member variables */ m_bCursor = true; m_FlashCounter = 0; m_yOffset = 0; m_mode = DOWN; m_CursorPos = 0;

m_initialised = true; }

//----------------------------------------------------------------------- // Render the console. Call this every frame. //----------------------------------------------------------------------- void CConsole::Render() { POSITION pos; int top; CString str; char *p; int x, y, c, len; D3DTLVERTEX v[4]; ULONG lOldZFunc, loldColor, loldAlpha, loldSrc, loldDest; float uoffset, voffset, usize = (1 / ( 256.0 / FONT_WIDTH)), vsize = (1 / ( 256.0 / FONT_HEIGHT)); bool done = false; static DWORD LastTime = timeGetTime(); DWORD ThisTime = timeGetTime(); DWORD elapsed = ThisTime - LastTime; HDC hdc = NULL; CDC dc; CFont *old;

if ( !m_initialised ) return;

/* 'Animation' stuff */

m_FlashCounter += elapsed; if ( m_FlashCounter > FLASH_SPEED ) { m_FlashCounter = 0; m_bCursor = m_bCursor ? false : true; }

if ( m_yOffset == 0 ) elapsed = 1;

LastTime = ThisTime; switch ( m_mode ) { case DOWN: // The console is scrolling down m_yOffset += (float)elapsed / 2.0; if ( m_yOffset > m_size.bottom ) { m_yOffset = m_size.bottom; m_mode = STATIC; }

/* fade in the console as is scrolls down */ alpha = m_yOffset / m_size.bottom; if ( alpha < 0.8f ) m_v[0].color = m_v[1].color= m_v[2].color = m_v[3].color = D3DRGBA(1,1,1,alpha);

break;

case UP: // The console is scrolling up m_yOffset -= elapsed; if ( m_yOffset < 0 ) { m_yOffset = 0; m_mode = DOWN; }

/* fade out the console as is scrolls up */ alpha = m_yOffset / m_size.bottom; if ( alpha >= 0 ) m_v[0].color = m_v[1].color= m_v[2].color = m_v[3].color = D3DRGBA(1,1,1,alpha); break;

case STATIC: // The console is fully visible break; }

/* Setup some render states */ LPDIRECT3DDEVICE3 pDevice = g_pFramework->GetD3DDevice();

pDevice->GetRenderState( D3DRENDERSTATE_ZFUNC, &lOldZFunc ); pDevice->SetRenderState( D3DRENDERSTATE_ZFUNC, D3DCMP_ALWAYS );

pDevice->GetTextureStageState( 1, D3DTSS_COLOROP,&loldColor ); pDevice->SetTextureStageState( 1, D3DTSS_COLOROP,D3DTOP_DISABLE );

pDevice->GetTextureStageState( 1, D3DTSS_ALPHAOP,&loldAlpha ); pDevice->SetTextureStageState( 1, D3DTSS_ALPHAOP,D3DTOP_DISABLE );

pDevice->GetRenderState( D3DRENDERSTATE_SRCBLEND,&loldSrc); pDevice->SetRenderState( D3DRENDERSTATE_SRCBLEND,D3DBLEND_SRCALPHA);

pDevice->GetRenderState( D3DRENDERSTATE_DESTBLEND,&loldDest ); pDevice->SetRenderState( D3DRENDERSTATE_DESTBLEND,D3DBLEND_INVSRCALPHA );

pDevice->SetTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 0 ); pDevice->SetTexture(0, m_background);

/* Draw the background (Transparent quad) */ m_v[0].sy = m_yOffset - m_size.bottom; m_v[1].sy = m_yOffset; m_v[2].sy = m_yOffset; m_v[3].sy = m_yOffset - m_size.bottom;

pDevice->DrawPrimitive(D3DPT_TRIANGLEFAN,D3DFVF_TLVERTEX ,(LPVOID)m_v,4,NULL);

/* Draw the text. This should be done using a vertex buffer & DrawIndexedPrimitiveVB()!!! */ pDevice->SetTexture(0, m_font); top = m_text.GetCount() - m_nLines; pos = m_text.FindIndex(top); x = XOFF; y = (m_yOffset - m_size.bottom) + YOFF;

while ( !done ) { if ( pos == NULL ) { str = m_InputBuffer; done = true; } else str = m_text.GetNext(pos);

len = str.GetLength();

p = str.GetBuffer(0);

for ( c = 0, x = XOFF; c < len; c++, x += DISPLAY_FONT_WIDTH,p++ ) { uoffset = (*p % UMAX ) * usize; voffset = (*p / UMAX ) * vsize;

v[0] = D3DTLVERTEX(D3DVECTOR(x,y,1),1,D3DRGB(1,1,1),D3DRGB(1,1,1),uoffset + COMP,voffset + COMP); v[1] = D3DTLVERTEX(D3DVECTOR(x,y + DISPLAY_FONT_HEIGHT ,0),1,D3DRGB(1,1,1),D3DRGB(1,1,1),uoffset + COMP,voffset + vsize - COMP - COMP); v[2] = D3DTLVERTEX(D3DVECTOR(x + DISPLAY_FONT_WIDTH,y + DISPLAY_FONT_HEIGHT,0),1,D3DRGB(1,1,1),D3DRGB(1,1,1),uoffset + usize - COMP - COMP ,voffset + vsize - COMP - COMP); v[3] = D3DTLVERTEX(D3DVECTOR(x + DISPLAY_FONT_WIDTH,y,1),1,D3DRGB(1,1,1),D3DRGB(1,1,1),uoffset + usize - COMP - COMP,voffset + COMP);

pDevice->DrawPrimitive(D3DPT_TRIANGLEFAN,D3DFVF_TLVERTEX ,(LPVOID)v,4,NULL); }

y += m_FontSz.cy; }

/* Draw the cursor */ if ( m_bCursor ) { y -= m_FontSz.cy; x = (m_FontSz.cx * m_CursorPos) + XOFF;

uoffset = ('I' % UMAX ) * usize; voffset = ('I' / UMAX ) * vsize;

v[0] = D3DTLVERTEX(D3DVECTOR(x,y,1),1,D3DRGB(1,1,1),D3DRGB(1,1,1),uoffset + COMP,voffset + COMP); v[1] = D3DTLVERTEX(D3DVECTOR(x,y + DISPLAY_FONT_HEIGHT ,0),1,D3DRGB(1,1,1),D3DRGB(1,1,1),uoffset + COMP,voffset + vsize - COMP - COMP); v[2] = D3DTLVERTEX(D3DVECTOR(x + DISPLAY_FONT_WIDTH,y + DISPLAY_FONT_HEIGHT,0),1,D3DRGB(1,1,1),D3DRGB(1,1,1),uoffset + usize - COMP - COMP ,voffset + vsize - COMP - COMP); v[3] = D3DTLVERTEX(D3DVECTOR(x + DISPLAY_FONT_WIDTH,y,1),1,D3DRGB(1,1,1),D3DRGB(1,1,1),uoffset + usize - COMP - COMP,voffset + COMP);

pDevice->DrawPrimitive(D3DPT_TRIANGLEFAN,D3DFVF_TLVERTEX ,(LPVOID)v,4,NULL); }

/* restore the device render states */ pDevice->SetRenderState( D3DRENDERSTATE_SRCBLEND,loldSrc); pDevice->SetRenderState( D3DRENDERSTATE_DESTBLEND,loldDest); pDevice->SetTextureStageState( 1, D3DTSS_COLOROP,loldColor); pDevice->SetTextureStageState( 1, D3DTSS_ALPHAOP,loldAlpha); pDevice->SetRenderState( D3DRENDERSTATE_ZFUNC,lOldZFunc);

}

//----------------------------------------------------------------------- // Call this when the device nees to be restored void CConsole::Restore() { D3DTextr_Restore(m_FontName,g_pFramework->GetD3DDevice()); m_font = D3DTextr_GetTexture(m_FontName); DDSetColorKey(D3DTextr_GetSurface(m_FontName),RGB(0,0,0));

D3DTextr_Restore( m_BackgroundName,g_pFramework->GetD3DDevice()); m_background = D3DTextr_GetTexture( m_BackgroundName); }

//----------------------------------------------------------------------- // Function to add a line to the console. Use in the same way as printf // eg "console.FormatLine("Loaded texture %s",texturename)"; void CConsole::FormatLine(char *format, ...) { va_list arg; char buffer[256];

va_start(arg, format); vsprintf(buffer, format, arg); va_end(arg);

DisplayLine(buffer);

}

//----------------------------------------------------------------------- // Function to display a line of text void CConsole::DisplayLine(char *text) { m_text.AddTail(text);

if ( m_text.GetCount() > MAX_SIZE ) m_text.RemoveHead(); }

//----------------------------------------------------------------------- // Function to handle a key press void CConsole::OnChar(char character) { if ( character != VK_TAB) m_TabCount = 0;

switch ( character ) { case '`': case '~': if ( m_mode == STATIC ) { m_InputBuffer.Empty(); m_CursorPos = 0; m_mode = UP; } break;

case VK_ESCAPE: if ( m_InputBuffer.IsEmpty() ) m_mode = UP; else { m_InputBuffer.Empty(); m_CursorPos = 0; }

break;

case VK_BACK: if ( !m_InputBuffer.IsEmpty()) { m_InputBuffer.Delete(m_CursorPos - 1); m_CursorPos--; } break;

case VK_RETURN: ProccessCommand();

break;

case VK_TAB: ProccessTab(); break;

default: if ( m_CursorPos < m_InputBuffer.GetLength() ) { m_InputBuffer.Insert(m_CursorPos,character); } else m_InputBuffer += character;

m_CursorPos++;

} }

//----------------------------------------------------------------------- // Function to handle a key press void CConsole::OnKeyUp(int key) { POSITION pos = NULL;

if ( key != VK_TAB ) m_TabCount = 0;

switch ( key ) { case VK_UP: if ( m_HistoryPos == NULL ) m_HistoryPos = m_CommandHistory.GetHeadPosition(); else m_CommandHistory.GetNext(m_HistoryPos);

if ( m_HistoryPos ) m_InputBuffer = m_CommandHistory.GetAt(m_HistoryPos); else m_HistoryPos = m_CommandHistory.GetTailPosition();

m_CursorPos = m_InputBuffer.GetLength(); break;

case VK_DOWN: if ( m_HistoryPos ) { m_CommandHistory.GetPrev(m_HistoryPos);

if ( m_HistoryPos == NULL ) m_HistoryPos = m_CommandHistory.GetHeadPosition();

m_InputBuffer = m_CommandHistory.GetAt(m_HistoryPos); }

m_CursorPos = m_InputBuffer.GetLength();

break;

case VK_LEFT: if ( m_CursorPos > 0 ) m_CursorPos--; break;

case VK_RIGHT: if ( m_CursorPos < m_InputBuffer.GetLength() ) m_CursorPos++; break;

case VK_DELETE: if ( m_CursorPos < m_InputBuffer.GetLength() ) { m_InputBuffer.Delete(m_CursorPos,1); } break;

case VK_HOME: m_CursorPos = 0; break;

case VK_END: m_CursorPos = m_InputBuffer.GetLength(); break;

}

}

//----------------------------------------------------------------------- // The main part of the console!! This examines the keyed input and // calls the appropriate function handler void CConsole::ProccessCommand() { struct console *pCommand = CommandList; char CommandLine[128], *p; int n = m_InputBuffer.Find(' ');

if ( m_InputBuffer.IsEmpty() ) { DisplayLine(""); return ; }

m_InputBuffer.TrimRight();

/* Update history */ m_CommandHistory.AddHead(m_InputBuffer); if ( m_CommandHistory.GetCount() > MAX_SIZE ) m_CommandHistory.RemoveHead();

m_HistoryPos = NULL;

strcpy(CommandLine,m_InputBuffer); m_InputBuffer.Empty(); m_CursorPos = 0;

while ( pCommand->command && pCommand->handler ) { if ( strnicmp(CommandLine,pCommand->command,n) == 0) { /* Display the command */ DisplayLine(CommandLine);

/* Get the option */ p = strtok(CommandLine," "); p = strtok(NULL," ");

/* Handle the command */ pCommand->handler(p); return; } pCommand++; }

/* Not found a match in the command list */ FormatLine("Unknown command :\"%s\".",CommandLine); DisplayLine( "Type HELP for list ");

}

//----------------------------------------------------------------------- // Enable the TAB key to complete the current command void CConsole::ProccessTab() { struct console *pCommand = CommandList; int match = 0;

if ( m_TabCount == 0 ) m_PrevInput = m_InputBuffer;

while ( pCommand->command && pCommand->handler ) { if ( strnicmp(m_PrevInput,pCommand->command,m_PrevInput.GetLength()) == 0) { m_InputBuffer = pCommand->command; m_CursorPos = m_InputBuffer.GetLength();

if ( m_TabCount <= match ) { m_TabCount = match + 1; return; } match++; }

pCommand++; } }

//----------------------------------------------------------------------- // Close the console void CConsole::Close() { m_yOffset = 0; m_mode = DOWN; }

The zip file viewer built into the Developer Toolbox made use of the zlib library, as well as the zlibdll source additions.

 

Copyright 1999-2008 (C) FLIPCODE.COM and/or the original content author(s). All rights reserved.
Please read our Terms, Conditions, and Privacy information.