a6ba983650
Merged Qt, SDL and WRL frontend on the same corewrapper Moved OpenGL code out of SDL and Qt frontends to OpenGl backend (JGfx.cpp) Updated file system and network code to be compatible with WRL
673 lines
22 KiB
C++
673 lines
22 KiB
C++
//-------------------------------------------------------------------------------------
|
|
//
|
|
// JGE++ is a hardware accelerated 2D game SDK for PSP/Windows.
|
|
//
|
|
// Licensed under the BSD license, see LICENSE in JGE root for details.
|
|
//
|
|
// Copyright (c) 2007 James Hui (a.k.a. Dr.Watson) <jhkhui@gmail.com>
|
|
//
|
|
//-------------------------------------------------------------------------------------
|
|
|
|
#ifndef _JRENDERER_H_
|
|
#define _JRENDERER_H_
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdarg.h>
|
|
|
|
#if (!defined IOS) && (!defined ANDROID) && (!defined QT_CONFIG) && (!defined WP8)
|
|
#include <gif_lib.h>
|
|
#endif //IOS ANDROID
|
|
|
|
#include "JTypes.h"
|
|
|
|
|
|
#if defined (WIN32)
|
|
#include <windows.h>
|
|
#elif defined (PSP)
|
|
|
|
#include <pspgu.h>
|
|
#include <pspkernel.h>
|
|
#include <pspdisplay.h>
|
|
#include <pspdebug.h>
|
|
#include <pspctrl.h>
|
|
#include <time.h>
|
|
#include <string.h>
|
|
#include <pspaudiolib.h>
|
|
#include <psprtc.h>
|
|
|
|
#endif
|
|
|
|
#include "Vector2D.h"
|
|
|
|
#define USING_MATH_TABLE
|
|
|
|
#ifdef USING_MATCH_TABLE
|
|
#define SINF(x) mSinTable[x]
|
|
#define COSF(x) mCosTable[x]
|
|
#else
|
|
#define SINF(x) sinf(x*DEG2RAD)
|
|
#define COSF(x) cosf(x*DEG2RAD)
|
|
#endif
|
|
|
|
#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) || ((defined WIN32) && !defined(WP8))
|
|
typedef struct
|
|
{
|
|
GLfloat m[4][4];
|
|
} ESMatrix;
|
|
#endif // (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0)
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// A collection of core rendering functions.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
class JRenderer
|
|
{
|
|
protected:
|
|
|
|
JRenderer();
|
|
~JRenderer();
|
|
void InitRenderer();
|
|
void DestroyRenderer();
|
|
|
|
float mWindowWidth;
|
|
float mWindowHeight;
|
|
|
|
float mLeft;
|
|
float mTop;
|
|
float mRight;
|
|
float mBottom;
|
|
|
|
public:
|
|
|
|
#if defined (PSP)
|
|
int PixelSize(int textureMode);
|
|
#endif
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Get the singleton instance
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
static JRenderer* GetInstance();
|
|
|
|
static void Destroy();
|
|
|
|
static void Set3DFlag(bool flag);
|
|
|
|
void BeginScene();
|
|
void EndScene();
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Render a textured quad with rotation and scaling.
|
|
///
|
|
/// @param quad - Quad with texturing info.
|
|
/// @param xo - x position.
|
|
/// @param yo - y position.
|
|
/// @param angle - Rotation (radian).
|
|
/// @param xScale - Horizontal rendering scale.
|
|
/// @param yScale - Vertical rendering scale.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void RenderQuad(JQuad* quad, float xo, float yo, float angle=0.0f, float xScale=1.0f, float yScale=1.0f);
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Render a textured quad with new texture mapping information.
|
|
///
|
|
/// @param quad - Quad with texturing information.
|
|
/// @param points - Array of vertices with new texture mapping information.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void RenderQuad(JQuad* quad, VertexColor* points);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Taking a screen shot.
|
|
///
|
|
/// @note This function works on PSP only. A PNG file will be saved in
|
|
/// the current folder of the game applicaton.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void ScreenShot(const char* filename);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Load a texture from file.
|
|
///
|
|
/// @param filename - Name of file.
|
|
/// @param mode - Choose to put texture in VRAM (PSP only).
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
JTexture* LoadTexture(const char* filename, int mode = 0, int textureFormat = TEXTURE_FORMAT);
|
|
|
|
/*
|
|
** Helper function - on Win, LoadTexture previously performed the image transfer into GL memory.
|
|
** However, this doesn't work if you want to call LoadTexture in a separate worker thread, as
|
|
** OpenGL has a limitation where only one thread can run the context. Now, the image loading/decompression
|
|
** happens in LoadTexture, and the JQuad constructor will complete the texture binding with this helper function.
|
|
**
|
|
** On PSP, this is a no-op.
|
|
*/
|
|
void TransferTextureToGLContext(JTexture& inTexture);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Create texture from memory on the fly.
|
|
///
|
|
/// @param width - Width of texture.
|
|
/// @param height - Height of texture.
|
|
/// @param mode - Choose to put texture in VRAM (PSP only)
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
JTexture* CreateTexture(int width, int height, int mode = 0);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Clear entire screen to a particular color.
|
|
///
|
|
/// @param color - Color to fill the screen.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void ClearScreen(PIXEL_TYPE color);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Enable VSync for the smoothness of moving objects. (PSP only)
|
|
///
|
|
/// @param flag - true to enable, false to disable.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void EnableVSync(bool flag);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Enable bi-linear filtering for better looking on-screen images.
|
|
///
|
|
/// @param flag - true to enable, false to disable.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void EnableTextureFilter(bool flag);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Enable/disable swizzle optimization. (PSP only)
|
|
///
|
|
/// @param s - 1 to enable, 0 to disable.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void SetSwizzle(int s) { mSwizzle = s; }
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Bind texture to be used for the rendering followed.
|
|
///
|
|
/// @param tex - Texture to use.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void BindTexture(JTexture *tex);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Set texture blending options.
|
|
///
|
|
/// @par Blending options:
|
|
///
|
|
/// @code
|
|
///
|
|
/// BLEND_ZERO
|
|
/// BLEND_ONE
|
|
/// BLEND_SRC_COLOR
|
|
/// BLEND_ONE_MINUS_SRC_COLOR
|
|
/// BLEND_SRC_ALPHA
|
|
/// BLEND_ONE_MINUS_SRC_ALPHA
|
|
/// BLEND_DST_ALPHA
|
|
/// BLEND_ONE_MINUS_DST_ALPHA
|
|
/// BLEND_DST_COLOR
|
|
/// BLEND_ONE_MINUS_DST_COLOR
|
|
/// BLEND_SRC_ALPHA_SATURATE
|
|
///
|
|
/// @endcode
|
|
///
|
|
/// @param src - Blending option for source image.
|
|
/// @param dest - Blending option for destination image.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void SetTexBlend(int src, int dest);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Set texture blending option for source image.
|
|
///
|
|
/// @param src - Blending option for source image.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void SetTexBlendSrc(int src);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Set texture blending option for destination image.
|
|
///
|
|
/// @param dest - Blending option for destination image.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void SetTexBlendDest(int dest);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Enable rendering in 2D mode.
|
|
///
|
|
/// @note To be implemented.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void Enable2D();
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Enable rendering in 3D mode.
|
|
///
|
|
/// @note To be implemented.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void Enable3D();
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Restrict all rendering to a rectangular area.
|
|
///
|
|
/// @note This is just the glScissor() function of OpenGL.
|
|
///
|
|
/// @param x - Left of the clipping area.
|
|
/// @param y - Top of the clipping area.
|
|
/// @param width - Width of the clipping area.
|
|
/// @param height - Height of the clipping area.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void SetClip(int x, int y, int width, int height);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Reset Modelview Identity.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void LoadIdentity();
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Tranlate position in 3D space.
|
|
///
|
|
/// @param x - X position.
|
|
/// @param y - Y position.
|
|
/// @param z - Z position.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void Translate(float x, float y, float z);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Rotate along X axis.
|
|
///
|
|
/// @param angle - Angle to rotate ( in radians).
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void RotateX(float angle);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Rotate along Y axis.
|
|
///
|
|
/// @param angle - Angle to rotate ( in radians).
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void RotateY(float angle);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Rotate along Z axis.
|
|
///
|
|
/// @param angle - Angle to rotate ( in radians).
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void RotateZ(float angle);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Push matrix.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void PushMatrix();
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Pop matrix.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void PopMatrix();
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Set the field of view angle (in degrees), effective at the next
|
|
/// Enable3D() call.
|
|
///
|
|
/// @param fov - The field of view angle (in degrees).
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void SetFOV(float fov);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Render triangles.
|
|
///
|
|
/// @param texture - Texture for the triangles.
|
|
/// @param tris - List of triangles.
|
|
/// @param start - starting index (Note: Index of triangles, NOT vertices).
|
|
/// @param count - Number of triangles (Note: NOT number of vertices).
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void RenderTriangles(JTexture* texture, Vertex3D *tris, int start, int count);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Fill a rectangular area with a specified color.
|
|
///
|
|
/// @param x - Starting x position.
|
|
/// @param y - Starting y position.
|
|
/// @param width - Width of the rectangle.
|
|
/// @param height - Height of the rectangle.
|
|
/// @param color - Filling color.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void FillRect(float x, float y, float width, float height, PIXEL_TYPE color);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Fill a rectangular area with a single color for each vertex.
|
|
///
|
|
/// @param x - Starting x position.
|
|
/// @param y - Starting y position.
|
|
/// @param width - Width of the rectangle.
|
|
/// @param height - Height of the rectangle.
|
|
/// @param color - Array of colors.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void FillRect(float x, float y, float width, float height, JColor* color);
|
|
void FillRect(float x, float y, float width, float height, PIXEL_TYPE* color);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Draw a rectangle.
|
|
///
|
|
/// @param x - Starting x position.
|
|
/// @param y - Starting y position.
|
|
/// @param width - Width of the rectangle.
|
|
/// @param height - Height of the rectangle.
|
|
/// @param color - Filling color.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void DrawRect(float x, float y, float width, float height, PIXEL_TYPE color);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Draw a single line.
|
|
///
|
|
/// @param x1 - Starting vertex, x.
|
|
/// @param y1 - Starting vertex, y.
|
|
/// @param x2 - Ending vertex, x.
|
|
/// @param y2 - Ending vertex, y.
|
|
/// @param color - Filling color.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void DrawLine(float x1, float y1, float x2, float y2, PIXEL_TYPE color);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Draw thick line.
|
|
///
|
|
/// @param x1 - Starting vertex, x.
|
|
/// @param y1 - Starting vertex, y.
|
|
/// @param x2 - Ending vertex, x.
|
|
/// @param y2 - Ending vertex, y.
|
|
/// @param lineWidth - Line width.
|
|
/// @param color - Filling color.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void DrawLine(float x1, float y1, float x2, float y2, float lineWidth, PIXEL_TYPE color);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Plot a pixel on screen.
|
|
///
|
|
/// @param x - X position of the pixel.
|
|
/// @param y - Y position of the pixel.
|
|
/// @param color - Draw colour.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void Plot(float x, float y, PIXEL_TYPE color);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Plot an array of pixels.
|
|
///
|
|
/// @param x - Array of X positions.
|
|
/// @param y - Array of Y positions.
|
|
/// @param count - Number of pixels to plot.
|
|
/// @param color - Color of pixel.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void PlotArray(float *x, float *y, int count, PIXEL_TYPE color);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Draw polygon with filled colour.
|
|
///
|
|
/// @param x - Array of X positions.
|
|
/// @param y - Array of Y positions.
|
|
/// @param count - Side count of the polygon.
|
|
/// @param color - Filling colour.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void FillPolygon(float* x, float* y, int count, PIXEL_TYPE color);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Draw polygon.
|
|
///
|
|
/// @param x - Array of X positions.
|
|
/// @param y - Array of Y positions.
|
|
/// @param count - Side count of the polygon.
|
|
/// @param color - Draw colour.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void DrawPolygon(float* x, float* y, int count, PIXEL_TYPE color);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Draw symmetric polygon with certain number of sides.
|
|
///
|
|
/// @param x - X positions of center of the polygon.
|
|
/// @param y - Y positions of center of the polygon.
|
|
/// @param size - Size of polygon.
|
|
/// @param count - Side count of the polygon.
|
|
/// @param startingAngle - Rotation angle of the polygon.
|
|
/// @param color - Draw colour.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void DrawPolygon(float x, float y, float size, int count, float startingAngle, PIXEL_TYPE color);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Draw solid symmetric polygon with certain number of sides.
|
|
///
|
|
/// @param x - X positions of center of the polygon.
|
|
/// @param y - Y positions of center of the polygon.
|
|
/// @param size - Size of polygon.
|
|
/// @param count - Side count of the polygon.
|
|
/// @param startingAngle - Rotation angle of the polygon.
|
|
/// @param color - Filling colour.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void FillPolygon(float x, float y, float size, int count, float startingAngle, PIXEL_TYPE color);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Draw circle with filled colour.
|
|
///
|
|
/// @param x - X positions of center of the circle.
|
|
/// @param y - Y positions of center of the circle.
|
|
/// @param radius - Radius of circle.
|
|
/// @param color - Filling colour.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void FillCircle(float x, float y, float radius, PIXEL_TYPE color);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Draw circle.
|
|
///
|
|
/// @param x - X positions of center of the circle.
|
|
/// @param y - Y positions of center of the circle.
|
|
/// @param radius - Radius of circle.
|
|
/// @param color - Draw colour.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void DrawCircle(float x, float y, float radius, PIXEL_TYPE color);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Draw a rectangle with round corners.
|
|
///
|
|
/// @param x - Starting x position.
|
|
/// @param y - Starting y position.
|
|
/// @param w - Width of the rectangle.
|
|
/// @param h - Height of the rectangle.
|
|
/// @param radius - Radius of the round corners.
|
|
/// @param color - Drawing color.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void DrawRoundRect(float x, float y, float w, float h, float radius, PIXEL_TYPE color);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Draw filled rectangle with round corners.
|
|
///
|
|
/// @param x - Starting x position.
|
|
/// @param y - Starting y position.
|
|
/// @param w - Width of the rectangle.
|
|
/// @param h - Height of the rectangle.
|
|
/// @param radius - Radius of the round corners.
|
|
/// @param color - Filling color.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void FillRoundRect(float x, float y, float w, float h, float radius, PIXEL_TYPE color);
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// Set custom image filter to be used at texture loading.
|
|
///
|
|
/// @param imageFilter - Custom image filter.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void SetImageFilter(JImageFilter* imageFilter);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
/// To be called each time the containing window size changes.
|
|
///
|
|
/// @param window - pointer to some platform specific window object.
|
|
/// @param inWidth - new width of the window.
|
|
/// @param inHeight - new height of the window.
|
|
///
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void OnWindowsSizeChanged(void* window, float inWidth, float inHeight);
|
|
|
|
/**
|
|
** Set/Get methods for the actual display screen size.
|
|
*/
|
|
inline void SetViewPort(float inLeft, float inTop, float inRight, float inBottom)
|
|
{
|
|
mLeft = inLeft;
|
|
mTop = inTop;
|
|
mRight = inRight;
|
|
mBottom = inBottom;
|
|
}
|
|
|
|
inline void GetViewPort(float& outLeft, float& outTop, float& outRight, float& outBottom)
|
|
{
|
|
outLeft = mLeft;
|
|
outTop = mTop;
|
|
outRight = mRight;
|
|
outBottom = mBottom;
|
|
}
|
|
|
|
inline float GetActualWidth()
|
|
{
|
|
return (mRight - mLeft);
|
|
}
|
|
|
|
inline float GetActualHeight()
|
|
{
|
|
return (mBottom - mTop);
|
|
}
|
|
|
|
private:
|
|
|
|
struct TextureInfo
|
|
{
|
|
u8 *mBits;
|
|
int mWidth;
|
|
int mHeight;
|
|
int mTexWidth;
|
|
int mTexHeight;
|
|
bool mVRAM;
|
|
};
|
|
|
|
#if (!defined IOS) && (!defined QT_CONFIG)
|
|
void LoadJPG(TextureInfo &textureInfo, const char *filename, int mode = 0, int TextureFormat = TEXTURE_FORMAT);
|
|
int LoadPNG(TextureInfo &textureInfo, const char *filename, int mode = 0, int TextureFormat = TEXTURE_FORMAT);
|
|
#if (!defined ANDROID) && (!defined QT_CONFIG) && (!defined WP8)
|
|
void LoadGIF(TextureInfo &textureInfo, const char *filename, int mode = 0, int TextureFormat = TEXTURE_FORMAT);
|
|
int image_readgif(void * handle, TextureInfo &textureInfo, DWORD * bgcolor, InputFunc readFunc,int mode = 0, int TextureFormat = TEXTURE_FORMAT);
|
|
#endif // (ANDROID) How can we get gif support for android ?
|
|
#endif //(IOS)
|
|
|
|
static JRenderer* mInstance;
|
|
|
|
#ifdef WP8
|
|
Microsoft::WRL::ComPtr<ID3D11Device1> m_d3dDevice;
|
|
Microsoft::WRL::ComPtr<ID3D11DeviceContext1> m_d3dContext;
|
|
D3D_FEATURE_LEVEL m_featureLevel;
|
|
Microsoft::WRL::ComPtr<IDXGISwapChain1> m_swapChain;
|
|
Microsoft::WRL::ComPtr<ID3D11RenderTargetView> m_renderTargetView;
|
|
Microsoft::WRL::ComPtr<ID3D11DepthStencilView> m_depthStencilView;
|
|
Microsoft::WRL::ComPtr<IUnknown> m_Window;
|
|
ID3D11Buffer* m_vertexBuffer;
|
|
ID3D11Buffer* m_indexBuffer;
|
|
|
|
#elif (!defined PSP) && (!defined WP8) && (!defined CONSOLE_CONFIG)
|
|
|
|
GLuint mCurrentTex;
|
|
#if (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0) || (defined WIN32)
|
|
// MVP matrix
|
|
ESMatrix theMvpMatrix;
|
|
|
|
// Handle to a program object
|
|
GLuint prog1;
|
|
// Attribute locations
|
|
GLint prog1_positionLoc;
|
|
GLint prog1_colorLoc;
|
|
// Uniform locations
|
|
GLint prog1_mvpLoc;
|
|
|
|
// Handle to a program object
|
|
GLuint prog2;
|
|
// Sampler location
|
|
GLint prog2_samplerLoc;
|
|
// Attribute locations
|
|
GLint prog2_positionLoc;
|
|
GLint prog2_texCoordLoc;
|
|
GLint prog2_colorLoc;
|
|
// MVP matrix
|
|
ESMatrix prog2_mvpMatrix;
|
|
// Uniform locations
|
|
GLint prog2_mvpLoc;
|
|
|
|
#endif // (defined GL_ES_VERSION_2_0) || (defined GL_VERSION_2_0)
|
|
#elif (defined PSP)
|
|
void *fbp0, *fbp1, *zbp;
|
|
PIXEL_TYPE* mVRAM;
|
|
int mCurrentTex;
|
|
int mCurrentBlend;
|
|
int mCurrentTextureFormat;
|
|
#endif
|
|
|
|
bool mVsync;
|
|
|
|
int mSwizzle;
|
|
int mTexCounter;
|
|
|
|
|
|
|
|
int mCurrentTextureFilter;
|
|
|
|
int mCurrTexBlendSrc;
|
|
int mCurrTexBlendDest;
|
|
|
|
JImageFilter* mImageFilter;
|
|
|
|
int mCurrentRenderMode;
|
|
|
|
float mFOV;
|
|
|
|
#ifdef USING_MATH_TABLE
|
|
float mSinTable[360];
|
|
float mCosTable[360];
|
|
#endif
|
|
|
|
static bool m3DEnabled;
|
|
};
|
|
|
|
|
|
#endif
|