void FbxLoader::ProcessMeshNode(FbxNode* node, Node& mnode)
{
if(!node)
return;
if(node->GetNodeAttribute()) {
auto type = node->GetNodeAttribute()->GetAttributeType();
if(type == FbxNodeAttribute::eMesh) {
mnode.type = Node::eMesh;
ProcessControlPoints(node, mnode);
ProcessBoneAndAnimation(node, mnode);
ProcessMesh(node, mnode);
BindMaterial(node, mnode);
}
else if(type == FbxNodeAttribute::eSkeleton) {
mnode.type = Node::eBone;
}
}
ComputeNodeMatrix(node, mnode, true);
const int count = node->GetChildCount();
mnode.childNodes.resize(count);
for(int i = 0; i < count; i++) {
auto child = node->GetChild(i);
auto& childNode = mnode.childNodes[i];
childNode.name = child->GetName();
childNode.parentName = mnode.name;
ProcessMeshNode(node->GetChild(i), childNode);
}
}
inline void Renderer::m_RenderSprite(Camera* camera, Sprite* sprite, Transform* transform) {
Material* material = sprite->material;
if (material == NULL) return;
CreateMaterial(material);
CreateSpriteAttributes();
SetProgram(material->GetOpenGLShader()->program);
BindMaterial(material, camera->projection, camera->view, transform);
BindSpriteAttributes(material);
if (material->GetWireframe()) {
glDrawArrays(GL_LINE_STRIP, 0, 4);
} else {
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
}
void MatWidget::CreateFromTable(lua_State *L) {
Widget::CreateFromTable(L);
lua_getfield(L, -1, "material");
D_Material::Ref m = lua::SharedPtr::Get<D_Material>(L, "D_Material", -1, false);
lua_pop(L, 1);
if (m)
BindMaterial(m->asset);
lua_getfield(L, -1, "drawMode");
if (!lua_isnil(L, -1)) {
int x = (int)luaL_checkinteger(L, -1);
if ((x != kDrawMode_Rect) && (x != kDrawMode_Circle))
luaL_error(L, "invalid draw mode %d", x);
m_drawMode = (DrawMode)x;
}
lua_pop(L, 1);
}
inline void Renderer::m_RenderMeshFilter(Camera* camera, MeshFilter* meshFilter, Transform* transform) {
Mesh* mesh = meshFilter->mesh;
Material* material = meshFilter->material;
if (mesh == NULL || material == NULL) return;
CreateMaterial(material);
CreateMeshAttributes(mesh);
SetProgram(material->GetOpenGLShader()->program);
BindMaterial(material, camera->projection, camera->view, transform);
BindMeshAttributes(material, mesh);
if (material->GetWireframe()) {
glDrawElements(GL_LINES, mesh->indices.Length(), GL_UNSIGNED_INT, BUFFER_OFFSET(0));
} else {
glDrawElements(GL_TRIANGLES, mesh->indices.Length(), GL_UNSIGNED_INT, BUFFER_OFFSET(0));
}
}
void PrelightPipeline::DrawRenderable(const std::shared_ptr<Pass> &pass, const std::shared_ptr<SceneNode> &node)
{
auto render = node->GetComponent<MeshRender>();
if (render == nullptr || !render->GetRenderable())
return;
auto mesh = render->GetMesh();
auto material = render->GetMaterial();
auto shader = material->GetShaderForPass(pass->GetRenderIndex());
if (shader == nullptr)
shader = pass->GetShader(material->GetShaderType());
if (shader == nullptr)
{
LOGW << "Failed to draw " << node->GetName() << ", data incomplete!";
return;
}
shader->Bind();
shader->BindCamera(m_CurrentCamera);
shader->BindMatrix(Matrix4::WORLD_MATRIX, node->GetWorldMatrix());
shader->BindMesh(mesh);
shader->BindMaterial(material);
for (unsigned int i = 0; i < pass->GetTextureCount(true); i++)
{
auto ptr = pass->GetTextureAt(i, true);
shader->BindTexture(ptr->GetName(), ptr);
}
glDrawElements(GL_TRIANGLES, mesh->Indices.Data.size(), GL_UNSIGNED_INT, 0);
shader->UnBind();
m_DrawCall++;
}
void CRender3D::UnbindMaterial()
{
BindMaterial(Core()->pResMan()->pIDefaultMaterial());
_stCurState.pCurMat = INVALID_MATERIAL;
}
ERet DeferredRenderer::RenderScene( const SceneView& sceneView, const Clump& sceneData )
{
gfxMARKER(RenderScene);
if( sceneView.viewportWidth != m_viewportWidth || sceneView.viewportHeight != m_viewportHeight )
{
this->ResizeBuffers( sceneView.viewportWidth, sceneView.viewportHeight, false );
m_viewportWidth = sceneView.viewportWidth;
m_viewportHeight = sceneView.viewportHeight;
}
mxDO(BeginRender_GBuffer());
G_PerCamera cbPerView;
{
cbPerView.g_viewMatrix = sceneView.viewMatrix;
cbPerView.g_viewProjectionMatrix = sceneView.viewMatrix * sceneView.projectionMatrix;
cbPerView.g_inverseViewMatrix = Matrix_OrthoInverse( sceneView.viewMatrix );
cbPerView.g_projectionMatrix = sceneView.projectionMatrix;
cbPerView.g_inverseProjectionMatrix = ProjectionMatrix_Inverse( sceneView.projectionMatrix );
cbPerView.g_inverseViewProjectionMatrix = Matrix_Inverse( cbPerView.g_viewProjectionMatrix );
cbPerView.g_WorldSpaceCameraPos = sceneView.worldSpaceCameraPos;
float n = sceneView.nearClip;
float f = sceneView.farClip;
float x = 1 - f / n;
float y = f / n;
float z = x / f;
float w = y / f;
cbPerView.g_ZBufferParams = Float4_Set( x, y, z, w );
cbPerView.g_ZBufferParams2 = Float4_Set( n, f, 1.0f/n, 1.0f/f );
float H = sceneView.projectionMatrix[0][0];
float V = sceneView.projectionMatrix[2][1];
float A = sceneView.projectionMatrix[1][2];
float B = sceneView.projectionMatrix[3][2];
cbPerView.g_ProjParams = Float4_Set( H, V, A, B );
// x = 1/H
// y = 1/V
// z = 1/B
// w = -A/B
cbPerView.g_ProjParams2 = Float4_Set( 1/H, 1/V, 1/B, -A/B );
llgl::UpdateBuffer(llgl::GetMainContext(), m_hCBPerCamera, sizeof(cbPerView), &cbPerView);
}
// G-Buffer Stage: Render all solid objects to a very sparse G-Buffer
{
gfxMARKER(Fill_Geometry_Buffer);
mxDO(FxSlow_SetRenderState(m_hRenderContext, *m_rendererData, "Default"));
G_PerObject cbPerObject;
TObjectIterator< rxModel > modelIt( sceneData );
while( modelIt.IsValid() )
{
const rxModel& model = modelIt.Value();
const Float3x4* TRS = model.m_transform;
{
cbPerObject.g_worldMatrix = Float3x4_Unpack( *TRS );
cbPerObject.g_worldViewMatrix = Matrix_Multiply(cbPerObject.g_worldMatrix, sceneView.viewMatrix);
cbPerObject.g_worldViewProjectionMatrix = Matrix_Multiply(cbPerObject.g_worldMatrix, sceneView.viewProjectionMatrix);
llgl::UpdateBuffer(m_hRenderContext, m_hCBPerObject, sizeof(cbPerObject), &cbPerObject);
}
const rxMesh* mesh = model.m_mesh;
for( int iSubMesh = 0; iSubMesh < mesh->m_parts.Num(); iSubMesh++ )
{
const rxSubmesh& submesh = mesh->m_parts[iSubMesh];
const rxMaterial* material = model.m_batches[iSubMesh];
const FxShader* shader = material->m_shader;
if( shader->localCBs.Num() )
{
mxASSERT(shader->localCBs.Num()==1);
const ParameterBuffer& uniforms = material->m_uniforms;
const FxCBuffer& rCB = shader->localCBs[0];
llgl::UpdateBuffer(m_hRenderContext, rCB.handle, uniforms.GetDataSize(), uniforms.ToPtr() );
}
llgl::DrawCall batch;
batch.Clear();
SetGlobalUniformBuffers( &batch );
BindMaterial( material, &batch );
batch.inputLayout = Rendering::g_inputLayouts[VTX_Draw];
batch.topology = mesh->m_topology;
batch.VB[0] = mesh->m_vertexBuffer;
batch.IB = mesh->m_indexBuffer;
batch.b32bit = (mesh->m_indexStride == sizeof(UINT32));
batch.baseVertex = submesh.baseVertex;
batch.vertexCount = submesh.vertexCount;
batch.startIndex = submesh.startIndex;
batch.indexCount = submesh.indexCount;
llgl::Submit(m_hRenderContext, batch);
}
modelIt.MoveToNext();
}
}
EndRender_GBuffer();
// Deferred Lighting Stage: Accumulate all lights as a screen space operation
{
gfxMARKER(Deferred_Lighting);
llgl::ViewState viewState;
{
viewState.Reset();
viewState.colorTargets[0].SetDefault();
viewState.targetCount = 1;
viewState.flags = llgl::ClearColor;
}
llgl::SubmitView(m_hRenderContext, viewState);
{
gfxMARKER(Directional_Lights);
mxDO(FxSlow_SetRenderState(m_hRenderContext, *m_rendererData, "Deferred_Lighting"));
FxShader* shader;
mxDO(GetByName(*m_rendererData, "deferred_directional_light", shader));
mxDO2(FxSlow_SetResource(shader, "GBufferTexture0", llgl::AsResource(m_colorRT0->handle), Rendering::g_samplers[PointSampler]));
mxDO2(FxSlow_SetResource(shader, "GBufferTexture1", llgl::AsResource(m_colorRT1->handle), Rendering::g_samplers[PointSampler]));
mxDO2(FxSlow_SetResource(shader, "DepthTexture", llgl::AsResource(m_depthRT->handle), Rendering::g_samplers[PointSampler]));
TObjectIterator< rxGlobalLight > lightIt( sceneData );
while( lightIt.IsValid() )
{
rxGlobalLight& light = lightIt.Value();
//mxDO(FxSlow_Commit(m_hRenderContext,shader));
DirectionalLight lightData;
{
lightData.direction = Matrix_TransformNormal(sceneView.viewMatrix, light.m_direction);
lightData.color = light.m_color;
}
mxDO2(FxSlow_UpdateUBO(m_hRenderContext,shader,"DATA",&lightData,sizeof(lightData)));
DrawFullScreenTriangle(shader);
lightIt.MoveToNext();
}
}
{
gfxMARKER(Point_Lights);
mxDO(FxSlow_SetRenderState(m_hRenderContext, *m_rendererData, "Deferred_Lighting"));
FxShader* shader;
mxDO(GetAsset(shader,MakeAssetID("deferred_point_light.shader"),m_rendererData));
mxDO2(FxSlow_SetResource(shader, "GBufferTexture0", llgl::AsResource(m_colorRT0->handle), Rendering::g_samplers[PointSampler]));
mxDO2(FxSlow_SetResource(shader, "GBufferTexture1", llgl::AsResource(m_colorRT1->handle), Rendering::g_samplers[PointSampler]));
mxDO2(FxSlow_SetResource(shader, "DepthTexture", llgl::AsResource(m_depthRT->handle), Rendering::g_samplers[PointSampler]));
TObjectIterator< rxLocalLight > lightIt( sceneData );
while( lightIt.IsValid() )
{
rxLocalLight& light = lightIt.Value();
//mxDO(FxSlow_Commit(m_hRenderContext,shader));
PointLight lightData;
{
Float3 viewSpaceLightPosition = Matrix_TransformPoint(sceneView.viewMatrix, light.position);
lightData.Position_InverseRadius = Float4_Set(viewSpaceLightPosition, 1.0f/light.radius);
lightData.Color_Radius = Float4_Set(light.color, light.radius);
}
mxDO2(FxSlow_UpdateUBO(m_hRenderContext,shader,"DATA",&lightData,sizeof(lightData)));
DrawFullScreenTriangle(shader);
lightIt.MoveToNext();
}
}
}
// Thursday, March 26, 2015 Implementing Weighted, Blended Order-Independent Transparency
//http://casual-effects.blogspot.ru/2015/03/implemented-weighted-blended-order.html
// Forward+ notes
//http://bioglaze.blogspot.fi/2014/07/2048-point-lights-60-fps.html
// Material Stage: Render all solid objects again while combining the lighting
// from Stage 2 with certain material-properties (colors, reflections, glow, fog, etc.)
// to produce the final image
#if 0
{
llgl::ViewState viewState;
{
viewState.Reset();
viewState.colorTargets[0].SetDefault();
viewState.targetCount = 1;
}
llgl::SubmitView(m_hRenderContext, viewState);
}
{
mxDO(FxSlow_SetRenderState(m_hRenderContext, *m_rendererData, "NoCulling"));
FxShader* shader;
mxDO(GetByName(*m_rendererData, "full_screen_triangle", shader));
mxDO(FxSlow_SetResource(shader, "t_sourceTexture", llgl::AsResource(pColorRT1->handle), Rendering::g_samplers[PointSampler]));
mxDO(FxSlow_Commit(m_hRenderContext,shader));
DrawFullScreenTriangle(shader);
}
#endif
#if 0
{
llgl::ViewState viewState;
{
viewState.Reset();
viewState.colorTargets[0].SetDefault();
viewState.targetCount = 1;
}
llgl::SubmitView(m_hRenderContext, viewState);
}
{
FxShader* shader;
mxDO(FxSlow_SetRenderState(m_hRenderContext, *m_rendererData, "Default"));
{
mxDO(GetAsset(shader,MakeAssetID("debug_draw_colored.shader"),m_rendererData));
mxDO(FxSlow_SetUniform(shader,"g_color",RGBAf::GRAY.ToPtr()));
mxDO(FxSlow_Commit(m_hRenderContext,shader));
DBG_Draw_Models_With_Custom_Shader(sceneView, sceneData, *shader);
}
mxDO(FxSlow_SetRenderState(m_hRenderContext, *m_rendererData, "NoCulling"));
{
mxDO(GetAsset(shader,MakeAssetID("debug_draw_normals.shader"),m_rendererData));
float lineLength = 4.0f;
mxDO(FxSlow_SetUniform(shader,"g_lineLength",&lineLength));
mxDO(FxSlow_Commit(m_hRenderContext,shader));
DBG_Draw_Models_With_Custom_Shader(sceneView, sceneData, *shader, Topology::PointList);
}
}
#endif
return ALL_OK;
}
void LandscapeDebugNode::Draw()
{
if(0 == heightmap->Size())
return;
BindMaterial(0);
int32 index = 0;
for (int32 y = 0; y < heightmap->Size(); ++y)
{
for (int32 x = 0; x < heightmap->Size(); ++x)
{
debugVertices[index].position = GetPoint(x, y, heightmap->Data()[y * heightmap->Size() + x]);
debugVertices[index].texCoord = Vector2((float32)x / (float32)(heightmap->Size() - 1), (float32)y / (float32)(heightmap->Size() - 1));
index++;
}
}
int32 step = 1;
int32 indexIndex = 0;
int32 quadWidth = heightmap->Size();
for(int32 y = 0; y < heightmap->Size() - 1; y += step)
{
for(int32 x = 0; x < heightmap->Size() - 1; x += step)
{
debugIndices[indexIndex++] = x + y * quadWidth;
debugIndices[indexIndex++] = (x + step) + y * quadWidth;
debugIndices[indexIndex++] = x + (y + step) * quadWidth;
debugIndices[indexIndex++] = (x + step) + y * quadWidth;
debugIndices[indexIndex++] = (x + step) + (y + step) * quadWidth;
debugIndices[indexIndex++] = x + (y + step) * quadWidth;
}
}
debugRenderDataObject->SetStream(EVF_VERTEX, TYPE_FLOAT, 3, sizeof(LandscapeVertex), &debugVertices[0].position);
debugRenderDataObject->SetStream(EVF_TEXCOORD0, TYPE_FLOAT, 2, sizeof(LandscapeVertex), &debugVertices[0].texCoord);
#if defined(__DAVAENGINE_OPENGL__)
if (debugFlags & DEBUG_DRAW_GRID)
{
debugFlags &= ~DEBUG_DRAW_GRID;
DrawLandscape();
debugFlags |= DEBUG_DRAW_GRID;
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
RenderManager::Instance()->SetColor(1.0f, 1.f, 1.f, 1.f);
RenderManager::Instance()->SetRenderEffect(RenderManager::FLAT_COLOR);
RenderManager::Instance()->SetShader(0);
RenderManager::Instance()->FlushState();
}
#endif //#if defined(__DAVAENGINE_OPENGL__)
DrawLandscape();
#if defined(__DAVAENGINE_OPENGL__)
if (debugFlags & DEBUG_DRAW_ALL)
{
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
#endif //#if defined(__DAVAENGINE_OPENGL__)
if(cursor)
{
RenderManager::Instance()->AppendState(RenderStateBlock::STATE_BLEND);
eBlendMode src = RenderManager::Instance()->GetSrcBlend();
eBlendMode dst = RenderManager::Instance()->GetDestBlend();
RenderManager::Instance()->SetBlendMode(BLEND_SRC_ALPHA, BLEND_ONE_MINUS_SRC_ALPHA);
RenderManager::Instance()->SetDepthFunc(CMP_LEQUAL);
cursor->Prepare();
RenderManager::Instance()->HWDrawElements(PRIMITIVETYPE_TRIANGLELIST, (heightmap->Size() - 1) * (heightmap->Size() - 1) * 6, EIF_32, &debugIndices.front());
RenderManager::Instance()->SetDepthFunc(CMP_LESS);
RenderManager::Instance()->RemoveState(RenderStateBlock::STATE_BLEND);
RenderManager::Instance()->SetBlendMode(src, dst);
}
UnbindMaterial();
}
