void World::CreateNamedRT(String worldName)
{
Graphics* g = context->GetSubsystem<Graphics>();
int w = g->GetWidth();
int h = g->GetHeight();
renderTexture = SharedPtr<Texture2D>(new Texture2D(context));
if (renderTexture)
{
renderTexture->SetSize(w, h, Graphics::GetRGBFormat(), TEXTURE_RENDERTARGET);
renderTexture->SetFilterMode(FILTER_NEAREST);
renderTexture->SetName(worldName);
ResourceCache* cache = context->GetSubsystem<ResourceCache>();
cache->AddManualResource(renderTexture);
RenderSurface* surface = renderTexture->GetRenderSurface();
surface->SetUpdateMode(RenderSurfaceUpdateMode::SURFACE_UPDATEALWAYS);
surface->SetViewport(0, camera.vp);
}
}
static void drawedge(PathNode* from, PathNode* to, uint32 rgb)
{
RenderSurface* screen = GUIApp::get_instance()->getScreen();
sint32 cx, cy, cz;
GUIApp::get_instance()->getGameMapGump()->GetCameraLocation(cx, cy, cz);
Pentagram::Rect d;
screen->GetSurfaceDims(d);
sint32 x0, y0, x1, y1;
cx = from->state.x - cx;
cy = from->state.y - cy;
cz = from->state.z - cz;
x0 = (d.w/2) + (cx - cy)/2;
y0 = (d.h/2) + (cx + cy)/4 - cz*2;
GUIApp::get_instance()->getGameMapGump()->GetCameraLocation(cx, cy, cz);
cx = to->state.x - cx;
cy = to->state.y - cy;
cz = to->state.z - cz;
x1 = (d.w/2) + (cx - cy)/2;
y1 = (d.h/2) + (cx + cy)/4 - cz*2;
screen->DrawLine32(rgb, x0, y0, x1, y1);
}
void RTTScene::CreateScene()
{
rttScene_ = new Scene(context_);
rttScene_->CreateComponent<Octree>();
Node* zoneNode = rttScene_->CreateChild("Zone");
Zone* zone = zoneNode->CreateComponent<Zone>();
zone->SetBoundingBox(BoundingBox(-1000.0f, 1000.0f));
zone->SetAmbientColor(Color(0.05f, 0.1f, 0.15f));
zone->SetFogColor(Color(0.1f, 0.2f, 0.3f));
zone->SetFogStart(10.0f);
zone->SetFogEnd(100.0f);
//用来指定ViewPort时的定位
rttCameraNode_ = rttScene_->CreateChild("Camera");
Camera* camera = rttCameraNode_->CreateComponent<Camera>();
Light* light = rttCameraNode_->CreateComponent<Light>();
light->SetLightType(LIGHT_POINT);
renderTexture = new Texture2D(context_);
//设置当前场景的ViewPort
renderTexture->SetSize(_width,_height,Graphics::GetRGBFormat(),TEXTURE_RENDERTARGET);
RenderSurface* surface = renderTexture->GetRenderSurface();
renderTexture->SetFilterMode(FILTER_BILINEAR);
Viewport* rttViewPort = new Viewport(context_,rttScene_,camera);
surface->SetViewport(0,rttViewPort);
}
void UISceneView::QueueUpdate()
{
if (!autoUpdate_)
{
RenderSurface* surface = renderTexture_->GetRenderSurface();
if (surface)
surface->QueueUpdate();
}
}
void UISceneView::SetAutoUpdate(bool enable)
{
if (enable != autoUpdate_)
{
autoUpdate_ = enable;
RenderSurface* surface = renderTexture_->GetRenderSurface();
if (surface)
surface->SetUpdateMode(autoUpdate_ ? SURFACE_UPDATEALWAYS : SURFACE_MANUALUPDATE);
}
}
void Adaptor::ReplaceSurface( Dali::RenderSurface& surface )
{
// adaptor implementation needs the implementation of
RenderSurface* internalSurface = dynamic_cast<Internal::Adaptor::RenderSurface*>( &surface );
DALI_ASSERT_ALWAYS( internalSurface && "Incorrect surface" );
mSurface = internalSurface;
SurfaceSizeChanged( internalSurface->GetPositionSize() );
// flush the event queue to give update and render threads chance
// to start processing messages for new camera setup etc as soon as possible
ProcessCoreEvents();
// this method is synchronous
mUpdateRenderController->ReplaceSurface(internalSurface);
}
static void drawdot(sint32 x, sint32 y, sint32 z, int size, uint32 rgb)
{
RenderSurface* screen = GUIApp::get_instance()->getScreen();
sint32 cx, cy, cz;
GUIApp::get_instance()->getGameMapGump()->GetCameraLocation(cx, cy, cz);
Pentagram::Rect d;
screen->GetSurfaceDims(d);
x -= cx;
y -= cy;
z -= cz;
sint32 x0,y0;
x0 = (d.w/2) + (x - y)/2;
y0 = (d.h/2) + (x + y)/4 - z*2;
screen->Fill32(rgb, x0-size, y0-size, 2*size+1, 2*size+1);
}
void Water::SetupViewport()
{
Graphics* graphics = GetContext()->m_Graphics.get();
Renderer* renderer = GetContext()->m_Renderer.get();
ResourceCache* cache = GetContext()->m_ResourceCache.get();
// Set up a viewport to the Renderer subsystem so that the 3D scene can be seen
SharedPtr<Viewport> viewport(new Viewport(GetContext(), scene_, cameraNode_->GetComponent<Camera>()));
renderer->SetViewport(0, viewport);
// Create a mathematical plane to represent the water in calculations
waterPlane_ = Plane(waterNode_->GetWorldRotation() * Vector3(0.0f, 1.0f, 0.0f), waterNode_->GetWorldPosition());
// Create a downward biased plane for reflection view clipping. Biasing is necessary to avoid too aggressive clipping
waterClipPlane_ = Plane(waterNode_->GetWorldRotation() * Vector3(0.0f, 1.0f, 0.0f), waterNode_->GetWorldPosition() -
Vector3(0.0f, 0.1f, 0.0f));
// Create camera for water reflection
// It will have the same farclip and position as the main viewport camera, but uses a reflection plane to modify
// its position when rendering
reflectionCameraNode_ = cameraNode_->CreateChild();
Camera* reflectionCamera = reflectionCameraNode_->CreateComponent<Camera>();
reflectionCamera->setFarClipDistance(750.0);
reflectionCamera->SetViewMask(0x7fffffff); // Hide objects with only bit 31 in the viewmask (the water plane)
reflectionCamera->SetAutoAspectRatio(false);
reflectionCamera->SetUseReflection(true);
reflectionCamera->SetReflectionPlane(waterPlane_);
reflectionCamera->SetUseClipping(true); // Enable clipping of geometry behind water plane
reflectionCamera->SetClipPlane(waterClipPlane_);
// The water reflection texture is rectangular. Set reflection camera aspect ratio to match
reflectionCamera->SetAspectRatio((float)graphics->GetWidth() / (float)graphics->GetHeight());
// View override flags could be used to optimize reflection rendering. For example disable shadows
//reflectionCamera->SetViewOverrideFlags(VO_DISABLE_SHADOWS);
// Create a texture and setup viewport for water reflection. Assign the reflection texture to the diffuse
// texture unit of the water material
int texSize = 1024;
SharedPtr<Texture2D> renderTexture(new Texture2D(GetContext()));
renderTexture->SetSize(texSize, texSize, Graphics::GetRGBFormat(), TEXTURE_RENDERTARGET);
renderTexture->SetFilterMode(FILTER_BILINEAR);
RenderSurface* surface = renderTexture->GetRenderSurface();
SharedPtr<Viewport> rttViewport(new Viewport(GetContext(), scene_, reflectionCamera));
surface->SetViewport(0, rttViewport);
Material* waterMat = cache->GetResource<Material>("Materials/Water.xml");
waterMat->SetTexture(TU_DIFFUSE, renderTexture);
}
static void drawbox(Item* item)
{
RenderSurface* screen = GUIApp::get_instance()->getScreen();
sint32 cx, cy, cz;
GUIApp::get_instance()->getGameMapGump()->GetCameraLocation(cx, cy, cz);
Pentagram::Rect d;
screen->GetSurfaceDims(d);
sint32 ix, iy, iz;
item->getLocation(ix, iy, iz);
sint32 xd, yd, zd;
item->getFootpadWorld(xd, yd, zd);
ix -= cx;
iy -= cy;
iz -= cz;
sint32 x0,y0,x1,y1,x2,y2,x3,y3;
x0 = (d.w/2) + (ix - iy)/2;
y0 = (d.h/2) + (ix + iy)/4 - iz*2;
x1 = (d.w/2) + (ix - iy)/2;
y1 = (d.h/2) + (ix + iy)/4 - (iz+zd)*2;
x2 = (d.w/2) + (ix-xd - iy)/2;
y2 = (d.h/2) + (ix-xd + iy)/4 - iz*2;
x3 = (d.w/2) + (ix - iy+yd)/2;
y3 = (d.h/2) + (ix + iy-yd)/4 - iz*2;
screen->Fill32(0xFF0000FF, x0-1, y0-1, 3, 3);
screen->DrawLine32(0xFF00FF00, x0, y0, x1, y1);
screen->DrawLine32(0xFF00FF00, x0, y0, x2, y2);
screen->DrawLine32(0xFF00FF00, x0, y0, x3, y3);
}
// ---------------------------------------------------------------------------------------------------------
LVEDRENDERINGENGINE_API void __stdcall LvEd_End()
{
RenderContext* rc = RenderContext::Inst();
RenderSurface* surface = s_engineData->pRenderSurface;
s_engineData->basicRenderer->End();
LineRenderer::Inst()->RenderAll(rc);
ErrorHandler::ClearError();
LvEdFonts::FontRenderer::Inst()->FlushPrintRequests( rc );
if(surface->GetType() == RenderSurface::kSwapChain)
{
RenderWorldAxis();
SwapChain* swapchain = static_cast<SwapChain*>(surface);
HRESULT hr = swapchain->GetDXGISwapChain()->Present(0,0);
Logger::IsFailureLog(hr, L"presenting swapchain");
}
s_engineData->renderableSorter.ClearLists();
s_engineData->pRenderSurface = NULL;
RenderContext::Inst()->LightEnvDirty = false;
}
void UISceneView::OnResize(const IntVector2 &newSize)
{
if (newSize.x_ == size_.x_ && newSize.y_ == size_.y_)
return;
int width = newSize.x_;
int height = newSize.y_;
if (width > 0 && height > 0)
{
viewport_->SetRect(IntRect(0, 0, width, height));
renderTexture_->SetSize(width, height, rttFormat_, TEXTURE_RENDERTARGET);
depthTexture_->SetSize(width, height, Graphics::GetDepthStencilFormat(), TEXTURE_DEPTHSTENCIL);
RenderSurface* surface = renderTexture_->GetRenderSurface();
surface->SetViewport(0, viewport_);
surface->SetUpdateMode(autoUpdate_ ? SURFACE_UPDATEALWAYS : SURFACE_MANUALUPDATE);
surface->SetLinkedDepthStencil(depthTexture_->GetRenderSurface());
size_ = newSize;
}
}
void GameMain::WaterSetup(Urho3D::String waterNodeName)
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
Graphics* graphics = GetSubsystem<Graphics>();
Node* waterNode_ = scene_->GetChild("waterNode",true);
StaticModel* waterMesh = waterNode_->GetComponent<StaticModel>();
waterMesh->SetViewMask(0x80000000);
world.camera.waterPlane_ = Plane(waterNode_->GetWorldRotation() * Vector3(0.0f, 1.0f, 0.0f), waterNode_->GetWorldPosition());
world.camera.waterClipPlane_ = Plane(waterNode_->GetWorldRotation() * Vector3(0.0f, 1.0f, 0.0f), waterNode_->GetWorldPosition() - Vector3(0.0f, 0.1f, 0.0f));
world.camera.reflectionCameraNode_ = world.camera.node_->CreateChild();
Camera* reflectionCamera = world.camera.reflectionCameraNode_->CreateComponent<Camera>();
reflectionCamera->SetFarClip(1000.0);
reflectionCamera->SetFov(75.0f);
reflectionCamera->SetViewMask(0x7fffffff); // Hide objects with only bit 31 in the viewmask (the water plane)
reflectionCamera->SetAutoAspectRatio(false);
reflectionCamera->SetUseReflection(true);
reflectionCamera->SetReflectionPlane(world.camera.waterPlane_);
reflectionCamera->SetUseClipping(true); // Enable clipping of geometry behind water plane
reflectionCamera->SetClipPlane(world.camera.waterClipPlane_);
reflectionCamera->SetAspectRatio((float)graphics->GetWidth() / (float)graphics->GetHeight());
int texSize = 1024;
SharedPtr<Texture2D> renderTexture(new Texture2D(context_));
renderTexture->SetSize(texSize, texSize, Graphics::GetRGBFormat(), TEXTURE_RENDERTARGET);
renderTexture->SetFilterMode(FILTER_BILINEAR);
RenderSurface* surface = renderTexture->GetRenderSurface();
SharedPtr<Viewport> rttViewport(new Viewport(context_, scene_, reflectionCamera));
surface->SetViewport(0, rttViewport);
Material* waterMat = cache->GetResource<Material>("Materials/Water.xml");
waterMat->SetTexture(TU_DIFFUSE, renderTexture);
}
LVEDRENDERINGENGINE_API bool __stdcall LvEd_SaveRenderSurfaceToFile(ObjectGUID renderSurfaceId, wchar_t *fileName)
{
ErrorHandler::ClearError();
if(fileName == NULL || wcslen(fileName) == 0 )
{
ErrorHandler::SetError(ErrorType::UnknownError, L"%s: filename is empty", __WFUNCTION__);
return false;
}
DirectX::ScratchImage scratchImg;
RenderSurface* renderSurface = reinterpret_cast<RenderSurface*>(renderSurfaceId);
HRESULT hr = CaptureTexture(gD3D11->GetDevice(),::gD3D11->GetImmediateContext(),
(ID3D11Resource*)renderSurface->GetColorBuffer()->GetTex(),scratchImg);
if(FAILED(hr)) return false;
const DirectX::Image* img = scratchImg.GetImage(0,0,0);
ImageData imgdata;
imgdata.InitFrom(img);
imgdata.SaveToFile(fileName);
return SUCCEEDED(hr);
}
void RenderToTexture::CreateScene()
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
{
// Create the scene which will be rendered to a texture
rttScene_ = new Scene(context_);
// Create octree, use default volume (-1000, -1000, -1000) to (1000, 1000, 1000)
rttScene_->CreateComponent<Octree>();
// Create a Zone for ambient light & fog control
Node* zoneNode = rttScene_->CreateChild("Zone");
Zone* zone = zoneNode->CreateComponent<Zone>();
// Set same volume as the Octree, set a close bluish fog and some ambient light
zone->SetBoundingBox(BoundingBox(-1000.0f, 1000.0f));
zone->SetAmbientColor(Color(0.05f, 0.1f, 0.15f));
zone->SetFogColor(Color(0.1f, 0.2f, 0.3f));
zone->SetFogStart(10.0f);
zone->SetFogEnd(100.0f);
// Create randomly positioned and oriented box StaticModels in the scene
const unsigned NUM_OBJECTS = 2000;
for (unsigned i = 0; i < NUM_OBJECTS; ++i)
{
Node* boxNode = rttScene_->CreateChild("Box");
boxNode->SetPosition(Vector3(Random(200.0f) - 100.0f, Random(200.0f) - 100.0f, Random(200.0f) - 100.0f));
// Orient using random pitch, yaw and roll Euler angles
boxNode->SetRotation(Quaternion(Random(360.0f), Random(360.0f), Random(360.0f)));
StaticModel* boxObject = boxNode->CreateComponent<StaticModel>();
boxObject->SetModel(cache->GetResource<Model>("Models/Box.mdl"));
boxObject->SetMaterial(cache->GetResource<Material>("Materials/Stone.xml"));
// Add our custom Rotator component which will rotate the scene node each frame, when the scene sends its update event.
// Simply set same rotation speed for all objects
Rotator* rotator = boxNode->CreateComponent<Rotator>();
rotator->SetRotationSpeed(Vector3(10.0f, 20.0f, 30.0f));
}
// Create a camera for the render-to-texture scene. Simply leave it at the world origin and let it observe the scene
rttCameraNode_ = rttScene_->CreateChild("Camera");
Camera* camera = rttCameraNode_->CreateComponent<Camera>();
camera->SetFarClip(100.0f);
// Create a point light to the camera scene node
Light* light = rttCameraNode_->CreateComponent<Light>();
light->SetLightType(LIGHT_POINT);
light->SetRange(30.0f);
}
{
// Create the scene in which we move around
scene_ = new Scene(context_);
// Create octree, use also default volume (-1000, -1000, -1000) to (1000, 1000, 1000)
scene_->CreateComponent<Octree>();
// Create a Zone component for ambient lighting & fog control
Node* zoneNode = scene_->CreateChild("Zone");
Zone* zone = zoneNode->CreateComponent<Zone>();
zone->SetBoundingBox(BoundingBox(-1000.0f, 1000.0f));
zone->SetAmbientColor(Color(0.1f, 0.1f, 0.1f));
zone->SetFogStart(100.0f);
zone->SetFogEnd(300.0f);
// Create a directional light without shadows
Node* lightNode = scene_->CreateChild("DirectionalLight");
lightNode->SetDirection(Vector3(0.5f, -1.0f, 0.5f));
Light* light = lightNode->CreateComponent<Light>();
light->SetLightType(LIGHT_DIRECTIONAL);
light->SetColor(Color(0.2f, 0.2f, 0.2f));
light->SetSpecularIntensity(1.0f);
// Create a "floor" consisting of several tiles
for (int y = -5; y <= 5; ++y)
{
for (int x = -5; x <= 5; ++x)
{
Node* floorNode = scene_->CreateChild("FloorTile");
floorNode->SetPosition(Vector3(x * 20.5f, -0.5f, y * 20.5f));
floorNode->SetScale(Vector3(20.0f, 1.0f, 20.f));
StaticModel* floorObject = floorNode->CreateComponent<StaticModel>();
floorObject->SetModel(cache->GetResource<Model>("Models/Box.mdl"));
floorObject->SetMaterial(cache->GetResource<Material>("Materials/Stone.xml"));
}
}
// Create a "screen" like object for viewing the second scene. Construct it from two StaticModels, a box for the frame
// and a plane for the actual view
{
Node* boxNode = scene_->CreateChild("ScreenBox");
boxNode->SetPosition(Vector3(0.0f, 10.0f, 0.0f));
boxNode->SetScale(Vector3(21.0f, 16.0f, 0.5f));
StaticModel* boxObject = boxNode->CreateComponent<StaticModel>();
boxObject->SetModel(cache->GetResource<Model>("Models/Box.mdl"));
boxObject->SetMaterial(cache->GetResource<Material>("Materials/Stone.xml"));
Node* screenNode = scene_->CreateChild("Screen");
screenNode->SetPosition(Vector3(0.0f, 10.0f, -0.27f));
screenNode->SetRotation(Quaternion(-90.0f, 0.0f, 0.0f));
screenNode->SetScale(Vector3(20.0f, 0.0f, 15.0f));
StaticModel* screenObject = screenNode->CreateComponent<StaticModel>();
screenObject->SetModel(cache->GetResource<Model>("Models/Plane.mdl"));
// Create a renderable texture (1024x768, RGB format), enable bilinear filtering on it
SharedPtr<Texture2D> renderTexture(new Texture2D(context_));
renderTexture->SetSize(1024, 768, Graphics::GetRGBFormat(), TEXTURE_RENDERTARGET);
renderTexture->SetFilterMode(FILTER_BILINEAR);
// Create a new material from scratch, use the diffuse unlit technique, assign the render texture
// as its diffuse texture, then assign the material to the screen plane object
SharedPtr<Material> renderMaterial(new Material(context_));
renderMaterial->SetTechnique(0, cache->GetResource<Technique>("Techniques/DiffUnlit.xml"));
renderMaterial->SetTexture(TU_DIFFUSE, renderTexture);
screenObject->SetMaterial(renderMaterial);
// Get the texture's RenderSurface object (exists when the texture has been created in rendertarget mode)
// and define the viewport for rendering the second scene, similarly as how backbuffer viewports are defined
// to the Renderer subsystem. By default the texture viewport will be updated when the texture is visible
// in the main view
RenderSurface* surface = renderTexture->GetRenderSurface();
SharedPtr<Viewport> rttViewport(new Viewport(context_, rttScene_, rttCameraNode_->GetComponent<Camera>()));
surface->SetViewport(0, rttViewport);
}
// Create the camera which we will move around. Limit far clip distance to match the fog
cameraNode_ = scene_->CreateChild("Camera");
Camera* camera = cameraNode_->CreateComponent<Camera>();
camera->SetFarClip(300.0f);
// Set an initial position for the camera scene node above the plane
cameraNode_->SetPosition(Vector3(0.0f, 7.0f, -30.0f));
}
}
void Pathfinder::newNode(PathNode* oldnode, PathfindingState& state,
unsigned int steps)
{
PathNode* newnode = new PathNode();
nodelist.push_back(newnode); // for garbage collection
newnode->state = state;
newnode->parent = oldnode;
newnode->depth = oldnode->depth + 1;
newnode->stepsfromparent = 0;
double sqrddist;
sqrddist = ((newnode->state.x - oldnode->state.x)*
(newnode->state.x - oldnode->state.x));
sqrddist += ((newnode->state.y - oldnode->state.y)*
(newnode->state.y - oldnode->state.y));
sqrddist += ((newnode->state.z - oldnode->state.z)*
(newnode->state.z - oldnode->state.z));
unsigned int dist;
dist = static_cast<unsigned int>(std::sqrt(sqrddist));
int turn = 0;
if (oldnode->depth > 0) {
turn = state.direction - oldnode->state.direction;
if (turn < 0) turn = -turn;
if (turn > 4) turn = 8 - turn;
}
newnode->cost = oldnode->cost + dist + 32*turn; //!! constant
bool done = checkTarget(newnode);
if (done)
newnode->heuristicTotalCost = 0;
else
costHeuristic(newnode);
#if 0
perr << "trying dir " << state.direction;
if (steps > 0) {
perr << ", " << steps << " steps";
}
perr << " from ("
<< oldnode->state.x << "," << oldnode->state.y << ") to ("
<< newnode->state.x << "," << newnode->state.y
<< "), cost = " << newnode->cost << ", heurtotcost = "
<< newnode->heuristicTotalCost << std::endl;
#endif
#ifdef DEBUG
if (actor->getObjId() == visualdebug_actor) {
RenderSurface* screen = GUIApp::get_instance()->getScreen();
screen->BeginPainting();
drawpath(newnode, 0xFFFFFF00, done);
screen->EndPainting();
SDL_Delay(250);
if (!done) {
screen->BeginPainting();
drawpath(newnode, 0xFFB0B000, done);
screen->EndPainting();
}
}
#endif
nodes.push(newnode);
}
static osgViewer::View* load(const std::string& file, const osgDB::ReaderWriter::Options* /*option*/)
{
osg::ref_ptr<CameraConfig> config = new CameraConfig;
//std::cout << "Parse file " << file << std::endl;
config->parseFile(file);
RenderSurface* rs = 0;
Camera* cm = 0;
std::map<RenderSurface*,osg::ref_ptr<osg::GraphicsContext> > surfaces;
osg::ref_ptr<osgViewer::View> _view = new osgViewer::View;
if (config->getNumberOfCameras()==1)
{
cm = config->getCamera(0);
rs = cm->getRenderSurface();
if (rs->getDrawableType() != osgProducer::RenderSurface::DrawableType_Window) return 0;
osg::ref_ptr<const osg::GraphicsContext::Traits> traits;
osg::ref_ptr<osg::GraphicsContext> gc;
if (surfaces.find(rs) != surfaces.end())
{
gc = surfaces[rs];
traits = gc.valid() ? gc->getTraits() : 0;
}
else
{
osg::GraphicsContext::Traits* newtraits = buildTrait(*rs);
#if 0
osg::GraphicsContext::ScreenIdentifier si;
si.readDISPLAY();
if (si.displayNum>=0) newtraits->displayNum = si.displayNum;
if (si.screenNum>=0) newtraits->screenNum = si.screenNum;
#endif
gc = osg::GraphicsContext::createGraphicsContext(newtraits);
surfaces[rs] = gc.get();
traits = gc.valid() ? gc->getTraits() : 0;
}
// std::cout << rs->getWindowName() << " " << rs->getWindowOriginX() << " " << rs->getWindowOriginY() << " " << rs->getWindowWidth() << " " << rs->getWindowHeight() << std::endl;
if (gc.valid())
{
OSG_INFO<<" GraphicsWindow has been created successfully."<<std::endl;
osg::ref_ptr<osg::Camera> camera = _view->getCamera();
camera->setGraphicsContext(gc.get());
int x,y;
unsigned int width,height;
cm->applyLens();
cm->getProjectionRectangle(x, y, width, height);
camera->setViewport(new osg::Viewport(x, y, width, height));
GLenum buffer = traits->doubleBuffer ? GL_BACK : GL_FRONT;
camera->setDrawBuffer(buffer);
camera->setReadBuffer(buffer);
camera->setProjectionMatrix(osg::Matrixd(cm->getProjectionMatrix()));
camera->setViewMatrix(osg::Matrixd(cm->getPositionAndAttitudeMatrix()));
#if 0
std::cout << "Matrix Projection " << projection << std::endl;
std::cout << "Matrix Projection master " << _view->getCamera()->getProjectionMatrix() << std::endl;
// will work only if it's a post multyply in the producer camera
std::cout << "Matrix View " << view << std::endl;
std::cout << _view->getCamera()->getProjectionMatrix() * offsetProjection << std::endl;
#endif
}
else
{
OSG_INFO<<" GraphicsWindow has not been created successfully."<<std::endl;
return 0;
}
}
else
{
for (int i = 0; i < (int)config->getNumberOfCameras(); i++)
{
cm = config->getCamera(i);
rs = cm->getRenderSurface();
if (rs->getDrawableType() != osgProducer::RenderSurface::DrawableType_Window)
continue;
osg::ref_ptr<const osg::GraphicsContext::Traits> traits;
osg::ref_ptr<osg::GraphicsContext> gc;
if (surfaces.find(rs) != surfaces.end())
{
gc = surfaces[rs];
traits = gc.valid() ? gc->getTraits() : 0;
}
else
{
osg::GraphicsContext::Traits* newtraits = buildTrait(*rs);
#if 0
osg::GraphicsContext::ScreenIdentifier si;
si.readDISPLAY();
if (si.displayNum>=0) newtraits->displayNum = si.displayNum;
if (si.screenNum>=0) newtraits->screenNum = si.screenNum;
#endif
gc = osg::GraphicsContext::createGraphicsContext(newtraits);
surfaces[rs] = gc.get();
traits = gc.valid() ? gc->getTraits() : 0;
}
// std::cout << rs->getWindowName() << " " << rs->getWindowOriginX() << " " << rs->getWindowOriginY() << " " << rs->getWindowWidth() << " " << rs->getWindowHeight() << std::endl;
if (gc.valid())
{
OSG_INFO<<" GraphicsWindow has been created successfully."<<std::endl;
osg::ref_ptr<osg::Camera> camera = new osg::Camera;
camera->setGraphicsContext(gc.get());
int x,y;
unsigned int width,height;
cm->applyLens();
cm->getProjectionRectangle(x, y, width, height);
camera->setViewport(new osg::Viewport(x, y, width, height));
GLenum buffer = traits->doubleBuffer ? GL_BACK : GL_FRONT;
camera->setDrawBuffer(buffer);
camera->setReadBuffer(buffer);
osg::Matrix projection(cm->getProjectionMatrix());
osg::Matrix offset = osg::Matrix::identity();
cm->setViewByMatrix(offset);
osg::Matrix view = osg::Matrix(cm->getPositionAndAttitudeMatrix());
// setup projection from parent
osg::Matrix offsetProjection = osg::Matrix::inverse(_view->getCamera()->getProjectionMatrix()) * projection;
_view->addSlave(camera.get(), offsetProjection, view);
#if 0
std::cout << "Matrix Projection " << projection << std::endl;
std::cout << "Matrix Projection master " << _view->getCamera()->getProjectionMatrix() << std::endl;
// will work only if it's a post multyply in the producer camera
std::cout << "Matrix View " << view << std::endl;
std::cout << _view->getCamera()->getProjectionMatrix() * offsetProjection << std::endl;
#endif
}
else
{
OSG_INFO<<" GraphicsWindow has not been created successfully."<<std::endl;
return 0;
}
}
}
// std::cout << "done" << std::endl;
return _view.release();
}
void GameMapGump::ConCmd_dumpMap(const Console::ArgvType &)
{
// We only support 32 bits per pixel for now
if (RenderSurface::format.s_bpp != 32) return;
// Save because we're going to potentially break the game by enlarging
// the fast area and available object IDs.
std::string savefile = "@save/dumpmap";
GUIApp::get_instance()->saveGame(savefile, "Pre-dumpMap save");
// Increase number of available object IDs.
ObjectManager::get_instance()->allow64kObjects();
// Actual size
sint32 awidth = 8192;
sint32 aheight = 8192;
sint32 xpos = 0;
sint32 ypos = 0;
sint32 left = 16384;
sint32 right = -16384;
sint32 top = 16384;
sint32 bot = -16384;
sint32 camheight = 256;
// Work out the map limit we do this very coarsly
// Now render the map
for (sint32 y = 0; y < 64; y++)
{
for (sint32 x = 0; x < 64; x++)
{
const std::list<Item *> *list =
World::get_instance()->getCurrentMap()->getItemList(x,y);
// Should iterate the items!
// (items could extend outside of this chunk and they have height)
if (list && list->size() != 0)
{
sint32 l = (x*512 - y*512)/4 - 128;
sint32 r = (x*512 - y*512)/4 + 128;
sint32 t = (x*512 + y*512)/8 - 256;
sint32 b = (x*512 + y*512)/8;
t -= 256; // approx. adjustment for height of items in chunk
if (l < left) left = l;
if (r > right) right = r;
if (t < top) top = t;
if (b > bot) bot = b;
}
}
}
if (right == -16384) return;
// camera height
bot += camheight;
top += camheight;
awidth = right-left;
aheight = bot-top;
ypos = top;
xpos = left;
// Buffer Size
sint32 bwidth = awidth;
sint32 bheight = 256;
// Tile size
sint32 twidth = bwidth/8;
sint32 theight = bheight;
GameMapGump* g = new GameMapGump(0, 0, twidth, theight);
// HACK: Setting both INVISIBLE and TRANSPARENT flags on the Avatar
// will make him completely invisible.
getMainActor()->setFlag(Item::FLG_INVISIBLE);
getMainActor()->setExtFlag(Item::EXT_TRANSPARENT);
World::get_instance()->getCurrentMap()->setWholeMapFast();
RenderSurface* s = RenderSurface::CreateSecondaryRenderSurface(bwidth,
bheight);
Texture* t = s->GetSurfaceAsTexture();
// clear buffer
std::memset(t->buffer, 0, 4*bwidth*bheight);
// Write tga header
std::string filename = "@home/mapdump";
char buf[32];
sprintf(buf, "%02d", World::get_instance()->getCurrentMap()->getNum());
filename += buf;
filename += ".png";
ODataSource *ds = FileSystem::get_instance()->WriteFile(filename);
std::string pngcomment = "Map ";
pngcomment += buf;
pngcomment += ", dumped by Pentagram.";
PNGWriter* pngw = new PNGWriter(ds);
pngw->init(awidth, aheight, pngcomment);
// Now render the map
for (sint32 y = 0; y < aheight; y+=theight)
{
for (sint32 x = 0; x < awidth; x+=twidth)
{
// Work out 'effective' and world coords
sint32 ex = xpos+x+twidth/2;
sint32 ey = ypos+y+theight/2;
sint32 wx = ex*2 + ey*4;
sint32 wy = ey*4 - ex*2;
s->SetOrigin(x,y%bheight);
CameraProcess::SetCameraProcess(
new CameraProcess(wx+4*camheight, wy+4*camheight, camheight));
g->Paint(s, 256, false);
}
// Write out the current buffer
if (((y+theight)%bheight) == 0) {
for (int i = 0; i < bwidth*bheight; ++i) {
// Convert to correct pixel format
uint8 r, g, b;
UNPACK_RGB8(t->buffer[i],r,g,b);
uint8 *buf = reinterpret_cast<uint8*>(&t->buffer[i]);
buf[0] = b; buf[1] = g; buf[2] = r; buf[3] = 0xFF;
}
pngw->writeRows(bheight, t);
// clear buffer for next set
std::memset(t->buffer, 0, 4*bwidth*bheight);
}
}
pngw->finish();
delete pngw;
delete ds;
delete g;
delete s;
// Reload
GUIApp::get_instance()->loadGame(savefile);
pout << "Map stored in " << filename << "." << std::endl;
}
// todo: move this code to C# side.
// Renders world axis at the bottom-left corner.
static void RenderWorldAxis()
{
RenderContext* rc = RenderContext::Inst();
RenderSurface* surface = s_engineData->pRenderSurface;
LineRenderer *lr = LineRenderer::Inst();
Camera& cam = rc->Cam();
float margin = 36; // margin in pixels
float xl = 28; // axis length in pixels.
float vw = (float)surface->GetWidth();
float vh = (float)surface->GetHeight();
Matrix view = cam.View();
view.M41 = -vw/2 + margin;
view.M42 = -vh/2 + margin;
view.M43 = -xl;
float3 look = cam.CamLook();
bool perspective = !cam.IsOrtho();
// for orthographic hide one of the axis depending on view-type
const float epsilon = 0.001f; // use relatively large number for this test.
bool renderX = perspective || abs(look.x) < epsilon;
bool renderY = perspective || abs(look.y) < epsilon;
bool renderZ = perspective || abs(look.z) < epsilon;
Matrix proj = Matrix::CreateOrthographic(vw,vh,1,10000);
cam.SetViewProj(view,proj);
float3 centerV(0,0,0);
// draw x,y,z
if(renderX)
lr->DrawLine(centerV,float3(xl,0,0),float4(1,0,0,1));
if(renderY)
lr->DrawLine(centerV,float3(0,xl,0),float4(0,1,0,1));
if(renderZ)
lr->DrawLine(centerV,float3(0,0,xl),float4(0,0,1,1));
lr->RenderAll(rc);
Font* font = s_engineData->AxisFont;
if(font)
{
float fh = font->GetFontSize();
float fhh = fh /2.0f;
FontRenderer* fr = LvEdFonts::FontRenderer::Inst();
Matrix vp = view * proj;
// draw x,y,z
if(renderX)
{
float3 xpos = surface->Project(float3(xl,fhh,0),vp);
fr->DrawText(font,L"X",(int)xpos.x,(int)xpos.y,float4(1,0,0,1));
}
if(renderY)
{
float3 ypos = surface->Project(float3(0,xl+fhh,0),vp);
fr->DrawText(font,L"Y",(int)ypos.x,(int)ypos.y,float4(0,1,0,1));
}
if(renderZ)
{
float3 zpos = surface->Project(float3(0,fhh,xl),vp);
int ycoord =(int) ((zpos.y + fh) > vh ? vh - fh : zpos.y);
fr->DrawText(font,L"Z",(int)zpos.x,ycoord,float4(0,0,1,1));
}
fr->FlushPrintRequests( rc );
}
}
LVEDRENDERINGENGINE_API bool __stdcall LvEd_FrustumPick(ObjectGUID renderSurface, float viewxform[], float projxform[],float* rect, HitRecord** hits, int* count)
{
ErrorHandler::ClearError();
*hits = 0;
*count = 0;
float w = rect[2];
float h = rect[3];
if(w == 0 || h == 0)
{
return false;
}
// init camera.
Matrix view = viewxform;
Matrix proj = projxform;
RenderContext::Inst()->Cam().SetViewProj(view,proj);
// same code used for rendering.
s_engineData->pickCollector.ClearLists();
s_engineData->pickCollector.SetFlags( RenderContext::Inst()->State()->GetGlobalRenderFlags() );
s_engineData->GameLevel->GetRenderables(&s_engineData->pickCollector, RenderContext::Inst());
RenderSurface* pRenderSurface = reinterpret_cast<RenderSurface*>(renderSurface);
float3 corners[8];
float x0 = rect[0];
float y0 = rect[1];
float x1 = x0 + w;
float y1 = y0 + h;
Matrix viewProj = view * proj;
Matrix invWVP; // inverse of world view projection matrix.
s_engineData->HitRecords.clear();
float3 zeroVector(0,0,0);
Frustum fr; // frustum in local space.
for(auto it = s_engineData->pickCollector.GetList().begin(); it != s_engineData->pickCollector.GetList().end(); it++)
{
RenderableNode& r = (*it);
if(r.mesh == NULL) continue;
invWVP = r.WorldXform * viewProj;
invWVP.Invert();
corners[0] = pRenderSurface->Unproject(float3(x0,y1,0),invWVP);
corners[4] = pRenderSurface->Unproject(float3(x0,y1,1),invWVP);
corners[1] = pRenderSurface->Unproject(float3(x1,y1,0),invWVP);
corners[5] = pRenderSurface->Unproject(float3(x1,y1,1),invWVP);
corners[2] = pRenderSurface->Unproject(float3(x1,y0,0),invWVP);
corners[6] = pRenderSurface->Unproject(float3(x1,y0,1),invWVP);
corners[3] = pRenderSurface->Unproject(float3(x0,y0,0),invWVP);
corners[7] = pRenderSurface->Unproject(float3(x0,y0,1),invWVP);
fr.InitFromCorners(corners);
int test = FrustumAABBIntersect(fr,r.mesh->bounds);
if(test)
{
if(test == 1
&& r.GetFlag(RenderableNode::kTestAgainstBBoxOnly) == false
&& r.mesh != NULL
&& r.mesh->primitiveType == PrimitiveType::TriangleList)
{
Mesh* mesh = r.mesh;
Triangle tr;
bool triHit = FrustumMeshIntersect(fr,
&mesh->pos[0],
(uint32_t)mesh->pos.size(),
&mesh->indices[0],
(uint32_t)mesh->indices.size());
if( triHit == false) continue;
}
HitRecord hit;
hit.objectId = r.objectId;
hit.index = 0;
hit.hitPt = zeroVector;
hit.normal = zeroVector;
hit.nearestVertex = zeroVector;
hit.distance = 0;
hit.hasNormal = false;
hit.hasNearestVertex = false;
s_engineData->HitRecords.push_back(hit);
}
}
// return the results to the C#.
if(s_engineData->HitRecords.size() > 0)
{
*hits = &s_engineData->HitRecords[0];
*count = (int)s_engineData->HitRecords.size();
}
return *count > 0;
}
bool Pathfinder::pathfind(std::vector<PathfindingAction>& path)
{
#if 0
pout << "Actor " << actor->getObjId();
if (targetitem) {
pout << " pathfinding to item: ";
targetitem->dumpInfo();
} else {
pout << " pathfinding to (" << targetx << "," << targety << "," << targetz << ")" << std::endl;
}
#endif
#ifdef DEBUG
if (actor->getObjId() == visualdebug_actor) {
RenderSurface* screen = GUIApp::get_instance()->getScreen();
screen->BeginPainting();
if (targetitem)
drawbox(targetitem);
else
drawdot(targetx, targety, targetz, 2, 0xFF0000FF);
screen->EndPainting();
}
#endif
path.clear();
PathNode* startnode = new PathNode();
startnode->state = start;
startnode->cost = 0;
startnode->parent = 0;
startnode->depth = 0;
startnode->stepsfromparent = 0;
nodelist.push_back(startnode);
nodes.push(startnode);
unsigned int expandednodes = 0;
const unsigned int NODELIMIT_MIN = 30; //! constant
const unsigned int NODELIMIT_MAX = 200; //! constant
bool found = false;
Uint32 starttime = SDL_GetTicks();
while (expandednodes < NODELIMIT_MAX && !nodes.empty() && !found) {
PathNode* node = nodes.top(); nodes.pop();
#if 0
pout << "Trying node: (" << node->state.x << "," << node->state.y
<< "," << node->state.z << ") target=(" << targetx << ","
<< targety << "," << targetz << ")" << std::endl;
#endif
if (checkTarget(node)) {
// done!
// find path length
PathNode* n = node;
unsigned int length = 0;
while (n->parent) {
n = n->parent;
length++;
}
#if 0
pout << "Pathfinder: path found (length = " << length << ")"
<< std::endl;
#endif
unsigned int i = length;
if (length > 0) length++; // add space for final 'stand' action
path.resize(length);
// now backtrack through the nodes to assemble the final animation
while (node->parent) {
PathfindingAction action;
action.action = node->state.lastanim;
action.direction = node->state.direction;
action.steps = node->stepsfromparent;
path[--i] = action;
#if 0
pout << "anim = " << node->state.lastanim << ", dir = "
<< node->state.direction << ", steps = "
<< node->stepsfromparent << std::endl;
#endif
//TODO: check how turns work
//TODO: append final 'stand' animation
node = node->parent;
}
if (length) {
if (node->state.combat)
path[length-1].action = Animation::combatStand;
else
path[length-1].action = Animation::stand;
path[length-1].direction = path[length-2].direction;
}
expandtime = SDL_GetTicks() - starttime;
return true;
}
expandNode(node);
expandednodes++;
if(expandednodes >= NODELIMIT_MIN && ((expandednodes) % 5) == 0)
{
Uint32 elapsed_ms = SDL_GetTicks() - starttime;
if(elapsed_ms > 350) break;
}
}
expandtime = SDL_GetTicks() - starttime;
#if 0
static sint32 pfcalls = 0;
static sint32 pftotaltime = 0;
pfcalls++;
pftotaltime += expandtime;
pout << "maxout average = " << (pftotaltime / pfcalls) << "ms." << std::endl;
#endif
return false;
}
