LCOV - code coverage report
Current view: top level - chart2/source/view/main - 3DChartObjects.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 0 136 0.0 %
Date: 2015-06-13 12:38:46 Functions: 0 24 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  */
       9             : 
      10             : #include "3DChartObjects.hxx"
      11             : #include <vcl/virdev.hxx>
      12             : #include <vcl/svapp.hxx>
      13             : 
      14             : #include <vcl/opengl/GLMHelper.hxx>
      15             : #include <vcl/opengl/OpenGLHelper.hxx>
      16             : #include <vcl/bmpacc.hxx>
      17             : 
      18             : namespace chart {
      19             : 
      20             : namespace opengl3D {
      21             : 
      22           0 : Renderable3DObject::Renderable3DObject(OpenGL3DRenderer* pRenderer, sal_uInt32 nId):
      23             :     mpRenderer(pRenderer),
      24           0 :     mnUniqueId(nId)
      25             : {
      26           0 : }
      27             : 
      28           0 : void Renderable3DObject::render()
      29             : {
      30             :     (void) mnUniqueId;
      31           0 : }
      32             : 
      33           0 : Bar::Bar(OpenGL3DRenderer* pRenderer, const glm::mat4& rPosition, sal_uInt32 aColor, sal_uInt32 nId)
      34             :     : Renderable3DObject(pRenderer, nId)
      35             :     , mbRoundedCorners(true)
      36             :     , maPos(rPosition)
      37           0 :     , maColor(aColor)
      38             : {
      39             :     SAL_INFO("chart2.3dopengl", rPosition);
      40           0 : }
      41             : 
      42           0 : void Bar::render()
      43             : {
      44           0 :     mpRenderer->AddShape3DExtrudeObject(mbRoundedCorners, maColor.GetColor(), 0xFFFFFF, maPos, mnUniqueId);
      45           0 :     mpRenderer->EndAddShape3DExtrudeObject();
      46           0 : }
      47             : 
      48           0 : Line::Line(OpenGL3DRenderer* pRenderer, sal_uInt32 nId):
      49           0 :     Renderable3DObject(pRenderer, nId)
      50             : {
      51           0 : }
      52             : 
      53           0 : void Line::render()
      54             : {
      55           0 :     mpRenderer->AddShapePolygon3DObject(0, true, maLineColor.GetColor(), 0, 0, mnUniqueId);
      56           0 :     mpRenderer->AddPolygon3DObjectPoint(maPosBegin.x, maPosBegin.y, maPosBegin.z);
      57           0 :     mpRenderer->AddPolygon3DObjectPoint(maPosEnd.x, maPosEnd.y, maPosEnd.z);
      58           0 :     mpRenderer->EndAddPolygon3DObjectPoint();
      59           0 :     mpRenderer->EndAddShapePolygon3DObject();
      60           0 : }
      61             : 
      62           0 : void Line::setPosition(const glm::vec3& rBegin, const glm::vec3& rEnd)
      63             : {
      64           0 :     maPosBegin = rBegin;
      65           0 :     maPosEnd = rEnd;
      66           0 : }
      67             : 
      68           0 : void Line::setLineColor(const Color& rColor)
      69             : {
      70           0 :     maLineColor = rColor;
      71           0 : }
      72             : 
      73           0 : const TextCacheItem& TextCache::getText(OUString const & rText, bool bIs3dText)
      74             : {
      75           0 :     TextCacheType::const_iterator itr = maTextCache.find(rText);
      76           0 :     if(itr != maTextCache.end())
      77           0 :         return *itr->second;
      78             : 
      79           0 :     ScopedVclPtrInstance< VirtualDevice > pDevice(*Application::GetDefaultDevice(), 0, 0);
      80           0 :     vcl::Font aFont;
      81           0 :     if(bIs3dText)
      82           0 :         aFont = vcl::Font("Brillante St",Size(0,0));
      83             :     else
      84           0 :         aFont = pDevice->GetFont();
      85           0 :     aFont.SetSize(Size(0, 96));
      86           0 :     static bool bOldRender = getenv("OLDRENDER");
      87           0 :     if (bOldRender)
      88           0 :         aFont.SetColor(COL_BLACK);
      89             :     else
      90           0 :         aFont.SetColor(COL_GREEN); // RGB_COLORDATA(0xf0, 0xf0, 0xf0));
      91           0 :     pDevice->SetFont(aFont);
      92           0 :     pDevice->Erase();
      93             : 
      94           0 :     pDevice->SetOutputSize(Size(pDevice->GetTextWidth(rText), pDevice->GetTextHeight()));
      95           0 :     pDevice->SetBackground(Wallpaper(COL_TRANSPARENT));
      96           0 :     pDevice->DrawText(Point(0,0), rText);
      97             : 
      98           0 :     BitmapEx aText(pDevice->GetBitmapEx(Point(0,0), pDevice->GetOutputSize()));
      99             : //    TextCacheItem *pItem = new TextCacheItem(OpenGLHelper::ConvertBitmapExToRGBABuffer(aText), aText.GetSizePixel());
     100           0 :     Bitmap aBitmap (aText.GetBitmap());
     101           0 :     BitmapReadAccess *pAcc = aBitmap.AcquireReadAccess();
     102           0 :     sal_uInt8 *buf = reinterpret_cast<sal_uInt8 *>(pAcc->GetBuffer());
     103           0 :     long nBmpWidth = aText.GetSizePixel().Width();
     104           0 :     long nBmpHeight = aText.GetSizePixel().Height();
     105           0 :     sal_uInt8* pBitmapBuf(new sal_uInt8[3* nBmpWidth * nBmpHeight]);
     106           0 :     memcpy(pBitmapBuf, buf, 3* nBmpWidth * nBmpHeight);
     107           0 :     TextCacheItem *pItem = new TextCacheItem(pBitmapBuf, aText.GetSizePixel());
     108           0 :     maTextCache.insert(rText, pItem);
     109             : 
     110           0 :     return *maTextCache.find(rText)->second;
     111             : }
     112             : 
     113           0 : Text::Text(OpenGL3DRenderer* pRenderer, TextCache& rTextCache, const OUString& rStr, sal_uInt32 nId):
     114             :     Renderable3DObject(pRenderer, nId),
     115           0 :     maText(rTextCache.getText(rStr))
     116             : {
     117           0 : }
     118             : 
     119           0 : void Text::render()
     120             : {
     121           0 :     glm::vec3 dir2 = maTopRight - maTopLeft;
     122           0 :     glm::vec3 bottomLeft = maBottomRight - dir2;
     123             :     mpRenderer->CreateTextTexture(maText.maPixels, maText.maSize,
     124             :                                   maTopLeft, maTopRight, maBottomRight, bottomLeft,
     125           0 :                                   mnUniqueId);
     126           0 : }
     127             : 
     128           0 : void Text::setPosition(const glm::vec3& rTopLeft, const glm::vec3& rTopRight, const glm::vec3& rBottomRight)
     129             : {
     130           0 :     maTopLeft = rTopLeft;
     131           0 :     maTopRight = rTopRight;
     132           0 :     maBottomRight = rBottomRight;
     133           0 : }
     134             : 
     135           0 : ScreenText::ScreenText(OpenGL3DRenderer* pRenderer, TextCache& rTextCache,
     136             :         const OUString& rStr, glm::vec4 rColor, sal_uInt32 nId, bool bIs3dText):
     137             :     Renderable3DObject(pRenderer, nId),
     138           0 :     maText(rTextCache.getText(rStr,bIs3dText)),
     139           0 :     maColor(rColor)
     140             : {
     141           0 : }
     142             : 
     143           0 : void ScreenText::setPosition(const glm::vec2& rTopLeft, const glm::vec2& rBottomRight,
     144             :         const glm::vec3& r3DPos)
     145             : {
     146           0 :     maTopLeft = rTopLeft;
     147           0 :     maBottomRight = rBottomRight;
     148           0 :     ma3DPos = r3DPos;
     149           0 : }
     150             : 
     151           0 : void ScreenText::render()
     152             : {
     153             :     mpRenderer->CreateScreenTextTexture(maText.maPixels, maText.maSize,
     154             :                                         maTopLeft, maBottomRight, ma3DPos, maColor,
     155           0 :                                         mnUniqueId);
     156           0 : }
     157             : 
     158           0 : Rectangle::Rectangle(OpenGL3DRenderer* pRenderer, sal_uInt32 nId):
     159           0 :     Renderable3DObject(pRenderer, nId)
     160             : {
     161           0 : }
     162             : 
     163           0 : void Rectangle::render()
     164             : {
     165           0 :     glm::vec3 dir1 = maBottomRight - maTopLeft;
     166           0 :     glm::vec3 dir2 = maTopRight - maTopLeft;
     167           0 :     glm::vec3 normal = glm::normalize(glm::cross(dir1, dir2));
     168           0 :     mpRenderer->AddShapePolygon3DObject(maColor.GetColor(), false, 0, 1, 0xFFFFFF, mnUniqueId);
     169           0 :     glm::vec3 bottomLeft = maBottomRight - dir2;
     170             :     //set polygon points and normals
     171           0 :     mpRenderer->AddPolygon3DObjectPoint(maBottomRight.x, maBottomRight.y, maBottomRight.z);
     172           0 :     mpRenderer->AddPolygon3DObjectNormalPoint(normal.x, normal.y, normal.z);
     173           0 :     mpRenderer->AddPolygon3DObjectPoint(maTopRight.x, maTopRight.y, maTopRight.z);
     174           0 :     mpRenderer->AddPolygon3DObjectNormalPoint(normal.x, normal.y, normal.z);
     175           0 :     mpRenderer->AddPolygon3DObjectPoint(maTopLeft.x, maTopLeft.y, maTopLeft.z);
     176           0 :     mpRenderer->AddPolygon3DObjectNormalPoint(normal.x, normal.y, normal.z);
     177           0 :     mpRenderer->AddPolygon3DObjectPoint(bottomLeft.x, bottomLeft.y, bottomLeft.z);
     178           0 :     mpRenderer->AddPolygon3DObjectNormalPoint(normal.x, normal.y, normal.z);
     179           0 :     mpRenderer->EndAddPolygon3DObjectPoint();
     180           0 :     mpRenderer->EndAddPolygon3DObjectNormalPoint();
     181           0 :     mpRenderer->EndAddShapePolygon3DObject();
     182             :     //we should render the edge if the edge color is different from the fill color
     183           0 :     if (maColor.GetColor() != maLineColor.GetColor())
     184             :     {
     185           0 :         mpRenderer->AddShapePolygon3DObject(0, true, maLineColor.GetColor(), 0, 0xFFFFFF, mnUniqueId);
     186           0 :         mpRenderer->AddPolygon3DObjectPoint(maBottomRight.x, maBottomRight.y, maBottomRight.z);
     187           0 :         mpRenderer->AddPolygon3DObjectPoint(maTopRight.x, maTopRight.y, maTopRight.z);
     188           0 :         mpRenderer->AddPolygon3DObjectPoint(maTopLeft.x, maTopLeft.y, maTopLeft.z);
     189           0 :         mpRenderer->AddPolygon3DObjectPoint(bottomLeft.x, bottomLeft.y, bottomLeft.z);
     190           0 :         mpRenderer->EndAddPolygon3DObjectPoint();
     191           0 :         mpRenderer->EndAddShapePolygon3DObject();
     192             :     }
     193           0 : }
     194             : 
     195           0 : void Rectangle::setPosition(const glm::vec3& rTopLeft, const glm::vec3& rTopRight, const glm::vec3& rBottomRight)
     196             : {
     197           0 :     maTopLeft = rTopLeft;
     198           0 :     maTopRight = rTopRight;
     199           0 :     maBottomRight = rBottomRight;
     200           0 : }
     201             : 
     202           0 : void Rectangle::setFillColor(const Color& rColor)
     203             : {
     204           0 :     maColor = rColor;
     205           0 : }
     206             : 
     207           0 : void Rectangle::setLineColor(const Color& rColor)
     208             : {
     209           0 :     maLineColor = rColor;
     210           0 : }
     211             : 
     212           0 : Camera::Camera(OpenGL3DRenderer* pRenderer):
     213             :     Renderable3DObject(pRenderer, 0),
     214             :     maPos(10,-50,20),
     215             :     maUp(0, 0, 1),
     216           0 :     maDirection(glm::vec3(0,0,0))
     217             : {
     218           0 : }
     219             : 
     220           0 : void Camera::render()
     221             : {
     222           0 :     mpRenderer->SetCameraInfo(maPos, maDirection, maUp);
     223           0 : }
     224             : 
     225           0 : void Camera::setPosition(const glm::vec3& rPos)
     226             : {
     227           0 :     maPos = rPos;
     228           0 : }
     229             : 
     230           0 : void Camera::setDirection(const glm::vec3& rDir)
     231             : {
     232           0 :     maDirection = rDir;
     233           0 : }
     234             : 
     235             : }
     236             : 
     237             : }
     238             : 
     239             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11