surface_manager.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * Additional copyright for this file:
 * Copyright (C) 1999-2000 Revolution Software Ltd.
 * This code is based on source code created by Revolution Software,
 * used with permission.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef ICB_SURFACE_MANAGER
#define ICB_SURFACE_MANAGER
 
#include "engines/icb/p4_generic.h"
#include "engines/icb/common/px_array.h"
#include "engines/icb/common/px_types.h"
 
#include "graphics/surface.h"
 
namespace ICB {
 
#define SURFACE_MANAGER_LOG "surface_manager_log.txt"
 
// If this is passed in as an id to the Blit_surface_to_surface() the blit is performed to the backbuffer.
#define SURFACE_MANAGER_USE_BACKBUFFER 0xffffffff
 
#define EITHER 0x00000002 // Surface can be in vram or system
#define SYSTEM 0x00000000 // Surface is in system
#define VIDEO 0x00000001  // Surface must be in vram
 
extern uint32 effect_time; // Time spent doing postprocessing effects (fades etc)
extern uint32 working_buffer_id;
extern uint32 bg_buffer_id;
 
// Define this here so we can get rid of the <ddraw.h> include
#define DDBLT_KEYSRC 0x00008000l
 
class _surface {
public:
    Graphics::Surface *m_dds;
    pxString m_name; // The surface name
    uint32 m_width;  // The surface width
    uint32 m_height; // The surface height
    bool8 m_locked;  // Is the surface locked ?
    uint32 m_colorKey;
 
    _surface();
    ~_surface();
};
 
class _surface_manager {
 
private:
    Graphics::Surface *screenSurface;
    LRECT m_screen_rect; // The screen rectangle
public:
    rcAutoPtrArray<_surface> m_Surfaces; // List of client surface
private:
    bool8 m_hasMMX; // True if the processor has MMX capabilities
 
public:
    _surface_manager();
    ~_surface_manager();
 
    uint32 Init_direct_draw();
    void Flip();
    void Reset_Effects();
 
    /* Public Surface Functions */
    uint32 Create_new_surface(const char *name, uint32 width, uint32 height, uint32 type);
    void Kill_surface(uint32 s_id);
 
    uint8 *Lock_surface(uint32 s_id);
    void Unlock_surface(uint32 s_id);
 
    void PrintDebugLabel(const char *mess, uint32 c);
    void PrintTimer(char label, uint32 time, uint32 limit);
 
    int32 Get_pitch(uint32 s_id);
    inline uint32 Get_width(uint32 nSurfaceID) const;
    inline uint32 Get_height(uint32 nSurfaceID) const;
    inline uint32 Get_BytesPP(uint32 nSurfaceID) const;
    void Clear_surface(uint32 s_id) { Fill_surface(s_id, 0x00000000); }
    void Fill_surface(uint32 s_id, uint32 rgb_value);
    void Blit_fillfx(uint32 surface_id, LRECT *rect, uint32 col);
    void Blit_surface_to_surface(uint32 from_id, uint32 to_id, LRECT *rect_from, LRECT *rect_to, uint32 nFlags = 0);
    void Set_transparent_colour_key(uint32 nSurfaceID, uint32 nKey);
    bool8 &HasMMX() { return m_hasMMX; }
    void RecordFrame(const char *path);
    void Unlock_all_surfaces();
 
public:
    void DrawEffects(uint32 surface_id);
 
    LRECT &BorderRect() {
        return m_borders; // Access to the border rect
    }
    uint8 &BorderRed() {
        return m_borderRed; // Access to the border colour
    }
    uint8 &BorderGreen() {
        return m_borderGreen; // Access to the border colour
    }
    uint8 &BorderBlue() {
        return m_borderBlue; // Access to the border colour
    }
    uint8 &BorderAlpha() {
        return m_borderAlpha; // Access to the border colour
    }
    uint32 &BorderMode() { return m_borderMode; }
 
    void LoadGFXInfo(Common::SeekableReadStream *stream);
    void SaveGFXInfo(Common::WriteStream *stream);
 
private:
    LRECT m_borders;     // The border to add to the screen
    uint8 m_borderRed;   // The colour of the border
    uint8 m_borderGreen; // The colour of the border
    uint8 m_borderBlue;  // The colour of the border
    uint8 m_borderAlpha; // The colour of the border
    uint32 m_borderMode;
 
public: /* FADE */
    uint32 &FadeMode() {
        return m_fadeMode; // Access to the fade mode
    }
    uint8 &FadeToRed() {
        return m_fadeToRed; // Access to the red fade component
    }
    uint8 &FadeToGreen() {
        return m_fadeToGreen; // Access to the red fade component
    }
    uint8 &FadeToBlue() {
        return m_fadeToBlue; // Access to the red fade component
    }
    uint8 &FadeFromRed() {
        return m_fadeFromRed; // Access to the red fade component
    }
    uint8 &FadeFromGreen() {
        return m_fadeFromGreen; // Access to the red fade component
    }
    uint8 &FadeFromBlue() {
        return m_fadeFromBlue; // Access to the red fade component
    }
    uint8 &FadeAlpha() {
        return m_fadeAlpha; // Access to the red fade component
    }
 
private:
    uint32 m_fadeMode;     // The type of fade (additive / subtractive / alpha )
    uint8 m_fadeToRed;     // The red component to fade to
    uint8 m_fadeToGreen;   // The green component to fade to
    uint8 m_fadeToBlue;    // The blue component to fade to
    uint8 m_fadeFromRed;   // The red component to fade from
    uint8 m_fadeFromGreen; // The green component to fade from
    uint8 m_fadeFromBlue;  // The blue component to fade from
    uint8 m_fadeAlpha;     // The alpha component of the fade
 
private: /* Private Helper Functions */
    /* Let the MouseDraw function get at the back buffer */
    friend int32 DrawMouse();
 
private:
    _surface_manager(const _surface_manager &) { ; }
    void operator=(const _surface_manager &) { ; }
};
 
inline uint32 _surface_manager::Get_width(uint32 nSurfaceID) const {
    assert(nSurfaceID < m_Surfaces.GetNoItems());
 
    return (m_Surfaces[nSurfaceID]->m_width);
}
 
inline uint32 _surface_manager::Get_height(uint32 nSurfaceID) const {
    assert(nSurfaceID < m_Surfaces.GetNoItems());
 
    return (m_Surfaces[nSurfaceID]->m_height);
}
 
inline uint32 _surface_manager::Get_BytesPP(uint32 nSurfaceID) const {
    assert(nSurfaceID < m_Surfaces.GetNoItems());
 
    return ((m_Surfaces[nSurfaceID]->m_dds->format.bytesPerPixel));
}
 
} // End of namespace ICB
 
#endif