HiGrass / 憋错料

Graphics.h

/***************************************************
    ©2014 Pf_D. All rights reserved.
***************************************************/
#pragma once
#include "OGRE\Ogre.h"
#include "OIS\OIS.h"

enum CameraStyle
{
    CS_FREELOOK,
    CS_ORBIT,
    CS_MANUAL
};

class cCameraManager
{
private:
    Ogre::Camera *mCamera;
    CameraStyle mStyle;
    Ogre::SceneNode *mTarget;
    bool mOrbiting;
    bool mZooming;
    Ogre::Real mTopSpeed;
    Ogre::Vector3 mVelocity;
    bool mGoingForward;
    bool mGoingBack;
    bool mGoingLeft;
    bool mGoingRight;
    bool mGoingUp;
    bool mGoingDown;
    bool mFastMove;

public:
    cCameraManager(Ogre::Camera *cam);

    void setCamera(Ogre::Camera *cam);
    Ogre::Camera *getCamera();

    void manualStop();

    void setStyle(CameraStyle style);
    CameraStyle getStyle();

    void setYawPitchDist(Ogre::Radian yaw, Ogre::Radian pitch, Ogre::Real dist);

    void setTarget(Ogre::SceneNode *target);
    Ogre::SceneNode *getTarget();

    void setTopSpeed(Ogre::Real topSpeed);
    Ogre::Real getTopSpeed();

    bool frameRenderingQueued(const Ogre::FrameEvent& evt);

    // Processes key press for free-look style movement.
    void injectKeyDown(const OIS::KeyEvent &evt);
    void injectKeyUp(const OIS::KeyEvent &evt);

    // Processes mouse movement differently for each style.
    void injectMouseMove(const OIS::MouseEvent &evt);

    // Processes mouse presses. Only applies for orbit style.
    // Left button is for orbiting, and right button is for zooming.
    void injectMouseDown(const OIS::MouseEvent &evt, OIS::MouseButtonID id);
    void injectMouseUp(const OIS::MouseEvent &evt, OIS::MouseButtonID id);
};

Graphics.cpp

/***************************************************
    ©2014 Pf_D. All rights reserved.
***************************************************/
#include "Graphics.h"

cCameraManager::cCameraManager(Ogre::Camera *cam)
    :mCamera(0),
    mStyle(CameraStyle::CS_FREELOOK),
    mTarget(0),
    mOrbiting(false),
    mZooming(false),
    mTopSpeed(150),
    mVelocity(Ogre::Vector3::ZERO),
    mGoingForward(false),
    mGoingBack(false),
    mGoingLeft(false),
    mGoingRight(false),
    mGoingUp(false),
    mGoingDown(false),
    mFastMove(false)
{
    setCamera(cam);
    setStyle(CS_FREELOOK);
}

void cCameraManager::setCamera(Ogre::Camera *cam)
{
    mCamera = cam;
}

Ogre::Camera *cCameraManager::getCamera()
{
    return mCamera;
}

void cCameraManager::setYawPitchDist(Ogre::Radian yaw, Ogre::Radian pitch, Ogre::Real dist)
{
    mCamera->setPosition(mTarget->_getDerivedPosition());
    mCamera->setOrientation(mTarget->_getDerivedOrientation());
    mCamera->yaw(yaw);
    mCamera->pitch(pitch);
    mCamera->moveRelative(Ogre::Vector3(0, 0, dist));
}

void cCameraManager::setTarget(Ogre::SceneNode *target)
{
    if(target != mTarget)
    {
        mTarget = target;
        if(target)
        {
            setYawPitchDist(Ogre::Degree(0), Ogre::Degree(15), 150);
            mCamera->setAutoTracking(true, mTarget);
        }
        else
            mCamera->setAutoTracking(false);
    }
}

Ogre::SceneNode *cCameraManager::getTarget()
{
    return mTarget;
}

void cCameraManager::manualStop()
{
    if(mStyle == CS_FREELOOK)
    {
        mVelocity = Ogre::Vector3::ZERO;
        mGoingForward = false;
        mGoingBack = false;
        mGoingLeft = false;
        mGoingRight = false;
        mGoingUp = false;
        mGoingDown = false;
    }
}

void cCameraManager::setStyle(CameraStyle style)
{
    if(mStyle != CS_ORBIT && style == CS_ORBIT)
    {
        setTarget(mTarget ? mTarget : mCamera->getSceneManager()->getRootSceneNode());
        mCamera->setFixedYawAxis(true);
        manualStop();
        setYawPitchDist(Ogre::Degree(0), Ogre::Degree(15), 150);
    }
    else if(mStyle != CS_FREELOOK && style == CS_FREELOOK)
    {
        mCamera->setAutoTracking(false);
        mCamera->setFixedYawAxis(true);
    }
    else if(mStyle != CS_MANUAL && style == CS_MANUAL)
    {
        mCamera->setAutoTracking(false);
        manualStop();
    }
    mStyle = style;
}

CameraStyle cCameraManager::getStyle()
{
    return mStyle;
}

void cCameraManager::setTopSpeed(Ogre::Real topSpeed)
{
    mTopSpeed = topSpeed;
}

Ogre::Real cCameraManager::getTopSpeed()
{
    return mTopSpeed;
}

bool cCameraManager::frameRenderingQueued(const Ogre::FrameEvent& evt)
{
    if (mStyle == CS_FREELOOK)
    {
        // build our acceleration vector based on keyboard input composite
        Ogre::Vector3 accel = Ogre::Vector3::ZERO;
        if (mGoingForward) accel += mCamera->getDirection();
        if (mGoingBack) accel -= mCamera->getDirection();
        if (mGoingRight) accel += mCamera->getRight();
        if (mGoingLeft) accel -= mCamera->getRight();
        if (mGoingUp) accel += mCamera->getUp();
        if (mGoingDown) accel -= mCamera->getUp();

        // if accelerating, try to reach top speed in a certain time
        Ogre::Real topSpeed = mFastMove ? mTopSpeed * 20 : mTopSpeed;
        if (accel.squaredLength() != 0)
        {
            accel.normalise();
            mVelocity += accel * topSpeed * evt.timeSinceLastFrame * 10;
        }
        // if not accelerating, try to stop in a certain time
        else mVelocity -= mVelocity * evt.timeSinceLastFrame * 10;

        Ogre::Real tooSmall = std::numeric_limits<Ogre::Real>::epsilon();

        // keep camera velocity below top speed and above epsilon
        if (mVelocity.squaredLength() > topSpeed * topSpeed)
        {
            mVelocity.normalise();
            mVelocity *= topSpeed;
        }
        else if (mVelocity.squaredLength() < tooSmall * tooSmall)
            mVelocity = Ogre::Vector3::ZERO;

        if (mVelocity != Ogre::Vector3::ZERO) mCamera->move(mVelocity * evt.timeSinceLastFrame);
    }

    return true;
}

void cCameraManager::injectKeyDown(const OIS::KeyEvent &evt)
{
    if(mStyle != CS_FREELOOK)
        return;
    if (evt.key == OIS::KC_W || evt.key == OIS::KC_UP) mGoingForward = true;
    else if (evt.key == OIS::KC_S || evt.key == OIS::KC_DOWN) mGoingBack = true;
    else if (evt.key == OIS::KC_A || evt.key == OIS::KC_LEFT) mGoingLeft = true;
    else if (evt.key == OIS::KC_D || evt.key == OIS::KC_RIGHT) mGoingRight = true;
    else if (evt.key == OIS::KC_PGUP) mGoingUp = true;
    else if (evt.key == OIS::KC_PGDOWN) mGoingDown = true;
    else if (evt.key == OIS::KC_LSHIFT) mFastMove = true;
}

void cCameraManager::injectKeyUp(const OIS::KeyEvent &evt)
{
    if(mStyle != CS_FREELOOK)
        return;
    if (evt.key == OIS::KC_W || evt.key == OIS::KC_UP) mGoingForward = false;
    else if (evt.key == OIS::KC_S || evt.key == OIS::KC_DOWN) mGoingBack = false;
    else if (evt.key == OIS::KC_A || evt.key == OIS::KC_LEFT) mGoingLeft = false;
    else if (evt.key == OIS::KC_D || evt.key == OIS::KC_RIGHT) mGoingRight = false;
    else if (evt.key == OIS::KC_PGUP) mGoingUp = false;
    else if (evt.key == OIS::KC_PGDOWN) mGoingDown = false;
    else if (evt.key == OIS::KC_LSHIFT) mFastMove = false;
}

void cCameraManager::injectMouseMove(const OIS::MouseEvent &evt)
{
    if (mStyle == CS_ORBIT)
    {
        Ogre::Real dist = (mCamera->getPosition() - mTarget->_getDerivedPosition()).length();

        if (mOrbiting)   // yaw around the target, and pitch locally
        {
            mCamera->setPosition(mTarget->_getDerivedPosition());

            mCamera->yaw(Ogre::Degree(-evt.state.X.rel * 0.25f));
            mCamera->pitch(Ogre::Degree(-evt.state.Y.rel * 0.25f));

            mCamera->moveRelative(Ogre::Vector3(0, 0, dist));

            // don‘t let the camera go over the top or around the bottom of the target
        }
        else if (mZooming)  // move the camera toward or away from the target
        {
            // the further the camera is, the faster it moves
            mCamera->moveRelative(Ogre::Vector3(0, 0, evt.state.Y.rel * 0.004f * dist));
        }
        else if (evt.state.Z.rel != 0)  // move the camera toward or away from the target
        {
            // the further the camera is, the faster it moves
            mCamera->moveRelative(Ogre::Vector3(0, 0, -evt.state.Z.rel * 0.0008f * dist));
        }
    }
    else if (mStyle == CS_FREELOOK)
    {
        mCamera->yaw(Ogre::Degree(-evt.state.X.rel * 0.15f));
        mCamera->pitch(Ogre::Degree(-evt.state.Y.rel * 0.15f));
    }
}

void cCameraManager::injectMouseDown(const OIS::MouseEvent &evt, OIS::MouseButtonID id)
{
    if (mStyle == CS_ORBIT)
    {
        if (id == OIS::MB_Left) mOrbiting = true;
        else if (id == OIS::MB_Right) mZooming = true;
    }
}

void cCameraManager::injectMouseUp(const OIS::MouseEvent &evt, OIS::MouseButtonID id)
{
    if (mStyle == CS_ORBIT)
    {
        if (id == OIS::MB_Left) mOrbiting = false;
        else if (id == OIS::MB_Right) mZooming = false;
    }
}

System.h

/***************************************************
    ©2014 Pf_D. All rights reserved.
***************************************************/
#pragma once
#include "Graphics.h"
#include "OGRE\Ogre.h"
#include "OIS\OIS.h"
#include "MyGUI.h"
#include "MyGUI_OgrePlatform.h"

class cApplication : public Ogre::FrameListener, public OIS::KeyListener, public OIS::MouseListener
{
protected:
    MyGUI::Gui          *mGUI;
    MyGUI::OgrePlatform *mPlatform;

    Ogre::Root          *mRoot;
    Ogre::RenderWindow  *mWindow;
    Ogre::SceneManager  *mSceneMgr;
    Ogre::Camera        *mCamera;

    cCameraManager      *mCameraMgr;
    OIS::InputManager   *mInputMgr;
    OIS::Keyboard       *mKeyboard;
    OIS::Mouse          *mMouse;
    bool mDragLook;

public:
    cApplication()
        :mDragLook(false)
    {
    }

    virtual bool frameStarted(const Ogre::FrameEvent &evt);
    virtual bool frameRenderingQueued(const Ogre::FrameEvent &evt);
    virtual bool frameEnded(const Ogre::FrameEvent &evt);

    virtual bool keyPressed(const OIS::KeyEvent &arg);
    virtual bool keyReleased(const OIS::KeyEvent &arg);

    virtual bool mouseMoved(const OIS::MouseEvent &arg);
    virtual bool mousePressed(const OIS::MouseEvent &arg, OIS::MouseButtonID id);
    virtual bool mouseReleased(const OIS::MouseEvent &arg, OIS::MouseButtonID id);

    virtual void setupResources();
    virtual void createInput();
    virtual void chooseSceneMgr();
    virtual void setupView();
    virtual void loadResources();
    virtual void createScene() {}

    bool setup();
    void go();

    void setDragLook(bool enabled);
};

System.cpp

/***************************************************
    ©2014 Pf_D. All rights reserved.
***************************************************/
#include "System.h"

bool cApplication::frameStarted(const Ogre::FrameEvent &evt)
{
    mKeyboard->capture();
    mMouse->capture();
    return true;
}

bool cApplication::frameRenderingQueued(const Ogre::FrameEvent &evt)
{
    mCameraMgr->frameRenderingQueued(evt);
    return true;
}

bool cApplication::frameEnded(const Ogre::FrameEvent &evt)
{
    return true;
}

bool cApplication::keyPressed(const OIS::KeyEvent &arg)
{
    if(arg.key == OIS::KC_ESCAPE)
        exit(0);
    MyGUI::InputManager::getInstance().injectKeyPress(
        MyGUI::KeyCode::Enum(arg.key), arg.text);
    mCameraMgr->injectKeyDown(arg);
    // ...
    return true;
}

bool cApplication::keyReleased(const OIS::KeyEvent &arg)
{
    MyGUI::InputManager::getInstance().injectKeyRelease(MyGUI::KeyCode::Enum(arg.key));
    mCameraMgr->injectKeyUp(arg);
    // ...
    return true;
}

bool cApplication::mouseMoved( const OIS::MouseEvent &arg )
{
    bool ret = MyGUI::InputManager::getInstance().injectMouseMove(
        arg.state.X.abs, arg.state.Y.abs, arg.state.Z.abs);
    if(!ret)
        mCameraMgr->injectMouseMove(arg);
    // ...
    return true;
}

bool cApplication::mousePressed( const OIS::MouseEvent &arg, OIS::MouseButtonID id )
{
    bool ret = MyGUI::InputManager::getInstance().injectMousePress(
        arg.state.X.abs, arg.state.Y.abs, MyGUI::MouseButton::Enum(id));
    if(!ret)
        mCameraMgr->injectMouseDown(arg, id);
    if(mDragLook && id == OIS::MB_Left)
    {
        mCameraMgr->setStyle(CS_FREELOOK);
        MyGUI::Gui::getInstance().hidePointer();
    }
    // ...
    return true;
}

bool cApplication::mouseReleased( const OIS::MouseEvent &arg, OIS::MouseButtonID id )
{
    bool ret = MyGUI::InputManager::getInstance().injectMouseRelease(
        arg.state.X.abs, arg.state.Y.abs, MyGUI::MouseButton::Enum(id));
    if(!ret)
        mCameraMgr->injectMouseUp(arg, id);
    if(mDragLook && id == OIS::MB_Left)
    {
        mCameraMgr->setStyle(CS_MANUAL);
        MyGUI::Gui::getInstance().showPointer();
    }
    // ...
    return true;
}

void cApplication::setupResources()
{
    Ogre::ConfigFile cf;
#if OGRE_DEBUG_MODE
    cf.load("resources_d.cfg");
#else
    cf.load("resources.cfg");
#endif
    Ogre::ConfigFile::SectionIterator secIter = cf.getSectionIterator();
    Ogre::String secName, typeName, archName;
    while(secIter.hasMoreElements())
    {
        secName = secIter.peekNextKey();
        Ogre::ConfigFile::SettingsMultiMap *settings = secIter.getNext();
        Ogre::ConfigFile::SettingsMultiMap::iterator i;
        for(i=settings->begin(); i!=settings->end(); i++)
        {
            typeName = i->first;
            archName = i->second;
            Ogre::ResourceGroupManager::getSingleton().addResourceLocation(
                archName, typeName, secName);
        }
    }
}

void cApplication::createInput()
{
    OIS::ParamList parameters;
    unsigned int windowHandle = 0;
    std::ostringstream windowHandleString;
    mWindow->getCustomAttribute("WINDOW", &windowHandle);
    windowHandleString << windowHandle;
    parameters.insert(std::make_pair("WINDOW", windowHandleString.str()));
    parameters.insert(std::make_pair("w32_mouse", std::string("DISCL_FOREGROUND")));
    parameters.insert(std::make_pair("w32_mouse", std::string("DISCL_NONEXCLUSIVE")));
    mInputMgr = OIS::InputManager::createInputSystem(parameters);
    mKeyboard = static_cast<OIS::Keyboard*>(mInputMgr->createInputObject(OIS::OISKeyboard, true));
    mKeyboard->setEventCallback(this);
    mMouse = static_cast<OIS::Mouse*>(mInputMgr->createInputObject(OIS::OISMouse, true));
    const OIS::MouseState &mouseState = mMouse->getMouseState();
    mouseState.width = mWindow->getWidth();
    mouseState.height = mWindow->getHeight();
    mMouse->setEventCallback(this);
}

void cApplication::chooseSceneMgr()
{
    mSceneMgr = mRoot->createSceneManager(Ogre::ST_GENERIC);
}

void cApplication::setupView()
{
    // Create camera
    mCamera = mSceneMgr->createCamera("Camera");
    mCamera->setPosition(Ogre::Vector3(0, 0, 50));
    mCamera->lookAt(Ogre::Vector3(0, 0, -300));
    mCamera->setNearClipDistance(5);
    mCameraMgr = new cCameraManager(mCamera);
    // Create viewports
    Ogre::Viewport *vp = mWindow->addViewport(mCamera);
    vp->setBackgroundColour(Ogre::ColourValue(0, 0, 0));
    mCamera->setAspectRatio(Ogre::Real(vp->getActualWidth())/Ogre::Real(vp->getActualHeight()));
}

void cApplication::loadResources()
{
    Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
}

bool cApplication::setup()
{
#ifndef OGRE_STATIC_LIB
#if OGRE_DEBUG_MODE
    mRoot = OGRE_NEW Ogre::Root("plugins_d.cfg");
#else
    mRoot = OGRE_NEW Ogre::Root("plugins.cfg");
#endif
#endif
    setupResources();
    if(!mRoot->showConfigDialog())
        return false;
    mWindow = mRoot->initialise(true);
    createInput();
    ShowCursor(false);
    chooseSceneMgr();
    setupView();
    loadResources();
    createScene();
    mRoot->addFrameListener(this);
    return true;
}

void cApplication::go()
{
    if(!setup())
        return;
    mRoot->startRendering();
}

void cApplication::setDragLook(bool enabled)
{
    if(enabled)
    {
        mCameraMgr->setStyle(CS_MANUAL);
        mDragLook = true;
    }
    else
    {
        mCameraMgr->setStyle(CS_FREELOOK);
        mDragLook = false;
    }
}

Main.cpp

/***************************************************
    ©2014 Pf_D. All rights reserved.
***************************************************/
#include "System.h"

class cMyApplication : public cApplication
{
public:
    void createScene()
    {
        // MyGUI
        mPlatform = new MyGUI::OgrePlatform();
        mPlatform->initialise(mWindow, mSceneMgr);
        mGUI = new MyGUI::Gui();
        mGUI->initialise();
		setDragLook(true);
		mSceneMgr->setAmbientLight(Ogre::ColourValue::White);
		//Ogre::Plane plane(Ogre::Vector3::UNIT_Y, -10);
		//Ogre::MeshManager::getSingleton().createPlane("plane",
		//	Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, plane,
		//	1500,1500,200,200,true,1,5,5,Ogre::Vector3::UNIT_Z);

		//Ogre::Entity* ent = mSceneMgr->createEntity("GrassPlane", "plane");
		//mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(ent);
		//ent->setMaterialName("Examples/GrassFloor");

		//Ogre::Light* light = mSceneMgr->createLight("Light1");
		//light->setType(Ogre::Light::LT_DIRECTIONAL);
		//light->setDirection(Ogre::Vector3(1,-1,0));

		//Ogre::ManualObject*  manual = mSceneMgr->createManualObject("grass");
		//manual->begin("Examples/GrassBlades", Ogre::RenderOperation::OT_TRIANGLE_LIST);

		////First triangle
		//manual->position(5.0, 0.0, 0.0);
		//manual->textureCoord(0,1);
		//manual->position(-5.0, 10.0, 0.0);
		//manual->textureCoord(1,0);
		//manual->position(-5.0, 0.0, 0.0);
		//manual->textureCoord(1,1);

		////Second triangle
		//manual->position(5.0, 0.0, 0.0);
		//manual->textureCoord(0,1);
		//manual->position(5.0, 10.0, 0.0);
		//manual->textureCoord(0,0);
		//manual->position(-5.0, 10.0, 0.0);
		//manual->textureCoord(1,0);

		////third triangle
		//manual->position(2.5, 0.0, 4.3);
		//manual->textureCoord(0,1);
		//manual->position(-2.5, 10.0, -4.3);
		//manual->textureCoord(1,0);
		//manual->position(-2.0, 0.0, -4.3);
		//manual->textureCoord(1,1);

		////forth triangle
		//manual->position(2.5, 0.0, 4.3);
		//manual->textureCoord(0,1);
		//manual->position(2.5, 10.0, 4.3);
		//manual->textureCoord(0,0);
		//manual->position(-2.5, 10.0, -4.3);
		//manual->textureCoord(1,0);

		////fifth triangle
		//manual->position(2.5, 0.0, -4.3);
		//manual->textureCoord(0,1);
		//manual->position(-2.5, 10.0, 4.3);
		//manual->textureCoord(1,0);
		//manual->position(-2.0, 0.0, 4.3);
		//manual->textureCoord(1,1);

		////sixth triangle
		//manual->position(2.5, 0.0, -4.3);
		//manual->textureCoord(0,1);
		//manual->position(2.5, 10.0, -4.3);
		//manual->textureCoord(0,0);
		//manual->position(-2.5, 10.0, 4.3);
		//manual->textureCoord(1,0);

		//manual->end();

		//manual->convertToMesh("BladesOfGrass");

		//	for(int i=0;i<50;i++)
		//	{
		//		for(int j=0;j<50;j++)
		//		{
		//			Ogre::Entity * ent = mSceneMgr->createEntity("BladesOfGrass");
		//			Ogre::SceneNode* node = mSceneMgr->getRootSceneNode()->createChildSceneNode(Ogre::Vector3(i*3,-10,j*3));
		//			node->attachObject(ent);
		//		}
		//	}
		Ogre::Plane plane(Ogre::Vector3::UNIT_Y, -10);
		Ogre::MeshManager::getSingleton().createPlane("plane",
			Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, plane,
			1500,1500,200,200,true,1,5,5,Ogre::Vector3::UNIT_Z);

		Ogre::Entity* ent = mSceneMgr->createEntity("GrassPlane", "plane");
		mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(ent);
		ent->setMaterialName("Examples/GrassFloor");

		Ogre::Light* light = mSceneMgr->createLight("Light1");
		light->setType(Ogre::Light::LT_DIRECTIONAL);
		light->setDirection(Ogre::Vector3(1,-1,0));

		Ogre::ManualObject*  manual = mSceneMgr->createManualObject("grass");
		manual->begin("Examples/GrassBlades", Ogre::RenderOperation::OT_TRIANGLE_LIST);

		manual->position(5.0, 0.0, 0.0);
		manual->textureCoord(0,1);
		manual->position(-5.0, 10.0, 0.0);
		manual->textureCoord(1,0);
		manual->position(-5.0, 0.0, 0.0);
		manual->textureCoord(1,1);
		manual->position(5.0, 10.0, 0.0);
		manual->textureCoord(0,0);

		manual->position(2.5, 0.0, 4.3);
		manual->textureCoord(0,1);
		manual->position(-2.5, 10.0, -4.3);
		manual->textureCoord(1,0);
		manual->position(-2.0, 0.0, -4.3);
		manual->textureCoord(1,1);
		manual->position(2.5, 10.0, 4.3);
		manual->textureCoord(0,0);

		manual->position(2.5, 0.0, -4.3);
		manual->textureCoord(0,1);
		manual->position(-2.5, 10.0, 4.3);
		manual->textureCoord(1,0);
		manual->position(-2.0, 0.0, 4.3);
		manual->textureCoord(1,1);
		manual->position(2.5, 10.0, -4.3);
		manual->textureCoord(0,0);

		manual->index(0);
		manual->index(1);
		manual->index(2);

		manual->index(0);
		manual->index(3);
		manual->index(1);

		manual->index(4);
		manual->index(5);
		manual->index(6);

		manual->index(4);
		manual->index(7);
		manual->index(5);

		manual->index(8);
		manual->index(9);
		manual->index(10);

		manual->index(8);
		manual->index(11);
		manual->index(9);

		manual->end();

		manual->convertToMesh("BladesOfGrass");

		Ogre::StaticGeometry* field = mSceneMgr->createStaticGeometry("FieldOfGrass");
		for(int i=0;i<50;i++)
		{
			for(int j=0;j<50;j++)
			{
				Ogre::Entity * ent = mSceneMgr->createEntity("BladesOfGrass");
				field->addEntity(ent,Ogre::Vector3(i*3,-10,j*3));

			}
		}

		field->build();
    }
};

int main()
{
    cMyApplication App;
    App.go();
    return 0;
}

时间： 2024-11-08 22:59:22

HiGrass

HiGrass的相关文章