//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
RendererImplemented::RendererImplemented( int32_t squareMaxCount )
: m_reference ( 1 )
, m_device ( NULL )
, m_context ( NULL )
, m_vertexBuffer( NULL )
, m_indexBuffer ( NULL )
, m_squareMaxCount ( squareMaxCount )
, m_coordinateSystem ( ::Effekseer::CoordinateSystem::RH )
, m_renderState ( NULL )
, m_restorationOfStates( true )
, m_shader(nullptr)
, m_shader_no_texture(nullptr)
, m_shader_distortion(nullptr)
, m_shader_no_texture_distortion(nullptr)
, m_standardRenderer(nullptr)
, m_background(nullptr)
, m_distortingCallback(nullptr)
{
::Effekseer::Vector3D direction( 1.0f, 1.0f, 1.0f );
SetLightDirection( direction );
::Effekseer::Color lightColor( 255, 255, 255, 255 );
SetLightColor( lightColor );
::Effekseer::Color lightAmbient( 0, 0, 0, 0 );
SetLightAmbientColor( lightAmbient );
m_state = new OriginalState();
#ifdef __EFFEKSEER_RENDERER_INTERNAL_LOADER__
EffekseerRenderer::PngTextureLoader::Initialize();
#endif
}
ShaderSP ShaderToon::Create()
{
std::string xmlPath("Resources/HLSL/Toon.xml");
CWsbXmlSP xml = CWsbXml::LoadXmlFile(xmlPath);
std::string path = xml->GetElement("path")->GetString();
ShaderSP shader;
std::unordered_map<std::string, ShaderSP>::iterator it = _shaders.find(path);
// 存在したら第二要素を返す
if(it != _shaders.end())
{
shader = (*it).second;
return shader;
}
// 存在しなければ新しく生成
std::string texturePath = xml->GetElement("ToonTex")->GetString();
float directionX = xml->GetElement("LightDirection")->GetElement("X")->GetFloat();
float directionY = xml->GetElement("LightDirection")->GetElement("Y")->GetFloat();
float directionZ = xml->GetElement("LightDirection")->GetElement("Z")->GetFloat();
auto shaderToon = new ShaderToon();
shaderToon->SetLightDirection(directionX, directionY, directionZ);
shaderToon->_toonTexture = Texture::CreateFromFile(texturePath, D3DX_DEFAULT);
shader = ShaderSP(shaderToon);
// ハッシュマップに挿入
_shaders.insert(std::make_pair(path, shader));
return shader;
}
void FPreviewScene::LoadSettings(const TCHAR* Section)
{
FRotator LightDir;
if ( GConfig->GetRotator( Section, TEXT("LightDir"), LightDir, GEditorUserSettingsIni ) )
{
SetLightDirection( LightDir );
}
}
void FJavascriptInGameScene::LoadSettings(const TCHAR* Section)
{
FRotator LightDir;
if (GConfig->GetRotator(Section, TEXT("LightDir"), LightDir, GEditorPerProjectIni))
{
SetLightDirection(LightDir);
}
}
void FAdvancedPreviewScene::Tick(float DeltaTime)
{
checkf(DefaultSettings && DefaultSettings->Profiles.IsValidIndex(CurrentProfileIndex), TEXT("Invalid default settings pointer or current profile index"));
FPreviewSceneProfile& Profile = DefaultSettings->Profiles[CurrentProfileIndex];
if (Profile.bRotateLightingRig)
{
CurrentRotationSpeed = Profile.RotationSpeed;
Profile.LightingRigRotation = FMath::Fmod(FMath::Max(FMath::Min(Profile.LightingRigRotation + (CurrentRotationSpeed * DeltaTime), 360.0f), 0.0f), 360.0f);
FRotator LightDir = GetLightDirection();
LightDir.Yaw += DeltaTime * -CurrentRotationSpeed;
SetLightDirection(LightDir);
DefaultSettings->Profiles[CurrentProfileIndex].DirectionalLightRotation = LightDir;
}
if (!FMath::IsNearlyEqual(PreviousRotation, Profile.LightingRigRotation, 0.05f))
{
SkyLightComponent->SourceCubemapAngle = Profile.LightingRigRotation;
SkyLightComponent->SetCaptureIsDirty();
SkyLightComponent->MarkRenderStateDirty();
SkyLightComponent->UpdateSkyCaptureContents(PreviewWorld);
InstancedSkyMaterial->SetScalarParameterValueEditorOnly(FName("CubemapRotation"), Profile.LightingRigRotation / 360.0f);
InstancedSkyMaterial->PostEditChange();
PreviewWorld->UpdateAllReflectionCaptures();
PreviewWorld->UpdateAllSkyCaptures();
PreviousRotation = Profile.LightingRigRotation;
}
// Update the sky every tick rather than every mouse move (UpdateScene call)
if (bSkyChanged)
{
SkyLightComponent->SetCaptureIsDirty();
SkyLightComponent->MarkRenderStateDirty();
SkyLightComponent->UpdateSkyCaptureContents(PreviewWorld);
InstancedSkyMaterial->PostEditChange();
bSkyChanged = false;
}
}
void ModelComponent::DrawDeferred(const tt::GameContext& context)
{
if(m_pMaterial == nullptr)
throw exception();
if( Cull(context) )
return;
auto pMat = dynamic_cast<SkinnedMaterial*>(m_pMaterial.get() );
if(pMat){
if(!m_pModel->HasAnimData())
MyServiceLocator::GetInstance()->GetService<DebugService>()->Log(_T("SkinnedMaterial cannot be assigned to a model without animation data"), LogLevel::Error);
m_pMeshAnimator->Draw(context);
pMat->SetBoneTransforms(m_pMeshAnimator->GetBoneTransforms() );
pMat->SetDualQuats(m_pMeshAnimator->GetDualQuats() );
pMat->SetLightDirection(tt::Vector3(0,-1,0) );
}
MyServiceLocator::GetInstance()->GetService<IGraphicsService>()->DrawDeferred(m_pModel, m_pTransform->GetWorldMatrix(), m_pMaterial, context);
}
void FAdvancedPreviewScene::UpdateScene(FPreviewSceneProfile& Profile, bool bUpdateSkyLight /*= true*/, bool bUpdateEnvironment /*= true*/, bool bUpdatePostProcessing /*= true*/, bool bUpdateDirectionalLight /*= true*/)
{
if (bUpdateSkyLight)
{
// Threshold to ensure we only update the intensity if it is going to make a difference
if (!FMath::IsNearlyEqual(SkyLightComponent->Intensity, Profile.SkyLightIntensity, 0.05f))
{
static const FName IntensityName("Intensity");
SkyLightComponent->SetIntensity(Profile.SkyLightIntensity);
InstancedSkyMaterial->SetScalarParameterValueEditorOnly(IntensityName, Profile.SkyLightIntensity);
bSkyChanged = true;
}
}
if (bUpdateEnvironment)
{
static const FName SkyBoxName("SkyBox");
static const FName CubeMapRotationName("CubemapRotation");
UTextureCube* EnvironmentTexture = Profile.EnvironmentCubeMap.LoadSynchronous();
UTexture* Texture = Cast<UTexture>(EnvironmentTexture);
InstancedSkyMaterial->GetTextureParameterValue(SkyBoxName, Texture);
if (Texture != EnvironmentTexture)
{
InstancedSkyMaterial->SetTextureParameterValueEditorOnly(SkyBoxName, EnvironmentTexture);
SkyLightComponent->Cubemap = EnvironmentTexture;
bSkyChanged = true;
}
static const float OneOver360 = 1.0f / 360.0f;
float Rotation = Profile.LightingRigRotation;
InstancedSkyMaterial->GetScalarParameterValue(CubeMapRotationName, Rotation);
if (!FMath::IsNearlyEqual(Rotation, Profile.LightingRigRotation, 0.05f))
{
InstancedSkyMaterial->SetScalarParameterValueEditorOnly(CubeMapRotationName, Profile.LightingRigRotation * OneOver360);
// Update light direction as well
FRotator LightDir = GetLightDirection();
LightDir.Yaw -= Profile.LightingRigRotation - (Rotation * 360.0f);
SetLightDirection(LightDir);
DefaultSettings->Profiles[CurrentProfileIndex].DirectionalLightRotation = LightDir;
SkyLightComponent->SourceCubemapAngle = Profile.LightingRigRotation;
bSkyChanged = true;
}
}
if (bUpdatePostProcessing)
{
PostProcessComponent->Settings = Profile.PostProcessingSettings;
PostProcessComponent->bEnabled = Profile.bPostProcessingEnabled;
bPostProcessing = Profile.bPostProcessingEnabled;
}
if (bUpdateDirectionalLight)
{
if (!FMath::IsNearlyEqual(DirectionalLight->Intensity, Profile.DirectionalLightIntensity, 0.05f))
{
DirectionalLight->SetIntensity(Profile.DirectionalLightIntensity);
}
DirectionalLight->SetLightColor(Profile.DirectionalLightColor);
}
SkyComponent->SetVisibility(Profile.bShowEnvironment, true);
FloorMeshComponent->SetVisibility(Profile.bShowFloor, true);
bRotateLighting = Profile.bRotateLightingRig;
CurrentRotationSpeed = Profile.RotationSpeed;
}
FAdvancedPreviewScene::FAdvancedPreviewScene(ConstructionValues CVS, float InFloorOffset)
: FPreviewScene(CVS)
{
DefaultSettings = UAssetViewerSettings::Get();
CurrentProfileIndex = DefaultSettings->Profiles.IsValidIndex(CurrentProfileIndex) ? GetDefault<UEditorPerProjectUserSettings>()->AssetViewerProfileIndex : 0;
ensureMsgf(DefaultSettings->Profiles.IsValidIndex(CurrentProfileIndex), TEXT("Invalid default settings pointer or current profile index"));
FPreviewSceneProfile& Profile = DefaultSettings->Profiles[CurrentProfileIndex];
const FTransform Transform(FRotator(0, 0, 0), FVector(0, 0, 0), FVector(1));
// Add and set up sky light using the set cube map texture
SkyLightComponent = NewObject<USkyLightComponent>();
SkyLightComponent->Cubemap = Profile.EnvironmentCubeMap.Get();
SkyLightComponent->SourceType = ESkyLightSourceType::SLS_SpecifiedCubemap;
SkyLightComponent->Mobility = EComponentMobility::Movable;
SkyLightComponent->bLowerHemisphereIsBlack = false;
SkyLightComponent->Intensity = Profile.SkyLightIntensity;
AddComponent(SkyLightComponent, Transform);
SkyLightComponent->UpdateSkyCaptureContents(PreviewWorld);
// Large scale to prevent sphere from clipping
const FTransform SphereTransform(FRotator(0, 0, 0), FVector(0, 0, 0), FVector(2000));
SkyComponent = NewObject<UStaticMeshComponent>(GetTransientPackage());
// Set up sky sphere showing hte same cube map as used by the sky light
UStaticMesh* SkySphere = LoadObject<UStaticMesh>(NULL, TEXT("/Engine/EditorMeshes/AssetViewer/Sphere_inversenormals.Sphere_inversenormals"), NULL, LOAD_None, NULL);
check(SkySphere);
SkyComponent->SetStaticMesh(SkySphere);
UMaterial* SkyMaterial = LoadObject<UMaterial>(NULL, TEXT("/Engine/EditorMaterials/AssetViewer/M_SkyBox.M_SkyBox"), NULL, LOAD_None, NULL);
check(SkyMaterial);
InstancedSkyMaterial = NewObject<UMaterialInstanceConstant>(GetTransientPackage());
InstancedSkyMaterial->Parent = SkyMaterial;
UTextureCube* DefaultTexture = LoadObject<UTextureCube>(NULL, TEXT("/Engine/MapTemplates/Sky/SunsetAmbientCubemap.SunsetAmbientCubemap"));
InstancedSkyMaterial->SetTextureParameterValueEditorOnly(FName("SkyBox"), ( Profile.EnvironmentCubeMap.Get() != nullptr ) ? Profile.EnvironmentCubeMap.Get() : DefaultTexture );
InstancedSkyMaterial->SetScalarParameterValueEditorOnly(FName("CubemapRotation"), Profile.LightingRigRotation / 360.0f);
InstancedSkyMaterial->SetScalarParameterValueEditorOnly(FName("Intensity"), Profile.SkyLightIntensity);
InstancedSkyMaterial->PostLoad();
SkyComponent->SetMaterial(0, InstancedSkyMaterial);
AddComponent(SkyComponent, SphereTransform);
PostProcessComponent = NewObject<UPostProcessComponent>();
PostProcessComponent->Settings = Profile.PostProcessingSettings;
PostProcessComponent->bUnbound = true;
AddComponent(PostProcessComponent, Transform);
UStaticMesh* FloorMesh = LoadObject<UStaticMesh>(NULL, TEXT("/Engine/EditorMeshes/AssetViewer/Floor_Mesh.Floor_Mesh"), NULL, LOAD_None, NULL);
check(FloorMesh);
FloorMeshComponent = NewObject<UStaticMeshComponent>(GetTransientPackage());
FloorMeshComponent->SetStaticMesh(FloorMesh);
FTransform FloorTransform(FRotator(0, 0, 0), FVector(0, 0, -(InFloorOffset)), FVector(4.0f, 4.0f, 1.0f ));
AddComponent(FloorMeshComponent, FloorTransform);
// Set up directional light's cascaded shadow maps for higher shadow quality
DirectionalLight->DynamicShadowCascades = 4;
DirectionalLight->DynamicShadowDistanceMovableLight = 5000.0f;
DirectionalLight->ShadowBias = 0.7f;
SetLightDirection(Profile.DirectionalLightRotation);
bRotateLighting = Profile.bRotateLightingRig;
CurrentRotationSpeed = Profile.RotationSpeed;
bSkyChanged = false;
}
void FAdvancedPreviewScene::SetProfileIndex(const int32 InProfileIndex)
{
CurrentProfileIndex = InProfileIndex;
SetLightDirection(DefaultSettings->Profiles[CurrentProfileIndex].DirectionalLightRotation);
UpdateScene(DefaultSettings->Profiles[CurrentProfileIndex]);
}
