thirdparty/scummvm
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

GRAPHICS: Move opengles2 files to the opengl folder

Browse source
This commit is contained in:
Bastien Bouclet 2016-01-04 22:23:01 +01:00
parent 4c2c1b4d36
commit 6c78bcebe4
22 changed files with 124 additions and 124 deletions
Download patch file Download diff file Expand all files Collapse all files

4
backends/graphics/surfacesdl/surfacesdl-graphics.cpp
View file

@ -389,8 +389,8 @@ Graphics::PixelBuffer SurfaceSdlGraphicsManager::setupScreen(uint screenW, uint
// Setup the box shader used to render the overlay
const char* attributes[] = { "position", "texcoord", NULL };
_boxShader = Graphics::Shader::fromStrings("box", Graphics::BuiltinShaders::boxVertex, Graphics::BuiltinShaders::boxFragment, attributes);
_boxVerticesVBO = Graphics::Shader::createBuffer(GL_ARRAY_BUFFER, sizeof(vertices), vertices);
_boxShader = OpenGL::Shader::fromStrings("box", OpenGL::BuiltinShaders::boxVertex, OpenGL::BuiltinShaders::boxFragment, attributes);
_boxVerticesVBO = OpenGL::Shader::createBuffer(GL_ARRAY_BUFFER, sizeof(vertices), vertices);
_boxShader->enableVertexAttribute("position", _boxVerticesVBO, 2, GL_FLOAT, GL_TRUE, 2 * sizeof(float), 0);
_boxShader->enableVertexAttribute("texcoord", _boxVerticesVBO, 2, GL_FLOAT, GL_TRUE, 2 * sizeof(float), 0);
#endif

4
backends/graphics/surfacesdl/surfacesdl-graphics.h
View file

@ -32,7 +32,7 @@
#undef ARRAYSIZE
#ifdef USE_OPENGL_SHADERS
#include "graphics/opengles2/shader.h"
#include "graphics/opengl/shader.h"
#endif
#include "backends/graphics/graphics.h"
@ -189,7 +189,7 @@ protected:
OpenGL::FrameBuffer *_frameBuffer;
#ifdef USE_OPENGL_SHADERS
Graphics::Shader *_boxShader;
OpenGL::Shader *_boxShader;
GLuint _boxVerticesVBO;
void drawOverlayOpenGLShaders();

2
backends/platform/android/gfx.cpp
View file

@ -42,7 +42,7 @@
#include "common/endian.h"
#include "common/tokenizer.h"
#include "graphics/conversion.h"
#include "graphics/opengles2/shader.h"
#include "graphics/opengl/shader.h"
#include "graphics/opengl/extensions.h"
#include "backends/platform/android/android.h"

8
backends/platform/android/texture.cpp
View file

@ -41,7 +41,7 @@
#include "base/main.h"
#include "graphics/surface.h"
#include "graphics/opengles2/shader.h"
#include "graphics/opengl/shader.h"
#include "graphics/opengl/extensions.h"
#include "common/rect.h"
@ -55,7 +55,7 @@
// Supported GL extensions
static bool npot_supported = false;
Graphics::Shader * g_box_shader;
OpenGL::Shader * g_box_shader;
GLuint g_verticesVBO;
static inline GLfixed xdiv(int numerator, int denominator) {
@ -86,8 +86,8 @@ void GLESBaseTexture::initGL() {
npot_supported = OpenGL::isExtensionSupported("GL_ARB_texture_non_power_of_two");
const char* attributes[] = { "position", "texcoord", NULL };
g_box_shader = Graphics::Shader::fromStrings("control", Graphics::BuiltinShaders::controlVertex, Graphics::BuiltinShaders::controlFragment, attributes);
g_verticesVBO = Graphics::Shader::createBuffer(GL_ARRAY_BUFFER, sizeof(vertices), vertices);
g_box_shader = OpenGL::Shader::fromStrings("control", OpenGL::BuiltinShaders::controlVertex, OpenGL::BuiltinShaders::controlFragment, attributes);
g_verticesVBO = OpenGL::Shader::createBuffer(GL_ARRAY_BUFFER, sizeof(vertices), vertices);
g_box_shader->enableVertexAttribute("position", g_verticesVBO, 2, GL_FLOAT, GL_TRUE, 2 * sizeof(float), 0);
g_box_shader->enableVertexAttribute("texcoord", g_verticesVBO, 2, GL_FLOAT, GL_TRUE, 2 * sizeof(float), 0);
}

70
engines/grim/gfx_opengl_shaders.cpp
View file

@ -110,7 +110,7 @@ struct GrimVertex {
};
struct TextUserData {
Graphics::Shader * shader;
OpenGL::Shader * shader;
uint32 characters;
Color color;
GLuint texture;
@ -122,7 +122,7 @@ struct FontUserData {
};
struct EMIModelUserData {
Graphics::Shader *_shader;
OpenGL::Shader *_shader;
uint32 _texCoordsVBO;
uint32 _colorMapVBO;
uint32 _verticesVBO;
@ -130,7 +130,7 @@ struct EMIModelUserData {
};
struct ModelUserData {
Graphics::Shader *_shader;
OpenGL::Shader *_shader;
uint32 _meshInfoVBO;
};
@ -290,11 +290,11 @@ void GfxOpenGLS::setupQuadEBO() {
p[5] = start++;
}
_quadEBO = Graphics::Shader::createBuffer(GL_ELEMENT_ARRAY_BUFFER, sizeof(quad_indices), quad_indices, GL_STATIC_DRAW);
_quadEBO = OpenGL::Shader::createBuffer(GL_ELEMENT_ARRAY_BUFFER, sizeof(quad_indices), quad_indices, GL_STATIC_DRAW);
}
void GfxOpenGLS::setupTexturedQuad() {
_smushVBO = Graphics::Shader::createBuffer(GL_ARRAY_BUFFER, sizeof(textured_quad), textured_quad, GL_STATIC_DRAW);
_smushVBO = OpenGL::Shader::createBuffer(GL_ARRAY_BUFFER, sizeof(textured_quad), textured_quad, GL_STATIC_DRAW);
_smushProgram->enableVertexAttribute("position", _smushVBO, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 0);
_smushProgram->enableVertexAttribute("texcoord", _smushVBO, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 2 * sizeof(float));
@ -310,7 +310,7 @@ void GfxOpenGLS::setupTexturedQuad() {
}
void GfxOpenGLS::setupTexturedCenteredQuad() {
_spriteVBO = Graphics::Shader::createBuffer(GL_ARRAY_BUFFER, sizeof(textured_quad_centered), textured_quad_centered, GL_STATIC_DRAW);
_spriteVBO = OpenGL::Shader::createBuffer(GL_ARRAY_BUFFER, sizeof(textured_quad_centered), textured_quad_centered, GL_STATIC_DRAW);
_spriteProgram->enableVertexAttribute("position", _spriteVBO, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), 0);
_spriteProgram->enableVertexAttribute("texcoord", _spriteVBO, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), 3 * sizeof(float));
_spriteProgram->disableVertexAttribute("color", Math::Vector4d(1.0f, 1.0f, 1.0f, 1.0f));
@ -372,26 +372,26 @@ void GfxOpenGLS::setupShaders() {
bool isEMI = g_grim->getGameType() == GType_MONKEY4;
static const char* commonAttributes[] = {"position", "texcoord", NULL};
_backgroundProgram = Graphics::Shader::fromFiles(isEMI ? "emi_background" : "grim_background", commonAttributes);
_smushProgram = Graphics::Shader::fromFiles("smush", commonAttributes);
_textProgram = Graphics::Shader::fromFiles("text", commonAttributes);
_emergProgram = Graphics::Shader::fromFiles("emerg", commonAttributes);
_backgroundProgram = OpenGL::Shader::fromFiles(isEMI ? "emi_background" : "grim_background", commonAttributes);
_smushProgram = OpenGL::Shader::fromFiles("smush", commonAttributes);
_textProgram = OpenGL::Shader::fromFiles("text", commonAttributes);
_emergProgram = OpenGL::Shader::fromFiles("emerg", commonAttributes);
static const char* actorAttributes[] = {"position", "texcoord", "color", "normal", NULL};
_actorProgram = Graphics::Shader::fromFiles(isEMI ? "emi_actor" : "grim_actor", actorAttributes);
_spriteProgram = Graphics::Shader::fromFiles(isEMI ? "emi_actor" : "grim_actor", actorAttributes);
_actorProgram = OpenGL::Shader::fromFiles(isEMI ? "emi_actor" : "grim_actor", actorAttributes);
_spriteProgram = OpenGL::Shader::fromFiles(isEMI ? "emi_actor" : "grim_actor", actorAttributes);
static const char* primAttributes[] = { "position", NULL };
_shadowPlaneProgram = Graphics::Shader::fromFiles("shadowplane", primAttributes);
_primitiveProgram = Graphics::Shader::fromFiles("grim_primitive", primAttributes);
_shadowPlaneProgram = OpenGL::Shader::fromFiles("shadowplane", primAttributes);
_primitiveProgram = OpenGL::Shader::fromFiles("grim_primitive", primAttributes);
if (!isEMI) {
_irisProgram = _primitiveProgram->clone();
_dimProgram = Graphics::Shader::fromFiles("dim", commonAttributes);
_dimProgram = OpenGL::Shader::fromFiles("dim", commonAttributes);
_dimRegionProgram = _dimProgram->clone();
} else {
_dimPlaneProgram = Graphics::Shader::fromFiles("emi_dimplane", primAttributes);
_dimPlaneProgram = OpenGL::Shader::fromFiles("emi_dimplane", primAttributes);
}
setupQuadEBO();
@ -400,7 +400,7 @@ void GfxOpenGLS::setupShaders() {
setupPrimitives();
if (!isEMI) {
_blastVBO = Graphics::Shader::createBuffer(GL_ARRAY_BUFFER, 128 * 16 * sizeof(float), NULL, GL_DYNAMIC_DRAW);
_blastVBO = OpenGL::Shader::createBuffer(GL_ARRAY_BUFFER, 128 * 16 * sizeof(float), NULL, GL_DYNAMIC_DRAW);
}
}
@ -862,8 +862,8 @@ void GfxOpenGLS::drawShadowPlanes() {
ShadowUserData *sud = new ShadowUserData;
_currentShadowArray->userData = sud;
sud->_numTriangles = numTriangles;
sud->_verticesVBO = Graphics::Shader::createBuffer(GL_ARRAY_BUFFER, 3 * numVertices * sizeof(float), vertBuf, GL_STATIC_DRAW);
sud->_indicesVBO = Graphics::Shader::createBuffer(GL_ELEMENT_ARRAY_BUFFER, 3 * numTriangles * sizeof(uint16), idxBuf, GL_STATIC_DRAW);
sud->_verticesVBO = OpenGL::Shader::createBuffer(GL_ARRAY_BUFFER, 3 * numVertices * sizeof(float), vertBuf, GL_STATIC_DRAW);
sud->_indicesVBO = OpenGL::Shader::createBuffer(GL_ELEMENT_ARRAY_BUFFER, 3 * numTriangles * sizeof(uint16), idxBuf, GL_STATIC_DRAW);
delete[] vertBuf;
delete[] idxBuf;
@ -974,7 +974,7 @@ void GfxOpenGLS::drawMesh(const Mesh *mesh) {
const ModelUserData *mud = (const ModelUserData *)mesh->_userData;
if (!mud)
return;
Graphics::Shader *actorShader = mud->_shader;
OpenGL::Shader *actorShader = mud->_shader;
actorShader->use();
actorShader->setUniform("extraMatrix", _matrixStack.top());
@ -1315,11 +1315,11 @@ void GfxOpenGLS::createBitmap(BitmapData *bitmap) {
delete[] texData;
bitmap->freeData();
Graphics::Shader *shader = _backgroundProgram->clone();
OpenGL::Shader *shader = _backgroundProgram->clone();
bitmap->_userData = shader;
if (g_grim->getGameType() == GType_MONKEY4) {
GLuint vbo = Graphics::Shader::createBuffer(GL_ARRAY_BUFFER, bitmap->_numCoords * 4 * sizeof(float), bitmap->_texc, GL_STATIC_DRAW);
GLuint vbo = OpenGL::Shader::createBuffer(GL_ARRAY_BUFFER, bitmap->_numCoords * 4 * sizeof(float), bitmap->_texc, GL_STATIC_DRAW);
shader->enableVertexAttribute("position", vbo, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 0);
shader->enableVertexAttribute("texcoord", vbo, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 2*sizeof(float));
}
@ -1333,7 +1333,7 @@ void GfxOpenGLS::createBitmap(BitmapData *bitmap) {
void GfxOpenGLS::drawBitmap(const Bitmap *bitmap, int dx, int dy, uint32 layer) {
if (g_grim->getGameType() == GType_MONKEY4 && bitmap->_data && bitmap->_data->_texc) {
BitmapData *data = bitmap->_data;
Graphics::Shader *shader = (Graphics::Shader *)data->_userData;
OpenGL::Shader *shader = (OpenGL::Shader *)data->_userData;
GLuint *textures = (GLuint *)bitmap->getTexIds();
glDisable(GL_DEPTH_TEST);
@ -1369,7 +1369,7 @@ void GfxOpenGLS::drawBitmap(const Bitmap *bitmap, int dx, int dy, uint32 layer)
glDisable(GL_BLEND);
}
Graphics::Shader *shader = (Graphics::Shader *)bitmap->_data->_userData;
OpenGL::Shader *shader = (OpenGL::Shader *)bitmap->_data->_userData;
shader->use();
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
@ -1424,7 +1424,7 @@ void GfxOpenGLS::destroyBitmap(BitmapData *bitmap) {
delete[] textures;
bitmap->_texIds = 0;
}
Graphics::Shader *shader = (Graphics::Shader *)bitmap->_userData;
OpenGL::Shader *shader = (OpenGL::Shader *)bitmap->_userData;
if (g_grim->getGameType() == GType_MONKEY4) {
glDeleteBuffers(1, &shader->getAttributeAt(0)._vbo);
}
@ -1584,10 +1584,10 @@ void GfxOpenGLS::createTextObject(TextObject *text) {
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferSubData(GL_ARRAY_BUFFER, 0, numCharacters * 16 * sizeof(float), bufData);
} else {
vbo = Graphics::Shader::createBuffer(GL_ARRAY_BUFFER, numCharacters * 16 * sizeof(float), bufData, GL_STATIC_DRAW);
vbo = OpenGL::Shader::createBuffer(GL_ARRAY_BUFFER, numCharacters * 16 * sizeof(float), bufData, GL_STATIC_DRAW);
}
Graphics::Shader * textShader = _textProgram->clone();
OpenGL::Shader * textShader = _textProgram->clone();
glBindBuffer(GL_ARRAY_BUFFER, vbo);
textShader->enableVertexAttribute("position", vbo, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 0);
@ -1974,15 +1974,15 @@ void GfxOpenGLS::renderZBitmaps(bool render) {
void GfxOpenGLS::createEMIModel(EMIModel *model) {
EMIModelUserData *mud = new EMIModelUserData;
model->_userData = mud;
mud->_verticesVBO = Graphics::Shader::createBuffer(GL_ARRAY_BUFFER, model->_numVertices * 3 * sizeof(float), model->_vertices, GL_STREAM_DRAW);
mud->_verticesVBO = OpenGL::Shader::createBuffer(GL_ARRAY_BUFFER, model->_numVertices * 3 * sizeof(float), model->_vertices, GL_STREAM_DRAW);
mud->_normalsVBO = Graphics::Shader::createBuffer(GL_ARRAY_BUFFER, model->_numVertices * 3 * sizeof(float), model->_normals, GL_STREAM_DRAW);
mud->_normalsVBO = OpenGL::Shader::createBuffer(GL_ARRAY_BUFFER, model->_numVertices * 3 * sizeof(float), model->_normals, GL_STREAM_DRAW);
mud->_texCoordsVBO = Graphics::Shader::createBuffer(GL_ARRAY_BUFFER, model->_numVertices * 2 * sizeof(float), model->_texVerts, GL_STATIC_DRAW);
mud->_texCoordsVBO = OpenGL::Shader::createBuffer(GL_ARRAY_BUFFER, model->_numVertices * 2 * sizeof(float), model->_texVerts, GL_STATIC_DRAW);
mud->_colorMapVBO = Graphics::Shader::createBuffer(GL_ARRAY_BUFFER, model->_numVertices * 4 * sizeof(byte), model->_colorMap, GL_STATIC_DRAW);
mud->_colorMapVBO = OpenGL::Shader::createBuffer(GL_ARRAY_BUFFER, model->_numVertices * 4 * sizeof(byte), model->_colorMap, GL_STATIC_DRAW);
Graphics::Shader * actorShader = _actorProgram->clone();
OpenGL::Shader * actorShader = _actorProgram->clone();
actorShader->enableVertexAttribute("position", mud->_verticesVBO, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), 0);
actorShader->enableVertexAttribute("normal", mud->_normalsVBO, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), 0);
actorShader->enableVertexAttribute("texcoord", mud->_texCoordsVBO, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), 0);
@ -1991,7 +1991,7 @@ void GfxOpenGLS::createEMIModel(EMIModel *model) {
for (uint32 i = 0; i < model->_numFaces; ++i) {
EMIMeshFace * face = &model->_faces[i];
face->_indicesEBO = Graphics::Shader::createBuffer(GL_ELEMENT_ARRAY_BUFFER, face->_faceLength * 3 * sizeof(uint32), face->_indexes, GL_STATIC_DRAW);
face->_indicesEBO = OpenGL::Shader::createBuffer(GL_ELEMENT_ARRAY_BUFFER, face->_faceLength * 3 * sizeof(uint32), face->_indexes, GL_STATIC_DRAW);
}
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
@ -2032,9 +2032,9 @@ void GfxOpenGLS::createMesh(Mesh *mesh) {
ModelUserData *mud = new ModelUserData;
mesh->_userData = mud;
mud->_meshInfoVBO = Graphics::Shader::createBuffer(GL_ARRAY_BUFFER, meshInfo.size() * sizeof(GrimVertex), &meshInfo[0], GL_STATIC_DRAW);
mud->_meshInfoVBO = OpenGL::Shader::createBuffer(GL_ARRAY_BUFFER, meshInfo.size() * sizeof(GrimVertex), &meshInfo[0], GL_STATIC_DRAW);
Graphics::Shader *shader = _actorProgram->clone();
OpenGL::Shader *shader = _actorProgram->clone();
mud->_shader = shader;
shader->enableVertexAttribute("position", mud->_meshInfoVBO, 3, GL_FLOAT, GL_FALSE, sizeof(GrimVertex), 0);
shader->enableVertexAttribute("texcoord", mud->_meshInfoVBO, 2, GL_FLOAT, GL_FALSE, sizeof(GrimVertex), 3 * sizeof(float));

26
engines/grim/gfx_opengl_shaders.h
View file

@ -25,7 +25,7 @@
#include "engines/grim/actor.h"
#include "engines/grim/gfx_base.h"
#include "graphics/opengles2/shader.h"
#include "graphics/opengl/shader.h"
#include "common/stack.h"
#include "common/rect.h"
@ -220,20 +220,20 @@ private:
float _alpha;
int _maxLights;
GLuint _emergTexture;
Graphics::Shader* _emergProgram;
OpenGL::Shader* _emergProgram;
Graphics::Shader* _backgroundProgram;
Graphics::Shader* _actorProgram;
Graphics::Shader* _spriteProgram;
Graphics::Shader* _dimProgram;
Graphics::Shader* _dimPlaneProgram;
Graphics::Shader* _dimRegionProgram;
Graphics::Shader* _smushProgram;
OpenGL::Shader* _backgroundProgram;
OpenGL::Shader* _actorProgram;
OpenGL::Shader* _spriteProgram;
OpenGL::Shader* _dimProgram;
OpenGL::Shader* _dimPlaneProgram;
OpenGL::Shader* _dimRegionProgram;
OpenGL::Shader* _smushProgram;
GLuint _smushVBO, _quadEBO;
Graphics::Shader* _textProgram;
Graphics::Shader* _primitiveProgram;
Graphics::Shader* _irisProgram;
Graphics::Shader* _shadowPlaneProgram;
OpenGL::Shader* _textProgram;
OpenGL::Shader* _primitiveProgram;
OpenGL::Shader* _irisProgram;
OpenGL::Shader* _shadowPlaneProgram;
int _smushWidth;
int _smushHeight;

30
engines/myst3/gfx_opengl_shaders.cpp
View file

@ -58,7 +58,7 @@
#include "math/quat.h"
#include "graphics/opengl/extensions.h"
#include "graphics/opengles2/shader.h"
#include "graphics/opengl/shader.h"
#include "engines/myst3/gfx.h"
#include "engines/myst3/gfx_opengl_texture.h"
@ -89,7 +89,7 @@ void ShaderRenderer::setupQuadEBO() {
p[5] = start++;
}
_quadEBO = Graphics::Shader::createBuffer(GL_ELEMENT_ARRAY_BUFFER, sizeof(quadIndices), quadIndices, GL_STATIC_DRAW);
_quadEBO = OpenGL::Shader::createBuffer(GL_ELEMENT_ARRAY_BUFFER, sizeof(quadIndices), quadIndices, GL_STATIC_DRAW);
}
Math::Vector2d ShaderRenderer::scaled(float x, float y) const {
@ -113,11 +113,11 @@ ShaderRenderer::ShaderRenderer(OSystem *system) :
}
ShaderRenderer::~ShaderRenderer() {
Graphics::Shader::freeBuffer(_boxVBO);
Graphics::Shader::freeBuffer(_cubeVBO);
Graphics::Shader::freeBuffer(_rect3dVBO);
Graphics::Shader::freeBuffer(_textVBO);
Graphics::Shader::freeBuffer(_quadEBO);
OpenGL::Shader::freeBuffer(_boxVBO);
OpenGL::Shader::freeBuffer(_cubeVBO);
OpenGL::Shader::freeBuffer(_rect3dVBO);
OpenGL::Shader::freeBuffer(_textVBO);
OpenGL::Shader::freeBuffer(_quadEBO);
delete _boxShader;
delete _cubeShader;
@ -151,23 +151,23 @@ void ShaderRenderer::init() {
glEnable(GL_DEPTH_TEST);
static const char* attributes[] = { "position", "texcoord", NULL };
_boxShader = Graphics::Shader::fromFiles("myst3_box", attributes);
_boxVBO = Graphics::Shader::createBuffer(GL_ARRAY_BUFFER, sizeof(boxVertices), boxVertices);
_boxShader = OpenGL::Shader::fromFiles("myst3_box", attributes);
_boxVBO = OpenGL::Shader::createBuffer(GL_ARRAY_BUFFER, sizeof(boxVertices), boxVertices);
_boxShader->enableVertexAttribute("position", _boxVBO, 2, GL_FLOAT, GL_TRUE, 2 * sizeof(float), 0);
_boxShader->enableVertexAttribute("texcoord", _boxVBO, 2, GL_FLOAT, GL_TRUE, 2 * sizeof(float), 0);
_cubeShader = Graphics::Shader::fromFiles("myst3_cube", attributes);
_cubeVBO = Graphics::Shader::createBuffer(GL_ARRAY_BUFFER, sizeof(cubeVertices), cubeVertices);
_cubeShader = OpenGL::Shader::fromFiles("myst3_cube", attributes);
_cubeVBO = OpenGL::Shader::createBuffer(GL_ARRAY_BUFFER, sizeof(cubeVertices), cubeVertices);
_cubeShader->enableVertexAttribute("texcoord", _cubeVBO, 2, GL_FLOAT, GL_TRUE, 5 * sizeof(float), 0);
_cubeShader->enableVertexAttribute("position", _cubeVBO, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), 2 * sizeof(float));
_rect3dShader = Graphics::Shader::fromFiles("myst3_cube", attributes);
_rect3dVBO = Graphics::Shader::createBuffer(GL_ARRAY_BUFFER, 20 * sizeof(float), NULL);
_rect3dShader = OpenGL::Shader::fromFiles("myst3_cube", attributes);
_rect3dVBO = OpenGL::Shader::createBuffer(GL_ARRAY_BUFFER, 20 * sizeof(float), NULL);
_rect3dShader->enableVertexAttribute("texcoord", _rect3dVBO, 2, GL_FLOAT, GL_TRUE, 5 * sizeof(float), 0);
_rect3dShader->enableVertexAttribute("position", _rect3dVBO, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), 2 * sizeof(float));
_textShader = Graphics::Shader::fromFiles("myst3_text", attributes);
_textVBO = Graphics::Shader::createBuffer(GL_ARRAY_BUFFER, 100 * 16 * sizeof(float), NULL, GL_DYNAMIC_DRAW);
_textShader = OpenGL::Shader::fromFiles("myst3_text", attributes);
_textVBO = OpenGL::Shader::createBuffer(GL_ARRAY_BUFFER, 100 * 16 * sizeof(float), NULL, GL_DYNAMIC_DRAW);
_textShader->enableVertexAttribute("texcoord", _textVBO, 2, GL_FLOAT, GL_TRUE, 4 * sizeof(float), 0);
_textShader->enableVertexAttribute("position", _textVBO, 2, GL_FLOAT, GL_TRUE, 4 * sizeof(float), 2 * sizeof(float));

10
engines/myst3/gfx_opengl_shaders.h
View file

@ -26,7 +26,7 @@
#include "common/rect.h"
#include "math/rect2d.h"
#include "graphics/opengles2/shader.h"
#include "graphics/opengl/shader.h"
#include "engines/myst3/gfx.h"
@ -62,10 +62,10 @@ private:
void setupQuadEBO();
Math::Vector2d scaled(float x, float y) const;
Graphics::Shader *_boxShader;
Graphics::Shader *_cubeShader;
Graphics::Shader *_rect3dShader;
Graphics::Shader *_textShader;
OpenGL::Shader *_boxShader;
OpenGL::Shader *_cubeShader;
OpenGL::Shader *_rect3dShader;
OpenGL::Shader *_textShader;
GLuint _boxVBO;
GLuint _cubeVBO;

14
engines/stark/gfx/opengls.cpp
View file

@ -36,7 +36,7 @@
#include "engines/stark/gfx/opengltexture.h"
#include "graphics/pixelbuffer.h"
#include "graphics/opengles2/shader.h"
#include "graphics/opengl/shader.h"
namespace Stark {
namespace Gfx {
@ -56,7 +56,7 @@ OpenGLSDriver::OpenGLSDriver() :
}
OpenGLSDriver::~OpenGLSDriver() {
Graphics::Shader::freeBuffer(_surfaceVBO);
OpenGL::Shader::freeBuffer(_surfaceVBO);
delete _surfaceShader;
delete _actorShader;
}
@ -68,13 +68,13 @@ void OpenGLSDriver::init() {
computeScreenViewport();
static const char* attributes[] = { "position", "texcoord", nullptr };
_surfaceShader = Graphics::Shader::fromFiles("stark_surface", attributes);
_surfaceVBO = Graphics::Shader::createBuffer(GL_ARRAY_BUFFER, sizeof(surfaceVertices), surfaceVertices);
_surfaceShader = OpenGL::Shader::fromFiles("stark_surface", attributes);
_surfaceVBO = OpenGL::Shader::createBuffer(GL_ARRAY_BUFFER, sizeof(surfaceVertices), surfaceVertices);
_surfaceShader->enableVertexAttribute("position", _surfaceVBO, 2, GL_FLOAT, GL_TRUE, 2 * sizeof(float), 0);
_surfaceShader->enableVertexAttribute("texcoord", _surfaceVBO, 2, GL_FLOAT, GL_TRUE, 2 * sizeof(float), 0);
static const char* actorAttributes[] = { "position1", "position2", "bone1", "bone2", "boneWeight", "normal", "texcoord", nullptr };
_actorShader = Graphics::Shader::fromFiles("stark_actor", actorAttributes);
_actorShader = OpenGL::Shader::fromFiles("stark_actor", actorAttributes);
}
void OpenGLSDriver::setScreenViewport(bool noScaling) {
@ -169,11 +169,11 @@ Common::Rect OpenGLSDriver::getUnscaledViewport() const {
return _unscaledViewport;
}
Graphics::Shader *OpenGLSDriver::createActorShaderInstance() {
OpenGL::Shader *OpenGLSDriver::createActorShaderInstance() {
return _actorShader->clone();
}
Graphics::Shader *OpenGLSDriver::createSurfaceShaderInstance() {
OpenGL::Shader *OpenGLSDriver::createSurfaceShaderInstance() {
return _surfaceShader->clone();
}

10
engines/stark/gfx/opengls.h
View file

@ -33,7 +33,7 @@
#include "math/vector2d.h"
namespace Graphics {
namespace OpenGL {
class Shader;
}
@ -58,8 +58,8 @@ public:
VisualProp *createPropRenderer() override;
SurfaceRenderer *createSurfaceRenderer() override;
Graphics::Shader *createActorShaderInstance();
Graphics::Shader *createSurfaceShaderInstance();
OpenGL::Shader *createActorShaderInstance();
OpenGL::Shader *createSurfaceShaderInstance();
void start2DMode();
void end2DMode();
@ -72,8 +72,8 @@ private:
Common::Rect _viewport;
Common::Rect _unscaledViewport;
Graphics::Shader *_surfaceShader;
Graphics::Shader *_actorShader;
OpenGL::Shader *_surfaceShader;
OpenGL::Shader *_actorShader;
uint32 _surfaceVBO;
};

10
engines/stark/gfx/openglsactor.cpp
View file

@ -29,7 +29,7 @@
#include "engines/stark/gfx/opengls.h"
#include "engines/stark/gfx/texture.h"
#include "graphics/opengles2/shader.h"
#include "graphics/opengl/shader.h"
namespace Stark {
namespace Gfx {
@ -120,11 +120,11 @@ void OpenGLSActorRenderer::render(const Math::Vector3d position, float direction
void OpenGLSActorRenderer::clearVertices() {
for (FaceBufferMap::iterator it = _faceVBO.begin(); it != _faceVBO.end(); ++it) {
Graphics::Shader::freeBuffer(it->_value);
OpenGL::Shader::freeBuffer(it->_value);
}
for (FaceBufferMap::iterator it = _faceEBO.begin(); it != _faceEBO.end(); ++it) {
Graphics::Shader::freeBuffer(it->_value);
OpenGL::Shader::freeBuffer(it->_value);
}
_faceVBO.clear();
@ -168,7 +168,7 @@ uint32 OpenGLSActorRenderer::createFaceVBO(const FaceNode *face) {
*vertPtr++ = (*tri)->_texT;
}
uint32 vbo = Graphics::Shader::createBuffer(GL_ARRAY_BUFFER, sizeof(float) * 14 * face->_verts.size(), vertices);
uint32 vbo = OpenGL::Shader::createBuffer(GL_ARRAY_BUFFER, sizeof(float) * 14 * face->_verts.size(), vertices);
delete[] vertices;
return vbo;
@ -190,7 +190,7 @@ uint32 OpenGLSActorRenderer::createFaceEBO(const FaceNode *face) {
}
}
uint32 ebo = Graphics::Shader::createBuffer(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint32) * 3 * face->_tris.size(), indices);
uint32 ebo = OpenGL::Shader::createBuffer(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint32) * 3 * face->_tris.size(), indices);
delete[] indices;
return ebo;

4
engines/stark/gfx/openglsactor.h
View file

@ -29,7 +29,7 @@
#include "engines/stark/gfx/renderentry.h"
#include "engines/stark/visual/actor.h"
namespace Graphics {
namespace OpenGL {
class Shader;
}
@ -49,7 +49,7 @@ protected:
typedef Common::HashMap<FaceNode *, uint32> FaceBufferMap;
OpenGLSDriver *_gfx;
Graphics::Shader *_shader;
OpenGL::Shader *_shader;
FaceBufferMap _faceVBO;
FaceBufferMap _faceEBO;

12
engines/stark/gfx/openglsprop.cpp
View file

@ -27,7 +27,7 @@
#include "engines/stark/gfx/driver.h"
#include "engines/stark/gfx/texture.h"
#include "graphics/opengles2/shader.h"
#include "graphics/opengl/shader.h"
namespace Stark {
namespace Gfx {
@ -37,7 +37,7 @@ OpenGLSPropRenderer::OpenGLSPropRenderer(Driver *gfx) :
_gfx(gfx),
_faceVBO(-1) {
static const char* attributes[] = { "position", "normal", "texcoord", nullptr };
_shader = Graphics::Shader::fromFiles("stark_prop", attributes);
_shader = OpenGL::Shader::fromFiles("stark_prop", attributes);
}
OpenGLSPropRenderer::~OpenGLSPropRenderer() {
@ -96,11 +96,11 @@ void OpenGLSPropRenderer::render(const Math::Vector3d position, float direction)
}
void OpenGLSPropRenderer::clearVertices() {
Graphics::Shader::freeBuffer(_faceVBO);
OpenGL::Shader::freeBuffer(_faceVBO);
_faceVBO = -1;
for (FaceBufferMap::iterator it = _faceEBO.begin(); it != _faceEBO.end(); ++it) {
Graphics::Shader::freeBuffer(it->_value);
OpenGL::Shader::freeBuffer(it->_value);
}
_faceEBO.clear();
@ -118,11 +118,11 @@ void OpenGLSPropRenderer::uploadVertices() {
uint32 OpenGLSPropRenderer::createFaceVBO() {
const Common::Array<Formats::BiffMesh::Vertex> &vertices = _model->getVertices();
return Graphics::Shader::createBuffer(GL_ARRAY_BUFFER, sizeof(float) * 9 * vertices.size(), &vertices.front());
return OpenGL::Shader::createBuffer(GL_ARRAY_BUFFER, sizeof(float) * 9 * vertices.size(), &vertices.front());
}
uint32 OpenGLSPropRenderer::createFaceEBO(const Formats::BiffMesh::Face *face) {
return Graphics::Shader::createBuffer(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint32) * face->vertexIndices.size(), &face->vertexIndices.front());
return OpenGL::Shader::createBuffer(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint32) * face->vertexIndices.size(), &face->vertexIndices.front());
}
} // End of namespace Gfx

4
engines/stark/gfx/openglsprop.h
View file

@ -29,7 +29,7 @@
#include "engines/stark/formats/biffmesh.h"
#include "engines/stark/visual/prop.h"
namespace Graphics {
namespace OpenGL {
class Shader;
}
@ -50,7 +50,7 @@ protected:
typedef Common::HashMap<const Formats::BiffMesh::Face *, uint32> FaceBufferMap;
Driver *_gfx;
Graphics::Shader *_shader;
OpenGL::Shader *_shader;
int32 _faceVBO;
FaceBufferMap _faceEBO;

2
engines/stark/gfx/openglssurface.cpp
View file

@ -25,7 +25,7 @@
#include "engines/stark/gfx/opengls.h"
#include "engines/stark/gfx/texture.h"
#include "graphics/opengles2/shader.h"
#include "graphics/opengl/shader.h"
namespace Stark {
namespace Gfx {

4
engines/stark/gfx/openglssurface.h
View file

@ -27,7 +27,7 @@
#include "math/vector2d.h"
namespace Graphics {
namespace OpenGL {
class Shader;
}
@ -53,7 +53,7 @@ private:
Math::Vector2d normalizeCurrentCoordinates(float x, float y) const;
OpenGLSDriver *_gfx;
Graphics::Shader *_shader;
OpenGL::Shader *_shader;
};
} // End of namespace Gfx

8
graphics/module.mk
View file

@ -30,10 +30,10 @@ MODULE_OBJS := \
opengl/framebuffer.o \
opengl/texture.o \
opengl/extensions.o \
opengles2/shader.o \
opengles2/box_shaders.o \
opengles2/control_shaders.o \
opengles2/compat_shaders.o \
opengl/shader.o \
opengl/box_shaders.o \
opengl/control_shaders.o \
opengl/compat_shaders.o \
tinygl/api.o \
tinygl/arrays.o \
tinygl/clear.o \

4
graphics/opengles2/box_shaders.cpp → graphics/opengl/box_shaders.cpp
View file

@ -24,7 +24,7 @@
#if defined(USE_GLES2) || defined(USE_OPENGL_SHADERS)
namespace Graphics {
namespace OpenGL {
namespace BuiltinShaders {
const char *boxVertex =
@ -60,6 +60,6 @@ const char *boxFragment =
"}\n";
}
}
} // End of namespace OpenGL
#endif

4
graphics/opengles2/compat_shaders.cpp → graphics/opengl/compat_shaders.cpp
View file

@ -24,7 +24,7 @@
#if defined(USE_GLES2) || defined(USE_OPENGL_SHADERS)
namespace Graphics {
namespace OpenGL {
namespace BuiltinShaders {
const char *compatVertex =
@ -76,6 +76,6 @@ const char *compatFragment =
;
}
}
} // End of namespace OpenGL
#endif

4
graphics/opengles2/control_shaders.cpp → graphics/opengl/control_shaders.cpp
View file

@ -24,7 +24,7 @@
#if defined(USE_GLES2) || defined(USE_OPENGL_SHADERS)
namespace Graphics {
namespace OpenGL {
namespace BuiltinShaders {
const char *controlVertex =
@ -60,6 +60,6 @@ const char *controlFragment =
"}\n";
}
}
} // End of namespace OpenGL
#endif

10
graphics/opengles2/shader.cpp → graphics/opengl/shader.cpp
View file

@ -24,9 +24,9 @@
#if defined(USE_GLES2) || defined(USE_OPENGL_SHADERS)
#include "graphics/opengles2/shader.h"
#include "graphics/opengl/shader.h"
namespace Graphics {
namespace OpenGL {
static const GLchar *readFile(const Common::String &filename) {
Common::File file;
@ -71,7 +71,7 @@ static GLuint createDirectShader(const char *shaderSource, GLenum shaderType, co
static GLuint createCompatShader(const char *shaderSource, GLenum shaderType, const Common::String &name) {
const GLchar *compatSource =
shaderType == GL_VERTEX_SHADER ? Graphics::BuiltinShaders::compatVertex : Graphics::BuiltinShaders::compatFragment;
shaderType == GL_VERTEX_SHADER ? OpenGL::BuiltinShaders::compatVertex : OpenGL::BuiltinShaders::compatFragment;
const GLchar *shaderSources[] = {
#ifdef USE_GLES2
"#version 100\n",
@ -181,7 +181,7 @@ void Shader::use(bool forceReload) {
glUseProgram(*_shaderNo);
for (uint32 i = 0; i < _attributes.size(); ++i) {
Graphics::VertexAttrib &attrib = _attributes[i];
VertexAttrib &attrib = _attributes[i];
if (attrib._enabled) {
glEnableVertexAttribArray(i);
glBindBuffer(GL_ARRAY_BUFFER, attrib._vbo);
@ -251,6 +251,6 @@ void Shader::unbind() {
glUseProgram(0);
_previousShader = nullptr;
}
}
} // End of namespace OpenGL
#endif

4
graphics/opengles2/shader.h → graphics/opengl/shader.h
View file

@ -35,7 +35,7 @@
#include "graphics/opengl/system_headers.h"
namespace Graphics {
namespace OpenGL {
namespace BuiltinShaders {
extern const char *boxVertex, *boxFragment;
@ -161,6 +161,6 @@ private:
static Shader *_previousShader;
};
}
} // End of namespace OpenGL
#endif