Src/QtGeoViewer/View3D.h

#pragma once

#include <LibQtGeoViewerCore/SceneMain.h>
#include <LibQtGeoViewerCore/Cursor3D.h>

#include "QtViewBase.h"

#include "Camera.h"
#include "GeometryRender.h"
#include "View3DConfig.h"
#include "CloseVertInfo.h"
#include "Modifier.h"
#include "GLWidgetList.h"
#include "CameraRecords.h"
#include "SelRange.h"
#include "PostProcBuffer.h"

#include "ShaderLibrary.h"
#include "Shader/ShaderInterface.h"

#include "PostprocLibrary.h"
#include "Postproc/PostprocInterface.h"

#include "../GLUtility/FBOPicker.h"

#include <C2/gl/Projection.h>
#include <C2/gl/Manipulator.h>
#include <C2/gl/Light.h>

#include <C2/util/optional.h>

#include <QGestureEvent>

using namespace gl;


namespace lib_gl
{
class GlPicker;
}


class View3D :
        public QtViewBase,
        public SceneObserver
{
        Q_OBJECT

public:
        View3D(void);

        virtual bool InitializeView(MyGLWidget* ParentWidget);
        void RegisterScene(SceneMain* scene);

        void SetLightStrengthByStdRatio(float rat);

        virtual void FinalizeView(void);

        void BeginRender(void);
        void EndRender(void);

        virtual void OnPaint(void);
        virtual void OnResize(int width, int height);

        virtual void OnMousePress(QMouseEvent *e);
        virtual void OnMouseRelease(QMouseEvent *e);
        virtual void OnMouseDoubleClick(QMouseEvent *e);
        virtual void OnMouseMove(QMouseEvent *e);

        virtual void OnWheel(QWheelEvent *e);

        virtual void OnGesturePan(QPanGesture *gesture);
        virtual void OnGesturePinch(QPinchGesture *gesture);

        virtual void OnKeyPress(QKeyEvent *e);
        virtual void OnKeyRelease(QKeyEvent *e);
        bool KeyPressOnRotCamera(QKeyEvent *e, const Modifier& m);

        // SceneObserver���m�C�x���g
        virtual void OnGeometryBuild(const SceneMain& scene);

        void ReleaseRenderbuffer(MeshBuf* mbuf);

        void RecordCamera(void);
        void MoveToRecordedCamera(int camera_idx, bool animation);
        void RemoveRecordedCamera(int camera_idx);
        void ClearRecordedCamera(void);

        void ResetPrimaryObjectLists(void);
        void ReleaseAllRenderBuffer(void);

        void DrawCloseVertInfo(void);

        void DrawCutPlane(void) const;
        void DrawObjectsBBox(void) const;

        void RepaintParent(void);

        std::vector<int> PickObjectAroundMouse(const QPoint& pos, int sel_range);
        bool IsInRange(int x, int y, const QImage& bmp) const;
        int QColorToIndex(const QColor& c) const;

        float GetGeomDepth(int x, int y);
        util::Optional<lm::vec3f> GetGeomDepht3DPos(int x, int y);

        void LookDepth(void);
        bool LookPixelDepth(int x, int y);
        void Look3DCursor(void);
        void ResetCursorMeasure(void);
        void UpdateCursorCutNormal(void);

        void MoveCaemraTo(ViewPoint vp);
        void MoveLookPosToCenter(void);
        void MoveLookPosToOrigin(void);
        void AdjustCameraDistAuto(void);

protected:
        void PaintMain(bool showOnlyGeom);
        void Render3D(Camera& camera, bool showOnlyGeom);
        void Render3DScene(Camera& camera, bool showOnlyGeom);
        void Render3DWithPostproc(Camera& camera);
        void UpdatePostProcContext(Camera& camera);
        void RenderClipRange(void);

        void RenderBillboard(void);
        void RenderSelRange(void);
        void RenderShadowmapBuf(void);

        void ClearRenderBuffer(void);
        void SetDefalutLightState(const Camera& camera);
        void SetDefalutCullState(void);

        void DrawAllGeom(bool UseShader);
        void DrawAllGeomMeshStd(bool UseShader, std::vector<GeomObject*>& target);
        void DrawAllGeomVLinks(std::vector<GeomObject*>& target);
        void DrawAllGeomPolyline(std::vector<GeomObject*>& target);
        void DrawPolyline(MeshBuf& mbuf);
        void DrawPolylineHighlight(MeshBuf& mbuf);
        void DrawPolylineGeom(const MeshBuf& mbuf, const lib_geo::BasePolyline& pl);
        void DrawAllGeomMeshIndexColor(int index_offset);

        void DrawOptions_Before(void);
        void DrawOptions_After(void);

        void DrawGeomMeshHighlight(void);
        void DrawSelVert(MeshBuf& mbuf, int vert_idx);
        void PickMouseClosePoint(int x, int y);
        void DrawSelection_VertSel(void);
        void GetSelVertsFromPickBuf(lib_gl::GlPicker& picker, unsigned int depth);
        void DrawVertexLinker(MeshBuf& mbuf);
        void DrawLookPos(void);

        void DrawEnvImage(Camera& camera);
        void DrawGround(void);
        void DrawAxis(void);
        void DrawMiniAxis(void);
        void Draw3DCursor(void);
        void Draw3DCursorAxis(const lm::vec3f& p, const lm::vec3f& c);
        void Draw3DCursorCoord(const lm::vec3f& p);
        void Draw3DCursorMeasure(void);
        void Draw3DCursorBary(void);

        void DrawAllGeomCrossSection(void);
        void DrawAllGeomCrossSectionLine(std::vector<GeomObject*>& objects);

        void BeginCutPlaneConfig(bool forCut);
        void EndCutPlaneConfig(void);

        void DrawClipRangeGraph(Camera& camera);

        void GetClipLimit(float& t, float& b) const;

        void DrawRenderTime(void);

        // mouse events
        bool MouseMove_OnSelRange        (QMouseEvent* e, QPointF& diff);
        bool MouseMove_OnZoomSelRange    (QMouseEvent* e, QPointF& diff);
        bool MouseMove_OnUpdateCloseVert (QMouseEvent* e, QPointF& diff);
        bool MouseMove_OnCameraControl   (QMouseEvent* e, QPointF& diff);
        bool MouseMove_OnLightControl    (QMouseEvent* e, QPointF& diff);
        bool MouseMove_OnCursorControl   (QMouseEvent* e);

        lm::vec3f Move3DCursor(lm::vec3f& cp, double px, double py);

        bool UpdateCloseVert(QMouseEvent* e);

        void DrawCenterCross(void);

        bool IsRequireUpdateShadowmap(void);

        ShaderInterface* GetPrimaryShader(void);
        void SetShaderResources(void);

        void UpdateShadowmap(void);
        void DrawAllGeomForShadowbuf(void);

        void SelectVertsSelRange(bool select_add);

        void DrawLightPos(const lib_gl::Light& light);

        void PushAndIdentityGLModelProjMatrix(void);
        void PushAndIdentityGLAllMatrix(void);
        void PopGLModelProjMatrix(void);
        void PopGLAllMatrix(void);

        void SelectClosestVertOnMouseDown(QMouseEvent *e);
        void SelectObjectOnMouseDown(QMouseEvent *e);

        bool CheckCameraIsReverse(void) const;

private:
        GeometryRender& GetRender(const MeshBuf* mbuf);

        void RenderCurrentTextureToBillboard(int left, int top, int width, int height);

        void ZoomSelRange(void);

        bool IsVisibleObject(const GeomObject& obj) const;
        std::vector<GeomObject*> GetVisibleObjects(void);

        MeshBuf* GetAndUpdateCursorCloseMBuf(void);
        void TestOnCursorColseElement(void);

        void UpdateModifierTip(QKeyEvent* e, const Modifier& m);
        bool IsModifierEvent(QKeyEvent* e);

        void GetAllVisibleObjects(std::vector<GeomObject*>& objects);

signals:
        void SelectedObjectChanged(int sel_idx);
        void SelectedMatChanged(int sel_idx);

        void CameraMoved(void);
        void StatusTipChanged(QString msg);


public:
        GLWidgetList* m_Widgets;

        Camera m_Camera;
        bool m_CameraReverse;

        CameraRecords m_CameraRecord;

        lib_gl::Light m_HeadLight;    //!< �J�����������u������, �����w�b�h���C�g�������C�g
        lib_gl::Light m_ControlLight; //!< �}�E�X�������������C�g

        View3DConfig m_Config;

        SceneMain* m_Scene;

        ShaderLibrary m_ShaderLib;
        ShaderContext m_ShaderContext;

        PosprocLibrary m_PPLib;
        PostprocContext m_PPContext;
        MultPathRenderBuf m_PPBuf;

        lib_graph::color4f m_BGColor;

        float m_GridAxisScale;

        bool m_FpsMode;


private:
        boost::ptr_map<const MeshBuf*, GeometryRender> m_RenderMap;

        bool m_GlewInitialized;

        int m_LastRenderTime;

        SelRange m_SelRange;
        SelRange m_ZoomSelRange;

        CloseVertInfo m_CloseVertInfo;

        QPointF m_LastMousePos;

        FBOPicker m_FboPicker;
};
