void FKSphereElem::GetElemSolid(const FTransform& ElemTM, const FVector& Scale3D, const FMaterialRenderProxy* MaterialRenderProxy, int32 ViewIndex, FMeshElementCollector& Collector) const
{
GetSphereMesh(ElemTM.GetLocation(), FVector(this->Radius * Scale3D.GetAbsMin()), DrawCollisionSides, DrawCollisionSides / 2, MaterialRenderProxy, SDPG_World, false, ViewIndex, Collector);
}
void DeferredRenderer::DrawPointLight(const Light &light) {
SR_ASSERT(light.type == kLightPoint);
Device *dev = Device::GetInstance();
RenderState &render_state = dev->render_state();
//해당위치의 스텐실 버퍼에 원을 그린다. 원으로 빛이 영향을 줄 영역을 결정해서
//depth test를 오래하지 않도록한다
//스텐실 버퍼에 의존하는 방식보다 scissor로 고치는게 성능상 유리할테니
//나중에는 적절히 고치자
//GeometricObject<vec3> sphere_mesh;
//sphere_mesh.SolidSphere(1, 16, 16);
//스텐실을 이용해서 그리면 화면 전체가 아니라
//빛이 영향을 받는 곳에 대해서만 구를 그려서 빛 계산을 하도록하니까
//계산부하를 줄일수잇다
const bool use_stencil = true;
if(use_stencil) {
//3d장면에 렌더링하기. 그래야 빛이 영향줄 구가 제대로 그려진다
render_state.Set3D();
const mat4 &projection = render_state.projection_mat();
const mat4 &view = render_state.view_mat();
mat4 model(1.0f);
model = glm::translate(model, light.pos);
model = glm::scale(model, vec3(light.radius));
mat4 mvp_3d = projection * view * model;
//단색쉐이더로 대충 그리기. 스텐실 버퍼에만 그려지면 됨
//색칠 영역은 스텐실 버퍼니까 적절히 초기화하기
glEnable(GL_STENCIL_TEST);
render_state.ClearBuffer(false, false, true, Color4ub::White());
glColorMask(false, false, false, false);
glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
glStencilFunc(GL_ALWAYS, 0xff, 0xff);
ShaderManager *shader_mgr = dev->shader_mgr();
Shader *const_color_shader = shader_mgr->Get(ShaderManager::kConstColor);
render_state.UseShader(*const_color_shader);
vec4 white(1.0f);
const_color_shader->SetUniformVector(kConstColorHandleName, white);
const_color_shader->SetUniformMatrix(kMVPHandleName, mvp_3d);
//const DrawCmdData<vec3> &draw_cmd = sphere_mesh.cmd_list().at(0);
//const_color_shader->SetVertexList(draw_cmd.vertex_list);
//const_color_shader->DrawElements(draw_cmd.draw_mode, draw_cmd.index_list);
const_color_shader->DrawMeshIgnoreMaterial(&GetSphereMesh());
}
{
//스텐실 영역에 잇는거 진짜로 그리기. 2D로 그리기
//이것을 진행하면서 빛 계산을 수행한다
if(use_stencil) {
glColorMask(true, true, true, true);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
glStencilFunc(GL_EQUAL, 0xff, 0xff);
}
//점광원 계산용 쉐이더로 교체
Shader &point_shader = this->point_shader();
render_state.UseShader(point_shader);
//빛 계산에 쓰이는 공용 속성 설정
SetCommonLightUniform(point_shader, light);
const mat4 &view = render_state.view_mat();
const mat4 &model = render_state.model_mat();
vec4 light_pos = model * vec4(light.pos, 1.0f);
light_pos.w = light.radius; //4번쨰를 반지름으로 사용
{
//Draw2DManager *draw_2d_mgr = dev->draw_2d();
//char light_pos_buf[128];
//sprintf(light_pos_buf, "LightPos:%.4f, %.4f, %.4f", light_pos.x, light_pos.y, light_pos.z);
//draw_2d_mgr->AddString(vec2(0, 100), light_pos_buf, Color4ub::Green(), 1.0f);
//DebugDrawManager *draw_3d_mgr = dev->debug_draw_mgr();
//draw_3d_mgr->AddString(light.pos, "Light", Color4ub::Red(), 1.0f);
}
point_shader.SetUniformVector("u_lightPos", light_pos);
//2d로 교체는 렌더링 직전에 수행하자
render_state.Set2D();
SetCommonLightQuadDraw(point_shader);
}
//restore state
if(use_stencil) {
glDisable(GL_STENCIL_TEST);
}
}
void FDebugRenderSceneProxy::GetDynamicMeshElements(const TArray<const FSceneView*>& Views, const FSceneViewFamily& ViewFamily, uint32 VisibilityMap, FMeshElementCollector& Collector) const
{
QUICK_SCOPE_CYCLE_COUNTER( STAT_DebugRenderSceneProxy_GetDynamicMeshElements );
// Draw solid spheres
struct FMaterialCache
{
FMaterialCache() : bUseFakeLight(false) {}
FMaterialRenderProxy* operator[](FLinearColor Color)
{
FMaterialRenderProxy* MeshColor = NULL;
const uint32 HashKey = GetTypeHash(Color);
if (MeshColorInstances.Contains(HashKey))
{
MeshColor = *MeshColorInstances.Find(HashKey);
}
else
{
if (bUseFakeLight && SolidMeshMaterial.IsValid())
{
MeshColor = new(FMemStack::Get()) FColoredMaterialRenderProxy(
SolidMeshMaterial->GetRenderProxy(false, false),
Color,
"GizmoColor"
);
}
else
{
MeshColor = new(FMemStack::Get()) FColoredMaterialRenderProxy(GEngine->DebugMeshMaterial->GetRenderProxy(false, false), Color);
}
MeshColorInstances.Add(HashKey, MeshColor);
}
return MeshColor;
}
void UseFakeLight(bool UseLight, class UMaterial* InMaterial) { bUseFakeLight = UseLight; SolidMeshMaterial = InMaterial; }
TMap<uint32, FMaterialRenderProxy*> MeshColorInstances;
TWeakObjectPtr<class UMaterial> SolidMeshMaterial;
bool bUseFakeLight;
};
FMaterialCache MaterialCache[2];
MaterialCache[1].UseFakeLight(true, SolidMeshMaterial.Get());
for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
{
if (VisibilityMap & (1 << ViewIndex))
{
const FSceneView* View = Views[ViewIndex];
FPrimitiveDrawInterface* PDI = Collector.GetPDI(ViewIndex);
// Draw Lines
const int32 LinesNum = Lines.Num();
PDI->AddReserveLines(SDPG_World, LinesNum, false, false);
for (const auto& CurrentLine : Lines)
{
PDI->DrawLine(CurrentLine.Start, CurrentLine.End, CurrentLine.Color, SDPG_World, CurrentLine.Thickness, 0, CurrentLine.Thickness > 0);
}
// Draw Dashed Lines
for(int32 DashIdx=0; DashIdx<DashedLines.Num(); DashIdx++)
{
const FDashedLine& Dash = DashedLines[DashIdx];
DrawDashedLine(PDI, Dash.Start, Dash.End, Dash.Color, Dash.DashSize, SDPG_World);
}
// Draw Arrows
const uint32 ArrowsNum = ArrowLines.Num();
PDI->AddReserveLines(SDPG_World, 5 * ArrowsNum, false, false);
for (const auto& CurrentArrow : ArrowLines)
{
DrawLineArrow(PDI, CurrentArrow.Start, CurrentArrow.End, CurrentArrow.Color, 8.0f);
}
// Draw Stars
for(int32 StarIdx=0; StarIdx<Stars.Num(); StarIdx++)
{
const FWireStar& Star = Stars[StarIdx];
DrawWireStar(PDI, Star.Position, Star.Size, Star.Color, SDPG_World);
}
// Draw Cylinders
for(const auto& Cylinder : Cylinders)
{
if (DrawType == SolidAndWireMeshes || DrawType == WireMesh)
{
DrawWireCylinder(PDI, Cylinder.Base, FVector(1, 0, 0), FVector(0, 1, 0), FVector(0, 0, 1), Cylinder.Color, Cylinder.Radius, Cylinder.HalfHeight, (DrawType == SolidAndWireMeshes) ? 9 : 16, SDPG_World, DrawType == SolidAndWireMeshes ? 2 : 0, 0, true);
}
if (DrawType == SolidAndWireMeshes || DrawType == SolidMesh)
{
GetCylinderMesh(Cylinder.Base, FVector(1, 0, 0), FVector(0, 1, 0), FVector(0, 0, 1), Cylinder.Radius, Cylinder.HalfHeight, 16, MaterialCache[0][Cylinder.Color.WithAlpha(DrawAlpha)], SDPG_World, ViewIndex, Collector);
}
}
// Draw Boxes
for(const auto& Box : Boxes)
{
if (DrawType == SolidAndWireMeshes || DrawType == WireMesh)
{
DrawWireBox(PDI, Box.Transform.ToMatrixWithScale(), Box.Box, Box.Color, SDPG_World, DrawType == SolidAndWireMeshes ? 2 : 0, 0, true);
}
if (DrawType == SolidAndWireMeshes || DrawType == SolidMesh)
{
GetBoxMesh(FTransform(Box.Box.GetCenter()).ToMatrixNoScale() * Box.Transform.ToMatrixWithScale(), Box.Box.GetExtent(), MaterialCache[0][Box.Color.WithAlpha(DrawAlpha)], SDPG_World, ViewIndex, Collector);
}
}
// Draw Boxes
TArray<FVector> Verts;
for (auto& CurrentCone : Cones)
{
if (DrawType == SolidAndWireMeshes || DrawType == WireMesh)
{
DrawWireCone(PDI, Verts, CurrentCone.ConeToWorld, 1, CurrentCone.Angle2, (DrawType == SolidAndWireMeshes) ? 9 : 16, CurrentCone.Color, SDPG_World, DrawType == SolidAndWireMeshes ? 2 : 0, 0, true);
}
if (DrawType == SolidAndWireMeshes || DrawType == SolidMesh)
{
GetConeMesh(CurrentCone.ConeToWorld, CurrentCone.Angle1, CurrentCone.Angle2, 16, MaterialCache[0][CurrentCone.Color.WithAlpha(DrawAlpha)], SDPG_World, ViewIndex, Collector);
}
}
for (auto It = Spheres.CreateConstIterator(); It; ++It)
{
if (PointInView(It->Location, View))
{
if (DrawType == SolidAndWireMeshes || DrawType == WireMesh)
{
DrawWireSphere(PDI, It->Location, It->Color.WithAlpha(255), It->Radius, 20, SDPG_World, DrawType == SolidAndWireMeshes ? 2 : 0, 0, true);
}
if (DrawType == SolidAndWireMeshes || DrawType == SolidMesh)
{
GetSphereMesh(It->Location, FVector(It->Radius), 20, 7, MaterialCache[0][It->Color.WithAlpha(DrawAlpha)], SDPG_World, false, ViewIndex, Collector);
}
}
}
for (auto It = Capsles.CreateConstIterator(); It; ++It)
{
if (PointInView(It->Location, View))
{
if (DrawType == SolidAndWireMeshes || DrawType == WireMesh)
{
const float HalfAxis = FMath::Max<float>(It->HalfHeight - It->Radius, 1.f);
const FVector BottomEnd = It->Location + It->Radius * It->Z;
const FVector TopEnd = BottomEnd + (2 * HalfAxis) * It->Z;
const float CylinderHalfHeight = (TopEnd - BottomEnd).Size() * 0.5;
const FVector CylinderLocation = BottomEnd + CylinderHalfHeight * It->Z;
DrawWireCapsule(PDI, CylinderLocation, It->X, It->Y, It->Z, It->Color, It->Radius, It->HalfHeight, (DrawType == SolidAndWireMeshes) ? 9 : 16, SDPG_World, DrawType == SolidAndWireMeshes ? 2 : 0, 0, true);
}
if (DrawType == SolidAndWireMeshes || DrawType == SolidMesh)
{
GetCapsuleMesh(It->Location, It->X, It->Y, It->Z, It->Color, It->Radius, It->HalfHeight, 16, MaterialCache[0][It->Color.WithAlpha(DrawAlpha)], SDPG_World, false, ViewIndex, Collector);
}
}
}
for (const auto& Mesh : Meshes)
{
FDynamicMeshBuilder MeshBuilder;
MeshBuilder.AddVertices(Mesh.Vertices);
MeshBuilder.AddTriangles(Mesh.Indices);
MeshBuilder.GetMesh(FMatrix::Identity, MaterialCache[Mesh.Color.A == 255 ? 1 : 0][Mesh.Color.WithAlpha(DrawAlpha)], SDPG_World, false, false, ViewIndex, Collector);
}
}
}
}
