MercuryDisplaySoftwareC.h

Go to the documentation of this file.

#ifndef _MERCURY_DISPLAY_SOFTWARE_C
#define _MERCURY_DISPLAY_SOFTWARE_C

#include "MercuryWindow.h"

#if defined (WIN32)
#include "Win32Window.h"
#endif

#include "MercuryDisplay.h"

class MercuryDisplaySoftwareC : public MercuryDisplay
{
public:
    MercuryDisplaySoftwareC();
    virtual bool BeginFrame() { return true; } //unessiary
    virtual bool EndFrame();// { return true; } //unessiary
//  virtual void Init();
    virtual bool MakeWindow(const char* title, int width, int height, int bits, bool fullscreenflag);
    virtual void RendererInfo() { } //unessiary

    virtual void DrawParticleField(const MercuryParticleField* field) { } //disabled
    virtual void DrawMesh(const MercuryMesh& mesh);
    virtual void DrawMeshVBO(const MercuryMesh& mesh) {};
    virtual void DrawSprite(const MercuryMesh& sprite) {};
    virtual void GenerateVBO(MercuryMesh& mesh) {};
    virtual void DestroyVBO(MercuryMesh& mesh) {};

    virtual void SetMaterial(const MercuryMaterial* material);
    virtual void ClearZBuffer();
    virtual void ClearFrameBuffer(){};
    virtual void BeginRenderToDynamicTexture (MercuryTexture* texture){};
    virtual void EndRenderToDynamicTexture (){};
    virtual void BeginRenderToDynamicCubeTexture (MercuryTexture *texture, unsigned int face){};
    virtual void EndRenderToDynamicCubeTexture   (){};


    virtual void DeleteTextures(int n, unsigned int* textureNames);
    virtual void UpdateTextureData(MercuryTexture* texture, unsigned int& ID);
    virtual void CreateCache(MercuryTexture* texture, unsigned int& ID);
    virtual void CreateCache(RawImageData* data, unsigned int& ID);

    virtual void EnablePixelshader () { } //disabled
    virtual void DisablePixelshader () { } //disabled

    virtual void EnableAllLighting() { } //disabled
    virtual void DisableAllLighting() { } //disabled

    virtual void EnableDepthTest() { bDepthTest = true; }
    virtual void DisableDepthTest() { bDepthTest = false; }

    virtual void EnableTextures(MercuryMaterial* material);
    virtual void ToggleTextureUse(bool toggle) {};
    virtual void EnableShaders(MercuryMaterial* material) {}

    virtual void ErrorCheck() { } //unesssiary
    virtual void EnableLights() { } //disabled
    virtual void ProcessStaticLights() { } //disabled
    virtual void DisableLights() { } //disabled
    virtual void ReadFrameBuffer(RawImageData& image);

    virtual void SendMatrixData(const MercuryMatrix& m);
    virtual void SendProjectionMatrixData() {};

    virtual void ToggleZBufferWrite(bool toggle) { m_zBufferWrite = toggle; };
    virtual void ToggleColorMask(bool toggle) {};
    virtual void ToggleStencilBufferWrite(bool toggle) {};
    virtual void StencilOp(STENCILOPS fail, STENCILOPS zfail, STENCILOPS zpass) {};
    virtual void CullBackface(bool toggle) {};
    virtual void StencilFunc(TFUNCT func, int ref, unsigned int zref) {};

    virtual void DisableOldLights() {};

    virtual void RenderTranslucentObject() {};
    virtual void DefineClippingPlanes(const MVector<MQuaternion>& planes) {};

    virtual void RenderText(const MercuryText& text) {};
protected:

    struct InternalTexture
    {
        bool m_isInUse;
        bool m_isMaterial;
        int m_width;
        int m_height;
        unsigned char * m_data;
        ColorBytes m_type;
        MercuryMatrix m_TexMat;
    };

    MVector< InternalTexture > m_InternalTextures;
    InternalTexture * m_pCurTexture;
    const MercuryTexture* m_pCurMercuryTexture;
    MercuryMaterial m_pCurMaterial;


    //Internal drawing
    struct InternalPoint
    {
        float x,y,z,w;
        float u,v;
    };

    MercuryMatrix mFinal;

    virtual void InternalPipelinePoint( const MercuryPoint &pIn, InternalPoint &pOut );
    virtual void InternalDrawPoly( const InternalPoint * points, int verts = 3, int mode = 0 );

    bool bDepthTest;
    static int m_width;
    static int m_height;
    static int m_bypp;
    static bool m_zBufferWrite;
    static unsigned char * m_cBuffer;
    static unsigned int * m_zBuffer;

private:
    virtual void ProcessLightsInternal( const MercuryLight* light[3], unsigned int index ) {};
};

#endif

/* 
 * Copyright (c) 2006, Charles Lohr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *  -   Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following disclaimer.
 *  -   Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *  -   Neither the name of the Mercury Engine nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

---

Hosted by