VedaMachineDreamcast/VedaMachineDreamcast.h

Go to the documentation of this file.

/*! \file 
    \author victorien ferry & www.m4nkind.com
    \brief This file applies the GNU LESSER GENERAL PUBLIC LICENSE Version 2.1 , read file COPYING.
*/
#ifndef COM_M4NKIND_VedaMachineDreamcast_H
#define COM_M4NKIND_VedaMachineDreamcast_H

#include "VirtualMachine.h"
#include "kos.h"
#include "MatrixModel.h"

//#define PRINTDEBUG         1

/*!
    \class  VedaMachineDreamcast
    \ingroup    VirtualMachineDocGroup
    \brief  Defines a \mainprojectname Machine targeted for the Sega
            Dreamcast hardware, using the free Developpement kit Kallistios,
            and other things. For the moment, the renderer is partly based on KGL.
*/

class VedaMachineDreamcast : public VirtualMachine
{
/*==================================================================
                                PUBLIC
==================================================================*/
public:
    /*!
        \brief  Constructor. 
    */
    VedaMachineDreamcast(void);
    /*!
        \brief  Destructor.
    */
    virtual ~VedaMachineDreamcast(void);
    class DCInternalTexture;
    class DCInternalObject3DBuffer;

    static void RenderMesh_SetglCullFaceDepthTestAndMask(unsigned int _renderflag);
    static void RenderMesh_Setgl2DBilinearAndClamp(unsigned int _renderflag);
    static void RenderMesh_SetGlColorToObjectAndTexture(float rgba[4],
            DCInternalObject3DBuffer *_pMeshBuffer,DCInternalTexture *_pOGLTexture);
    //! tool method used by pass1(opque) and 2(transp.). drawn after flags&matrix are set.
    static void RenderMesh_Draw3D_Flat( DCInternalObject3DBuffer *pbuffer);
    static void RenderMesh_Draw3D_FlatColor4( DCInternalObject3DBuffer *pbuffer);
    static void RenderMesh_Draw3D_Bitmap( DCInternalObject3DBuffer *pbuffer);
    static void RenderMesh_Draw3D_BitmapColor4( DCInternalObject3DBuffer *pbuffer);
    static void RenderMesh_Draw3D_Environment( DCInternalObject3DBuffer *pbuffer, matrix_t *pMatrix);
    static void RenderMesh_Draw3D_EnvironmentColor4( DCInternalObject3DBuffer *pbuffer, matrix_t *pMatrix);

    /*!
        \class  InternalViewPort
        \brief nested class that defines a viewport where to draw (screen, sub-screen,texture rendering screens.)
            It must be extented to other classes.
    */
    class   DCInternalViewPort : public InternalViewPort
    {   public:
        /*!
            \brief  Constructor. 
            \param  _pFather the father, or NULL if new root.
        */
        DCInternalViewPort(DCInternalViewPort *_pFather);
#ifdef _ENGINE_EDITABLE_
        /*!
            \brief  Destructor. See DeleteViewport() 
        */
        virtual ~DCInternalViewPort();
#endif
        /*!
            \brief  Reset color to black (or given color),and depth buffer, of this ViewPort.
            \param  _red [0.0,1.0]
            \param  _green [0.0,1.0]
            \param  _blue [0.0,1.0]
        */
        virtual void    Clear( float _red=0.0f,float _green=0.0f,float _blue=0.0f);
        /*!
            \brief  Render a 3D Object. The vertexes are transformed with matrix _pMatrix,
                    the object shape is defined by _pMeshBuffer, the texture of the object is
                    defined by _pTexture, the ViewPort that define the rectangle where to draw,
                    and the camera parameters is _pViewPort, or the default viewport if not specified.  
                    Note drawings on the main screen needs a SwapScreenBuffer() to be shown at each frames.
            \param  _pMatrix Internal3DMatrixStack
            \param  _pMeshBuffer InternalObject3DBuffer
            \param  _pTexture InternalTexture or nothing, will draw shades.
        */
        virtual void    RenderMesh( InternalObject3DBuffer *_pMeshBuffer,
                                    InternalTexture *_pTexture=0L
                                    ) ;
        /*!
            \brief  Render directly a 32bit pixel bitmap image from memory on a viewport.
                    Note drawings on the main screen needs a SwapScreenBuffer() to be shown at each frames.
            \param  _prgbaTable pointer to the beginning of a 32bit RGBA table.
            \param  _PixelWidth number of pixel of a line
            \param  _PixelHeight number of pixel lines.
        */
        virtual void    DrawRGBARectangle( 
                                            unsigned char   *_prgbaTable,
                                            unsigned int    _PixelWidth,
                                            unsigned int    _PixelHeight
                                            ) ;
        /*!
            \brief  Swap buffer so that what was drawn on the viewport is shown.
                    this is needed to active all Clear(), RenderMesh() ,...
                    It has to be done with main screen viewport like texture-rendering
                    viewports.
        */
        virtual void    SwapBuffer();
        /*
            \brief  Change the coodinates of the clipping borders of a ViewPort,
                    in the origin of its father.default is 0.0,0.0,1.0,1.0
                    If the ViewPort is a Root ViewPort, like the main screen,
                    or a texture rendering, it is inactive.
            \param  _ClippingX1 upperleft corner in [0,1] scale for visible bounds.
            \param  _ClippingY1 upperleft corner in [0,1] scale for visible bounds.
            \param  _ClippingX2 downright corner in [0,1] scale for visible bounds.
            \param  _ClippingY2 downright corner in [0,1] scale for visible bounds.
        */
        virtual void SetClippingCoordinates(float _ClippingX1,float _ClippingY1,float _ClippingX2,float _ClippingY2 );
        /*
            \brief  Change the coodinates of the draw scale of a ViewPort, in the origin 
                    of its father. default is 0.0,0.0,1.0,1.0
                    If the ViewPort is a Root ViewPort, like the main screen,
                    or a texture rendering, it is inactive.
            \param  _ScaleX1 upperleft corner in [0,1] scale for aspect ratio .
            \param  _ScaleY1 upperleft corner in [0,1] scale for aspect ratio .
            \param  _ScaleX2 downright corner in [0,1] scale for aspect ratio .
            \param  _ScaleY2 downright corner in [0,1] scale for aspect ratio .
        */
        virtual void SetScaleCoordinates(float _ScaleX1,float _ScaleY1,float _ScaleX2,float _ScaleY2 );

        /*!
            \brief  Change the root viewport pixel resolution.This is a low level call in case of resize or screen init.        
            \param  _pixelWidth 
            \param  _pixelHeight
        */  
        void    ResetRootPixelSize( unsigned int _pixelWidth,unsigned int _pixelHeight );
        /*!
            \brief  get the rectangle pixel coordinates in the root viewport bitmap.
            \return pixel
        */  
        inline  int GetPixelX1(){ return m_pixel_x1; };
        /*!
            \brief  get the rectangle pixel coordinates in the root viewport bitmap.
            \return pixel
        */  
        inline  int GetPixelY1(){ return m_pixel_y1; };
        /*!
            \brief  get the rectangle pixel coordinates in the root viewport bitmap.
            \return pixel
        */  
        inline  int GetPixelX2(){ return m_pixel_x2; };
        /*!
            \brief  get the rectangle pixel coordinates in the root viewport bitmap.
            \return pixel
        */  
        inline  int GetPixelY2(){ return m_pixel_y2; };
        //! for 3D rendering, Distance between the projected plane and the center. must be >0.001
        inline float GetFov() { return m_fov;  };   
        //! 
        inline float GetNearCutPlane() { return m_NearCutPlane;  }; 
        //! 
        inline float GetFarCutPlane() { return m_FarCutPlane;  };   

        //! 2d Scale coordinates of the rectangle recomputed in the Root ViewPort scale.
        float m_ScaleRootX1;    
        float m_ScaleRootY1;
        float m_ScaleRootX2;
        float m_ScaleRootY2;

        //! 2d coordinates of the rectangle recomputed in the Root ViewPort scale.
        float m_ClippingRootX1; 
        float m_ClippingRootY1;
        float m_ClippingRootX2;
        float m_ClippingRootY2;

        //! real clipped frustrum
        float   m_FinalClipFrustrumX1;
        float   m_FinalClipFrustrumY1;
        float   m_FinalClipFrustrumX2;
        float   m_FinalClipFrustrumY2;

        //! in case of texture rendering, otherwise 0L:
        DCInternalTexture   *m_pRenderTexture;
        //! for texture rendering, we manage the PVR mem:
        pvr_ptr_t   m_pvrmem;
        //! OGL texture:
        int                 m_RenderTextureOGLHandle;

        /*!
            \brief  Tool for other methods: Set the current GL viewport matrix to an InternalViewPort.
        */
        //virtual   void    SetGLToViewPort();
        /*
            \brief Matrix_
        */
        virtual void    Matrix_LoadID(eLoadId _enum=eLoadId_All);
        virtual void    Matrix_Translate(float _x,float _y,float _z);
        virtual void    Matrix_Rotate( float _angle,float _x,float _y,float _z);
        virtual void    Matrix_Scale(float _sx,float _sy,float _sz);
        virtual void    Matrix_Push();
        virtual void    Matrix_Pop();
        VedaMachineDreamcast    *m_pMachine;


    protected:
        //! if false, can't be drawn, because invalid coordinates.
        bool    m_Valid;
        //! the rectangle coordinates in term of screen pixel. 
        int     m_pixel_x1; 
        //! the rectangle coordinates in term of screen pixel. 
        int     m_pixel_y1;
        //! the rectangle coordinates in term of screen pixel. 
        int     m_pixel_x2;
        //! the rectangle coordinates in term of screen pixel. 
        int     m_pixel_y2;
        //! we manage a 3D transformation matrix
        MatrixModel m_Matrix;

        /*
            \brief  Change the coodinates of the ViewPort pixels, in its root origin.
                    Used by SetCoordinates(). Non-Virtual. Reset the hierarchy down.
        */
        void    ResetPixelCoordinates();

        //! the pointer where this viewport was attached in the clipping hierarchy, father or brother. 
        //! Used to destroy the object. Use ClippingHierarchy_AttachTo to change it.
        InternalViewPort    **m_ppClippingHierarchyAttached;
#ifdef _ENGINE_EDITABLE_
        /*
            \brief  tool: invalidate down the viewport hierachy when a viewport is destroyed.
        */
        void    ClippingDetach();
#endif

    };

    /*! 
        \class  DCInternalObject3DBuffer
        \brief  Nested class that implements a 3D object as a vertex and a polygon list.
                You ask the creation of it with VirtualMachine::NewObject3DBuffer(),
                then defines its shape by filling the list you get with GetFirstVertex()
                and GetFirstTriangle(), then it can be rendered with VirtualMachine::RenderMesh().
                In order to optimize a static shape, use VirtualMachine::CompileObject3DBufferAsStatic()
                In edition mode, it can be destroyed with VirtualMachine::DeleteObject3DBuffer().
    */
    class   DCInternalObject3DBuffer : public InternalObject3DBuffer
    { public:
        /*!
            \brief  A call to CompileObject3DBufferAsStatic() will fix the current geometry of an object.
                    It will try to use the 3D buffer compilation of a given machine, which can fasten the drawing.
                    From that moment on, further modification to its shape will be useless.
        */
        virtual void    CompileAsStatic( );
        /*!
            \brief  return true is CompileAsStatic() were used.
            \return  true is CompileAsStatic() were used, false if still dynamic.
        */
        virtual bool    IsCompiledAsStatic();
        /*!
            \brief  Get the beginning of the vertex list. Assume the maximum number of vertex 
                    was given by NewObject3DBuffer() and can be read with GetMaximumNumberOfVertexes().
            \return a pointer to the first Vertex.
        */
        virtual InternalVertex   *GetFirstVertex();
        /*!
            \brief  Get the beginning of the Triangle list. Assume the maximum number of Triangle 
                    was given by NewObject3DBuffer() and can be read with GetMaximumNumberOfTriangles().
                    last Note: the first triangle returned  already use the offset given with SetNumberOfActiveTriangle(): _FirstActiveTriangleIndex.
            \return a pointer to the first Vertex.
        */
        virtual InternalTriangle *GetFirstTriangle();
        /*!
            \brief  Set the number of active triangle defined in the triangle list.
                    note the active number of vertex is actually given by the highest vertex
                    number used by one of the active triangle. If _CurrentNumberOfTriangle is
                    greater than GetMaximumNumberOfTriangles(), it is set to zero.
                    _FirstActiveTriangleIndex is an optional offset in the triangle list.
                    it allows the rendering of a mesh with multiple textures, by 
                    setting a windowing in the triangle list and using
                    multiple calls to RenderMesh(). Default is zero, start of the list.
            \param _CurrentNumberOfTriangle the new number of triangle in the object.
            \param _FirstActiveTriangleIndex optional active triangle offset in list.
        */
        virtual void    SetNumberOfActiveTriangle( unsigned int _CurrentNumberOfTriangle,unsigned int _FirstActiveTriangleIndex=0 );

        /*!
            \brief  Get the number of active triangle defined by SetNumberOfActiveTriangle().
            \return the number of triangle in the object.
        */
        virtual unsigned int GetNumberOfActiveTriangle();       
        /*!
            \brief  the maximum number of elements in table GetFirstVertex()
            \return  the maximum number of elements in table GetFirstVertex() 
        */
        virtual unsigned int    GetMaximumNumberOfVertexes();
        /*!
            \brief  the maximum number of elements in table GetFirstTriangle()
            \return  the maximum number of elements in table GetFirstTriangle() 
        */
        virtual unsigned int    GetMaximumNumberOfTriangles();
        /*!
            \brief   Set the color for the whole object. Active if object was not created with bOb3D_EnableRGB or bOb3D_EnableAlpha.
            \param  _red    color component
            \param  _green  color component
            \param  _blue   color component
            \param  _alpha  color component
        */
        virtual void    SetColor(float _red,float _green,float _blue,float _alpha=1.0f);

        //! real implementation of the vertex base.
        InternalVertex      *m_pVertexBase;
        //! real implementation of the triangle base.
        InternalTriangle    *m_pTriangleBase;
        //! First Active Triangle Index
        unsigned int    m_FirstActiveTriangleIndex;
        //! current number of active triangle set by SetNumberOfActiveTriangle()
        unsigned int        m_NumberOfActiveTriangles;
        //! If !=0, It is an OpenGL compiled process: 
        unsigned int        m_CompiledObjectHandler;
        //! the maximum number of vertex, and the size of the vertex list returned by GetFirstVertex().
        unsigned int    m_MaximumNumberOfVertexes;
        //! the maximum number of Triangles, and the size of the triangle list returned by GetFirstTriangle().
        unsigned int    m_MaximumNumberOfTriangles;
        //! tells which vertex members are enabled; use VirtualMachine::bOB3d_xxx
        unsigned int    m_ExtraMemberFlags;
        //! main color of the object(RGBA, [0.0,1.0]): (note:there is also vertex colors) 
        float           m_Color[4];
        //! DC special: environment mapping computation. nb=m_MaximumNumberOfVertexes*2
        float           *m_pVertexEnvironmentUV;
    };
    /*!
        \class  DCInternalTexture
                Nested Class that defines a texture to render an object with VirtualMachine::RenderMesh().
    */
    class   DCInternalTexture : public InternalTexture
    { public:
        /*!
            \brief  Constructor
        */
        DCInternalTexture(void);
        /*!
            \brief  Set or change the render flags for a texture.
            \param  _flags or'ed bit flags ( itf_... flags)
        */
        virtual void    SetRenderFlags( unsigned int _flags );
        /*!
            \brief  Set base color, default to 1.0f,1.0f,1.0f,1.0f
            \param  _rgba Red Green Blue and Alpha transparency components. 
        */
        virtual void    SetBaseColor( float _rgba[4] );     
        /*!
            \brief  Get the render flags for a texture.
            \return  or'ed bit flags (InternalTextureFlagBitsEnum)
        */
        virtual unsigned int GetRenderFlags( );     
        /*!
            \brief  set an image layer for a texture. see layers with itile_... enums.
            \param  _layerToSet the enum that define which layer to change.
            \param  _pByteChunk     pointer to a byte chunk 
            \param  _pixelByteDepth number of bytes per pixel in _pByteChunk.
            \param  _pixelWidth     the number of pixel in a row
            \param  _pixelHeight
        */
        virtual void    SetImageBitmap( TextureImageLayerEnum _layerToSet,
                                const unsigned char *_pByteChunk,
                                unsigned int _pixelByteDepth,
                                unsigned int _pixelWidth,
                                unsigned int _pixelHeight
                                );
        static const int    m_MaxNumberOfLayer=2;
        //! \class Layer
        //! `\brief nested class for private use.
        class Layer { public:
            unsigned int    m_OGLTextureHandler;
            unsigned int    m_BitmapPixelWidth;
            unsigned int    m_BitmapPixelHeight;
            //! video mem:
            pvr_ptr_t       m_txaddr;
        };
        //! OGL texture handlers: simple map+env.
        Layer       m_Layer[m_MaxNumberOfLayer];
        //! OGL texture handlers: simple map+env.
        //unsigned int  m_OGLTextureHandler[2];
        //! current flags set
        unsigned int    m_flags;
        //! the base color, which is modulated on mapping layer.
        float       m_BaseColorRGBA[4];     
        //! tell which layer is active:
        unsigned int    m_ActiveLayerFlag;
        //! true if ARGBA were used as pixel format (then the mesh will be declared translucent)
        bool        m_BitmapImageUseAlpha;
        //! in case of render to texture with render extension:
        //int m_frameBuffer;
        //! in case of render to texture with render extension:
        //int m_depthRenderBuffer;
    };
    
    /*!
        \brief  Init the machine. It would open a screen and do the init for each theme (3D,sound,...)
                the machine closing should be done at deletion.
        \return vmr_OK or vmr_FAILED
    */
    virtual eVMResult   InitMachine();
    /*!
        \brief  Ask the Creation of a new InternalObject3DBuffer you can then fill with 
                    InternalObject3DBuffer::GetFirstVertex() , InternalObject3DBuffer::GetFirstTriangle()
                    and InternalObject3DBuffer::SetNumberOfActiveTriangle() .
                    Then the object can be positionned with the matrix methods, and drawn with RenderMesh()
                    The object shape can be dynamic and rebuilt, until a call to CompileObject3DBufferAsStatic().
                    In edition mode, object has to be destroyed with DeleteObject3DBuffer().
        \param  _ppVertexAndPolygonBufferOut    the object returned, or 0L if failed.(no mem ?)
        \param  _maxNbVertex                    maximum number of vertex to fill.
        \param  _maxNbTriangle                  maximum number of Triangle to fill.
        \param  _extraMemberFlags               or'ed bits (bOb3D_...) to activate extra vertex members.
    */
    virtual void    NewObject3DBuffer(  InternalObject3DBuffer **_ppVertexAndPolygonBufferOut, 
                            unsigned int _maxNbVertex,
                            unsigned int _maxNbTriangle, 
                            unsigned int _extraMemberFlags );

    /*
        \brief      Destroy objects previously created with NewObject3DBuffer()
        \param      _ppBufferToDestroy object to destroy, and set to 0L.
    */
    virtual void    DeleteObject3DBuffer(  InternalObject3DBuffer **_ppBufferToDestroy );

    /*!
        \brief  Ask the Creation of a new InternalTexture, then used to render 3D objects with RenderMesh().
                In edition mode, InternalTexture has to be destroyed with DeleteTexture().
        \param  _ppTextureOut   the object returned, or 0L if failed.(no mem ?)
    */
    virtual void    NewTexture(  InternalTexture **_ppTextureOut  );
#ifdef _ENGINE_EDITABLE_
    /*!
        \brief  Destroy objects previously created with NewTexture()
        \param  _ppTextureToDestroy  object to destroy, and set to 0L.
    */
    virtual void    DeleteTexture(  InternalTexture **_ppTextureToDestroy );
#endif

    /*!
        \brief  Ask the Creation of a new InternalViewPort, that must be the child of another ViewPort,
                specified by _pFatherViewPort.if no father is specified, the new ViewPort will be
                the child of the default root ViewPort. To create another Root ViewPort, create a texture
                and use VirtualMedia::NewViewPortOnTexture().
                In edition mode, each InternalViewPort has to be destroyed with DeleteViewPort().
        \param  _ppViewPortOut  the object returned, or 0L if failed.(no mem ?)
        \param  _pFatherViewPort the father viewport. If 0L, it uses the default root.
    */
    virtual void    NewViewPortChild(  InternalViewPort **_ppViewPortOut,InternalViewPort *_pFatherViewPort=0L);
    /*!
        \brief  Ask the Creation of a new Root InternalViewPort, that will render on a texture image.
                specified by _pRootTexture. You got to create a texture first for parameter _pRootTexture.
                In edition mode, each InternalViewPort has to be destroyed with DeleteViewPort().
        \param  _ppViewPortOut  the object returned, or 0L if failed.(no mem ?)
        \param  _pRootTexture an InternalTexture. Can't be null.
        \param  _np2PixelWidth  integer which can be 1,2,4,8,16,32,64,128,256,512 that stand for the square of the pixel width.
        \param  _np2PixelHeight integer which can be 1,2,4,8,16,32,64,128,256,512 that stand for the square of the pixel height.
        \param  _layerToAffect  the texture layer (simple mapping, environment) where  to render.
    */
    virtual void    NewViewPortOnTexture(  InternalViewPort **_ppViewPortOut,
                                            InternalTexture *_pRootTexture,
                                            unsigned int _np2PixelWidth,
                                            unsigned int _np2PixelHeight,
                                            InternalTexture::TextureImageLayerEnum _layerToAffect);


    /*!
        \brief  Destroy any objects previously created with NewViewPortChild() or NewViewPortOnTexture().
        \param  _ppViewPortToDestroy     pointer to object to destroy, and set to 0L.
    */
    virtual void    DeleteViewPort(  InternalViewPort **_ppViewPortToDestroy );

    /*!
        \brief  Swap buffer so that what was drawn on the main screen is shown.
    */
    virtual void    SwapScreenBuffer();
    /*!
        \brief  Return the machine main play frequency, in herz, (tick per sec).
        \return freq (44100.0,22050.0,...)
    */
    virtual float   GetPlayFrequency();
    /*!
        \brief  force a date to the clock passed to the sound objects.  
        \param  _seconds    in second units.
        \param  _fraction   the following after-the-point-units of _seconds, like if the whole were a 64 bits integer.
    */
    virtual void    SetSoundCurrentTime(int _seconds,unsigned int _fraction );
    /*!
        \brief  tool: change main volume [0,1].
                Yes, you can saturate when >1.
        \param  _newVolumeValue [0,1]
    */
    virtual void    SetSoundVolume(float _newVolumeValue);  
    /*!
        \brief  tool: get main volume value [0,1].
        \return VolumeValue [0,1]
    */
    virtual float   GetSoundVolume();   
    /*!
        \brief  For Information, an image of the current sound buffer.
                This is always a 2 float(left,right) table: 
                The buffer size may vary. It can be used by preview methods or
                live effects.
        \param  _ppSoundBuffer  pointer on pointer on the buffer to return.
        \param  _pLength    pointer on a unsigned int that return the length.
    */
    virtual void    GetCurrentSoundBufferImage(float ** const _ppSoundBuffer,unsigned int *_pLength) const ;
    /*!
        \brief  Return the language of the machine, as a simple enum. It can be used
            to display one or the other langage.
        \return an enum integer.
    */
    virtual eMachineLocalization    GetCurrentWorldLocalizationEnum();

    /*!
        \brief  Process the Machine's interface messages (mouse,keyboard,...), in the real time.
                Then methods like VirtualMachine::GetQuitMessage() are updated.
    */
    virtual void    ProcessInterface();



    float   GetCurrentTime( );

    void    SetCurrentTime( float _timeSec );

    /*!
        \brief  Process the Machine's interface messages (mouse,keyboard,...), in the real time.
                Then methods like VirtualMachine::GetQuitMessage() are updated.
    */
    inline void SetRate( float _rate){ m_timerate = _rate ; };

/*
    void printtest(){ 
    printf("nbtranslu:%d\n",m_NumberOfTranslucentObjects);};
*/
/*==================================================================
                                PROTECTED
==================================================================*/
protected:

    
    //! link the machine to a static machine list, because sound mixing is static for more than one machine:
    static  VedaMachineDreamcast    *m_pFirstMachine;
    VedaMachineDreamcast            *m_pNextMachine;
    // -----------------------------------
    //! 1st pad:
    unsigned int m_FirstController;
    //!
    unsigned int    m_MachineLocalization;
    //!
    unsigned int m_PixelWidth;
    //!
    unsigned int m_PixelHeight;
    //!
    VedaMachineDreamcast::DCInternalViewPort    *m_pCurrentActiveViewport;
    //!
    void    SetCurrentActiveViewport(DCInternalViewPort *_pViewport);
    // -------------------------------------------  
    //! sound mix rate: 22050,44100 , ...
    static unsigned int m_MixRate;
    //! float version:
    static float m_fPlayFrequency;
    //! 1/m_fPlayFrequency
    //float         m_1OverMixRate;
    //! sound stuff
    unsigned int    m_TotalPlaySize;
    //!
    int         m_LastStartPlayTime_SecondUnit;
    //!
    unsigned int    m_LastStartPlayTime_SecondFrac;
    //! synchronize more.
    //unsigned int  m_TimeShift;
    //!
    bool InitSound();
    //!
    void ExitSound();
    //! 
    static  void    *StreamCallBack(int _p1, int *_pp2);

    static void SoundServer_thread(void *p);
    //! 32768
    static const unsigned int m_SoundBufferLength=4096;
    static const unsigned int m_NumberOfBuf=16; // 2^n
    static short *m_pShortSoundBuffer;
    // we alloc a larger sound buffer to 
    static float *m_pFloatSoundBufferAlloc;
    static unsigned int m_SoundBufferIndex;

    //static float *m_pFloatSoundBuffer2;
    static unsigned int m_LastSoundBufferLength[m_NumberOfBuf];

    static volatile bool m_SoundThreadGotToQuit;
    static volatile bool m_SoundThreadIsOn;
    unsigned int m_CurrentPolyListIndex; // KOS poly list system current index.

    //! translucent mesh list, for pass 2 rendering for kgl. cf SwapScreenBuffer()
    static const unsigned int   m_TranslucentListMaximumDepth=240;
    //! the real alloc for m_pTranslucentMatrixList, because it must be 32b aligned.
    unsigned char   *m_pAllocChunkForTranslucentList;

    //! \struct _translucentMeshToRender MUST BE 32b aligned !!!
    typedef struct _translucentMeshToRender
    { public:
        // sizeof:64
        matrix_t                    m_matrix;
        // sizeof 4
        DCInternalObject3DBuffer    *m_pObject;
        // 4
        unsigned int                m_GLTextureHandler;
        //! 4
        unsigned int                m_renderFlags; 
        //! 4
        unsigned int                m_IsEnvironment;
        //! 16b. color and alpha, may be transparent:
        float                       m_rgba[4];
        float                   m_fov;
        float                   m_near;
        float                   m_far;
        float                   m_dummy[5];
    } translucentMeshToRender ; // sizeof: 32+64=96
    //!
    translucentMeshToRender *m_pTranslucentMeshList;
    //!
    unsigned int    m_NumberOfTranslucentObjects;

    unsigned int        m_LastProcessInterfaceClock;
    //! last 
    unsigned int        m_lastButtonCondition;
    //! 
    unsigned int        m_interfaceStateBits;
    unsigned int        m_ChoicePannelIndex;
    float           m_QuitChoicePanelAlpha;
    float           m_TimePanelAlpha;
    float           m_timerate;
    //!
    float       m_StartTime;
    //!
    float       m_TimeSpeed;
    int m_ClockStart;

    static const unsigned int m_bs_QuitChoicePanelIsOn=1;
};


#endif

---

      /\/\        4         N         k         !         N         D
                      _______  _ __ ___  _____            ___ _ _  ____
     ___________  __//___   /________  |/    / ___________\_______/    \
    /   _   _   \/   _     /    _   /      _/_/____/    _       __     /
   /    /   /       /     /    /    \      \/     /    /    \   \     /
  \\___/___/___/    ¯    _____/_____/       ______\___/_____/\________\\
               \________/_ ___ __ l____\      /elD!  
                 http://www.m4nkind.com \____/