mirror of
https://github.com/izzy2lost/Super3.git
synced 2026-03-26 16:58:30 -07:00
izzy2lost
a281cb2422
Timing toggle set to NEW can fix some games like eca export, and USA. Fix flickering in sega rally 2. Breaks some other games. Default set to legacy. Quick options menu via back button press.
272 lines
8.5 KiB
C++
272 lines
8.5 KiB
C++
/**
|
|
** Supermodel
|
|
** A Sega Model 3 Arcade Emulator.
|
|
** Copyright 2011-2012 Bart Trzynadlowski, Nik Henson
|
|
**
|
|
** This file is part of Supermodel.
|
|
**
|
|
** Supermodel 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.
|
|
**
|
|
** Supermodel 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 Supermodel. If not, see <http://www.gnu.org/licenses/>.
|
|
**/
|
|
|
|
/*
|
|
* Render2D.h
|
|
*
|
|
* Header file defining the CRender2D class: OpenGL tile generator graphics.
|
|
*/
|
|
|
|
#ifndef INCLUDED_RENDER2D_H
|
|
#define INCLUDED_RENDER2D_H
|
|
|
|
#ifdef __ANDROID__
|
|
#include <cstdint>
|
|
#include <utility>
|
|
#include <vector>
|
|
namespace Util { namespace Config { class Node; } }
|
|
|
|
// Android software renderer: decodes the tile generator into an RGBA8888 buffer.
|
|
// This is enough to show the built-in test menus (2D only) while the 3D/GPU path
|
|
// is still stubbed out on Android.
|
|
class CRender2D
|
|
{
|
|
public:
|
|
using AndroidTileBlitFn = void (*)(const uint32_t* pixelsARGB, int width, int height, bool alphaBlend);
|
|
|
|
explicit CRender2D(const Util::Config::Node &config);
|
|
~CRender2D() = default;
|
|
|
|
static void SetAndroidTileBlit(AndroidTileBlitFn fn);
|
|
|
|
void BeginFrame(void);
|
|
void PreRenderFrame(void);
|
|
void RenderFrameBottom(void);
|
|
void RenderFrameTop(void);
|
|
void EndFrame(void);
|
|
void AttachVRAM(const uint8_t *vramPtr);
|
|
void AttachPalette(const uint32_t *palPtr[2]);
|
|
void AttachRegisters(const uint32_t *regPtr);
|
|
bool Init(unsigned xOffset, unsigned yOffset, unsigned xRes, unsigned yRes, unsigned totalXRes, unsigned totalYRes);
|
|
|
|
const uint32_t* GetFrameBufferARGB() const { return m_frame.data(); }
|
|
const uint32_t* GetTopSurfaceARGB() const { return m_topSurface.data(); }
|
|
unsigned GetFrameWidth() const { return m_xPixels; }
|
|
unsigned GetFrameHeight() const { return m_yPixels; }
|
|
bool HasFrame() const { return !m_frame.empty(); }
|
|
bool HasTopSurface() const { return m_surfacesPresent.first; }
|
|
|
|
private:
|
|
std::pair<bool, bool> DrawTilemaps(uint32_t *pixelsBottom, uint32_t *pixelsTop);
|
|
void CompositeTopOntoFrame();
|
|
|
|
const Util::Config::Node &m_config;
|
|
const uint32_t *m_vram = nullptr;
|
|
const uint32_t *m_palette[2] = { nullptr, nullptr };
|
|
const uint32_t *m_regs = nullptr;
|
|
|
|
unsigned m_xPixels = 496;
|
|
unsigned m_yPixels = 384;
|
|
|
|
std::vector<uint32_t> m_topSurface;
|
|
std::vector<uint32_t> m_bottomSurface;
|
|
std::vector<uint32_t> m_frame;
|
|
std::pair<bool, bool> m_surfacesPresent{false, false}; // top, bottom
|
|
};
|
|
|
|
#else
|
|
|
|
#include <GL/glew.h>
|
|
#include "Util/NewConfig.h"
|
|
|
|
|
|
/*
|
|
* CRender2D:
|
|
*
|
|
* Tile generator graphics engine. This must be constructed and initialized
|
|
* before being attached to any objects that want to make use of it. Apart from
|
|
* the constructor, all members assume that a global GL device
|
|
* context is available and that GL functions may be called.
|
|
*/
|
|
class CRender2D
|
|
{
|
|
public:
|
|
/*
|
|
* BeginFrame(void):
|
|
*
|
|
* Prepare to render a new frame. Must be called once per frame prior to
|
|
* drawing anything.
|
|
*/
|
|
void BeginFrame(void);
|
|
|
|
/*
|
|
* PreRenderFrame(void):
|
|
*
|
|
* Draws the all top layers (above 3D graphics) and bottom layers (below 3D
|
|
* graphics) but does not yet display them. May send data to the GPU.
|
|
*/
|
|
void PreRenderFrame(void);
|
|
|
|
/*
|
|
* RenderFrameBottom(void):
|
|
*
|
|
* Overwrites the color buffer with bottom surface that was pre-rendered by
|
|
* the last call to PreRenderFrame().
|
|
*/
|
|
void RenderFrameBottom(void);
|
|
|
|
/*
|
|
* RenderFrameTop(void):
|
|
*
|
|
* Draws the top surface (if it exists) that was pre-rendered by the last
|
|
* call to PreRenderFrame(). Previously drawn graphics layers will be visible
|
|
* through transparent regions.
|
|
*/
|
|
void RenderFrameTop(void);
|
|
|
|
/*
|
|
* EndFrame(void):
|
|
*
|
|
* Signals the end of rendering for this frame. Must be called last during
|
|
* the frame.
|
|
*/
|
|
void EndFrame(void);
|
|
|
|
/*
|
|
* WriteVRAM(addr, data):
|
|
*
|
|
* Indicates what will be written next to the tile generator's RAM. The
|
|
* VRAM address must not have yet been updated, to allow the renderer to
|
|
* check for changes. Data is accepted in the same form as the tile
|
|
* generator: the MSB is what was written to addr+3. This function is
|
|
* intended to facilitate on-the-fly decoding of tiles and palette data.
|
|
*
|
|
* Parameters:
|
|
* addr Address in tile generator RAM. Caller must ensure it is
|
|
* clamped to the range 0x000000 to 0x11FFFF because this
|
|
* function does not.
|
|
* data The data to write.
|
|
*/
|
|
void WriteVRAM(unsigned addr, uint32_t data);
|
|
|
|
/*
|
|
* AttachRegisters(regPtr):
|
|
*
|
|
* Attaches tile generator registers. This must be done prior to any
|
|
* rendering otherwise the program may crash with an access violation.
|
|
*
|
|
* Parameters:
|
|
* regPtr Pointer to the base of the tile generator registers. There
|
|
* are assumed to be 64 in all.
|
|
*/
|
|
void AttachRegisters(const uint32_t *regPtr);
|
|
|
|
/*
|
|
* AttachPalette(palPtr):
|
|
*
|
|
* Attaches tile generator palettes. This must be done prior to any
|
|
* rendering.
|
|
*
|
|
* Parameters:
|
|
* palPtr Pointer to two palettes. The first is for layers A/A' and
|
|
* the second is for B/B'.
|
|
*/
|
|
void AttachPalette(const uint32_t *palPtr[2]);
|
|
|
|
/*
|
|
* AttachVRAM(vramPtr):
|
|
*
|
|
* Attaches tile generator RAM. This must be done prior to any rendering
|
|
* otherwise the program may crash with an access violation.
|
|
*
|
|
* Parameters:
|
|
* vramPtr Pointer to the base of the tile generator RAM (0x120000
|
|
* bytes). VRAM is assumed to be in little endian format.
|
|
*/
|
|
void AttachVRAM(const uint8_t *vramPtr);
|
|
|
|
/*
|
|
* Init(xOffset, yOffset, xRes, yRes, totalXRes, totalYRes);
|
|
*
|
|
* One-time initialization of the context. Must be called before any other
|
|
* members (meaning it should be called even before being attached to any
|
|
* other objects that want to use it).
|
|
*
|
|
* Parameters:
|
|
* xOffset X offset of the viewable area within OpenGL display
|
|
* surface, in pixels.
|
|
* yOffset Y offset.
|
|
* xRes Horizontal resolution of the viewable area.
|
|
* yRes Vertical resolution.
|
|
* totalXRes Horizontal resolution of the complete display area.
|
|
* totalYRes Vertical resolution.
|
|
*
|
|
* Returns:
|
|
* OKAY is successful, otherwise FAILED if a non-recoverable error
|
|
* occurred. Prints own error messages.
|
|
*/
|
|
bool Init(unsigned xOffset, unsigned yOffset, unsigned xRes, unsigned yRes, unsigned totalXRes, unsigned totalYRes);
|
|
|
|
/*
|
|
* CRender2D(config):
|
|
* ~CRender2D(void):
|
|
*
|
|
* Constructor and destructor.
|
|
*
|
|
* Parameters:
|
|
* config Run-time configuration.
|
|
*/
|
|
CRender2D(const Util::Config::Node &config);
|
|
~CRender2D(void);
|
|
|
|
private:
|
|
// Private member functions
|
|
std::pair<bool, bool> DrawTilemaps(uint32_t *destBottom, uint32_t *destTop);
|
|
void DisplaySurface(int surface);
|
|
void Setup2D(bool isBottom);
|
|
|
|
// Run-time configuration
|
|
const Util::Config::Node &m_config;
|
|
|
|
// Data received from tile generator device object
|
|
const uint32_t *m_vram;
|
|
const uint32_t *m_palette[2]; // palettes for A/A' and B/B'
|
|
const uint32_t *m_regs;
|
|
|
|
// OpenGL data
|
|
GLuint m_texID[2]; // IDs for the 2 layer textures (top and bottom)
|
|
unsigned m_xPixels = 496; // display surface resolution
|
|
unsigned m_yPixels = 384; // ...
|
|
unsigned m_xOffset = 0; // offset
|
|
unsigned m_yOffset = 0;
|
|
unsigned m_totalXPixels; // total display surface resolution
|
|
unsigned m_totalYPixels;
|
|
unsigned m_correction = 0;
|
|
|
|
// Shader programs and input data locations
|
|
GLuint m_shaderProgram; // shader program object
|
|
GLuint m_vertexShader; // vertex shader handle
|
|
GLuint m_fragmentShader; // fragment shader
|
|
GLuint m_textureMapLoc; // location of "textureMap" uniform
|
|
|
|
// PreRenderFrame() tracks which surfaces exist in current frame
|
|
std::pair<bool, bool> m_surfaces_present = std::pair<bool, bool>(false, false);
|
|
|
|
// Buffers
|
|
uint8_t *m_memoryPool = 0; // all memory is allocated here
|
|
uint32_t *m_topSurface = 0; // 512x384x32bpp pixel surface for top layers
|
|
uint32_t *m_bottomSurface = 0; // bottom layers
|
|
};
|
|
|
|
#endif // __ANDROID__
|
|
|
|
#endif // INCLUDED_RENDER2D_H
|