示例#1
0
//[-------------------------------------------------------]
//[ Private virtual SurfacePainter functions              ]
//[-------------------------------------------------------]
void SPMaterialPreview::OnPaint(Surface &cSurface)
{
    // Get the used renderer
    Renderer &cRenderer = GetRenderer();

    // Set all render states to known default settings
    cRenderer.Reset();

    // Clear the frame buffer
    cRenderer.Clear();

    // Get the used material
    Material *pMaterial = cRenderer.GetRendererContext().GetMaterialManager().GetByName(m_sMaterial);
    if (pMaterial) {
        // Begin 2D mode
        DrawHelpers &cDrawHelpers = cRenderer.GetDrawHelpers();
        cDrawHelpers.Begin2DMode();

        // Draw image (we have to flip the result upside-down...)
        SamplerStates cSamplerStates;
        for (uint32 i=0; i<pMaterial->GetNumOfPasses(); i++) {
            pMaterial->SetupPass(i);
            TextureBuffer *pTextureBuffer = cRenderer.GetTextureBuffer(0);
            if (pTextureBuffer) {
                cRenderer.SetRenderState(RenderState::CullMode, Cull::None);
                cDrawHelpers.DrawImage(*pTextureBuffer, cSamplerStates, Vector2(m_vCameraPosition.x-m_vCameraPosition.z, m_vCameraPosition.y-m_vCameraPosition.z), Vector2(m_vCameraPosition.z*2, m_vCameraPosition.z*2),
                                       Color4::White, 1.0f, Vector2::One, Vector2::NegativeOne);
            }
        }

        // End 2D mode
        cDrawHelpers.End2DMode();
    }
}
示例#2
0
//[-------------------------------------------------------]
//[ Public virtual PLScene::SceneNode functions           ]
//[-------------------------------------------------------]
void SNLoadScreen::DrawPost(Renderer &cRenderer, const VisNode *pVisNode)
{
	// Call base implementation
	SNLoadScreenBase::DrawPost(cRenderer, pVisNode);

	// Hide the load screen?
	const float fProgress = GetLoadProgress();
	if (fProgress > 1.0f || fProgress < 0.0f) {
		// We do not longer need the used materials :)
		FreeMaterials();
	} else {
		// Clear the screen
		if (ClearFlags) {
			uint32 nFlags = 0;
			if (ClearFlags & Color)
				nFlags |= Clear::Color;
			if (ClearFlags & Depth)
				nFlags |= Clear::ZBuffer;
			if (ClearFlags & Stencil)
				nFlags |= Clear::Stencil;
			cRenderer.Clear(nFlags, ClearColor.Get());
		}

		// Screen alpha
		const float fPerImage = (Images > 1) ? 1.0f/Images : 0.1f;
		if (GetFlags() & NoImageBlend) {
			// No image blend, please
			for (uint8 i=0; i<Images; i++) {
				m_fAlpha[i] = (fProgress-(static_cast<float>(i)*fPerImage))/fPerImage;
				m_fAlpha[i] = (m_fAlpha[i] > 1.0f || m_fAlpha[i] < 0.0f) ? 0.0f : 1.0f;
			}
		} else {
			if (Images > 1) {
				// Image blend, please
				for (uint8 i=0; i<Images; i++) {
					m_fAlpha[i] = (fProgress-(static_cast<float>(i)*fPerImage))/fPerImage;
					if (m_fAlpha[i] > 1.0f)
						m_fAlpha[i] = 1.0f-(fProgress-(fPerImage*static_cast<float>(i+1)))/fPerImage;
				}
			} else {
				m_fAlpha[0] = fProgress*10;
				if (m_fAlpha[0] > 1.0f)
					m_fAlpha[0] = 1.0f;
			}
		}

		// Load bar alpha
		m_fBarBackAlpha = fProgress/0.25f;
		if (m_fBarBackAlpha > 1.0f)
			m_fBarBackAlpha = 1.0f;
		m_fBarAlpha[0] = (Math::Sin(fProgress)/4+0.75f)*m_fBarBackAlpha;
		m_fBarAlpha[1] = (Math::Cos(fProgress)/4+0.75f)*m_fBarBackAlpha;
		const float fBarRight = BarX+BarWidth*fProgress;

		// Begin 2D mode
		SamplerStates cSamplerStates;
		DrawHelpers &cDrawHelpers = cRenderer.GetDrawHelpers();
		cDrawHelpers.Begin2DMode();

			// Screen
			const Color4 cImageColor = ImageColor.Get();
			MaterialManager &cMaterialManager = cRenderer.GetRendererContext().GetMaterialManager();
			for (uint8 i=0; i<Images; i++) {
				if (m_fAlpha[i] > 0.0f) {
					Material *pMaterial = m_cScreenMaterial[i].GetResource();
					if (!pMaterial) {
						pMaterial = cMaterialManager.LoadResource(m_sScreenMaterial[i]);
						if (pMaterial)
							m_cScreenMaterial[i].SetResource(pMaterial);
					}
					if (pMaterial) {
						for (uint32 nPass=0; nPass<pMaterial->GetNumOfPasses(); nPass++) {
							pMaterial->SetupPass(nPass);
							TextureBuffer *pTextureBuffer = cRenderer.GetTextureBuffer(0);
							if (pTextureBuffer) {
								cRenderer.SetRenderState(RenderState::CullMode, Cull::None);
								cDrawHelpers.DrawImage(*pTextureBuffer, cSamplerStates, Vector2(ImageX, ImageY), Vector2(ImageWidth, ImageHeight),
													   Color4(cImageColor.r, cImageColor.g, cImageColor.b, cImageColor.a*m_fAlpha[i]));
							}
						}
					}

				// Else unload (if it's loaded :) the material because the don't need it!
				} else {
					m_cScreenMaterial[i].SetResource();
				}
			}

			// Load bar background
			const Color4 cBarColor = BarColor.Get();
			Material *pMaterial = m_cBarBackMaterial.GetResource();
			if (pMaterial) {
				for (uint32 nPass=0; nPass<pMaterial->GetNumOfPasses(); nPass++) {
					pMaterial->SetupPass(nPass);
					TextureBuffer *pTextureBuffer = cRenderer.GetTextureBuffer(0);
					if (pTextureBuffer) {
						cRenderer.SetRenderState(RenderState::CullMode, Cull::None);
						cDrawHelpers.DrawImage(*pTextureBuffer, cSamplerStates, Vector2(BarX, BarY), Vector2(BarWidth, BarHeight),
											   Color4(cBarColor.r, cBarColor.g, cBarColor.b, (GetFlags() & NoImageBlend) ? cBarColor.a : cBarColor.a*m_fBarBackAlpha));
					}
				}

			// Try to load it
			} else {
				m_cBarBackMaterial.SetResource(cMaterialManager.LoadResource(m_sBarBackMaterial));
			}

			// Load bar
			for (int i=0; i<2; i++) {
				pMaterial = m_cBarMaterial[i].GetResource();
				if (pMaterial) {
					for (uint32 nPass=0; nPass<pMaterial->GetNumOfPasses(); nPass++) {
						pMaterial->SetupPass(nPass);
						TextureBuffer *pTextureBuffer = cRenderer.GetTextureBuffer(0);
						if (pTextureBuffer) {
							cRenderer.SetRenderState(RenderState::CullMode, Cull::None);
							cDrawHelpers.DrawImage(*pTextureBuffer, cSamplerStates, Vector2(BarX, BarY), Vector2(fBarRight - BarX, BarHeight),
												   Color4(cBarColor.r, cBarColor.g, cBarColor.b, cBarColor.a*m_fBarAlpha[i]), 1.0f, Vector2::Zero, Vector2(fProgress, 1.0f));
						}
					}

				// Try to load it
				} else {
					m_cBarMaterial[i].SetResource(cMaterialManager.LoadResource(m_sBarMaterial[i]));
				}
			}

		// End 2D mode
		cDrawHelpers.End2DMode();
	}
}
示例#3
0
//[-------------------------------------------------------]
//[ Public virtual PLScene::SceneNode functions           ]
//[-------------------------------------------------------]
void SNConsole::DrawPost(Renderer &cRenderer, const VisNode *pVisNode)
{
    // Check whether the console is inactive
    if (m_nState != Inactive) {
        DrawHelpers &cDrawHelpers = cRenderer.GetDrawHelpers();

        // Call base implementation
        SNConsoleBase::DrawPost(cRenderer, pVisNode);

        // Backup renderer states
        uint32 nFixedFillModeBackup = cRenderer.GetRenderState(RenderState::FixedFillMode);
        uint32 nFillModeBackup      = cRenderer.GetRenderState(RenderState::FillMode);

        // Set new renderer states
        cRenderer.SetRenderState(RenderState::FixedFillMode, Fill::Solid);
        cRenderer.SetRenderState(RenderState::FillMode,      Fill::Solid);

        // Draw the background material
        Material *pMaterial = m_cMaterial.GetResource();
        if (pMaterial) {
            SamplerStates cSamplerStates;
            for (uint32 i=0; i<pMaterial->GetNumOfPasses(); i++) {
                pMaterial->SetupPass(i);
                TextureBuffer *pTextureBuffer = cRenderer.GetTextureBuffer(0);
                if (pTextureBuffer) {
                    // Begin 2D mode
                    cDrawHelpers.Begin2DMode();

                    // Draw image
                    cRenderer.SetRenderState(RenderState::CullMode, Cull::None);
                    cDrawHelpers.DrawImage(*pTextureBuffer, cSamplerStates, Vector2::Zero, Vector2::One, Color4(0.5f, 0.5f, 0.5f, m_fAlpha/255*0.6f));

                    // End 2D mode
                    cDrawHelpers.End2DMode();
                }
            }
        }

        // Get the font
        Font *pFont = cRenderer.GetFontManager().GetDefaultFontTexture();
        if (pFont) {
            // Set render states
            cRenderer.GetRendererContext().GetEffectManager().Use();
            cRenderer.SetRenderState(RenderState::ZEnable,      false);
            cRenderer.SetRenderState(RenderState::ZWriteEnable, false);

            // Begin 2D mode
            static const float VirtualWidth  = 800.0f;
            static const float VirtualHeight = 600.0f;
            cDrawHelpers.Begin2DMode(0.0f, 0.0f, VirtualWidth, VirtualHeight);

            // Draw current console line
            const float fY = 100*((255-m_fAlpha)/255);
            cDrawHelpers.DrawText(*pFont, ">>" + m_sFoundCommand, Color4(0.5f, 0.5f, 0.5f, m_fAlpha/255), Vector2(5, 480-fY));
            const Color4 cColor(1.0f, 1.0f, 1.0f, m_fAlpha/255);
            cDrawHelpers.DrawText(*pFont, ">>" + m_sCommand, cColor, Vector2(5, 480-fY));

            // Draw cursor
            if ((Timing::GetInstance()->GetPastTime()/500)%2) {
                const float fX = m_nCursor ? cDrawHelpers.GetTextWidth(*pFont, ">>" + m_sCommand.GetSubstring(0, m_nCursor)) : cDrawHelpers.GetTextWidth(*pFont, ">>");
                cDrawHelpers.DrawText(*pFont, '|', cColor, Vector2(5 + fX*VirtualWidth, 480-fY));
            }

            // Draw selection
            if (m_nSelStart != -1 && m_nSelEnd != -1 && m_nSelStart != m_nSelEnd) {
                // Get the start and end of the selection
                uint32 nSelStart = m_nSelStart;
                uint32 nSelEnd   = m_nSelEnd;
                if (nSelStart > nSelEnd) {
                    nSelStart = m_nSelEnd;
                    nSelEnd   = m_nSelStart;
                }

                // Draw selection
                float fX = 5+cDrawHelpers.GetTextWidth(*pFont, ">>")*VirtualWidth;
                if (nSelStart)
                    fX += cDrawHelpers.GetTextWidth(*pFont, m_sCommand.GetSubstring(0, nSelStart))*VirtualWidth;
                const float fHeight = cDrawHelpers.GetTextHeight(*pFont)*VirtualHeight;
                cDrawHelpers.DrawLine(cColor,
                                      Vector2(fX, 482-fY+fHeight),
                                      Vector2(fX+cDrawHelpers.GetTextWidth(*pFont, m_sCommand.GetSubstring(nSelStart, nSelEnd-nSelStart))*VirtualWidth, 482-fY+fHeight),
                                      1.0f);
            }

            // Print console description
            cDrawHelpers.DrawText(*pFont, GetDescription(), cColor, Vector2(400, 500-fY), Font::CenterText);

            // Draw the log
            for (uint32 i=0; i<m_lstLogLines.GetNumOfElements(); i++)
                cDrawHelpers.DrawText(*pFont, m_lstLogLines[i], cColor, Vector2(5, 460 - fY - i*15.0f), 0, Vector2(0.8f, 0.8f));

            // End 2D mode
            cDrawHelpers.End2DMode();

            // Reset renderer states
            cRenderer.SetRenderState(RenderState::FillMode,		 nFillModeBackup);
            cRenderer.SetRenderState(RenderState::FixedFillMode, nFixedFillModeBackup);
        }
    }
}