Extern/Beef
1
0
Fork 0
mirror of https://github.com/beefytech/Beef.git synced 2025-06-10 04:22:20 +02:00
Code Activity

SDL/OGL platform improvements

Browse source
This commit is contained in:
Brian Fiete 2022-11-03 10:58:24 -07:00
parent 213aea8c82
commit 258a6653f9
16 changed files with 711 additions and 1141 deletions
Download patch file Download diff file Expand all files Collapse all files

1
BeefySysLib/gfx/DrawLayer.cpp
View file

@ -164,7 +164,6 @@ DrawLayer::DrawLayer()
DrawLayer::~DrawLayer() DrawLayer::~DrawLayer()
{ {
NOP;
} }
void DrawLayer::CloseDrawBatch() void DrawLayer::CloseDrawBatch()

25
BeefySysLib/gfx/FTFont.cpp
View file

@ -265,24 +265,28 @@ FTFontManager::Glyph* FTFont::AllocGlyph(int charCode, bool allowDefault)
if (page->mTexture == NULL) if (page->mTexture == NULL)
{ {
ImageData img; ImageData* img = new ImageData();
img.CreateNew(FT_PAGE_WIDTH, FT_PAGE_HEIGHT); img->CreateNew(FT_PAGE_WIDTH, FT_PAGE_HEIGHT);
auto* bits = img->mBits;
for (int i = 0; i < FT_PAGE_HEIGHT * FT_PAGE_WIDTH; i++) for (int i = 0; i < FT_PAGE_HEIGHT * FT_PAGE_WIDTH; i++)
{ {
if (i % 3 == 0) if (i % 3 == 0)
img.mBits[i] = 0xFFFF0000; bits[i] = 0xFFFF0000;
else if (i % 3 == 1) else if (i % 3 == 1)
img.mBits[i] = 0xFF00FF00; bits[i] = 0xFF00FF00;
else else
img.mBits[i] = 0xFF0000FF; bits[i] = 0xFF0000FF;
} }
page->mTexture = gBFApp->mRenderDevice->LoadTexture(&img, TextureFlag_NoPremult); page->mTexture = gBFApp->mRenderDevice->LoadTexture(img, TextureFlag_NoPremult);
img->Deref();
} }
if (bitmap.width > 0) if (bitmap.width > 0)
{ {
ImageData img; ImageData* img = new ImageData();
img.CreateNew(bitmap.width, bitmap.rows); img->CreateNew(bitmap.width, bitmap.rows);
auto* bits = img->mBits;
int width = img->mWidth;
for (int y = 0; y < (int)bitmap.rows; y++) for (int y = 0; y < (int)bitmap.rows; y++)
{ {
for (int x = 0; x < (int)bitmap.width; x++) for (int x = 0; x < (int)bitmap.width; x++)
@ -292,11 +296,12 @@ FTFontManager::Glyph* FTFont::AllocGlyph(int charCode, bool allowDefault)
uint8 whiteVal = gFTFontManager.mWhiteTab[val]; uint8 whiteVal = gFTFontManager.mWhiteTab[val];
uint8 blackVal = gFTFontManager.mBlackTab[val]; uint8 blackVal = gFTFontManager.mBlackTab[val];
img.mBits[y * img.mWidth + x] = ((int32)whiteVal << 24) | bits[y * width + x] = ((int32)whiteVal << 24) |
((int32)blackVal) | ((int32)0xFF << 8) | ((int32)0xFF << 16); ((int32)blackVal) | ((int32)0xFF << 8) | ((int32)0xFF << 16);
} }
} }
page->mTexture->Blt(&img, page->mCurX, page->mCurY); page->mTexture->Blt(img, page->mCurX, page->mCurY);
img->Deref();
} }
page->mCurX += bitmap.width; page->mCurX += bitmap.width;

2
BeefySysLib/gfx/RenderDevice.cpp
View file

@ -164,7 +164,7 @@ Texture* RenderDevice::LoadTexture(const StringImpl& fileName, int flags)
if (!failed) if (!failed)
aTexture = LoadTexture(imageData, flags); aTexture = LoadTexture(imageData, flags);
delete imageData; imageData->Deref();
return aTexture; return aTexture;
} }

13
BeefySysLib/img/ImageData.cpp
View file

@ -20,14 +20,27 @@ ImageData::ImageData()
mAlphaPremultiplied = false; mAlphaPremultiplied = false;
mIsAdditive = false; mIsAdditive = false;
mSrcDataLen = 0; mSrcDataLen = 0;
mRefCount = 1;
} }
ImageData::~ImageData() ImageData::~ImageData()
{ {
BF_ASSERT(mRefCount <= 1); // Allow direct delete if we only have one reference
delete [] mBits; delete [] mBits;
delete [] mSrcData; delete [] mSrcData;
} }
void ImageData::AddRef()
{
mRefCount++;
}
void ImageData::Deref()
{
if (--mRefCount == 0)
delete this;
}
void ImageData::SwapRAndB() void ImageData::SwapRAndB()
{ {
int aSize = mWidth*mHeight; int aSize = mWidth*mHeight;

3
BeefySysLib/img/ImageData.h
View file

@ -15,6 +15,7 @@ enum
class ImageData class ImageData
{ {
public: public:
int mRefCount;
int mX; int mX;
int mY; int mY;
int mWidth; int mWidth;
@ -36,6 +37,8 @@ public:
ImageData(); ImageData();
virtual ~ImageData(); virtual ~ImageData();
void AddRef();
void Deref();
void SwapRAndB(); void SwapRAndB();
void CreateNew(int x, int y, int width, int height, bool clear = true); void CreateNew(int x, int y, int width, int height, bool clear = true);
void CreateNew(int width, int height, bool clear = true); void CreateNew(int width, int height, bool clear = true);

791
BeefySysLib/platform/sdl/GLRenderDevice.cpp
View file

@ -3,12 +3,14 @@
#include "BFWindow.h" #include "BFWindow.h"
#include "img/ImageData.h" #include "img/ImageData.h"
#include "util/PerfTimer.h" #include "util/PerfTimer.h"
#include "SDL_video.h" #include <SDL2/SDL_video.h>
USING_NS_BF; USING_NS_BF;
#define NOT_IMPL throw "Not implemented" #define NOT_IMPL throw "Not implemented"
#pragma comment(lib, "SDL2.lib")
#ifdef _WIN32 #ifdef _WIN32
#ifdef BF_PLATFORM_OPENGL_ES2 #ifdef BF_PLATFORM_OPENGL_ES2
#pragma comment(lib, "libEGL.lib") #pragma comment(lib, "libEGL.lib")
@ -34,6 +36,12 @@ USING_NS_BF;
#define APIENTRYP BF_CALLTYPE * #define APIENTRYP BF_CALLTYPE *
#endif #endif
typedef void (APIENTRYP GL_DEBUGPROC)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, const void* userParam);
static void (APIENTRYP bf_glDebugMessageCallback)(GL_DEBUGPROC callback, const void* userParam);
static void (APIENTRYP bf_glActiveTexture)(GLenum texture);
static void (APIENTRYP bf_glGenVertexArrays)(GLsizei n, GLuint* buffers);
static void (APIENTRYP bf_glBindVertexArray)(GLenum target);
static void (APIENTRYP bf_glGenBuffers)(GLsizei n, GLuint *buffers); static void (APIENTRYP bf_glGenBuffers)(GLsizei n, GLuint *buffers);
static void (APIENTRYP bf_glBindBuffer)(GLenum target, GLuint buffer); static void (APIENTRYP bf_glBindBuffer)(GLenum target, GLuint buffer);
static void (APIENTRYP bf_glBufferData)(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage); static void (APIENTRYP bf_glBufferData)(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
@ -159,32 +167,14 @@ GLShader::GLShader()
GLShader::~GLShader() GLShader::~GLShader()
{ {
GLShaderParamMap::iterator itr = mParamsMap.begin(); for (auto paramKV : mParamsMap)
while (itr != mParamsMap.end())
{ {
delete itr->second; delete paramKV.mValue;
++itr; }
} }
//if (mGLEffect != NULL) ShaderParam* GLShader::GetShaderParam(const StringImpl& name)
//mGLEffect->Release();
}
ShaderParam* GLShader::GetShaderParam(const std::wstring& name)
{ {
/*GLShaderParamMap::iterator itr = mParamsMap.find(name);
if (itr != mParamsMap.end())
return itr->second;
IGL10EffectVariable* d3DVariable = mGLEffect->GetVariableByName(ToString(name).c_str());
if (d3DVariable == NULL)
return NULL;
GLShaderParam* shaderParam = new GLShaderParam();
shaderParam->mGLVariable = d3DVariable;
mParamsMap[name] = shaderParam;
return shaderParam;*/
NOT_IMPL; NOT_IMPL;
return NULL; return NULL;
} }
@ -193,13 +183,17 @@ ShaderParam* GLShader::GetShaderParam(const std::wstring& name)
GLTexture::GLTexture() GLTexture::GLTexture()
{ {
mGLTexture = NULL; mGLTexture = 0;
mGLTexture2 = 0;
//mGLRenderTargetView = NULL; //mGLRenderTargetView = NULL;
mRenderDevice = NULL; mRenderDevice = NULL;
mImageData = NULL;
} }
GLTexture::~GLTexture() GLTexture::~GLTexture()
{ {
if (mImageData != NULL)
mImageData->Deref();
//if (mGLTexture != NULL) //if (mGLTexture != NULL)
//mGLTexture->Release(); //mGLTexture->Release();
} }
@ -207,42 +201,30 @@ GLTexture::~GLTexture()
void GLTexture::PhysSetAsTarget() void GLTexture::PhysSetAsTarget()
{ {
NOT_IMPL; NOT_IMPL;
//{ }
// GL10_VIEWPORT viewPort;
// viewPort.Width = mWidth;
// viewPort.Height = mHeight;
// viewPort.MinDepth = 0.0f;
// viewPort.MaxDepth = 1.0f;
// viewPort.TopLeftX = 0;
// viewPort.TopLeftY = 0;
// mRenderDevice->mGLDevice->RSSetViewports(1, &viewPort); void GLTexture::Blt(ImageData* imageData, int x, int y)
// mRenderDevice->mGLDevice->OMSetRenderTargets(1, &mGLRenderTargetView, NULL); {
//} if (mImageData != NULL)
{
//if (!mHasBeenDrawnTo) for (int row = 0; row < imageData->mHeight; row++)
//{ {
// //mRenderDevice->mGLDevice->ClearRenderTargetView(mGLRenderTargetView, D3GLVECTOR4(1, 0.5, 0.5, 1)); memcpy(mImageData->mBits + (y + row) * mImageData->mWidth + x,
// mHasBeenDrawnTo = true; imageData->mBits + row * imageData->mWidth, imageData->mWidth * 4);
//} }
}
else
{
glBindTexture(GL_TEXTURE_2D, mGLTexture);
glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, imageData->mWidth, imageData->mHeight, GL_RGBA, GL_UNSIGNED_BYTE, imageData->mBits);
}
} }
/// ///
GLDrawBatch::GLDrawBatch(int minVtxSize, int minIdxSize) : DrawBatch() GLDrawBatch::GLDrawBatch() : DrawBatch()
{ {
mAllocatedVertices = 16*1024;
// Alloc more indices than vertices. Worst case is really long tri strip.
mAllocatedIndices = mAllocatedVertices * 3;
if (minVtxSize > mAllocatedVertices)
mAllocatedVertices = GetPowerOfTwo(minVtxSize);
if (minIdxSize > mAllocatedIndices)
mAllocatedIndices = GetPowerOfTwo(minIdxSize);
mVertices = new Vertex3D[mAllocatedVertices];
mIndices = new uint16[mAllocatedIndices];
mNext = NULL;
} }
GLDrawBatch::~GLDrawBatch() GLDrawBatch::~GLDrawBatch()
@ -252,14 +234,16 @@ GLDrawBatch::~GLDrawBatch()
//mGLBuffer->Release(); //mGLBuffer->Release();
} }
void GLDrawBatch::Lock()
{
//mGLBuffer->Map(GL10_MAP_WRITE_DISCARD, 0, (void**) &mVertices);
}
extern int gBFDrawBatchCount; extern int gBFDrawBatchCount;
void GLDrawBatch::Draw() struct GLVertex3D
{
float x, y, z;
float u, v;
uint32 color;
};
void GLDrawBatch::Render(RenderDevice* renderDevice, RenderWindow* renderWindow)
{ {
if (mIdxIdx == 0) if (mIdxIdx == 0)
return; return;
@ -267,66 +251,31 @@ void GLDrawBatch::Draw()
gBFDrawBatchCount++; gBFDrawBatchCount++;
GLRenderDevice* glRenderDevice = (GLRenderDevice*) gBFApp->mRenderDevice; GLRenderDevice* glRenderDevice = (GLRenderDevice*) gBFApp->mRenderDevice;
if (glRenderDevice->mPhysRenderWindow != mDrawLayer->mRenderWindow) GLShader* curShader = (GLShader*)mRenderState->mShader;
glRenderDevice->PhysSetRenderWindow(mDrawLayer->mRenderWindow);
//// Flip BGRA to RGBA if (glRenderDevice->mGLVAO == 0)
//for (int i = 0; i < mIdx; i++)
//{
// uint32 aColor = mVertices[i].color;
// aColor =
// (aColor & 0xFF00FF00) |
// ((aColor & 0x00FF0000) >> 16) |
// ((aColor & 0x000000FF) << 16);
// mVertices[i].color = aColor;
//}
//mGLBuffer->Unmap();
//GLShader* curShader = (GLShader*) aRenderDevice->mCurShader;
GLShader* curShader = (GLShader*) mCurShader;
//if (curShader->mTextureParam != NULL)
//curShader->mTextureParam->SetTexture(mCurTexture);
#ifdef BF_PLATFORM_OPENGL_ES2
//bf_glClientActiveTexture(GL_TEXTURE0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, ((GLTexture*)mCurTexture)->mGLTexture);
glUniform1i(curShader->mAttribTex0, 0);
//bf_glClientActiveTexture(GL_TEXTURE1);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, ((GLTexture*)mCurTexture)->mGLTexture2);
glUniform1i(curShader->mAttribTex1, 1);
//glEnable(GL_TEXTURE_2D);
#else
glBindTexture(GL_TEXTURE_2D, ((GLTexture*)mCurTexture)->mGLTexture);
#endif
//if (mIsAdditive != glRenderDevice->mCurAdditive)
//glRenderDevice->PhysSetAdditive(mIsAdditive);
//TODO: Just do 'apply', we don't have to do full PhysSetShaderPass
if (curShader != glRenderDevice->mPhysShader)
glRenderDevice->PhysSetShader(mCurShader);
// Set vertex buffer
if (glRenderDevice->mGLVertexBuffer == 0)
{ {
bf_glGenVertexArrays(1, &glRenderDevice->mGLVAO);
bf_glBindVertexArray(glRenderDevice->mGLVAO);
bf_glGenBuffers(1, &glRenderDevice->mGLVertexBuffer); bf_glGenBuffers(1, &glRenderDevice->mGLVertexBuffer);
bf_glGenBuffers(1, &glRenderDevice->mGLIndexBuffer); bf_glGenBuffers(1, &glRenderDevice->mGLIndexBuffer);
} }
bf_glBindBuffer(GL_ARRAY_BUFFER, glRenderDevice->mGLVertexBuffer); auto glVertices = (GLVertex3D*)mVertices;
bf_glBufferData(GL_ARRAY_BUFFER, mVtxIdx * sizeof(Vertex3D), mVertices, GL_STREAM_DRAW);
bf_glVertexAttribPointer(curShader->mAttribPosition, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex3D), (void*)offsetof(Vertex3D, x)); bf_glBindBuffer(GL_ARRAY_BUFFER, glRenderDevice->mGLVertexBuffer);
bf_glVertexAttribPointer(curShader->mAttribTexCoord0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex3D), (void*)offsetof(Vertex3D, u)); bf_glBufferData(GL_ARRAY_BUFFER, mVtxIdx * sizeof(GLVertex3D), mVertices, GL_STREAM_DRAW);
bf_glVertexAttribPointer(curShader->mAttribColor, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(Vertex3D), (void*)offsetof(Vertex3D, color));
bf_glEnableVertexAttribArray(curShader->mAttribPosition);
bf_glVertexAttribPointer(curShader->mAttribPosition, 3, GL_FLOAT, GL_FALSE, sizeof(GLVertex3D), (void*)offsetof(GLVertex3D, x));
bf_glEnableVertexAttribArray(curShader->mAttribTexCoord0);
bf_glVertexAttribPointer(curShader->mAttribTexCoord0, 2, GL_FLOAT, GL_FALSE, sizeof(GLVertex3D), (void*)offsetof(GLVertex3D, u));
bf_glEnableVertexAttribArray(curShader->mAttribColor);
bf_glVertexAttribPointer(curShader->mAttribColor, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(GLVertex3D), (void*)offsetof(GLVertex3D, color));
if (mRenderState != renderDevice->mPhysRenderState)
renderDevice->PhysSetRenderState(mRenderState);
bf_glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, glRenderDevice->mGLIndexBuffer); bf_glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, glRenderDevice->mGLIndexBuffer);
bf_glBufferData(GL_ELEMENT_ARRAY_BUFFER, mIdxIdx * sizeof(int16), mIndices, GL_STREAM_DRAW); bf_glBufferData(GL_ELEMENT_ARRAY_BUFFER, mIdxIdx * sizeof(int16), mIndices, GL_STREAM_DRAW);
@ -349,56 +298,21 @@ DrawBatch* GLDrawLayer::CreateDrawBatch()
return new GLDrawBatch(); return new GLDrawBatch();
} }
DrawBatch* GLDrawLayer::AllocateBatch(int minVtxCount, int minIdxCount)
RenderCmd* GLDrawLayer::CreateSetTextureCmd(int textureIdx, Texture* texture)
{ {
AutoPerf autoPerf("GLDrawLayer::AllocateBatch"); GLSetTextureCmd* setTextureCmd = AllocRenderCmd<GLSetTextureCmd>();
setTextureCmd->mTextureIdx = textureIdx;
//GLDrawBatchVector* pool = &((GLRenderDevice*) gBFApp->mRenderDevice)->mDrawBatchPool; setTextureCmd->mTexture = texture;
return setTextureCmd;
GLRenderDevice* glRenderDevice = (GLRenderDevice*)gBFApp->mRenderDevice;
GLDrawBatch* newBatch = NULL;
//TODO: Search
GLDrawBatch** prevRefPtr = &glRenderDevice->mFreeBatchHead;
GLDrawBatch* checkBatch = glRenderDevice->mFreeBatchHead;
while (checkBatch != NULL)
{
if ((checkBatch->mAllocatedVertices >= minVtxCount) &&
(checkBatch->mAllocatedIndices >= minIdxCount))
{
newBatch = checkBatch;
*prevRefPtr = (GLDrawBatch*)checkBatch->mNext;
checkBatch->mNext = NULL;
break;
} }
checkBatch = (GLDrawBatch*)checkBatch->mNext; void GLDrawLayer::SetShaderConstantData(int usageIdx, int slotIdx, void* constData, int size)
prevRefPtr = (GLDrawBatch**)&checkBatch->mNext;
}
/*for (int i = pool->size() -1; i >= 0; i--)
{ {
GLDrawBatch* checkBatch = (*pool)[i];
if ((checkBatch->mAllocatedVertices >= minVtxCount) &&
(checkBatch->mAllocatedIndices >= minIdxCount))
{
newBatch = checkBatch;
pool->erase(pool->begin() + i);
break;
}
}*/
if (newBatch == NULL)
newBatch = new GLDrawBatch(minVtxCount, minIdxCount);
newBatch->mDrawLayer = this;
return newBatch;
} }
void GLDrawLayer::FreeBatch(DrawBatch* drawBatch)
/*void GLDrawLayer::FreeBatch(DrawBatch* drawBatch)
{ {
//delete drawBatch; //delete drawBatch;
@ -410,46 +324,46 @@ void GLDrawLayer::FreeBatch(DrawBatch* drawBatch)
GLRenderDevice* glRenderDevice = (GLRenderDevice*)gBFApp->mRenderDevice; GLRenderDevice* glRenderDevice = (GLRenderDevice*)gBFApp->mRenderDevice;
drawBatch->mNext = glRenderDevice->mFreeBatchHead; drawBatch->mNext = glRenderDevice->mFreeBatchHead;
glRenderDevice->mFreeBatchHead = batch; glRenderDevice->mFreeBatchHead = batch;
} }*/
void GLRenderDevice::PhysSetShader(Shader* shader) //void GLRenderDevice::PhysSetShader(Shader* shader)
{ //{
GLRenderDevice* aRenderDevice = (GLRenderDevice*) gBFApp->mRenderDevice; // GLRenderDevice* aRenderDevice = (GLRenderDevice*) gBFApp->mRenderDevice;
//
//TODO: Cache more // //TODO: Cache more
//
GLShader* glShader = (GLShader*)shader; // GLShader* glShader = (GLShader*)shader;
//
GLfloat matrix[4][4]; // GLfloat matrix[4][4];
CreateOrthographicOffCenter(0.0f, (float)mPhysRenderWindow->mWidth, (float)mPhysRenderWindow->mHeight, 0.0f, -100.0f, 100.0f, matrix); // CreateOrthographicOffCenter(0.0f, (float)mPhysRenderWindow->mWidth, (float)mPhysRenderWindow->mHeight, 0.0f, -100.0f, 100.0f, matrix);
GLint matrixLoc = bf_glGetUniformLocation(glShader->mGLProgram, "screenMatrix"); // GLint matrixLoc = bf_glGetUniformLocation(glShader->mGLProgram, "screenMatrix");
//BF_ASSERT(matrixLoc >= 0); // //BF_ASSERT(matrixLoc >= 0);
if (matrixLoc >= 0) // if (matrixLoc >= 0)
bf_glUniformMatrix4fv(matrixLoc, 1, false, (float*)matrix); // bf_glUniformMatrix4fv(matrixLoc, 1, false, (float*)matrix);
//
/*mPhysShaderPass = shaderPass; // /*mPhysShaderPass = shaderPass;
GLShaderPass* dXShaderPass = (GLShaderPass*) mPhysShaderPass; // GLShaderPass* dXShaderPass = (GLShaderPass*) mPhysShaderPass;
mGLDevice->IASetInputLayout(dXShaderPass->mGLLayout); // mGLDevice->IASetInputLayout(dXShaderPass->mGLLayout);
//
if (mCurShader->mLastResizeCount != mCurRenderTarget->mResizeNum) // if (mCurShader->mLastResizeCount != mCurRenderTarget->mResizeNum)
{ // {
ShaderParam* shaderParam = mCurShader->GetShaderParam(L"WindowSize"); // ShaderParam* shaderParam = mCurShader->GetShaderParam(L"WindowSize");
if (shaderParam != NULL) // if (shaderParam != NULL)
{ // {
shaderParam->SetFloat2((float) mCurRenderTarget->mWidth, (float) mCurRenderTarget->mHeight); // shaderParam->SetFloat2((float) mCurRenderTarget->mWidth, (float) mCurRenderTarget->mHeight);
} // }
//
mCurShader->mLastResizeCount = mCurRenderTarget->mResizeNum; // mCurShader->mLastResizeCount = mCurRenderTarget->mResizeNum;
} // }
//
GLCHECK(dXShaderPass->mGLEffectPass->Apply(0));*/ // GLCHECK(dXShaderPass->mGLEffectPass->Apply(0));*/
//
/*GLfloat matrix[4][4]; // /*GLfloat matrix[4][4];
CreateOrthographicOffCenter(0.0f, (float)mPhysRenderWindow->mWidth, (float)mPhysRenderWindow->mHeight, 0.0f, -100.0f, 100.0f, matrix); // CreateOrthographicOffCenter(0.0f, (float)mPhysRenderWindow->mWidth, (float)mPhysRenderWindow->mHeight, 0.0f, -100.0f, 100.0f, matrix);
GLint uniformLocation = bf_glGetUniformLocation(((GLShader*)shaderPass->mTechnique->mShader)->mGLProgram, "screenMatrix"); // GLint uniformLocation = bf_glGetUniformLocation(((GLShader*)shaderPass->mTechnique->mShader)->mGLProgram, "screenMatrix");
if (uniformLocation != -1) // if (uniformLocation != -1)
bf_glUniformMatrix4fv(uniformLocation, 1, false, (GLfloat*)matrix);*/ // bf_glUniformMatrix4fv(uniformLocation, 1, false, (GLfloat*)matrix);*/
} //}
void GLRenderDevice::PhysSetRenderWindow(RenderWindow* renderWindow) void GLRenderDevice::PhysSetRenderWindow(RenderWindow* renderWindow)
{ {
@ -474,10 +388,19 @@ static void BFGetGLProc(T& proc, const char* name)
#define BF_GET_GLPROC(name) BFGetGLProc(bf_##name, #name) #define BF_GET_GLPROC(name) BFGetGLProc(bf_##name, #name)
void GL_DebugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, const void* userParam)
{
NOP;
}
GLRenderWindow::GLRenderWindow(GLRenderDevice* renderDevice, SDL_Window* sdlWindow) GLRenderWindow::GLRenderWindow(GLRenderDevice* renderDevice, SDL_Window* sdlWindow)
{ {
if (bf_glGenBuffers == NULL) if (bf_glGenBuffers == NULL)
{ {
BF_GET_GLPROC(glDebugMessageCallback);
BF_GET_GLPROC(glActiveTexture);
BF_GET_GLPROC(glGenVertexArrays);
BF_GET_GLPROC(glBindVertexArray);
BF_GET_GLPROC(glGenBuffers); BF_GET_GLPROC(glGenBuffers);
BF_GET_GLPROC(glBindBuffer); BF_GET_GLPROC(glBindBuffer);
BF_GET_GLPROC(glBufferData); BF_GET_GLPROC(glBufferData);
@ -545,90 +468,21 @@ GLRenderWindow::GLRenderWindow(GLRenderDevice* renderDevice, SDL_Window* sdlWind
mRenderDevice = renderDevice; mRenderDevice = renderDevice;
Resized(); Resized();
//mGLSwapChain = NULL; //bf_glDebugMessageCallback(GL_DebugCallback, NULL);
//mGLBackBuffer = NULL;
//mGLRenderTargetView = NULL;
//mRenderDevice = renderDevice;
//mHWnd = hWnd;
//HRESULT hr = S_OK;
//Resized();
//GLGI_SWAP_CHAIN_DESC swapChainDesc;
//ZeroMemory( &swapChainDesc, sizeof(swapChainDesc) );
//swapChainDesc.BufferCount = 1;
//swapChainDesc.BufferDesc.Width = mWidth;
//swapChainDesc.BufferDesc.Height = mHeight;
//swapChainDesc.BufferDesc.Format = GLGI_FORMAT_R8G8B8A8_UNORM;
//swapChainDesc.BufferUsage = GLGI_USAGE_RENDER_TARGET_OUTPUT;
//swapChainDesc.OutputWindow = mHWnd;
//swapChainDesc.SampleDesc.Count = 1;
//swapChainDesc.SampleDesc.Quality = 0;
//swapChainDesc.Windowed = TRUE;
////swapChainDesc.BufferDesc.RefreshRate.Numerator = 60;
////swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
////swapChainDesc.Flags = GLGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
// IGLGIDevice* pGLGIDevice = NULL;
// mRenderDevice->mGLDevice->QueryInterface(__uuidof(IGLGIDevice), (void**) &pGLGIDevice );
// GLCHECK(mRenderDevice->mGLGIFactory->CreateSwapChain(pGLGIDevice, &swapChainDesc, &mGLSwapChain));
// pGLGIDevice->Release();
// pGLGIDevice = NULL;
//
//GLCHECK(mGLSwapChain->GetBuffer(0, __uuidof(IGL10Texture2D), (LPVOID*)&mGLBackBuffer));
//GLCHECK(mRenderDevice->mGLDevice->CreateRenderTargetView(mGLBackBuffer, NULL, &mGLRenderTargetView));
} }
GLRenderWindow::~GLRenderWindow() GLRenderWindow::~GLRenderWindow()
{ {
/*if (mGLRenderTargetView != NULL)
mGLRenderTargetView->Release();
if (mGLBackBuffer != NULL)
mGLBackBuffer->Release();
if (mGLSwapChain != NULL)
mGLSwapChain->Release(); */
} }
void GLRenderWindow::PhysSetAsTarget() void GLRenderWindow::PhysSetAsTarget()
{ {
GLfloat matrix[4][4]; GLfloat matrix[4][4];
CreateOrthographicOffCenter(0.0f, (float)mWidth, (float)mHeight, 0.0f, -100.0f, 100.0f, matrix); CreateOrthographicOffCenter(0.0f, (float)mWidth, (float)mHeight, 0.0f, -100.0f, 100.0f, matrix);
glViewport(0, 0, (GLsizei)mWidth, (GLsizei)mHeight); glViewport(0, 0, (GLsizei)mWidth, (GLsizei)mHeight);
//TODO: Set matrix variable mHasBeenDrawnTo = true;
//glMatrixMode(GL_MODELVIEW);
//glLoadMatrixf((const GLfloat*)matrix);
//NOT_IMPL;
////if (mRenderDevice->mCurRenderTarget != this)
//{
// GL10_VIEWPORT viewPort;
// viewPort.Width = mWidth;
// viewPort.Height = mHeight;
// viewPort.MinDepth = 0.0f;
// viewPort.MaxDepth = 1.0f;
// viewPort.TopLeftX = 0;
// viewPort.TopLeftY = 0;
//
// mRenderDevice->mGLDevice->OMSetRenderTargets(1, &mGLRenderTargetView, NULL);
// mRenderDevice->mGLDevice->RSSetViewports(1, &viewPort);
//}
//if (!mHasBeenDrawnTo)
//{
// //mRenderDevice->mGLDevice->ClearRenderTargetView(mGLRenderTargetView, D3GLVECTOR4(rand() / (float) RAND_MAX, 0, 1, 0));
// mRenderDevice->mGLDevice->ClearRenderTargetView(mGLRenderTargetView, D3GLVECTOR4(0, 0, 0, 0));
//}
//mHasBeenDrawnTo = true;
} }
void GLRenderWindow::SetAsTarget() void GLRenderWindow::SetAsTarget()
@ -708,6 +562,8 @@ void GLRenderWindow::CopyBitsTo(uint32* dest, int width, int height)
GLRenderDevice::GLRenderDevice() GLRenderDevice::GLRenderDevice()
{ {
//mGLDevice = NULL; //mGLDevice = NULL;
mCurShader = NULL;
mGLVAO = 0;
mGLVertexBuffer = 0; mGLVertexBuffer = 0;
mGLIndexBuffer = 0; mGLIndexBuffer = 0;
mBlankTexture = 0; mBlankTexture = 0;
@ -722,6 +578,23 @@ bool GLRenderDevice::Init(BFApp* app)
{ {
SdlBFApp* winApp = (SdlBFApp*) app; SdlBFApp* winApp = (SdlBFApp*) app;
//RenderState* glRenderState;
if (mDefaultRenderState == NULL)
{
auto dxRenderState = (RenderState*)CreateRenderState(NULL);
mDefaultRenderState = dxRenderState;
mDefaultRenderState->mDepthFunc = DepthFunc_Less;
mDefaultRenderState->mWriteDepthBuffer = true;
mPhysRenderState = mDefaultRenderState;
}
else
{
//glRenderState = (DXRenderState*)mDefaultRenderState;
//glRenderState->ReinitNative();
}
/// ///
////Use GL10_CREATE_DEVICE_DEBUG for PIX ////Use GL10_CREATE_DEVICE_DEBUG for PIX
@ -785,177 +658,55 @@ void GLRenderDevice::FrameStart()
{ {
mCurRenderTarget = NULL; mCurRenderTarget = NULL;
mPhysRenderWindow = NULL; mPhysRenderWindow = NULL;
mPhysShader = NULL;
RenderWindowList::iterator itr = mRenderWindowList.begin(); for (auto aRenderWindow : mRenderWindowList)
while (itr != mRenderWindowList.end())
{ {
(*itr)->mHasBeenDrawnTo = false; aRenderWindow->mHasBeenDrawnTo = false;
(*itr)->mHasBeenTargeted = false; aRenderWindow->mHasBeenTargeted = false;
++itr;
} }
} }
void GLRenderDevice::FrameEnd() void GLRenderDevice::FrameEnd()
{ {
RenderWindowList::iterator itr = mRenderWindowList.begin(); for (auto aRenderWindow : mRenderWindowList)
while (itr != mRenderWindowList.end())
{ {
RenderWindow* aRenderWindow = *itr;
if (aRenderWindow->mHasBeenTargeted) if (aRenderWindow->mHasBeenTargeted)
{ {
//aRenderWindow->mCurDrawLayer->Flush(); PhysSetRenderWindow(aRenderWindow);
PhysSetRenderState(mDefaultRenderState);
DrawLayerList::iterator drawLayerItr = aRenderWindow->mDrawLayerList.begin(); for (auto drawLayer : aRenderWindow->mDrawLayerList)
while (drawLayerItr != aRenderWindow->mDrawLayerList.end())
{ {
DrawLayer* drawLayer = *drawLayerItr;
drawLayer->Flush(); drawLayer->Flush();
++drawLayerItr;
} }
aRenderWindow->Present(); aRenderWindow->Present();
} }
++itr;
} }
} }
Texture* GLRenderDevice::LoadTexture(ImageData* imageData, bool additive) Texture* GLRenderDevice::LoadTexture(ImageData* imageData, int flags)
{ {
imageData->mIsAdditive = additive; imageData->mIsAdditive = (flags & TextureFlag_Additive) != 0;
imageData->PremultiplyAlpha(); imageData->PremultiplyAlpha();
//int w = power_of_two(imageData->mWidth); //int w = power_of_two(imageData->mWidth);
//int h = power_of_two(imageData->mHeight); //int h = power_of_two(imageData->mHeight);
if (mBlankTexture == 0)
{
glGenTextures(1, &mBlankTexture);
glBindTexture(GL_TEXTURE_2D, mBlankTexture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
/*if (bf_glCompressedTexImage2D != NULL)
{
uint64 hwData = 0;
bf_glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG, 4, 4, 0,
sizeof(hwData), (uint8*)&hwData);
}
else*/
{
uint16 color = 0;
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0,
GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, &color);
}
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
}
GLTexture* glTexture = new GLTexture(); GLTexture* glTexture = new GLTexture();
glTexture->mGLTexture2 = mBlankTexture; glTexture->mRenderDevice = this;
int texCount = 0;
texCount = (imageData->mHWBitsType == HWBITS_PVRTC_2X4BPPV1) ? 2 : 1;
for (int texNum = 0; texNum < 2/*texCount*/; texNum++)
{
GLuint glTextureID;
glGenTextures(1, &glTextureID);
glBindTexture(GL_TEXTURE_2D, glTextureID);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
if (imageData->mHWBits != NULL)
{
int internalFormat = (imageData->mHWBitsType == HWBITS_PVRTC_2BPPV1) ?
GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG :
GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;
int texSize = imageData->mHWBitsLength / texCount;
bf_glCompressedTexImage2D(GL_TEXTURE_2D, 0, internalFormat, imageData->mWidth, imageData->mHeight, 0,
texSize, (uint8*)imageData->mHWBits /*+ (texNum * texSize)*/);
}
else
{
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageData->mWidth, imageData->mHeight, 0,
GL_RGBA, GL_UNSIGNED_BYTE, imageData->mBits);
}
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
if (texNum == 0)
glTexture->mGLTexture = glTextureID;
else
glTexture->mGLTexture2 = glTextureID;
}
glTexture->mWidth = imageData->mWidth; glTexture->mWidth = imageData->mWidth;
glTexture->mHeight = imageData->mHeight; glTexture->mHeight = imageData->mHeight;
glTexture->AddRef(); glTexture->mImageData = imageData;
imageData->AddRef();
return glTexture; return glTexture;
//IGL10ShaderResourceView* d3DShaderResourceView = NULL;
//imageData->PremultiplyAlpha();
//int aWidth = 0;
//int aHeight = 0;
//
//// Create the render target texture
//GL10_TEXTURE2D_DESC desc;
//ZeroMemory(&desc, sizeof(desc));
//desc.Width = imageData->mWidth;
//desc.Height = imageData->mHeight;
//desc.MipLevels = 1;
//desc.ArraySize = 1;
//desc.Format = GLGI_FORMAT_R8G8B8A8_UNORM;
//desc.SampleDesc.Count = 1;
//desc.Usage = GL10_USAGE_DYNAMIC;
//desc.CPUAccessFlags = GL10_CPU_ACCESS_WRITE;
//desc.BindFlags = GL10_BIND_SHADER_RESOURCE;
//IGL10Texture2D* d3DTexture = NULL;
//GLCHECK(mGLDevice->CreateTexture2D(&desc, NULL, &d3DTexture));
//aWidth = imageData->mWidth;
//aHeight = imageData->mHeight;
//GL10_MAPPED_TEXTURE2D mapTex;
//GLCHECK(d3DTexture->Map(GL10CalcSubresource(0, 0, 1), GL10_MAP_WRITE_DISCARD, 0, &mapTex));
//uint8* destPtr = (uint8*) mapTex.pData;
//uint8* srcPtr = (uint8*) imageData->mBits;
//for (int y = 0; y < imageData->mHeight; y++)
//{
// memcpy(destPtr, srcPtr, aWidth*sizeof(uint32));
// srcPtr += aWidth*sizeof(uint32);
// destPtr += mapTex.RowPitch;
//}
//d3DTexture->Unmap(0);
//GL10_SHADER_RESOURCE_VIEW_DESC srDesc;
//srDesc.Format = desc.Format;
//srDesc.ViewDimension = GL10_SRV_DIMENSION_TEXTURE2D;
//srDesc.Texture2D.MostDetailedMip = 0;
//srDesc.Texture2D.MipLevels = 1;
//
//GLCHECK(mGLDevice->CreateShaderResourceView(d3DTexture, &srDesc, &d3DShaderResourceView));
//GLTexture* aTexture = new GLTexture();
//aTexture->mWidth = aWidth;
//aTexture->mHeight = aHeight;
//aTexture->mGLTexture = d3DShaderResourceView;
//aTexture->AddRef();
//return aTexture;
} }
Shader* GLRenderDevice::LoadShader(const StringImpl& fileName) Shader* GLRenderDevice::LoadShader(const StringImpl& fileName, VertexDefinition* vertexDefinition)
{ {
GLShader* glShader = new GLShader(); GLShader* glShader = new GLShader();
glShader->mVertexSize = sizeof(GLVertex3D);
glShader->mGLVertexShader = bf_glCreateShader(GL_VERTEX_SHADER); glShader->mGLVertexShader = bf_glCreateShader(GL_VERTEX_SHADER);
glShader->mGLFragmentShader = bf_glCreateShader(GL_FRAGMENT_SHADER); glShader->mGLFragmentShader = bf_glCreateShader(GL_FRAGMENT_SHADER);
@ -963,11 +714,11 @@ Shader* GLRenderDevice::LoadShader(const StringImpl& fileName)
GLint fragProgramLen = 0; GLint fragProgramLen = 0;
#ifdef BF_PLATFORM_OPENGL_ES2 #ifdef BF_PLATFORM_OPENGL_ES2
GLchar* vertProgram = (GLchar*)LoadBinaryData(fileName + L"_es.vert", &vertProgramLen); GLchar* vertProgram = (GLchar*)LoadBinaryData(fileName + "_es.vert", &vertProgramLen);
GLchar* fragProgram = (GLchar*)LoadBinaryData(fileName + L"_es.frag", &fragProgramLen); GLchar* fragProgram = (GLchar*)LoadBinaryData(fileName + "_es.frag", &fragProgramLen);
#else #else
GLchar* vertProgram = (GLchar*)LoadBinaryData(fileName + L".vert", &vertProgramLen); GLchar* vertProgram = (GLchar*)LoadBinaryData(fileName + ".vert", &vertProgramLen);
GLchar* fragProgram = (GLchar*)LoadBinaryData(fileName + L".frag", &fragProgramLen); GLchar* fragProgram = (GLchar*)LoadBinaryData(fileName + ".frag", &fragProgramLen);
#endif #endif
if ((vertProgram == NULL) || (fragProgram == NULL)) if ((vertProgram == NULL) || (fragProgram == NULL))
@ -1004,7 +755,6 @@ Shader* GLRenderDevice::LoadShader(const StringImpl& fileName)
bf_glAttachShader(glShader->mGLProgram, glShader->mGLFragmentShader); bf_glAttachShader(glShader->mGLProgram, glShader->mGLFragmentShader);
bf_glLinkProgram(glShader->mGLProgram); bf_glLinkProgram(glShader->mGLProgram);
bf_glUseProgram(glShader->mGLProgram);
glShader->mAttribPosition = bf_glGetAttribLocation(glShader->mGLProgram, "position"); glShader->mAttribPosition = bf_glGetAttribLocation(glShader->mGLProgram, "position");
glShader->mAttribTexCoord0 = bf_glGetAttribLocation(glShader->mGLProgram, "texCoord0"); glShader->mAttribTexCoord0 = bf_glGetAttribLocation(glShader->mGLProgram, "texCoord0");
@ -1012,113 +762,148 @@ Shader* GLRenderDevice::LoadShader(const StringImpl& fileName)
glShader->mAttribTex0 = bf_glGetUniformLocation(glShader->mGLProgram, "tex"); glShader->mAttribTex0 = bf_glGetUniformLocation(glShader->mGLProgram, "tex");
glShader->mAttribTex1 = bf_glGetUniformLocation(glShader->mGLProgram, "tex2"); glShader->mAttribTex1 = bf_glGetUniformLocation(glShader->mGLProgram, "tex2");
if (glShader->mAttribPosition >= 0)
bf_glEnableVertexAttribArray(glShader->mAttribPosition);
if (glShader->mAttribTexCoord0 >= 0)
bf_glEnableVertexAttribArray(glShader->mAttribTexCoord0);
if (glShader->mAttribColor >= 0)
bf_glEnableVertexAttribArray(glShader->mAttribColor);
return glShader; return glShader;
} }
void GLRenderDevice::SetShader(Shader* shader) void GLRenderDevice::PhysSetRenderState(RenderState* renderState)
{ {
mShaderChanged = true; mCurShader = (GLShader*)renderState->mShader;
mCurShader = shader; if (mCurShader != NULL)
{
bf_glUseProgram(mCurShader->mGLProgram);
GLRenderDevice* aRenderDevice = (GLRenderDevice*)gBFApp->mRenderDevice;
//TODO: Cache more
GLfloat matrix[4][4];
CreateOrthographicOffCenter(0.0f, (float)mPhysRenderWindow->mWidth, (float)mPhysRenderWindow->mHeight, 0.0f, -100.0f, 100.0f, matrix);
GLint matrixLoc = bf_glGetUniformLocation(mCurShader->mGLProgram, "screenMatrix");
//BF_ASSERT(matrixLoc >= 0);
if (matrixLoc >= 0)
bf_glUniformMatrix4fv(matrixLoc, 1, false, (float*)matrix);
} }
void GLRenderDevice::PhysSetAdditive(bool additive) if (renderState->mClipped)
{ {
if (additive) glEnable(GL_SCISSOR_TEST);
glBlendFunc(GL_SRC_ALPHA, GL_ONE); glScissor((GLsizei)renderState->mClipRect.mX,
mPhysRenderWindow->mHeight - (GLsizei)renderState->mClipRect.mY - (GLsizei)renderState->mClipRect.mHeight,
(GLsizei)renderState->mClipRect.mWidth, (GLsizei)renderState->mClipRect.mHeight);
}
else else
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); {
mCurAdditive = additive; glDisable(GL_SCISSOR_TEST);
} }
void GLRenderDevice::SetClip(float x, float y, float width, float height) mPhysRenderState = renderState;
{
//TODO: Store state in draw batcher
mCurDrawLayer->Flush();
NOT_IMPL;
/*GL10_RECT rects[1];
rects[0].left = (int) x;
rects[0].right = (int) (x + width);
rects[0].top = (int) y;
rects[0].bottom = (int) (y + height);
mGLDevice->RSSetScissorRects(1, rects);
mGLDevice->RSSetState(mGLRasterizerStateClipped);*/
}
void GLRenderDevice::DisableClip()
{
mCurDrawLayer->Flush();
NOT_IMPL;
//mGLDevice->RSSetState(mGLRasterizerStateUnclipped);
} }
Texture* GLRenderDevice::CreateRenderTarget(int width, int height, bool destAlpha) Texture* GLRenderDevice::CreateRenderTarget(int width, int height, bool destAlpha)
{ {
NOT_IMPL; NOT_IMPL;
}
//IGL10ShaderResourceView* d3DShaderResourceView = NULL;
// void GLRenderDevice::SetRenderState(RenderState* renderState)
//int aWidth = 0; {
//int aHeight = 0; mCurRenderState = renderState;
// }
//// Create the render target texture
//GL10_TEXTURE2D_DESC desc;
//ZeroMemory(&desc, sizeof(desc)); void GLSetTextureCmd::Render(RenderDevice* renderDevice, RenderWindow* renderWindow)
//desc.Width = width; {
//desc.Height = height; /*#ifdef BF_PLATFORM_OPENGL_ES2
//desc.MipLevels = 1; //bf_glClientActiveTexture(GL_TEXTURE0);
//desc.ArraySize = 1; glActiveTexture(GL_TEXTURE0);
//desc.Format = GLGI_FORMAT_R8G8B8A8_UNORM; glBindTexture(GL_TEXTURE_2D, ((GLTexture*)mTexture)->mGLTexture);
//desc.SampleDesc.Count = 1; glUniform1i(curShader->mAttribTex0, 0);
//UINT qualityLevels = 0;
//bf_glClientActiveTexture(GL_TEXTURE1);
//int samples = 1;
//GLCHECK(mGLDevice->CheckMultisampleQualityLevels(GLGI_FORMAT_R8G8B8A8_UNORM, samples, &qualityLevels)); glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, ((GLTexture*)mTexture)->mGLTexture2);
//desc.SampleDesc.Count = samples; glUniform1i(curShader->mAttribTex1, 1);
//desc.SampleDesc.Quality = qualityLevels-1;
//glEnable(GL_TEXTURE_2D);
//desc.Usage = GL10_USAGE_DEFAULT; #else
//desc.CPUAccessFlags = 0; //GL10_CPU_ACCESS_WRITE; glActiveTexture(GL_TEXTURE0 + mTextureIdx);
//desc.BindFlags = GL10_BIND_SHADER_RESOURCE | GL10_BIND_RENDER_TARGET; glBindTexture(GL_TEXTURE_2D, ((GLTexture*)mTexture)->mGLTexture);
#endif*/
//IGL10Texture2D* d3DTexture = NULL;
//GLCHECK(mGLDevice->CreateTexture2D(&desc, NULL, &d3DTexture)); auto glTexture = (GLTexture*)mTexture;
auto glRenderDevice = (GLRenderDevice*)renderDevice;
//aWidth = width;
//aHeight = height; if (glRenderDevice->mBlankTexture == 0)
{
//GL10_SHADER_RESOURCE_VIEW_DESC srDesc; glGenTextures(1, &glRenderDevice->mBlankTexture);
//srDesc.Format = desc.Format; glBindTexture(GL_TEXTURE_2D, glRenderDevice->mBlankTexture);
//srDesc.ViewDimension = GL10_SRV_DIMENSION_TEXTURE2D; glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
//srDesc.Texture2D.MostDetailedMip = 0; glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
//srDesc.Texture2D.MipLevels = 1; glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
//if (qualityLevels != 0)
//{ /*if (bf_glCompressedTexImage2D != NULL)
// srDesc.ViewDimension = GL10_SRV_DIMENSION_TEXTURE2DMS; {
//} uint64 hwData = 0;
bf_glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG, 4, 4, 0,
//GLCHECK(mGLDevice->CreateShaderResourceView(d3DTexture, &srDesc, &d3DShaderResourceView)); sizeof(hwData), (uint8*)&hwData);
// }
//IGL10RenderTargetView* d3DRenderTargetView; else*/
//GLCHECK(mGLDevice->CreateRenderTargetView(d3DTexture, NULL, &d3DRenderTargetView)); {
uint16 color = 0;
//GLTexture* aRenderTarget = new GLTexture(); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0,
//aRenderTarget->mWidth = width; GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, &color);
//aRenderTarget->mHeight = height; }
//aRenderTarget->mRenderDevice = this; glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
//aRenderTarget->mGLTexture = d3DShaderResourceView; }
//aRenderTarget->mGLRenderTargetView = d3DRenderTargetView;
//aRenderTarget->AddRef(); if (glTexture->mImageData != NULL)
//return aRenderTarget; {
glTexture->mGLTexture2 = glRenderDevice->mBlankTexture;
int texCount = 1;
//texCount = (imageData->mHWBitsType == HWBITS_PVRTC_2X4BPPV1) ? 2 : 1;
for (int texNum = 0; texNum < 2/*texCount*/; texNum++)
{
GLuint glTextureID;
glGenTextures(1, &glTextureID);
glBindTexture(GL_TEXTURE_2D, glTextureID);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
//if (imageData->mHWBits != NULL)
//{
// int internalFormat = (imageData->mHWBitsType == HWBITS_PVRTC_2BPPV1) ?
// GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG :
// GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;
// int texSize = imageData->mHWBitsLength / texCount;
// bf_glCompressedTexImage2D(GL_TEXTURE_2D, 0, internalFormat, imageData->mWidth, imageData->mHeight, 0,
// texSize, (uint8*)imageData->mHWBits /*+ (texNum * texSize)*/);
//}
//else
{
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, glTexture->mImageData->mWidth, glTexture->mImageData->mHeight, 0,
GL_RGBA, GL_UNSIGNED_BYTE, glTexture->mImageData->mBits);
}
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
if (texNum == 0)
glTexture->mGLTexture = glTextureID;
else
glTexture->mGLTexture2 = glTextureID;
}
glTexture->mImageData->Deref();
glTexture->mImageData = NULL;
}
bf_glActiveTexture(GL_TEXTURE0 + mTextureIdx);
//glUniform1i(curShader->mAttribTex0, 0);
glBindTexture(GL_TEXTURE_2D, glTexture->mGLTexture);
} }

50
BeefySysLib/platform/sdl/GLRenderDevice.h
View file

@ -1,11 +1,12 @@
#pragma once #pragma once
#include "Common.h" #include "Common.h"
#include "util/Dictionary.h"
#ifdef BF_PLATFORM_OPENGL_ES2 #ifdef BF_PLATFORM_OPENGL_ES2
#include "SDL_opengles2.h" #include <SDL2/SDL_opengles2.h>
#else #else
#include "SDL_opengl.h" #include <SDL2/SDL_opengl.h>
#endif #endif
#include "gfx/Shader.h" #include "gfx/Shader.h"
@ -26,6 +27,7 @@ public:
GLRenderDevice* mRenderDevice; GLRenderDevice* mRenderDevice;
GLuint mGLTexture; GLuint mGLTexture;
GLuint mGLTexture2; GLuint mGLTexture2;
ImageData* mImageData;
//IGL10RenderTargetView* mGLRenderTargetView; //IGL10RenderTargetView* mGLRenderTargetView;
public: public:
@ -33,6 +35,7 @@ public:
~GLTexture(); ~GLTexture();
virtual void PhysSetAsTarget(); virtual void PhysSetAsTarget();
virtual void Blt(ImageData* imageData, int x, int y) override;
}; };
class GLShaderParam : public ShaderParam class GLShaderParam : public ShaderParam
@ -48,7 +51,7 @@ public:
virtual void SetFloat4(float x, float y, float z, float w) override; virtual void SetFloat4(float x, float y, float z, float w) override;
}; };
typedef std::map<String, GLShaderParam*> GLShaderParamMap; typedef Dictionary<String, GLShaderParam*> GLShaderParamMap;
class GLShader : public Shader class GLShader : public Shader
{ {
@ -73,25 +76,36 @@ public:
virtual ShaderParam* GetShaderParam(const StringImpl& name) override; virtual ShaderParam* GetShaderParam(const StringImpl& name) override;
}; };
class GLSetTextureCmd : public RenderCmd
{
public:
int mTextureIdx;
Texture* mTexture;
public:
virtual void Render(RenderDevice* renderDevice, RenderWindow* renderWindow) override;
};
class GLDrawBatch : public DrawBatch class GLDrawBatch : public DrawBatch
{ {
public: public:
//IGL10Buffer* mGLBuffer; //IGL10Buffer* mGLBuffer;
public: public:
GLDrawBatch(int minVtxSize = 0, int minIdxSize = 0); GLDrawBatch();
~GLDrawBatch(); ~GLDrawBatch();
virtual void Lock(); //virtual void Lock();
virtual void Draw(); virtual void Render(RenderDevice* renderDevice, RenderWindow* renderWindow) override;
}; };
class GLDrawLayer : public DrawLayer class GLDrawLayer : public DrawLayer
{ {
public: public:
virtual DrawBatch* CreateDrawBatch(); virtual DrawBatch* CreateDrawBatch();
virtual DrawBatch* AllocateBatch(int minVtxCount, int minIdxCount) override; virtual RenderCmd* CreateSetTextureCmd(int textureIdx, Texture* texture) override;
virtual void FreeBatch(DrawBatch* drawBatch) override; virtual void SetShaderConstantData(int usageIdx, int slotIdx, void* constData, int size) override;
public: public:
GLDrawLayer(); GLDrawLayer();
@ -136,9 +150,11 @@ public:
//IGL10RasterizerState* mGLRasterizerStateClipped; //IGL10RasterizerState* mGLRasterizerStateClipped;
//IGL10RasterizerState* mGLRasterizerStateUnclipped; //IGL10RasterizerState* mGLRasterizerStateUnclipped;
GLuint mGLVAO;
GLuint mGLVertexBuffer; GLuint mGLVertexBuffer;
GLuint mGLIndexBuffer; GLuint mGLIndexBuffer;
GLuint mBlankTexture; GLuint mBlankTexture;
GLShader* mCurShader;
bool mHasVSync; bool mHasVSync;
@ -146,10 +162,11 @@ public:
GLDrawBatch* mFreeBatchHead; GLDrawBatch* mFreeBatchHead;
public: public:
virtual void PhysSetAdditive(bool additive); //virtual void PhysSetAdditive(bool additive);
virtual void PhysSetShader(Shader* shaderPass); //virtual void PhysSetShader(Shader* shaderPass);
virtual void PhysSetRenderWindow(RenderWindow* renderWindow); virtual void PhysSetRenderWindow(RenderWindow* renderWindow);
virtual void PhysSetRenderTarget(Texture* renderTarget); virtual void PhysSetRenderState(RenderState* renderState) override;
virtual void PhysSetRenderTarget(Texture* renderTarget) override;
public: public:
GLRenderDevice(); GLRenderDevice();
@ -159,13 +176,16 @@ public:
void FrameStart() override; void FrameStart() override;
void FrameEnd() override; void FrameEnd() override;
Texture* LoadTexture(ImageData* imageData, bool additive) override; Texture* LoadTexture(ImageData* imageData, int flags) override;
Shader* LoadShader(const StringImpl& fileName) override; Shader* LoadShader(const StringImpl& fileName, VertexDefinition* vertexDefinition) override;
Texture* CreateRenderTarget(int width, int height, bool destAlpha) override; Texture* CreateRenderTarget(int width, int height, bool destAlpha) override;
void SetShader(Shader* shader) override; virtual Texture* CreateDynTexture(int width, int height) override { return NULL; }
virtual void SetRenderState(RenderState* renderState) override;
/*void SetShader(Shader* shader) override;
virtual void SetClip(float x, float y, float width, float height) override; virtual void SetClip(float x, float y, float width, float height) override;
virtual void DisableClip() override; virtual void DisableClip() override;*/
}; };
NS_BF_END; NS_BF_END;

390
BeefySysLib/platform/sdl/SdlBFApp.cpp
View file

@ -1,6 +1,7 @@
#include "SdlBFApp.h" #include "SdlBFApp.h"
#include "GLRenderDevice.h" #include "GLRenderDevice.h"
#include "SDL.h" #include "platform/PlatformHelper.h"
#include <SDL2/SDL.h>
USING_NS_BF; USING_NS_BF;
@ -9,6 +10,7 @@ USING_NS_BF;
#pragma comment(lib, "imm32.lib") #pragma comment(lib, "imm32.lib")
#pragma comment(lib, "version.lib") #pragma comment(lib, "version.lib")
SdlBFWindow::SdlBFWindow(BFWindow* parent, const StringImpl& title, int x, int y, int width, int height, int windowFlags) SdlBFWindow::SdlBFWindow(BFWindow* parent, const StringImpl& title, int x, int y, int width, int height, int windowFlags)
{ {
int sdlWindowFlags = 0; int sdlWindowFlags = 0;
@ -22,6 +24,10 @@ SdlBFWindow::SdlBFWindow(BFWindow* parent, const StringImpl& title, int x, int y
mSDLWindow = SDL_CreateWindow(title.c_str(), x, y, width, height, sdlWindowFlags); mSDLWindow = SDL_CreateWindow(title.c_str(), x, y, width, height, sdlWindowFlags);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
if (!SDL_GL_CreateContext(mSDLWindow)) if (!SDL_GL_CreateContext(mSDLWindow))
{ {
BF_FATAL(StrFormat("Unable to create OpenGL context: %s", SDL_GetError()).c_str()); BF_FATAL(StrFormat("Unable to create OpenGL context: %s", SDL_GetError()).c_str());
@ -29,19 +35,16 @@ SdlBFWindow::SdlBFWindow(BFWindow* parent, const StringImpl& title, int x, int y
exit(2); exit(2);
} }
glEnable(GL_DEBUG_OUTPUT);
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glEnable(GL_BLEND); glEnable(GL_BLEND);
//glBlendFunc(GL_SRC_ALPHA, GL_ONE);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
//glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
#ifndef BF_PLATFORM_OPENGL_ES2 #ifndef BF_PLATFORM_OPENGL_ES2
glEnableClientState(GL_INDEX_ARRAY); //glEnableClientState(GL_INDEX_ARRAY);
#endif #endif
//glEnableClientState(GL_VERTEX_ARRAY);
//glEnableClientState(GL_TEXTURE_COORD_ARRAY);
//glEnableClientState(GL_COLOR_ARRAY);
mIsMouseInside = false; mIsMouseInside = false;
mRenderWindow = new GLRenderWindow((GLRenderDevice*)gBFApp->mRenderDevice, mSDLWindow); mRenderWindow = new GLRenderWindow((GLRenderDevice*)gBFApp->mRenderDevice, mSDLWindow);
mRenderWindow->mWindow = this; mRenderWindow->mWindow = this;
@ -60,321 +63,13 @@ SdlBFWindow::~SdlBFWindow()
bool SdlBFWindow::TryClose() bool SdlBFWindow::TryClose()
{ {
SdlBFApp* app = (SdlBFApp*)gBFApp; SdlBFApp* app = (SdlBFApp*)gBFApp;
SdlWindowMap::iterator itr = app->mSdlWindowMap.find(SDL_GetWindowID(mSDLWindow)); app->mSdlWindowMap.Remove(SDL_GetWindowID(mSDLWindow));
app->mSdlWindowMap.erase(itr);
SDL_DestroyWindow(mSDLWindow); SDL_DestroyWindow(mSDLWindow);
mSDLWindow = NULL; mSDLWindow = NULL;
return true; return true;
} }
//LRESULT SdlBFWindow::WindowProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
//{
// SdlBFApp* app = (SdlBFApp*) gBFApp;
//
// switch (Msg)
// {
// case WM_CLOSE:
// {
// if (mCloseQueryFunc(this) != 0)
// gBFApp->RemoveWindow(this);
// return 0;
// }
// break;
// case WM_DESTROY:
// /*if (mFlags & BFWINDOW_QUIT_ON_CLOSE)
// {
// gBFApp->mRunning = false;
// }*/
// mHWnd = NULL;
// break;
// }
//
// LRESULT result = 0;
// bool doResult = false;
//
// if (!app->mInMsgProc)
// {
// app->mInMsgProc = true;
//
// switch (Msg)
// {
//
// case WM_SIZE:
// mRenderWindow->Resized();
// if (mMovedFunc != NULL)
// mMovedFunc(this);
// break;
// case WM_PAINT:
// break;
// case WM_LBUTTONDOWN:
// case WM_RBUTTONDOWN:
// case WM_MBUTTONDOWN:
// case WM_LBUTTONDBLCLK:
// case WM_RBUTTONDBLCLK:
// case WM_LBUTTONUP:
// case WM_RBUTTONUP:
// case WM_MBUTTONUP:
// case WM_MOUSEWHEEL:
// case WM_MOUSEMOVE:
// {
// int x = (short) LOWORD(lParam);
// int y = (short) HIWORD(lParam);
//
// bool releaseCapture = false;
//
// POINT point = {x, y};
// ::ClientToScreen(hWnd, &point);
// HWND windowAtPoint = ::WindowFromPoint(point);
//
// bool isMouseOver = windowAtPoint == hWnd;
//
// if ((!mIsMouseInside) && (isMouseOver))
// {
// TRACKMOUSEEVENT tme;
// tme.cbSize = sizeof(TRACKMOUSEEVENT);
// tme.dwFlags = TME_LEAVE;
// tme.hwndTrack = hWnd;
// TrackMouseEvent(&tme);
// mIsMouseInside = true;
// }
//
// if ((mIsMouseInside) && (!isMouseOver))
// {
// mIsMouseInside = false;
// mMouseLeaveFunc(this);
// }
//
// switch (Msg)
// {
// case WM_LBUTTONDOWN:
// SetCapture(hWnd);
// mMouseDownFunc(this, x, y, 0, 1);
// break;
// case WM_RBUTTONDOWN:
// SetCapture(hWnd);
// mMouseDownFunc(this, x, y, 1, 1);
// break;
// case WM_MBUTTONDOWN:
// SetCapture(hWnd);
// mMouseDownFunc(this, x, y, 2, 1);
// break;
// case WM_LBUTTONDBLCLK:
// SetCapture(hWnd);
// mMouseDownFunc(this, x, y, 0, 2);
// break;
// case WM_RBUTTONDBLCLK:
// SetCapture(hWnd);
// mMouseDownFunc(this, x, y, 1, 2);
// break;
// case WM_MBUTTONDBLCLK:
// SetCapture(hWnd);
// mMouseDownFunc(this, x, y, 2, 2);
// break;
// case WM_LBUTTONUP:
// releaseCapture = true;
// mMouseUpFunc(this, x, y, 0);
// break;
// case WM_RBUTTONUP:
// releaseCapture = true;
// mMouseUpFunc(this, x, y, 1);
// break;
// case WM_MBUTTONUP:
// releaseCapture = true;
// mMouseUpFunc(this, x, y, 2);
// break;
// case WM_MOUSEWHEEL:
// {
// POINT pt = {x, y};
// ScreenToClient(mHWnd, &pt);
//
// int delta = ((int16)HIWORD(wParam)) / 120;
// mMouseWheelFunc(this, pt.x, pt.y, delta);
// }
// break;
// case WM_MOUSEMOVE:
// {
// mMouseMoveFunc(this, x, y);
//
// if ((wParam != 0) && (gBFApp->mWindowList.size() > 1))
// {
// // See if our mouse is down and has entered into another window's space
// POINT point = {x, y};
// ::ClientToScreen(hWnd, &point);
//
// HWND windowAtPoint = ::WindowFromPoint(point);
//
// BFWindowList::iterator itr = gBFApp->mWindowList.begin();
// while (itr != gBFApp->mWindowList.end())
// {
// SdlBFWindow* aWindow = (SdlBFWindow*) *itr;
// if (aWindow != this)
// {
// if (aWindow->mHWnd == windowAtPoint)
// {
// POINT clientPt = point;
// ::ScreenToClient(aWindow->mHWnd, &clientPt);
// aWindow->mMouseProxyMoveFunc(this, clientPt.x, clientPt.y);
// aWindow->mIsMouseInside = true;
// }
// else if (aWindow->mIsMouseInside)
// {
// aWindow->mMouseLeaveFunc(this);
// aWindow->mIsMouseInside = false;
// }
// }
// ++itr;
// }
// }
// }
// break;
// }
//
// if (releaseCapture)
// {
// ReleaseCapture();
//
// BFWindowList::iterator itr = gBFApp->mWindowList.begin();
// while (itr != gBFApp->mWindowList.end())
// {
// SdlBFWindow* aWindow = (SdlBFWindow*) *itr;
// if ((aWindow != this) && (aWindow->mIsMouseInside))
// {
// aWindow->mMouseLeaveFunc(this);
// aWindow->mIsMouseInside = false;
// }
// ++itr;
// }
// }
// }
// break;
//
// case WM_COMMAND:
// {
// SdlBFMenu* aMenu = mMenuIDMap[(uint32)wParam];
// if (aMenu != NULL)
// mMenuItemSelectedFunc(this, aMenu);
// }
// break;
// case WM_INITMENUPOPUP:
// {
// HMENU hMenu = (HMENU) wParam;
// SdlBFMenu* aMenu = mHMenuMap[hMenu];
// if (aMenu != NULL)
// mMenuItemSelectedFunc(this, aMenu);
// }
// break;
//
// case WM_MOUSEACTIVATE:
// if (mFlags & BFWINDOW_NO_MOUSE_ACTIVATE)
// {
// doResult = true;
// result = MA_NOACTIVATE;
// }
// break;
//
// case WM_KILLFOCUS:
// mLostFocusFunc(this);
// break;
// case WM_SETFOCUS:
// mGotFocusFunc(this);
// break;
// case WM_MOUSELEAVE:
// mIsMouseInside = false;
// mMouseLeaveFunc(this);
// break;
//
// case WM_CHAR:
// mKeyCharFunc(this, (WCHAR)wParam);
// break;
// case WM_SYSKEYDOWN:
// case WM_KEYDOWN:
// {
// int keyCode = (int) wParam;
// mIsKeyDown[keyCode] = true;
//
// WinMenuIDMap::iterator itr = mMenuIDMap.begin();
// while (itr != mMenuIDMap.end())
// {
// SdlBFMenu* aMenu = itr->second;
// if ((aMenu->mKeyCode == keyCode) &&
// (aMenu->mKeyShift == mIsKeyDown[VK_SHIFT]) &&
// (aMenu->mKeyCtrl == mIsKeyDown[VK_CONTROL]) &&
// (aMenu->mKeyAlt == mIsKeyDown[VK_MENU]))
// {
// mMenuItemSelectedFunc(this, aMenu);
// doResult = true;
// break;
// }
// ++itr;
// }
// mKeyDownFunc(this, (int) wParam, (lParam & 0x7FFF) != 0);
// }
// break;
// case WM_SYSCHAR:
// {
// int keyCode = toupper((int) wParam);
//
// WinMenuIDMap::iterator itr = mMenuIDMap.begin();
// while (itr != mMenuIDMap.end())
// {
// SdlBFMenu* aMenu = itr->second;
// if ((aMenu->mKeyCode == keyCode) &&
// (aMenu->mKeyShift == mIsKeyDown[VK_SHIFT]) &&
// (aMenu->mKeyCtrl == mIsKeyDown[VK_CONTROL]) &&
// (aMenu->mKeyAlt == mIsKeyDown[VK_MENU]))
// {
// doResult = true;
// break;
// }
// ++itr;
// }
// }
// break;
// case WM_SYSKEYUP:
// case WM_KEYUP:
// {
// int keyCode = (int) wParam;
// if (mIsKeyDown[keyCode])
// {
// mKeyUpFunc(this, (int) wParam);
// mIsKeyDown[keyCode] = false;
// }
// }
// break;
//
// case WM_TIMER:
// if (gBFApp->mSysDialogCnt == 0)
// gBFApp->Process();
// break;
//
// case WM_SETCURSOR:
// gBFApp->PhysSetCursor();
// break;
//
// case WM_MOVING:
// if (mMovedFunc != NULL)
// mMovedFunc(this);
// break;
// case WM_SIZING:
// mRenderWindow->Resized();
// if (mMovedFunc != NULL)
// mMovedFunc(this);
// if (gBFApp->mSysDialogCnt == 0)
// gBFApp->Process();
// break;
// }
//
//
// app->mInMsgProc = false;
// }
//
// if (doResult)
// return result;
//
// return DefWindowProc(hWnd, Msg, wParam, lParam);
//}
static int SDLConvertScanCode(int scanCode) static int SDLConvertScanCode(int scanCode)
{ {
if ((scanCode >= SDL_SCANCODE_A) && (scanCode <= SDL_SCANCODE_Z)) if ((scanCode >= SDL_SCANCODE_A) && (scanCode <= SDL_SCANCODE_Z))
@ -461,29 +156,20 @@ extern HINSTANCE gDLLInstance;
SdlBFApp::SdlBFApp() SdlBFApp::SdlBFApp()
{ {
//_CrtSetReportHook(SdlBFReportHook);
mRunning = false; mRunning = false;
mRenderDevice = NULL; mRenderDevice = NULL;
wchar_t aStr[MAX_PATH]; Beefy::String exePath;
#ifdef _WIN32 BfpGetStrHelper(exePath, [](char* outStr, int* inOutStrSize, BfpResult* result)
GetModuleFileNameW(gDLLInstance, aStr, MAX_PATH);
#else
GetModuleFileNameW(NULL, aStr, MAX_PATH);
#endif
if (aStr[0] == '!')
{ {
new SdlBFWindow(NULL, "", 0, 0, 0, 0, 0); BfpSystem_GetExecutablePath(outStr, inOutStrSize, (BfpSystemResult*)result);
} });
mInstallDir = aStr; mInstallDir = GetFileDir(exePath) + "/";
int lastSlash = std::max((int)mInstallDir.rfind('\\'), (int)mInstallDir.rfind('/')); int lastSlash = std::max((int)mInstallDir.LastIndexOf('\\'), (int)mInstallDir.LastIndexOf('/'));
if (lastSlash != -1) if (lastSlash != -1)
mInstallDir = mInstallDir.substr(0, lastSlash); mInstallDir = mInstallDir.Substring(0, lastSlash);
//TODO: We're not properly using DataDir vs InstallDir //TODO: We're not properly using DataDir vs InstallDir
#if (!defined BFSYSLIB_DYNAMIC) && (defined BF_RESOURCES_REL_DIR) #if (!defined BFSYSLIB_DYNAMIC) && (defined BF_RESOURCES_REL_DIR)
@ -492,8 +178,6 @@ SdlBFApp::SdlBFApp()
mInstallDir += "/"; mInstallDir += "/";
//OutputDebugStrF(L"DataDir: %s\n", mInstallDir.c_str());
mDataDir = mInstallDir; mDataDir = mInstallDir;
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMECONTROLLER) < 0) if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMECONTROLLER) < 0)
@ -506,10 +190,9 @@ SdlBFApp::~SdlBFApp()
SdlBFWindow* SdlBFApp::GetSdlWindowFromId(uint32 id) SdlBFWindow* SdlBFApp::GetSdlWindowFromId(uint32 id)
{ {
SdlWindowMap::iterator itr = mSdlWindowMap.find(id); SdlBFWindow* window = NULL;
if (itr != mSdlWindowMap.end()) mSdlWindowMap.TryGetValue(id, &window);
return itr->second; return window;
return NULL;
} }
void SdlBFApp::Init() void SdlBFApp::Init()
@ -623,29 +306,7 @@ void SdlBFWindow::GetPosition(int* x, int* y, int* width, int* height, int* clie
void SdlBFApp::PhysSetCursor() void SdlBFApp::PhysSetCursor()
{ {
//
//static HCURSOR cursors [] =
// {
// ::LoadCursor(NULL, IDC_ARROW),
//
// //TODO: mApp->mHandCursor);
// ::LoadCursor(NULL, IDC_ARROW),
// //TODO: mApp->mDraggingCursor);
// ::LoadCursor(NULL, IDC_ARROW),
// ::LoadCursor(NULL, IDC_IBEAM),
//
// ::LoadCursor(NULL, IDC_NO),
// ::LoadCursor(NULL, IDC_SIZEALL),
// ::LoadCursor(NULL, IDC_SIZENESW),
// ::LoadCursor(NULL, IDC_SIZENS),
// ::LoadCursor(NULL, IDC_SIZENWSE),
// ::LoadCursor(NULL, IDC_SIZEWE),
// ::LoadCursor(NULL, IDC_WAIT),
// NULL
// };
//::SetCursor(cursors[mCursor]);
} }
void SdlBFWindow::SetClientPosition(int x, int y) void SdlBFWindow::SetClientPosition(int x, int y)
@ -681,7 +342,7 @@ void SdlBFApp::SetClipboardData(const StringImpl& format, const void* ptr, int s
SDL_SetClipboardText((const char*)ptr); SDL_SetClipboardText((const char*)ptr);
} }
BFMenu* SdlBFWindow::AddMenuItem(BFMenu* parent, const wchar_t* text, const wchar_t* hotKey, BFSysBitmap* sysBitmap, bool enabled, int checkState, bool radioCheck) BFMenu* SdlBFWindow::AddMenuItem(BFMenu* parent, int insertIdx, const char* text, const char* hotKey, BFSysBitmap* bitmap, bool enabled, int checkState, bool radioCheck)
{ {
return NULL; return NULL;
} }
@ -709,17 +370,18 @@ DrawLayer* SdlBFApp::CreateDrawLayer(BFWindow* window)
drawLayer->mRenderWindow = window->mRenderWindow; drawLayer->mRenderWindow = window->mRenderWindow;
window->mRenderWindow->mDrawLayerList.push_back(drawLayer); window->mRenderWindow->mDrawLayerList.push_back(drawLayer);
} }
drawLayer->mRenderDevice = mRenderDevice;
return drawLayer; return drawLayer;
} }
void SdlBFApp::GetDesktopResolution(int& width, int& height) override void SdlBFApp::GetDesktopResolution(int& width, int& height)
{ {
width = 1024; width = 1024;
height = 768; height = 768;
} }
void SdlBFApp::GetWorkspaceRect(int& x, int& y, int& width, int& height) override void SdlBFApp::GetWorkspaceRect(int& x, int& y, int& width, int& height)
{ {
x = 0; x = 0;
y = 0; y = 0;

21
BeefySysLib/platform/sdl/SdlBFApp.h
View file

@ -3,6 +3,7 @@
#include "BFApp.h" #include "BFApp.h"
#include "BFWindow.h" #include "BFWindow.h"
#include <map> #include <map>
#include "util/Dictionary.h"
struct SDL_Window; struct SDL_Window;
@ -23,17 +24,31 @@ public:
SdlBFWindow(BFWindow* parent, const StringImpl& title, int x, int y, int width, int height, int windowFlags); SdlBFWindow(BFWindow* parent, const StringImpl& title, int x, int y, int width, int height, int windowFlags);
~SdlBFWindow(); ~SdlBFWindow();
virtual void* GetUnderlying() {return mSDLWindow; };
virtual void Destroy() { }
virtual void SetTitle(const char* title) override {}
virtual void SetMinimumSize(int minWidth, int minHeight, bool clientSized) override {}
virtual void GetPlacement(int* normX, int* normY, int* normWidth, int* normHeight, int* showKind) override { }
virtual void Resize(int x, int y, int width, int height, int showKind) override {}
virtual void SetMouseVisible(bool isMouseVisible) override {}
virtual bool TryClose() override; virtual bool TryClose() override;
virtual void GetPosition(int* x, int* y, int* width, int* height, int* clientX, int* clientY, int* clientWidth, int* clientHeight) override; virtual void GetPosition(int* x, int* y, int* width, int* height, int* clientX, int* clientY, int* clientWidth, int* clientHeight) override;
virtual void SetClientPosition(int x, int y) override; virtual void SetClientPosition(int x, int y) override;
virtual void SetAlpha(float alpha, uint32 destAlphaSrcMask, bool isMouseVisible) override; virtual void SetAlpha(float alpha, uint32 destAlphaSrcMask, bool isMouseVisible) override;
virtual BFMenu* AddMenuItem(BFMenu* parent, const wchar_t* text, const wchar_t* hotKey, BFSysBitmap* sysBitmap, bool enabled, int checkState, bool radioCheck); virtual BFMenu* AddMenuItem(BFMenu* parent, int insertIdx, const char* text, const char* hotKey, BFSysBitmap* bitmap, bool enabled, int checkState, bool radioCheck) override;
virtual void ModifyMenuItem(BFMenu* item, const char* text, const char* hotKey, BFSysBitmap* bitmap, bool enabled, int checkState, bool radioCheck) override {}
virtual void RemoveMenuItem(BFMenu* item) override; virtual void RemoveMenuItem(BFMenu* item) override;
virtual void LostFocus(BFWindow* newFocus) override {};
virtual void ModalsRemoved() override; virtual void ModalsRemoved() override;
virtual void SetForeground() override {};
}; };
typedef std::map<uint32, SdlBFWindow*> SdlWindowMap; typedef Dictionary<uint32, SdlBFWindow*> SdlWindowMap;
class SdlBFApp : public BFApp class SdlBFApp : public BFApp
{ {

10
IDE/dist/shaders/Std.frag vendored Normal file
View file

@ -0,0 +1,10 @@
uniform sampler2D tex;
uniform sampler2D tex2;
varying vec4 varying_color;
varying vec2 varying_texCoord0;
void main()
{
vec4 texColor = texture2D(tex, varying_texCoord0);
gl_FragColor = texColor * varying_color;
}

12
IDE/dist/shaders/Std_font.frag vendored Normal file
View file

@ -0,0 +1,12 @@
uniform sampler2D tex;
uniform sampler2D tex2;
varying vec4 varying_color;
varying vec2 varying_texCoord0;
void main()
{
vec4 texColor = texture2D(tex, varying_texCoord0);
float gray = varying_color.r * 0.299 + varying_color.g * 0.587 + varying_color.b * 0.114;
float a = mix(texColor.a, texColor.r, gray);
gl_FragColor = vec4(a, a, a, a) * varying_color;
}

15
IDE/dist/shaders/Std_font.vert vendored Normal file
View file

@ -0,0 +1,15 @@
uniform mat4 screenMatrix;
attribute vec4 position;
attribute vec2 texCoord0;
attribute vec4 color;
varying vec4 varying_color;
varying vec2 varying_texCoord0;
void main()
{
gl_Position = screenMatrix * position;
varying_color = vec4(color.b * color.a, color.g * color.a, color.r * color.a, color.a);
varying_texCoord0 = texCoord0;
}

14
IDE/dist/shaders/Std_font_es.frag vendored Normal file
View file

@ -0,0 +1,14 @@
precision lowp float;
uniform lowp sampler2D tex;
uniform lowp sampler2D tex2;
varying lowp vec4 varying_color;
varying mediump vec2 varying_texCoord0;
void main()
{
lowp vec4 texColor = texture2D(tex, varying_texCoord0);
float gray = varying_color.r * 0.299 + varying_color.g * 0.587 + varying_color.b * 0.114;
float a = mix(texColor.a, texColor.r, gray);
gl_FragColor = vec4(a, a, a, a) * varying_color;
}

17
IDE/dist/shaders/Std_font_es.vert vendored Normal file
View file

@ -0,0 +1,17 @@
precision mediump float;
uniform mat4 screenMatrix;
attribute vec4 position;
attribute vec2 texCoord0;
attribute vec4 color;
precision lowp float;
varying lowp vec4 varying_color;
varying mediump vec2 varying_texCoord0;
void main()
{
gl_Position = screenMatrix * position;
varying_color = vec4(color.b * color.a, color.g * color.a, color.r * color.a, color.a);
varying_texCoord0 = texCoord0;
}