void
COpenGLDemo::RenderScene()
{
PreRender();
Render();
PostRender();
}
void FinishAndroidFrame()
{
ProcessAndroidEvents();
RenderViews();
PostRender();
eglSwapBuffers(g_engine.display, g_engine.surface);
}
void FinishFrame()
{
RenderViews();
PostRender();
context->SwapBuffers();
context->ProcessEvents();
}
void FinishFrame()
{
RenderViews();
PostRender();
glXSwapBuffers ( display, win );
ProcessX11Events();
}
bool KCore::GameRender()
{
PreRender();
Render();
m_Timer.Render();
I_Input.Render();
DrawDebug();
PostRender();
return true;
}
void CScythe::RenderScythe( void )
{
if( m_pTex )
{
PreRender( );
DrawScythe( );
PostRender( );
}
}
void CShockWaveEffect::Render()
{
if(!PreRender())
{
return;
}
if (GetOwner() != NULL)
{ // HIDDEN 속성의 NPC의 이펙트를 보기 위해서는 캐릭터가 ENF_SHOWHIDDEN을 가지고 있어야 한다.
if (GetOwner()->IsFlagOn(ENF_HIDDEN) && (CEntity::GetPlayerEntity(0)->IsFlagOff(ENF_SHOWHIDDEN) ||
(CEntity::GetPlayerEntity(0)->IsFlagOn(ENF_SHOWHIDDEN)&&!GetOwner()->IsEnemy())))//ENF_SHOWHIDDEN이면 npc effect는 볼 수 있다.
return;
}
gfxSetBlendType(m_eBlendType);
if(m_ptdTexture != NULL)
{
gfxSetTextureUnit(0);
m_ptdTexture->SetAsCurrent();
if(RM_AreHardwareShadersAvailable())
{
gfxSetVertexProgram( m_ulVertexProgramTex );
gfxSetPixelProgram( m_ulPixelProgramTex );
}
else
{
gfxSetTextureModulation(1);
}
}
else
{
if(RM_AreHardwareShadersAvailable())
{
gfxSetVertexProgram( m_ulVertexProgramNoTex );
gfxSetPixelProgram( m_ulPixelProgramNoTex );
}
else
{
//gfxSetTextureSelectArg(0, GFX_TA_DIFFUSE, GFX_TA_DIFFUSE);
}
}
gfxSetVertexArray( &m_vectorGFXVertex[0], m_vectorGFXVertex.size() );
gfxSetColorArray( &m_vectorGFXColor[0] );
if(m_ptdTexture != NULL) gfxSetTexCoordArray( &m_vectorTexCoord[0], FALSE );
gfxDrawElements( m_iSplitCount * 2 * 3, &m_vectorIndex[0]);
if(!RM_AreHardwareShadersAvailable())
{
//gfxSetTextureSelectArg(0, GFX_TA_TEXTURE, GFX_TA_TEXTURE);
gfxSetTextureModulation(1);
}
PostRender();
}
bool CParticleSystem::RenderSystem( void )
{
// heres where we loop through the system and render it
if( TestSystem( ) )
{
// if test works update it
UpdateSystem( );
//now we loop thorugh the parts in the system and render them
Particle_s *pPart = m_pHeadPart;
int iCount = 0;
PreRender( );
while( pPart )
{
// first we need to test if the particle should still be living
Particle_s *pTmp = pPart->pNext;
if( TestPart( pPart ) )
{
UpdatePart( pPart );
if( TestVisability( pPart ) )
{
// then we should update the particle
// now draw it
RenderPart( pPart );
iCount ++;
}
}
else
{
// test show no need for particle remove it
ReturnToPool( pPart );
}
//move to the next part
pPart = pTmp;
}
// turn it off
PostRender( );
// if( iCount >= 5000 )
/*{
gEngfuncs.Con_Printf( "Parts: %i\n", iCount );
}*/
}
else
{
//we can break out system doesnt need to be around any more
return false;
}
//every thing was successfull
return true;
}
bool scene::RenderFunc(float d)
{
PreRender(d);
OBJ_LSIT_ITR itr = m_obj_list.begin();
for (; itr != m_obj_list.end();itr++)
{
(*itr)->RenderFunc(d);
}
GUIAPP_LSIT_ITR itr_gui = m_guiapp_list.begin();
for (; itr_gui != m_guiapp_list.end();itr_gui++)
{
(*itr_gui)->RenderFunc(d);
}
PostRender(d);
return TRUE;
}
void EFFECT_FIREBALL::Render()
{
PreRender();
if(billboardMesh)
{
D3DXVECTOR3 orgRot = m_t1.m_rot;
D3DXVECTOR3 rotations[] = {D3DXVECTOR3(0.0f, 0.0f, 0.0f),
D3DXVECTOR3(D3DX_PI * 0.5f, 0.0f, 0.0f),
D3DXVECTOR3(0.0f, D3DX_PI * 0.5f, 0.0f),
D3DXVECTOR3(0.0f, 0.0f, D3DX_PI * 0.5f)};
D3DXVECTOR3 orgPos = m_t1.m_pos;
D3DXVECTOR3 positions[] = {m_t1.m_pos,
GetPosition(m_prc - (1.5f / m_length)),
GetPosition(m_prc - (2.5f / m_length)),
GetPosition(m_prc - (3.25f / m_length)),
GetPosition(m_prc - (4.0f / m_length))};
D3DXVECTOR3 orgSca = m_t1.m_sca;
D3DXVECTOR3 scales[] = {m_t1.m_sca,
m_t1.m_sca * 0.8f,
m_t1.m_sca * 0.6f,
m_t1.m_sca * 0.4f,
m_t1.m_sca * 0.2f};
m_pDevice->SetTexture(0, fireballTexture);
for(int t=0;t<5;t++)
for(int i=0;i<4;i++)
{
m_t1.m_pos = positions[t];
m_t1.m_rot = orgRot + rotations[i];
m_t1.m_sca = scales[t];
effectVertexShader.SetMatrix(effectMatW, m_t1.GetWorldMatrix());
billboardMesh->DrawSubset(0);
}
m_t1.m_pos = orgPos;
m_t1.m_rot = orgRot;
m_t1.m_sca = orgSca;
}
PostRender();
}
//----------------------------------------------------------------------------
void AllegroRender::Render() {
// Pre-Render
PreRender();
// Clear screen
al_clear_to_color(al_map_rgb_f(0, 0, 0));
// Render
sceneManager->Render();
// TODO: remove me...
//al_draw_text(font, al_map_rgba_f(1, 1, 1, 0.5), 0, 0, 0, text);
// Display frame
FlipDoubleBuffer();
// Post Render
PostRender();
}
inline FTPoint FTTextureFontImpl::RenderI(const T* string, const int len,
FTPoint position, FTPoint spacing,
int renderMode)
{
disableTexture2D = false;
disableBlend = false;
FTPoint tmp;
if (preRendered)
{
tmp = FTFontImpl::Render(string, len, position, spacing, renderMode);
}
else
{
PreRender();
tmp = FTFontImpl::Render(string, len, position, spacing, renderMode);
PostRender();
}
return tmp;
}
//protected:
virtual void Render() const override {
//Debug::Log("Rendere %s", m_gameObject->name().c_str());
auto meshFilter = m_gameObject->GetComponent<MeshFilter>();
if (meshFilter == nullptr) {
Debug::LogWarning("This GameObject has no MeshFilter");
return;
}
auto model = transform()->localToWorldMatrix();
auto camera = Scene::mainCamera();
auto view = camera->worldToCameraMatrix();
auto proj = camera->projectionMatrix();
auto mv = view * model;
auto mvp = proj * mv;
ShaderUniforms uniforms;
//std::map<std::string, Matrix4x4> matrices;
uniforms.mat4s["_Object2World"] = model;
uniforms.mat4s["MATRIX_V"] = view;
uniforms.mat4s["MATRIX_P"] = proj;
uniforms.mat4s["MATRIX_VP"] = proj * view;
uniforms.mat4s["MATRIX_MVP"] = mvp;
uniforms.mat4s["MATRIX_MV"] = mv;
uniforms.mat4s["MATRIX_IT_M"] = glm::inverse(glm::transpose(model));
uniforms.mat4s["MATRIX_IT_MV"] = glm::inverse(glm::transpose(mv));
//auto camera = Scene::getMainCamera();
uniforms.vec3s["_WorldSpaceCameraPos"] = camera->transform()->position();
for (auto& m : m_materials) {
auto shader = m->shader();
shader->Use();
shader->PreRender();
shader->BindUniforms(uniforms);
m->Update();
shader->CheckStatus();
meshFilter->mesh()->Render();
shader->PostRender();
}
}
void EFFECT_SPELL::Render()
{
PreRender();
if(billboardMesh)
{
//Spinning quad
m_pDevice->SetTexture(0, runesTexture);
effectVertexShader.SetMatrix(effectMatW, m_t1.GetWorldMatrix());
billboardMesh->DrawSubset(0);
//Cloud
m_pDevice->SetTexture(0, cloudTexture);
for(int i=0;i<10;i++)
{
effectVertexShader.SetMatrix(effectMatW, m_c[i].GetWorldMatrix());
billboardMesh->DrawSubset(0);
}
}
PostRender();
}
void UOffAxisGameViewportClient::Draw(FViewport* InViewport, FCanvas* SceneCanvas)
{
//Valid SceneCanvas is required. Make this explicit.
check(SceneCanvas);
FCanvas* DebugCanvas = InViewport->GetDebugCanvas();
// Create a temporary canvas if there isn't already one.
static FName CanvasObjectName(TEXT("CanvasObject"));
UCanvas* CanvasObject = GetCanvasByName(CanvasObjectName);
CanvasObject->Canvas = SceneCanvas;
// Create temp debug canvas object
static FName DebugCanvasObjectName(TEXT("DebugCanvasObject"));
UCanvas* DebugCanvasObject = GetCanvasByName(DebugCanvasObjectName);
DebugCanvasObject->Canvas = DebugCanvas;
DebugCanvasObject->Init(InViewport->GetSizeXY().X, InViewport->GetSizeXY().Y, NULL);
const bool bScaledToRenderTarget = GEngine->HMDDevice.IsValid() && GEngine->IsStereoscopic3D(InViewport);
if (bScaledToRenderTarget)
{
// Allow HMD to modify screen settings
GEngine->HMDDevice->UpdateScreenSettings(Viewport);
}
if (DebugCanvas)
{
DebugCanvas->SetScaledToRenderTarget(bScaledToRenderTarget);
}
if (SceneCanvas)
{
SceneCanvas->SetScaledToRenderTarget(bScaledToRenderTarget);
}
bool bUIDisableWorldRendering = false;
FViewElementDrawer GameViewDrawer;
// create the view family for rendering the world scene to the viewport's render target
FSceneViewFamilyContext ViewFamily(FSceneViewFamily::ConstructionValues(
InViewport,
GetWorld()->Scene,
EngineShowFlags)
.SetRealtimeUpdate(true));
// Allow HMD to modify the view later, just before rendering
if (GEngine->HMDDevice.IsValid() && GEngine->IsStereoscopic3D(InViewport))
{
ISceneViewExtension* HmdViewExt = GEngine->HMDDevice->GetViewExtension();
if (HmdViewExt)
{
ViewFamily.ViewExtensions.Add(HmdViewExt);
HmdViewExt->ModifyShowFlags(ViewFamily.EngineShowFlags);
}
}
ESplitScreenType::Type SplitScreenConfig = GetCurrentSplitscreenConfiguration();
EngineShowFlagOverride(ESFIM_Game, (EViewModeIndex)ViewModeIndex, ViewFamily.EngineShowFlags, NAME_None, SplitScreenConfig != ESplitScreenType::None);
TMap<ULocalPlayer*, FSceneView*> PlayerViewMap;
FAudioDevice* AudioDevice = GEngine->GetAudioDevice();
bool bReverbSettingsFound = false;
FReverbSettings ReverbSettings;
class AAudioVolume* AudioVolume = nullptr;
for (FConstPlayerControllerIterator Iterator = GetWorld()->GetPlayerControllerIterator(); Iterator; ++Iterator)
{
APlayerController* PlayerController = *Iterator;
if (PlayerController)
{
ULocalPlayer* LocalPlayer = Cast<ULocalPlayer>(PlayerController->Player);
if (LocalPlayer)
{
const bool bEnableStereo = GEngine->IsStereoscopic3D(InViewport);
int32 NumViews = bEnableStereo ? 2 : 1;
for (int i = 0; i < NumViews; ++i)
{
// Calculate the player's view information.
FVector ViewLocation;
FRotator ViewRotation;
EStereoscopicPass PassType = !bEnableStereo ? eSSP_FULL : ((i == 0) ? eSSP_LEFT_EYE : eSSP_RIGHT_EYE);
FSceneView* View = LocalPlayer->CalcSceneView(&ViewFamily, ViewLocation, ViewRotation, InViewport, &GameViewDrawer, PassType);
if (mOffAxisMatrixSetted)
UpdateProjectionMatrix(View, mOffAxisMatrix);
if (View)
{
if (View->Family->EngineShowFlags.Wireframe)
{
// Wireframe color is emissive-only, and mesh-modifying materials do not use material substitution, hence...
View->DiffuseOverrideParameter = FVector4(0.f, 0.f, 0.f, 0.f);
View->SpecularOverrideParameter = FVector4(0.f, 0.f, 0.f, 0.f);
}
else if (View->Family->EngineShowFlags.OverrideDiffuseAndSpecular)
{
View->DiffuseOverrideParameter = FVector4(GEngine->LightingOnlyBrightness.R, GEngine->LightingOnlyBrightness.G, GEngine->LightingOnlyBrightness.B, 0.0f);
View->SpecularOverrideParameter = FVector4(.1f, .1f, .1f, 0.0f);
}
else if (View->Family->EngineShowFlags.ReflectionOverride)
{
View->DiffuseOverrideParameter = FVector4(0.f, 0.f, 0.f, 0.f);
View->SpecularOverrideParameter = FVector4(1, 1, 1, 0.0f);
View->NormalOverrideParameter = FVector4(0, 0, 1, 0.0f);
View->RoughnessOverrideParameter = FVector2D(0.0f, 0.0f);
}
if (!View->Family->EngineShowFlags.Diffuse)
{
View->DiffuseOverrideParameter = FVector4(0.f, 0.f, 0.f, 0.f);
}
if (!View->Family->EngineShowFlags.Specular)
{
View->SpecularOverrideParameter = FVector4(0.f, 0.f, 0.f, 0.f);
}
View->CameraConstrainedViewRect = View->UnscaledViewRect;
// If this is the primary drawing pass, update things that depend on the view location
if (i == 0)
{
// Save the location of the view.
LocalPlayer->LastViewLocation = ViewLocation;
PlayerViewMap.Add(LocalPlayer, View);
// Update the listener.
if (AudioDevice != NULL)
{
FVector Location;
FVector ProjFront;
FVector ProjRight;
PlayerController->GetAudioListenerPosition(/*out*/ Location, /*out*/ ProjFront, /*out*/ ProjRight);
FTransform ListenerTransform(FRotationMatrix::MakeFromXY(ProjFront, ProjRight));
ListenerTransform.SetTranslation(Location);
ListenerTransform.NormalizeRotation();
bReverbSettingsFound = true;
FReverbSettings PlayerReverbSettings;
FInteriorSettings PlayerInteriorSettings;
class AAudioVolume* PlayerAudioVolume = GetWorld()->GetAudioSettings(Location, &PlayerReverbSettings, &PlayerInteriorSettings);
if (AudioVolume == nullptr || (PlayerAudioVolume != nullptr && PlayerAudioVolume->Priority > AudioVolume->Priority))
{
AudioVolume = PlayerAudioVolume;
ReverbSettings = PlayerReverbSettings;
}
uint32 ViewportIndex = PlayerViewMap.Num() - 1;
AudioDevice->SetListener(ViewportIndex, ListenerTransform, (View->bCameraCut ? 0.f : GetWorld()->GetDeltaSeconds()), PlayerAudioVolume, PlayerInteriorSettings);
}
}
// Add view information for resource streaming.
IStreamingManager::Get().AddViewInformation(View->ViewMatrices.ViewOrigin, View->ViewRect.Width(), View->ViewRect.Width() * View->ViewMatrices.ProjMatrix.M[0][0]);
GetWorld()->ViewLocationsRenderedLastFrame.Add(View->ViewMatrices.ViewOrigin);
}
}
}
}
}
if (bReverbSettingsFound)
{
AudioDevice->SetReverbSettings(AudioVolume, ReverbSettings);
}
// Update level streaming.
GetWorld()->UpdateLevelStreaming();
// Draw the player views.
if (!bDisableWorldRendering && !bUIDisableWorldRendering && PlayerViewMap.Num() > 0)
{
GetRendererModule().BeginRenderingViewFamily(SceneCanvas, &ViewFamily);
}
// Clear areas of the rendertarget (backbuffer) that aren't drawn over by the views.
{
// Find largest rectangle bounded by all rendered views.
uint32 MinX = InViewport->GetSizeXY().X, MinY = InViewport->GetSizeXY().Y, MaxX = 0, MaxY = 0;
uint32 TotalArea = 0;
for (int32 ViewIndex = 0; ViewIndex < ViewFamily.Views.Num(); ++ViewIndex)
{
const FSceneView* View = ViewFamily.Views[ViewIndex];
FIntRect UpscaledViewRect = View->UnscaledViewRect;
MinX = FMath::Min<uint32>(UpscaledViewRect.Min.X, MinX);
MinY = FMath::Min<uint32>(UpscaledViewRect.Min.Y, MinY);
MaxX = FMath::Max<uint32>(UpscaledViewRect.Max.X, MaxX);
MaxY = FMath::Max<uint32>(UpscaledViewRect.Max.Y, MaxY);
TotalArea += FMath::TruncToInt(UpscaledViewRect.Width()) * FMath::TruncToInt(UpscaledViewRect.Height());
}
// To draw black borders around the rendered image (prevents artifacts from post processing passes that read outside of the image e.g. PostProcessAA)
{
int32 BlackBorders = 0; // FMath::Clamp(CVarSetBlackBordersEnabled.GetValueOnGameThread(), 0, 10);
if (ViewFamily.Views.Num() == 1 && BlackBorders)
{
MinX += BlackBorders;
MinY += BlackBorders;
MaxX -= BlackBorders;
MaxY -= BlackBorders;
TotalArea = (MaxX - MinX) * (MaxY - MinY);
}
}
// If the views don't cover the entire bounding rectangle, clear the entire buffer.
if (ViewFamily.Views.Num() == 0 || TotalArea != (MaxX - MinX)*(MaxY - MinY) || bDisableWorldRendering)
{
SceneCanvas->DrawTile(0, 0, InViewport->GetSizeXY().X, InViewport->GetSizeXY().Y, 0.0f, 0.0f, 1.0f, 1.f, FLinearColor::Black, NULL, false);
}
else
{
// clear left
if (MinX > 0)
{
SceneCanvas->DrawTile(0, 0, MinX, InViewport->GetSizeXY().Y, 0.0f, 0.0f, 1.0f, 1.f, FLinearColor::Black, NULL, false);
}
// clear right
if (MaxX < (uint32)InViewport->GetSizeXY().X)
{
SceneCanvas->DrawTile(MaxX, 0, InViewport->GetSizeXY().X, InViewport->GetSizeXY().Y, 0.0f, 0.0f, 1.0f, 1.f, FLinearColor::Black, NULL, false);
}
// clear top
if (MinY > 0)
{
SceneCanvas->DrawTile(MinX, 0, MaxX, MinY, 0.0f, 0.0f, 1.0f, 1.f, FLinearColor::Black, NULL, false);
}
// clear bottom
if (MaxY < (uint32)InViewport->GetSizeXY().Y)
{
SceneCanvas->DrawTile(MinX, MaxY, MaxX, InViewport->GetSizeXY().Y, 0.0f, 0.0f, 1.0f, 1.f, FLinearColor::Black, NULL, false);
}
}
}
// Remove temporary debug lines.
if (GetWorld()->LineBatcher != NULL)
{
GetWorld()->LineBatcher->Flush();
}
if (GetWorld()->ForegroundLineBatcher != NULL)
{
GetWorld()->ForegroundLineBatcher->Flush();
}
// Draw FX debug information.
if (GetWorld()->FXSystem)
{
GetWorld()->FXSystem->DrawDebug(SceneCanvas);
}
// Render the UI.
{
//SCOPE_CYCLE_COUNTER(STAT_UIDrawingTime);
// render HUD
bool bDisplayedSubtitles = false;
for (FConstPlayerControllerIterator Iterator = GetWorld()->GetPlayerControllerIterator(); Iterator; ++Iterator)
{
APlayerController* PlayerController = *Iterator;
if (PlayerController)
{
ULocalPlayer* LocalPlayer = Cast<ULocalPlayer>(PlayerController->Player);
if (LocalPlayer)
{
FSceneView* View = PlayerViewMap.FindRef(LocalPlayer);
if (View != NULL)
{
// rendering to directly to viewport target
FVector CanvasOrigin(FMath::TruncToFloat(View->UnscaledViewRect.Min.X), FMath::TruncToInt(View->UnscaledViewRect.Min.Y), 0.f);
CanvasObject->Init(View->UnscaledViewRect.Width(), View->UnscaledViewRect.Height(), View);
// Set the canvas transform for the player's view rectangle.
SceneCanvas->PushAbsoluteTransform(FTranslationMatrix(CanvasOrigin));
CanvasObject->ApplySafeZoneTransform();
// Render the player's HUD.
if (PlayerController->MyHUD)
{
//SCOPE_CYCLE_COUNTER(STAT_HudTime);
DebugCanvasObject->SceneView = View;
PlayerController->MyHUD->SetCanvas(CanvasObject, DebugCanvasObject);
if (GEngine->IsStereoscopic3D(InViewport))
{
check(GEngine->StereoRenderingDevice.IsValid());
GEngine->StereoRenderingDevice->PushViewportCanvas(eSSP_LEFT_EYE, SceneCanvas, CanvasObject, Viewport);
PlayerController->MyHUD->PostRender();
SceneCanvas->PopTransform();
GEngine->StereoRenderingDevice->PushViewportCanvas(eSSP_RIGHT_EYE, SceneCanvas, CanvasObject, Viewport);
PlayerController->MyHUD->PostRender();
SceneCanvas->PopTransform();
// Reset the canvas for rendering to the full viewport.
CanvasObject->Reset();
CanvasObject->SizeX = View->UnscaledViewRect.Width();
CanvasObject->SizeY = View->UnscaledViewRect.Height();
CanvasObject->SetView(NULL);
CanvasObject->Update();
}
else
{
PlayerController->MyHUD->PostRender();
}
// Put these pointers back as if a blueprint breakpoint hits during HUD PostRender they can
// have been changed
CanvasObject->Canvas = SceneCanvas;
DebugCanvasObject->Canvas = DebugCanvas;
// A side effect of PostRender is that the playercontroller could be destroyed
if (!PlayerController->IsPendingKill())
{
PlayerController->MyHUD->SetCanvas(NULL, NULL);
}
}
if (DebugCanvas != NULL)
{
DebugCanvas->PushAbsoluteTransform(FTranslationMatrix(CanvasOrigin));
UDebugDrawService::Draw(ViewFamily.EngineShowFlags, InViewport, View, DebugCanvas);
DebugCanvas->PopTransform();
}
CanvasObject->PopSafeZoneTransform();
SceneCanvas->PopTransform();
// draw subtitles
if (!bDisplayedSubtitles)
{
FVector2D MinPos(0.f, 0.f);
FVector2D MaxPos(1.f, 1.f);
GetSubtitleRegion(MinPos, MaxPos);
uint32 SizeX = SceneCanvas->GetRenderTarget()->GetSizeXY().X;
uint32 SizeY = SceneCanvas->GetRenderTarget()->GetSizeXY().Y;
FIntRect SubtitleRegion(FMath::TruncToInt(SizeX * MinPos.X), FMath::TruncToInt(SizeY * MinPos.Y), FMath::TruncToInt(SizeX * MaxPos.X), FMath::TruncToInt(SizeY * MaxPos.Y));
// We need a world to do this
FSubtitleManager::GetSubtitleManager()->DisplaySubtitles(SceneCanvas, SubtitleRegion, GetWorld()->GetAudioTimeSeconds());
}
}
}
}
}
//ensure canvas has been flushed before rendering UI
SceneCanvas->Flush_GameThread();
if (DebugCanvas != NULL)
{
DebugCanvas->Flush_GameThread();
}
// Allow the viewport to render additional stuff
PostRender(DebugCanvasObject);
// Render the console.
if (ViewportConsole)
{
if (GEngine->IsStereoscopic3D(InViewport))
{
GEngine->StereoRenderingDevice->PushViewportCanvas(eSSP_LEFT_EYE, DebugCanvas, DebugCanvasObject, Viewport);
ViewportConsole->PostRender_Console(DebugCanvasObject);
#if !UE_BUILD_SHIPPING
if (DebugCanvas != NULL && GEngine->HMDDevice.IsValid())
{
GEngine->HMDDevice->DrawDebug(DebugCanvasObject, eSSP_LEFT_EYE);
}
#endif
DebugCanvas->PopTransform();
GEngine->StereoRenderingDevice->PushViewportCanvas(eSSP_RIGHT_EYE, DebugCanvas, DebugCanvasObject, Viewport);
ViewportConsole->PostRender_Console(DebugCanvasObject);
#if !UE_BUILD_SHIPPING
if (DebugCanvas != NULL && GEngine->HMDDevice.IsValid())
{
GEngine->HMDDevice->DrawDebug(DebugCanvasObject, eSSP_RIGHT_EYE);
}
#endif
DebugCanvas->PopTransform();
// Reset the canvas for rendering to the full viewport.
DebugCanvasObject->Reset();
DebugCanvasObject->SizeX = Viewport->GetSizeXY().X;
DebugCanvasObject->SizeY = Viewport->GetSizeXY().Y;
DebugCanvasObject->SetView(NULL);
DebugCanvasObject->Update();
}
else
{
ViewportConsole->PostRender_Console(DebugCanvasObject);
}
}
}
// Grab the player camera location and orientation so we can pass that along to the stats drawing code.
FVector PlayerCameraLocation = FVector::ZeroVector;
FRotator PlayerCameraRotation = FRotator::ZeroRotator;
{
for (FConstPlayerControllerIterator Iterator = GetWorld()->GetPlayerControllerIterator(); Iterator; ++Iterator)
{
(*Iterator)->GetPlayerViewPoint(PlayerCameraLocation, PlayerCameraRotation);
}
}
if (GEngine->IsStereoscopic3D(InViewport))
{
GEngine->StereoRenderingDevice->PushViewportCanvas(eSSP_LEFT_EYE, DebugCanvas, DebugCanvasObject, InViewport);
DrawStatsHUD(GetWorld(), InViewport, DebugCanvas, DebugCanvasObject, DebugProperties, PlayerCameraLocation, PlayerCameraRotation);
DebugCanvas->PopTransform();
GEngine->StereoRenderingDevice->PushViewportCanvas(eSSP_RIGHT_EYE, DebugCanvas, DebugCanvasObject, InViewport);
DrawStatsHUD(GetWorld(), InViewport, DebugCanvas, DebugCanvasObject, DebugProperties, PlayerCameraLocation, PlayerCameraRotation);
DebugCanvas->PopTransform();
// Reset the canvas for rendering to the full viewport.
DebugCanvasObject->Reset();
DebugCanvasObject->SizeX = Viewport->GetSizeXY().X;
DebugCanvasObject->SizeY = Viewport->GetSizeXY().Y;
DebugCanvasObject->SetView(NULL);
DebugCanvasObject->Update();
#if !UE_BUILD_SHIPPING
if (GEngine->HMDDevice.IsValid())
{
GEngine->HMDDevice->DrawDebug(DebugCanvasObject, eSSP_FULL);
}
#endif
}
else
{
DrawStatsHUD(GetWorld(), InViewport, DebugCanvas, DebugCanvasObject, DebugProperties, PlayerCameraLocation, PlayerCameraRotation);
}
}
void MainHost::SetupGroupContainer()
{
if(!groupContainer.isNull()) {
mainContainer->ParkObject( groupContainer );
groupContainer.clear();
UpdateSolver(true);
if(mainWindow)
mainWindow->mySceneView->viewGroup->ClearViewPrograms();
}
ObjectInfo info;
info.nodeType = NodeType::container;
info.objType = ObjType::Container;
info.name = "groupContainer";
info.forcedObjId = FixedObjId::groupContainer;
groupContainer = objFactory->NewObject(info).staticCast<Connectables::Container>();
if(groupContainer.isNull())
return;
groupContainer->SetLoadingMode(true);
groupContainer->LoadProgram(0);
mainContainer->AddObject(groupContainer);
QSharedPointer<Connectables::Object> bridge;
//bridge in
ObjectInfo in;
in.name="in";
in.nodeType = NodeType::bridge;
in.objType = ObjType::BridgeIn;
in.forcedObjId = FixedObjId::groupContainerIn;
bridge = objFactory->NewObject(in);
groupContainer->AddObject( bridge );
bridge->SetBridgePinsInVisible(false);
groupContainer->bridgeIn = bridge;
//bridge out
ObjectInfo out;
out.name="out";
out.nodeType = NodeType::bridge;
out.objType = ObjType::BridgeOut;
out.forcedObjId = FixedObjId::groupContainerOut;
bridge = objFactory->NewObject(out);
groupContainer->AddObject( bridge );
bridge->SetBridgePinsOutVisible(false);
groupContainer->bridgeOut = bridge;
//connect with programContainer
if(!programContainer.isNull()) {
mainContainer->ConnectObjects(programContainer->bridgeSend, groupContainer->bridgeIn,true);
mainContainer->ConnectObjects(groupContainer->bridgeOut, programContainer->bridgeReturn,true);
}
//bridge send
ObjectInfo send;
send.name="send";
send.nodeType = NodeType::bridge;
send.objType = ObjType::BridgeSend;
send.forcedObjId = FixedObjId::groupContainerSend;
bridge = objFactory->NewObject(send);
groupContainer->AddObject( bridge );
bridge->SetBridgePinsOutVisible(false);
groupContainer->bridgeSend = bridge;
//bridge return
ObjectInfo retrn;
retrn.name="return";
retrn.nodeType = NodeType::bridge;
retrn.objType = ObjType::BridgeReturn;
retrn.forcedObjId = FixedObjId::groupContainerReturn;
bridge = objFactory->NewObject(retrn);
groupContainer->AddObject( bridge );
bridge->SetBridgePinsInVisible(false);
groupContainer->bridgeReturn = bridge;
//connect with hostContainer
if(!hostContainer.isNull()) {
mainContainer->ConnectObjects(groupContainer->bridgeSend, hostContainer->bridgeIn,true);
mainContainer->ConnectObjects(hostContainer->bridgeOut, groupContainer->bridgeReturn,true);
}
connect(programsModel, SIGNAL(GroupChanged(QModelIndex)),
groupContainer.data(), SLOT(SetProgram(QModelIndex)));
connect(programsModel, SIGNAL(GroupDelete(QModelIndex)),
groupContainer.data(), SLOT(RemoveProgram(QModelIndex)));
connect(this,SIGNAL(Rendered()),
groupContainer.data(), SLOT(PostRender()));
emit groupParkingModelChanged(&groupContainer->parkModel);
if(projectContainer)
projectContainer->childContainer=groupContainer;
if(programContainer) {
groupContainer->childContainer=programContainer;
programContainer->parentContainer=groupContainer;
}
groupContainer->SetLoadingMode(false);
groupContainer->UpdateModificationTime();
SetSolverUpdateNeeded();
}
bool RenderThread::Run()
{
DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Run\n");
// Install a function for logging
mEnvironmentOptions.InstallLogFunction();
InitializeEgl();
Dali::Integration::RenderStatus renderStatus;
RenderRequest* request = NULL;
// Render loop, we stay inside here when rendering
while( mThreadSynchronization.RenderReady( request ) )
{
DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Run. 1 - RenderReady\n");
// Consume any pending events to avoid memory leaks
DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Run. 2 - ConsumeEvents\n");
mDisplayConnection->ConsumeEvents();
// Check if we've got a request from the main thread (e.g. replace surface)
if( request )
{
// Process the request, we should NOT render when we have a request
DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Run. 3 - Process requests\n");
ProcessRequest( request );
}
else
{
// No request to process so we render
if( PreRender() ) // Returns false if no surface onto which to render
{
// Render
DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Run. 3 - Core.Render()\n");
mThreadSynchronization.AddPerformanceMarker( PerformanceInterface::RENDER_START );
mCore.Render( renderStatus );
mThreadSynchronization.AddPerformanceMarker( PerformanceInterface::RENDER_END );
// Decrement the count of how far update is ahead of render
mThreadSynchronization.RenderFinished();
// Perform any post-render operations
if ( renderStatus.HasRendered() )
{
DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Run. 4 - PostRender()\n");
PostRender();
}
}
}
request = NULL; // Clear the request if it was set, no need to release memory
}
// Shut down EGL
ShutdownEgl();
// Uninstall the logging function
mEnvironmentOptions.UnInstallLogFunction();
return true;
}
ActorId ActorPicker::VPick(void)
{
Render();
PostRender();
return m_currentActor;
}
bool TDxObject::Render(ID3D11DeviceContext* pContext, UINT iVertexSize, UINT iCount)
{
PreRender(pContext, iVertexSize);
PostRender(pContext, iCount);
return true;
}
LRESULT CALLBACK C3DCoordinateAxisMain::WndProc(HWND hWnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
TCHAR log[256]= {0,};
//std::string info;
HDC hdc;
PAINTSTRUCT ps;
//POINT pt;
switch(iMsg)
{
case WM_TIMER:
Update();
return 0;
case WM_LBUTTONDOWN:
{
POINT pt = {LOWORD(lParam), HIWORD(lParam)};
if( m_clickCnt < CLICK_MAX )
{
m_clickVecPt[m_clickCnt].x = pt.x - WIN_WIDTH/2;
m_clickVecPt[m_clickCnt].y = WIN_HEIGHT/2 - pt.y;
m_clickVecPt[m_clickCnt].z = 0;
m_clickCnt++;
if(m_clickCnt == CLICK_MAX)
{
VECTOR tempVec[2];
for (UINT i = 0 ; i < m_clickCnt ; i++ )
{
D3DVecNormalize( &tempVec[i], &m_clickVecPt[i]);
}
//cos0
float cos = D3DVecDot( &tempVec[0], &tempVec[1] );
//각도로 변경
degree = acosf(cos)*180/PI;
//외적
D3DVecCross(&m_crossVec, &tempVec[0], &tempVec[1]);
D3DVecNormalize( &m_crossVec, &m_crossVec );
}
}
}
return 0;
case WM_RBUTTONDOWN:
if(m_clickCnt > 0)
{
m_clickCnt--;
}
return 0;
case WM_PAINT:
{
hdc = BeginPaint(hWnd,&ps);
PreRender(hdc);
Render(m_hMemDc);
PostRender(hdc);
EndPaint(hWnd,&ps);
}
return 0;
case WM_KEYDOWN:
switch(wParam)
{
case VK_ESCAPE:
PostQuitMessage(0);
UnregisterTimer();
break;
}
break;
case WM_DESTROY:
PostQuitMessage(0);
UnregisterTimer();
return 0;
}
return DefWindowProc(hWnd, iMsg, wParam, lParam);
}
