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(); }