GameView.h

#pragma once
 
namespace SharpKmyPhysics
{
    ref class PhysicsBase;
}
 
namespace SharpKmyGfx
{
    ref class SpriteBatch;
    ref class Manipulator;
    ref class GameViewDrawHook;
    ref class Material;
 
    public enum class ModelBoundSphereDrawType {
        None,
        All,
        Selected,
    };
 
    public ref class GameViewDrawSuspendChecker
    {
    public:
        virtual bool drawEnable() { return true; }
    };
 
    template<typename T>
    public ref class SharedPtr
    {
    public:
        SharedPtr() {
            m_ptr = new std::shared_ptr<T>();
        }
        void release() {
            if(m_ptr)delete m_ptr;
            m_ptr = nullptr;
        }
        std::shared_ptr<T>* m_ptr = nullptr;
        operator bool()
        {
            return m_ptr != nullptr && m_ptr->get() != nullptr; 
        }
        T* operator->() { return m_ptr->get(); }
        std::shared_ptr<T> &operator* () { return *m_ptr; }
    };
 
    public ref class GameView
    {
    public:
        GameView();
        GameView(const std::shared_ptr<kmyGfx::GameView>& ptr);
        ~GameView();
        kmyGfx::GameView* getNativePtr() { return obj ? (*obj).get() : nullptr; }
        
        void draw(bool swapbuffer, float timeScale);
        void preDraw(float timeScale, Action<float>^ startFixedUpdate, Action<float>^ afterAnimate, Action<float>^ afterSimulate);
        void postDraw(bool swapbuffer);
        void setCamera(SharpKmyMath::Matrix4^ proj, SharpKmyMath::Matrix4^ view);
        void setDirectionalLightPosture(SharpKmyMath::Matrix4^ posture);
        void setDirectionalLightColor(SharpKmyGfx::Color color);
        void setDirectionalLightShadowColor(SharpKmyGfx::Color color);
        void setDirectionalLightShadowVolumeMargin(f32 margin);
        void setDirectionalLightShadowBias(f32 bias);
        void setDirectionalLightShadowDistance(f32 distance);
        void setCascadeStep(float s1, float s2, float s3);
        void setCascadeCount(int num);
        void enableCascadeVisualize(bool flg);
        void setAmbientLight(SharpKmyGfx::Color color);
        void setViewport(int x, int y, int width, int height);
        void setViewportSize(int width, int height);
        SharpKmyMath::Vector2 getViewportSize();
        u32 getDisplayID() { return obj ? obj->getDisplayID() : 0; }
        void setDisplayID(unsigned int id);
        void setBackGroundColor(SharpKmyGfx::Color color);
        void addPickupFrame(int size);
        void addCaptureFrame(int width, int height);
        void removeCaptureFrame();
        void enableBloom(bool flg);
        void setBloomParam(float apply, float hilightThreshold);
        void enableAutoExposure(bool flg);
        void setAutoExposureParam(float targetBrightness, float minScale, float maxScale);
        void enableChromaticAbberation(bool flg);
        void setChromaticAbberationParam(float size);
        void enableDof(bool flg);
        void enableFxaa(bool flg);
        void setDofParam(float focalDistance, float focalRange, float radius);
        void enableSharpen(bool flg);
        void setShapenParam(float strength, float distance);
        void getImage(int x, int y, int w, int h, array<UINT32> ^buffer);
        void getDepth(int x, int y, int w, int h, array<float>^ buffer);
        void getNormal(int x, int y, int w, int h, array<UINT32>^ buffer);
        void getCaptureFrame(array<UINT32> ^color, array<UINT32> ^depth);
        void createScreenShot(System::String^ path);
        void setSpriteBatch(SpriteBatch^ s);
        void setFogColor(SharpKmyGfx::Color color);
        void setFogParam(f32 start, f32 depthDensity, f32 heightFallOff);
        void setSSAOParam(f32 radius, f32 minLimit, f32 maxLimit, f32 shadowScale, int sampleCount, f32 contrast, SharpKmyGfx::Color color);
        void enableSSSSS(bool flg);
        void setSSSSSParam(f32 radius, int sampleCount, f32 apply);
        void clearSettings() { if(obj)obj->clearSettings(); }
 
        unsigned short pickup(float x, float y, SharpKmyMath::Vector3% wpos);
        int pickupDetail(float x, float y, array<UINT16> ^idlist, array<SharpKmyMath::Vector3> ^wposlist, array<float> ^depthlist);
        void getTerrainNormal(float x, float y, SharpKmyMath::Vector3% nrm);
        /*
        * ��`�Ńs�b�N�A�b�v���s��
        * left/top/right/bottom (0�`1) �X�N���[�����W�n(���㌴�_)�Ńs�b�N�A�b�v�������͈͂��w�肷��
        * idlist �s�b�N�A�b�v���ꂽ�A�C�e����ID������
        * ignoreTerrain �n�`�͑ΏۊO
        * ignoreManipulator �}�j�s�����[�^�͑ΏۊO
        */
        void pickupRect(float left, float top, float right, float bottom, System::Collections::Generic::List<UINT16>^ idlist, bool ignoreTerrain, bool ignoreManipulator);
        void addHilightPickupID(unsigned short id);
        void clearHilightPickupID();
        void addHoverHilightPickupID(unsigned short id);
        void clearHoverHilightPickupID();
 
        void setReflectionMap(Texture^ tex);
        void setSkyBoxMaterial(System::Guid mtl);
        void setLutMap(System::Guid id);
        void use2DGizmo() { if(obj)obj->use2DGizmo(); }
        void enableVignette(bool flg);
        void setVignette(float value);
        void setIBLIntensity(float value);
        void setReflectionIntensity(float value);
        void setBillboardLightModulation(float value);
 
        void setDistanceFadeEnable(bool flg) { if (obj)obj->setDistanceFadeEnable(flg); }
        void setDistanceFadeStart(float v) { if (obj)obj->setDistanceFadeStart(v); }
 
        bool XZPlaneHitTest(float u, float v, float yoffset, SharpKmyMath::Vector3 %hitpos);
        void addPhysics() { if (obj)obj->addPhysics(); }
        SharpKmyPhysics::PhysicsBase^ getPhysics();
        void addManipulator() { if (obj)obj->addManipulator(); }
        Manipulator^ getManipulator();
        void setMainGameView() { if (obj)obj->setMainGameView(); }
        void resetQualityAdjust() { if (obj)obj->m_gpuTime.resetQualityAdjust((*obj).get()); }
        void set3DGizmoDrawEnabled(bool flg);
        void setModelBoundSphereDrawType(ModelBoundSphereDrawType flg) { if (obj)obj->setModelBoundSphereDrawType((kmyGfx::ModelBoundSphereDrawType)flg); }
        void setSelectionDrawEnabled(bool flg);
        void setPhysicsDebugDrawEnabled(int flag);
        void setPhysicsDebugDrawContactPoints(bool flg);
        void setPhysicsDebugDrawConstraints(bool flg);
        void setPhysicsProcessEnabled(bool flag);
        bool viewVolumeCheck(float x, float y, float z, float radius);
        void addSubGameView(GameView^ sub);
        void enableAsSubGameView(bool flg);
        void removeSubGameView(GameView^ sub, bool removeForce);
        void removeSubGameView(GameView^ sub) { removeSubGameView(sub, true); }
        Texture^ getCaptureColorTexture();
        Texture^ getCaptureDepthTexture();
        void copyBaseRenderingEnviroment(GameView^ src);
        void baseImageCapture(bool flg);
        void enableDynamicResolution(bool flg);
        void setShadowMapScale(float s);
        void setDrawDelegate(GameViewDrawHook ^d);
        void usetDeferredLighting(bool flg);
        void ignoreSuspendChecker() { m_ignoreSuspendChecker = true; }
        void setHiddenStencilColor(float r, float g, float b, float a) { if(obj)obj->setHiddenStencilColor(r, g, b, a); };
 
        static GameView^ getTaskGameView();
        static void setSpriteBatchToTaskGameView(SpriteBatch^ s);
        static void setMaximumResolution(int w, int h);
        static void useAsyncCommandExec() { kmyGfx::GameViewStatics::asyncRendering(); }
        static void globalEnablePostFX(bool flg);
        static Texture^ getPickupIDTexture();
        static Texture^ getBaseDepthTexture();
        static void setPerformanceMeterDrawMode(int mode) { kmyBase::PerformanceMeter::setDrawMode((kmyBase::PerformanceMeter::DrawMode)mode); }
        static void setDrawSuspendChecker(GameViewDrawSuspendChecker^ body);
        static bool isDrawSuspending();
        static GameViewDrawSuspendChecker^ s_checker;
        static void bootProgressMessage(System::String^ text);
 
        bool m_ignoreSuspendChecker = false;
        bool owning = false;
 
        void save();
        void restore();
 
        void enableIconDrawer(bool enable) { if (obj) obj->m_iconDrawer._enable = enable; }
 
        SharpKmyMath::Matrix4 getCameraProj()
        {
            return (context._setCamera) ? context._cameraProj : SharpKmyMath::Matrix4::identity();
        }
        SharpKmyMath::Matrix4 getCameraView()
        {
            return (context._setCamera) ? context._cameraView : SharpKmyMath::Matrix4::identity();
        }
 
    private:
        SharedPtr<kmyGfx::GameView>^ obj = nullptr;
 
        ref struct settings
        {
            bool _setSpriteBatch = false;
            SpriteBatch ^_spriteBatch;
            bool _setCamera = false;
            SharpKmyMath::Matrix4 _cameraProj;
            SharpKmyMath::Matrix4 _cameraView;
            bool _setDLPosture = false;
            SharpKmyMath::Matrix4 _directionalLightPosture;
            bool _setDLColor = false;
            SharpKmyGfx::Color _directionalLightColor;
            bool _setDLShadowColor = false;
            SharpKmyGfx::Color _directionalLightShadowColor;
            bool _setDLShadowVM = false;
            f32 _directionalLightShadowVolumeMargin;
            bool _setDLShadowBias = false;
            f32 _directionalLightShadowBias;
            bool _setDLShadowDistane = false;
            f32 _directionalLightShadowDistance;
            bool _setCascadeStep = false;
            f32 _cascadeStep1;
            f32 _cascadeStep2;
            f32 _cascadeStep3;
            bool _setCascadeCount = false;
            int _cascadeCount = 4;
            bool _setEnableCascadeViusalize = false;
            bool _enableCascadeVisualize = false;
            bool _setAmbientLight = false;
            SharpKmyGfx::Color _ambientLight;
            bool _setViewport = false;
            int _viewportX;
            int _viewportY;
            int _viewportWidth;
            int _viewportHeight;
            bool _setViewportSize = false;
            int _viewportSizeWidth;
            int _viewportSizeHeight;
            bool _setDisplayID = false;
            unsigned int _displayID;
            bool _setBackGroundColor = false;
            SharpKmyGfx::Color _backGroundColor;
            bool _setBloom = false;
            bool _bloom;
            bool _setBloomParam = false;
            float _bloomParamApply;
            float _bloomParamHilightThreshold;
            bool _setAutoExposure = false;
            bool _autoExposure;
            bool _setAutoExposureParam = false;
            float _autoExposureParamTargetBrightness;
            float _autoExposureParamMinScale;
            float _autoExposureParamMaxScale;
            bool _setChromaticAbberation = false;
            bool _chromaticAbberation;
            bool _setChromaticAbberationParam = false;
            float _chromaticAbberationParmSize;
            bool _setDof = false;
            bool _dof;
            bool _setDofParam = false;
            float _dofParamSmoothStart;
            float _dofParamSmoothRange;
            float _dofParamRadius;
            bool _setFxaa = false;
            bool _fxaa;
            bool _setReflectionMap = false;
            Texture^ _reflectionMap;
            bool _setSkyBoxMaterial = false;
            System::Guid _skyBoxMaterial;
            bool _setLutMap = false;
            System::Guid _lutMap;
            bool _setFogColor = false;
            SharpKmyGfx::Color _fogColor;
            bool _setFogParam = false;
            f32 _fogParamStart;
            f32 _fogParamDepthDensity;
            f32 _fogParamHeightFallOff;
            bool _setSSAOParam = false;
            f32 _ssaoParamRadius;
            f32 _ssaoParamMinLimit;
            f32 _ssaoParamMaxLimit;
            f32 _ssaoParamShadowScle;
            int _ssaoParamSampleCount;
            f32 _ssaoParamContrast;
            SharpKmyGfx::Color _ssaoParamColor;
            bool _setSSSSS = false;
            bool _SSSSS;
            bool _setSSSSSParam = false;
            f32 _SSSSSParamRadius;
            int _SSSSSParamSampleCount;
            f32 _SSSSSParamApply;
            bool _setShadowMapScale = false;
            float _shadowMapScale;
 
            bool _setEnableVignette = false;
            bool _enableVignette;
            bool _setVignette = false;
            float _vignatte;
            bool _setIBLIntensity = false;
            float _IBLIntensity;
            bool _setBillboardLightModulation = false;
            float _billboardLightModulation;
            bool _setReflectionIntensity = false;
            float _reflectionIntensity;
            bool _setUsetDeferredLighting = false;
            bool _usetDeferredLighting;
 
            bool _setSharpen = false;
            bool _sharpen = false;
            bool _setSharpenParam = false;
            float _sharpenParamStrength;
            float _sharpenParamDistance;
 
            void copy(settings% o)
            {
                _setSpriteBatch = o._setSpriteBatch;
                _spriteBatch = o._spriteBatch;
                _setCamera = o._setCamera;
                _cameraProj = o._cameraProj;
                _cameraView = o._cameraView;
                _setDLPosture = o._setDLPosture;
                _directionalLightPosture = o._directionalLightPosture;
                _setDLColor = o._setDLColor;
                _directionalLightColor = o._directionalLightColor;
                _setDLShadowColor = o._setDLShadowColor;
                _directionalLightShadowColor = o._directionalLightShadowColor;
                _setDLShadowVM = o._setDLShadowVM;
                _directionalLightShadowVolumeMargin = o._directionalLightShadowVolumeMargin;
                _setDLShadowBias = o._setDLShadowBias;
                _directionalLightShadowBias = o._directionalLightShadowBias;
                _setDLShadowDistane = o._setDLShadowDistane;
                _directionalLightShadowDistance = o._directionalLightShadowDistance;
                _cascadeStep1 = o._cascadeStep1;
                _cascadeStep2 = o._cascadeStep2;
                _cascadeStep3 = o._cascadeStep3;
                _cascadeCount = o._cascadeCount;
                _enableCascadeVisualize = o._enableCascadeVisualize;
                _setAmbientLight = o._setAmbientLight;
                _ambientLight = o._ambientLight;
                _setViewportSize = o._setViewportSize;
                _viewportSizeWidth = o._viewportSizeWidth;
                _viewportSizeHeight = o._viewportSizeHeight;
                _setDisplayID = o._setDisplayID;
                _displayID = o._displayID;
                _setBackGroundColor = o._setBackGroundColor;
                _backGroundColor = o._backGroundColor;
                _setBloom = o._setBloom;
                _bloom = o._bloom;
                _setBloomParam = o._setBloomParam;
                _bloomParamApply = o._bloomParamApply;
                _bloomParamHilightThreshold = o._bloomParamHilightThreshold;
                _setAutoExposure = o._setAutoExposure;
                _autoExposure = o._autoExposure;
                _setAutoExposureParam = o._setAutoExposureParam;
                _autoExposureParamTargetBrightness = o._autoExposureParamTargetBrightness;
                _autoExposureParamMinScale = o._autoExposureParamMinScale;
                _autoExposureParamMaxScale = o._autoExposureParamMaxScale;
                _setChromaticAbberation = o._setChromaticAbberation;
                _chromaticAbberation = o._chromaticAbberation;
                _setChromaticAbberationParam = o._setChromaticAbberationParam;
                _chromaticAbberationParmSize = o._chromaticAbberationParmSize;
                _setDof = o._setDof;
                _dof = o._dof;
                _setDofParam = o._setDofParam;
                _dofParamSmoothStart = o._dofParamSmoothStart;
                _dofParamSmoothRange = o._dofParamSmoothRange;
                _dofParamRadius = o._dofParamRadius;
                _setFxaa = o._setFxaa;
                _fxaa = o._fxaa;
                _setReflectionMap = o._setReflectionMap;
                _reflectionMap = o._reflectionMap;
                _setSkyBoxMaterial = o._setSkyBoxMaterial;
                _skyBoxMaterial = o._skyBoxMaterial;
                _setLutMap = o._setLutMap;
                _lutMap = o._lutMap;
                _setFogColor = o._setFogColor;
                _fogColor = o._fogColor;
                _setFogParam = o._setFogParam;
                _fogParamStart = o._fogParamStart;
                _fogParamDepthDensity = o._fogParamDepthDensity;
                _fogParamHeightFallOff = o._fogParamHeightFallOff;
                _setSSAOParam = o._setSSAOParam;
                _ssaoParamRadius = o._ssaoParamRadius;
                _ssaoParamMinLimit = o._ssaoParamMinLimit;
                _ssaoParamMaxLimit = o._ssaoParamMaxLimit;
                _ssaoParamShadowScle = o._ssaoParamShadowScle;
                _ssaoParamSampleCount = o._ssaoParamSampleCount;
                _ssaoParamContrast = o._ssaoParamContrast;
                _ssaoParamColor = o._ssaoParamColor;
                _setSSSSS = o._setSSSSS;
                _SSSSS = o._SSSSS;
                _setSSSSSParam = o._setSSSSSParam;
                _SSSSSParamRadius = o._SSSSSParamRadius;
                _SSSSSParamSampleCount = o._SSSSSParamSampleCount;
                _SSSSSParamApply = o._SSSSSParamApply;
                _setShadowMapScale = o._setShadowMapScale;
                _shadowMapScale = o._shadowMapScale;
 
                _setEnableVignette = o._setEnableVignette;
                _enableVignette = o._enableVignette;
                _setVignette = o._setVignette;
                _vignatte = o._vignatte;
                _setIBLIntensity = o._setIBLIntensity;
                _IBLIntensity = o._IBLIntensity;
                _setReflectionIntensity = o._setReflectionIntensity;
                _reflectionIntensity = o._reflectionIntensity;
                _setUsetDeferredLighting = o._setUsetDeferredLighting;
                _usetDeferredLighting = o._usetDeferredLighting;
            }
        };
        settings context;
        bool _saved = false;
        settings contextSaved;
    };
 
    public ref class GfxTest
    {
    public:
        //�񓯊��e�X�g
        static void addParticleResourceForLoadTest(System::String^ path);
    };
}