Cleaning for opengl rendering prep.

This commit is contained in:
James Grogan 2022-11-14 11:19:51 +00:00
parent 402f381d10
commit 7c6a92f4ec
58 changed files with 570 additions and 533 deletions

View file

@ -8,9 +8,6 @@ endif()
# Sample Console # Sample Console
add_executable(sample_console console-main.cpp) add_executable(sample_console console-main.cpp)
target_include_directories(sample_console PUBLIC
"${PROJECT_SOURCE_DIR}/src/console"
)
target_link_libraries(sample_console PUBLIC console core network target_link_libraries(sample_console PUBLIC console core network
database geometry audio web) database geometry audio web)

View file

@ -20,8 +20,8 @@ MediaTool::MediaTool(std::unique_ptr<CommandLineArgs> args)
void MediaTool::initializeViews() void MediaTool::initializeViews()
{ {
auto mainWindow = mDesktopManager->GetWindowManager()->GetMainWindow(); auto mainWindow = mDesktopManager->getWindowManager()->getMainWindow();
mainWindow->SetSize(800, 600); mainWindow->setSize(800, 600);
/* /*
auto tabbedPanel = TabbedPanelWidget::Create(); auto tabbedPanel = TabbedPanelWidget::Create();
@ -65,5 +65,5 @@ void MediaTool::initializeViews()
horizontal_spacer->addWidgetWithScale(std::move(button), 1); horizontal_spacer->addWidgetWithScale(std::move(button), 1);
horizontal_spacer->addWidgetWithScale(std::move(background_widget), 1); horizontal_spacer->addWidgetWithScale(std::move(background_widget), 1);
mainWindow->AddWidget(std::move(horizontal_spacer)); mainWindow->setWidget(std::move(horizontal_spacer));
} }

View file

@ -70,8 +70,6 @@ list(APPEND audio_LIB_INCLUDES
add_library(audio SHARED ${audio_LIB_INCLUDES} ${platform_INCLUDES} ${audio_HEADERS} ${platform_HEADERS}) add_library(audio SHARED ${audio_LIB_INCLUDES} ${platform_INCLUDES} ${audio_HEADERS} ${platform_HEADERS})
target_include_directories(audio PUBLIC target_include_directories(audio PUBLIC
"${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}"
"${PROJECT_SOURCE_DIR}/src/core/file_utilities"
"${PROJECT_SOURCE_DIR}/src/core/loggers"
"${CMAKE_CURRENT_SOURCE_DIR}/audio_interfaces" "${CMAKE_CURRENT_SOURCE_DIR}/audio_interfaces"
"${CMAKE_CURRENT_SOURCE_DIR}/midi" "${CMAKE_CURRENT_SOURCE_DIR}/midi"
"${CMAKE_CURRENT_SOURCE_DIR}/midi/reader" "${CMAKE_CURRENT_SOURCE_DIR}/midi/reader"

View file

@ -20,8 +20,6 @@ target_include_directories(client PUBLIC
"${CMAKE_CURRENT_SOURCE_DIR}/audio_editor" "${CMAKE_CURRENT_SOURCE_DIR}/audio_editor"
"${CMAKE_CURRENT_SOURCE_DIR}/image_editor" "${CMAKE_CURRENT_SOURCE_DIR}/image_editor"
"${CMAKE_CURRENT_SOURCE_DIR}/web_client" "${CMAKE_CURRENT_SOURCE_DIR}/web_client"
"${PROJECT_SOURCE_DIR}/src/console"
"${PROJECT_SOURCE_DIR}/src/ui_elements/widgets"
) )
set_property(TARGET client PROPERTY FOLDER src) set_property(TARGET client PROPERTY FOLDER src)
set_target_properties( client PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON ) set_target_properties( client PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON )

View file

@ -39,7 +39,6 @@ void GuiApplication::setUiInterfaceBackend(UiInterfaceFactory::Backend backend)
void GuiApplication::run() void GuiApplication::run()
{ {
auto mainWindow = mDesktopManager->GetWindowManager()->GetMainWindow();
initializeViews(); initializeViews();
MLOG_INFO("Creating Window Interface"); MLOG_INFO("Creating Window Interface");

View file

@ -5,18 +5,7 @@ list(APPEND console_LIB_INCLUDES MainApplication.cpp)
add_library(console SHARED ${console_LIB_INCLUDES} ${console_HEADERS}) add_library(console SHARED ${console_LIB_INCLUDES} ${console_HEADERS})
target_include_directories(console PUBLIC target_include_directories(console PUBLIC
"${PROJECT_SOURCE_DIR}/src/core/" "${CMAKE_CURRENT_SOURCE_DIR}"
"${PROJECT_SOURCE_DIR}/src/core/file_utilities"
"${PROJECT_SOURCE_DIR}/src/core/loggers"
"${PROJECT_SOURCE_DIR}/src/database"
"${PROJECT_SOURCE_DIR}/src/database/database_interfaces"
"${PROJECT_SOURCE_DIR}/src/network"
"${PROJECT_SOURCE_DIR}/src/network/sockets"
"${PROJECT_SOURCE_DIR}/src/audio"
"${PROJECT_SOURCE_DIR}/src/audio/midi"
"${PROJECT_SOURCE_DIR}/src/audio/audio_interfaces"
"${PROJECT_SOURCE_DIR}/src/graphics"
"${PROJECT_SOURCE_DIR}/src/web"
) )
set_property(TARGET console PROPERTY FOLDER src) set_property(TARGET console PROPERTY FOLDER src)
target_link_libraries(console PUBLIC core audio network database web graphics) target_link_libraries(console PUBLIC core audio network database web graphics)

View file

@ -6,13 +6,13 @@
#include "DrawingManager.h" #include "DrawingManager.h"
#include "DrawingSurface.h" #include "DrawingSurface.h"
#include "DrawingContext.h" #include "DrawingContext.h"
#include "Rasterizer.h"
#include "Grid.h" #include "Grid.h"
#include "Image.h" #include "Image.h"
#include "TriMesh.h" #include "TriMesh.h"
#include "AbstractPainter.h"
#include "TextNode.h" #include "TextNode.h"
#include "DiscretePoint.h" #include "DiscretePoint.h"
#include "Scene.h"
#include <filesystem> #include <filesystem>

View file

@ -41,6 +41,7 @@ target_include_directories(core PUBLIC
"${CMAKE_CURRENT_SOURCE_DIR}/loggers" "${CMAKE_CURRENT_SOURCE_DIR}/loggers"
"${CMAKE_CURRENT_SOURCE_DIR}/memory" "${CMAKE_CURRENT_SOURCE_DIR}/memory"
"${CMAKE_CURRENT_SOURCE_DIR}/streams" "${CMAKE_CURRENT_SOURCE_DIR}/streams"
"${CMAKE_CURRENT_SOURCE_DIR}/http"
"${CMAKE_CURRENT_SOURCE_DIR}/data_structures" "${CMAKE_CURRENT_SOURCE_DIR}/data_structures"
"${CMAKE_CURRENT_SOURCE_DIR}/serializers" "${CMAKE_CURRENT_SOURCE_DIR}/serializers"
) )

View file

@ -1,15 +1,33 @@
#pragma once #pragma once
class Rectangle; class Rectangle;
class Point;
template<class T>
class Grid; class Grid;
class AbstractGeometricItem class AbstractGeometricItem
{ {
public: public:
virtual ~AbstractGeometricItem() = default; struct Bounds
{
Bounds(double width, double height)
: mWidth(width),
mHeight(height)
{
//Rectangle GetBounds() const = 0; }
virtual void Sample(Grid* grid) const = 0; double mWidth{0.0};
double mHeight{0.0};
};
virtual ~AbstractGeometricItem() = default;
virtual Bounds getSize() const = 0;
virtual const Point& getLocation() const = 0;
virtual void sample(Grid<unsigned char>* grid) const = 0;
}; };

View file

@ -0,0 +1,50 @@
#include "Grid.h"
template<typename T>
Grid<T>::Grid(const Rectangle& bounds)
: mBounds(bounds)
{
mValues = std::vector<T>(mNumX*mNumY, T());
}
template<typename T>
const Rectangle& Grid<T>::getBounds() const
{
return mBounds;
}
template<typename T>
double Grid<T>::getXSpacing() const
{
return mBounds.getWidth()/double(mNumX);
}
template<typename T>
double Grid<T>::getYSpacing() const
{
return mBounds.getHeight()/double(mNumY);
}
template<typename T>
const std::vector<T>& Grid<T>::getValues() const
{
return mValues;
}
template<typename T>
void Grid<T>::resetBounds(const Rectangle& bounds)
{
mBounds = bounds;
mValues = std::vector<T>(mNumX*mNumY, T());
}
template<typename T>
void Grid<T>::setValues(const std::vector<std::size_t>& indices, T value)
{
for (auto index : indices)
{
mValues[index] = value;
}
}
template class Grid<unsigned char>;

View file

@ -3,54 +3,28 @@
#include "Rectangle.h" #include "Rectangle.h"
#include <vector> #include <vector>
template<typename T>
class Grid class Grid
{ {
public: public:
Grid(const Rectangle& bounds) Grid(const Rectangle& bounds);
: mBounds(bounds)
{
mValues = std::vector<double>(mNumX*mNumY, 0.0);
}
Rectangle GetBounds() const const Rectangle& getBounds() const;
{
return mBounds;
}
double GetXSpacing() const double getXSpacing() const;
{
return mBounds.GetWidth()/double(mNumX);
}
double GetYSpacing() const double getYSpacing() const;
{
return mBounds.GetHeight()/double(mNumY);
}
std::vector<double> GetValues() const const std::vector<T>& getValues() const;
{
return mValues;
}
void ResetBounds(const Rectangle& bounds) void resetBounds(const Rectangle& bounds);
{
mBounds = bounds;
mValues = std::vector<double>(mNumX*mNumY, 0.0);
}
void SetValues(const std::vector<std::size_t>& indices, double value)
{
for (auto index : indices)
{
mValues[index] = value;
}
}
void setValues(const std::vector<std::size_t>& indices, T value);
private: private:
Rectangle mBounds; Rectangle mBounds;
std::vector<double> mValues; std::vector<T> mValues;
unsigned mNumX{5}; unsigned mNumX{5};
unsigned mNumY{5}; unsigned mNumY{5};
}; };

View file

@ -1,28 +1,43 @@
#include "LineSegment.h" #include "LineSegment.h"
LineSegment::LineSegment(PointPtr p0, PointPtr p1) LineSegment::LineSegment(const Point& p0, const Point& p1)
: mP0(p0), : mP0(p0),
mP1(p1) mP1(p1)
{ {
} }
std::shared_ptr<LineSegment> LineSegment::Create(PointPtr p0, PointPtr p1) std::unique_ptr<LineSegment> LineSegment::Create(const Point& p0, const Point& p1)
{ {
return std::make_shared<LineSegment>(p0, p1); return std::make_unique<LineSegment>(p0, p1);
} }
double LineSegment::getLength() const double LineSegment::getLength() const
{ {
return mP0->getDistance(mP1.get()); return mP0.getDistance(mP1);
} }
Point* LineSegment::getPoint0() const const Point& LineSegment::getPoint0() const
{ {
return mP0.get(); return mP0;
} }
Point* LineSegment::getPoint1() const const Point& LineSegment::getPoint1() const
{ {
return mP1.get(); return mP1;
}
void LineSegment::sample(Grid<unsigned char>* grid) const
{
}
LineSegment::Bounds LineSegment::getSize() const
{
return {mP0.getDeltaX(mP1), mP0.getDeltaY(mP1)};
}
const Point& LineSegment::getLocation() const
{
return mP0;
} }

View file

@ -3,25 +3,29 @@
#include "AbstractGeometricItem.h" #include "AbstractGeometricItem.h"
#include "Point.h" #include "Point.h"
template<class T>
class Grid;
class LineSegment : public AbstractGeometricItem class LineSegment : public AbstractGeometricItem
{ {
public: public:
LineSegment(PointPtr p0, PointPtr p1); LineSegment(const Point& p0, const Point& p1);
static std::shared_ptr<LineSegment> Create(PointPtr p0, PointPtr p1); static std::unique_ptr<LineSegment> Create(const Point& p0, const Point& p1);
double getLength() const; double getLength() const;
Point* getPoint0() const; const Point& getPoint0() const;
Point* getPoint1() const; const Point& getPoint1() const;
void Sample(Grid* grid) const void sample(Grid<unsigned char>* grid) const override;
{
} Bounds getSize() const override;
const Point& getLocation() const override;
private: private:
PointPtr mP0; Point mP0;
PointPtr mP1; Point mP1;
}; };

View file

@ -0,0 +1,38 @@
#include "Rectangle.h"
Rectangle::Rectangle(const Point& bottomLeft, const Point& topRight)
: mBottomLeft(bottomLeft)
{
mHeight = mBottomLeft.getDeltaY(topRight);
mWidth = mBottomLeft.getDeltaX(topRight);
}
Rectangle Rectangle::getBounds() const
{
return Rectangle(mBottomLeft, Point(mBottomLeft, mWidth, mHeight));
}
void Rectangle::sample(Grid<unsigned char>* grid) const
{
}
double Rectangle::getHeight() const
{
return mHeight;
}
double Rectangle::getWidth() const
{
return mWidth;
}
const Point& Rectangle::getLocation() const
{
return mBottomLeft;
}
Rectangle::Bounds Rectangle::getSize() const
{
return {mWidth, mHeight};
}

View file

@ -3,43 +3,29 @@
#include "AbstractGeometricItem.h" #include "AbstractGeometricItem.h"
#include "Point.h" #include "Point.h"
template<class T>
class Grid;
class Rectangle : public AbstractGeometricItem class Rectangle : public AbstractGeometricItem
{ {
public: public:
Rectangle(const Point& bottomLeft, const Point& topRight) Rectangle(const Point& bottomLeft, const Point& topRight);
: mBottomLeft(bottomLeft),
mTopRight(topRight)
{
} double getHeight() const;
Rectangle GetBounds() const double getWidth() const;
{
return Rectangle(mBottomLeft, mTopRight);
}
void Sample(Grid* grid) const override const Point& getLocation() const override;
{
} Bounds getSize() const override;
double GetHeight() const Rectangle getBounds() const;
{
return mBottomLeft.getDeltaY(mTopRight);
}
double GetWidth() const void sample(Grid<unsigned char>* grid) const override;
{
return mBottomLeft.getDeltaX(mTopRight);
}
Point getBottomLeft() const
{
return mBottomLeft;
}
private: private:
Point mBottomLeft; Point mBottomLeft;
Point mTopRight; double mWidth{0};
double mHeight{0};
}; };

View file

@ -0,0 +1,10 @@
#pragma once
class DrawingContext;
class AbstractPainter
{
public:
virtual ~AbstractPainter() = default;
virtual void paint(DrawingContext* context) = 0;
};

View file

@ -7,23 +7,21 @@ list(APPEND graphics_LIB_INCLUDES
DrawingContext.cpp DrawingContext.cpp
DrawingManager.cpp DrawingManager.cpp
DrawingSurface.cpp DrawingSurface.cpp
Rasterizer.cpp RasterPainter.cpp
${platform_LIB_INCLUDES} ${platform_LIB_INCLUDES}
) )
list(APPEND graphics_HEADERS list(APPEND graphics_HEADERS
${platform_HEADERS} ${platform_HEADERS}
Rasterizer.h RasterPainter.h
INativeDrawingSurface.h
INativeDrawingContext.h
) )
set(OpenGL_GL_PREFERENCE "GLVND") set(OpenGL_GL_PREFERENCE "GLVND")
find_package(OpenGL QUIET) find_package(OpenGL QUIET)
if (OpenGL_FOUND) if (OpenGL_FOUND)
list(APPEND platform_LIBS OpenGL::GL) list(APPEND platform_LIBS OpenGL::GL)
list(APPEND graphics_LIB_INCLUDES opengl/OpenGlInterface.cpp) list(APPEND graphics_LIB_INCLUDES opengl/OpenGlPainter.cpp)
list(APPEND graphics_HEADERS opengl/OpenGlInterface.h) list(APPEND graphics_HEADERS opengl/OpenGlPainter.h)
else() else()
message(STATUS "OpenGL headers not found - skipping OpenGL support") message(STATUS "OpenGL headers not found - skipping OpenGL support")
endif() endif()
@ -35,11 +33,7 @@ add_library(graphics SHARED
target_include_directories(graphics PUBLIC target_include_directories(graphics PUBLIC
${platform_INCLUDE_DIRS} ${platform_INCLUDE_DIRS}
"${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}"
"${CMAKE_CURRENT_SOURCE_DIR}/cairo"
"${CMAKE_CURRENT_SOURCE_DIR}/opengl" "${CMAKE_CURRENT_SOURCE_DIR}/opengl"
"${PROJECT_SOURCE_DIR}/src/geometry/"
"${PROJECT_SOURCE_DIR}/src/image/"
"${PROJECT_SOURCE_DIR}/src/visual_elements/"
) )
target_link_libraries(graphics PUBLIC visual_elements image ${platform_LIBS}) target_link_libraries(graphics PUBLIC visual_elements image ${platform_LIBS})

View file

@ -1,43 +1,53 @@
#include "DrawingContext.h" #include "DrawingContext.h"
#include "INativeDrawingContext.h"
#include "AbstractGeometricItem.h" #include "AbstractGeometricItem.h"
#include "AbstractPainter.h"
#include "OpenGlPainter.h"
#include "RasterPainter.h"
#include "DrawingSurface.h"
#include "Scene.h"
#include "Grid.h"
#include "MeshBuilder.h" #include "MeshBuilder.h"
#include "TriMesh.h" #include "TriMesh.h"
std::unique_ptr<DrawingContext> DrawingContext::Create() DrawingContext::DrawingContext(DrawingSurface* surface, DrawingMode requestedDrawingMode)
: mSurface(surface),
mDrawingMode(requestedDrawingMode),
mScene(std::make_unique<Scene>())
{ {
return std::make_unique<DrawingContext>(); if (mDrawingMode == DrawingMode::GRAPH)
{
mPainter = std::make_unique<OpenGlPainter>();
}
else
{
mPainter = std::make_unique<RasterPainter>();
}
} }
void DrawingContext::setNativeContext(std::unique_ptr<INativeDrawingContext> context) std::unique_ptr<DrawingContext> DrawingContext::Create(DrawingSurface* surface, DrawingMode requestedDrawingMode)
{ {
mNativeDrawingContext = std::move(context); return std::make_unique<DrawingContext>(surface, requestedDrawingMode);
}
INativeDrawingContext* DrawingContext::getNativeContext()
{
return mNativeDrawingContext.get();
}
void DrawingContext::addDrawable(AbstractGeometricItemPtr item)
{
mItems.push_back(std::move(item));
}
unsigned DrawingContext::getNumItems() const
{
return mItems.size();
}
AbstractGeometricItem* DrawingContext::getDrawable(unsigned idx) const
{
return mItems[idx].get();
} }
void DrawingContext::updateMesh() void DrawingContext::updateMesh()
{ {
} }
Scene* DrawingContext::getScene() const
{
return mScene.get();
}
DrawingSurface* DrawingContext::getSurface() const
{
return mSurface;
}
void DrawingContext::paint()
{
}

View file

@ -3,35 +3,38 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
class INativeDrawingContext; class Scene;
class AbstractGeometricItem; class AbstractPainter;
using AbstractGeometricItemPtr = std::unique_ptr<AbstractGeometricItem>; class DrawingSurface;
class TriMesh; class TriMesh;
enum class DrawingMode
{
RASTER,
GRAPH
};
class DrawingContext class DrawingContext
{ {
public: public:
DrawingContext() = default; DrawingContext(DrawingSurface* surface, DrawingMode requestedDrawingMode);
static std::unique_ptr<DrawingContext> Create(); static std::unique_ptr<DrawingContext> Create(DrawingSurface* surface, DrawingMode requestedDrawingMode);
void setNativeContext(std::unique_ptr<INativeDrawingContext> context); Scene* getScene() const;
INativeDrawingContext* getNativeContext(); DrawingSurface* getSurface() const;
unsigned getNumItems() const; void paint();
void addDrawable(AbstractGeometricItemPtr item);
AbstractGeometricItem* getDrawable(unsigned idx) const;
private: private:
void updateMesh(); void updateMesh();
DrawingMode mDrawingMode;
std::unique_ptr<TriMesh> mMesh; std::unique_ptr<TriMesh> mMesh;
std::vector<std::unique_ptr<AbstractGeometricItem> > mItems; std::unique_ptr<Scene> mScene;
std::unique_ptr<INativeDrawingContext> mNativeDrawingContext; DrawingSurface* mSurface{nullptr};
std::unique_ptr<AbstractPainter> mPainter;
}; };
using DrawingContextPtr = std::unique_ptr<DrawingContext>; using DrawingContextPtr = std::unique_ptr<DrawingContext>;

View file

@ -1,16 +1,15 @@
#include "DrawingManager.h" #include "DrawingManager.h"
#include "INativeDrawingContext.h"
#include "DrawingSurface.h" #include "DrawingSurface.h"
#include "DrawingContext.h" #include "DrawingContext.h"
#include "Rasterizer.h" #include "AbstractPainter.h"
#include "Grid.h" #include "Grid.h"
#include "Image.h" #include "Image.h"
#include "TriMesh.h" #include "TriMesh.h"
#include "Scene.h"
DrawingManager::DrawingManager() DrawingManager::DrawingManager()
: mRasterizer(std::make_unique<Rasterizer>())
{ {
} }
@ -23,12 +22,12 @@ std::unique_ptr<DrawingManager> DrawingManager::Create()
void DrawingManager::InitalizeSurface(unsigned width, unsigned height) void DrawingManager::InitalizeSurface(unsigned width, unsigned height)
{ {
mDrawingSurface = DrawingSurface::Create(); mDrawingSurface = DrawingSurface::Create();
mDrawingSurface->SetSize(width, height); mDrawingSurface->setSize(width, height);
} }
void DrawingManager::InitializeContext() void DrawingManager::InitializeContext()
{ {
mDrawingContext = DrawingContext::Create(); //mDrawingContext = DrawingContext::Create();
} }
void DrawingManager::AddText(TextNode* text) void DrawingManager::AddText(TextNode* text)

View file

@ -2,8 +2,6 @@
#include <memory> #include <memory>
#include <string> #include <string>
#include "INativeDrawingContext.h"
#include "INativeDrawingSurface.h"
class TextNode; class TextNode;
@ -12,8 +10,6 @@ using DrawingSurfacePtr = std::unique_ptr<DrawingSurface>;
class DrawingContext; class DrawingContext;
using DrawingContextPtr = std::unique_ptr<DrawingContext>; using DrawingContextPtr = std::unique_ptr<DrawingContext>;
class Rasterizer;
class DrawingManager class DrawingManager
{ {
public: public:
@ -25,7 +21,6 @@ public:
void RenderToFile(const std::string& path); void RenderToFile(const std::string& path);
private: private:
std::unique_ptr<Rasterizer> mRasterizer;
DrawingSurfacePtr mDrawingSurface {nullptr}; DrawingSurfacePtr mDrawingSurface {nullptr};
DrawingContextPtr mDrawingContext {nullptr}; DrawingContextPtr mDrawingContext {nullptr};
}; };

View file

@ -7,40 +7,28 @@ std::unique_ptr<DrawingSurface> DrawingSurface::Create()
return std::make_unique<DrawingSurface>(); return std::make_unique<DrawingSurface>();
} }
INativeDrawingSurface* DrawingSurface::GetNativeSurface() void DrawingSurface::setSize(unsigned width, unsigned height)
{
if (mNativeDrawingSurface)
{
return mNativeDrawingSurface.get();
}
else
{
return nullptr;
}
}
void DrawingSurface::SetNativeSurface(std::unique_ptr<INativeDrawingSurface> surface)
{
mNativeDrawingSurface = std::move(surface);
}
void DrawingSurface::SetSize(unsigned width, unsigned height)
{ {
mWidth = width; mWidth = width;
mHeight = height; mHeight = height;
} }
unsigned DrawingSurface::GetWidth() const unsigned DrawingSurface::getWidth() const
{ {
return mWidth; return mWidth;
} }
unsigned DrawingSurface::GetHeight() const unsigned DrawingSurface::getHeight() const
{ {
return mHeight; return mHeight;
} }
void DrawingSurface::Paint(Grid* grid) Image<unsigned char>* DrawingSurface::getImage()
{ {
//mImageBuffer = std::make_unique<Image>(); if (!mBackingImage)
{
mBackingImage = std::make_unique<Image<unsigned char> >(mWidth, mHeight);
mBackingImage->initialize();
}
return mBackingImage.get();
} }

View file

@ -2,36 +2,27 @@
#include <memory> #include <memory>
#include "INativeDrawingSurface.h" template<typename T>
#include "Image.h" class Image;
class Grid;
class DrawingSurface class DrawingSurface
{ {
public: public:
DrawingSurface() = default; DrawingSurface() = default;
virtual ~DrawingSurface() = default;
static std::unique_ptr<DrawingSurface> Create(); static std::unique_ptr<DrawingSurface> Create();
INativeDrawingSurface* GetNativeSurface(); void setSize(unsigned width, unsigned height);
void SetNativeSurface(std::unique_ptr<INativeDrawingSurface> surface); unsigned getWidth() const;
void SetSize(unsigned width, unsigned height); unsigned getHeight() const;
unsigned GetWidth() const; Image<unsigned char>* getImage();
unsigned GetHeight() const;
void Paint(Grid* grid);
Image<unsigned char>* GetAsImage() const;
private:
protected:
unsigned mWidth = 0; unsigned mWidth = 0;
unsigned mHeight = 0; unsigned mHeight = 0;
std::unique_ptr<Image<unsigned char> > mImageBuffer; std::unique_ptr<Image<unsigned char> > mBackingImage;
std::unique_ptr<INativeDrawingSurface> mNativeDrawingSurface;
}; };

View file

@ -1,8 +0,0 @@
#pragma once
class INativeDrawingContext
{
public:
virtual ~INativeDrawingContext() = default;
};

View file

@ -1,9 +0,0 @@
#pragma once
class INativeDrawingSurface
{
public:
virtual ~INativeDrawingSurface() = default;
virtual void DestroyNativeSurface() = 0;
};

View file

@ -0,0 +1,27 @@
#include "RasterPainter.h"
#include "DrawingSurface.h"
#include "DrawingContext.h"
#include "Grid.h"
RasterPainter::RasterPainter()
: mGrid(std::make_unique<Grid<unsigned char> >(Rectangle(Point(0, 0), Point(100, 100))))
{
}
void RasterPainter::paint(DrawingContext* context)
{
const auto width = context->getSurface()->getWidth();
const auto height = context->getSurface()->getHeight();
mGrid->resetBounds(Rectangle(Point(0, 0), Point(width, height)));
/*
for (unsigned idx=0; idx< context->getNumItems(); idx++)
{
context->getDrawable(idx)->sample(mGrid.get());
}
context->getSurface()->getImage()->setData(mGrid->getValues());
*/
}

View file

@ -0,0 +1,20 @@
#pragma once
#include "AbstractPainter.h"
#include <memory>
class DrawingContext;
template<class T>
class Grid;
class RasterPainter : public AbstractPainter
{
public:
RasterPainter();
void paint(DrawingContext* context) override;
private:
std::unique_ptr<Grid<unsigned char> > mGrid;
};

View file

@ -1,25 +0,0 @@
#include "Rasterizer.h"
#include "DrawingSurface.h"
#include "DrawingContext.h"
#include "Grid.h"
Rasterizer::Rasterizer()
: mGrid(std::make_unique<Grid>(Rectangle(Point(0, 0), Point(100, 100))))
{
}
void Rasterizer::Paint(DrawingSurface* surface, DrawingContext* context)
{
const auto width = surface->GetWidth();
const auto height = surface->GetHeight();
mGrid->ResetBounds(Rectangle(Point(0, 0), Point(width, height)));
for (unsigned idx=0; idx< context->getNumItems(); idx++)
{
context->getDrawable(idx)->Sample(mGrid.get());
}
surface->Paint(mGrid.get());
}

View file

@ -1,18 +0,0 @@
#pragma once
#include <memory>
class DrawingSurface;
class DrawingContext;
class Grid;
class Rasterizer
{
public:
Rasterizer();
void Paint(DrawingSurface* surface, DrawingContext* context);
private:
std::unique_ptr<Grid> mGrid;
};

View file

@ -1,11 +0,0 @@
#pragma once
class TriMesh;
class OpenGlInterface
{
public:
static void draw(TriMesh* mesh);
};

View file

@ -1,11 +1,14 @@
#include "OpenGlInterface.h" #include "OpenGlPainter.h"
#include "DrawingContext.h"
#ifdef _WIN32 #ifdef _WIN32
#include <windows.h> #include <windows.h>
#endif #endif
#include <GL/gl.h> #include <GL/gl.h>
void OpenGlInterface::draw(TriMesh* mesh) void OpenGlPainter::paint(DrawingContext* context)
{ {
glClearColor(0.4, 0.4, 0.4, 0.4); glClearColor(0.4, 0.4, 0.4, 0.4);
glClear(GL_COLOR_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT);
@ -13,8 +16,6 @@ void OpenGlInterface::draw(TriMesh* mesh)
glColor3f(1.0, 1.0, 1.0); glColor3f(1.0, 1.0, 1.0);
glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0); glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
glBegin(GL_TRIANGLES); glBegin(GL_TRIANGLES);
glVertex3f(-0.7, 0.7, 0); glVertex3f(-0.7, 0.7, 0);
glVertex3f(0.7, 0.7, 0); glVertex3f(0.7, 0.7, 0);

View file

@ -0,0 +1,13 @@
#pragma once
#include "AbstractPainter.h"
class DrawingContext;
class OpenGlPainter : public AbstractPainter
{
public:
void paint(DrawingContext* context) override;
};

View file

@ -23,7 +23,6 @@ target_include_directories(network PUBLIC
"${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}"
"${CMAKE_CURRENT_SOURCE_DIR}/sockets" "${CMAKE_CURRENT_SOURCE_DIR}/sockets"
"${CMAKE_CURRENT_SOURCE_DIR}/web" "${CMAKE_CURRENT_SOURCE_DIR}/web"
"${PROJECT_SOURCE_DIR}/src/core/http"
) )
set_target_properties( network PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON ) set_target_properties( network PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON )
target_link_libraries( network PUBLIC core) target_link_libraries( network PUBLIC core)

View file

@ -24,16 +24,13 @@ list(APPEND ui_elements_LIB_INCLUDES
add_library(ui_elements SHARED ${ui_elements_LIB_INCLUDES}) add_library(ui_elements SHARED ${ui_elements_LIB_INCLUDES})
target_include_directories(ui_elements PUBLIC target_include_directories(ui_elements PUBLIC
"${PROJECT_SOURCE_DIR}/src/core/"
"${PROJECT_SOURCE_DIR}/src/geometry/"
"${PROJECT_SOURCE_DIR}/src/visual_elements"
"${CMAKE_CURRENT_SOURCE_DIR}/" "${CMAKE_CURRENT_SOURCE_DIR}/"
"${CMAKE_CURRENT_SOURCE_DIR}/widgets" "${CMAKE_CURRENT_SOURCE_DIR}/widgets"
"${CMAKE_CURRENT_SOURCE_DIR}/widgets/elements" "${CMAKE_CURRENT_SOURCE_DIR}/widgets/elements"
"${CMAKE_CURRENT_SOURCE_DIR}/ui_events" "${CMAKE_CURRENT_SOURCE_DIR}/ui_events"
"${CMAKE_CURRENT_SOURCE_DIR}/desktop_elements" "${CMAKE_CURRENT_SOURCE_DIR}/desktop_elements"
) )
target_link_libraries(ui_elements PUBLIC core geometry visual_elements image) target_link_libraries(ui_elements PUBLIC core geometry graphics visual_elements image)
set_property(TARGET ui_elements PROPERTY FOLDER src) set_property(TARGET ui_elements PROPERTY FOLDER src)

View file

@ -12,7 +12,8 @@ class IPlatformSurface
{ {
public: public:
virtual ~IPlatformSurface() = default; virtual ~IPlatformSurface() = default;
virtual void paint(mt::Screen* screen) = 0; virtual void beforePaint(mt::Screen* screen) = 0;
virtual void afterPaint(mt::Screen* screen) = 0;
}; };
class IPlatformWindow : public IPlatformSurface class IPlatformWindow : public IPlatformSurface
@ -31,6 +32,7 @@ public:
virtual void map() = 0; virtual void map() = 0;
virtual void clear() = 0; virtual void clear() = 0;
protected: protected:
mt::Window* mWindow{nullptr}; mt::Window* mWindow{nullptr};
}; };

View file

@ -1,23 +1,30 @@
#include "Window.h" #include "Window.h"
#include "IPlatformWindow.h"
#include "PaintEvent.h" #include "PaintEvent.h"
#include "MouseEvent.h" #include "MouseEvent.h"
#include "VisualLayer.h"
#include "KeyboardEvent.h" #include "KeyboardEvent.h"
#include "Image.h"
#include "Widget.h"
#include "VisualLayer.h"
#include "Scene.h"
#include "TriMesh.h"
#include "AbstractPainter.h"
#include "DrawingContext.h"
#include "IPlatformWindow.h"
#include "Screen.h" #include "Screen.h"
#include "Image.h"
namespace mt namespace mt
{ {
Window::Window() Window::Window()
:mWidth(800), : DrawingSurface(),
mHeight(600), mWidget(Widget::Create())
mBackingImage(std::make_unique<Image<uint8_t> >(mWidth, mHeight)),
mWidget(Widget::Create())
{ {
mWidget->setBounds(mWidth, mHeight); mWidget->setBounds(mWidth, mHeight);
mWidth = 800;
mHeight = 600;
} }
Window::~Window() Window::~Window()
@ -30,33 +37,27 @@ std::unique_ptr<Window> Window::Create()
return std::make_unique<Window>(); return std::make_unique<Window>();
} }
std::vector<VisualLayer*> Window::GetLayers()
{
return mWidget->getLayers();
}
void Window::clearPlatformWindow() void Window::clearPlatformWindow()
{ {
mPlatformWindow.reset(); mPlatformWindow.reset();
} }
void Window::onMouseEvent(const MouseEvent* event)
void Window::OnMouseEvent(const MouseEvent* event)
{ {
mWidget->onMouseEvent(event); mWidget->onMouseEvent(event);
} }
void Window::OnKeyboardEvent(const KeyboardEvent* event) void Window::onKeyboardEvent(const KeyboardEvent* event)
{ {
mWidget->onKeyboardEvent(event); mWidget->onKeyboardEvent(event);
} }
void Window::OnPaint(const PaintEvent* event) void Window::onPaint(const PaintEvent* event)
{ {
mWidget->onPaintEvent(event); mWidget->onPaintEvent(event);
} }
void Window::AddWidget(WidgetUPtr widget) void Window::setWidget(WidgetPtr widget)
{ {
if (mWidget) if (mWidget)
{ {
@ -66,29 +67,7 @@ void Window::AddWidget(WidgetUPtr widget)
mWidget->setBounds(mWidth, mHeight); mWidget->setBounds(mWidth, mHeight);
} }
Widget* Window::GetWidget() const IPlatformWindow* Window::getPlatformWindow() const
{
return mWidget.get();
}
unsigned Window::GetWidth() const
{
return mWidth;
}
unsigned Window::GetHeight() const
{
return mHeight;
}
void Window::SetSize(unsigned width, unsigned height)
{
mWidth = width;
mHeight = height;
mWidget->setBounds(mWidth, mHeight);
}
IPlatformWindow* Window::GetPlatformWindow() const
{ {
if (mPlatformWindow) if (mPlatformWindow)
{ {
@ -97,14 +76,10 @@ IPlatformWindow* Window::GetPlatformWindow() const
return nullptr; return nullptr;
} }
void Window::SetPlatformWindow(IPlatformWindowPtr window) void Window::setPlatformWindow(IPlatformWindowPtr window, DrawingMode drawingMode)
{ {
mPlatformWindow = std::move(window); mPlatformWindow = std::move(window);
} mDrawingContext = std::make_unique<DrawingContext>(this, drawingMode);
Image<uint8_t>* Window::getBackingImage() const
{
return mBackingImage.get();
} }
void Window::map() void Window::map()
@ -127,7 +102,13 @@ void Window::doPaint(mt::Screen* screen)
{ {
if (mPlatformWindow) if (mPlatformWindow)
{ {
mPlatformWindow->paint(screen); mPlatformWindow->beforePaint(screen);
mDrawingContext->getScene()->setLayers(mWidget->getLayers());
mDrawingContext->paint();
mPlatformWindow->afterPaint(screen);
} }
} }

View file

@ -1,7 +1,6 @@
#pragma once #pragma once
#include "Widget.h" #include "DrawingSurface.h"
#include "Image.h"
#include <memory> #include <memory>
#include <vector> #include <vector>
@ -10,7 +9,11 @@
class PaintEvent; class PaintEvent;
class MouseEvent; class MouseEvent;
class KeyboardEvent; class KeyboardEvent;
class VisualLayer;
class DrawingContext;
enum class DrawingMode;
class Widget;
using WidgetPtr = std::unique_ptr<Widget>;
class IPlatformWindow; class IPlatformWindow;
using IPlatformWindowPtr = std::unique_ptr<IPlatformWindow>; using IPlatformWindowPtr = std::unique_ptr<IPlatformWindow>;
@ -19,7 +22,7 @@ namespace mt
class Screen; class Screen;
class Window class Window : public DrawingSurface
{ {
public: public:
@ -30,29 +33,17 @@ public:
static std::unique_ptr<Window> Create(); static std::unique_ptr<Window> Create();
void AddWidget(WidgetUPtr widget); void setWidget(WidgetPtr widget);
Widget* GetWidget() const; void onPaint(const PaintEvent* event);
std::vector<VisualLayer*> GetLayers(); void onMouseEvent(const MouseEvent* event);
unsigned GetWidth() const; void onKeyboardEvent(const KeyboardEvent* event);
unsigned GetHeight() const; IPlatformWindow* getPlatformWindow() const;
void SetSize(unsigned width, unsigned height); void setPlatformWindow(IPlatformWindowPtr window, DrawingMode drawingMode);
void OnPaint(const PaintEvent* event);
void OnMouseEvent(const MouseEvent* event);
void OnKeyboardEvent(const KeyboardEvent* event);
IPlatformWindow* GetPlatformWindow() const;
void SetPlatformWindow(IPlatformWindowPtr window);
Image<uint8_t>* getBackingImage() const;
void map(); void map();
@ -65,12 +56,9 @@ public:
void clearPlatformWindow(); void clearPlatformWindow();
private: private:
int mHandle {-1}; WidgetPtr mWidget {nullptr};
WidgetUPtr mWidget {nullptr};
unsigned mWidth {800};
unsigned mHeight {600};
IPlatformWindowPtr mPlatformWindow {nullptr}; IPlatformWindowPtr mPlatformWindow {nullptr};
std::unique_ptr<Image<uint8_t> > mBackingImage; std::unique_ptr<DrawingContext> mDrawingContext;
}; };
} }

View file

@ -3,17 +3,17 @@ list(APPEND visual_elements_LIB_INCLUDES
RectangleNode.cpp RectangleNode.cpp
TextNode.cpp TextNode.cpp
VisualLayer.cpp VisualLayer.cpp
Scene.cpp
) )
add_library(visual_elements SHARED ${visual_elements_LIB_INCLUDES}) add_library(visual_elements SHARED ${visual_elements_LIB_INCLUDES})
target_include_directories(visual_elements PUBLIC target_include_directories(visual_elements PUBLIC
"${PROJECT_SOURCE_DIR}/src/core/" "${CMAKE_CURRENT_SOURCE_DIR}"
"${PROJECT_SOURCE_DIR}/src/geometry/"
) )
target_link_libraries(visual_elements PUBLIC core geometry mesh image) target_link_libraries(visual_elements PUBLIC core geometry mesh image)
set_property(TARGET visual_elements PROPERTY FOLDER src) set_property(TARGET visual_elements PROPERTY FOLDER src)
set_target_properties( visual_elements PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON ) set_target_properties( visual_elements PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON )

View file

@ -0,0 +1,23 @@
#pragma once
#include <vector>
class VisualLayer;
class Scene
{
public:
Scene() = default;
void setLayers(const std::vector<VisualLayer*>& layers)
{
mLayers = layers;
}
const std::vector<VisualLayer*>& getLayers() const
{
return mLayers;
}
private:
std::vector<VisualLayer*> mLayers;
};

View file

@ -23,9 +23,6 @@ list(APPEND web_LIB_INCLUDES
add_library(web SHARED ${web_LIB_INCLUDES}) add_library(web SHARED ${web_LIB_INCLUDES})
target_include_directories(web PUBLIC target_include_directories(web PUBLIC
"${PROJECT_SOURCE_DIR}/src/core/"
"${PROJECT_SOURCE_DIR}/src/core/loggers"
"${PROJECT_SOURCE_DIR}/src/core/file_utilities"
"${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}"
"${CMAKE_CURRENT_SOURCE_DIR}/xml" "${CMAKE_CURRENT_SOURCE_DIR}/xml"
"${CMAKE_CURRENT_SOURCE_DIR}/xml/xml-elements" "${CMAKE_CURRENT_SOURCE_DIR}/xml/xml-elements"

View file

@ -88,11 +88,6 @@ target_include_directories(windows PUBLIC
"${CMAKE_CURRENT_SOURCE_DIR}/ui_interfaces/x11" "${CMAKE_CURRENT_SOURCE_DIR}/ui_interfaces/x11"
"${CMAKE_CURRENT_SOURCE_DIR}/ui_interfaces/wayland" "${CMAKE_CURRENT_SOURCE_DIR}/ui_interfaces/wayland"
"${CMAKE_CURRENT_SOURCE_DIR}/ui_interfaces/win32" "${CMAKE_CURRENT_SOURCE_DIR}/ui_interfaces/win32"
"${PROJECT_SOURCE_DIR}/src/core"
"${PROJECT_SOURCE_DIR}/src/geometry"
"${PROJECT_SOURCE_DIR}/src/graphics"
"${PROJECT_SOURCE_DIR}/src/ui_elements"
"${PROJECT_SOURCE_DIR}/src/ui_elements/widgets"
${WAYLAND_INCLUDE_DIRS} ${WAYLAND_INCLUDE_DIRS}
${X11_INCLUDE_DIRS} ${X11_INCLUDE_DIRS}
) )

View file

@ -25,32 +25,32 @@ std::unique_ptr<DesktopManager> DesktopManager::Create(AbstractDesktopApp* appli
return std::make_unique<DesktopManager>(application); return std::make_unique<DesktopManager>(application);
} }
void DesktopManager::ClearEvents() void DesktopManager::clearEvents()
{ {
mEventManager->ClearEvents(); mEventManager->ClearEvents();
} }
void DesktopManager::OnKeyboardEvent(const KeyboardEvent* event) void DesktopManager::onKeyboardEvent(const KeyboardEvent* event)
{ {
GetWindowManager()->OnKeyboardEvent(event); mWindowManager->onKeyboardEvent(event);
} }
void DesktopManager::OnPaintEvent(const PaintEvent* event) void DesktopManager::onPaintEvent(const PaintEvent* event)
{ {
GetWindowManager()->OnPaintEvent(event); mWindowManager->onPaintEvent(event);
} }
void DesktopManager::OnMouseEvent(const MouseEvent* event) void DesktopManager::onMouseEvent(const MouseEvent* event)
{ {
GetWindowManager()->OnMouseEvent(event); mWindowManager->onMouseEvent(event);
} }
bool DesktopManager::IsModified() const bool DesktopManager::isModified() const
{ {
return mModified; return mModified;
} }
void DesktopManager::OnUiEvent(UiEventUPtr eventUPtr) void DesktopManager::onUiEvent(UiEventUPtr eventUPtr)
{ {
mModified = false; mModified = false;
const auto event = mEventManager->AddEvent(std::move(eventUPtr)); const auto event = mEventManager->AddEvent(std::move(eventUPtr));
@ -58,19 +58,19 @@ void DesktopManager::OnUiEvent(UiEventUPtr eventUPtr)
{ {
case (UiEvent::Type::Paint): case (UiEvent::Type::Paint):
{ {
OnPaintEvent(dynamic_cast<const PaintEvent*>(event)); onPaintEvent(dynamic_cast<const PaintEvent*>(event));
break; break;
} }
case (UiEvent::Type::Keyboard): case (UiEvent::Type::Keyboard):
{ {
OnKeyboardEvent(dynamic_cast<const KeyboardEvent*>(event)); onKeyboardEvent(dynamic_cast<const KeyboardEvent*>(event));
mModified = true; mModified = true;
break; break;
} }
case (UiEvent::Type::Mouse): case (UiEvent::Type::Mouse):
{ {
auto mouseEvent = dynamic_cast<const MouseEvent*>(event); auto mouseEvent = dynamic_cast<const MouseEvent*>(event);
OnMouseEvent(mouseEvent); onMouseEvent(mouseEvent);
if (mouseEvent->GetAction() == MouseEvent::Action::Pressed) if (mouseEvent->GetAction() == MouseEvent::Action::Pressed)
{ {
mModified = true; mModified = true;
@ -86,17 +86,17 @@ void DesktopManager::OnUiEvent(UiEventUPtr eventUPtr)
} }
} }
void DesktopManager::SetIsModified(bool modified) void DesktopManager::setIsModified(bool modified)
{ {
mModified = modified; mModified = modified;
} }
Keyboard* DesktopManager::GetKeyboard() const Keyboard* DesktopManager::getKeyboard() const
{ {
return mKeyboard.get(); return mKeyboard.get();
} }
void DesktopManager::SetKeyboard(KeyboardUPtr keyboard) void DesktopManager::setKeyboard(KeyboardUPtr keyboard)
{ {
mKeyboard = std::move(keyboard); mKeyboard = std::move(keyboard);
} }
@ -106,12 +106,12 @@ AbstractApp* DesktopManager::getMainApp() const
return mUiApplication->getMainApplication(); return mUiApplication->getMainApplication();
} }
void DesktopManager::AddScreen(ScreenPtr screen) void DesktopManager::addScreen(ScreenPtr screen)
{ {
mScreens.push_back(std::move(screen)); mScreens.push_back(std::move(screen));
} }
mt::Screen* DesktopManager::GetDefaultScreen() const mt::Screen* DesktopManager::getDefaultScreen() const
{ {
if (mScreens.size() > 0) if (mScreens.size() > 0)
{ {
@ -120,12 +120,12 @@ mt::Screen* DesktopManager::GetDefaultScreen() const
return nullptr; return nullptr;
} }
void DesktopManager::SetWindowManager(WindowManagerUPtr windowManager) void DesktopManager::setWindowManager(WindowManagerUPtr windowManager)
{ {
mWindowManager = std::move(windowManager); mWindowManager = std::move(windowManager);
} }
WindowManager* DesktopManager::GetWindowManager() const WindowManager* DesktopManager::getWindowManager() const
{ {
return mWindowManager.get(); return mWindowManager.get();
} }

View file

@ -25,33 +25,33 @@ public:
static std::unique_ptr<DesktopManager> Create(AbstractDesktopApp* application); static std::unique_ptr<DesktopManager> Create(AbstractDesktopApp* application);
void SetWindowManager(WindowManagerUPtr windowManager); void setWindowManager(WindowManagerUPtr windowManager);
AbstractApp* getMainApp() const; AbstractApp* getMainApp() const;
WindowManager* GetWindowManager() const; WindowManager* getWindowManager() const;
Keyboard* GetKeyboard() const; Keyboard* getKeyboard() const;
void AddScreen(ScreenPtr screen); void addScreen(ScreenPtr screen);
mt::Screen* GetDefaultScreen() const; mt::Screen* getDefaultScreen() const;
bool IsModified() const; bool isModified() const;
void SetIsModified(bool modified); void setIsModified(bool modified);
void SetKeyboard(KeyboardUPtr keyboard); void setKeyboard(KeyboardUPtr keyboard);
void OnUiEvent(UiEventUPtr event); void onUiEvent(UiEventUPtr event);
void OnKeyboardEvent(const KeyboardEvent* keyboardEvent); void onKeyboardEvent(const KeyboardEvent* keyboardEvent);
void OnMouseEvent(const MouseEvent* mouseEvent); void onMouseEvent(const MouseEvent* mouseEvent);
void OnPaintEvent(const PaintEvent* paintEvent); void onPaintEvent(const PaintEvent* paintEvent);
void ClearEvents(); void clearEvents();
private: private:
std::vector<ScreenPtr> mScreens; std::vector<ScreenPtr> mScreens;

View file

@ -3,7 +3,7 @@
WindowManager::WindowManager() WindowManager::WindowManager()
: mWindows() : mWindows()
{ {
AddWindow(mt::Window::Create()); addWindow(mt::Window::Create());
} }
WindowManager::~WindowManager() WindowManager::~WindowManager()
@ -16,22 +16,22 @@ std::unique_ptr<WindowManager> WindowManager::Create()
return std::make_unique<WindowManager>(); return std::make_unique<WindowManager>();
} }
void WindowManager::OnPaintEvent(const PaintEvent* event) void WindowManager::onPaintEvent(const PaintEvent* event)
{ {
GetMainWindow()->OnPaint(event); getMainWindow()->onPaint(event);
} }
void WindowManager::OnMouseEvent(const MouseEvent* event) void WindowManager::onMouseEvent(const MouseEvent* event)
{ {
GetMainWindow()->OnMouseEvent(event); getMainWindow()->onMouseEvent(event);
} }
void WindowManager::OnKeyboardEvent(const KeyboardEvent* event) void WindowManager::onKeyboardEvent(const KeyboardEvent* event)
{ {
GetMainWindow()->OnKeyboardEvent(event); getMainWindow()->onKeyboardEvent(event);
} }
void WindowManager::AddWindow(WindowUPtr window) void WindowManager::addWindow(WindowUPtr window)
{ {
mWindows.push_back(std::move(window)); mWindows.push_back(std::move(window));
} }
@ -44,7 +44,7 @@ void WindowManager::clearPlatformWindows()
} }
} }
mt::Window* WindowManager::GetMainWindow() const mt::Window* WindowManager::getMainWindow() const
{ {
if(mWindows.size()>0) if(mWindows.size()>0)
{ {

View file

@ -17,15 +17,15 @@ public:
static std::unique_ptr<WindowManager> Create(); static std::unique_ptr<WindowManager> Create();
void AddWindow(WindowUPtr window); void addWindow(WindowUPtr window);
mt::Window* GetMainWindow() const; mt::Window* getMainWindow() const;
void OnPaintEvent(const PaintEvent* event); void onPaintEvent(const PaintEvent* event);
void OnMouseEvent(const MouseEvent* event); void onMouseEvent(const MouseEvent* event);
void OnKeyboardEvent(const KeyboardEvent* event); void onKeyboardEvent(const KeyboardEvent* event);
void clearPlatformWindows(); void clearPlatformWindows();

View file

@ -1,7 +1,6 @@
#include "WaylandEglWindowInterface.h" #include "WaylandEglWindowInterface.h"
#include "FileLogger.h" #include "FileLogger.h"
#include "OpenGlInterface.h"
#include <wayland-egl.h> #include <wayland-egl.h>
@ -59,7 +58,7 @@ void WaylandEglWindowInterface::initialize(wl_surface* surface, int width, int h
} }
} }
void WaylandEglWindowInterface::draw() void WaylandEglWindowInterface::beforePaint()
{ {
if (!mEglSurface) if (!mEglSurface)
{ {
@ -70,8 +69,14 @@ void WaylandEglWindowInterface::draw()
{ {
MLOG_ERROR("Made current failed"); MLOG_ERROR("Made current failed");
} }
}
OpenGlInterface::draw(nullptr); void WaylandEglWindowInterface::afterPaint()
{
if (!mEglSurface)
{
return;
}
if (!eglSwapBuffers(mEglInterface->getDisplay(), mEglSurface)) if (!eglSwapBuffers(mEglInterface->getDisplay(), mEglSurface))
{ {

View file

@ -15,7 +15,8 @@ public:
void initialize(wl_surface* surface, int width, int height); void initialize(wl_surface* surface, int width, int height);
void draw(); void beforePaint();
void afterPaint();
private: private:
wl_egl_window* mEglWindow{nullptr}; wl_egl_window* mEglWindow{nullptr};

View file

@ -81,13 +81,13 @@ void WaylandInterface::initialize()
initializeHardwareRendering(); initializeHardwareRendering();
} }
const auto num_windows = mDesktopManager->GetWindowManager()->getNumWindows(); const auto num_windows = mDesktopManager->getWindowManager()->getNumWindows();
for(std::size_t idx=0; idx< num_windows; idx++) for(std::size_t idx=0; idx< num_windows; idx++)
{ {
addWindow(mDesktopManager->GetWindowManager()->getWindow(idx)); addWindow(mDesktopManager->getWindowManager()->getWindow(idx));
} }
mDesktopManager->GetWindowManager()->GetMainWindow()->show(); mDesktopManager->getWindowManager()->getMainWindow()->show();
} }
void WaylandInterface::initializeHardwareRendering() void WaylandInterface::initializeHardwareRendering()

View file

@ -2,11 +2,14 @@
#include "WaylandEglWindowInterface.h" #include "WaylandEglWindowInterface.h"
#include "ImagePrimitives.h" #include "ImagePrimitives.h"
#include "DrawingContext.h"
void WaylandSurface::add(mt::Window* window, wl_compositor* compositor, xdg_wm_base* xdg_wm_base, std::shared_ptr<WaylandBuffer> buffer, WaylandEglInterface* eglInterface) void WaylandSurface::add(mt::Window* window, wl_compositor* compositor, xdg_wm_base* xdg_wm_base, std::shared_ptr<WaylandBuffer> buffer, WaylandEglInterface* eglInterface)
{ {
auto wayland_window = std::make_unique<WaylandSurface>(window, compositor, xdg_wm_base, buffer, eglInterface); auto wayland_window = std::make_unique<WaylandSurface>(window, compositor, xdg_wm_base, buffer, eglInterface);
window->SetPlatformWindow(std::move(wayland_window));
const auto drawing_mode = eglInterface ? DrawingMode::GRAPH : DrawingMode::RASTER;
window->setPlatformWindow(std::move(wayland_window), drawing_mode);
} }
WaylandSurface::WaylandSurface(mt::Window* window, wl_compositor* compositor, xdg_wm_base* xdg_wm_base, std::shared_ptr<WaylandBuffer> buffer, WaylandEglInterface* eglInterface) WaylandSurface::WaylandSurface(mt::Window* window, wl_compositor* compositor, xdg_wm_base* xdg_wm_base, std::shared_ptr<WaylandBuffer> buffer, WaylandEglInterface* eglInterface)
@ -62,7 +65,7 @@ void WaylandSurface::initialize()
xdg_toplevel_set_title(mXdgTopLevel, "Example client"); xdg_toplevel_set_title(mXdgTopLevel, "Example client");
auto region = wl_compositor_create_region(mCompositor); auto region = wl_compositor_create_region(mCompositor);
wl_region_add(region, 0, 0, mWindow->GetWidth(), mWindow->GetHeight()); wl_region_add(region, 0, 0, mWindow->getWidth(), mWindow->getHeight());
wl_surface_set_opaque_region(mSurface, region); wl_surface_set_opaque_region(mSurface, region);
wl_surface_commit(mSurface); wl_surface_commit(mSurface);
@ -71,56 +74,65 @@ void WaylandSurface::initialize()
void WaylandSurface::onConfigure(xdg_surface *xdg_surface, uint32_t serial) void WaylandSurface::onConfigure(xdg_surface *xdg_surface, uint32_t serial)
{ {
xdg_surface_ack_configure(xdg_surface, serial); xdg_surface_ack_configure(xdg_surface, serial);
paint(nullptr); beforePaint(nullptr);
} }
void WaylandSurface::paint(mt::Screen* screen) void WaylandSurface::beforePaint(mt::Screen* screen)
{ {
if (mEglWindowInterface) if (mEglWindowInterface)
{ {
paintHardware(); mEglWindowInterface->initialize(mSurface, mWindow->getWidth(), mWindow->getHeight());
mEglWindowInterface->beforePaint();
} }
else else
{ {
paintSoftware(); beforePaintSoftware();
} }
} }
void WaylandSurface::paintHardware() void WaylandSurface::afterPaint(mt::Screen* screen)
{ {
mEglWindowInterface->initialize(mSurface, mWindow->GetWidth(), mWindow->GetHeight()); if (mEglWindowInterface)
mEglWindowInterface->draw(); {
mEglWindowInterface->afterPaint();
}
else
{
afterPaintSoftware();
}
} }
void WaylandSurface::paintSoftware() unsigned WaylandSurface::getImageBufferSize() const
{ {
auto buffer = drawFrame(); const auto width = mWindow->getWidth();
wl_surface_attach(mSurface, buffer, 0, 0); const auto height = mWindow->getHeight();
//wl_surface_damage(mSurface, 0, 0, UINT32_MAX, UINT32_MAX); const int stride = width * mWorkingBitDepth;
wl_surface_commit(mSurface);
}
wl_buffer* WaylandSurface::drawFrame()
{
const auto width = mWindow->GetWidth();
const auto height = mWindow->GetHeight();
const int bitDepth = 4;
const int stride = width * bitDepth;
//const int numBuffers = 2; // i.e. front/back //const int numBuffers = 2; // i.e. front/back
const int numBuffers = 1; return height * stride * mNumFrameBuffers;
const int shm_pool_size = height * stride * numBuffers; }
void WaylandSurface::beforePaintSoftware()
{
const auto width = mWindow->getWidth();
const auto height = mWindow->getHeight();
const int stride = width * mWorkingBitDepth;
const int shm_pool_size = getImageBufferSize();
mBuffer->initializeSharedBuffer(shm_pool_size); mBuffer->initializeSharedBuffer(shm_pool_size);
mBuffer->setUpPool(shm_pool_size, width, height, stride); mBuffer->setUpPool(shm_pool_size, width, height, stride);
int offset = 0; //ImagePrimitives::drawCheckerboard(mBuffer->getPoolData(), width, height, offset);
}
ImagePrimitives::drawCheckerboard(mBuffer->getPoolData(), width, height, offset);
void WaylandSurface::afterPaintSoftware()
mBuffer->tearDownPool(shm_pool_size); {
const int shm_pool_size = getImageBufferSize();
return mBuffer->getWorkingBuffer(); mBuffer->tearDownPool(shm_pool_size);
wl_surface_attach(mSurface, mBuffer->getWorkingBuffer(), 0, 0);
//wl_surface_damage(mSurface, 0, 0, UINT32_MAX, UINT32_MAX);
wl_surface_commit(mSurface);
} }

View file

@ -37,13 +37,13 @@ public:
private: private:
void initialize(); void initialize();
void paint(mt::Screen* screen) override; void beforePaint(mt::Screen* screen) override;
void afterPaint(mt::Screen* screen) override;
void paintHardware(); void beforePaintSoftware();
void paintSoftware(); void afterPaintSoftware();
unsigned getImageBufferSize() const;
wl_buffer* drawFrame();
mt::Window* mWindow{nullptr}; mt::Window* mWindow{nullptr};
@ -57,6 +57,8 @@ private:
xdg_surface_listener mXdgSurfaceListener; xdg_surface_listener mXdgSurfaceListener;
xdg_toplevel* mXdgTopLevel{nullptr}; xdg_toplevel* mXdgTopLevel{nullptr};
unsigned mWorkingBitDepth{4};
unsigned mNumFrameBuffers{1};
}; };
using WaylandSurfacePtr = std::unique_ptr<WaylandSurface>; using WaylandSurfacePtr = std::unique_ptr<WaylandSurface>;

View file

@ -1,6 +1,5 @@
#include "XcbGlWindowInterface.h" #include "XcbGlWindowInterface.h"
#include "OpenGlInterface.h"
#include "XcbGlInterface.h" #include "XcbGlInterface.h"
#include "FileLogger.h" #include "FileLogger.h"
@ -22,9 +21,8 @@ XcbGlWindowInterface::~XcbGlWindowInterface()
} }
} }
void XcbGlWindowInterface::draw() void XcbGlWindowInterface::afterPaint()
{ {
OpenGlInterface::draw(nullptr);
swapBuffers(); swapBuffers();
} }

View file

@ -14,7 +14,7 @@ public:
bool initialize(xcb_window_t window); bool initialize(xcb_window_t window);
void draw(); void afterPaint();
private: private:
void destroyWindow(); void destroyWindow();

View file

@ -4,6 +4,7 @@
#include "Window.h" #include "Window.h"
#include "XcbWindow.h" #include "XcbWindow.h"
#include "Image.h"
class XcbImage class XcbImage
{ {
@ -11,9 +12,9 @@ public:
XcbImage(xcb_connection_t* connection, mt::Window* window, xcb_screen_t* screen) XcbImage(xcb_connection_t* connection, mt::Window* window, xcb_screen_t* screen)
{ {
mPixmap = xcb_generate_id(connection); mPixmap = xcb_generate_id(connection);
auto hwnd = dynamic_cast<XcbWindow*>(window->GetPlatformWindow())->getHandle(); auto hwnd = dynamic_cast<XcbWindow*>(window->getPlatformWindow())->getHandle();
const auto w = window->GetWidth(); const auto w = window->getWidth();
const auto h = window->GetHeight(); const auto h = window->getHeight();
xcb_create_pixmap(connection, screen->root_depth, mPixmap, hwnd, w, h); xcb_create_pixmap(connection, screen->root_depth, mPixmap, hwnd, w, h);
} }
@ -21,10 +22,10 @@ public:
{ {
if (!mXImage) if (!mXImage)
{ {
auto backing_image = window->getBackingImage(); auto backing_image = window->getImage();
const auto w = window->GetWidth(); const auto w = window->getWidth();
const auto h = window->GetHeight(); const auto h = window->getHeight();
//auto data = const_cast<unsigned char*>(backing_image->getDataPtr()); //auto data = const_cast<unsigned char*>(backing_image->getDataPtr());
auto data = backing_image->getData(); auto data = backing_image->getData();

View file

@ -40,15 +40,15 @@ void XcbInterface::initialize()
{ {
initializeHardwareRendering(); initializeHardwareRendering();
} }
mDesktopManager->SetKeyboard(XcbKeyboard::Create()); mDesktopManager->setKeyboard(XcbKeyboard::Create());
const auto num_windows = mDesktopManager->GetWindowManager()->getNumWindows(); const auto num_windows = mDesktopManager->getWindowManager()->getNumWindows();
for(std::size_t idx=0; idx< num_windows; idx++) for(std::size_t idx=0; idx< num_windows; idx++)
{ {
addWindow(mDesktopManager->GetWindowManager()->getWindow(idx)); addWindow(mDesktopManager->getWindowManager()->getWindow(idx));
} }
mDesktopManager->GetWindowManager()->GetMainWindow()->show(); mDesktopManager->getWindowManager()->getMainWindow()->show();
} }
void XcbInterface::connect() void XcbInterface::connect()
@ -96,7 +96,7 @@ void XcbInterface::updateScreen()
auto xcb_screen = XcbScreen::Create(screen_iter.data); auto xcb_screen = XcbScreen::Create(screen_iter.data);
auto screen = mt::Screen::Create(); auto screen = mt::Screen::Create();
screen->SetPlatformScreen(std::move(xcb_screen)); screen->SetPlatformScreen(std::move(xcb_screen));
mDesktopManager->AddScreen(std::move(screen)); mDesktopManager->addScreen(std::move(screen));
} }
void XcbInterface::initializeHardwareRendering() void XcbInterface::initializeHardwareRendering()
@ -107,11 +107,11 @@ void XcbInterface::initializeHardwareRendering()
void XcbInterface::createGraphicsContext() void XcbInterface::createGraphicsContext()
{ {
if (!mConnection || mDesktopManager->GetDefaultScreen()) if (!mConnection || mDesktopManager->getDefaultScreen())
{ {
return; return;
} }
auto xcb_screen = dynamic_cast<XcbScreen*>(mDesktopManager->GetDefaultScreen()->GetPlatformScreen()); auto xcb_screen = dynamic_cast<XcbScreen*>(mDesktopManager->getDefaultScreen()->GetPlatformScreen());
if (!xcb_screen) if (!xcb_screen)
{ {
return; return;
@ -145,16 +145,16 @@ uint32_t XcbInterface::getEventMask()
void XcbInterface::addWindow(mt::Window* window) void XcbInterface::addWindow(mt::Window* window)
{ {
auto screen = mDesktopManager->GetDefaultScreen(); auto screen = mDesktopManager->getDefaultScreen();
XcbWindow::add(window, mConnection, screen, getEventMask(), mGlInterface.get()); XcbWindow::add(window, mConnection, screen, getEventMask(), mGlInterface.get());
} }
void XcbInterface::onPaint() void XcbInterface::onPaint()
{ {
mDesktopManager->OnUiEvent(PaintEvent::Create()); mDesktopManager->onUiEvent(PaintEvent::Create());
auto mainWindow = mDesktopManager->GetWindowManager()->GetMainWindow(); auto mainWindow = mDesktopManager->getWindowManager()->getMainWindow();
auto defaultScreen = mDesktopManager->GetDefaultScreen(); auto defaultScreen = mDesktopManager->getDefaultScreen();
mainWindow->doPaint(defaultScreen); mainWindow->doPaint(defaultScreen);
} }
@ -183,26 +183,26 @@ void XcbInterface::loop()
} }
case XCB_KEY_PRESS: { case XCB_KEY_PRESS: {
auto kp = reinterpret_cast<xcb_key_press_event_t*>(event); auto kp = reinterpret_cast<xcb_key_press_event_t*>(event);
auto ui_event = mEventInterface->ConvertKeyPress(kp, mDesktopManager->GetKeyboard()); auto ui_event = mEventInterface->ConvertKeyPress(kp, mDesktopManager->getKeyboard());
mDesktopManager->OnUiEvent(std::move(ui_event)); mDesktopManager->onUiEvent(std::move(ui_event));
break; break;
} }
case XCB_KEY_RELEASE: { case XCB_KEY_RELEASE: {
auto kr = reinterpret_cast<xcb_key_release_event_t*>(event); auto kr = reinterpret_cast<xcb_key_release_event_t*>(event);
auto ui_event = mEventInterface->ConvertKeyRelease(kr, mDesktopManager->GetKeyboard()); auto ui_event = mEventInterface->ConvertKeyRelease(kr, mDesktopManager->getKeyboard());
mDesktopManager->OnUiEvent(std::move(ui_event)); mDesktopManager->onUiEvent(std::move(ui_event));
break; break;
} }
case XCB_BUTTON_PRESS: { case XCB_BUTTON_PRESS: {
auto press = reinterpret_cast<xcb_button_press_event_t*>(event); auto press = reinterpret_cast<xcb_button_press_event_t*>(event);
auto ui_event = mEventInterface->ConvertButtonPress(press); auto ui_event = mEventInterface->ConvertButtonPress(press);
mDesktopManager->OnUiEvent(std::move(ui_event)); mDesktopManager->onUiEvent(std::move(ui_event));
break; break;
} }
case XCB_BUTTON_RELEASE: { case XCB_BUTTON_RELEASE: {
auto release = reinterpret_cast<xcb_button_release_event_t*>(event); auto release = reinterpret_cast<xcb_button_release_event_t*>(event);
auto ui_event = mEventInterface->ConvertButtonRelease(release); auto ui_event = mEventInterface->ConvertButtonRelease(release);
mDesktopManager->OnUiEvent(std::move(ui_event)); mDesktopManager->onUiEvent(std::move(ui_event));
break; break;
} }
default: default:
@ -216,17 +216,17 @@ void XcbInterface::loop()
void XcbInterface::onEventsDispatched() void XcbInterface::onEventsDispatched()
{ {
if (mDesktopManager->IsModified()) if (mDesktopManager->isModified())
{ {
mDesktopManager->SetIsModified(false); mDesktopManager->setIsModified(false);
auto mainWindow = mDesktopManager->GetWindowManager()->GetMainWindow(); auto mainWindow = mDesktopManager->getWindowManager()->getMainWindow();
mainWindow->clear(); mainWindow->clear();
} }
} }
void XcbInterface::shutDown() void XcbInterface::shutDown()
{ {
mDesktopManager->GetWindowManager()->clearPlatformWindows(); mDesktopManager->getWindowManager()->clearPlatformWindows();
if (!mConnection) if (!mConnection)
{ {

View file

@ -7,6 +7,7 @@
#include "Screen.h" #include "Screen.h"
#include "ImagePrimitives.h" #include "ImagePrimitives.h"
#include "XcbGlWindowInterface.h" #include "XcbGlWindowInterface.h"
#include "DrawingContext.h"
#include <xcb/xcb.h> #include <xcb/xcb.h>
@ -42,14 +43,16 @@ void XcbWindow::add(mt::Window* window, xcb_connection_t* connection, mt::Screen
hwnd, /* window Id */ hwnd, /* window Id */
xcb_screen->GetNativeScreen()->root, /* parent window */ xcb_screen->GetNativeScreen()->root, /* parent window */
0, 0, /* x, y */ 0, 0, /* x, y */
window->GetWidth(), window->GetHeight(), /* width, height */ window->getWidth(), window->getHeight(), /* width, height */
10, /* border_width */ 10, /* border_width */
XCB_WINDOW_CLASS_INPUT_OUTPUT, /* class */ XCB_WINDOW_CLASS_INPUT_OUTPUT, /* class */
xcb_screen->GetNativeScreen()->root_visual, /* visual */ xcb_screen->GetNativeScreen()->root_visual, /* visual */
mask, values ); /* masks */ mask, values ); /* masks */
auto xcb_window = std::make_unique<XcbWindow>(window, hwnd, connection, xcbGlInterface); auto xcb_window = std::make_unique<XcbWindow>(window, hwnd, connection, xcbGlInterface);
window->SetPlatformWindow(std::move(xcb_window));
const auto drawing_mode = xcbGlInterface ? DrawingMode::GRAPH : DrawingMode::RASTER;
window->setPlatformWindow(std::move(xcb_window), drawing_mode);
} }
int XcbWindow::getHandle() const int XcbWindow::getHandle() const
@ -67,54 +70,40 @@ void XcbWindow::show()
map(); map();
} }
void XcbWindow::paint(mt::Screen* screen) void XcbWindow::beforePaint(mt::Screen* screen)
{
auto xcb_screen = dynamic_cast<XcbScreen*>(screen->GetPlatformScreen());
if (mGlInterface)
{
paintHardware(xcb_screen);
}
else
{
paintSoftware(xcb_screen);
}
}
void XcbWindow::paintHardware(XcbScreen* screen)
{ {
if (mGlInterface) if (mGlInterface)
{ {
mGlInterface->initialize(mHandle); mGlInterface->initialize(mHandle);
mGlInterface->draw(); }
else
{
auto xcb_screen = dynamic_cast<XcbScreen*>(screen->GetPlatformScreen());
if (!mBackingImage)
{
mBackingImage = std::make_unique<XcbImage>(mConnection, mWindow, xcb_screen->GetNativeScreen());
}
} }
} }
void XcbWindow::paintSoftware(XcbScreen* screen) void XcbWindow::afterPaint(mt::Screen* screen)
{ {
if (!mBackingImage) if (mGlInterface)
{ {
mBackingImage = std::make_unique<XcbImage>(mConnection, mWindow, screen->GetNativeScreen()); mGlInterface->afterPaint();
} }
else
auto backing_image = mWindow->getBackingImage();
backing_image->initialize();
//ImagePrimitives::drawCheckerboard(const_cast<unsigned char*>(backing_image->getDataPtr()), backing_image->getWidth(), backing_image->getHeight(), 0);
mBackingImage->update(mWindow, screen->GetNativeScreen(), mConnection, screen->GetGraphicsContext());
xcb_copy_area(mConnection, mBackingImage->getPixMap(), mHandle, screen->GetGraphicsContext(), 0, 0 ,0 , 0, backing_image->getWidth(), backing_image->getHeight());
/*
for(const auto& layer : mWindow->GetLayers())
{ {
XcbLayerInterface::AddLayer(mConnection, xcb_screen->GetNativeScreen(), mHandle, xcb_screen->GetGraphicsContext(), layer); auto xcb_screen = dynamic_cast<XcbScreen*>(screen->GetPlatformScreen());
mBackingImage->update(mWindow, xcb_screen->GetNativeScreen(), mConnection, xcb_screen->GetGraphicsContext());
xcb_copy_area(mConnection, mBackingImage->getPixMap(), mHandle, xcb_screen->GetGraphicsContext(), 0, 0 ,0 , 0, mWindow->getWidth(), mWindow->getHeight());
} }
*/
} }
void XcbWindow::clear() void XcbWindow::clear()
{ {
xcb_clear_area(mConnection, 1, mHandle, 0, 0, mWindow->GetWidth(), mWindow->GetHeight()); xcb_clear_area(mConnection, 1, mHandle, 0, 0, mWindow->getWidth(), mWindow->getHeight());
xcb_flush(mConnection); xcb_flush(mConnection);
} }

View file

@ -26,16 +26,15 @@ public:
void show() override; void show() override;
void paint(mt::Screen* screen) override; void beforePaint(mt::Screen* screen) override;
void afterPaint(mt::Screen* screen) override;
void clear() override; void clear() override;
void map() override; void map() override;
private: private:
void paintHardware(XcbScreen* screen);
void paintSoftware(XcbScreen* screen);
int mHandle{-1}; int mHandle{-1};
unsigned mGraphicsContext {0}; unsigned mGraphicsContext {0};
xcb_connection_t* mConnection{nullptr}; xcb_connection_t* mConnection{nullptr};

View file

@ -4,7 +4,8 @@
#include "DrawingSurface.h" #include "DrawingSurface.h"
#include "DrawingContext.h" #include "DrawingContext.h"
#include "Grid.h" #include "Grid.h"
#include "Rasterizer.h" #include "Scene.h"
#include "RasterPainter.h"
#include "LineSegment.h" #include "LineSegment.h"
#include "Point.h" #include "Point.h"
#include "TriMesh.h" #include "TriMesh.h"
@ -15,7 +16,7 @@ int main()
manager.InitalizeSurface(200, 200); manager.InitalizeSurface(200, 200);
manager.InitializeContext(); manager.InitializeContext();
auto line = LineSegment::Create(Point::Create(10.0, 10.0), Point::Create(190.0, 190.0)); auto line = LineSegment::Create(Point(10.0, 10.0), Point(190.0, 190.0));
return 0; return 0;
} }