doc/api/_gx_sys_environment_8h_source.html

//===========================================================================

//===========================================================================

#pragma once


#define USE_GXSYSGPGPU 0


GX_CORE_NAMESPACE_BEGIN()


//===========================================================================

//===========================================================================


class GxRandomMT19937 : public GxRandom

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GX_PROHIBIT_COPY(GxRandomMT19937)

private:

    static constexpr s32        N = 624;

    static constexpr s32        M = 397;

    static constexpr u32        MATRIX_A = 0x9908b0dfU;

    static constexpr u32        UPPER_MASK = 0x80000000U;   // most significant w-r bits //

    static constexpr u32        LOWER_MASK = 0x7fffffffU;   // least significant r bits //


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GxRandomMT19937(void);

    GxRandomMT19937(u32 seed);

    ~GxRandomMT19937(void) override {}


    void initialize(u32 seed) override;


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    u32 getRandomU32(void) override;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

private:

    void updateTable(void);


    //-----------------------------------------------------------

    //-----------------------------------------------------------

private:

    u32     mt[N];

    s32     mti;


};


class Utility

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:


    struct VertexPositionTexture

    {

        GxFloat3    _position;

        GxFloat2    _uv;

    };


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    static void createMipmap( GxRenderTexture* pTexture );

    static s32 getMaterialFunctionIndex( GxResShaderPackage* pShaderPackage, GX_HANDLE handleMaterialFunctions, const GxString& materialFunctionName );

    static void setMaterialFunctions( GxResShaderPackage* pShaderPackage, GxShaderPackage::GxShaderCode* pShaderCode, const GxString& materialName, const GxString& materialFunctionName );

    static b32 setShaders( GxResShaderPackage* pShaderPackage, GxShaderPackage::GxShaderCode* pShaderCode );

    static void setSamplerState( GX_HANDLE handle, RENDER_SAMPLER_FILTER min, RENDER_SAMPLER_FILTER mag, RENDER_SAMPLER_FILTER mip, RENDER_SAMPLER_ADDRESS_MODE addressU, RENDER_SAMPLER_ADDRESS_MODE addressV );

    static void setTexture( GX_HANDLE handle, GxRenderTexture* pTexture, RENDER_SAMPLER_FILTER min, RENDER_SAMPLER_FILTER mag, RENDER_SAMPLER_FILTER mip, RENDER_SAMPLER_ADDRESS_MODE addressU, RENDER_SAMPLER_ADDRESS_MODE addressV );

    static GxRenderVertexBuffer* createVertexBufferSphere( s32 xdiv, s32 ydiv, s32 ycount );

    static GxRenderVertexDeclaration* createVertexDeclarationSphere(void);


    static GxVector4 getFogParam( f32 startDistance, f32 endDistance, f32 min, f32 max );


};


enum RENDER_MODE

{

    // アルファブレンドモード //

    RENDER_MODE_OPAQUE                  = 0,

    RENDER_MODE_TRANSLUCENT             = 1,

    RENDER_MODE_CUTOUT                  = 2,

    RENDER_MODE_ADDITIVE                = 3,

    RENDER_MODE_SUBTRACTIVE             = 4,

    RENDER_MODE_BLEND_RESERVED1         = 5,

    RENDER_MODE_BLEND_RESERVED2         = 6,

    RENDER_MODE_BLEND_RESERVED3         = 7,

    RENDER_MODE_BLEND_MASK              = 7,

    // デプスモード //

    RENDER_MODE_DEPTH_DISABLE           = 0,

    RENDER_MODE_DEPTH_ENABLE            = 8,

    RENDER_MODE_DEPTH_TEST_BUT_NO_WRITES = 16,

    RENDER_MODE_DEPTH_NO_TEST_BUT_WRITES = 24,

    RENDER_MODE_DEPTH_MASK              = 24,

    // カルモード //

    RENDER_MODE_CULL_NONE               = 0,

    RENDER_MODE_CULL_CW                 = 32,

    RENDER_MODE_CULL_CCW                = 64,

    RENDER_MODE_CULL_RESERVED           = 96,

    RENDER_MODE_CULL_MASK               = 96,

};


class RenderMode : public GxClassBase

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    RenderMode(void);

    ~RenderMode(void) override {}


    void initialize(void);


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    void setRenderMode( u32 mode );


    //-------------------------------------------------------------

    //-------------------------------------------------------------

private:

    u32     _currentMode;


};


struct PerlinNoiseParam : public GxStructBase

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_RTTI_STRUCT(PerlinNoiseParam)


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    PerlinNoiseParam(void) :

        _seed(0), _startOctave(0), _endOctave(0), _amplitude(0.f), _persistence(0.f), _base(0.f) {}


    PerlinNoiseParam( s8 startOctave, s8 endOctave, f32 amplitude, f32 persistence, f32 base, u16 seed ) :

        _seed(seed), _startOctave(startOctave), _endOctave(endOctave), _amplitude(amplitude), _persistence(persistence), _base(base) {}


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    void clamp(void);


    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    u16         _seed;

    s8          _startOctave;

    s8          _endOctave;

    f32         _amplitude;

    f32         _persistence;

    f32         _base;


};


//===========================================================================

//===========================================================================


class GxSysGpgpu : public GxSysBase, public SingletonBase<GxSysGpgpu>

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_RTTI_ABSTRACT_CLASS(GxSysGpgpu, GxSysBase)

    // ClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxSysGpgpu)


    class BlockDraw : public GxClassBase

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------

    public:

        GX_RTTI_CLASS(BlockDraw, GxClassBase)


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        BlockDraw(void) : _isDrawFinished(true) {}

        ~BlockDraw(void) override { blockDrawFinished(); }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GX_FORCE_INLINE void setCallback(void)

        {

            _isDrawFinished = false;

            getGxRenderContext()->setCallback(GX_CALLBACK_HANDLER_CLASS(GxSysGpgpu::BlockDraw, this, callbackDrawFinished), this, &_isDrawFinished);

        }


        GX_FORCE_INLINE void blockDrawFinished(void) const

        {

            while (!isDrawFinished());  // 描画終了を待つ //

        }


    private:

        s32 callbackDrawFinished(void* pSource, void* pArgument);


        //-------------------------------------------------------------

        //-------------------------------------------------------------

    public:

        GX_FORCE_INLINE b32 isDrawFinished(void) const { return _isDrawFinished; }


        //-------------------------------------------------------------

        //-------------------------------------------------------------

    private:

        b32                     _isDrawFinished;


    };


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GxSysGpgpu(void);

    ~GxSysGpgpu(void) override {}


    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    void startUsing(void);

    void endUsing(void);

    b32 beginCompute( GxRenderTexture* pTarget, const GxString& computeName );

    void endCompute(void);


    // Computeメソッド //

    void computePerlinNoise( s32 startOctave, s32 endOctave, f32 amplitude, f32 persistence, f32 base, const GxVector2* pOrigin );

    void computePerlinNoise( s32 startOctave, s32 endOctave, f32 amplitude, f32 persistence, f32 base, u16 seed );

    void computePerlinNoise( const PerlinNoiseParam& param );

    void computeNormalAndHeight( GxRenderTexture* pHeightTexture, f32 normalScale );


private:

    void createRandomTexture(void);


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    constexpr GxRenderTexture* getRandomTexture( s32 index ) const { return (index == 0) ? _pTextureRandom0 : _pTextureRandom1; }


    //-------------------------------------------------------------

    //-------------------------------------------------------------

private:

    s32                         _referenceCount;


    GxRenderVertexDeclaration*  _pVertexDeclarationCompute;

    GxRenderVertexBuffer*       _pVertexBufferCompute;

    GxResShaderPackage*         _pShaderPackageCompute;

#if USE_GXSYSGPGPU

    GxShaderPackage::GxShaderCode*  _pShaderCodeCompute;

#endif //USE_GXSYSGPGPU

    GxRenderTexture*            _pTextureRandom0;

    GxRenderTexture*            _pTextureRandom1;

    GX_HANDLE                   _handleRandomSampler0;

    GX_HANDLE                   _handleRandomSampler1;

    GX_HANDLE                   _handleBase;

    GX_HANDLE                   _handleRandomOrigin;

    GX_HANDLE                   _handleHeightSampler;

    GX_HANDLE                   _handleNormalScale;

#if USE_GXSYSGPGPU

    RENDER_VIEW                 _oldView;

#endif //USE_GXSYSGPGPU


};


// アクセスインターフェース

GX_FORCE_INLINE GxSysGpgpu* getGxGpgpu(void){ return GxSysGpgpu::getSingletonPointer(); }


//===========================================================================

//===========================================================================


enum class WEEKDAY

{

    SUN,

    MON,

    TUE,

    WED,

    THU,

    FRI,

    SAT,

    MAX,

};


class GxDateBase : public GxClassBase

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_RTTI_ABSTRACT_CLASS(GxDateBase, GxClassBase)


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GxDateBase(void);

    GxDateBase( s32 year, s32 month, s32 day );

    GxDateBase( s32 julianDay );


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    constexpr s32               getYear(void) const { return _year; }

    constexpr void              setYear( s32 year ) { _year = static_cast<s16>(year); }


    constexpr s32               getMonth(void) const { return _month; }

    constexpr void              setMonth( s32 month ) { _month = static_cast<s8>(month); }


    constexpr s32               getDay(void) const { return _day; }

    constexpr void              setDay( s32 day ) { _day = static_cast<s8>(day); }


    virtual s32                 getJulianDay(void) const = 0;

    GxString                    getDateString(void) const;

    WEEKDAY                     getWeekday(void) const;


    static f64 GetGreenwichSiderealTime( f64 Tu );


protected:

    static s32 getMonth(s32 julianDay);

    static s32 getDate(s32 julianDay, s32 month);


    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    static constexpr s32 divedeFloor(s32 a, s32 b) { return((a > 0) ? a / b : (a - b + 1) / b); }

#if GX_DEVELOP

    static void                 test(void);

#endif //GX_DEVELOP


    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    static s16                  _totalDays[12];


protected:

    s16     _year;

    s8      _month;

    s8      _day;


};


class GxDate : public GxDateBase

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_RTTI_CLASS(GxDate, GxDateBase)


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GxDate(void) : GxDateBase() {}

    GxDate( s32 year, s32 month, s32 day ) : GxDateBase( year, month, day ) {}

    GxDate( s32 julianDay );


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    s32                 getJulianDay(void) const override;


};


class GxJulianDate : public GxDateBase

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_RTTI_CLASS(GxJulianDate, GxClassBase)


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GxJulianDate(void) : GxDateBase() {}

    GxJulianDate( s32 year, s32 month, s32 day ) : GxDateBase( year, month, day ) {}

    GxJulianDate( s32 julianDay );


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    s32 getJulianDay(void) const override;

private:

    static s32 getJuliCalY( s32 j );

    static s32 getJuliCalJD( s32 j );


};


class GxOrbitalPosition

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    static  GxVector3 calcOrbitalPosition( f64 a, f64 e, f64 M0, f64 n, f64 epoch, f64 t );

private:

    static  GxVector3 calcEllipticalOrbit( f64 a, f64 e, f64 M );

    static  GxVector3 calcHyperbolicOrbit( f64 a, f64 e, f64 M );


};


// 定数定義

#define     GX_K_GAUSS              0.01720209895

#define     GX_SPEED_OF_LIGHT       299792458.0


#define     GX_1AU_SEC              499.0047838061

#define     GX_G_GRAV               6.672e-11

#define     GX_R_ME                 0.01230002


#define     GX_J2000                2451545.0

#define     GX_EPSJ2000             (84381.448/(60*60))


#define     GX_1AU_METER            (GX_SPEED_OF_LIGHT * GX_1AU_SEC)

#define     GX_1LY_METER            (GX_SPEED_OF_LIGHT * 365.25*24*60*60)

#define     GX_1PC_METER            (GX_1AU_METER / 4.8481369958608411e-6)


#define     GX_1AU_KM               (GX_1AU_METER / GxMath::KILO_VALUE)

#define     GX_1KM_AU               (1.0 / GX_1AU_KM)

#define     GX_1LY_KM               (GX_1LY_METER / GxMath::KILO_VALUE)

#define     GX_1KM_LY               (1.0 / GX_1LY_KM)

#define     GX_1PC_KM               (GX_1PC_METER / GxMath::KILO_VALUE)

#define     GX_1KM_PC               (1.0 / GX_1PC_KM)


#define     GX_1AU_PC               GX_1AU_METER/GX_1PC_METER

#define     GX_1PC_AU               GX_1PC_METER/GX_1AU_METER

#define     GX_1PC_LY               GX_1PC_METER/GX_1LY_METER

#define     GX_1LY_PC               GX_1LY_METER/GX_1PC_METER


// original : orbital_elements "mtk_orbital_element.h"


class OrbitalElements

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    void    initialize( f64 epoch, f64 a, f64 e, f64 M0, f64 node, f64 i, f64 omg );


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    void    update( f64 t );


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    constexpr f64               getEpoch(void) const    { return _epoch; }

    constexpr f64               getA(void) const        { return _a; }

    constexpr f64               getE(void) const        { return _e; }

    constexpr f64               getM0(void) const       { return _M0; }

    constexpr f64               getN(void) const        { return _n; }

    GX_FORCE_INLINE GxMatrixAffine  getTransformMatrix(void) const  { return _transformMatrix; }

    GX_FORCE_INLINE GxVector3       getPosition(void) const { return _position; }


    GxVector3   calcOrbitalPosition( f64 phi ) const;

    static GxVector3 calcOrbitalPosition( f64 a, f64 e, f64 phi );


    //-------------------------------------------------------------

    //-------------------------------------------------------------

private:

    f64             _epoch;

    f64             _a;

    f64             _e;

    f64             _M0;

    f64             _n;

    GxMatrixAffine  _transformMatrix;


    GxVector3       _position;


};


enum class GX_PLANET

{

    MERCURY,

    VENUS,

    EARTH,

    MARS,

    JUPITER,

    SATURN,

    URANUS,

    NEPTUNE,

    PLUTO,

    MAX,

};


class GxPlanetData

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    // original : planet_orbital_elements "mtk_planet_position.cpp"


    struct PlanetOribtalElements

    {

        f64     _epoch;

        f64     _a;

        f64     _e;

        f64     _T;

        f64     _i;

        f64     _node;

        f64     _omg_bar;

        f64     _L;

        f64     _Re;

    };


    static const PlanetOribtalElements  planetOribtalElements[static_cast<s32>(GX_PLANET::MAX)];


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    static constexpr f64 getPlanetRadius( GX_PLANET planet ) { return planetOribtalElements[ static_cast<u32>(planet) ]._Re * GX_1KM_PC; }

    static constexpr f64 getMoonRadius(void) { return 1738 * GX_1KM_PC; }

    static constexpr f64 getSunRadius(void) { return 696000 * GX_1KM_PC; }


};


class GxSolarSystem

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------


    struct GxVector3f64

    {

        //-------------------------------------------------------------

        //-------------------------------------------------------------


        GxVector3f64( f64 x, f64 y, f64 z ) { _x = x; _y = y; _z = z; }

        GxVector3f64( const GxVector3& v ) { _x = v._x; _y = v._y; _z = v._z; }

        operator GxVector3(void) const { return GxVector3( static_cast<f32>(_x), static_cast<f32>(_y), static_cast<f32>(_z) ); }


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        static GxVector3f64 getCross(const GxVector3f64& vector0, const GxVector3f64& vector1);

        GxVector3f64 getNormalize(void) const;

        GxVector3f64 getTransformNormal( const GxMatrixAffine& matrix );


        //-------------------------------------------------------------

        //-------------------------------------------------------------


        f64 _x;

        f64 _y;

        f64 _z;


    };


    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    void initialize(void);


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    void update( f64 at, f64 longitude, f64 latitude );


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GX_FORCE_INLINE const GxVector3&            getPlanetPositionEC( GX_PLANET planet ) const { return _planetPositionsEC[static_cast<u32>(planet)]; }

    GX_FORCE_INLINE const GxVector3&            getPlanetPositionHC( GX_PLANET planet ) const { return _planetPositionsHC[static_cast<u32>(planet)]; }

    constexpr f64                               getPlanetRadius( GX_PLANET planet ) const { return GxPlanetData::getPlanetRadius( planet ); }

    GX_FORCE_INLINE const GxVector3&            getMoonPositionEC(void) const { return _moonPositionEC; }

    GX_FORCE_INLINE const GxVector3&            getMoonPositionHC(void) const { return _moonPositionHC; }

    GX_FORCE_INLINE const GxMatrixAffine&       getMoonOrientation(void) const { return _moonEcToSatMatrix; }

    constexpr f64                               getMoonRadius(void) const { return GxPlanetData::getMoonRadius(); }

    GX_FORCE_INLINE const GxVector3&            getSunPositionHC(void) const { return _sunPositionHC; }

    constexpr f64                               getSunRadius(void) const { return GxPlanetData::getSunRadius(); }


    GX_FORCE_INLINE const GxMatrixAffine&       getPlanetMatrixECtoPL(void) const { return _planetMatrixECtoPL; }


    GX_FORCE_INLINE const OrbitalElements&      getPlanetOrbitalElements( GX_PLANET planet ) const { return _planetsOrbitalElements[static_cast<u32>(planet)]; }


    constexpr GX_CSTR                           getPlanetNameJapan( GX_PLANET planet ) const { return _planetNameJapan[2 + static_cast<s32>(planet)]; }

    constexpr GX_CSTR                           getPlanetNameEnglish( GX_PLANET planet ) const { return _planetNameEnglish[2 + static_cast<s32>(planet)]; }

    GX_FORCE_INLINE GX_CSTR                     getSunNameJapan(void) const { return _planetNameJapan[0]; }

    GX_FORCE_INLINE GX_CSTR                     getSunNameEnglish(void) const { return _planetNameEnglish[0]; }

    GX_FORCE_INLINE GX_CSTR                     getMoonNameJapan(void) const { return _planetNameJapan[1]; }

    GX_FORCE_INLINE GX_CSTR                     getMoonNameEnglish(void) const { return _planetNameEnglish[1]; }


    static GxVector3 transformPosition( f32 alpha, f32 delta );

private:

    static GxVector3            calcMoonPosition(f64 t);

    static void                 calcMoonOrientation(f64 at, f64& alpha, f64& delta, f64& W);

    static GxMatrixAffine       getPlanetMatrixECtoPL(f64 at);

    static GxMatrixAffine       getMoonMatrixECtoSAT(f64 at);

    static GxVector3f64         getPlanetNormalVectorPL(f64 longitude, f64 latitude);

    static GxVector3f64         getPlanetNormalVectorEC(const GxMatrixAffine& planetMatrixECtoPL, f64 longitude, f64 latitude);


    //-------------------------------------------------------------

    //-------------------------------------------------------------

private:

    f64                         _t;

    f64                         _at;

    f64                         _longitude;

    f64                         _latitude;


    OrbitalElements             _planetsOrbitalElements[static_cast<s32>(GX_PLANET::MAX)];


    GxVector3                   _planetPositionsEC[static_cast<s32>(GX_PLANET::MAX)];

    GxVector3                   _planetPositionsHC[static_cast<s32>(GX_PLANET::MAX)];


    GxVector3                   _moonPositionEC;

    GxVector3                   _moonPositionHC;


    GxMatrixAffine              _moonEcToSatMatrix;


    GxVector3                   _sunPositionHC;


    GxMatrixAffine              _planetMatrixECtoPL;


    static GX_CSTR              _planetNameJapan[];

    static GX_CSTR              _planetNameEnglish[];

};


//===========================================================================

//===========================================================================


class GxSysEnvironment : public GxSysBase, public SingletonBase<GxSysEnvironment>

{

    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    GX_RTTI_ABSTRACT_CLASS(GxSysEnvironment, GxSysBase)

    // ClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxSysEnvironment)


    //-------------------------------------------------------------

    //-------------------------------------------------------------


    GxSysEnvironment(void);

    ~GxSysEnvironment(void) override {}


    //-------------------------------------------------------------

    //-------------------------------------------------------------

public:

    void                        update(void) override;

private:

    f32                         calcSiderealTime(void) const;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    constexpr f32               getLatitude(void) const { return _latitude; }

    GX_FORCE_INLINE void        setLatitude(f32 latitude) { _latitude = GxMath::getClamp( latitude, -89.9999f, 89.9999f ); }


    constexpr f32               getLongitude(void) const { return _longitude; }

    constexpr void              setLongitude(f32 longitude) { _longitude = longitude; }


    constexpr f32               getAltitude(void) const { return _altitude; }

    constexpr void              setAltitude(f32 altitude) { _altitude = altitude; }


    constexpr f32               getObliquity(void) const { return _obliquity; }

    constexpr void              setObliquity(f32 obliquity) { _obliquity = obliquity; }


    const GxDate&               getDate(void) const { return _date; }

    GX_FORCE_INLINE void        setDate( const GxDate& date ) { _date = date; _julianDay = date.getJulianDay(); }

    GX_FORCE_INLINE void        setJulianDay( s32 julianDay ) { _julianDay = julianDay; _date = GxDate( julianDay ); }


    constexpr f32               getDifferentTime(void) const { return _differentTime; }

    constexpr void              setDifferentTime(f32 time) { _differentTime = time; }


    constexpr f32               getSiderealTime(void) const { return _siderealTime; }


    constexpr f64               getRotationTime(void) const { return _rotationTime; }

    constexpr void              setRotationTime(f64 time) { _rotationTime = time; }

    constexpr void              setRotationTime( s32 hour, s32 minute, f64 second ) { _rotationTime = (hour*3600 + minute*60 + second)/(24*3600.0); }

    constexpr f64               getRotationSpeed(void) const { return _rotationSpeed; }

    constexpr f64               getRotationSpeedScale(void) const { return _rotationSpeedScale; }

    constexpr void              setRotationSpeed(f64 speed) { _rotationSpeed = speed; _rotationSpeedScale = _rotationSpeed * (24.0*60*60*60); }

    constexpr void              setRotationSpeedScale(f64 speedScale) { _rotationSpeed = speedScale/(24.0*60*60*60); _rotationSpeedScale = speedScale; }


    constexpr f32               getCloudyFactor(void) const { return _cloudyFactor; }

    constexpr void              setCloudyFactor(f32 factor) { _cloudyFactor = factor; }

    constexpr f32               getStormyFactor(void) const { return _stormyFactor; }

    constexpr void              setStormyFactor(f32 factor) { _stormyFactor = factor; }

    constexpr f32               getBlizzardFactor(void) const { return _blizzardFactor; }

    constexpr void              setBlizzardFactor(f32 factor) { _blizzardFactor = factor; }

    const GxVector3&            getWindVector(void) const { return _windVector; }

    GX_FORCE_INLINE void        setWindVector(const GxVector3& vector) { _windVector = vector; }

    GX_FORCE_INLINE GxSolarSystem&  getSolarSystem(void) { return _solarSystem; }


    GX_FORCE_INLINE const GxVector4& getDirectionalLightVector(void) const { return _directionalLightVector; }

    GX_FORCE_INLINE const GxVector4& getDirectionalLightColor(void) const { return _directionalLightColor; }

    GX_FORCE_INLINE const GxVector4& getAmbientColor(void) const { return _ambientColor; }


    //-------------------------------------------------------------

    //-------------------------------------------------------------

private:

    f32                         _latitude;

    f32                         _longitude;

    f32                         _altitude;

    f32                         _obliquity;


    GxDate                      _date;

    s32                         _julianDay;

    f32                         _differentTime;

    f64                         _rotationTime;

    f64                         _rotationSpeed;

    f64                         _rotationSpeedScale;

    f32                         _siderealTime;


    f32                         _cloudyFactor;

    f32                         _stormyFactor;

    f32                         _blizzardFactor;

    GxVector3                   _windVector;


    GxVector4                   _directionalLightVector;

    GxVector4                   _directionalLightColor;

    GxVector4                   _ambientColor;


    GxSolarSystem               _solarSystem;


};


// アクセスインターフェース

GX_FORCE_INLINE GxSysEnvironment* getGxSysEnvironment(void){ return GxSysEnvironment::getSingletonPointer(); }


GX_CORE_NAMESPACE_END()

GX_PROHIBIT_COPY
#define GX_PROHIBIT_COPY(__CLASS__)
コピー禁止
Definition GxBase.h:233

GX_PROHIBIT_CLASS_BASE
#define GX_PROHIBIT_CLASS_BASE(__CLASS__)
GxClassBase継承の禁止宣言
Definition GxBase.h:240

GX_CALLBACK_HANDLER_CLASS
#define GX_CALLBACK_HANDLER_CLASS(__class__, __pOwner__, __func__)
クラスメンバ関数用
Definition GxCallback.h:204

GX_HANDLE
u32 GX_HANDLE
ハンドル
Definition GxDefine.h:214

RENDER_SAMPLER_FILTER
RENDER_SAMPLER_FILTER
サンプラステート(フィルタ)
Definition GxRender.h:992

RENDER_VIEW
RENDER_VIEW
描画優先度（ビュー）
Definition GxRender.h:442

RENDER_SAMPLER_ADDRESS_MODE
RENDER_SAMPLER_ADDRESS_MODE
サンプラステート(アドレッシングモード)
Definition GxRender.h:958

GX_PLANET
GX_PLANET
惑星定義
Definition GxSysEnvironment.h:696

GX_PLANET::MAX
@ MAX
定義数

GX_PLANET::SATURN
@ SATURN
"{土星|どせい}"

GX_PLANET::MARS
@ MARS
"{火星|かせい}"

GX_PLANET::URANUS
@ URANUS
"{天王星|てんのうせい}"

GX_PLANET::VENUS
@ VENUS
"{金星|きんせい}"

GX_PLANET::JUPITER
@ JUPITER
"{木星|もくせい}"

GX_PLANET::NEPTUNE
@ NEPTUNE
"{海王星|かいおうせい}"

GX_PLANET::MERCURY
@ MERCURY
"{水星|すいせい}"

GX_PLANET::EARTH
@ EARTH
"{地球|ちきゅう}"

GX_PLANET::PLUTO
@ PLUTO
"{冥王星|めいおうせい}"

WEEKDAY
WEEKDAY
日付クラス
Definition GxSysEnvironment.h:405

WEEKDAY::MAX
@ MAX
定義数

WEEKDAY::FRI
@ FRI
金曜日

WEEKDAY::SAT
@ SAT
土曜日

WEEKDAY::SUN
@ SUN
日曜日

WEEKDAY::WED
@ WED
水曜日

WEEKDAY::MON
@ MON
月曜日

WEEKDAY::THU
@ THU
木曜日

WEEKDAY::TUE
@ TUE
火曜日

GX_1KM_PC
#define GX_1KM_PC
KM -> PC.
Definition GxSysEnvironment.h:622

RENDER_MODE
RENDER_MODE
描画モード定義
Definition GxSysEnvironment.h:134

RENDER_MODE_SUBTRACTIVE
@ RENDER_MODE_SUBTRACTIVE
減算
Definition GxSysEnvironment.h:140

RENDER_MODE_BLEND_RESERVED2
@ RENDER_MODE_BLEND_RESERVED2
ブレンド予備
Definition GxSysEnvironment.h:142

RENDER_MODE_DEPTH_TEST_BUT_NO_WRITES
@ RENDER_MODE_DEPTH_TEST_BUT_NO_WRITES
深度テスト(書き込み無し)
Definition GxSysEnvironment.h:148

RENDER_MODE_CULL_RESERVED
@ RENDER_MODE_CULL_RESERVED
カリング予備
Definition GxSysEnvironment.h:155

RENDER_MODE_BLEND_RESERVED1
@ RENDER_MODE_BLEND_RESERVED1
ブレンド予備
Definition GxSysEnvironment.h:141

RENDER_MODE_OPAQUE
@ RENDER_MODE_OPAQUE
不透明
Definition GxSysEnvironment.h:136

RENDER_MODE_TRANSLUCENT
@ RENDER_MODE_TRANSLUCENT
半透明
Definition GxSysEnvironment.h:137

RENDER_MODE_CULL_NONE
@ RENDER_MODE_CULL_NONE
カリング無し
Definition GxSysEnvironment.h:152

RENDER_MODE_DEPTH_DISABLE
@ RENDER_MODE_DEPTH_DISABLE
深度無効
Definition GxSysEnvironment.h:146

RENDER_MODE_CULL_CW
@ RENDER_MODE_CULL_CW
フロントフェースカリング
Definition GxSysEnvironment.h:153

RENDER_MODE_CULL_CCW
@ RENDER_MODE_CULL_CCW
バックフェースカリング
Definition GxSysEnvironment.h:154

RENDER_MODE_BLEND_RESERVED3
@ RENDER_MODE_BLEND_RESERVED3
ブレンド予備
Definition GxSysEnvironment.h:143

RENDER_MODE_CULL_MASK
@ RENDER_MODE_CULL_MASK
カリングマスク
Definition GxSysEnvironment.h:156

RENDER_MODE_ADDITIVE
@ RENDER_MODE_ADDITIVE
加算
Definition GxSysEnvironment.h:139

RENDER_MODE_DEPTH_NO_TEST_BUT_WRITES
@ RENDER_MODE_DEPTH_NO_TEST_BUT_WRITES
深度書き込み(テスト無し)
Definition GxSysEnvironment.h:149

RENDER_MODE_DEPTH_ENABLE
@ RENDER_MODE_DEPTH_ENABLE
深度有効
Definition GxSysEnvironment.h:147

RENDER_MODE_DEPTH_MASK
@ RENDER_MODE_DEPTH_MASK
深度マスク
Definition GxSysEnvironment.h:150

RENDER_MODE_CUTOUT
@ RENDER_MODE_CUTOUT
切り取り
Definition GxSysEnvironment.h:138

RENDER_MODE_BLEND_MASK
@ RENDER_MODE_BLEND_MASK
ブレンドマスク
Definition GxSysEnvironment.h:144

GxClassBase
オブジェクト基底クラス
Definition GxBase.h:88

GxDateBase
暦ベース抽象クラス
Definition GxSysEnvironment.h:418

GxDateBase::setYear
constexpr void setYear(s32 year)
年を設定
Definition GxSysEnvironment.h:448

GxDateBase::getDate
static s32 getDate(s32 julianDay, s32 month)
日を取得
Definition GxSysEnvironment.cpp:1878

GxDateBase::_day
s8 _day
日
Definition GxSysEnvironment.h:501

GxDateBase::_month
s8 _month
月
Definition GxSysEnvironment.h:500

GxDateBase::getJulianDay
virtual s32 getJulianDay(void) const =0
修正ユリウス日を返す

GxDateBase::setDay
constexpr void setDay(s32 day)
日を設定
Definition GxSysEnvironment.h:458

GxDateBase::GetGreenwichSiderealTime
static f64 GetGreenwichSiderealTime(f64 Tu)
Definition GxSysEnvironment.cpp:1917

GxDateBase::GxDateBase
GxDateBase(void)
デフォルトコンストラクタ
Definition GxSysEnvironment.cpp:1805

GxDateBase::_year
s16 _year
合計日数
Definition GxSysEnvironment.h:499

GxDateBase::setMonth
constexpr void setMonth(s32 month)
月を設定
Definition GxSysEnvironment.h:453

GxDateBase::divedeFloor
static constexpr s32 divedeFloor(s32 a, s32 b)
除算(切り捨て)
Definition GxSysEnvironment.h:484

GxDateBase::getMonth
constexpr s32 getMonth(void) const
月を取得
Definition GxSysEnvironment.h:451

GxDateBase::getDateString
GxString getDateString(void) const
日付文字列を返す
Definition GxSysEnvironment.cpp:1887

GxDateBase::getYear
constexpr s32 getYear(void) const
年を取得
Definition GxSysEnvironment.h:446

GxDateBase::getDay
constexpr s32 getDay(void) const
日を取得
Definition GxSysEnvironment.h:456

GxDateBase::getWeekday
WEEKDAY getWeekday(void) const
曜日を返す
Definition GxSysEnvironment.cpp:1901

GxDate
Definition GxSysEnvironment.h:509

GxDate::GxDate
GxDate(s32 year, s32 month, s32 day)
コンストラクタ
Definition GxSysEnvironment.h:526

GxDate::GxDate
GxDate(void)
デフォルトコンストラクタ
Definition GxSysEnvironment.h:524

GxDate::getJulianDay
s32 getJulianDay(void) const override
日を取得
Definition GxSysEnvironment.cpp:2037

GxJulianDate
ユリウス暦
Definition GxSysEnvironment.h:544

GxJulianDate::GxJulianDate
GxJulianDate(void)
デフォルトコンストラクタ
Definition GxSysEnvironment.h:559

GxJulianDate::getJulianDay
s32 getJulianDay(void) const override
日を取得
Definition GxSysEnvironment.cpp:2092

GxJulianDate::GxJulianDate
GxJulianDate(s32 year, s32 month, s32 day)
コンストラクタ
Definition GxSysEnvironment.h:561

GxMath::getClamp
static GX_FORCE_INLINE T getClamp(const T value, const T min, const T max)
最小値・最大値で切り落とす
Definition GxMath.h:170

GxOrbitalPosition
軌道計算クラス
Definition GxSysEnvironment.h:584

GxOrbitalPosition::calcOrbitalPosition
static GxVector3 calcOrbitalPosition(f64 a, f64 e, f64 M0, f64 n, f64 epoch, f64 t)
軌道上の位置を求める（軌道座標系：焦点が原点）
Definition GxSysEnvironment.cpp:1155

GxPlanetData
惑星データ取得クラス
Definition GxSysEnvironment.h:711

GxPlanetData::planetOribtalElements
static const PlanetOribtalElements planetOribtalElements[static_cast< s32 >(GX_PLANET::MAX)]
データテーブル
Definition GxSysEnvironment.h:1250

GxPlanetData::getMoonRadius
static constexpr f64 getMoonRadius(void)
月の半径を取得
Definition GxSysEnvironment.h:743

GxPlanetData::getSunRadius
static constexpr f64 getSunRadius(void)
太陽の半径を取得
Definition GxSysEnvironment.h:745

GxPlanetData::getPlanetRadius
static constexpr f64 getPlanetRadius(GX_PLANET planet)
星の半径を取得
Definition GxSysEnvironment.h:741

GxRandom
乱数クラス
Definition GxRandom.h:20

GxRandomMT19937
メルセンヌツイスター乱数クラス
Definition GxSysEnvironment.h:22

GxRandomMT19937::~GxRandomMT19937
~GxRandomMT19937(void) override
デストラクタ
Definition GxSysEnvironment.h:53

GxRenderContext::setCallback
void setCallback(GxCallback::GxHandlerBase handle, void *pSource, void *pArgument)
コールバックの設定
Definition GxRenderContext.cpp:1091

GxRenderTexture
テクスチャクラス
Definition GxRenderTexture.h:19

GxRenderVertexBuffer
頂点バッファを管理する
Definition GxRenderVertexBuffer.h:20

GxRenderVertexDeclaration
頂点シェーダに渡す頂点の宣言を管理する
Definition GxRenderVertexDeclaration.h:22

GxResShaderPackage
シェーダパッケージリソースクラス
Definition GxResShaderPackage.h:19

GxSolarSystem
太陽系クラス
Definition GxSysEnvironment.h:752

GxSolarSystem::getMoonNameEnglish
GX_FORCE_INLINE GX_CSTR getMoonNameEnglish(void) const
月の英語名を取得
Definition GxSysEnvironment.h:858

GxSolarSystem::getMoonRadius
constexpr f64 getMoonRadius(void) const
月半径を取得
Definition GxSysEnvironment.h:835

GxSolarSystem::getPlanetRadius
constexpr f64 getPlanetRadius(GX_PLANET planet) const
惑星半径を取得
Definition GxSysEnvironment.h:827

GxSolarSystem::getMoonPositionEC
GX_FORCE_INLINE const GxVector3 & getMoonPositionEC(void) const
月位置を取得(黄道座標系)
Definition GxSysEnvironment.h:829

GxSolarSystem::getSunNameJapan
GX_FORCE_INLINE GX_CSTR getSunNameJapan(void) const
太陽の日本語名を取得
Definition GxSysEnvironment.h:852

GxSolarSystem::getPlanetOrbitalElements
GX_FORCE_INLINE const OrbitalElements & getPlanetOrbitalElements(GX_PLANET planet) const
軌道情報を取得
Definition GxSysEnvironment.h:845

GxSolarSystem::transformPosition
static GxVector3 transformPosition(f32 alpha, f32 delta)
赤道座標系から直交座標系への変換
Definition GxSysEnvironment.cpp:1782

GxSolarSystem::update
void update(f64 at, f64 longitude, f64 latitude)
更新
Definition GxSysEnvironment.cpp:1701

GxSolarSystem::initialize
void initialize(void)
初期化
Definition GxSysEnvironment.cpp:1684

GxSolarSystem::getPlanetPositionEC
GX_FORCE_INLINE const GxVector3 & getPlanetPositionEC(GX_PLANET planet) const
惑星位置を取得
Definition GxSysEnvironment.h:823

GxSolarSystem::getPlanetPositionHC
GX_FORCE_INLINE const GxVector3 & getPlanetPositionHC(GX_PLANET planet) const
惑星位置を取得
Definition GxSysEnvironment.h:825

GxSolarSystem::getMoonOrientation
GX_FORCE_INLINE const GxMatrixAffine & getMoonOrientation(void) const
月の向きを取得
Definition GxSysEnvironment.h:833

GxSolarSystem::getPlanetNameJapan
constexpr GX_CSTR getPlanetNameJapan(GX_PLANET planet) const
星の日本語名を取得
Definition GxSysEnvironment.h:848

GxSolarSystem::getSunNameEnglish
GX_FORCE_INLINE GX_CSTR getSunNameEnglish(void) const
太陽の英語名を取得
Definition GxSysEnvironment.h:854

GxSolarSystem::getPlanetNameEnglish
constexpr GX_CSTR getPlanetNameEnglish(GX_PLANET planet) const
星の英語名を取得
Definition GxSysEnvironment.h:850

GxSolarSystem::getMoonPositionHC
GX_FORCE_INLINE const GxVector3 & getMoonPositionHC(void) const
月位置を取得(地平座標系)
Definition GxSysEnvironment.h:831

GxSolarSystem::getSunPositionHC
GX_FORCE_INLINE const GxVector3 & getSunPositionHC(void) const
太陽位置を取得
Definition GxSysEnvironment.h:837

GxSolarSystem::getSunRadius
constexpr f64 getSunRadius(void) const
太陽半径を取得
Definition GxSysEnvironment.h:839

GxSolarSystem::getPlanetMatrixECtoPL
GX_FORCE_INLINE const GxMatrixAffine & getPlanetMatrixECtoPL(void) const
黄道座標から惑星座標へ変換するマトリクスを取得
Definition GxSysEnvironment.h:842

GxSolarSystem::getMoonNameJapan
GX_FORCE_INLINE GX_CSTR getMoonNameJapan(void) const
月の日本語名を取得
Definition GxSysEnvironment.h:856

GxSysBase
システム基底クラス
Definition GxSysBase.h:18

GxSysEnvironment
環境システムクラス
Definition GxSysEnvironment.h:910

GxSysEnvironment::getSolarSystem
GX_FORCE_INLINE GxSolarSystem & getSolarSystem(void)
太陽系を取得
Definition GxSysEnvironment.h:1016

GxSysEnvironment::getAltitude
constexpr f32 getAltitude(void) const
標高取得
Definition GxSysEnvironment.h:960

GxSysEnvironment::setRotationSpeed
constexpr void setRotationSpeed(f64 speed)
自転速度設定
Definition GxSysEnvironment.h:995

GxSysEnvironment::setDifferentTime
constexpr void setDifferentTime(f32 time)
時差設定
Definition GxSysEnvironment.h:979

GxSysEnvironment::setBlizzardFactor
constexpr void setBlizzardFactor(f32 factor)
吹雪度合い設定
Definition GxSysEnvironment.h:1010

GxSysEnvironment::setRotationTime
constexpr void setRotationTime(s32 hour, s32 minute, f64 second)
自転時間設定
Definition GxSysEnvironment.h:989

GxSysEnvironment::setLatitude
GX_FORCE_INLINE void setLatitude(f32 latitude)
緯度設定
Definition GxSysEnvironment.h:952

GxSysEnvironment::~GxSysEnvironment
~GxSysEnvironment(void) override
デストラクタ
Definition GxSysEnvironment.h:929

GxSysEnvironment::getDirectionalLightColor
GX_FORCE_INLINE const GxVector4 & getDirectionalLightColor(void) const
ディレクショナルライトの色を取得
Definition GxSysEnvironment.h:1021

GxSysEnvironment::getDirectionalLightVector
GX_FORCE_INLINE const GxVector4 & getDirectionalLightVector(void) const
ディレクショナルライトの方向を取得
Definition GxSysEnvironment.h:1019

GxSysEnvironment::GxSysEnvironment
GxSysEnvironment(void)
コンストラクタ
Definition GxSysEnvironment.cpp:989

GxSysEnvironment::getLongitude
constexpr f32 getLongitude(void) const
経度取得
Definition GxSysEnvironment.h:955

GxSysEnvironment::setLongitude
constexpr void setLongitude(f32 longitude)
経度設定
Definition GxSysEnvironment.h:957

GxSysEnvironment::setDate
GX_FORCE_INLINE void setDate(const GxDate &date)
日付設定
Definition GxSysEnvironment.h:972

GxSysEnvironment::getDate
const GxDate & getDate(void) const
日付取得
Definition GxSysEnvironment.h:970

GxSysEnvironment::setObliquity
constexpr void setObliquity(f32 obliquity)
自転軸の傾き設定
Definition GxSysEnvironment.h:967

GxSysEnvironment::getLatitude
constexpr f32 getLatitude(void) const
緯度取得
Definition GxSysEnvironment.h:950

GxSysEnvironment::getBlizzardFactor
constexpr f32 getBlizzardFactor(void) const
吹雪度合い取得
Definition GxSysEnvironment.h:1008

GxSysEnvironment::setStormyFactor
constexpr void setStormyFactor(f32 factor)
嵐度合い設定
Definition GxSysEnvironment.h:1006

GxSysEnvironment::update
void update(void) override
更新
Definition GxSysEnvironment.cpp:1013

GxSysEnvironment::getAmbientColor
GX_FORCE_INLINE const GxVector4 & getAmbientColor(void) const
環境光の色を取得
Definition GxSysEnvironment.h:1023

GxSysEnvironment::getSiderealTime
constexpr f32 getSiderealTime(void) const
恒星時取得
Definition GxSysEnvironment.h:982

GxSysEnvironment::setJulianDay
GX_FORCE_INLINE void setJulianDay(s32 julianDay)
日付設定
Definition GxSysEnvironment.h:974

GxSysEnvironment::setAltitude
constexpr void setAltitude(f32 altitude)
標高設定
Definition GxSysEnvironment.h:962

GxSysEnvironment::setCloudyFactor
constexpr void setCloudyFactor(f32 factor)
曇り度合い設定
Definition GxSysEnvironment.h:1002

GxSysEnvironment::getRotationTime
constexpr f64 getRotationTime(void) const
自転時間取得
Definition GxSysEnvironment.h:985

GxSysEnvironment::getStormyFactor
constexpr f32 getStormyFactor(void) const
嵐度合い取得
Definition GxSysEnvironment.h:1004

GxSysEnvironment::getObliquity
constexpr f32 getObliquity(void) const
自転軸の傾き取得
Definition GxSysEnvironment.h:965

GxSysEnvironment::setWindVector
GX_FORCE_INLINE void setWindVector(const GxVector3 &vector)
風の強さを設定
Definition GxSysEnvironment.h:1014

GxSysEnvironment::getRotationSpeedScale
constexpr f64 getRotationSpeedScale(void) const
自転速度取得
Definition GxSysEnvironment.h:993

GxSysEnvironment::setRotationTime
constexpr void setRotationTime(f64 time)
自転時間設定
Definition GxSysEnvironment.h:987

GxSysEnvironment::getRotationSpeed
constexpr f64 getRotationSpeed(void) const
自転速度取得
Definition GxSysEnvironment.h:991

GxSysEnvironment::getDifferentTime
constexpr f32 getDifferentTime(void) const
時差取得
Definition GxSysEnvironment.h:977

GxSysEnvironment::setRotationSpeedScale
constexpr void setRotationSpeedScale(f64 speedScale)
自転速度設定
Definition GxSysEnvironment.h:997

GxSysEnvironment::getWindVector
const GxVector3 & getWindVector(void) const
風の強さを取得
Definition GxSysEnvironment.h:1012

GxSysEnvironment::getCloudyFactor
constexpr f32 getCloudyFactor(void) const
曇り度合い取得
Definition GxSysEnvironment.h:1000

GxSysGpgpu::BlockDraw
描画終了ブロッククラス
Definition GxSysEnvironment.h:259

GxSysGpgpu::BlockDraw::setCallback
GX_FORCE_INLINE void setCallback(void)
コールバックのセット
Definition GxSysEnvironment.h:285

GxSysGpgpu::BlockDraw::blockDrawFinished
GX_FORCE_INLINE void blockDrawFinished(void) const
ブロック
Definition GxSysEnvironment.h:291

GxSysGpgpu::BlockDraw::~BlockDraw
~BlockDraw(void) override
デストラクタ
Definition GxSysEnvironment.h:276

GxSysGpgpu::BlockDraw::isDrawFinished
GX_FORCE_INLINE b32 isDrawFinished(void) const
描画終了判定
Definition GxSysEnvironment.h:306

GxSysGpgpu
GPGPUシステムクラス
Definition GxSysEnvironment.h:247

GxSysGpgpu::endUsing
void endUsing(void)
使用終了
Definition GxSysEnvironment.cpp:604

GxSysGpgpu::computeNormalAndHeight
void computeNormalAndHeight(GxRenderTexture *pHeightTexture, f32 normalScale)
法線と高さを計算
Definition GxSysEnvironment.cpp:717

GxSysGpgpu::computePerlinNoise
void computePerlinNoise(s32 startOctave, s32 endOctave, f32 amplitude, f32 persistence, f32 base, const GxVector2 *pOrigin)
パーリンノイズを計算
Definition GxSysEnvironment.cpp:767

GxSysGpgpu::endCompute
void endCompute(void)
コンピュート終了
Definition GxSysEnvironment.cpp:669

GxSysGpgpu::beginCompute
b32 beginCompute(GxRenderTexture *pTarget, const GxString &computeName)
コンピュート開始
Definition GxSysEnvironment.cpp:622

GxSysGpgpu::~GxSysGpgpu
~GxSysGpgpu(void) override
デストラクタ
Definition GxSysEnvironment.h:328

GxSysGpgpu::GxSysGpgpu
GxSysGpgpu(void)
コンストラクタ
Definition GxSysEnvironment.cpp:545

GxSysGpgpu::startUsing
void startUsing(void)
使用開始
Definition GxSysEnvironment.cpp:561

GxSysGpgpu::getRandomTexture
constexpr GxRenderTexture * getRandomTexture(s32 index) const
ランダムテクスチャを取得
Definition GxSysEnvironment.h:366

OrbitalElements
軌道要素クラス
Definition GxSysEnvironment.h:632

OrbitalElements::getM0
constexpr f64 getM0(void) const
平均近点角を取得
Definition GxSysEnvironment.h:663

OrbitalElements::update
void update(f64 t)
更新
Definition GxSysEnvironment.cpp:1210

OrbitalElements::initialize
void initialize(f64 epoch, f64 a, f64 e, f64 M0, f64 node, f64 i, f64 omg)
初期化
Definition GxSysEnvironment.cpp:1191

OrbitalElements::getEpoch
constexpr f64 getEpoch(void) const
元期 (JD)を取得
Definition GxSysEnvironment.h:657

OrbitalElements::calcOrbitalPosition
GxVector3 calcOrbitalPosition(f64 phi) const
軌道上の位置の計算
Definition GxSysEnvironment.cpp:1222

OrbitalElements::getA
constexpr f64 getA(void) const
軌道長半径(AU)を取得
Definition GxSysEnvironment.h:659

OrbitalElements::getTransformMatrix
GX_FORCE_INLINE GxMatrixAffine getTransformMatrix(void) const
変換行列を取得
Definition GxSysEnvironment.h:667

OrbitalElements::getE
constexpr f64 getE(void) const
軌道離心率を取得
Definition GxSysEnvironment.h:661

OrbitalElements::getN
constexpr f64 getN(void) const
平均日々運動を取得
Definition GxSysEnvironment.h:665

OrbitalElements::getPosition
GX_FORCE_INLINE GxVector3 getPosition(void) const
座標を取得
Definition GxSysEnvironment.h:669

RenderMode
描画モードクラス
Definition GxSysEnvironment.h:161

RenderMode::RenderMode
RenderMode(void)
コンストラクタ
Definition GxSysEnvironment.cpp:354

RenderMode::setRenderMode
void setRenderMode(u32 mode)
描画モードを設定
Definition GxSysEnvironment.cpp:389

RenderMode::~RenderMode
~RenderMode(void) override
デストラクタ
Definition GxSysEnvironment.h:170

RenderMode::initialize
void initialize(void)
初期化
Definition GxSysEnvironment.cpp:362

SingletonBase
シングルトン基礎クラス
Definition GxSingleton.h:19

SingletonBase< GxSysGpgpu >::getSingletonPointer
static constexpr GxSysGpgpu * getSingletonPointer(void)
Definition GxSingleton.h:59

Utility
ユーティリティメソッド
Definition GxSysEnvironment.h:90

Utility::createMipmap
static void createMipmap(GxRenderTexture *pTexture)
ミップマップの生成
Definition GxSysEnvironment.cpp:103

Utility::setMaterialFunctions
static void setMaterialFunctions(GxResShaderPackage *pShaderPackage, GxShaderPackage::GxShaderCode *pShaderCode, const GxString &materialName, const GxString &materialFunctionName)
マテリアル関数を設定する
Definition GxSysEnvironment.cpp:204

Utility::createVertexBufferSphere
static GxRenderVertexBuffer * createVertexBufferSphere(s32 xdiv, s32 ydiv, s32 ycount)
スフィア頂点バッファの生成
Definition GxSysEnvironment.cpp:275

Utility::createVertexDeclarationSphere
static GxRenderVertexDeclaration * createVertexDeclarationSphere(void)
スフィア頂点定義の生成
Definition GxSysEnvironment.cpp:320

Utility::setTexture
static void setTexture(GX_HANDLE handle, GxRenderTexture *pTexture, RENDER_SAMPLER_FILTER min, RENDER_SAMPLER_FILTER mag, RENDER_SAMPLER_FILTER mip, RENDER_SAMPLER_ADDRESS_MODE addressU, RENDER_SAMPLER_ADDRESS_MODE addressV)
テクスチャの設定
Definition GxSysEnvironment.cpp:262

Utility::getFogParam
static GxVector4 getFogParam(f32 startDistance, f32 endDistance, f32 min, f32 max)
フォグパラメータの生成
Definition GxSysEnvironment.cpp:338

Utility::getMaterialFunctionIndex
static s32 getMaterialFunctionIndex(GxResShaderPackage *pShaderPackage, GX_HANDLE handleMaterialFunctions, const GxString &materialFunctionName)
マテリアル関数名からマテリアル関数番号を取得する
Definition GxSysEnvironment.cpp:182

Utility::setShaders
static b32 setShaders(GxResShaderPackage *pShaderPackage, GxShaderPackage::GxShaderCode *pShaderCode)
シェーダコードの設定
Definition GxSysEnvironment.cpp:216

Utility::setSamplerState
static void setSamplerState(GX_HANDLE handle, RENDER_SAMPLER_FILTER min, RENDER_SAMPLER_FILTER mag, RENDER_SAMPLER_FILTER mip, RENDER_SAMPLER_ADDRESS_MODE addressU, RENDER_SAMPLER_ADDRESS_MODE addressV)
サンプラの設定
Definition GxSysEnvironment.cpp:236

GxFloat2
2次元浮動小数点数クラス
Definition GxStruct.h:22

GxFloat3
3次元浮動小数点数クラス
Definition GxStruct.h:91

GxMatrixAffine
アフィン変換行列(行優先)
Definition GxMatrix.h:330

GxPlanetData::PlanetOribtalElements
惑星の軌道要素
Definition GxSysEnvironment.h:720

GxPlanetData::PlanetOribtalElements::_e
f64 _e
軌道離心率
Definition GxSysEnvironment.h:723

GxPlanetData::PlanetOribtalElements::_i
f64 _i
軌道傾角（度）
Definition GxSysEnvironment.h:725

GxPlanetData::PlanetOribtalElements::_omg_bar
f64 _omg_bar
近日点黄経（度）
Definition GxSysEnvironment.h:727

GxPlanetData::PlanetOribtalElements::_Re
f64 _Re
赤道半径(km)
Definition GxSysEnvironment.h:729

GxPlanetData::PlanetOribtalElements::_a
f64 _a
軌道長半径(AU)
Definition GxSysEnvironment.h:722

GxPlanetData::PlanetOribtalElements::_epoch
f64 _epoch
元期(JD)
Definition GxSysEnvironment.h:721

GxPlanetData::PlanetOribtalElements::_L
f64 _L
平均黄経（度）
Definition GxSysEnvironment.h:728

GxPlanetData::PlanetOribtalElements::_T
f64 _T
公転周期（年）...未使用
Definition GxSysEnvironment.h:724

GxPlanetData::PlanetOribtalElements::_node
f64 _node
昇交点黄経（度）
Definition GxSysEnvironment.h:726

GxShaderPackage::GxShaderCode
シェーダコード
Definition GxShaderPackage.h:52

GxString
文字列型クラス
Definition GxString.h:18

GxStructBase
Definition GxBase.h:24

GxVector2
2次元ベクトル
Definition GxVector.h:34

GxVector3
3次元ベクトル
Definition GxVector.h:245

GxVector3::_z
f32 _z
Z値
Definition GxVector.h:572

GxVector3::_y
f32 _y
Y値
Definition GxVector.h:571

GxVector3::_x
f32 _x
X値
Definition GxVector.h:570

GxVector4
4次元ベクトル
Definition GxVector.h:582

PerlinNoiseParam
パーリンノイズパラメータ構造体
Definition GxSysEnvironment.h:197

PerlinNoiseParam::_amplitude
f32 _amplitude
振幅
Definition GxSysEnvironment.h:236

PerlinNoiseParam::clamp
void clamp(void)
クランプ
Definition GxSysEnvironment.cpp:527

PerlinNoiseParam::_seed
u16 _seed
シード
Definition GxSysEnvironment.h:233

PerlinNoiseParam::_startOctave
s8 _startOctave
開始オクターブ
Definition GxSysEnvironment.h:234

PerlinNoiseParam::_persistence
f32 _persistence
永続性
Definition GxSysEnvironment.h:237

PerlinNoiseParam::_base
f32 _base
基準値
Definition GxSysEnvironment.h:238

PerlinNoiseParam::_endOctave
s8 _endOctave
終了オクターブ
Definition GxSysEnvironment.h:235

PerlinNoiseParam::PerlinNoiseParam
PerlinNoiseParam(s8 startOctave, s8 endOctave, f32 amplitude, f32 persistence, f32 base, u16 seed)
コンストラクタ
Definition GxSysEnvironment.h:215

Utility::VertexPositionTexture
頂点座標データ
Definition GxSysEnvironment.h:98

Utility::VertexPositionTexture::_position
GxFloat3 _position
座標
Definition GxSysEnvironment.h:99

Utility::VertexPositionTexture::_uv
GxFloat2 _uv
UV座標
Definition GxSysEnvironment.h:100

b32
32bitブーリアン
Definition GxDefine.h:173