[Scummvm-git-logs] scummvm branch-2-5 -> 91672019fbed0c26daa27052909b4e5c3a28d210
aquadran
aquadran at gmail.com
Thu Oct 28 08:57:37 UTC 2021
This automated email contains information about 1 new commit which have been
pushed to the 'scummvm' repo located at https://github.com/scummvm/scummvm .
Summary:
91672019fb STARK: Added OpenGL renderer (without shaders)
Commit: 91672019fbed0c26daa27052909b4e5c3a28d210
https://github.com/scummvm/scummvm/commit/91672019fbed0c26daa27052909b4e5c3a28d210
Author: Paweł Kołodziejski (aquadran at gmail.com)
Date: 2021-10-28T10:57:31+02:00
Commit Message:
STARK: Added OpenGL renderer (without shaders)
Changed paths:
NEWS.md
engines/stark/gfx/driver.cpp
engines/stark/gfx/driver.h
engines/stark/gfx/opengl.cpp
engines/stark/gfx/opengl.h
engines/stark/gfx/openglactor.cpp
engines/stark/gfx/openglactor.h
engines/stark/gfx/openglprop.cpp
engines/stark/gfx/openglprop.h
engines/stark/gfx/opengls.cpp
engines/stark/gfx/opengls.h
engines/stark/gfx/openglsactor.cpp
engines/stark/gfx/openglsprop.cpp
engines/stark/gfx/renderentry.h
engines/stark/resources/location.cpp
engines/stark/shaders/stark_actor.vertex
engines/stark/shaders/stark_prop.vertex
engines/stark/ui/dialogbox.cpp
engines/stark/ui/menu/saveloadmenu.cpp
engines/stark/ui/world/fmvscreen.cpp
engines/stark/visual/effects/effect.cpp
engines/stark/visual/explodingimage.cpp
engines/stark/visual/flashingimage.cpp
engines/stark/visual/image.cpp
engines/stark/visual/smacker.cpp
engines/stark/visual/text.cpp
math/vector3d.h
diff --git a/NEWS.md b/NEWS.md
index 041d94c182..37f0016005 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -15,6 +15,9 @@ For a more comprehensive changelog of the latest experimental code, see:
- Improved support for the high-resolution text in the 16-color Macintosh
versions of Loom and Indiana Jones and the Last Crusade.
+ Stark:
+ - Added OpenGL renderer (without shaders).
+
Xeen:
- Fix crash on startup loading constants from xeen.ccs
diff --git a/engines/stark/gfx/driver.cpp b/engines/stark/gfx/driver.cpp
index 617741dc47..524b985c24 100644
--- a/engines/stark/gfx/driver.cpp
+++ b/engines/stark/gfx/driver.cpp
@@ -45,43 +45,42 @@ Driver *Driver::create() {
Graphics::RendererType desiredRendererType = Graphics::parseRendererTypeCode(rendererConfig);
Graphics::RendererType matchingRendererType = Graphics::getBestMatchingAvailableRendererType(desiredRendererType);
-#if defined(USE_OPENGL_SHADERS) || defined(USE_GLES2)
+#if defined(USE_OPENGL_GAME) || defined(USE_OPENGL_SHADERS) || defined(USE_GLES2)
bool softRenderer = matchingRendererType == Graphics::kRendererTypeTinyGL;
if (!softRenderer) {
initGraphics3d(kOriginalWidth, kOriginalHeight);
} else {
#endif
initGraphics(kOriginalWidth, kOriginalHeight, nullptr);
-#if defined(USE_OPENGL_SHADERS) || defined(USE_GLES2)
+#if defined(USE_OPENGL_GAME) || defined(USE_OPENGL_SHADERS) || defined(USE_GLES2)
}
#endif
- Driver *driver = nullptr;
-
if (matchingRendererType != desiredRendererType && desiredRendererType != Graphics::kRendererTypeDefault) {
// Display a warning if unable to use the desired renderer
warning("Unable to match a '%s' renderer", rendererConfig.c_str());
}
+ Driver *driver = nullptr;
+
#if defined(USE_GLES2) || defined(USE_OPENGL_SHADERS)
bool backendCapableOpenGLShaders = g_system->hasFeature(OSystem::kFeatureOpenGLForGame) && OpenGLContext.shadersSupported;
if (backendCapableOpenGLShaders && matchingRendererType == Graphics::kRendererTypeOpenGLShaders) {
driver = new OpenGLSDriver();
}
#endif
- if (matchingRendererType == Graphics::kRendererTypeTinyGL) {
- //driver = new TinyGLDriver();
+#if defined(USE_OPENGL_GAME) && !defined(USE_GLES2)
+ bool backendCapableOpenGL = g_system->hasFeature(OSystem::kFeatureOpenGLForGame);
+ if (backendCapableOpenGL && matchingRendererType == Graphics::kRendererTypeOpenGL) {
+ driver = new OpenGLDriver();
}
+#endif
- if (!driver) {
- if (desiredRendererType != Graphics::kRendererTypeDefault) {
- warning("Desired a '%s' renderer is not supported", rendererConfig.c_str());
- GUI::displayErrorDialog(Common::U32String::format("Desired a '%s' renderer is not supported", rendererConfig.c_str()));
- } else {
- warning("No renderers have been found for this game");
- GUI::displayErrorDialog(Common::U32String::format(_("No renderers have been found for this game")));
- }
- }
+ if (driver)
+ return driver;
+
+ warning("No renderers have been found for this game");
+ GUI::displayErrorDialog(Common::U32String::format(_("No renderers have been found for this game")));
return driver;
}
diff --git a/engines/stark/gfx/driver.h b/engines/stark/gfx/driver.h
index 3c4053a2ec..6f68b188ef 100644
--- a/engines/stark/gfx/driver.h
+++ b/engines/stark/gfx/driver.h
@@ -63,13 +63,21 @@ public:
virtual void flipBuffer() = 0;
/**
- * Create a new texture
+ * Create a new texture for 3D
*
* The caller is responsible for freeing it.
*
*/
virtual Texture *createTexture(const Graphics::Surface *surface = nullptr, const byte *palette = nullptr) = 0;
+ /**
+ * Create a new texture for 2D
+ *
+ * The caller is responsible for freeing it.
+ *
+ */
+ virtual Texture *createBitmap(const Graphics::Surface *surface = nullptr, const byte *palette = nullptr) = 0;
+
/**
* Create a new actor renderer
*
@@ -131,6 +139,7 @@ public:
virtual Graphics::Surface *getViewportScreenshot() const = 0;
virtual void set3DMode() = 0;
+ virtual bool computeLightsEnabled() = 0;
static const int32 kOriginalWidth = 640;
static const int32 kOriginalHeight = 480;
@@ -145,6 +154,7 @@ protected:
static void flipVertical(Graphics::Surface *s);
Common::Rect _screenViewport;
+ bool _computeLights;
};
} // End of namespace Gfx
diff --git a/engines/stark/gfx/opengl.cpp b/engines/stark/gfx/opengl.cpp
index 954a1d6d9d..87ddbfff73 100644
--- a/engines/stark/gfx/opengl.cpp
+++ b/engines/stark/gfx/opengl.cpp
@@ -43,6 +43,7 @@ namespace Stark {
namespace Gfx {
OpenGLDriver::OpenGLDriver() {
+ _computeLights = true;
}
OpenGLDriver::~OpenGLDriver() {
@@ -60,6 +61,7 @@ void OpenGLDriver::init() {
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
+ glDisable(GL_LIGHTING);
}
void OpenGLDriver::setScreenViewport(bool noScaling) {
@@ -108,7 +110,6 @@ void OpenGLDriver::setupLights(const LightEntryArray &lights) {
assert(ambient->type == LightEntry::kAmbient); // The first light must be the ambient light
Math::Matrix4 viewMatrix = StarkScene->getViewMatrix();
- Math::Matrix3 viewMatrixRot = viewMatrix.getRotation();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
@@ -121,6 +122,7 @@ void OpenGLDriver::setupLights(const LightEntryArray &lights) {
GLfloat lightDir[] = { 0.0f, 0.0f, -1.0f };
GLfloat cutoff = 180.0f;
GLfloat spotExp = 0.0f;
+ GLfloat c_attenuation = 1.0f;
GLfloat l_attenuation = 0.0f;
GLfloat q_attenuation = 0.0f;
@@ -133,10 +135,9 @@ void OpenGLDriver::setupLights(const LightEntryArray &lights) {
Math::Vector4d eyePosition = viewMatrix * worldPosition;
Math::Vector3d worldDirection = l->direction;
- Math::Vector3d eyeDirection = viewMatrixRot * worldDirection;
+ Math::Vector3d eyeDirection = viewMatrix.getRotation() * worldDirection;
eyeDirection.normalize();
- glDisable(GL_LIGHT0 + i);
switch (l->type) {
case LightEntry::kPoint:
lightColor[0] = (GLfloat)l->color.x();
@@ -150,9 +151,9 @@ void OpenGLDriver::setupLights(const LightEntryArray &lights) {
lightColor[0] = (GLfloat)l->color.x();
lightColor[1] = (GLfloat)l->color.y();
lightColor[2] = (GLfloat)l->color.z();
- lightPos[0] = -(GLfloat)eyeDirection.x();
- lightPos[1] = -(GLfloat)eyeDirection.y();
- lightPos[2] = -(GLfloat)eyeDirection.z();
+ lightPos[0] = (GLfloat)-eyeDirection.x();
+ lightPos[1] = (GLfloat)-eyeDirection.y();
+ lightPos[2] = (GLfloat)-eyeDirection.z();
lightPos[3] = 0;
break;
case LightEntry::kSpot:
@@ -162,19 +163,15 @@ void OpenGLDriver::setupLights(const LightEntryArray &lights) {
lightPos[0] = (GLfloat)eyePosition.x();
lightPos[1] = (GLfloat)eyePosition.y();
lightPos[2] = (GLfloat)eyePosition.z();
- lightDir[0] = -(GLfloat)eyeDirection.x();
- lightDir[1] = -(GLfloat)eyeDirection.y();
- lightDir[2] = -(GLfloat)eyeDirection.z();
- // FIXME
- l_attenuation = 0.0000001f;
- q_attenuation = 0.0000001f;
- //spotExp = 0.0f;
- //cutoff = (l->outerConeAngle.getDegrees() + l->innerConeAngle.getDegrees()) / 2.0f;
+ lightDir[0] = (GLfloat)eyeDirection.x();
+ lightDir[1] = (GLfloat)eyeDirection.y();
+ lightDir[2] = (GLfloat)eyeDirection.z();
+ cutoff = (l->outerConeAngle.getDegrees() + l->innerConeAngle.getDegrees()) / 2.26f;
break;
case LightEntry::kAmbient:
- ambientColor[0] = (GLfloat)l->color.x();
- ambientColor[1] = (GLfloat)l->color.y();
- ambientColor[2] = (GLfloat)l->color.z();
+ lightColor[0] = (GLfloat)l->color.x();
+ lightColor[1] = (GLfloat)l->color.y();
+ lightColor[2] = (GLfloat)l->color.z();
break;
default:
break;
@@ -186,6 +183,7 @@ void OpenGLDriver::setupLights(const LightEntryArray &lights) {
glLightfv(GL_LIGHT0 + i, GL_SPOT_DIRECTION, lightDir);
glLightf(GL_LIGHT0 + i, GL_SPOT_EXPONENT, spotExp);
glLightf(GL_LIGHT0 + i, GL_SPOT_CUTOFF, cutoff);
+ glLightf(GL_LIGHT0 + i, GL_CONSTANT_ATTENUATION, c_attenuation);
glLightf(GL_LIGHT0 + i, GL_LINEAR_ATTENUATION, l_attenuation);
glLightf(GL_LIGHT0 + i, GL_QUADRATIC_ATTENUATION, q_attenuation);
glEnable(GL_LIGHT0 + i);
@@ -207,6 +205,10 @@ Texture *OpenGLDriver::createTexture(const Graphics::Surface *surface, const byt
return texture;
}
+Texture *OpenGLDriver::createBitmap(const Graphics::Surface *surface, const byte *palette) {
+ return createTexture(surface, palette);
+}
+
VisualActor *OpenGLDriver::createActorRenderer() {
return new OpenGLActorRenderer(this);
}
@@ -224,6 +226,11 @@ FadeRenderer *OpenGLDriver::createFadeRenderer() {
}
void OpenGLDriver::start2DMode() {
+#if defined(USE_OPENGL_SHADERS)
+ // The ShaderSurfaceRenderer sets an array buffer which conflict with fixed pipeline rendering
+ glBindBuffer(GL_ARRAY_BUFFER, 0);
+#endif // defined(USE_OPENGL_SHADERS)
+
// Enable alpha blending
glEnable(GL_BLEND);
//glBlendEquation(GL_FUNC_ADD); // It's the default
@@ -235,7 +242,8 @@ void OpenGLDriver::start2DMode() {
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
- glDisable(GL_LIGHTING);
+ if (!_computeLights)
+ glDisable(GL_LIGHTING);
}
void OpenGLDriver::end2DMode() {
@@ -244,10 +252,14 @@ void OpenGLDriver::end2DMode() {
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
- glEnable(GL_LIGHTING);
}
void OpenGLDriver::set3DMode() {
+#if defined(USE_OPENGL_SHADERS)
+ // The ShaderSurfaceRenderer sets an array buffer which conflict with fixed pipeline rendering
+ glBindBuffer(GL_ARRAY_BUFFER, 0);
+#endif // defined(USE_OPENGL_SHADERS)
+
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
@@ -256,6 +268,13 @@ void OpenGLDriver::set3DMode() {
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glStencilFunc(GL_EQUAL, 0, 0xFF);
glStencilOp(GL_KEEP, GL_KEEP, GL_INCR);
+
+ if (!_computeLights)
+ glEnable(GL_LIGHTING);
+}
+
+bool OpenGLDriver::computeLightsEnabled() {
+ return _computeLights;
}
Common::Rect OpenGLDriver::getViewport() const {
diff --git a/engines/stark/gfx/opengl.h b/engines/stark/gfx/opengl.h
index 07e86bc35d..bb9c68794e 100644
--- a/engines/stark/gfx/opengl.h
+++ b/engines/stark/gfx/opengl.h
@@ -50,6 +50,7 @@ public:
void flipBuffer() override;
Texture *createTexture(const Graphics::Surface *surface = nullptr, const byte *palette = nullptr) override;
+ Texture *createBitmap(const Graphics::Surface *surface = nullptr, const byte *palette = nullptr) override;
VisualActor *createActorRenderer() override;
VisualProp *createPropRenderer() override;
SurfaceRenderer *createSurfaceRenderer() override;
@@ -58,6 +59,7 @@ public:
void start2DMode();
void end2DMode();
void set3DMode() override;
+ bool computeLightsEnabled() override;
Common::Rect getViewport() const;
Common::Rect getUnscaledViewport() const;
diff --git a/engines/stark/gfx/openglactor.cpp b/engines/stark/gfx/openglactor.cpp
index 9d775743f1..8116ad4d2e 100644
--- a/engines/stark/gfx/openglactor.cpp
+++ b/engines/stark/gfx/openglactor.cpp
@@ -66,17 +66,31 @@ void OpenGLActorRenderer::render(const Math::Vector3d &position, float direction
Math::Vector3d lightDirection;
_gfx->set3DMode();
- _gfx->setupLights(lights);
+ if (!_gfx->computeLightsEnabled())
+ _gfx->setupLights(lights);
Math::Matrix4 model = getModelMatrix(position, direction);
Math::Matrix4 view = StarkScene->getViewMatrix();
Math::Matrix4 projection = StarkScene->getProjectionMatrix();
Math::Matrix4 modelViewMatrix = view * model;
- modelViewMatrix.transpose(); // OpenGL expects matrices transposed when compared to ScummVM's
+ modelViewMatrix.transpose(); // OpenGL expects matrices transposed
+ glMatrixMode(GL_MODELVIEW);
+ glLoadMatrixf(modelViewMatrix.getData());
Math::Matrix4 projectionMatrix = projection;
- projectionMatrix.transpose(); // OpenGL expects matrices transposed when compared to ScummVM's
+ projectionMatrix.transpose(); // OpenGL expects matrices transposed
+ glMatrixMode(GL_PROJECTION);
+ glLoadMatrixf(projectionMatrix.getData());
+
+ Math::Matrix4 normalMatrix;
+ if (_gfx->computeLightsEnabled()) {
+ projectionMatrix.transpose();
+ modelViewMatrix.transpose();
+
+ normalMatrix = modelViewMatrix;
+ normalMatrix.invertAffineOrthonormal();
+ }
Math::Matrix4 mvp;
if (drawShadow) {
@@ -87,40 +101,43 @@ void OpenGLActorRenderer::render(const Math::Vector3d &position, float direction
lightDirection = getShadowLightDirection(lights, position, modelInverse.getRotation());
}
- glMatrixMode(GL_PROJECTION);
- glLoadMatrixf(projectionMatrix.getData());
-
- glMatrixMode(GL_MODELVIEW);
- glLoadMatrixf(modelViewMatrix.getData());
-
glEnable(GL_TEXTURE_2D);
Common::Array<Face *> faces = _model->getFaces();
Common::Array<Material *> mats = _model->getMaterials();
const Common::Array<BoneNode *> &bones = _model->getBones();
- glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
- glEnable(GL_COLOR_MATERIAL);
+ if (!_gfx->computeLightsEnabled()) {
+ glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
+ glEnable(GL_COLOR_MATERIAL);
+ }
+
for (Common::Array<Face *>::const_iterator face = faces.begin(); face != faces.end(); ++face) {
const Material *material = mats[(*face)->materialId];
+ Math::Vector3d color;
const Gfx::Texture *tex = resolveTexture(material);
- if (tex) {
- tex->bind();
- glColor3f(1.0f, 1.0f, 1.0f);
- } else {
- glBindTexture(GL_TEXTURE_2D, 0);
- glColor3f(material->r, material->g, material->b);
- }
-
auto vertexIndices = _faceEBO[*face];
auto numVertexIndices = (*face)->vertexIndices.size();
for (uint32 i = 0; i < numVertexIndices; i++) {
+ if (tex) {
+ tex->bind();
+ if (_gfx->computeLightsEnabled())
+ color = Math::Vector3d(1.0f, 1.0f, 1.0f);
+ else
+ glColor3f(1.0f, 1.0f, 1.0f);
+ } else {
+ glBindTexture(GL_TEXTURE_2D, 0);
+ if (_gfx->computeLightsEnabled())
+ color = Math::Vector3d(material->r, material->g, material->b);
+ else
+ glColor3f(material->r, material->g, material->b);
+ }
uint32 index = vertexIndices[i];
auto vertex = _faceVBO[index];
uint32 bone1 = vertex.bone1;
uint32 bone2 = vertex.bone2;
- Math::Vector3d position1 = vertex.pos1;
- Math::Vector3d position2 = vertex.pos2;
+ Math::Vector3d position1 = Math::Vector3d(vertex.pos1x, vertex.pos1y, vertex.pos1z);
+ Math::Vector3d position2 = Math::Vector3d(vertex.pos2x, vertex.pos2y, vertex.pos2z);
Math::Vector3d bone1Position = Math::Vector3d(bones[bone1]->_animPos.x(),
bones[bone1]->_animPos.y(),
bones[bone1]->_animPos.z());
@@ -136,27 +153,38 @@ void OpenGLActorRenderer::render(const Math::Vector3d &position, float direction
bones[bone2]->_animRot.z(),
bones[bone2]->_animRot.w());
float boneWeight = vertex.boneWeight;
- Math::Vector3d normal = vertex.normal;
+ Math::Vector3d normal = Math::Vector3d(vertex.normalx, vertex.normaly, vertex.normalz);
// Compute the vertex position in eye-space
bone1Rotation.transform(position1);
position1 += bone1Position;
bone2Rotation.transform(position2);
position2 += bone2Position;
- Math::Vector3d modelPosition = position2 * (1.0 - boneWeight) + position1 * boneWeight;
+ Math::Vector3d modelPosition = Math::Vector3d::interpolate(position2, position1, boneWeight);
vertex.x = modelPosition.x();
vertex.y = modelPosition.y();
vertex.z = modelPosition.z();
-
+ Math::Vector4d modelEyePosition;
+ if (_gfx->computeLightsEnabled()) {
+ modelEyePosition = modelViewMatrix * Math::Vector4d(modelPosition.x(),
+ modelPosition.y(),
+ modelPosition.z(),
+ 1.0);
+ }
// Compute the vertex normal in eye-space
Math::Vector3d n1 = normal;
bone1Rotation.transform(n1);
Math::Vector3d n2 = normal;
bone2Rotation.transform(n2);
- Math::Vector3d modelNormal = Math::Vector3d(n2 * (1.0 - boneWeight) + n1 * boneWeight).getNormalized();
+ Math::Vector3d modelNormal = Math::Vector3d(Math::Vector3d::interpolate(n2, n1, boneWeight)).getNormalized();
vertex.nx = modelNormal.x();
vertex.ny = modelNormal.y();
vertex.nz = modelNormal.z();
+ Math::Vector3d modelEyeNormal;
+ if (_gfx->computeLightsEnabled()) {
+ modelEyeNormal = normalMatrix.getRotation() * modelNormal;
+ modelEyeNormal.normalize();
+ }
if (drawShadow) {
Math::Vector3d shadowPosition = modelPosition + lightDirection * (-modelPosition.y() / lightDirection.y());
@@ -165,33 +193,100 @@ void OpenGLActorRenderer::render(const Math::Vector3d &position, float direction
vertex.sz = shadowPosition.z();
}
+ if (_gfx->computeLightsEnabled()) {
+ static const uint maxLights = 10;
+
+ assert(lights.size() >= 1);
+ assert(lights.size() <= maxLights);
+
+ const LightEntry *ambient = lights[0];
+ assert(ambient->type == LightEntry::kAmbient); // The first light must be the ambient light
+
+ Math::Vector3d lightColor = ambient->color;
+
+ for (uint li = 0; li < lights.size() - 1; li++) {
+ const LightEntry *l = lights[li + 1];
+
+ switch (l->type) {
+ case LightEntry::kPoint: {
+ Math::Vector3d vertexToLight = l->eyePosition.getXYZ() - modelEyePosition.getXYZ();
+
+ float dist = vertexToLight.length();
+ vertexToLight.normalize();
+ float attn = CLIP((l->falloffFar - dist) / MAX(0.001f, l->falloffFar - l->falloffNear), 0.0f, 1.0f);
+ float incidence = MAX(0.0f, Math::Vector3d::dotProduct(modelEyeNormal, vertexToLight));
+ lightColor += l->color * attn * incidence;
+ break;
+ }
+ case LightEntry::kDirectional: {
+ float incidence = MAX(0.0f, Math::Vector3d::dotProduct(modelEyeNormal, -l->eyeDirection));
+ lightColor += (l->color * incidence);
+ break;
+ }
+ case LightEntry::kSpot: {
+ Math::Vector3d vertexToLight = l->eyePosition.getXYZ() - modelEyePosition.getXYZ();
+
+ float dist = vertexToLight.length();
+ float attn = CLIP((l->falloffFar - dist) / MAX(0.001f, l->falloffFar - l->falloffNear), 0.0f, 1.0f);
+
+ vertexToLight.normalize();
+ float incidence = MAX(0.0f, modelEyeNormal.dotProduct(vertexToLight));
+
+ float cosAngle = MAX(0.0f, vertexToLight.dotProduct(-l->eyeDirection));
+ float cone = CLIP((cosAngle - l->innerConeAngle.getCosine()) / MAX(0.001f, l->outerConeAngle.getCosine() - l->innerConeAngle.getCosine()), 0.0f, 1.0f);
+
+ lightColor += l->color * attn * incidence * cone;
+ break;
+ }
+ default:
+ break;
+ }
+ }
+
+ lightColor.x() = CLIP(lightColor.x(), 0.0f, 1.0f);
+ lightColor.y() = CLIP(lightColor.y(), 0.0f, 1.0f);
+ lightColor.z() = CLIP(lightColor.z(), 0.0f, 1.0f);
+ color = color * lightColor;
+ vertex.r = color.x();
+ vertex.g = color.y();
+ vertex.b = color.z();
+ }
+
_faceVBO[index] = vertex;
}
glEnableClientState(GL_VERTEX_ARRAY);
- glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+ if (_gfx->computeLightsEnabled())
+ glEnableClientState(GL_COLOR_ARRAY);
+ if (tex)
+ glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glVertexPointer(3, GL_FLOAT, sizeof(ActorVertex), &_faceVBO[0].x);
if (tex)
glTexCoordPointer(2, GL_FLOAT, sizeof(ActorVertex), &_faceVBO[0].texS);
glNormalPointer(GL_FLOAT, sizeof(ActorVertex), &_faceVBO[0].nx);
+ if (_gfx->computeLightsEnabled())
+ glColorPointer(3, GL_FLOAT, sizeof(ActorVertex), &_faceVBO[0].r);
glDrawElements(GL_TRIANGLES, numVertexIndices, GL_UNSIGNED_INT, vertexIndices);
glDisableClientState(GL_VERTEX_ARRAY);
- glDisableClientState(GL_NORMAL_ARRAY);
+ if (_gfx->computeLightsEnabled())
+ glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-
+ glDisableClientState(GL_NORMAL_ARRAY);
}
- glDisable(GL_COLOR_MATERIAL);
+ if (!_gfx->computeLightsEnabled())
+ glDisable(GL_COLOR_MATERIAL);
if (drawShadow) {
glEnable(GL_BLEND);
glEnable(GL_STENCIL_TEST);
glDisable(GL_TEXTURE_2D);
- glDisable(GL_LIGHTING);
+ if (!_gfx->computeLightsEnabled())
+ glDisable(GL_LIGHTING);
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(projectionMatrix.getData());
@@ -213,7 +308,8 @@ void OpenGLActorRenderer::render(const Math::Vector3d &position, float direction
glDisableClientState(GL_VERTEX_ARRAY);
}
- glEnable(GL_LIGHTING);
+ if (!_gfx->computeLightsEnabled())
+ glEnable(GL_LIGHTING);
glEnable(GL_TEXTURE_2D);
glDisable(GL_BLEND);
glDisable(GL_STENCIL_TEST);
@@ -247,12 +343,18 @@ ActorVertex *OpenGLActorRenderer::createModelVBO(const Model *model) {
// Build a vertex array
int i = 0;
for (Common::Array<VertNode *>::const_iterator tri = modelVertices.begin(); tri != modelVertices.end(); ++tri, i++) {
- vertices[i].pos1 = Math::Vector3d((*tri)->_pos1.x(), (*tri)->_pos1.y(), (*tri)->_pos1.z());
- vertices[i].pos2 = Math::Vector3d((*tri)->_pos2.x(), (*tri)->_pos2.y(), (*tri)->_pos2.z());
+ vertices[i].pos1x = (*tri)->_pos1.x();
+ vertices[i].pos1y = (*tri)->_pos1.y();
+ vertices[i].pos1z = (*tri)->_pos1.z();
+ vertices[i].pos2x = (*tri)->_pos2.x();
+ vertices[i].pos2y = (*tri)->_pos2.y();
+ vertices[i].pos2z = (*tri)->_pos2.z();
vertices[i].bone1 = (*tri)->_bone1;
vertices[i].bone2 = (*tri)->_bone2;
vertices[i].boneWeight = (*tri)->_boneWeight;
- vertices[i].normal = Math::Vector3d((*tri)->_normal.x(), (*tri)->_normal.y(), (*tri)->_normal.z());
+ vertices[i].normalx = (*tri)->_normal.x();
+ vertices[i].normaly = (*tri)->_normal.y();
+ vertices[i].normalz = (*tri)->_normal.z();
vertices[i].texS = -(*tri)->_texS;
vertices[i].texT = (*tri)->_texT;
}
diff --git a/engines/stark/gfx/openglactor.h b/engines/stark/gfx/openglactor.h
index a4f80bc16b..a837f0bfcd 100644
--- a/engines/stark/gfx/openglactor.h
+++ b/engines/stark/gfx/openglactor.h
@@ -42,12 +42,18 @@ class OpenGLDriver;
#include "common/pack-start.h"
struct _ActorVertex {
- Math::Vector3d pos1;
- Math::Vector3d pos2;
+ float pos1x;
+ float pos1y;
+ float pos1z;
+ float pos2x;
+ float pos2y;
+ float pos2z;
uint32 bone1;
uint32 bone2;
float boneWeight;
- Math::Vector3d normal;
+ float normalx;
+ float normaly;
+ float normalz;
float texS;
float texT;
float x;
@@ -59,6 +65,9 @@ struct _ActorVertex {
float sx;
float sy;
float sz;
+ float r;
+ float g;
+ float b;
} PACKED_STRUCT;
typedef _ActorVertex ActorVertex;
diff --git a/engines/stark/gfx/openglprop.cpp b/engines/stark/gfx/openglprop.cpp
index 5e6e1bd9e0..ba9539f2f7 100644
--- a/engines/stark/gfx/openglprop.cpp
+++ b/engines/stark/gfx/openglprop.cpp
@@ -45,66 +45,168 @@ OpenGLPropRenderer::~OpenGLPropRenderer() {
void OpenGLPropRenderer::render(const Math::Vector3d &position, float direction, const LightEntryArray &lights) {
if (_modelIsDirty) {
- // Update the OpenGL Buffer Objects if required
clearVertices();
uploadVertices();
_modelIsDirty = false;
}
_gfx->set3DMode();
- _gfx->setupLights(lights);
+ if (!_gfx->computeLightsEnabled())
+ _gfx->setupLights(lights);
Math::Matrix4 model = getModelMatrix(position, direction);
Math::Matrix4 view = StarkScene->getViewMatrix();
Math::Matrix4 projection = StarkScene->getProjectionMatrix();
Math::Matrix4 modelViewMatrix = view * model;
- modelViewMatrix.transpose(); // OpenGL expects matrices transposed when compared to ScummVM's
+ modelViewMatrix.transpose(); // OpenGL expects matrices transposed
+ glMatrixMode(GL_MODELVIEW);
+ glLoadMatrixf(modelViewMatrix.getData());
Math::Matrix4 projectionMatrix = projection;
- projectionMatrix.transpose(); // OpenGL expects matrices transposed when compared to ScummVM's
+ projectionMatrix.transpose(); // OpenGL expects matrices transposed
+ glMatrixMode(GL_PROJECTION);
+ glLoadMatrixf(projectionMatrix.getData());
+
+ Math::Matrix4 normalMatrix;
+ if (_gfx->computeLightsEnabled()) {
+ projectionMatrix.transpose();
+ modelViewMatrix.transpose();
+
+ normalMatrix = modelViewMatrix;
+ normalMatrix.invertAffineOrthonormal();
+ }
const Common::Array<Face> &faces = _model->getFaces();
const Common::Array<Material> &materials = _model->getMaterials();
- glEnable(GL_COLOR_MATERIAL);
+ if (!_gfx->computeLightsEnabled())
+ glEnable(GL_COLOR_MATERIAL);
for (Common::Array<Face>::const_iterator face = faces.begin(); face != faces.end(); ++face) {
const Material &material = materials[face->materialId];
-
- // For each face draw its vertices from the VBO, indexed by the EBO
+ Math::Vector3d color;
const Gfx::Texture *tex = _texture->getTexture(material.texture);
- if (material.doubleSided)
- glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
- else
- glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
- if (tex) {
- tex->bind();
- glColor3f(1.0f, 1.0f, 1.0f);
- } else {
- glBindTexture(GL_TEXTURE_2D, 0);
- glColor3f(material.r, material.g, material.b);
- }
-
auto vertexIndices = _faceEBO[face];
+ auto numVertexIndices = (face)->vertexIndices.size();
+ if (!_gfx->computeLightsEnabled()) {
+ if (material.doubleSided)
+ glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
+ else
+ glColorMaterial(GL_FRONT, GL_DIFFUSE);
+ }
+ for (uint32 i = 0; i < numVertexIndices; i++) {
+ uint32 index = vertexIndices[i];
+ auto vertex = _faceVBO[index];
+ if (tex) {
+ tex->bind();
+ if (_gfx->computeLightsEnabled())
+ color = Math::Vector3d(1.0f, 1.0f, 1.0f);
+ else
+ glColor3f(1.0f, 1.0f, 1.0f);
+ if (material.doubleSided) {
+ vertex.texS = vertex.stexS;
+ vertex.texT = 1.0f - vertex.stexT;
+ } else {
+ vertex.texS = 1.0f - vertex.stexS;
+ vertex.texT = 1.0f - vertex.stexT;
+ }
+ } else {
+ glBindTexture(GL_TEXTURE_2D, 0);
+ if (_gfx->computeLightsEnabled())
+ color = Math::Vector3d(material.r, material.g, material.b);
+ else
+ glColor3f(material.r, material.g, material.b);
+ }
+
+ if (_gfx->computeLightsEnabled()) {
+ Math::Vector4d modelEyePosition = modelViewMatrix * Math::Vector4d(vertex.x, vertex.y, vertex.z, 1.0);
+ Math::Vector3d modelEyeNormal = normalMatrix.getRotation() * Math::Vector3d(vertex.nx, vertex.ny, vertex.nz);
+ modelEyeNormal.normalize();
+
+ static const uint maxLights = 10;
+
+ assert(lights.size() >= 1);
+ assert(lights.size() <= maxLights);
+
+ const LightEntry *ambient = lights[0];
+ assert(ambient->type == LightEntry::kAmbient); // The first light must be the ambient light
+
+ Math::Vector3d lightColor = ambient->color;
+
+ for (uint li = 0; li < lights.size() - 1; li++) {
+ const LightEntry *l = lights[li + 1];
+
+ switch (l->type) {
+ case LightEntry::kPoint: {
+ Math::Vector3d vertexToLight = l->eyePosition.getXYZ() - modelEyePosition.getXYZ();
+
+ float dist = vertexToLight.length();
+ vertexToLight.normalize();
+ float attn = CLIP((l->falloffFar - dist) / MAX(0.001f, l->falloffFar - l->falloffNear), 0.0f, 1.0f);
+ float incidence = MAX(0.0f, Math::Vector3d::dotProduct(modelEyeNormal, vertexToLight));
+ lightColor += l->color * attn * incidence;
+ break;
+ }
+ case LightEntry::kDirectional: {
+ float incidence = MAX(0.0f, Math::Vector3d::dotProduct(modelEyeNormal, -l->eyeDirection));
+ lightColor += (l->color * incidence);
+ break;
+ }
+ case LightEntry::kSpot: {
+ Math::Vector3d vertexToLight = l->eyePosition.getXYZ() - modelEyePosition.getXYZ();
+
+ float dist = vertexToLight.length();
+ float attn = CLIP((l->falloffFar - dist) / MAX(0.001f, l->falloffFar - l->falloffNear), 0.0f, 1.0f);
+
+ vertexToLight.normalize();
+ float incidence = MAX(0.0f, modelEyeNormal.dotProduct(vertexToLight));
+
+ float cosAngle = MAX(0.0f, vertexToLight.dotProduct(-l->eyeDirection));
+ float cone = CLIP((cosAngle - l->innerConeAngle.getCosine()) / MAX(0.001f, l->outerConeAngle.getCosine() - l->innerConeAngle.getCosine()), 0.0f, 1.0f);
+
+ lightColor += l->color * attn * incidence * cone;
+ break;
+ }
+ default:
+ break;
+ }
+ }
+
+ lightColor.x() = CLIP(lightColor.x(), 0.0f, 1.0f);
+ lightColor.y() = CLIP(lightColor.y(), 0.0f, 1.0f);
+ lightColor.z() = CLIP(lightColor.z(), 0.0f, 1.0f);
+ color = color * lightColor;
+ vertex.r = color.x();
+ vertex.g = color.y();
+ vertex.b = color.z();
+ }
+ _faceVBO[index] = vertex;
+ }
glEnableClientState(GL_VERTEX_ARRAY);
- glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+ if (_gfx->computeLightsEnabled())
+ glEnableClientState(GL_COLOR_ARRAY);
+ if (tex)
+ glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glVertexPointer(3, GL_FLOAT, sizeof(PropVertex), &_faceVBO[0].x);
if (tex)
glTexCoordPointer(2, GL_FLOAT, sizeof(PropVertex), &_faceVBO[0].texS);
glNormalPointer(GL_FLOAT, sizeof(PropVertex), &_faceVBO[0].nx);
+ if (_gfx->computeLightsEnabled())
+ glColorPointer(3, GL_FLOAT, sizeof(PropVertex), &_faceVBO[0].r);
glDrawElements(GL_TRIANGLES, face->vertexIndices.size(), GL_UNSIGNED_INT, vertexIndices);
glDisableClientState(GL_VERTEX_ARRAY);
- glDisableClientState(GL_NORMAL_ARRAY);
+ if (_gfx->computeLightsEnabled())
+ glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-
+ glDisableClientState(GL_NORMAL_ARRAY);
}
- glDisable(GL_COLOR_MATERIAL);
-
+ if (!_gfx->computeLightsEnabled())
+ glDisable(GL_COLOR_MATERIAL);
}
void OpenGLPropRenderer::clearVertices() {
@@ -138,8 +240,8 @@ PropVertex *OpenGLPropRenderer::createFaceVBO() {
vertices[i].nx = modelVertices[i].normal.x();
vertices[i].ny = modelVertices[i].normal.y();
vertices[i].nz = modelVertices[i].normal.z();
- vertices[i].texS = modelVertices[i].texturePosition.x();
- vertices[i].texT = modelVertices[i].texturePosition.y();
+ vertices[i].stexS = modelVertices[i].texturePosition.x();
+ vertices[i].stexT = modelVertices[i].texturePosition.y();
}
return vertices;
diff --git a/engines/stark/gfx/openglprop.h b/engines/stark/gfx/openglprop.h
index 2c3cbe33c6..0ebf32081c 100644
--- a/engines/stark/gfx/openglprop.h
+++ b/engines/stark/gfx/openglprop.h
@@ -49,8 +49,13 @@ struct _PropVertex {
float nx;
float ny;
float nz;
+ float stexS;
+ float stexT;
float texS;
float texT;
+ float r;
+ float g;
+ float b;
} PACKED_STRUCT;
typedef _PropVertex PropVertex;
diff --git a/engines/stark/gfx/opengls.cpp b/engines/stark/gfx/opengls.cpp
index 63a09cea7e..84e87d4e1c 100644
--- a/engines/stark/gfx/opengls.cpp
+++ b/engines/stark/gfx/opengls.cpp
@@ -142,6 +142,10 @@ Texture *OpenGLSDriver::createTexture(const Graphics::Surface *surface, const by
return texture;
}
+Texture *OpenGLSDriver::createBitmap(const Graphics::Surface *surface, const byte *palette) {
+ return createTexture(surface, palette);
+}
+
VisualActor *OpenGLSDriver::createActorRenderer() {
return new OpenGLSActorRenderer(this);
}
@@ -191,6 +195,10 @@ void OpenGLSDriver::set3DMode() {
glStencilOp(GL_KEEP, GL_KEEP, GL_INCR);
}
+bool OpenGLSDriver::computeLightsEnabled() {
+ return false;
+}
+
Common::Rect OpenGLSDriver::getViewport() const {
return _viewport;
}
diff --git a/engines/stark/gfx/opengls.h b/engines/stark/gfx/opengls.h
index f40bda1082..6925b582f6 100644
--- a/engines/stark/gfx/opengls.h
+++ b/engines/stark/gfx/opengls.h
@@ -52,6 +52,7 @@ public:
void flipBuffer() override;
Texture *createTexture(const Graphics::Surface *surface = nullptr, const byte *palette = nullptr) override;
+ Texture *createBitmap(const Graphics::Surface *surface = nullptr, const byte *palette = nullptr) override;
VisualActor *createActorRenderer() override;
VisualProp *createPropRenderer() override;
SurfaceRenderer *createSurfaceRenderer() override;
@@ -65,6 +66,7 @@ public:
void start2DMode();
void end2DMode();
void set3DMode() override;
+ bool computeLightsEnabled() override;
Common::Rect getViewport() const;
Common::Rect getUnscaledViewport() const;
diff --git a/engines/stark/gfx/openglsactor.cpp b/engines/stark/gfx/openglsactor.cpp
index 4ef1b9fc9b..31bafb69dd 100644
--- a/engines/stark/gfx/openglsactor.cpp
+++ b/engines/stark/gfx/openglsactor.cpp
@@ -71,15 +71,13 @@ void OpenGLSActorRenderer::render(const Math::Vector3d &position, float directio
Math::Matrix4 projection = StarkScene->getProjectionMatrix();
Math::Matrix4 modelViewMatrix = view * model;
- modelViewMatrix.transpose(); // OpenGL expects matrices transposed when compared to ScummVM's
+ modelViewMatrix.transpose(); // OpenGL expects matrices transposed
Math::Matrix4 projectionMatrix = projection;
- projectionMatrix.transpose(); // OpenGL expects matrices transposed when compared to ScummVM's
+ projectionMatrix.transpose(); // OpenGL expects matrices transposed
Math::Matrix4 normalMatrix = modelViewMatrix;
normalMatrix.invertAffineOrthonormal();
- //normalMatrix.transpose(); // OpenGL expects matrices transposed when compared to ScummVM's
- //normalMatrix.transpose(); // No need to transpose twice in a row
_shader->enableVertexAttribute("position1", _faceVBO, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(float), 0);
_shader->enableVertexAttribute("position2", _faceVBO, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(float), 12);
diff --git a/engines/stark/gfx/openglsprop.cpp b/engines/stark/gfx/openglsprop.cpp
index e2e45eb471..45f11a2591 100644
--- a/engines/stark/gfx/openglsprop.cpp
+++ b/engines/stark/gfx/openglsprop.cpp
@@ -65,15 +65,13 @@ void OpenGLSPropRenderer::render(const Math::Vector3d &position, float direction
Math::Matrix4 projection = StarkScene->getProjectionMatrix();
Math::Matrix4 modelViewMatrix = view * model;
- modelViewMatrix.transpose(); // OpenGL expects matrices transposed when compared to ScummVM's
+ modelViewMatrix.transpose(); // OpenGL expects matrices transposed
Math::Matrix4 projectionMatrix = projection;
- projectionMatrix.transpose(); // OpenGL expects matrices transposed when compared to ScummVM's
+ projectionMatrix.transpose(); // OpenGL expects matrices transposed
Math::Matrix4 normalMatrix = modelViewMatrix;
normalMatrix.invertAffineOrthonormal();
- //normalMatrix.transpose(); // OpenGL expects matrices transposed when compared to ScummVM's
- //normalMatrix.transpose(); // No need to transpose twice in a row
_shader->enableVertexAttribute("position", _faceVBO, 3, GL_FLOAT, GL_FALSE, 9 * sizeof(float), 0);
_shader->enableVertexAttribute("normal", _faceVBO, 3, GL_FLOAT, GL_FALSE, 9 * sizeof(float), 12);
diff --git a/engines/stark/gfx/renderentry.h b/engines/stark/gfx/renderentry.h
index a400209760..c5f5593f64 100644
--- a/engines/stark/gfx/renderentry.h
+++ b/engines/stark/gfx/renderentry.h
@@ -58,6 +58,9 @@ struct LightEntry {
Math::Angle outerConeAngle;
float falloffNear;
float falloffFar;
+ Math::Vector4d worldPosition;
+ Math::Vector4d eyePosition;
+ Math::Vector3d eyeDirection;
};
typedef Common::Array<LightEntry *> LightEntryArray;
diff --git a/engines/stark/resources/location.cpp b/engines/stark/resources/location.cpp
index f6f489f7b6..17b6fc274a 100644
--- a/engines/stark/resources/location.cpp
+++ b/engines/stark/resources/location.cpp
@@ -214,6 +214,14 @@ Gfx::LightEntryArray Location::listLightEntries() {
if (light->type == Gfx::LightEntry::kAmbient) {
ambient = light;
} else {
+ Math::Matrix4 view = StarkScene->getViewMatrix();
+ light->worldPosition.x() = light->position.x();
+ light->worldPosition.y() = light->position.y();
+ light->worldPosition.z() = light->position.z();
+ light->worldPosition.w() = 1.0f;
+ light->eyePosition = view * light->worldPosition;
+ light->eyeDirection = view.getRotation() * light->direction;
+ light->eyeDirection.normalize();
others.push_back(light);
}
}
diff --git a/engines/stark/shaders/stark_actor.vertex b/engines/stark/shaders/stark_actor.vertex
index aa08a2e80a..dbfd0893dc 100644
--- a/engines/stark/shaders/stark_actor.vertex
+++ b/engines/stark/shaders/stark_actor.vertex
@@ -60,12 +60,17 @@ vec3 directionalLight(vec3 direction, vec3 color) {
vec3 spotLight(vec3 position, vec3 color, float falloffNear, float falloffFar, vec3 direction, float cosInnerAngle, float cosOuterAngle) {
vec3 vertexToLight = position - eyePosition.xyz;
+
+ float dist = length(vertexToLight);
+ float attn = clamp((falloffFar - dist) / max(0.001, falloffFar - falloffNear), 0.0, 1.0);
+
vertexToLight = normalize(vertexToLight);
+ float incidence = max(0.0, dot(eyeNormal, vertexToLight));
float cosAngle = max(0.0, dot(vertexToLight, -direction));
float cone = clamp((cosAngle - cosInnerAngle) / max(0.001, cosOuterAngle - cosInnerAngle), 0.0, 1.0);
- return pointLight(position, color, falloffNear, falloffFar) * cone;
+ return color * attn * incidence * cone;
}
void main()
@@ -105,7 +110,7 @@ void main()
lightColor += directionalLight(lights[i].direction, lights[i].color);
} else if (type == lightTypeSpot) {
lightColor += spotLight(lights[i].position.xyz, lights[i].color, lights[i].params.x, lights[i].params.y,
- lights[i].direction, lights[i].params.z, lights[i].params.w);
+ lights[i].direction, lights[i].params.z, lights[i].params.w);
}
}
diff --git a/engines/stark/shaders/stark_prop.vertex b/engines/stark/shaders/stark_prop.vertex
index af35c1381c..8ea49401aa 100644
--- a/engines/stark/shaders/stark_prop.vertex
+++ b/engines/stark/shaders/stark_prop.vertex
@@ -48,12 +48,17 @@ vec3 directionalLight(vec3 direction, vec3 color) {
vec3 spotLight(vec3 position, vec3 color, float falloffNear, float falloffFar, vec3 direction, float cosInnerAngle, float cosOuterAngle) {
vec3 vertexToLight = position - eyePosition.xyz;
+
+ float dist = length(vertexToLight);
+ float attn = clamp((falloffFar - dist) / max(0.001, falloffFar - falloffNear), 0.0, 1.0);
+
vertexToLight = normalize(vertexToLight);
+ float incidence = max(0.0, dot(eyeNormal, vertexToLight));
float cosAngle = max(0.0, dot(vertexToLight, -direction));
float cone = clamp((cosAngle - cosInnerAngle) / max(0.001, cosOuterAngle - cosInnerAngle), 0.0, 1.0);
- return pointLight(position, color, falloffNear, falloffFar) * cone;
+ return color * attn * incidence * cone;
}
void main() {
diff --git a/engines/stark/ui/dialogbox.cpp b/engines/stark/ui/dialogbox.cpp
index b475ba8b1f..15c10d852d 100644
--- a/engines/stark/ui/dialogbox.cpp
+++ b/engines/stark/ui/dialogbox.cpp
@@ -62,7 +62,7 @@ DialogBox::DialogBox(StarkEngine *vm, Gfx::Driver *gfx, Cursor *cursor) :
uint32 blue = background->format.RGBToColor(26, 28, 57);
background->fillRect(Common::Rect(256, 256), blue);
}
- _backgroundTexture = gfx->createTexture(background);
+ _backgroundTexture = gfx->createBitmap(background);
_backgroundTexture->setSamplingFilter(Gfx::Texture::kLinear);
background->free();
@@ -168,7 +168,7 @@ void DialogBox::recomputeLayout() {
drawBevel(&foreground, _confirmButtonRect);
drawBevel(&foreground, _cancelButtonRect);
- _foregroundTexture = _gfx->createTexture(&foreground);
+ _foregroundTexture = _gfx->createBitmap(&foreground);
_foregroundTexture->setSamplingFilter(Gfx::Texture::kLinear);
foreground.free();
diff --git a/engines/stark/ui/menu/saveloadmenu.cpp b/engines/stark/ui/menu/saveloadmenu.cpp
index d3da8e205d..4d57063106 100644
--- a/engines/stark/ui/menu/saveloadmenu.cpp
+++ b/engines/stark/ui/menu/saveloadmenu.cpp
@@ -246,8 +246,8 @@ SaveDataWidget::SaveDataWidget(int slot, Gfx::Driver *gfx, SaveLoadMenuScreen *s
_screen(screen),
_thumbWidth(kThumbnailWidth),
_thumbHeight(kThumbnailHeight),
- _texture(gfx->createTexture()),
- _outline(gfx->createTexture()),
+ _texture(gfx->createBitmap()),
+ _outline(gfx->createBitmap()),
_surfaceRenderer(gfx->createSurfaceRenderer()),
_textDesc(gfx),
_textTime(gfx),
diff --git a/engines/stark/ui/world/fmvscreen.cpp b/engines/stark/ui/world/fmvscreen.cpp
index 4a2ac66749..a93ee9933e 100644
--- a/engines/stark/ui/world/fmvscreen.cpp
+++ b/engines/stark/ui/world/fmvscreen.cpp
@@ -44,7 +44,7 @@ FMVScreen::FMVScreen(Gfx::Driver *gfx, Cursor *cursor) :
_decoder->setDefaultHighColorFormat(Gfx::Driver::getRGBAPixelFormat());
_decoder->setSoundType(Audio::Mixer::kSFXSoundType);
- _texture = _gfx->createTexture();
+ _texture = _gfx->createBitmap();
_texture->setSamplingFilter(StarkSettings->getImageSamplingFilter());
_surfaceRenderer = _gfx->createSurfaceRenderer();
diff --git a/engines/stark/visual/effects/effect.cpp b/engines/stark/visual/effects/effect.cpp
index 6db6f830e9..9e449f5144 100644
--- a/engines/stark/visual/effects/effect.cpp
+++ b/engines/stark/visual/effects/effect.cpp
@@ -41,7 +41,7 @@ VisualEffect::VisualEffect(VisualType type, const Common::Point &size, Gfx::Driv
_surface = new Graphics::Surface();
_surface->create(size.x, size.y, Gfx::Driver::getRGBAPixelFormat());
- _texture = _gfx->createTexture(_surface);
+ _texture = _gfx->createBitmap(_surface);
_texture->setSamplingFilter(StarkSettings->getImageSamplingFilter());
_surfaceRenderer = _gfx->createSurfaceRenderer();
diff --git a/engines/stark/visual/explodingimage.cpp b/engines/stark/visual/explodingimage.cpp
index ca44437e1e..496d710437 100644
--- a/engines/stark/visual/explodingimage.cpp
+++ b/engines/stark/visual/explodingimage.cpp
@@ -62,7 +62,7 @@ void VisualExplodingImage::initFromSurface(const Graphics::Surface *surface, uin
_originalWidth = originalWidth;
_originalHeight = originalHeight;
- _texture = _gfx->createTexture(_surface);
+ _texture = _gfx->createBitmap(_surface);
_texture->setSamplingFilter(StarkSettings->getImageSamplingFilter());
// Create an explosion unit for each pixel in the surface
diff --git a/engines/stark/visual/flashingimage.cpp b/engines/stark/visual/flashingimage.cpp
index 77b9c36fad..883752216f 100644
--- a/engines/stark/visual/flashingimage.cpp
+++ b/engines/stark/visual/flashingimage.cpp
@@ -60,7 +60,7 @@ void VisualFlashingImage::initFromSurface(const Graphics::Surface *surface, uint
_originalWidth = originalWidth;
_originalHeight = originalHeight;
- _texture = _gfx->createTexture(surface);
+ _texture = _gfx->createBitmap(surface);
_texture->setSamplingFilter(StarkSettings->getImageSamplingFilter());
}
diff --git a/engines/stark/visual/image.cpp b/engines/stark/visual/image.cpp
index 71b3734eb3..ba6b5d6ddd 100644
--- a/engines/stark/visual/image.cpp
+++ b/engines/stark/visual/image.cpp
@@ -62,7 +62,7 @@ void VisualImageXMG::load(Common::ReadStream *stream) {
// Decode the XMG
_surface = Formats::XMGDecoder::decode(stream);
- _texture = _gfx->createTexture(_surface);
+ _texture = _gfx->createBitmap(_surface);
_texture->setSamplingFilter(StarkSettings->getImageSamplingFilter());
_originalWidth = _surface->w;
@@ -95,7 +95,7 @@ bool VisualImageXMG::loadPNG(Common::SeekableReadStream *stream) {
_surface = pngDecoder.getSurface()->convertTo(Gfx::Driver::getRGBAPixelFormat());
}
- _texture = _gfx->createTexture(_surface);
+ _texture = _gfx->createBitmap(_surface);
_texture->setSamplingFilter(StarkSettings->getImageSamplingFilter());
return true;
diff --git a/engines/stark/visual/smacker.cpp b/engines/stark/visual/smacker.cpp
index ee553dce10..7f8347a495 100644
--- a/engines/stark/visual/smacker.cpp
+++ b/engines/stark/visual/smacker.cpp
@@ -85,7 +85,7 @@ void VisualSmacker::init() {
rewind();
- _texture = _gfx->createTexture();
+ _texture = _gfx->createBitmap();
_texture->setSamplingFilter(StarkSettings->getImageSamplingFilter());
update();
diff --git a/engines/stark/visual/text.cpp b/engines/stark/visual/text.cpp
index 169e79bc6b..edc40df2df 100644
--- a/engines/stark/visual/text.cpp
+++ b/engines/stark/visual/text.cpp
@@ -294,7 +294,7 @@ void VisualText::createTexture() {
multiplyColorWithAlpha(&surface);
// Create a texture from the surface
- _texture = _gfx->createTexture(&surface);
+ _texture = _gfx->createBitmap(&surface);
_texture->setSamplingFilter(Gfx::Texture::kNearest);
surface.free();
@@ -310,7 +310,7 @@ void VisualText::createTexture() {
surface.fillRect(Common::Rect(surface.w, surface.h), bgColor);
multiplyColorWithAlpha(&surface);
- _bgTexture = _gfx->createTexture(&surface);
+ _bgTexture = _gfx->createBitmap(&surface);
surface.free();
}
diff --git a/math/vector3d.h b/math/vector3d.h
index e1e1f26ae6..ca9cf889fb 100644
--- a/math/vector3d.h
+++ b/math/vector3d.h
@@ -84,6 +84,33 @@ public:
inline static Angle angle(const Vector3d& v1, const Vector3d& v2) {
return Angle::arcCosine(fminf(fmaxf(dotProduct(v1, v2) / (v1.getMagnitude() * v2.getMagnitude()), -1.0f), 1.0f));
}
+
+ /**
+ * Calculate vector length
+ * @return The computed length
+ */
+ inline static float length(const Vector3d& v) {
+ return sqrtf(v.x() * v.x() + v.y() * v.y() + v.z() * v.z());
+ }
+
+ /**
+ * Calculate vector length
+ * @return The computed length
+ */
+ float length() {
+ return sqrtf(x() * x() + y() * y() + z() * z());
+ }
+
+ /**
+ * Linearly interpolate between two vectors
+ * @param v1 The first vector
+ * @param v2 The second vector
+ * @param a The value to use to interpolate between v1 and v2
+ * @return The resulting calculation
+ */
+ inline static Vector3d interpolate(const Vector3d& v1, const Vector3d& v2, const float a) {
+ return Vector3d(v1 * (1.0f - a) + v2 * a);
+ }
};
} // end of namespace Math
More information about the Scummvm-git-logs
mailing list