Intention
I wanted to create an archetype program that would be able
to handle multiple key combinations. Say, the right shift key and the
the key character 'X'. My options available were OIS, MFC, or WxWindows.
MFC and WxWindows would be a lot overhead and dll version management for
what is a simple program. After unsuccseful attempts at making OIS work,
I decided that the Petzold style of program would minimize the windows
"portion" and show how ogre would need to interact. When finished, this program
would show the classic orgehead mesh, respond to a few key inputs and
adjust to camera position in response to the mouse or the keyboard.
Table of contents
Starting point
First this program was created with Microsoft Visual Studio 2003 and links to
the Eihort version 1.3.0 of OGRE. The easiest way to start off is to use the
wizard to create a simple windows application ogre32, which should give you the following files:
ogre32.cpp ogre32.h ogre32.ico ogre32.ncb ogre32.rc ogre32.sln ogre32.vcproj ReadMe.txt Resource.h small.ico stdafx.cpp stdafx.h
Before modifying the code that the wizard created, you will need to
get the media files and scripts necessary to display the ogrehead.mesh
file. To do this you will need to create the directory 'media' under your
main project and copy the following files into this directory.
The png and jpg files can be found in the textures directory.
The Ogre.material file is a modified version of the Ogre.material
file that comes with the OGRE source code. The original one can be found
at .\ogrenew\Samples\Media\materials\scripts.
cursor.png dirt01.jpg GreenSkin.jpg Ogre.material ogreborder.png ogreborderUp.png ogrehead.mesh spheremap.png WeirdEye.png
You will need to create three configuration files:
{CODE(wrap="1"}ogre.cfg
Plugins.cfg
resources.cfg
{CODE}
ogre.cfg
Render System=Direct3D9 Rendering Subsystem [Direct3D9 Rendering Subsystem] Allow NVPerfHUD=No FSAA=0 Floating-point mode=Fastest Full Screen=No Rendering Device=NVIDIA GeForce FX 5200 VSync=No Video Mode=800 x 600 @ 32-bit colour [OpenGL Rendering Subsystem] Colour Depth=32 Display Frequency=60 FSAA=0 Full Screen=Yes RTT Preferred Mode=FBO VSync=No Video Mode=1024 x 768
Note: If you hear your graphics card squealing when showing the Ogre head, turn Vsync to "yes" in ogre.cfg! Your graphics card will squeal when there are too many frames per second being rendered.
Plugins.cfg
# Defines plugins to load # Define plugin folder PluginFolder=. # Define plugins Plugin=RenderSystem_Direct3D9
resources.cfg
# Resource locations to be added to the default path [General] FileSystem=./media
You will need to edit the follow files:
stdafx.h ogre32.cpp
stdafx.h
#pragma once #define WIN32_LEAN_AND_MEAN #include <windows.h> // C RunTime Header Files #include <stdlib.h> #include <malloc.h> #include <memory.h> #include <tchar.h> #include <Ogre.h> //brings in almost everything
ogre32.cpp
The following is the original ogre32.cpp file
This will create a simple project that displays the ogrehead mesh file.
// ogre32.cpp : Defines the entry point for the application. // #include "stdafx.h" #include "ogre32.h" #define MAX_LOADSTRING 100 // Global Variables: HINSTANCE hInst; // current instance TCHAR szTitle[MAX_LOADSTRING]; // The title bar text TCHAR szWindowClass[MAX_LOADSTRING]; // the main window class name using namespace Ogre; // <-- ultimate in lazy
The most important of the following variables is mRoot.
As the "Root class represents a starting point for the client application.
From here, the application can gain access to the fundamentals of the system ...
and Root must be created before any other Ogre operations are called.
Once an instance has been created, the same instance is accessible throughout the life of that
object by using Root::getSingleton (as a reference) or Root::getSingletonPtr (as a pointer). "
See http://www.ogre3d.org/docs/api/html/classOgre_1_1Root.html#_details for more details.
Please consult the wiki for more
detailed reasons on why we added each of
these variables.
Root *mRoot = 0; //
SceneManager *mSceneMgr = 0; //
Camera *mCamera = 0; //
Viewport* mViewPort = 0;
RenderWindow* mRenderWindow=0;
// Forward declarations of functions included in this code module:
ATOM MyRegisterClass(HINSTANCE hInstance);
BOOL InitInstance(HINSTANCE, int);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK About(HWND, UINT, WPARAM, LPARAM);
int APIENTRY _tWinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPTSTR lpCmdLine,
int nCmdShow)
{
// TODO: Place code here.
MSG msg;
HACCEL hAccelTable;
HWND hWnd;
// Initialize global strings
LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
LoadString(hInstance, IDC_OGRE32, szWindowClass, MAX_LOADSTRING);
MyRegisterClass(hInstance);
hInst = hInstance; // Store instance handle in our global variable
hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
if (!hWnd)
{
return FALSE;
}
create the root ogre system
mRoot = new Root();
load the configuration file
ConfigFile cf;
cf.load("resources.cfg");
ConfigFile::SectionIterator seci = cf.getSectionIterator();
String secName, typeName, archName;
while (seci.hasMoreElements())
{
secName = seci.peekNextKey();
ConfigFile::SettingsMultiMap *settings = seci.getNext();
ConfigFile::SettingsMultiMap::iterator i;
for (i = settings->begin(); i != settings->end(); ++i)
{
typeName = i->first;
archName = i->second;
ResourceGroupManager::getSingleton().addResourceLocation(
archName, typeName, secName);
}
}
Load the directx rendering system we dont have
to Display the configuration dialog.
RenderSystemList *rsList = mRoot->getAvailableRenderers();
int c=0;
bool foundit = false;
RenderSystem *selectedRenderSystem=0;
while(c < (int) rsList->size())
{
selectedRenderSystem = rsList->at(c);
String rname = selectedRenderSystem->getName();
if(rname.compare("Direct3D9 Rendering Subsystem")==0)
{
foundit=true;
break;
}
c++; // <-- oh how clever
}
if(!foundit)
return FALSE; //we didn't find it...
//we found it, we might as well use it!
mRoot->setRenderSystem(selectedRenderSystem);
selectedRenderSystem->setConfigOption("Full Screen","No");
selectedRenderSystem->setConfigOption("Video Mode","800 x 600 @ 16-bit colour");
//retrieve the config option map
ConfigOptionMap comap = selectedRenderSystem->getConfigOptions();
//and now we need to run through all of it
ConfigOptionMap::const_iterator start = comap.begin();
ConfigOptionMap::const_iterator end = comap.end();
while(start != end)
{
String OptionName = start->first;
String CurrentValue = start->second.currentValue;
StringVector PossibleValues = start->second.possibleValues;
int c=0;
while (c < (int) PossibleValues.size())
{
String OneValue = PossibleValues.at(c);
c++;
}
start++;
}
//end boilerplate
this is the magic! here is where we take the window that has been previously
been created and attach ogre to it.
mRoot->initialise(false,"Some Window Title");
NameValuePairList misc;
misc["externalWindowHandle"] = StringConverter::toString( (size_t)hWnd);
mRenderWindow = mRoot->createRenderWindow( "My sub render window", 800, 600, false, &misc );
create a scene manager
// choose sm
mSceneMgr = mRoot->createSceneManager(ST_GENERIC, "mSceneMgr");
mSceneMgr->setAmbientLight(ColourValue(0.5, 0.5, 0.5));
This is so we can have scripts work and the mesh is properly rendered.
ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
Load a mesh that is located in the ./media directory.
Entity *ent1 = mSceneMgr->createEntity( "ogre", "ogrehead.mesh" );
SceneNode *node1 = mSceneMgr->getRootSceneNode()->createChildSceneNode( "RobotNode" );
node1->attachObject( ent1 );
Create a camera so we can look at his lovely mug.
// --------------------
// Create the camera
mCamera = mSceneMgr->createCamera("PlayerCam");
// Position it at 500 in Z direction
mCamera->setPosition(Ogre::Vector3(0,0,500));
// Look back along -Z
mCamera->lookAt(Ogre::Vector3(0,0,-300));
mCamera->setNearClipDistance(5);
// Set the viewport
mViewPort = mRenderWindow->addViewport(mCamera);
mViewPort->setBackgroundColour(Ogre::ColourValue(0.0f, 0.0f, 0.0f, 1.0f));
ShowWindow(hWnd, nCmdShow);
UpdateWindow(hWnd);
hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_OGRE32);
// Main message loop:
while (GetMessage(&msg, NULL, 0, 0))
{
//placing renderOneFrame seems to allow for a clean shutdown.
//thanks to user lakin for that hint.
if (mRoot->renderOneFrame())
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
return (int) msg.wParam;
}
ATOM MyRegisterClass(HINSTANCE hInstance)
{
WNDCLASSEX wcex;
wcex.cbSize = sizeof(WNDCLASSEX);
wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = (WNDPROC)WndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = LoadIcon(hInstance, (LPCTSTR)IDI_OGRE32);
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wcex.lpszMenuName = NULL;
wcex.lpszClassName = szWindowClass;
wcex.hIconSm = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);
return RegisterClassEx(&wcex);
}
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
HWND hWnd;
hInst = hInstance; // Store instance handle in our global variable
hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
if (!hWnd)
{
return FALSE;
}
ShowWindow(hWnd, nCmdShow);
UpdateWindow(hWnd);
return TRUE;
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
int wmId, wmEvent;
PAINTSTRUCT ps;
HDC hdc;
switch (message)
{
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// Parse the menu selections:
switch (wmId)
{
case IDM_EXIT:
I was told to do this. This may or may not be necessary.
mRoot->detachRenderTarget(mRenderWindow);
DestroyWindow(hWnd);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
break;
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
// TODO: Add any drawing code here...
EndPaint(hWnd, &ps);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
Returning 1 will cause the screen not flicker when the
window is being resized.
case WM_ERASEBKGND:
return 1;
Handle resizing the window.
one of the things this program does not do
is display full screen. This should be relatively
simple to implement. Also the section is
direct translation of the WxWindows code that
was posted to forum.
case WM_SIZE:
if (mCamera)
{
RECT rect;
GetClientRect(hWnd,&rect);
// notify "render window" instance
mRenderWindow->windowMovedOrResized();
// Adjust camera's aspect ratio, too
if ((rect.bottom - rect.top) != 0 && mCamera != 0)
mCamera->setAspectRatio((Ogre::Real)mRenderWindow->getWidth() / (Ogre::Real)mRenderWindow->getHeight());
mCamera->yaw(Radian(0));
Root::getSingletonPtr()->renderOneFrame();
}
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
#endif
Alias: Simple_Win32_Program
;){kind=link}
;){kind=link}