ilikecats/stk-code_catmod
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert "Running whitespaces.py; no more trailing whitespaces & tabs -> 4 spaces"

Browse Source 
This reverts commit 65e2dcf2f09e979b39f8d115da7d17dabac0b957.
This commit is contained in:
konstin 2014-03-29 11:32:04 +01:00
parent 65e2dcf2f0
commit 663fffdebb
218 changed files with 5512 additions and 5512 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/config/stk_config.hpp
View File

@ -67,7 +67,7 @@ public:
float m_parachute_ubound_fraction; /**<Upper bound fraction of speed when float m_parachute_ubound_fraction; /**<Upper bound fraction of speed when
lost will detach parachute. */ lost will detach parachute. */
float m_parachute_lbound_fraction; /**<Lower bound fraction of speed when float m_parachute_lbound_fraction; /**<Lower bound fraction of speed when
lost will detach parachute. */ lost will detach parachute. */
float m_parachute_max_speed; /**<Max speed to rate current speed */ float m_parachute_max_speed; /**<Max speed to rate current speed */
float m_parachute_time; /**<Time a parachute is active. */ float m_parachute_time; /**<Time a parachute is active. */
float m_parachute_time_other; /**<Time a parachute attached to other float m_parachute_time_other; /**<Time a parachute attached to other

614
src/graphics/CBatchingMesh.cpp
View File

@ -14,232 +14,232 @@ CBatchingMesh::CBatchingMesh()
CBatchingMesh::~CBatchingMesh() CBatchingMesh::~CBatchingMesh()
{ {
u32 i; u32 i;
for (i=0; i < DestBuffers.size(); ++i) for (i=0; i < DestBuffers.size(); ++i)
DestBuffers[i].Buffer->drop(); DestBuffers[i].Buffer->drop();
for (i=0; i < SourceBuffers.size(); ++i) for (i=0; i < SourceBuffers.size(); ++i)
SourceBuffers[i]->drop(); SourceBuffers[i]->drop();
} }
bool CBatchingMesh::isDirty(s32 id) bool CBatchingMesh::isDirty(s32 id)
{ {
if ((u32)id > DestBuffers.size()) if ((u32)id > DestBuffers.size())
return IsDirty; return IsDirty;
else else
return DestBuffers[id].IsDirty; return DestBuffers[id].IsDirty;
} }
//! refreshes the internal buffers from source //! refreshes the internal buffers from source
void CBatchingMesh::update() void CBatchingMesh::update()
{ {
// allocate the index and vertex arrays // allocate the index and vertex arrays
u32 i; u32 i;
for (i=0; i<DestBuffers.size(); ++i) for (i=0; i<DestBuffers.size(); ++i)
{ {
if (DestBuffers[i].IndexCount != DestBuffers[i].Buffer->getIndexCount() || if (DestBuffers[i].IndexCount != DestBuffers[i].Buffer->getIndexCount() ||
DestBuffers[i].VertexCount != DestBuffers[i].Buffer->getVertexCount()) DestBuffers[i].VertexCount != DestBuffers[i].Buffer->getVertexCount())
{ {
DestBuffers[i].IsDirty = true; DestBuffers[i].IsDirty = true;
switch (DestBuffers[i].VertexType) switch (DestBuffers[i].VertexType)
{ {
case video::EVT_STANDARD: case video::EVT_STANDARD:
{ {
SMeshBuffer* mb = (SMeshBuffer*)DestBuffers[i].Buffer; SMeshBuffer* mb = (SMeshBuffer*)DestBuffers[i].Buffer;
mb->Vertices.set_used(DestBuffers[i].VertexCount); mb->Vertices.set_used(DestBuffers[i].VertexCount);
mb->Indices.set_used(DestBuffers[i].IndexCount); mb->Indices.set_used(DestBuffers[i].IndexCount);
break; break;
} }
case video::EVT_2TCOORDS: case video::EVT_2TCOORDS:
{ {
SMeshBufferLightMap* mb = (SMeshBufferLightMap*)DestBuffers[i].Buffer; SMeshBufferLightMap* mb = (SMeshBufferLightMap*)DestBuffers[i].Buffer;
mb->Vertices.set_used(DestBuffers[i].VertexCount); mb->Vertices.set_used(DestBuffers[i].VertexCount);
mb->Indices.set_used(DestBuffers[i].IndexCount); mb->Indices.set_used(DestBuffers[i].IndexCount);
break; break;
} }
case video::EVT_TANGENTS: case video::EVT_TANGENTS:
{ {
SMeshBufferTangents* mb = (SMeshBufferTangents*)DestBuffers[i].Buffer; SMeshBufferTangents* mb = (SMeshBufferTangents*)DestBuffers[i].Buffer;
mb->Vertices.set_used(DestBuffers[i].VertexCount); mb->Vertices.set_used(DestBuffers[i].VertexCount);
mb->Indices.set_used(DestBuffers[i].IndexCount); mb->Indices.set_used(DestBuffers[i].IndexCount);
break; break;
} }
default: // shouldn't ever happen default: // shouldn't ever happen
continue; continue;
} }
} }
} }
// refresh dirty buffers from source // refresh dirty buffers from source
for (i=0; i<BufferReferences.size(); ++i) for (i=0; i<BufferReferences.size(); ++i)
{ {
if (DestBuffers[BufferReferences[i].DestReference].IsDirty) if (DestBuffers[BufferReferences[i].DestReference].IsDirty)
{ {
updateDestFromSourceBuffer(i); updateDestFromSourceBuffer(i);
} }
} }
// calculate bounding boxes // calculate bounding boxes
for (i=0; i< DestBuffers.size(); ++i) for (i=0; i< DestBuffers.size(); ++i)
{ {
if (DestBuffers[i].IsDirty) if (DestBuffers[i].IsDirty)
{ {
recalculateDestBufferBoundingBox(i); recalculateDestBufferBoundingBox(i);
// reset dirty state too // reset dirty state too
DestBuffers[i].IsDirty = false; DestBuffers[i].IsDirty = false;
} }
} }
IsDirty = false; IsDirty = false;
recalculateBoundingBox(); recalculateBoundingBox();
} }
//! adds a mesh to the buffers with the given offset //! adds a mesh to the buffers with the given offset
/** \Returns Returns an array of ID numbers */ /** \Returns Returns an array of ID numbers */
core::array<s32> CBatchingMesh::addMesh(IMesh* mesh, core::vector3df pos, core::vector3df rot, core::vector3df scale) core::array<s32> CBatchingMesh::addMesh(IMesh* mesh, core::vector3df pos, core::vector3df rot, core::vector3df scale)
{ {
core::matrix4 m; core::matrix4 m;
m.setRotationDegrees(rot); m.setRotationDegrees(rot);
m.setTranslation(pos); m.setTranslation(pos);
core::matrix4 scalem; core::matrix4 scalem;
scalem.setScale(scale); scalem.setScale(scale);
m *= scalem; m *= scalem;
return addMesh(mesh, m); return addMesh(mesh, m);
} }
//! adds a mesh with the given transformation //! adds a mesh with the given transformation
core::array<s32> CBatchingMesh::addMesh(IMesh* mesh, const core::matrix4 &transform) core::array<s32> CBatchingMesh::addMesh(IMesh* mesh, const core::matrix4 &transform)
{ {
core::array<s32> bufferNos; core::array<s32> bufferNos;
if (!mesh) if (!mesh)
return bufferNos; return bufferNos;
u32 i; u32 i;
for (i=0; i<mesh->getMeshBufferCount(); ++i) for (i=0; i<mesh->getMeshBufferCount(); ++i)
bufferNos.push_back(addMeshBuffer(mesh->getMeshBuffer(i), transform)); bufferNos.push_back(addMeshBuffer(mesh->getMeshBuffer(i), transform));
return bufferNos; return bufferNos;
} }
//! adds a mesh buffer with the given transformation //! adds a mesh buffer with the given transformation
/** \Return Returns the ID of this mesh buffer */ /** \Return Returns the ID of this mesh buffer */
s32 CBatchingMesh::addMeshBuffer(IMeshBuffer* buffer, core::vector3df pos, core::vector3df rot, core::vector3df scale) s32 CBatchingMesh::addMeshBuffer(IMeshBuffer* buffer, core::vector3df pos, core::vector3df rot, core::vector3df scale)
{ {
core::matrix4 m; core::matrix4 m;
m.setRotationDegrees(rot); m.setRotationDegrees(rot);
m.setTranslation(pos); m.setTranslation(pos);
core::matrix4 scalem; core::matrix4 scalem;
scalem.setScale(scale); scalem.setScale(scale);
m *= scalem; m *= scalem;
return addMeshBuffer(buffer, m); return addMeshBuffer(buffer, m);
} }
//! adds a mesh with the given transformation //! adds a mesh with the given transformation
/** \Return Returns the ID of this mesh buffer */ /** \Return Returns the ID of this mesh buffer */
s32 CBatchingMesh::addMeshBuffer(IMeshBuffer* buffer, const core::matrix4 &transform) s32 CBatchingMesh::addMeshBuffer(IMeshBuffer* buffer, const core::matrix4 &transform)
{ {
if (!buffer || IsFinal) if (!buffer || IsFinal)
return -1; return -1;
u32 i; u32 i;
video::SMaterial m = buffer->getMaterial(); video::SMaterial m = buffer->getMaterial();
// find material // find material
bool found=false; bool found=false;
video::E_VERTEX_TYPE vt = buffer->getVertexType(); video::E_VERTEX_TYPE vt = buffer->getVertexType();
for (i=0; i<MaterialReferences.size(); ++i) for (i=0; i<MaterialReferences.size(); ++i)
{ {
if (MaterialReferences[i].VertexType == vt && if (MaterialReferences[i].VertexType == vt &&
MaterialReferences[i].Material == m) MaterialReferences[i].Material == m)
{ {
// will there be too many vertices in the buffer? // will there be too many vertices in the buffer?
u32 newTotalI = buffer->getIndexCount() + DestBuffers[ MaterialReferences[i].BufferIndex ].IndexCount; u32 newTotalI = buffer->getIndexCount() + DestBuffers[ MaterialReferences[i].BufferIndex ].IndexCount;
u32 newTotalV = buffer->getVertexCount() + DestBuffers[ MaterialReferences[i].BufferIndex ].VertexCount; u32 newTotalV = buffer->getVertexCount() + DestBuffers[ MaterialReferences[i].BufferIndex ].VertexCount;
if ( newTotalI < 65536*3 && newTotalV < 65536) if ( newTotalI < 65536*3 && newTotalV < 65536)
{ {
found = true; found = true;
DestBuffers[ MaterialReferences[i].BufferIndex ].IndexCount = newTotalI; DestBuffers[ MaterialReferences[i].BufferIndex ].IndexCount = newTotalI;
DestBuffers[ MaterialReferences[i].BufferIndex ].VertexCount = newTotalV; DestBuffers[ MaterialReferences[i].BufferIndex ].VertexCount = newTotalV;
break; break;
} }
} }
} }
if (!found) if (!found)
{ {
// we need a new destination buffer and material reference // we need a new destination buffer and material reference
IMeshBuffer *mb=0; IMeshBuffer *mb=0;
SMaterialReference r; SMaterialReference r;
r.Material = m; r.Material = m;
r.VertexType = vt; r.VertexType = vt;
r.BufferIndex = DestBuffers.size(); r.BufferIndex = DestBuffers.size();
switch (vt) switch (vt)
{ {
case video::EVT_STANDARD: case video::EVT_STANDARD:
mb = (IMeshBuffer*)new SMeshBuffer(); mb = (IMeshBuffer*)new SMeshBuffer();
mb->getMaterial() = m; mb->getMaterial() = m;
break; break;
case video::EVT_2TCOORDS: case video::EVT_2TCOORDS:
mb = (IMeshBuffer*)new SMeshBufferLightMap(); mb = (IMeshBuffer*)new SMeshBufferLightMap();
mb->getMaterial() = m; mb->getMaterial() = m;
break; break;
case video::EVT_TANGENTS: case video::EVT_TANGENTS:
mb = (IMeshBuffer*)new SMeshBufferTangents(); mb = (IMeshBuffer*)new SMeshBufferTangents();
mb->getMaterial() = m; mb->getMaterial() = m;
break; break;
default: // unknown vertex type default: // unknown vertex type
return -1; return -1;
} }
i = MaterialReferences.size(); i = MaterialReferences.size();
MaterialReferences.push_back(r); MaterialReferences.push_back(r);
SDestBufferReference db; SDestBufferReference db;
db.Buffer = mb; db.Buffer = mb;
db.IndexCount = buffer->getIndexCount(); db.IndexCount = buffer->getIndexCount();
db.VertexCount = buffer->getVertexCount(); db.VertexCount = buffer->getVertexCount();
db.IsDirty = true; db.IsDirty = true;
db.VertexType = vt; db.VertexType = vt;
DestBuffers.push_back(db); DestBuffers.push_back(db);
} }
// now we add the mesh reference // now we add the mesh reference
SBufferReference r; SBufferReference r;
r.DestReference = i; r.DestReference = i;
r.SourceBuffer = buffer; r.SourceBuffer = buffer;
r.Transform = transform; r.Transform = transform;
r.IndexCount = buffer->getIndexCount(); r.IndexCount = buffer->getIndexCount();
r.VertexCount = buffer->getVertexCount(); r.VertexCount = buffer->getVertexCount();
r.FirstIndex = DestBuffers[ MaterialReferences[i].BufferIndex ].IndexCount - r.IndexCount; r.FirstIndex = DestBuffers[ MaterialReferences[i].BufferIndex ].IndexCount - r.IndexCount;
r.FirstVertex = DestBuffers[ MaterialReferences[i].BufferIndex ].VertexCount - r.VertexCount; r.FirstVertex = DestBuffers[ MaterialReferences[i].BufferIndex ].VertexCount - r.VertexCount;
r.Initialized = false; r.Initialized = false;
BufferReferences.push_back(r); BufferReferences.push_back(r);
addSourceBuffer(buffer); addSourceBuffer(buffer);
IsDirty = true; IsDirty = true;
return BufferReferences.size()-1; return BufferReferences.size()-1;
} }
//! updates bouding box from internal buffers //! updates bouding box from internal buffers
void CBatchingMesh::recalculateBoundingBox() void CBatchingMesh::recalculateBoundingBox()
{ {
if (DestBuffers.size() == 0) if (DestBuffers.size() == 0)
Box.reset(0,0,0); Box.reset(0,0,0);
else else
{ {
Box.reset(DestBuffers[0].Buffer->getBoundingBox().MinEdge); Box.reset(DestBuffers[0].Buffer->getBoundingBox().MinEdge);
u32 i; u32 i;
for (i=0; i < DestBuffers.size(); ++i) for (i=0; i < DestBuffers.size(); ++i)
Box.addInternalBox(DestBuffers[i].Buffer->getBoundingBox()); Box.addInternalBox(DestBuffers[i].Buffer->getBoundingBox());
} }
} }
@ -249,7 +249,7 @@ void CBatchingMesh::recalculateBoundingBox()
/** \return Returns the amount of mesh buffers (IMeshBuffer) in this mesh. */ /** \return Returns the amount of mesh buffers (IMeshBuffer) in this mesh. */
u32 CBatchingMesh::getMeshBufferCount() const u32 CBatchingMesh::getMeshBufferCount() const
{ {
return DestBuffers.size(); return DestBuffers.size();
} }
//! Returns pointer to a mesh buffer. //! Returns pointer to a mesh buffer.
@ -259,29 +259,29 @@ getMeshBufferCount() - 1;
NULL if there is no such mesh buffer. */ NULL if there is no such mesh buffer. */
IMeshBuffer* CBatchingMesh::getMeshBuffer(u32 nr) const IMeshBuffer* CBatchingMesh::getMeshBuffer(u32 nr) const
{ {
if (nr < DestBuffers.size()) if (nr < DestBuffers.size())
return DestBuffers[nr].Buffer; return DestBuffers[nr].Buffer;
else else
return 0; return 0;
} }
//! Returns pointer to a mesh buffer which fits a material //! Returns pointer to a mesh buffer which fits a material
IMeshBuffer* CBatchingMesh::getMeshBuffer( const video::SMaterial &material) const IMeshBuffer* CBatchingMesh::getMeshBuffer( const video::SMaterial &material) const
{ {
return 0; return 0;
} }
//! Returns an axis aligned bounding box of the mesh. //! Returns an axis aligned bounding box of the mesh.
/** \return A bounding box of this mesh is returned. */ /** \return A bounding box of this mesh is returned. */
const core::aabbox3d<f32>& CBatchingMesh::getBoundingBox() const const core::aabbox3d<f32>& CBatchingMesh::getBoundingBox() const
{ {
return Box; return Box;
} }
//! set user axis aligned bounding box //! set user axis aligned bounding box
void CBatchingMesh::setBoundingBox( const core::aabbox3df& box) void CBatchingMesh::setBoundingBox( const core::aabbox3df& box)
{ {
Box = box; Box = box;
} }
//! Sets a flag of all contained materials to a new value. //! Sets a flag of all contained materials to a new value.
@ -289,218 +289,218 @@ void CBatchingMesh::setBoundingBox( const core::aabbox3df& box)
\param newvalue: New value to set in all materials. */ \param newvalue: New value to set in all materials. */
void CBatchingMesh::setMaterialFlag(video::E_MATERIAL_FLAG flag, bool newvalue) void CBatchingMesh::setMaterialFlag(video::E_MATERIAL_FLAG flag, bool newvalue)
{ {
for (u32 i=0; i<DestBuffers.size(); ++i) for (u32 i=0; i<DestBuffers.size(); ++i)
DestBuffers[i].Buffer->getMaterial().setFlag(flag, newvalue); DestBuffers[i].Buffer->getMaterial().setFlag(flag, newvalue);
} }
//! drops all buffers and clears internal states //! drops all buffers and clears internal states
void CBatchingMesh::clear() void CBatchingMesh::clear()
{ {
u32 i; u32 i;
for (i=0; i < DestBuffers.size(); ++i) for (i=0; i < DestBuffers.size(); ++i)
DestBuffers[i].Buffer->drop(); DestBuffers[i].Buffer->drop();
for (i=0; i < SourceBuffers.size(); ++i) for (i=0; i < SourceBuffers.size(); ++i)
SourceBuffers[i]->drop(); SourceBuffers[i]->drop();
BufferReferences.clear(); BufferReferences.clear();
MaterialReferences.clear(); MaterialReferences.clear();
DestBuffers.clear(); DestBuffers.clear();
SourceBuffers.clear(); SourceBuffers.clear();
IsDirty = false; IsDirty = false;
IsFinal = false; IsFinal = false;
} }
//! first updates the mesh, then drops all source buffers. //! first updates the mesh, then drops all source buffers.
/** once this mesh has been finalized, it cannot be changed again! */ /** once this mesh has been finalized, it cannot be changed again! */
void CBatchingMesh::finalize() void CBatchingMesh::finalize()
{ {
update(); update();
for (u32 i=0; i < SourceBuffers.size(); ++i) for (u32 i=0; i < SourceBuffers.size(); ++i)
SourceBuffers[i]->drop(); SourceBuffers[i]->drop();
SourceBuffers.clear(); SourceBuffers.clear();
IsFinal = true; IsFinal = true;
} }
//! Moves a mesh //! Moves a mesh
core::array<bool> CBatchingMesh::moveMesh(const core::array<s32>& bufferIDs, const core::matrix4 &newMatrix) core::array<bool> CBatchingMesh::moveMesh(const core::array<s32>& bufferIDs, const core::matrix4 &newMatrix)
{ {
core::array<bool> result; core::array<bool> result;
result.reallocate(bufferIDs.size()); result.reallocate(bufferIDs.size());
for (u32 i=0; i<bufferIDs.size(); ++i) for (u32 i=0; i<bufferIDs.size(); ++i)
result.push_back(moveMeshBuffer(bufferIDs[i], newMatrix)); result.push_back(moveMeshBuffer(bufferIDs[i], newMatrix));
return result; return result;
} }
//! Moves a mesh buffer //! Moves a mesh buffer
bool CBatchingMesh::moveMeshBuffer(const s32 id, const core::matrix4 &newMatrix) bool CBatchingMesh::moveMeshBuffer(const s32 id, const core::matrix4 &newMatrix)
{ {
if ((u32)id > BufferReferences.size() || IsFinal ) if ((u32)id > BufferReferences.size() || IsFinal )
return false; return false;
BufferReferences[id].Transform = newMatrix; BufferReferences[id].Transform = newMatrix;
// is the source buffer dirty? // is the source buffer dirty?
if (!DestBuffers[BufferReferences[id].DestReference].IsDirty) if (!DestBuffers[BufferReferences[id].DestReference].IsDirty)
{ {
// transform each vertex and normal // transform each vertex and normal
updateDestFromSourceBuffer(id); updateDestFromSourceBuffer(id);
recalculateDestBufferBoundingBox(BufferReferences[id].DestReference); recalculateDestBufferBoundingBox(BufferReferences[id].DestReference);
} }
return true; return true;
} }
//! returns the source buffer, if available //! returns the source buffer, if available
IMeshBuffer* CBatchingMesh::getSourceBuffer(s32 id) IMeshBuffer* CBatchingMesh::getSourceBuffer(s32 id)
{ {
if ((u32)id > BufferReferences.size() || IsFinal) if ((u32)id > BufferReferences.size() || IsFinal)
return 0; return 0;
else else
return BufferReferences[id].SourceBuffer; return BufferReferences[id].SourceBuffer;
} }
//! returns the matrix of the source buffer //! returns the matrix of the source buffer
core::matrix4 CBatchingMesh::getSourceBufferMatrix(s32 id) core::matrix4 CBatchingMesh::getSourceBufferMatrix(s32 id)
{ {
core::matrix4 ret; core::matrix4 ret;
if ((u32)id > BufferReferences.size() || IsFinal) if ((u32)id > BufferReferences.size() || IsFinal)
ret.makeIdentity(); ret.makeIdentity();
else else
ret = BufferReferences[id].Transform; ret = BufferReferences[id].Transform;
return ret; return ret;
} }
//! returns the number of source buffers //! returns the number of source buffers
u32 CBatchingMesh::getSourceBufferCount() const u32 CBatchingMesh::getSourceBufferCount() const
{ {
return BufferReferences.size(); return BufferReferences.size();
} }
// private functions // private functions
void CBatchingMesh::recalculateDestBufferBoundingBox(u32 i) void CBatchingMesh::recalculateDestBufferBoundingBox(u32 i)
{ {
switch (DestBuffers[i].VertexType) switch (DestBuffers[i].VertexType)
{ {
case video::EVT_STANDARD: case video::EVT_STANDARD:
((SMeshBuffer*)DestBuffers[i].Buffer)->recalculateBoundingBox(); ((SMeshBuffer*)DestBuffers[i].Buffer)->recalculateBoundingBox();
break; break;
case video::EVT_2TCOORDS: case video::EVT_2TCOORDS:
((SMeshBufferLightMap*)DestBuffers[i].Buffer)->recalculateBoundingBox(); ((SMeshBufferLightMap*)DestBuffers[i].Buffer)->recalculateBoundingBox();
break; break;
case video::EVT_TANGENTS: case video::EVT_TANGENTS:
((SMeshBufferTangents*)DestBuffers[i].Buffer)->recalculateBoundingBox(); ((SMeshBufferTangents*)DestBuffers[i].Buffer)->recalculateBoundingBox();
break; break;
} }
} }
void CBatchingMesh::updateDestFromSourceBuffer(u32 i) void CBatchingMesh::updateDestFromSourceBuffer(u32 i)
{ {
u16* ind = BufferReferences[i].SourceBuffer->getIndices(); u16* ind = BufferReferences[i].SourceBuffer->getIndices();
void*ver = BufferReferences[i].SourceBuffer->getVertices(); void*ver = BufferReferences[i].SourceBuffer->getVertices();
core::matrix4 m = BufferReferences[i].Transform; core::matrix4 m = BufferReferences[i].Transform;
u32 fi = BufferReferences[i].FirstIndex; u32 fi = BufferReferences[i].FirstIndex;
u32 fv = BufferReferences[i].FirstVertex; u32 fv = BufferReferences[i].FirstVertex;
u32 ic = BufferReferences[i].IndexCount; u32 ic = BufferReferences[i].IndexCount;
u32 vc = BufferReferences[i].VertexCount; u32 vc = BufferReferences[i].VertexCount;
u32 x; u32 x;
video::E_VERTEX_TYPE vt = DestBuffers[BufferReferences[i].DestReference].VertexType; video::E_VERTEX_TYPE vt = DestBuffers[BufferReferences[i].DestReference].VertexType;
switch (vt) switch (vt)
{ {
case video::EVT_STANDARD: case video::EVT_STANDARD:
{ {
SMeshBuffer* dest = (SMeshBuffer*) DestBuffers[BufferReferences[i].DestReference].Buffer; SMeshBuffer* dest = (SMeshBuffer*) DestBuffers[BufferReferences[i].DestReference].Buffer;
for (x=fi; x < fi+ic; ++x) for (x=fi; x < fi+ic; ++x)
dest->Indices[x] = ind[x-fi]+fv; dest->Indices[x] = ind[x-fi]+fv;
video::S3DVertex* vertices= (video::S3DVertex*) ver; video::S3DVertex* vertices= (video::S3DVertex*) ver;
for (x=fv; x < fv+vc; ++x) for (x=fv; x < fv+vc; ++x)
{ {
dest->Vertices[x] = vertices[x-fv]; dest->Vertices[x] = vertices[x-fv];
m.transformVect(dest->Vertices[x].Pos); m.transformVect(dest->Vertices[x].Pos);
m.rotateVect(dest->Vertices[x].Normal); m.rotateVect(dest->Vertices[x].Normal);
} }
break; break;
} }
case video::EVT_2TCOORDS: case video::EVT_2TCOORDS:
{ {
SMeshBufferLightMap* dest = (SMeshBufferLightMap*) DestBuffers[BufferReferences[i].DestReference].Buffer; SMeshBufferLightMap* dest = (SMeshBufferLightMap*) DestBuffers[BufferReferences[i].DestReference].Buffer;
for (x=fi; x < fi+ic; ++x) for (x=fi; x < fi+ic; ++x)
dest->Indices[x] = ind[x-fi]+fv; dest->Indices[x] = ind[x-fi]+fv;
video::S3DVertex2TCoords* vertices= (video::S3DVertex2TCoords*) ver; video::S3DVertex2TCoords* vertices= (video::S3DVertex2TCoords*) ver;
for (x=fv; x < fv+vc; ++x) for (x=fv; x < fv+vc; ++x)
{ {
dest->Vertices[x] = vertices[x-fv]; dest->Vertices[x] = vertices[x-fv];
m.transformVect(dest->Vertices[x].Pos); m.transformVect(dest->Vertices[x].Pos);
m.rotateVect(dest->Vertices[x].Normal); m.rotateVect(dest->Vertices[x].Normal);
} }
break; break;
} }
case video::EVT_TANGENTS: case video::EVT_TANGENTS:
{ {
SMeshBufferTangents* dest = (SMeshBufferTangents*) DestBuffers[BufferReferences[i].DestReference].Buffer; SMeshBufferTangents* dest = (SMeshBufferTangents*) DestBuffers[BufferReferences[i].DestReference].Buffer;
for (x=fi; x < fi+ic; ++x) for (x=fi; x < fi+ic; ++x)
dest->Indices[x] = ind[x-fi]+fv; dest->Indices[x] = ind[x-fi]+fv;
video::S3DVertexTangents* vertices= (video::S3DVertexTangents*) ver; video::S3DVertexTangents* vertices= (video::S3DVertexTangents*) ver;
for (x=fv; x < fv+vc; ++x) for (x=fv; x < fv+vc; ++x)
{ {
dest->Vertices[x] = vertices[x-fv]; dest->Vertices[x] = vertices[x-fv];
m.transformVect(dest->Vertices[x].Pos); m.transformVect(dest->Vertices[x].Pos);
m.rotateVect(dest->Vertices[x].Normal); // are tangents/binormals in face space? m.rotateVect(dest->Vertices[x].Normal); // are tangents/binormals in face space?
} }
break; break;
} }
default: default:
break; break;
} }
} }
void CBatchingMesh::addSourceBuffer(IMeshBuffer *source) void CBatchingMesh::addSourceBuffer(IMeshBuffer *source)
{ {
bool found = false; bool found = false;
for (u32 i=0; i<SourceBuffers.size(); ++i) for (u32 i=0; i<SourceBuffers.size(); ++i)
{ {
if (SourceBuffers[i] == source) if (SourceBuffers[i] == source)
{ {
found = true; found = true;
break; break;
} }
} }
if (!found) if (!found)
{ {
source->grab(); source->grab();
SourceBuffers.push_back(source); SourceBuffers.push_back(source);
} }
} }
void CBatchingMesh::setHardwareMappingHint(E_HARDWARE_MAPPING mapping, E_BUFFER_TYPE type) void CBatchingMesh::setHardwareMappingHint(E_HARDWARE_MAPPING mapping, E_BUFFER_TYPE type)
{ {
for (u32 i=0; i < DestBuffers.size(); ++i) for (u32 i=0; i < DestBuffers.size(); ++i)
DestBuffers[i].Buffer->setHardwareMappingHint(mapping, type); DestBuffers[i].Buffer->setHardwareMappingHint(mapping, type);
} }
void CBatchingMesh::setDirty(E_BUFFER_TYPE type) void CBatchingMesh::setDirty(E_BUFFER_TYPE type)
{ {
for (u32 i=0; i < DestBuffers.size(); ++i) for (u32 i=0; i < DestBuffers.size(); ++i)
DestBuffers[i].Buffer->setDirty(type); DestBuffers[i].Buffer->setDirty(type);
} }
} // namespace scene } // namespace scene

226
src/graphics/CBatchingMesh.hpp
View File

@ -15,157 +15,157 @@ namespace scene
class CBatchingMesh : public IMesh class CBatchingMesh : public IMesh
{ {
public: public:
CBatchingMesh(); CBatchingMesh();
virtual ~CBatchingMesh(); virtual ~CBatchingMesh();
//! returns true if new buffers have been added without updating the internal buffers //! returns true if new buffers have been added without updating the internal buffers
bool isDirty(s32 id=-1); bool isDirty(s32 id=-1);
//! refreshes the internal buffers from source //! refreshes the internal buffers from source
void update(); void update();
//! drops all buffers and clears internal states //! drops all buffers and clears internal states
void clear(); void clear();
//! first updates the mesh, then drops all source buffers. //! first updates the mesh, then drops all source buffers.
/** once this mesh has been finalized, it cannot be changed again! */ /** once this mesh has been finalized, it cannot be changed again! */
void finalize(); void finalize();
//! adds a mesh to the buffers with the given offset //! adds a mesh to the buffers with the given offset
/** \Return: Returns an array of ID numbers */ /** \Return: Returns an array of ID numbers */
core::array<s32> addMesh(IMesh* mesh, core::array<s32> addMesh(IMesh* mesh,
core::vector3df pos = core::vector3df(0,0,0), core::vector3df pos = core::vector3df(0,0,0),
core::vector3df rot = core::vector3df(0,0,0), core::vector3df rot = core::vector3df(0,0,0),
core::vector3df scale = core::vector3df(1,1,1)); core::vector3df scale = core::vector3df(1,1,1));
//! adds a mesh with the given transformation //! adds a mesh with the given transformation
/** \Return: Returns an array of ID numbers */ /** \Return: Returns an array of ID numbers */
core::array<s32> addMesh(IMesh* mesh, const core::matrix4 &transform); core::array<s32> addMesh(IMesh* mesh, const core::matrix4 &transform);
//! adds a mesh buffer with the given transformation //! adds a mesh buffer with the given transformation
/** \Return: Returns the ID of this mesh buffer */ /** \Return: Returns the ID of this mesh buffer */
s32 addMeshBuffer(IMeshBuffer* buffer, s32 addMeshBuffer(IMeshBuffer* buffer,
core::vector3df pos = core::vector3df(0,0,0), core::vector3df pos = core::vector3df(0,0,0),
core::vector3df rot = core::vector3df(0,0,0), core::vector3df rot = core::vector3df(0,0,0),
core::vector3df scale = core::vector3df(1,1,1)); core::vector3df scale = core::vector3df(1,1,1));
//! adds a mesh with the given transformation //! adds a mesh with the given transformation
/** \Return Returns the ID of this mesh buffer */ /** \Return Returns the ID of this mesh buffer */
s32 addMeshBuffer(IMeshBuffer* buffer, const core::matrix4 &transform); s32 addMeshBuffer(IMeshBuffer* buffer, const core::matrix4 &transform);
//! updates bouding box from internal buffers //! updates bouding box from internal buffers
void recalculateBoundingBox(); void recalculateBoundingBox();
//! Moves a mesh, //! Moves a mesh,
/** mesh buffers in clean destination buffers will be moved immediately, /** mesh buffers in clean destination buffers will be moved immediately,
ones in dirty buffers will be left until the next update */ ones in dirty buffers will be left until the next update */
core::array<bool> moveMesh(const core::array<s32>& bufferIDs, const core::matrix4 &newMatrix); core::array<bool> moveMesh(const core::array<s32>& bufferIDs, const core::matrix4 &newMatrix);
//! Moves a mesh buffer //! Moves a mesh buffer
/** if the destination buffer is clean it will be moved immediately, /** if the destination buffer is clean it will be moved immediately,
if a member of a dirty buffer, it will be left until the next update */ if a member of a dirty buffer, it will be left until the next update */
bool moveMeshBuffer(const s32 id, const core::matrix4 &newMatrix); bool moveMeshBuffer(const s32 id, const core::matrix4 &newMatrix);
//! returns the source buffer, if available //! returns the source buffer, if available
IMeshBuffer* getSourceBuffer(s32 id); IMeshBuffer* getSourceBuffer(s32 id);
//! returns the matrix of the source buffer //! returns the matrix of the source buffer
core::matrix4 getSourceBufferMatrix(s32 id); core::matrix4 getSourceBufferMatrix(s32 id);
//! returns the number of source buffers //! returns the number of source buffers
u32 getSourceBufferCount() const; u32 getSourceBufferCount() const;
/* Standard IMesh functions */ /* Standard IMesh functions */
//! Returns the amount of mesh buffers. //! Returns the amount of mesh buffers.
/** \return Returns the amount of mesh buffers (IMeshBuffer) in this mesh. */ /** \return Returns the amount of mesh buffers (IMeshBuffer) in this mesh. */
virtual u32 getMeshBufferCount() const; virtual u32 getMeshBufferCount() const;
//! Returns pointer to a mesh buffer. //! Returns pointer to a mesh buffer.
/** \param nr: Zero based index of the mesh buffer. The maximum value is /** \param nr: Zero based index of the mesh buffer. The maximum value is
getMeshBufferCount() - 1; getMeshBufferCount() - 1;
\return Returns the pointer to the mesh buffer or \return Returns the pointer to the mesh buffer or
NULL if there is no such mesh buffer. */ NULL if there is no such mesh buffer. */
virtual IMeshBuffer* getMeshBuffer(u32 nr) const; virtual IMeshBuffer* getMeshBuffer(u32 nr) const;
//! Returns pointer to a mesh buffer which fits a material //! Returns pointer to a mesh buffer which fits a material
/** \param material: material to search for /** \param material: material to search for
\return Returns the pointer to the mesh buffer or \return Returns the pointer to the mesh buffer or
NULL if there is no such mesh buffer. */ NULL if there is no such mesh buffer. */
virtual IMeshBuffer* getMeshBuffer( const video::SMaterial &material) const; virtual IMeshBuffer* getMeshBuffer( const video::SMaterial &material) const;
//! Returns an axis aligned bounding box of the mesh. //! Returns an axis aligned bounding box of the mesh.
/** \return A bounding box of this mesh is returned. */ /** \return A bounding box of this mesh is returned. */
virtual const core::aabbox3d<f32>& getBoundingBox() const; virtual const core::aabbox3d<f32>& getBoundingBox() const;
//! set user axis aligned bounding box //! set user axis aligned bounding box
virtual void setBoundingBox( const core::aabbox3df& box); virtual void setBoundingBox( const core::aabbox3df& box);
//! Sets a flag of all contained materials to a new value. //! Sets a flag of all contained materials to a new value.
/** \param flag: Flag to set in all materials. /** \param flag: Flag to set in all materials.
\param newvalue: New value to set in all materials. */ \param newvalue: New value to set in all materials. */
virtual void setMaterialFlag(video::E_MATERIAL_FLAG flag, bool newvalue); virtual void setMaterialFlag(video::E_MATERIAL_FLAG flag, bool newvalue);
virtual void setHardwareMappingHint(E_HARDWARE_MAPPING mapping, E_BUFFER_TYPE type); virtual void setHardwareMappingHint(E_HARDWARE_MAPPING mapping, E_BUFFER_TYPE type);
virtual void setDirty(E_BUFFER_TYPE type); virtual void setDirty(E_BUFFER_TYPE type);
private: private:
// add a buffer to the source buffers array if it doesn't already exist // add a buffer to the source buffers array if it doesn't already exist
void addSourceBuffer(IMeshBuffer* source); void addSourceBuffer(IMeshBuffer* source);
// updates the vertices in dest buffer from the source one // updates the vertices in dest buffer from the source one
void updateDestFromSourceBuffer(u32 id); void updateDestFromSourceBuffer(u32 id);
// recalculates the bounding box for the given dest buffer // recalculates the bounding box for the given dest buffer
void recalculateDestBufferBoundingBox(u32 i); void recalculateDestBufferBoundingBox(u32 i);
struct SBufferReference struct SBufferReference
{ {
SBufferReference() SBufferReference()
: SourceBuffer(0), DestReference(0), FirstVertex(0), VertexCount(0), : SourceBuffer(0), DestReference(0), FirstVertex(0), VertexCount(0),
FirstIndex(0), IndexCount(0), Initialized(false) { } FirstIndex(0), IndexCount(0), Initialized(false) { }
IMeshBuffer* SourceBuffer; IMeshBuffer* SourceBuffer;
u32 DestReference; u32 DestReference;
u32 FirstVertex, VertexCount, FirstIndex, IndexCount; u32 FirstVertex, VertexCount, FirstIndex, IndexCount;
core::matrix4 Transform; core::matrix4 Transform;
bool Initialized; bool Initialized;
}; };
struct SMaterialReference struct SMaterialReference
{ {
video::SMaterial Material; video::SMaterial Material;
video::E_VERTEX_TYPE VertexType; video::E_VERTEX_TYPE VertexType;
u32 BufferIndex; u32 BufferIndex;
}; };
struct SDestBufferReference struct SDestBufferReference
{ {
IMeshBuffer* Buffer; IMeshBuffer* Buffer;
video::E_VERTEX_TYPE VertexType; video::E_VERTEX_TYPE VertexType;
u32 VertexCount; u32 VertexCount;
u32 IndexCount; u32 IndexCount;
bool IsDirty; bool IsDirty;
}; };
//! Source mesh buffers, these are locked //! Source mesh buffers, these are locked
core::array<IMeshBuffer*> SourceBuffers; core::array<IMeshBuffer*> SourceBuffers;
core::array<SBufferReference> BufferReferences; core::array<SBufferReference> BufferReferences;
core::array<SMaterialReference> MaterialReferences; core::array<SMaterialReference> MaterialReferences;
core::array<SDestBufferReference> DestBuffers; core::array<SDestBufferReference> DestBuffers;
//! bounding containing all destination buffers //! bounding containing all destination buffers
core::aabbox3d<f32> Box; core::aabbox3d<f32> Box;
//! does it require an update? //! does it require an update?
bool IsDirty; bool IsDirty;
//! can it be changed? //! can it be changed?
bool IsFinal; bool IsFinal;
}; };
} // namespace scene } // namespace scene

26
src/graphics/callbacks.cpp
View File

@ -558,21 +558,21 @@ void DisplaceProvider::OnSetConstants(IMaterialRendererServices *srv, int)
void DisplaceProvider::update() void DisplaceProvider::update()
{ {
const float time = irr_driver->getDevice()->getTimer()->getTime() / 1000.0f; const float time = irr_driver->getDevice()->getTimer()->getTime() / 1000.0f;
const float speed = World::getWorld()->getTrack()->getDisplacementSpeed(); const float speed = World::getWorld()->getTrack()->getDisplacementSpeed();
float strength = time; float strength = time;
strength = fabsf(noise2d(strength / 10.0f)) * 0.006f + 0.002f; strength = fabsf(noise2d(strength / 10.0f)) * 0.006f + 0.002f;
vector3df wind = irr_driver->getWind() * strength * speed; vector3df wind = irr_driver->getWind() * strength * speed;
m_dir[0] += wind.X; m_dir[0] += wind.X;
m_dir[1] += wind.Z; m_dir[1] += wind.Z;
strength = time * 0.56f + sinf(time); strength = time * 0.56f + sinf(time);
strength = fabsf(noise2d(0.0, strength / 6.0f)) * 0.0095f + 0.0025f; strength = fabsf(noise2d(0.0, strength / 6.0f)) * 0.0095f + 0.0025f;
wind = irr_driver->getWind() * strength * speed; wind = irr_driver->getWind() * strength * speed;
wind.rotateXZBy(cosf(time)); wind.rotateXZBy(cosf(time));
m_dir2[0] += wind.X; m_dir2[0] += wind.X;
m_dir2[1] += wind.Z; m_dir2[1] += wind.Z;
} }

74
src/graphics/callbacks.hpp
View File

@ -121,15 +121,15 @@ public:
m_amplitude = amp; m_amplitude = amp;
} }
float getSpeed() const float getSpeed() const
{ {
return m_speed; return m_speed;
} }
float getAmplitude() const float getAmplitude() const
{ {
return m_amplitude; return m_amplitude;
} }
private: private:
float m_amplitude, m_speed; float m_amplitude, m_speed;
@ -327,20 +327,20 @@ public:
m_color[2] = b; m_color[2] = b;
} }
float getRed() const float getRed() const
{ {
return m_color[0]; return m_color[0];
} }
float getGreen() const float getGreen() const
{ {
return m_color[1]; return m_color[1];
} }
float getBlue() const float getBlue() const
{ {
return m_color[2]; return m_color[2];
} }
private: private:
float m_color[3]; float m_color[3];
@ -555,27 +555,27 @@ public:
m_dir[0] = m_dir[1] = m_dir2[0] = m_dir2[1] = 0; m_dir[0] = m_dir[1] = m_dir2[0] = m_dir2[1] = 0;
} }
void update(); void update();
float getDirX() const float getDirX() const
{ {
return m_dir[0]; return m_dir[0];
} }
float getDirY() const float getDirY() const
{ {
return m_dir[1]; return m_dir[1];
} }
float getDir2X() const float getDir2X() const
{ {
return m_dir2[0]; return m_dir2[0];
} }
float getDir2Y() const float getDir2Y() const
{ {
return m_dir2[1]; return m_dir2[1];
} }
private: private:
float m_screen[2]; float m_screen[2];

308
src/graphics/glwrap.cpp
View File

@ -141,64 +141,64 @@ debugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei le
void initGL() void initGL()
{ {
if (is_gl_init) if (is_gl_init)
return; return;
is_gl_init = true; is_gl_init = true;
#ifdef _IRR_WINDOWS_API_ #ifdef _IRR_WINDOWS_API_
glGenTransformFeedbacks = (PFNGLGENTRANSFORMFEEDBACKSPROC)IRR_OGL_LOAD_EXTENSION("glGenTransformFeedbacks"); glGenTransformFeedbacks = (PFNGLGENTRANSFORMFEEDBACKSPROC)IRR_OGL_LOAD_EXTENSION("glGenTransformFeedbacks");
glBindTransformFeedback = (PFNGLBINDTRANSFORMFEEDBACKPROC)IRR_OGL_LOAD_EXTENSION("glBindTransformFeedback"); glBindTransformFeedback = (PFNGLBINDTRANSFORMFEEDBACKPROC)IRR_OGL_LOAD_EXTENSION("glBindTransformFeedback");
glDrawTransformFeedback = (PFNGLDRAWTRANSFORMFEEDBACKPROC)IRR_OGL_LOAD_EXTENSION("glDrawTransformFeedback"); glDrawTransformFeedback = (PFNGLDRAWTRANSFORMFEEDBACKPROC)IRR_OGL_LOAD_EXTENSION("glDrawTransformFeedback");
glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)IRR_OGL_LOAD_EXTENSION("glBeginTransformFeedback"); glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)IRR_OGL_LOAD_EXTENSION("glBeginTransformFeedback");
glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)IRR_OGL_LOAD_EXTENSION("glEndTransformFeedback"); glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)IRR_OGL_LOAD_EXTENSION("glEndTransformFeedback");
glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)IRR_OGL_LOAD_EXTENSION("glBindBufferBase"); glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)IRR_OGL_LOAD_EXTENSION("glBindBufferBase");
glGenBuffers = (PFNGLGENBUFFERSPROC)IRR_OGL_LOAD_EXTENSION("glGenBuffers"); glGenBuffers = (PFNGLGENBUFFERSPROC)IRR_OGL_LOAD_EXTENSION("glGenBuffers");
glBindBuffer = (PFNGLBINDBUFFERPROC)IRR_OGL_LOAD_EXTENSION("glBindBuffer"); glBindBuffer = (PFNGLBINDBUFFERPROC)IRR_OGL_LOAD_EXTENSION("glBindBuffer");
glBufferData = (PFNGLBUFFERDATAPROC)IRR_OGL_LOAD_EXTENSION("glBufferData"); glBufferData = (PFNGLBUFFERDATAPROC)IRR_OGL_LOAD_EXTENSION("glBufferData");
glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)IRR_OGL_LOAD_EXTENSION("glVertexAttribPointer"); glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)IRR_OGL_LOAD_EXTENSION("glVertexAttribPointer");
glCreateShader = (PFNGLCREATESHADERPROC)IRR_OGL_LOAD_EXTENSION("glCreateShader"); glCreateShader = (PFNGLCREATESHADERPROC)IRR_OGL_LOAD_EXTENSION("glCreateShader");
glCompileShader = (PFNGLCOMPILESHADERPROC)IRR_OGL_LOAD_EXTENSION("glCompileShader"); glCompileShader = (PFNGLCOMPILESHADERPROC)IRR_OGL_LOAD_EXTENSION("glCompileShader");
glShaderSource = (PFNGLSHADERSOURCEPROC)IRR_OGL_LOAD_EXTENSION("glShaderSource"); glShaderSource = (PFNGLSHADERSOURCEPROC)IRR_OGL_LOAD_EXTENSION("glShaderSource");
glCreateProgram = (PFNGLCREATEPROGRAMPROC)IRR_OGL_LOAD_EXTENSION("glCreateProgram"); glCreateProgram = (PFNGLCREATEPROGRAMPROC)IRR_OGL_LOAD_EXTENSION("glCreateProgram");
glAttachShader = (PFNGLATTACHSHADERPROC)IRR_OGL_LOAD_EXTENSION("glAttachShader"); glAttachShader = (PFNGLATTACHSHADERPROC)IRR_OGL_LOAD_EXTENSION("glAttachShader");
glLinkProgram = (PFNGLLINKPROGRAMPROC)IRR_OGL_LOAD_EXTENSION("glLinkProgram"); glLinkProgram = (PFNGLLINKPROGRAMPROC)IRR_OGL_LOAD_EXTENSION("glLinkProgram");
glUseProgram = (PFNGLUSEPROGRAMPROC)IRR_OGL_LOAD_EXTENSION("glUseProgram"); glUseProgram = (PFNGLUSEPROGRAMPROC)IRR_OGL_LOAD_EXTENSION("glUseProgram");
glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)IRR_OGL_LOAD_EXTENSION("glEnableVertexAttribArray"); glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)IRR_OGL_LOAD_EXTENSION("glEnableVertexAttribArray");
glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)IRR_OGL_LOAD_EXTENSION("glGetUniformLocation"); glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)IRR_OGL_LOAD_EXTENSION("glGetUniformLocation");
glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)IRR_OGL_LOAD_EXTENSION("glUniformMatrix4fv"); glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)IRR_OGL_LOAD_EXTENSION("glUniformMatrix4fv");
glUniform1f = (PFNGLUNIFORM1FPROC)IRR_OGL_LOAD_EXTENSION("glUniform1f"); glUniform1f = (PFNGLUNIFORM1FPROC)IRR_OGL_LOAD_EXTENSION("glUniform1f");
glUniform3f = (PFNGLUNIFORM3FPROC)IRR_OGL_LOAD_EXTENSION("glUniform3f"); glUniform3f = (PFNGLUNIFORM3FPROC)IRR_OGL_LOAD_EXTENSION("glUniform3f");
glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)IRR_OGL_LOAD_EXTENSION("glDisableVertexAttribArray"); glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)IRR_OGL_LOAD_EXTENSION("glDisableVertexAttribArray");
glDeleteShader = (PFNGLDELETESHADERPROC)IRR_OGL_LOAD_EXTENSION("glDeleteShader"); glDeleteShader = (PFNGLDELETESHADERPROC)IRR_OGL_LOAD_EXTENSION("glDeleteShader");
glGetShaderiv = (PFNGLGETSHADERIVPROC)IRR_OGL_LOAD_EXTENSION("glGetShaderiv"); glGetShaderiv = (PFNGLGETSHADERIVPROC)IRR_OGL_LOAD_EXTENSION("glGetShaderiv");
glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)IRR_OGL_LOAD_EXTENSION("glGetShaderInfoLog"); glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)IRR_OGL_LOAD_EXTENSION("glGetShaderInfoLog");
glActiveTexture = (PFNGLACTIVETEXTUREPROC)IRR_OGL_LOAD_EXTENSION("glActiveTexture"); glActiveTexture = (PFNGLACTIVETEXTUREPROC)IRR_OGL_LOAD_EXTENSION("glActiveTexture");
glUniform2f = (PFNGLUNIFORM2FPROC)IRR_OGL_LOAD_EXTENSION("glUniform2f"); glUniform2f = (PFNGLUNIFORM2FPROC)IRR_OGL_LOAD_EXTENSION("glUniform2f");
glUniform4i = (PFNGLUNIFORM4IPROC)IRR_OGL_LOAD_EXTENSION("glUniform4i"); glUniform4i = (PFNGLUNIFORM4IPROC)IRR_OGL_LOAD_EXTENSION("glUniform4i");
glUniform3i = (PFNGLUNIFORM3IPROC)IRR_OGL_LOAD_EXTENSION("glUniform3i"); glUniform3i = (PFNGLUNIFORM3IPROC)IRR_OGL_LOAD_EXTENSION("glUniform3i");
glUniform1i = (PFNGLUNIFORM1IPROC)IRR_OGL_LOAD_EXTENSION("glUniform1i"); glUniform1i = (PFNGLUNIFORM1IPROC)IRR_OGL_LOAD_EXTENSION("glUniform1i");
glGetProgramiv = (PFNGLGETPROGRAMIVPROC)IRR_OGL_LOAD_EXTENSION("glGetProgramiv"); glGetProgramiv = (PFNGLGETPROGRAMIVPROC)IRR_OGL_LOAD_EXTENSION("glGetProgramiv");
glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)IRR_OGL_LOAD_EXTENSION("glGetProgramInfoLog"); glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)IRR_OGL_LOAD_EXTENSION("glGetProgramInfoLog");
glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)IRR_OGL_LOAD_EXTENSION("glTransformFeedbackVaryings"); glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)IRR_OGL_LOAD_EXTENSION("glTransformFeedbackVaryings");
glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)IRR_OGL_LOAD_EXTENSION("glGetAttribLocation"); glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)IRR_OGL_LOAD_EXTENSION("glGetAttribLocation");
glBlendEquation = (PFNGLBLENDEQUATIONPROC)IRR_OGL_LOAD_EXTENSION("glBlendEquation"); glBlendEquation = (PFNGLBLENDEQUATIONPROC)IRR_OGL_LOAD_EXTENSION("glBlendEquation");
glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)IRR_OGL_LOAD_EXTENSION("glVertexAttribDivisor"); glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)IRR_OGL_LOAD_EXTENSION("glVertexAttribDivisor");
glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)IRR_OGL_LOAD_EXTENSION("glDrawArraysInstanced"); glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)IRR_OGL_LOAD_EXTENSION("glDrawArraysInstanced");
glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)IRR_OGL_LOAD_EXTENSION("glDeleteBuffers"); glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)IRR_OGL_LOAD_EXTENSION("glDeleteBuffers");
glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)IRR_OGL_LOAD_EXTENSION("glGenVertexArrays"); glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)IRR_OGL_LOAD_EXTENSION("glGenVertexArrays");
glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)IRR_OGL_LOAD_EXTENSION("glBindVertexArray"); glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)IRR_OGL_LOAD_EXTENSION("glBindVertexArray");
glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)IRR_OGL_LOAD_EXTENSION("glDeleteVertexArrays"); glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)IRR_OGL_LOAD_EXTENSION("glDeleteVertexArrays");
glTexBuffer = (PFNGLTEXBUFFERPROC)IRR_OGL_LOAD_EXTENSION("glTexBuffer"); glTexBuffer = (PFNGLTEXBUFFERPROC)IRR_OGL_LOAD_EXTENSION("glTexBuffer");
glUniform1fv = (PFNGLUNIFORM1FVPROC)IRR_OGL_LOAD_EXTENSION("glUniform1fv"); glUniform1fv = (PFNGLUNIFORM1FVPROC)IRR_OGL_LOAD_EXTENSION("glUniform1fv");
glUniform4fv = (PFNGLUNIFORM4FVPROC)IRR_OGL_LOAD_EXTENSION("glUniform4fv"); glUniform4fv = (PFNGLUNIFORM4FVPROC)IRR_OGL_LOAD_EXTENSION("glUniform4fv");
glBufferSubData = (PFNGLBUFFERSUBDATAPROC)IRR_OGL_LOAD_EXTENSION("glBufferSubData"); glBufferSubData = (PFNGLBUFFERSUBDATAPROC)IRR_OGL_LOAD_EXTENSION("glBufferSubData");
glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)IRR_OGL_LOAD_EXTENSION("glVertexAttribIPointer"); glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)IRR_OGL_LOAD_EXTENSION("glVertexAttribIPointer");
glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)IRR_OGL_LOAD_EXTENSION("glGenFramebuffers"); glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)IRR_OGL_LOAD_EXTENSION("glGenFramebuffers");
glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)IRR_OGL_LOAD_EXTENSION("glBindFramebuffer"); glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)IRR_OGL_LOAD_EXTENSION("glBindFramebuffer");
glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)IRR_OGL_LOAD_EXTENSION("glFramebufferTexture"); glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)IRR_OGL_LOAD_EXTENSION("glFramebufferTexture");
glTexImage3D = (PFNGLTEXIMAGE3DPROC)IRR_OGL_LOAD_EXTENSION("glTexImage3D"); glTexImage3D = (PFNGLTEXIMAGE3DPROC)IRR_OGL_LOAD_EXTENSION("glTexImage3D");
glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)IRR_OGL_LOAD_EXTENSION("glCheckFramebufferStatus"); glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)IRR_OGL_LOAD_EXTENSION("glCheckFramebufferStatus");
#ifdef DEBUG #ifdef DEBUG
glDebugMessageCallbackARB = (PFNGLDEBUGMESSAGECALLBACKARBPROC)IRR_OGL_LOAD_EXTENSION("glDebugMessageCallbackARB"); glDebugMessageCallbackARB = (PFNGLDEBUGMESSAGECALLBACKARBPROC)IRR_OGL_LOAD_EXTENSION("glDebugMessageCallbackARB");
#endif #endif
#endif #endif
#ifdef ARB_DEBUG_OUTPUT #ifdef ARB_DEBUG_OUTPUT
@ -210,36 +210,36 @@ void initGL()
// Mostly from shader tutorial // Mostly from shader tutorial
GLuint LoadShader(const char * file, unsigned type) GLuint LoadShader(const char * file, unsigned type)
{ {
GLuint Id = glCreateShader(type); GLuint Id = glCreateShader(type);
char versionString[20]; char versionString[20];
sprintf(versionString, "#version %d\n", irr_driver->getGLSLVersion()); sprintf(versionString, "#version %d\n", irr_driver->getGLSLVersion());
std::string Code = versionString; std::string Code = versionString;
std::ifstream Stream(file, std::ios::in); std::ifstream Stream(file, std::ios::in);
if (Stream.is_open()) if (Stream.is_open())
{ {
std::string Line = ""; std::string Line = "";
while (getline(Stream, Line)) while (getline(Stream, Line))
Code += "\n" + Line; Code += "\n" + Line;
Stream.close(); Stream.close();
} }
GLint Result = GL_FALSE; GLint Result = GL_FALSE;
int InfoLogLength; int InfoLogLength;
Log::info("GLWrap", "Compiling shader : %s", file); Log::info("GLWrap", "Compiling shader : %s", file);
char const * SourcePointer = Code.c_str(); char const * SourcePointer = Code.c_str();
int length = strlen(SourcePointer); int length = strlen(SourcePointer);
glShaderSource(Id, 1, &SourcePointer, &length); glShaderSource(Id, 1, &SourcePointer, &length);
glCompileShader(Id); glCompileShader(Id);
glGetShaderiv(Id, GL_COMPILE_STATUS, &Result); glGetShaderiv(Id, GL_COMPILE_STATUS, &Result);
if (Result == GL_FALSE) if (Result == GL_FALSE)
{ {
Log::error("GLWrap", "Error in shader %s", file); Log::error("GLWrap", "Error in shader %s", file);
glGetShaderiv(Id, GL_INFO_LOG_LENGTH, &InfoLogLength); glGetShaderiv(Id, GL_INFO_LOG_LENGTH, &InfoLogLength);
char *ErrorMessage = new char[InfoLogLength]; char *ErrorMessage = new char[InfoLogLength];
glGetShaderInfoLog(Id, InfoLogLength, NULL, ErrorMessage); glGetShaderInfoLog(Id, InfoLogLength, NULL, ErrorMessage);
Log::error("GLWrap", ErrorMessage); Log::error("GLWrap", ErrorMessage);
delete[] ErrorMessage; delete[] ErrorMessage;
} }
GLenum glErr = glGetError(); GLenum glErr = glGetError();
if (glErr != GL_NO_ERROR) if (glErr != GL_NO_ERROR)
@ -247,27 +247,27 @@ GLuint LoadShader(const char * file, unsigned type)
Log::warn("IrrDriver", "GLWrap : OpenGL error %i\n", glErr); Log::warn("IrrDriver", "GLWrap : OpenGL error %i\n", glErr);
} }
return Id; return Id;
} }
GLuint LoadTFBProgram(const char * vertex_file_path, const char **varyings, unsigned varyingscount) GLuint LoadTFBProgram(const char * vertex_file_path, const char **varyings, unsigned varyingscount)
{ {
GLuint Program = glCreateProgram(); GLuint Program = glCreateProgram();
loadAndAttach(Program, GL_VERTEX_SHADER, vertex_file_path); loadAndAttach(Program, GL_VERTEX_SHADER, vertex_file_path);
glTransformFeedbackVaryings(Program, varyingscount, varyings, GL_INTERLEAVED_ATTRIBS); glTransformFeedbackVaryings(Program, varyingscount, varyings, GL_INTERLEAVED_ATTRIBS);
glLinkProgram(Program); glLinkProgram(Program);
GLint Result = GL_FALSE; GLint Result = GL_FALSE;
int InfoLogLength; int InfoLogLength;
glGetProgramiv(Program, GL_LINK_STATUS, &Result); glGetProgramiv(Program, GL_LINK_STATUS, &Result);
if (Result == GL_FALSE) if (Result == GL_FALSE)
{ {
glGetProgramiv(Program, GL_INFO_LOG_LENGTH, &InfoLogLength); glGetProgramiv(Program, GL_INFO_LOG_LENGTH, &InfoLogLength);
char *ErrorMessage = new char[InfoLogLength]; char *ErrorMessage = new char[InfoLogLength];
glGetProgramInfoLog(Program, InfoLogLength, NULL, ErrorMessage); glGetProgramInfoLog(Program, InfoLogLength, NULL, ErrorMessage);
printf(ErrorMessage); printf(ErrorMessage);
delete[] ErrorMessage; delete[] ErrorMessage;
} }
GLenum glErr = glGetError(); GLenum glErr = glGetError();
if (glErr != GL_NO_ERROR) if (glErr != GL_NO_ERROR)
@ -275,7 +275,7 @@ GLuint LoadTFBProgram(const char * vertex_file_path, const char **varyings, unsi
Log::warn("IrrDriver", "GLWrap : OpenGL error %i\n", glErr); Log::warn("IrrDriver", "GLWrap : OpenGL error %i\n", glErr);
} }
return Program; return Program;
} }
GLuint getTextureGLuint(irr::video::ITexture *tex) GLuint getTextureGLuint(irr::video::ITexture *tex)
@ -291,12 +291,12 @@ GLuint getDepthTexture(irr::video::ITexture *tex)
void setTexture(unsigned TextureUnit, GLuint TextureId, GLenum MagFilter, GLenum MinFilter, bool allowAF) void setTexture(unsigned TextureUnit, GLuint TextureId, GLenum MagFilter, GLenum MinFilter, bool allowAF)
{ {
glActiveTexture(GL_TEXTURE0 + TextureUnit); glActiveTexture(GL_TEXTURE0 + TextureUnit);
glBindTexture(GL_TEXTURE_2D, TextureId); glBindTexture(GL_TEXTURE_2D, TextureId);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, MagFilter); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, MagFilter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, MinFilter); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, MinFilter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
int aniso = UserConfigParams::m_anisotropic; int aniso = UserConfigParams::m_anisotropic;
if (aniso == 0) aniso = 1; if (aniso == 0) aniso = 1;
@ -470,14 +470,14 @@ void draw2DImage(const video::ITexture* texture, const core::rect<s32>& destRect
} }
void draw2DImage(const video::ITexture* texture, const core::rect<s32>& destRect, void draw2DImage(const video::ITexture* texture, const core::rect<s32>& destRect,
const core::rect<s32>& sourceRect, const core::rect<s32>* clipRect, const core::rect<s32>& sourceRect, const core::rect<s32>* clipRect,
const video::SColor* const colors, bool useAlphaChannelOfTexture) const video::SColor* const colors, bool useAlphaChannelOfTexture)
{ {
if (!irr_driver->isGLSL()) if (!irr_driver->isGLSL())
{ {
irr_driver->getVideoDriver()->draw2DImage(texture, destRect, sourceRect, clipRect, colors, useAlphaChannelOfTexture); irr_driver->getVideoDriver()->draw2DImage(texture, destRect, sourceRect, clipRect, colors, useAlphaChannelOfTexture);
return; return;
} }
float width, height, float width, height,
center_pos_x, center_pos_y, center_pos_x, center_pos_y,
@ -487,15 +487,15 @@ void draw2DImage(const video::ITexture* texture, const core::rect<s32>& destRect
getSize(texture, destRect, sourceRect, width, height, center_pos_x, center_pos_y, getSize(texture, destRect, sourceRect, width, height, center_pos_x, center_pos_y,
tex_width, tex_height, tex_center_pos_x, tex_center_pos_y); tex_width, tex_height, tex_center_pos_x, tex_center_pos_y);
if (useAlphaChannelOfTexture) if (useAlphaChannelOfTexture)
{ {
glEnable(GL_BLEND); glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
} }
else else
{ {
glDisable(GL_BLEND); glDisable(GL_BLEND);
} }
if (clipRect) if (clipRect)
{ {
if (!clipRect->isValid()) if (!clipRect->isValid())
@ -506,15 +506,15 @@ void draw2DImage(const video::ITexture* texture, const core::rect<s32>& destRect
glScissor(clipRect->UpperLeftCorner.X, renderTargetSize.Height - clipRect->LowerRightCorner.Y, glScissor(clipRect->UpperLeftCorner.X, renderTargetSize.Height - clipRect->LowerRightCorner.Y,
clipRect->getWidth(), clipRect->getHeight()); clipRect->getWidth(), clipRect->getHeight());
} }
if (colors) if (colors)
drawTexColoredQuad(texture, colors, width, height, center_pos_x, center_pos_y, drawTexColoredQuad(texture, colors, width, height, center_pos_x, center_pos_y,
tex_center_pos_x, tex_center_pos_y, tex_width, tex_height); tex_center_pos_x, tex_center_pos_y, tex_width, tex_height);
else else
drawTexQuad(texture, width, height, center_pos_x, center_pos_y, drawTexQuad(texture, width, height, center_pos_x, center_pos_y,
tex_center_pos_x, tex_center_pos_y, tex_width, tex_height); tex_center_pos_x, tex_center_pos_y, tex_width, tex_height);
if (clipRect) if (clipRect)
glDisable(GL_SCISSOR_TEST); glDisable(GL_SCISSOR_TEST);
glUseProgram(0); glUseProgram(0);
GLenum glErr = glGetError(); GLenum glErr = glGetError();
if (glErr != GL_NO_ERROR) if (glErr != GL_NO_ERROR)
@ -524,39 +524,39 @@ void draw2DImage(const video::ITexture* texture, const core::rect<s32>& destRect
} }
void GL32_draw2DRectangle(video::SColor color, const core::rect<s32>& position, void GL32_draw2DRectangle(video::SColor color, const core::rect<s32>& position,
const core::rect<s32>* clip) const core::rect<s32>* clip)
{ {
if (!irr_driver->isGLSL()) if (!irr_driver->isGLSL())
{ {
irr_driver->getVideoDriver()->draw2DRectangle(color, position, clip); irr_driver->getVideoDriver()->draw2DRectangle(color, position, clip);
return; return;
} }
core::dimension2d<u32> frame_size = core::dimension2d<u32> frame_size =
irr_driver->getVideoDriver()->getCurrentRenderTargetSize(); irr_driver->getVideoDriver()->getCurrentRenderTargetSize();
const int screen_w = frame_size.Width; const int screen_w = frame_size.Width;
const int screen_h = frame_size.Height; const int screen_h = frame_size.Height;
float center_pos_x = position.UpperLeftCorner.X + position.LowerRightCorner.X; float center_pos_x = position.UpperLeftCorner.X + position.LowerRightCorner.X;
center_pos_x /= screen_w; center_pos_x /= screen_w;
center_pos_x -= 1; center_pos_x -= 1;
float center_pos_y = position.UpperLeftCorner.Y + position.LowerRightCorner.Y; float center_pos_y = position.UpperLeftCorner.Y + position.LowerRightCorner.Y;
center_pos_y /= screen_h; center_pos_y /= screen_h;
center_pos_y = 1 - center_pos_y; center_pos_y = 1 - center_pos_y;
float width = position.LowerRightCorner.X - position.UpperLeftCorner.X; float width = position.LowerRightCorner.X - position.UpperLeftCorner.X;
width /= screen_w; width /= screen_w;
float height = position.LowerRightCorner.Y - position.UpperLeftCorner.Y; float height = position.LowerRightCorner.Y - position.UpperLeftCorner.Y;
height /= screen_h; height /= screen_h;
if (color.getAlpha() < 255) if (color.getAlpha() < 255)
{ {
glEnable(GL_BLEND); glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
} }
else else
{ {
glDisable(GL_BLEND); glDisable(GL_BLEND);
} }
if (clip) if (clip)
{ {
@ -569,16 +569,16 @@ void GL32_draw2DRectangle(video::SColor color, const core::rect<s32>& position,
clip->getWidth(), clip->getHeight()); clip->getWidth(), clip->getHeight());
} }
glUseProgram(UIShader::ColoredRectShader::Program); glUseProgram(UIShader::ColoredRectShader::Program);
glBindVertexArray(UIShader::ColoredRectShader::vao); glBindVertexArray(UIShader::ColoredRectShader::vao);
UIShader::ColoredRectShader::setUniforms(center_pos_x, center_pos_y, width, height, color); UIShader::ColoredRectShader::setUniforms(center_pos_x, center_pos_y, width, height, color);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0); glBindVertexArray(0);
if (clip) if (clip)
glDisable(GL_SCISSOR_TEST); glDisable(GL_SCISSOR_TEST);
glUseProgram(0); glUseProgram(0);
GLenum glErr = glGetError(); GLenum glErr = glGetError();
if (glErr != GL_NO_ERROR) if (glErr != GL_NO_ERROR)

6
src/graphics/glwrap.hpp
View File

@ -156,9 +156,9 @@ void draw2DImage(const irr::video::ITexture* texture, const irr::core::rect<s32>
const irr::video::SColor &color, bool useAlphaChannelOfTexture); const irr::video::SColor &color, bool useAlphaChannelOfTexture);
void draw2DImage(const irr::video::ITexture* texture, const irr::core::rect<s32>& destRect, void draw2DImage(const irr::video::ITexture* texture, const irr::core::rect<s32>& destRect,
const irr::core::rect<s32>& sourceRect, const irr::core::rect<s32>* clipRect, const irr::core::rect<s32>& sourceRect, const irr::core::rect<s32>* clipRect,
const irr::video::SColor* const colors, bool useAlphaChannelOfTexture); const irr::video::SColor* const colors, bool useAlphaChannelOfTexture);
void GL32_draw2DRectangle(irr::video::SColor color, const irr::core::rect<s32>& position, void GL32_draw2DRectangle(irr::video::SColor color, const irr::core::rect<s32>& position,
const irr::core::rect<s32>* clip = 0); const irr::core::rect<s32>* clip = 0);
#endif #endif

42
src/graphics/irr_driver.cpp
View File

@ -155,7 +155,7 @@ STKRenderingPass IrrDriver::getPhase() const
void IrrDriver::IncreaseObjectCount() void IrrDriver::IncreaseObjectCount()
{ {
object_count[m_phase]++; object_count[m_phase]++;
} }
core::array<video::IRenderTarget> &IrrDriver::getMainSetup() core::array<video::IRenderTarget> &IrrDriver::getMainSetup()
@ -424,10 +424,10 @@ void IrrDriver::initDevice()
GLMajorVersion = 2; GLMajorVersion = 2;
GLMinorVersion = 1; GLMinorVersion = 1;
glGetIntegerv(GL_MAJOR_VERSION, &GLMajorVersion); glGetIntegerv(GL_MAJOR_VERSION, &GLMajorVersion);
glGetIntegerv(GL_MINOR_VERSION, &GLMinorVersion); glGetIntegerv(GL_MINOR_VERSION, &GLMinorVersion);
Log::info("IrrDriver", "OPENGL VERSION IS %d.%d", GLMajorVersion, GLMinorVersion); Log::info("IrrDriver", "OPENGL VERSION IS %d.%d", GLMajorVersion, GLMinorVersion);
m_glsl = (GLMajorVersion > 3 || (GLMajorVersion == 3 && GLMinorVersion >= 1)) && UserConfigParams::m_pixel_shaders; m_glsl = (GLMajorVersion > 3 || (GLMajorVersion == 3 && GLMinorVersion >= 1)) && UserConfigParams::m_pixel_shaders;
// This remaps the window, so it has to be done before the clear to avoid flicker // This remaps the window, so it has to be done before the clear to avoid flicker
m_device->setResizable(false); m_device->setResizable(false);
@ -458,7 +458,7 @@ void IrrDriver::initDevice()
m_mrt.push_back(m_rtts->getRTT(RTT_COLOR)); m_mrt.push_back(m_rtts->getRTT(RTT_COLOR));
m_mrt.push_back(m_rtts->getRTT(RTT_NORMAL_AND_DEPTH)); m_mrt.push_back(m_rtts->getRTT(RTT_NORMAL_AND_DEPTH));
irr::video::COpenGLDriver* gl_driver = (irr::video::COpenGLDriver*)m_device->getVideoDriver(); irr::video::COpenGLDriver* gl_driver = (irr::video::COpenGLDriver*)m_device->getVideoDriver();
gl_driver->extGlGenQueries(1, &m_lensflare_query); gl_driver->extGlGenQueries(1, &m_lensflare_query);
m_query_issued = false; m_query_issued = false;
@ -964,17 +964,17 @@ scene::ISceneNode *IrrDriver::addBillboard(const core::dimension2d< f32 > size,
video::ITexture *texture, video::ITexture *texture,
scene::ISceneNode* parent, bool alphaTesting) scene::ISceneNode* parent, bool alphaTesting)
{ {
scene::IBillboardSceneNode* node; scene::IBillboardSceneNode* node;
if (isGLSL()) if (isGLSL())
{ {
if (!parent) if (!parent)
parent = m_scene_manager->getRootSceneNode(); parent = m_scene_manager->getRootSceneNode();
node = new STKBillboard(parent, m_scene_manager, -1, vector3df(0., 0., 0.), size); node = new STKBillboard(parent, m_scene_manager, -1, vector3df(0., 0., 0.), size);
node->drop(); node->drop();
} }
else else
node = m_scene_manager->addBillboardSceneNode(parent, size); node = m_scene_manager->addBillboardSceneNode(parent, size);
assert(node->getMaterialCount() > 0); assert(node->getMaterialCount() > 0);
node->setMaterialTexture(0, texture); node->setMaterialTexture(0, texture);
if(alphaTesting) if(alphaTesting)
@ -1150,7 +1150,7 @@ scene::ISceneNode *IrrDriver::addSkyDome(video::ITexture *texture,
float texture_percent, float texture_percent,
float sphere_percent) float sphere_percent)
{ {
Log::error("skybox", "Using deprecated SkyDome"); Log::error("skybox", "Using deprecated SkyDome");
return m_scene_manager->addSkyDomeSceneNode(texture, hori_res, vert_res, return m_scene_manager->addSkyDomeSceneNode(texture, hori_res, vert_res,
texture_percent, texture_percent,
sphere_percent); sphere_percent);
@ -1171,7 +1171,7 @@ scene::ISceneNode *IrrDriver::addSkyBox(const std::vector<video::ITexture*>
&texture) &texture)
{ {
assert(texture.size() == 6); assert(texture.size() == 6);
SkyboxTextures = texture; SkyboxTextures = texture;
SkyboxCubeMap = 0; SkyboxCubeMap = 0;
ConvolutedSkyboxCubeMap = 0; ConvolutedSkyboxCubeMap = 0;
return m_scene_manager->addSkyBoxSceneNode(texture[0], texture[1], return m_scene_manager->addSkyBoxSceneNode(texture[0], texture[1],
@ -1181,7 +1181,7 @@ scene::ISceneNode *IrrDriver::addSkyBox(const std::vector<video::ITexture*>
void IrrDriver::suppressSkyBox() void IrrDriver::suppressSkyBox()
{ {
SkyboxTextures.clear(); SkyboxTextures.clear();
glDeleteTextures(1, &SkyboxCubeMap); glDeleteTextures(1, &SkyboxCubeMap);
glDeleteTextures(1, &ConvolutedSkyboxCubeMap); glDeleteTextures(1, &ConvolutedSkyboxCubeMap);
SkyboxCubeMap = 0; SkyboxCubeMap = 0;
@ -1518,9 +1518,9 @@ void IrrDriver::displayFPS()
{ {
sprintf(buffer, "FPS: %i/%i/%i - Objects (P1:%d P2:%d T:%d) KTris - LightDst : ~%d", sprintf(buffer, "FPS: %i/%i/%i - Objects (P1:%d P2:%d T:%d) KTris - LightDst : ~%d",
min, fps, max, object_count[SOLID_NORMAL_AND_DEPTH_PASS], object_count[SOLID_NORMAL_AND_DEPTH_PASS], object_count[TRANSPARENT_PASS], m_last_light_bucket_distance); min, fps, max, object_count[SOLID_NORMAL_AND_DEPTH_PASS], object_count[SOLID_NORMAL_AND_DEPTH_PASS], object_count[TRANSPARENT_PASS], m_last_light_bucket_distance);
object_count[SOLID_NORMAL_AND_DEPTH_PASS] = 0; object_count[SOLID_NORMAL_AND_DEPTH_PASS] = 0;
object_count[SOLID_NORMAL_AND_DEPTH_PASS] = 0; object_count[SOLID_NORMAL_AND_DEPTH_PASS] = 0;
object_count[TRANSPARENT_PASS] = 0; object_count[TRANSPARENT_PASS] = 0;
} }
else else
{ {
@ -2216,7 +2216,7 @@ scene::ISceneNode *IrrDriver::addLight(const core::vector3df &pos, float energy,
} }
else else
{ {
return m_scene_manager->addLightSceneNode(m_scene_manager->getRootSceneNode(), return m_scene_manager->addLightSceneNode(m_scene_manager->getRootSceneNode(),
pos, video::SColorf(1.0f, r, g, b)); pos, video::SColorf(1.0f, r, g, b));
} }
} }

30
src/graphics/irr_driver.hpp
View File

@ -65,13 +65,13 @@ class ShadowImportance;
enum STKRenderingPass enum STKRenderingPass
{ {
SOLID_NORMAL_AND_DEPTH_PASS, SOLID_NORMAL_AND_DEPTH_PASS,
SOLID_LIT_PASS, SOLID_LIT_PASS,
TRANSPARENT_PASS, TRANSPARENT_PASS,
GLOW_PASS, GLOW_PASS,
DISPLACEMENT_PASS, DISPLACEMENT_PASS,
SHADOW_PASS, SHADOW_PASS,
PASS_COUNT, PASS_COUNT,
}; };
/** /**
@ -115,7 +115,7 @@ private:
/** Matrixes used in several places stored here to avoid recomputation. */ /** Matrixes used in several places stored here to avoid recomputation. */
core::matrix4 m_ViewMatrix, m_InvViewMatrix, m_ProjMatrix, m_InvProjMatrix, m_ProjViewMatrix, m_InvProjViewMatrix; core::matrix4 m_ViewMatrix, m_InvViewMatrix, m_ProjMatrix, m_InvProjMatrix, m_ProjViewMatrix, m_InvProjViewMatrix;
std::vector<video::ITexture *> SkyboxTextures; std::vector<video::ITexture *> SkyboxTextures;
float blueSHCoeff[9]; float blueSHCoeff[9];
float greenSHCoeff[9]; float greenSHCoeff[9];
@ -183,9 +183,9 @@ private:
bool m_shadowviz; bool m_shadowviz;
bool m_lightviz; bool m_lightviz;
bool m_distortviz; bool m_distortviz;
/** Performance stats */ /** Performance stats */
unsigned m_last_light_bucket_distance; unsigned m_last_light_bucket_distance;
unsigned object_count[PASS_COUNT]; unsigned object_count[PASS_COUNT];
u32 m_renderpass; u32 m_renderpass;
u32 m_lensflare_query; u32 m_lensflare_query;
bool m_query_issued; bool m_query_issued;
@ -208,7 +208,7 @@ private:
std::vector<scene::ISceneNode *> m_background; std::vector<scene::ISceneNode *> m_background;
STKRenderingPass m_phase; STKRenderingPass m_phase;
#ifdef DEBUG #ifdef DEBUG
/** Used to visualise skeletons. */ /** Used to visualise skeletons. */
@ -244,13 +244,13 @@ public:
void reset(); void reset();
void generateSkyboxCubemap(); void generateSkyboxCubemap();
void renderSkybox(); void renderSkybox();
void setPhase(STKRenderingPass); void setPhase(STKRenderingPass);
STKRenderingPass getPhase() const; STKRenderingPass getPhase() const;
const std::vector<core::matrix4> &getShadowViewProj() const const std::vector<core::matrix4> &getShadowViewProj() const
{ {
return sun_ortho_matrix; return sun_ortho_matrix;
} }
void IncreaseObjectCount(); void IncreaseObjectCount();
core::array<video::IRenderTarget> &getMainSetup(); core::array<video::IRenderTarget> &getMainSetup();
void updateConfigIfRelevant(); void updateConfigIfRelevant();
void setAllMaterialFlags(scene::IMesh *mesh) const; void setAllMaterialFlags(scene::IMesh *mesh) const;
@ -297,7 +297,7 @@ public:
int vert_res, float texture_percent, int vert_res, float texture_percent,
float sphere_percent); float sphere_percent);
scene::ISceneNode *addSkyBox(const std::vector<video::ITexture*> &texture_names); scene::ISceneNode *addSkyBox(const std::vector<video::ITexture*> &texture_names);
void suppressSkyBox(); void suppressSkyBox();
void removeNode(scene::ISceneNode *node); void removeNode(scene::ISceneNode *node);
void removeMeshFromCache(scene::IMesh *mesh); void removeMeshFromCache(scene::IMesh *mesh);
void removeTexture(video::ITexture *t); void removeTexture(video::ITexture *t);

62
src/graphics/large_mesh_buffer.hpp
View File

@ -13,43 +13,43 @@ namespace irr
{ {
namespace scene namespace scene
{ {
//! A SMeshBuffer with 32-bit indices //! A SMeshBuffer with 32-bit indices
class LargeMeshBuffer : public SMeshBuffer class LargeMeshBuffer : public SMeshBuffer
{ {
public: public:
//! Get type of index data which is stored in this meshbuffer. //! Get type of index data which is stored in this meshbuffer.
/** \return Index type of this buffer. */ /** \return Index type of this buffer. */
virtual video::E_INDEX_TYPE getIndexType() const virtual video::E_INDEX_TYPE getIndexType() const
{ {
return video::EIT_32BIT; return video::EIT_32BIT;
} }
//! Get pointer to indices //! Get pointer to indices
/** \return Pointer to indices. */ /** \return Pointer to indices. */
virtual const u16* getIndices() const virtual const u16* getIndices() const
{ {
return (u16 *) Indices.const_pointer(); return (u16 *) Indices.const_pointer();
} }
//! Get pointer to indices //! Get pointer to indices
/** \return Pointer to indices. */ /** \return Pointer to indices. */
virtual u16* getIndices() virtual u16* getIndices()
{ {
return (u16 *) Indices.pointer(); return (u16 *) Indices.pointer();
} }
//! Get number of indices //! Get number of indices
/** \return Number of indices. */ /** \return Number of indices. */
virtual u32 getIndexCount() const virtual u32 getIndexCount() const
{ {
return Indices.size(); return Indices.size();
} }
//! Indices into the vertices of this buffer. //! Indices into the vertices of this buffer.
core::array<u32> Indices; core::array<u32> Indices;
}; };
} // end namespace scene } // end namespace scene
} // end namespace irr } // end namespace irr

14
src/graphics/material.cpp
View File

@ -661,11 +661,11 @@ void Material::setMaterialProperties(video::SMaterial *m, scene::IMeshBuffer* m
int modes = 0; int modes = 0;
if (!m_lighting && irr_driver->isGLSL() && !m_alpha_blending && !m_add) if (!m_lighting && irr_driver->isGLSL() && !m_alpha_blending && !m_add)
{ {
m->MaterialType = irr_driver->getShader(ES_OBJECT_UNLIT); m->MaterialType = irr_driver->getShader(ES_OBJECT_UNLIT);
modes++; modes++;
} }
if (m_alpha_testing) if (m_alpha_testing)
{ {
@ -765,8 +765,8 @@ void Material::setMaterialProperties(video::SMaterial *m, scene::IMeshBuffer* m
if (irr_driver->isGLSL()) if (irr_driver->isGLSL())
{ {
if (mb->getVertexType() != video::EVT_TANGENTS) if (mb->getVertexType() != video::EVT_TANGENTS)
Log::error("material", "Requiring normal map without tangent enabled mesh"); Log::error("material", "Requiring normal map without tangent enabled mesh");
ITexture* tex = irr_driver->getTexture(m_normal_map_tex); ITexture* tex = irr_driver->getTexture(m_normal_map_tex);
if (m_is_heightmap) if (m_is_heightmap)
{ {

6
src/graphics/material.hpp
View File

@ -346,9 +346,9 @@ public:
void onMadeVisible(scene::IMeshBuffer* who); void onMadeVisible(scene::IMeshBuffer* who);
void onHidden(scene::IMeshBuffer* who); void onHidden(scene::IMeshBuffer* who);
void isInitiallyHidden(scene::IMeshBuffer* who); void isInitiallyHidden(scene::IMeshBuffer* who);
/** For particle system : specify if the particle should be additively blended /** For particle system : specify if the particle should be additively blended
*/ */
bool isAlphaAdditive() const { return !m_alpha_blending; } bool isAlphaAdditive() const { return !m_alpha_blending; }
} ; } ;

22
src/graphics/particle_emitter.cpp
View File

@ -390,21 +390,21 @@ void ParticleEmitter::setCreationRateAbsolute(float f)
if (f <= 0.0f && m_node->getEmitter()) if (f <= 0.0f && m_node->getEmitter())
{ {
m_node->clearParticles(); m_node->clearParticles();
} }
else if (m_node->getEmitter() == NULL) else if (m_node->getEmitter() == NULL)
{ {
m_node->setEmitter(m_emitter); m_node->setEmitter(m_emitter);
} }
#endif #endif
/* if (f <= 0.0f) /* if (f <= 0.0f)
{ {
m_node->setVisible(false); m_node->setVisible(false);
} }
else else
{ {
m_node->setVisible(true); m_node->setVisible(true);
}*/ }*/
} // setCreationRateAbsolute } // setCreationRateAbsolute
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -520,7 +520,7 @@ void ParticleEmitter::setParticleType(const ParticleKind* type)
case EMITTER_POINT: case EMITTER_POINT:
{ {
m_emitter = m_node->createPointEmitter(velocity, m_emitter = m_node->createPointEmitter(velocity,
type->getMinRate(), type->getMaxRate(), type->getMinRate(), type->getMaxRate(),
type->getMinColor(), type->getMinColor(), type->getMinColor(), type->getMinColor(),
lifeTimeMin, lifeTimeMax, lifeTimeMin, lifeTimeMax,
m_particle_type->getAngleSpread() /* angle */ m_particle_type->getAngleSpread() /* angle */
@ -680,7 +680,7 @@ void ParticleEmitter::setParticleType(const ParticleKind* type)
if (flips) if (flips)
{ {
if (m_is_glsl) if (m_is_glsl)
static_cast<ParticleSystemProxy *>(m_node)->setFlip(); static_cast<ParticleSystemProxy *>(m_node)->setFlip();
} }
} }
} // setParticleType } // setParticleType

384
src/graphics/post_processing.cpp
View File

@ -58,11 +58,11 @@ PostProcessing::PostProcessing(IVideoDriver* video_driver)
io::IReadFile *areamap = irr_driver->getDevice()->getFileSystem()-> io::IReadFile *areamap = irr_driver->getDevice()->getFileSystem()->
createMemoryReadFile((void *) AreaMap33, sizeof(AreaMap33), createMemoryReadFile((void *) AreaMap33, sizeof(AreaMap33),
"AreaMap33", false); "AreaMap33", false);
if (!areamap) if (!areamap)
{ {
Log::fatal("postprocessing", "Failed to load the areamap"); Log::fatal("postprocessing", "Failed to load the areamap");
return; return;
} }
m_areamap = irr_driver->getVideoDriver()->getTexture(areamap); m_areamap = irr_driver->getVideoDriver()->getTexture(areamap);
areamap->drop(); areamap->drop();
@ -207,77 +207,77 @@ void PostProcessing::update(float dt)
static static
void renderBloom(ITexture *in) void renderBloom(ITexture *in)
{ {
const float threshold = World::getWorld()->getTrack()->getBloomThreshold(); const float threshold = World::getWorld()->getTrack()->getBloomThreshold();
glUseProgram(FullScreenShader::BloomShader::Program); glUseProgram(FullScreenShader::BloomShader::Program);
glBindVertexArray(FullScreenShader::BloomShader::vao); glBindVertexArray(FullScreenShader::BloomShader::vao);
glUniform1f(FullScreenShader::BloomShader::uniform_low, threshold); glUniform1f(FullScreenShader::BloomShader::uniform_low, threshold);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, getTextureGLuint(in)); glBindTexture(GL_TEXTURE_2D, getTextureGLuint(in));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glUniform1i(FullScreenShader::BloomShader::uniform_texture, 0); glUniform1i(FullScreenShader::BloomShader::uniform_texture, 0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0); glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
} }
static static
void renderBloomBlend(ITexture *in) void renderBloomBlend(ITexture *in)
{ {
glEnable(GL_BLEND); glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD); glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_ONE, GL_ONE); glBlendFunc(GL_ONE, GL_ONE);
glDisable(GL_DEPTH_TEST); glDisable(GL_DEPTH_TEST);
glUseProgram(FullScreenShader::BloomBlendShader::Program); glUseProgram(FullScreenShader::BloomBlendShader::Program);
glBindVertexArray(FullScreenShader::BloomBlendShader::vao); glBindVertexArray(FullScreenShader::BloomBlendShader::vao);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, getTextureGLuint(in)); glBindTexture(GL_TEXTURE_2D, getTextureGLuint(in));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glUniform1i(FullScreenShader::BloomBlendShader::uniform_texture, 0); glUniform1i(FullScreenShader::BloomBlendShader::uniform_texture, 0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0); glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND); glDisable(GL_BLEND);
} }
static static
void renderColorLevel(ITexture *in) void renderColorLevel(ITexture *in)
{ {
core::vector3df m_inlevel = World::getWorld()->getTrack()->getColorLevelIn(); core::vector3df m_inlevel = World::getWorld()->getTrack()->getColorLevelIn();
core::vector2df m_outlevel = World::getWorld()->getTrack()->getColorLevelOut(); core::vector2df m_outlevel = World::getWorld()->getTrack()->getColorLevelOut();
glDisable(GL_BLEND); glDisable(GL_BLEND);
glDisable(GL_DEPTH_TEST); glDisable(GL_DEPTH_TEST);
glUseProgram(FullScreenShader::ColorLevelShader::Program); glUseProgram(FullScreenShader::ColorLevelShader::Program);
glBindVertexArray(FullScreenShader::ColorLevelShader::vao); glBindVertexArray(FullScreenShader::ColorLevelShader::vao);
glUniform3f(FullScreenShader::ColorLevelShader::uniform_inlevel, m_inlevel.X, m_inlevel.Y, m_inlevel.Z); glUniform3f(FullScreenShader::ColorLevelShader::uniform_inlevel, m_inlevel.X, m_inlevel.Y, m_inlevel.Z);
glUniform2f(FullScreenShader::ColorLevelShader::uniform_outlevel, m_outlevel.X, m_outlevel.Y); glUniform2f(FullScreenShader::ColorLevelShader::uniform_outlevel, m_outlevel.X, m_outlevel.Y);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, getTextureGLuint(in)); glBindTexture(GL_TEXTURE_2D, getTextureGLuint(in));
glActiveTexture(GL_TEXTURE1); glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, getDepthTexture(irr_driver->getRTT(RTT_NORMAL_AND_DEPTH))); glBindTexture(GL_TEXTURE_2D, getDepthTexture(irr_driver->getRTT(RTT_NORMAL_AND_DEPTH)));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glUniform1i(FullScreenShader::ColorLevelShader::uniform_tex, 0); glUniform1i(FullScreenShader::ColorLevelShader::uniform_tex, 0);
glUniform1i(FullScreenShader::ColorLevelShader::uniform_dtex, 1); glUniform1i(FullScreenShader::ColorLevelShader::uniform_dtex, 1);
glUniformMatrix4fv(FullScreenShader::ColorLevelShader::uniform_invprojm, 1, GL_FALSE, irr_driver->getInvProjMatrix().pointer()); glUniformMatrix4fv(FullScreenShader::ColorLevelShader::uniform_invprojm, 1, GL_FALSE, irr_driver->getInvProjMatrix().pointer());
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0); glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
} }
void PostProcessing::renderDiffuseEnvMap(const float *bSHCoeff, const float *gSHCoeff, const float *rSHCoeff) void PostProcessing::renderDiffuseEnvMap(const float *bSHCoeff, const float *gSHCoeff, const float *rSHCoeff)
@ -349,103 +349,103 @@ void PostProcessing::renderShadowedSunlight(const std::vector<core::matrix4> &su
void PostProcessing::renderGaussian3Blur(video::ITexture *in, video::ITexture *temprtt, float inv_width, float inv_height) void PostProcessing::renderGaussian3Blur(video::ITexture *in, video::ITexture *temprtt, float inv_width, float inv_height)
{ {
glDisable(GL_BLEND); glDisable(GL_BLEND);
glDisable(GL_DEPTH_TEST); glDisable(GL_DEPTH_TEST);
{ {
irr_driver->getVideoDriver()->setRenderTarget(temprtt, false, false); irr_driver->getVideoDriver()->setRenderTarget(temprtt, false, false);
glUseProgram(FullScreenShader::Gaussian3VBlurShader::Program); glUseProgram(FullScreenShader::Gaussian3VBlurShader::Program);
glBindVertexArray(FullScreenShader::Gaussian3VBlurShader::vao); glBindVertexArray(FullScreenShader::Gaussian3VBlurShader::vao);
glUniform2f(FullScreenShader::Gaussian3VBlurShader::uniform_pixel, inv_width, inv_height); glUniform2f(FullScreenShader::Gaussian3VBlurShader::uniform_pixel, inv_width, inv_height);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, getTextureGLuint(in)); glBindTexture(GL_TEXTURE_2D, getTextureGLuint(in));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glUniform1i(FullScreenShader::Gaussian3VBlurShader::uniform_tex, 0); glUniform1i(FullScreenShader::Gaussian3VBlurShader::uniform_tex, 0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
} }
{ {
irr_driver->getVideoDriver()->setRenderTarget(in, false, false); irr_driver->getVideoDriver()->setRenderTarget(in, false, false);
glUseProgram(FullScreenShader::Gaussian3HBlurShader::Program); glUseProgram(FullScreenShader::Gaussian3HBlurShader::Program);
glBindVertexArray(FullScreenShader::Gaussian3HBlurShader::vao); glBindVertexArray(FullScreenShader::Gaussian3HBlurShader::vao);
glUniform2f(FullScreenShader::Gaussian3HBlurShader::uniform_pixel, inv_width, inv_height); glUniform2f(FullScreenShader::Gaussian3HBlurShader::uniform_pixel, inv_width, inv_height);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, getTextureGLuint(temprtt)); glBindTexture(GL_TEXTURE_2D, getTextureGLuint(temprtt));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glUniform1i(FullScreenShader::Gaussian3HBlurShader::uniform_tex, 0); glUniform1i(FullScreenShader::Gaussian3HBlurShader::uniform_tex, 0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
} }
glBindVertexArray(0); glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
} }
void PostProcessing::renderGaussian6Blur(video::ITexture *in, video::ITexture *temprtt, float inv_width, float inv_height) void PostProcessing::renderGaussian6Blur(video::ITexture *in, video::ITexture *temprtt, float inv_width, float inv_height)
{ {
glDisable(GL_BLEND); glDisable(GL_BLEND);
glDisable(GL_DEPTH_TEST); glDisable(GL_DEPTH_TEST);
{ {
irr_driver->getVideoDriver()->setRenderTarget(temprtt, false, false); irr_driver->getVideoDriver()->setRenderTarget(temprtt, false, false);
glUseProgram(FullScreenShader::Gaussian6VBlurShader::Program); glUseProgram(FullScreenShader::Gaussian6VBlurShader::Program);
glBindVertexArray(FullScreenShader::Gaussian6VBlurShader::vao); glBindVertexArray(FullScreenShader::Gaussian6VBlurShader::vao);
glUniform2f(FullScreenShader::Gaussian6VBlurShader::uniform_pixel, inv_width, inv_height); glUniform2f(FullScreenShader::Gaussian6VBlurShader::uniform_pixel, inv_width, inv_height);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, getTextureGLuint(in)); glBindTexture(GL_TEXTURE_2D, getTextureGLuint(in));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glUniform1i(FullScreenShader::Gaussian6VBlurShader::uniform_tex, 0); glUniform1i(FullScreenShader::Gaussian6VBlurShader::uniform_tex, 0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
} }
{ {
irr_driver->getVideoDriver()->setRenderTarget(in, false, false); irr_driver->getVideoDriver()->setRenderTarget(in, false, false);
glUseProgram(FullScreenShader::Gaussian6HBlurShader::Program); glUseProgram(FullScreenShader::Gaussian6HBlurShader::Program);
glBindVertexArray(FullScreenShader::Gaussian6HBlurShader::vao); glBindVertexArray(FullScreenShader::Gaussian6HBlurShader::vao);
glUniform2f(FullScreenShader::Gaussian6HBlurShader::uniform_pixel, inv_width, inv_height); glUniform2f(FullScreenShader::Gaussian6HBlurShader::uniform_pixel, inv_width, inv_height);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, getTextureGLuint(temprtt)); glBindTexture(GL_TEXTURE_2D, getTextureGLuint(temprtt));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glUniform1i(FullScreenShader::Gaussian6HBlurShader::uniform_tex, 0); glUniform1i(FullScreenShader::Gaussian6HBlurShader::uniform_tex, 0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
} }
glBindVertexArray(0); glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
} }
void PostProcessing::renderPassThrough(ITexture *tex) void PostProcessing::renderPassThrough(ITexture *tex)
{ {
glDisable(GL_DEPTH_TEST); glDisable(GL_DEPTH_TEST);
glUseProgram(FullScreenShader::PassThroughShader::Program); glUseProgram(FullScreenShader::PassThroughShader::Program);
glBindVertexArray(FullScreenShader::PassThroughShader::vao); glBindVertexArray(FullScreenShader::PassThroughShader::vao);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, getTextureGLuint(tex)); glBindTexture(GL_TEXTURE_2D, getTextureGLuint(tex));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glUniform1i(FullScreenShader::PassThroughShader::uniform_texture, 0); glUniform1i(FullScreenShader::PassThroughShader::uniform_texture, 0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0); glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND); glDisable(GL_BLEND);
} }
void PostProcessing::renderPassThrough(GLuint tex) void PostProcessing::renderPassThrough(GLuint tex)
@ -471,85 +471,85 @@ void PostProcessing::renderPassThrough(GLuint tex)
void PostProcessing::renderGlow(ITexture *tex) void PostProcessing::renderGlow(ITexture *tex)
{ {
glDisable(GL_DEPTH_TEST); glDisable(GL_DEPTH_TEST);
glUseProgram(FullScreenShader::GlowShader::Program); glUseProgram(FullScreenShader::GlowShader::Program);
glBindVertexArray(FullScreenShader::GlowShader::vao); glBindVertexArray(FullScreenShader::GlowShader::vao);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, getTextureGLuint(tex)); glBindTexture(GL_TEXTURE_2D, getTextureGLuint(tex));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glUniform1i(FullScreenShader::GlowShader::uniform_tex, 0); glUniform1i(FullScreenShader::GlowShader::uniform_tex, 0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0); glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND); glDisable(GL_BLEND);
} }
ITexture *noise_tex = 0; ITexture *noise_tex = 0;
void PostProcessing::renderSSAO(const core::matrix4 &invprojm, const core::matrix4 &projm) void PostProcessing::renderSSAO(const core::matrix4 &invprojm, const core::matrix4 &projm)
{ {
glDisable(GL_DEPTH_TEST); glDisable(GL_DEPTH_TEST);
glDisable(GL_BLEND); glDisable(GL_BLEND);
glDisable(GL_ALPHA_TEST); glDisable(GL_ALPHA_TEST);
if (!noise_tex) if (!noise_tex)
noise_tex = irr_driver->getTexture(file_manager->getAsset("textures/noise.png").c_str()); noise_tex = irr_driver->getTexture(file_manager->getAsset("textures/noise.png").c_str());
glUseProgram(FullScreenShader::SSAOShader::Program); glUseProgram(FullScreenShader::SSAOShader::Program);
glBindVertexArray(FullScreenShader::SSAOShader::vao); glBindVertexArray(FullScreenShader::SSAOShader::vao);
setTexture(0, getTextureGLuint(irr_driver->getRTT(RTT_NORMAL_AND_DEPTH)), GL_NEAREST, GL_NEAREST); setTexture(0, getTextureGLuint(irr_driver->getRTT(RTT_NORMAL_AND_DEPTH)), GL_NEAREST, GL_NEAREST);
setTexture(1, getDepthTexture(irr_driver->getRTT(RTT_NORMAL_AND_DEPTH)), GL_LINEAR, GL_LINEAR); setTexture(1, getDepthTexture(irr_driver->getRTT(RTT_NORMAL_AND_DEPTH)), GL_LINEAR, GL_LINEAR);
setTexture(2, getTextureGLuint(noise_tex), GL_NEAREST, GL_NEAREST); setTexture(2, getTextureGLuint(noise_tex), GL_NEAREST, GL_NEAREST);
FullScreenShader::SSAOShader::setUniforms(projm, invprojm, 0, 1, 2); FullScreenShader::SSAOShader::setUniforms(projm, invprojm, 0, 1, 2);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0); glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
} }
void PostProcessing::renderFog(const core::matrix4 &ipvmat) void PostProcessing::renderFog(const core::matrix4 &ipvmat)
{ {
irr_driver->getVideoDriver()->setRenderTarget(irr_driver->getRTT(RTT_COLOR), false, false); irr_driver->getVideoDriver()->setRenderTarget(irr_driver->getRTT(RTT_COLOR), false, false);
const Track * const track = World::getWorld()->getTrack(); const Track * const track = World::getWorld()->getTrack();
// This function is only called once per frame - thus no need for setters. // This function is only called once per frame - thus no need for setters.
const float fogmax = track->getFogMax(); const float fogmax = track->getFogMax();
const float startH = track->getFogStartHeight(); const float startH = track->getFogStartHeight();
const float endH = track->getFogEndHeight(); const float endH = track->getFogEndHeight();
const float start = track->getFogStart(); const float start = track->getFogStart();
const float end = track->getFogEnd(); const float end = track->getFogEnd();
const SColor tmpcol = track->getFogColor(); const SColor tmpcol = track->getFogColor();
core::vector3df col( tmpcol.getRed() / 255.0f, core::vector3df col( tmpcol.getRed() / 255.0f,
tmpcol.getGreen() / 255.0f, tmpcol.getGreen() / 255.0f,
tmpcol.getBlue() / 255.0f ); tmpcol.getBlue() / 255.0f );
glDisable(GL_DEPTH_TEST); glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND); glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD); glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glUseProgram(FullScreenShader::FogShader::Program); glUseProgram(FullScreenShader::FogShader::Program);
glBindVertexArray(FullScreenShader::FogShader::vao); glBindVertexArray(FullScreenShader::FogShader::vao);
setTexture(0, getDepthTexture(irr_driver->getRTT(RTT_NORMAL_AND_DEPTH)), GL_NEAREST, GL_NEAREST); setTexture(0, getDepthTexture(irr_driver->getRTT(RTT_NORMAL_AND_DEPTH)), GL_NEAREST, GL_NEAREST);
FullScreenShader::FogShader::setUniforms(ipvmat, fogmax, startH, endH, start, end, col, 0); FullScreenShader::FogShader::setUniforms(ipvmat, fogmax, startH, endH, start, end, col, 0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0); glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND); glDisable(GL_BLEND);
} }
void PostProcessing::renderMotionBlur(unsigned cam, ITexture *in, ITexture *out) void PostProcessing::renderMotionBlur(unsigned cam, ITexture *in, ITexture *out)
@ -647,24 +647,24 @@ void PostProcessing::render()
mocb->setCurrentCamera(cam); mocb->setCurrentCamera(cam);
ITexture *in = irr_driver->getRTT(RTT_COLOR); ITexture *in = irr_driver->getRTT(RTT_COLOR);
ITexture *out = irr_driver->getRTT(RTT_TMP1); ITexture *out = irr_driver->getRTT(RTT_TMP1);
// Each effect uses these as named, and sets them up for the next effect. // Each effect uses these as named, and sets them up for the next effect.
// This allows chaining effects where some may be disabled. // This allows chaining effects where some may be disabled.
// As the original color shouldn't be touched, the first effect can't be disabled. // As the original color shouldn't be touched, the first effect can't be disabled.
PROFILER_PUSH_CPU_MARKER("- Bloom", 0xFF, 0x00, 0x00); PROFILER_PUSH_CPU_MARKER("- Bloom", 0xFF, 0x00, 0x00);
if (1) // bloom if (1) // bloom
{ {
// Blit the base to tmp1 // Blit the base to tmp1
drv->setRenderTarget(out, true, false); drv->setRenderTarget(out, true, false);
renderPassThrough(in); renderPassThrough(in);
const bool globalbloom = World::getWorld()->getTrack()->getBloom(); const bool globalbloom = World::getWorld()->getTrack()->getBloom();
if (globalbloom) if (globalbloom)
{ {
drv->setRenderTarget(irr_driver->getRTT(RTT_TMP3), true, false); drv->setRenderTarget(irr_driver->getRTT(RTT_TMP3), true, false);
renderBloom(in); renderBloom(in);
} }
@ -681,23 +681,23 @@ void PostProcessing::render()
// To half // To half
drv->setRenderTarget(irr_driver->getRTT(RTT_HALF1), true, false); drv->setRenderTarget(irr_driver->getRTT(RTT_HALF1), true, false);
renderPassThrough(irr_driver->getRTT(RTT_TMP3)); renderPassThrough(irr_driver->getRTT(RTT_TMP3));
// To quarter // To quarter
drv->setRenderTarget(irr_driver->getRTT(RTT_QUARTER1), true, false); drv->setRenderTarget(irr_driver->getRTT(RTT_QUARTER1), true, false);
renderPassThrough(irr_driver->getRTT(RTT_HALF1)); renderPassThrough(irr_driver->getRTT(RTT_HALF1));
// To eighth // To eighth
drv->setRenderTarget(irr_driver->getRTT(RTT_EIGHTH1), true, false); drv->setRenderTarget(irr_driver->getRTT(RTT_EIGHTH1), true, false);
renderPassThrough(irr_driver->getRTT(RTT_QUARTER1)); renderPassThrough(irr_driver->getRTT(RTT_QUARTER1));
// Blur it for distribution. // Blur it for distribution.
renderGaussian6Blur(irr_driver->getRTT(RTT_EIGHTH1), irr_driver->getRTT(RTT_EIGHTH2), 8.f / UserConfigParams::m_width, 8.f / UserConfigParams::m_height); renderGaussian6Blur(irr_driver->getRTT(RTT_EIGHTH1), irr_driver->getRTT(RTT_EIGHTH2), 8.f / UserConfigParams::m_width, 8.f / UserConfigParams::m_height);
// Additively blend on top of tmp1 // Additively blend on top of tmp1
drv->setRenderTarget(out, false, false); drv->setRenderTarget(out, false, false);
renderBloomBlend(irr_driver->getRTT(RTT_EIGHTH1)); renderBloomBlend(irr_driver->getRTT(RTT_EIGHTH1));
} // end if bloom } // end if bloom
in = irr_driver->getRTT(RTT_TMP1); in = irr_driver->getRTT(RTT_TMP1);
@ -735,7 +735,7 @@ void PostProcessing::render()
// Blur // Blur
renderGaussian3Blur(irr_driver->getRTT(RTT_QUARTER1), renderGaussian3Blur(irr_driver->getRTT(RTT_QUARTER1),
irr_driver->getRTT(RTT_QUARTER2), irr_driver->getRTT(RTT_QUARTER2),
4.f / UserConfigParams::m_width, 4.f / UserConfigParams::m_width,
4.f / UserConfigParams::m_height); 4.f / UserConfigParams::m_height);
@ -853,14 +853,14 @@ void PostProcessing::render()
} }
// Final blit // Final blit
// TODO : Use glBlitFramebuffer // TODO : Use glBlitFramebuffer
drv->setRenderTarget(ERT_FRAME_BUFFER, false, false); drv->setRenderTarget(ERT_FRAME_BUFFER, false, false);
if (irr_driver->getNormals()) if (irr_driver->getNormals())
renderPassThrough(irr_driver->getRTT(RTT_NORMAL_AND_DEPTH)); renderPassThrough(irr_driver->getRTT(RTT_NORMAL_AND_DEPTH));
else if (irr_driver->getSSAOViz()) else if (irr_driver->getSSAOViz())
renderPassThrough(irr_driver->getRTT(RTT_SSAO)); renderPassThrough(irr_driver->getRTT(RTT_SSAO));
else else
renderColorLevel(in); renderColorLevel(in);
} }
} // render } // render

20
src/graphics/post_processing.hpp
View File

@ -72,24 +72,24 @@ public:
void begin(); void begin();
void update(float dt); void update(float dt);
/** Generate diffuse and specular map */ /** Generate diffuse and specular map */
void renderSunlight(); void renderSunlight();
void renderShadowedSunlight(const std::vector<core::matrix4> &sun_ortho_matrix, unsigned depthtex); void renderShadowedSunlight(const std::vector<core::matrix4> &sun_ortho_matrix, unsigned depthtex);
void renderFog(const core::matrix4 &ipvmat); void renderFog(const core::matrix4 &ipvmat);
void renderSSAO(const core::matrix4 &invprojm, const core::matrix4 &projm); void renderSSAO(const core::matrix4 &invprojm, const core::matrix4 &projm);
void renderDiffuseEnvMap(const float *bSHCoeff, const float *gSHCoeff, const float *rSHCoeff); void renderDiffuseEnvMap(const float *bSHCoeff, const float *gSHCoeff, const float *rSHCoeff);
/** Blur the in texture */ /** Blur the in texture */
void renderGaussian3Blur(video::ITexture *in, video::ITexture *temprtt, float inv_width, float inv_height); void renderGaussian3Blur(video::ITexture *in, video::ITexture *temprtt, float inv_width, float inv_height);
void renderGaussian6Blur(video::ITexture *in, video::ITexture *temprtt, float inv_width, float inv_height); void renderGaussian6Blur(video::ITexture *in, video::ITexture *temprtt, float inv_width, float inv_height);
/** Render tex. Used for blit/texture resize */ /** Render tex. Used for blit/texture resize */
void renderPassThrough(video::ITexture *tex); void renderPassThrough(video::ITexture *tex);
void renderPassThrough(unsigned tex); void renderPassThrough(unsigned tex);
void renderMotionBlur(unsigned cam, video::ITexture *in, video::ITexture *out); void renderMotionBlur(unsigned cam, video::ITexture *in, video::ITexture *out);
void renderGlow(video::ITexture *tex); void renderGlow(video::ITexture *tex);
/** Render the post-processed scene */ /** Render the post-processed scene */
void render(); void render();

160
src/graphics/render.cpp
View File

@ -189,14 +189,14 @@ void IrrDriver::renderGLSL(float dt)
}*/ }*/
// Fire up the MRT // Fire up the MRT
irr_driver->getVideoDriver()->setRenderTarget(irr_driver->getRTT(RTT_NORMAL_AND_DEPTH), false, false); irr_driver->getVideoDriver()->setRenderTarget(irr_driver->getRTT(RTT_NORMAL_AND_DEPTH), false, false);
PROFILER_PUSH_CPU_MARKER("- Solid Pass 1", 0xFF, 0x00, 0x00); PROFILER_PUSH_CPU_MARKER("- Solid Pass 1", 0xFF, 0x00, 0x00);
m_renderpass = scene::ESNRP_CAMERA | scene::ESNRP_SOLID; m_renderpass = scene::ESNRP_CAMERA | scene::ESNRP_SOLID;
glDepthFunc(GL_LEQUAL); glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
glDisable(GL_ALPHA_TEST); glDisable(GL_ALPHA_TEST);
glDepthMask(GL_TRUE); glDepthMask(GL_TRUE);
glDisable(GL_BLEND); glDisable(GL_BLEND);
glEnable(GL_CULL_FACE); glEnable(GL_CULL_FACE);
irr_driver->setPhase(SOLID_NORMAL_AND_DEPTH_PASS); irr_driver->setPhase(SOLID_NORMAL_AND_DEPTH_PASS);
m_scene_manager->drawAll(m_renderpass); m_scene_manager->drawAll(m_renderpass);
@ -204,7 +204,7 @@ void IrrDriver::renderGLSL(float dt)
irr_driver->setViewMatrix(irr_driver->getVideoDriver()->getTransform(video::ETS_VIEW)); irr_driver->setViewMatrix(irr_driver->getVideoDriver()->getTransform(video::ETS_VIEW));
irr_driver->genProjViewMatrix(); irr_driver->genProjViewMatrix();
PROFILER_POP_CPU_MARKER(); PROFILER_POP_CPU_MARKER();
// Todo : reenable glow and shadows // Todo : reenable glow and shadows
//ShadowImportanceProvider * const sicb = (ShadowImportanceProvider *) //ShadowImportanceProvider * const sicb = (ShadowImportanceProvider *)
@ -227,14 +227,14 @@ void IrrDriver::renderGLSL(float dt)
// Lights // Lights
renderLights(cambox, camnode, overridemat, cam, dt); renderLights(cambox, camnode, overridemat, cam, dt);
PROFILER_POP_CPU_MARKER(); PROFILER_POP_CPU_MARKER();
PROFILER_PUSH_CPU_MARKER("- Solid Pass 2", 0x00, 0x00, 0xFF); PROFILER_PUSH_CPU_MARKER("- Solid Pass 2", 0x00, 0x00, 0xFF);
irr_driver->setPhase(SOLID_LIT_PASS); irr_driver->setPhase(SOLID_LIT_PASS);
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
glDisable(GL_ALPHA_TEST); glDisable(GL_ALPHA_TEST);
glDepthMask(GL_FALSE); glDepthMask(GL_FALSE);
glDisable(GL_BLEND); glDisable(GL_BLEND);
m_renderpass = scene::ESNRP_CAMERA | scene::ESNRP_SOLID; m_renderpass = scene::ESNRP_CAMERA | scene::ESNRP_SOLID;
setTexture(0, getTextureGLuint(irr_driver->getRTT(RTT_TMP1)), GL_NEAREST, GL_NEAREST); setTexture(0, getTextureGLuint(irr_driver->getRTT(RTT_TMP1)), GL_NEAREST, GL_NEAREST);
setTexture(1, getTextureGLuint(irr_driver->getRTT(RTT_TMP2)), GL_NEAREST, GL_NEAREST); setTexture(1, getTextureGLuint(irr_driver->getRTT(RTT_TMP2)), GL_NEAREST, GL_NEAREST);
@ -248,27 +248,27 @@ void IrrDriver::renderGLSL(float dt)
PROFILER_POP_CPU_MARKER(); PROFILER_POP_CPU_MARKER();
if (World::getWorld()->getTrack()->isFogEnabled()) if (World::getWorld()->getTrack()->isFogEnabled())
{ {
PROFILER_PUSH_CPU_MARKER("- Fog", 0xFF, 0x00, 0x00); PROFILER_PUSH_CPU_MARKER("- Fog", 0xFF, 0x00, 0x00);
m_post_processing->renderFog(irr_driver->getInvProjMatrix()); m_post_processing->renderFog(irr_driver->getInvProjMatrix());
PROFILER_POP_CPU_MARKER(); PROFILER_POP_CPU_MARKER();
} }
PROFILER_PUSH_CPU_MARKER("- Glow", 0xFF, 0xFF, 0x00); PROFILER_PUSH_CPU_MARKER("- Glow", 0xFF, 0xFF, 0x00);
// Render anything glowing. // Render anything glowing.
if (!m_mipviz && !m_wireframe) if (!m_mipviz && !m_wireframe)
{ {
irr_driver->setPhase(GLOW_PASS); irr_driver->setPhase(GLOW_PASS);
renderGlow(overridemat, glows, cambox, cam); renderGlow(overridemat, glows, cambox, cam);
} // end glow } // end glow
PROFILER_POP_CPU_MARKER(); PROFILER_POP_CPU_MARKER();
PROFILER_PUSH_CPU_MARKER("- Skybox", 0xFF, 0x00, 0xFF); PROFILER_PUSH_CPU_MARKER("- Skybox", 0xFF, 0x00, 0xFF);
renderSkybox(); renderSkybox();
PROFILER_POP_CPU_MARKER(); PROFILER_POP_CPU_MARKER();
PROFILER_PUSH_CPU_MARKER("- Lensflare/godray", 0x00, 0xFF, 0xFF); PROFILER_PUSH_CPU_MARKER("- Lensflare/godray", 0x00, 0xFF, 0xFF);
// Is the lens flare enabled & visible? Check last frame's query. // Is the lens flare enabled & visible? Check last frame's query.
@ -276,7 +276,7 @@ void IrrDriver::renderGLSL(float dt)
const bool hasgodrays = World::getWorld()->getTrack()->hasGodRays(); const bool hasgodrays = World::getWorld()->getTrack()->hasGodRays();
if (true)//hasflare || hasgodrays) if (true)//hasflare || hasgodrays)
{ {
irr::video::COpenGLDriver* gl_driver = (irr::video::COpenGLDriver*)m_device->getVideoDriver(); irr::video::COpenGLDriver* gl_driver = (irr::video::COpenGLDriver*)m_device->getVideoDriver();
GLuint res = 0; GLuint res = 0;
if (m_query_issued) if (m_query_issued)
@ -305,26 +305,26 @@ void IrrDriver::renderGLSL(float dt)
// We need to re-render camera due to the per-cam-node hack. // We need to re-render camera due to the per-cam-node hack.
PROFILER_PUSH_CPU_MARKER("- Transparent Pass", 0xFF, 0x00, 0x00); PROFILER_PUSH_CPU_MARKER("- Transparent Pass", 0xFF, 0x00, 0x00);
irr_driver->setPhase(TRANSPARENT_PASS); irr_driver->setPhase(TRANSPARENT_PASS);
m_renderpass = scene::ESNRP_CAMERA | scene::ESNRP_TRANSPARENT; m_renderpass = scene::ESNRP_CAMERA | scene::ESNRP_TRANSPARENT;
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
glDisable(GL_ALPHA_TEST); glDisable(GL_ALPHA_TEST);
glDepthMask(GL_FALSE); glDepthMask(GL_FALSE);
glEnable(GL_BLEND); glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD); glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_CULL_FACE); glDisable(GL_CULL_FACE);
m_scene_manager->drawAll(m_renderpass); m_scene_manager->drawAll(m_renderpass);
PROFILER_POP_CPU_MARKER(); PROFILER_POP_CPU_MARKER();
PROFILER_PUSH_CPU_MARKER("- Particles", 0xFF, 0xFF, 0x00); PROFILER_PUSH_CPU_MARKER("- Particles", 0xFF, 0xFF, 0x00);
m_renderpass = scene::ESNRP_CAMERA | scene::ESNRP_TRANSPARENT_EFFECT; m_renderpass = scene::ESNRP_CAMERA | scene::ESNRP_TRANSPARENT_EFFECT;
glDepthMask(GL_FALSE); glDepthMask(GL_FALSE);
glDisable(GL_CULL_FACE); glDisable(GL_CULL_FACE);
glEnable(GL_BLEND); glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD); glBlendEquation(GL_FUNC_ADD);
m_scene_manager->drawAll(m_renderpass); m_scene_manager->drawAll(m_renderpass);
PROFILER_POP_CPU_MARKER(); PROFILER_POP_CPU_MARKER();
PROFILER_PUSH_CPU_MARKER("- Displacement", 0x00, 0x00, 0xFF); PROFILER_PUSH_CPU_MARKER("- Displacement", 0x00, 0x00, 0xFF);
// Handle displacing nodes, if any // Handle displacing nodes, if any
@ -689,10 +689,10 @@ void IrrDriver::renderGlow(video::SOverrideMaterial &overridemat,
glStencilFunc(GL_ALWAYS, 1, ~0); glStencilFunc(GL_ALWAYS, 1, ~0);
glEnable(GL_STENCIL_TEST); glEnable(GL_STENCIL_TEST);
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
glDisable(GL_ALPHA_TEST); glDisable(GL_ALPHA_TEST);
glDepthMask(GL_FALSE); glDepthMask(GL_FALSE);
glDisable(GL_BLEND); glDisable(GL_BLEND);
for (u32 i = 0; i < glowcount; i++) for (u32 i = 0; i < glowcount; i++)
{ {
@ -723,22 +723,22 @@ void IrrDriver::renderGlow(video::SOverrideMaterial &overridemat,
// To half // To half
m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_HALF1), false, false); m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_HALF1), false, false);
m_post_processing->renderPassThrough(m_rtts->getRTT(RTT_TMP1)); m_post_processing->renderPassThrough(m_rtts->getRTT(RTT_TMP1));
// To quarter // To quarter
m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_QUARTER1), false, false); m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_QUARTER1), false, false);
m_post_processing->renderPassThrough(m_rtts->getRTT(RTT_HALF1)); m_post_processing->renderPassThrough(m_rtts->getRTT(RTT_HALF1));
// Blur it // Blur it
m_post_processing->renderGaussian6Blur(m_rtts->getRTT(RTT_QUARTER1), m_rtts->getRTT(RTT_QUARTER2), 4.f / UserConfigParams::m_width, 4.f / UserConfigParams::m_height); m_post_processing->renderGaussian6Blur(m_rtts->getRTT(RTT_QUARTER1), m_rtts->getRTT(RTT_QUARTER2), 4.f / UserConfigParams::m_width, 4.f / UserConfigParams::m_height);
glEnable(GL_BLEND); glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD); glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glStencilFunc(GL_EQUAL, 0, ~0); glStencilFunc(GL_EQUAL, 0, ~0);
glEnable(GL_STENCIL_TEST); glEnable(GL_STENCIL_TEST);
m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_COLOR), false, false); m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_COLOR), false, false);
m_post_processing->renderGlow(m_rtts->getRTT(RTT_QUARTER1)); m_post_processing->renderGlow(m_rtts->getRTT(RTT_QUARTER1));
glDisable(GL_STENCIL_TEST); glDisable(GL_STENCIL_TEST);
} }
@ -863,9 +863,9 @@ void IrrDriver::renderLights(const core::aabbox3df& cambox,
// Blur it to reduce noise. // Blur it to reduce noise.
if(UserConfigParams::m_ssao == 1) if(UserConfigParams::m_ssao == 1)
m_post_processing->renderGaussian3Blur(irr_driver->getRTT(RTT_SSAO), irr_driver->getRTT(RTT_QUARTER4), 4.f / UserConfigParams::m_width, 4.f / UserConfigParams::m_height); m_post_processing->renderGaussian3Blur(irr_driver->getRTT(RTT_SSAO), irr_driver->getRTT(RTT_QUARTER4), 4.f / UserConfigParams::m_width, 4.f / UserConfigParams::m_height);
else if (UserConfigParams::m_ssao == 2) else if (UserConfigParams::m_ssao == 2)
m_post_processing->renderGaussian6Blur(irr_driver->getRTT(RTT_SSAO), irr_driver->getRTT(RTT_TMP4), 1.f / UserConfigParams::m_width, 1.f / UserConfigParams::m_height); m_post_processing->renderGaussian6Blur(irr_driver->getRTT(RTT_SSAO), irr_driver->getRTT(RTT_TMP4), 1.f / UserConfigParams::m_width, 1.f / UserConfigParams::m_height);
m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_COLOR), false, false); m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_COLOR), false, false);
} }
@ -1265,17 +1265,17 @@ void IrrDriver::renderSkybox()
if (!SkyboxCubeMap) if (!SkyboxCubeMap)
generateSkyboxCubemap(); generateSkyboxCubemap();
glBindVertexArray(MeshShader::SkyboxShader::cubevao); glBindVertexArray(MeshShader::SkyboxShader::cubevao);
glDisable(GL_CULL_FACE); glDisable(GL_CULL_FACE);
assert(SkyboxTextures.size() == 6); assert(SkyboxTextures.size() == 6);
core::matrix4 transform = irr_driver->getProjViewMatrix(); core::matrix4 transform = irr_driver->getProjViewMatrix();
core::matrix4 translate; core::matrix4 translate;
translate.setTranslation(camera->getAbsolutePosition()); translate.setTranslation(camera->getAbsolutePosition());
// Draw the sky box between the near and far clip plane // Draw the sky box between the near and far clip plane
const f32 viewDistance = (camera->getNearValue() + camera->getFarValue()) * 0.5f; const f32 viewDistance = (camera->getNearValue() + camera->getFarValue()) * 0.5f;
core::matrix4 scale; core::matrix4 scale;
scale.setScale(core::vector3df(viewDistance, viewDistance, viewDistance)); scale.setScale(core::vector3df(viewDistance, viewDistance, viewDistance));
transform *= translate * scale; transform *= translate * scale;
core::matrix4 invtransform; core::matrix4 invtransform;
transform.getInverse(invtransform); transform.getInverse(invtransform);
@ -1297,15 +1297,15 @@ void IrrDriver::renderDisplacement(video::SOverrideMaterial &overridemat,
irr_driver->getVideoDriver()->setRenderTarget(irr_driver->getRTT(RTT_TMP4), true, false); irr_driver->getVideoDriver()->setRenderTarget(irr_driver->getRTT(RTT_TMP4), true, false);
irr_driver->getVideoDriver()->setRenderTarget(irr_driver->getRTT(RTT_DISPLACE), true, false); irr_driver->getVideoDriver()->setRenderTarget(irr_driver->getRTT(RTT_DISPLACE), true, false);
DisplaceProvider * const cb = (DisplaceProvider *)irr_driver->getCallback(ES_DISPLACE); DisplaceProvider * const cb = (DisplaceProvider *)irr_driver->getCallback(ES_DISPLACE);
cb->update(); cb->update();
const int displacingcount = m_displacing.size(); const int displacingcount = m_displacing.size();
irr_driver->setPhase(DISPLACEMENT_PASS); irr_driver->setPhase(DISPLACEMENT_PASS);
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
glDisable(GL_ALPHA_TEST); glDisable(GL_ALPHA_TEST);
glDepthMask(GL_FALSE); glDepthMask(GL_FALSE);
glDisable(GL_BLEND); glDisable(GL_BLEND);
glClear(GL_STENCIL_BUFFER_BIT); glClear(GL_STENCIL_BUFFER_BIT);
glEnable(GL_STENCIL_TEST); glEnable(GL_STENCIL_TEST);
glStencilFunc(GL_ALWAYS, 1, 0xFF); glStencilFunc(GL_ALWAYS, 1, 0xFF);

2
src/graphics/rtts.cpp
View File

@ -70,7 +70,7 @@ RTT::RTT()
rtts[RTT_TMP2] = drv->addRenderTargetTexture(res, "rtt.tmp2", ECF_A8R8G8B8, stencil); rtts[RTT_TMP2] = drv->addRenderTargetTexture(res, "rtt.tmp2", ECF_A8R8G8B8, stencil);
rtts[RTT_TMP3] = drv->addRenderTargetTexture(res, "rtt.tmp3", ECF_A8R8G8B8, stencil); rtts[RTT_TMP3] = drv->addRenderTargetTexture(res, "rtt.tmp3", ECF_A8R8G8B8, stencil);
rtts[RTT_TMP4] = drv->addRenderTargetTexture(res, "rtt.tmp4", ECF_R8, stencil); rtts[RTT_TMP4] = drv->addRenderTargetTexture(res, "rtt.tmp4", ECF_R8, stencil);
rtts[RTT_NORMAL_AND_DEPTH] = drv->addRenderTargetTexture(res, "rtt.normal_and_depth", ECF_G16R16F, stencil); rtts[RTT_NORMAL_AND_DEPTH] = drv->addRenderTargetTexture(res, "rtt.normal_and_depth", ECF_G16R16F, stencil);
rtts[RTT_COLOR] = drv->addRenderTargetTexture(res, "rtt.color", ECF_A16B16G16R16F, stencil); rtts[RTT_COLOR] = drv->addRenderTargetTexture(res, "rtt.color", ECF_A16B16G16R16F, stencil);
rtts[RTT_HALF1] = drv->addRenderTargetTexture(half, "rtt.half1", ECF_A8R8G8B8, stencil); rtts[RTT_HALF1] = drv->addRenderTargetTexture(half, "rtt.half1", ECF_A8R8G8B8, stencil);

10
src/graphics/screenquad.cpp
View File

@ -23,8 +23,8 @@ const u16 ScreenQuad::indices[4] = {0, 1, 2, 3};
static const SColor white(255, 255, 255, 255); static const SColor white(255, 255, 255, 255);
const S3DVertex ScreenQuad::vertices[4] = { const S3DVertex ScreenQuad::vertices[4] = {
S3DVertex(-1, 1, 0, 0, 1, 0, white, 0, 1), S3DVertex(-1, 1, 0, 0, 1, 0, white, 0, 1),
S3DVertex(1, 1, 0, 0, 1, 0, white, 1, 1), S3DVertex(1, 1, 0, 0, 1, 0, white, 1, 1),
S3DVertex(-1, -1, 0, 0, 1, 0, white, 0, 0), S3DVertex(-1, -1, 0, 0, 1, 0, white, 0, 0),
S3DVertex(1, -1, 0, 0, 1, 0, white, 1, 0), S3DVertex(1, -1, 0, 0, 1, 0, white, 1, 0),
}; };

1928
src/graphics/shaders.cpp
View File

File diff suppressed because it is too large Load Diff

316
src/graphics/shaders.hpp
View File

@ -21,7 +21,7 @@
#include <IMeshSceneNode.h> #include <IMeshSceneNode.h>
#include <vector> #include <vector>
typedef unsigned int GLuint; typedef unsigned int GLuint;
using namespace irr; using namespace irr;
class ParticleSystemProxy; class ParticleSystemProxy;
@ -36,22 +36,22 @@ namespace MeshShader
class ObjectPass1Shader class ObjectPass1Shader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_normal; static GLuint attrib_position, attrib_normal;
static GLuint uniform_MVP, uniform_TIMV; static GLuint uniform_MVP, uniform_TIMV;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView); static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView);
}; };
class ObjectRefPass1Shader class ObjectRefPass1Shader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_normal, attrib_texcoord; static GLuint attrib_position, attrib_normal, attrib_texcoord;
static GLuint uniform_MVP, uniform_TM, uniform_TIMV, uniform_tex; static GLuint uniform_MVP, uniform_TM, uniform_TIMV, uniform_tex;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView, const core::matrix4 &TextureMatrix, unsigned TU_texture); static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView, const core::matrix4 &TextureMatrix, unsigned TU_texture);
}; };
@ -80,108 +80,108 @@ public:
class ObjectPass2Shader class ObjectPass2Shader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_texcoord; static GLuint attrib_position, attrib_texcoord;
static GLuint uniform_MVP, uniform_TM, uniform_screen, uniform_ambient; static GLuint uniform_MVP, uniform_TM, uniform_screen, uniform_ambient;
static GLuint TU_Albedo; static GLuint TU_Albedo;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TextureMatrix); static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TextureMatrix);
}; };
class DetailledObjectPass2Shader class DetailledObjectPass2Shader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_texcoord, attrib_second_texcoord; static GLuint attrib_position, attrib_texcoord, attrib_second_texcoord;
static GLuint uniform_MVP, uniform_screen, uniform_ambient; static GLuint uniform_MVP, uniform_screen, uniform_ambient;
static GLuint TU_Albedo, TU_detail; static GLuint TU_Albedo, TU_detail;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix); static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix);
}; };
class ObjectRimLimitShader class ObjectRimLimitShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_normal, attrib_texcoord; static GLuint attrib_position, attrib_normal, attrib_texcoord;
static GLuint uniform_MVP, uniform_TIMV, uniform_TM, uniform_screen, uniform_ambient; static GLuint uniform_MVP, uniform_TIMV, uniform_TM, uniform_screen, uniform_ambient;
static GLuint TU_Albedo; static GLuint TU_Albedo;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView, const core::matrix4 &TextureMatrix); static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView, const core::matrix4 &TextureMatrix);
}; };
class UntexturedObjectShader class UntexturedObjectShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_color; static GLuint attrib_position, attrib_color;
static GLuint uniform_MVP, uniform_screen, uniform_ambient; static GLuint uniform_MVP, uniform_screen, uniform_ambient;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix); static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix);
}; };
class ObjectUnlitShader class ObjectUnlitShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_texcoord; static GLuint attrib_position, attrib_texcoord;
static GLuint uniform_MVP; static GLuint uniform_MVP;
static GLuint TU_tex; static GLuint TU_tex;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix); static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix);
}; };
class ObjectRefPass2Shader class ObjectRefPass2Shader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_texcoord; static GLuint attrib_position, attrib_texcoord;
static GLuint uniform_MVP, uniform_TM, uniform_screen, uniform_ambient; static GLuint uniform_MVP, uniform_TM, uniform_screen, uniform_ambient;
static GLuint TU_Albedo; static GLuint TU_Albedo;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TextureMatrix); static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TextureMatrix);
}; };
class GrassPass2Shader class GrassPass2Shader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_texcoord, attrib_color; static GLuint attrib_position, attrib_texcoord, attrib_color;
static GLuint uniform_MVP, uniform_screen, uniform_ambient, uniform_windDir; static GLuint uniform_MVP, uniform_screen, uniform_ambient, uniform_windDir;
static GLuint TU_Albedo; static GLuint TU_Albedo;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::vector3df &windDirection); static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::vector3df &windDirection);
}; };
class SphereMapShader class SphereMapShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_normal; static GLuint attrib_position, attrib_normal;
static GLuint uniform_MVP, uniform_TIMV, uniform_TVM, uniform_invproj, uniform_screen; static GLuint uniform_MVP, uniform_TIMV, uniform_TVM, uniform_invproj, uniform_screen;
static GLuint TU_tex; static GLuint TU_tex;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TransposeViewMatrix, const core::matrix4 &TransposeInverseModelView, const core::matrix4 &InvProj, const core::vector2df& screen); static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TransposeViewMatrix, const core::matrix4 &TransposeInverseModelView, const core::matrix4 &InvProj, const core::vector2df& screen);
}; };
class SplattingShader class SplattingShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_texcoord, attrib_second_texcoord; static GLuint attrib_position, attrib_texcoord, attrib_second_texcoord;
static GLuint uniform_MVP, uniform_screen, uniform_ambient; static GLuint uniform_MVP, uniform_screen, uniform_ambient;
static GLuint TU_tex_layout, TU_tex_detail0, TU_tex_detail1, TU_tex_detail2, TU_tex_detail3; static GLuint TU_tex_layout, TU_tex_detail0, TU_tex_detail1, TU_tex_detail2, TU_tex_detail3;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix); static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix);
}; };
class CausticsShader class CausticsShader
@ -199,22 +199,22 @@ public:
class BubbleShader class BubbleShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_texcoord; static GLuint attrib_position, attrib_texcoord;
static GLuint uniform_MVP, uniform_tex, uniform_time, uniform_transparency; static GLuint uniform_MVP, uniform_tex, uniform_time, uniform_transparency;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, unsigned TU_tex, float time, float transparency); static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, unsigned TU_tex, float time, float transparency);
}; };
class TransparentShader class TransparentShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_texcoord, attrib_color; static GLuint attrib_position, attrib_texcoord, attrib_color;
static GLuint uniform_MVP, uniform_TM, uniform_tex; static GLuint uniform_MVP, uniform_TM, uniform_tex;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TextureMatrix, unsigned TU_tex); static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TextureMatrix, unsigned TU_tex);
}; };
@ -232,24 +232,24 @@ public:
class BillboardShader class BillboardShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_corner, attrib_texcoord; static GLuint attrib_corner, attrib_texcoord;
static GLuint uniform_MV, uniform_P, uniform_tex, uniform_Position, uniform_Size; static GLuint uniform_MV, uniform_P, uniform_tex, uniform_Position, uniform_Size;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewMatrix, const core::matrix4 &ProjectionMatrix, const core::vector3df &Position, const core::dimension2d<float> &size, unsigned TU_tex); static void setUniforms(const core::matrix4 &ModelViewMatrix, const core::matrix4 &ProjectionMatrix, const core::vector3df &Position, const core::dimension2d<float> &size, unsigned TU_tex);
}; };
class ColorizeShader class ColorizeShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position; static GLuint attrib_position;
static GLuint uniform_MVP, uniform_col; static GLuint uniform_MVP, uniform_col;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, float r, float g, float b); static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, float r, float g, float b);
}; };
class ShadowShader class ShadowShader
@ -299,11 +299,11 @@ public:
class DisplaceShader class DisplaceShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_texcoord, attrib_second_texcoord; static GLuint attrib_position, attrib_texcoord, attrib_second_texcoord;
static GLuint uniform_MVP, uniform_MV, uniform_displacement_tex, uniform_mask_tex, uniform_color_tex, uniform_screen, uniform_dir, uniform_dir2; static GLuint uniform_MVP, uniform_MV, uniform_displacement_tex, uniform_mask_tex, uniform_color_tex, uniform_screen, uniform_dir, uniform_dir2;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &ModelViewMatrix, const core::vector2df &dir, const core::vector2df &dir2, const core::vector2df &screen, unsigned TU_displacement_tex, unsigned TU_mask_tex, unsigned TU_color_tex); static void setUniforms(const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &ModelViewMatrix, const core::vector2df &dir, const core::vector2df &dir2, const core::vector2df &screen, unsigned TU_displacement_tex, unsigned TU_mask_tex, unsigned TU_color_tex);
}; };
@ -359,11 +359,11 @@ namespace ParticleShader
class SimpleSimulationShader class SimpleSimulationShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_velocity, attrib_lifetime, attrib_initial_position, attrib_initial_velocity, attrib_initial_lifetime, attrib_size, attrib_initial_size; static GLuint attrib_position, attrib_velocity, attrib_lifetime, attrib_initial_position, attrib_initial_velocity, attrib_initial_lifetime, attrib_size, attrib_initial_size;
static GLuint uniform_sourcematrix, uniform_dt, uniform_level, uniform_size_increase_factor; static GLuint uniform_sourcematrix, uniform_dt, uniform_level, uniform_size_increase_factor;
static void init(); static void init();
}; };
@ -371,23 +371,23 @@ public:
class HeightmapSimulationShader class HeightmapSimulationShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_velocity, attrib_lifetime, attrib_initial_position, attrib_initial_velocity, attrib_initial_lifetime, attrib_size, attrib_initial_size; static GLuint attrib_position, attrib_velocity, attrib_lifetime, attrib_initial_position, attrib_initial_velocity, attrib_initial_lifetime, attrib_size, attrib_initial_size;
static GLuint uniform_sourcematrix, uniform_dt, uniform_level, uniform_size_increase_factor; static GLuint uniform_sourcematrix, uniform_dt, uniform_level, uniform_size_increase_factor;
static GLuint uniform_track_x, uniform_track_z, uniform_track_x_len, uniform_track_z_len, uniform_heightmap; static GLuint uniform_track_x, uniform_track_z, uniform_track_x_len, uniform_track_z_len, uniform_heightmap;
static void init(); static void init();
}; };
class SimpleParticleRender class SimpleParticleRender
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_pos, attrib_lf, attrib_quadcorner, attrib_texcoord, attrib_sz; static GLuint attrib_pos, attrib_lf, attrib_quadcorner, attrib_texcoord, attrib_sz;
static GLuint uniform_matrix, uniform_viewmatrix, uniform_tex, uniform_dtex, uniform_screen, uniform_invproj, uniform_color_from, uniform_color_to; static GLuint uniform_matrix, uniform_viewmatrix, uniform_tex, uniform_dtex, uniform_screen, uniform_invproj, uniform_color_from, uniform_color_to;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ViewMatrix, const core::matrix4 &ProjMatrix, static void setUniforms(const core::matrix4 &ViewMatrix, const core::matrix4 &ProjMatrix,
const core::matrix4 InvProjMatrix, float width, float height, unsigned TU_tex, const core::matrix4 InvProjMatrix, float width, float height, unsigned TU_tex,
unsigned TU_normal_and_depth, const ParticleSystemProxy* particle_system); unsigned TU_normal_and_depth, const ParticleSystemProxy* particle_system);
}; };
@ -395,12 +395,12 @@ public:
class FlipParticleRender class FlipParticleRender
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_pos, attrib_lf, attrib_quadcorner, attrib_texcoord, attrib_sz, attrib_rotationvec, attrib_anglespeed; static GLuint attrib_pos, attrib_lf, attrib_quadcorner, attrib_texcoord, attrib_sz, attrib_rotationvec, attrib_anglespeed;
static GLuint uniform_matrix, uniform_viewmatrix, uniform_tex, uniform_dtex, uniform_screen, uniform_invproj; static GLuint uniform_matrix, uniform_viewmatrix, uniform_tex, uniform_dtex, uniform_screen, uniform_invproj;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ViewMatrix, const core::matrix4 &ProjMatrix, const core::matrix4 InvProjMatrix, float width, float height, unsigned TU_tex, unsigned TU_normal_and_depth); static void setUniforms(const core::matrix4 &ViewMatrix, const core::matrix4 &ProjMatrix, const core::matrix4 InvProjMatrix, float width, float height, unsigned TU_tex, unsigned TU_normal_and_depth);
}; };
} }
@ -410,42 +410,42 @@ namespace FullScreenShader
class BloomShader class BloomShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint uniform_texture, uniform_low; static GLuint uniform_texture, uniform_low;
static GLuint vao; static GLuint vao;
static void init(); static void init();
}; };
class BloomBlendShader class BloomBlendShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint uniform_texture, uniform_low; static GLuint uniform_texture, uniform_low;
static GLuint vao; static GLuint vao;
static void init(); static void init();
}; };
class ColorLevelShader class ColorLevelShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint uniform_tex, uniform_invprojm, uniform_dtex, uniform_inlevel, uniform_outlevel; static GLuint uniform_tex, uniform_invprojm, uniform_dtex, uniform_inlevel, uniform_outlevel;
static GLuint vao; static GLuint vao;
static void init(); static void init();
}; };
class SunLightShader class SunLightShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint uniform_ntex, uniform_dtex, uniform_direction, uniform_col, uniform_invproj; static GLuint uniform_ntex, uniform_dtex, uniform_direction, uniform_col, uniform_invproj;
static GLuint vao; static GLuint vao;
static void init(); static void init();
static void setUniforms(const core::vector3df &direction, const core::matrix4 &InvProjMatrix, float r, float g, float b, unsigned TU_ntex, unsigned TU_dtex); static void setUniforms(const core::vector3df &direction, const core::matrix4 &InvProjMatrix, float r, float g, float b, unsigned TU_ntex, unsigned TU_dtex);
}; };
class DiffuseEnvMapShader class DiffuseEnvMapShader
@ -473,41 +473,41 @@ public:
class Gaussian6HBlurShader class Gaussian6HBlurShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint uniform_tex, uniform_pixel; static GLuint uniform_tex, uniform_pixel;
static GLuint vao; static GLuint vao;
static void init(); static void init();
}; };
class Gaussian3HBlurShader class Gaussian3HBlurShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint uniform_tex, uniform_pixel; static GLuint uniform_tex, uniform_pixel;
static GLuint vao; static GLuint vao;
static void init(); static void init();
}; };
class Gaussian6VBlurShader class Gaussian6VBlurShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint uniform_tex, uniform_pixel; static GLuint uniform_tex, uniform_pixel;
static GLuint vao; static GLuint vao;
static void init(); static void init();
}; };
class Gaussian3VBlurShader class Gaussian3VBlurShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint uniform_tex, uniform_pixel; static GLuint uniform_tex, uniform_pixel;
static GLuint vao; static GLuint vao;
static void init(); static void init();
}; };
class PenumbraHShader class PenumbraHShader
@ -546,44 +546,44 @@ public:
class PassThroughShader class PassThroughShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint uniform_texture; static GLuint uniform_texture;
static GLuint vao; static GLuint vao;
static void init(); static void init();
}; };
class GlowShader class GlowShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint uniform_tex; static GLuint uniform_tex;
static GLuint vao; static GLuint vao;
static void init(); static void init();
}; };
class SSAOShader class SSAOShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint uniform_ntex, uniform_dtex, uniform_noise_texture, uniform_invprojm, uniform_projm, uniform_samplePoints; static GLuint uniform_ntex, uniform_dtex, uniform_noise_texture, uniform_invprojm, uniform_projm, uniform_samplePoints;
static GLuint vao; static GLuint vao;
static float SSAOSamples[64]; static float SSAOSamples[64];
static void init(); static void init();
static void setUniforms(const core::matrix4& projm, const core::matrix4 &invprojm, unsigned TU_ntex, unsigned TU_dtex, unsigned TU_noise); static void setUniforms(const core::matrix4& projm, const core::matrix4 &invprojm, unsigned TU_ntex, unsigned TU_dtex, unsigned TU_noise);
}; };
class FogShader class FogShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint uniform_tex, uniform_fogmax, uniform_startH, uniform_endH, uniform_start, uniform_end, uniform_col, uniform_ipvmat; static GLuint uniform_tex, uniform_fogmax, uniform_startH, uniform_endH, uniform_start, uniform_end, uniform_col, uniform_ipvmat;
static GLuint vao; static GLuint vao;
static void init(); static void init();
static void setUniforms(const core::matrix4 &ipvmat, float fogmax, float startH, float endH, float start, float end, const core::vector3df &col, unsigned TU_ntex); static void setUniforms(const core::matrix4 &ipvmat, float fogmax, float startH, float endH, float start, float end, const core::vector3df &col, unsigned TU_ntex);
}; };
class MotionBlurShader class MotionBlurShader
@ -626,13 +626,13 @@ namespace UIShader
class TextureRectShader class TextureRectShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_texcoord; static GLuint attrib_position, attrib_texcoord;
static GLuint uniform_tex, uniform_center, uniform_size, uniform_texcenter, uniform_texsize; static GLuint uniform_tex, uniform_center, uniform_size, uniform_texcenter, uniform_texsize;
static GLuint vao; static GLuint vao;
static void init(); static void init();
static void setUniforms(float center_pos_x, float center_pos_y, float width, float height, float tex_center_pos_x, float tex_center_pos_y, float tex_width, float tex_height, unsigned TU_tex); static void setUniforms(float center_pos_x, float center_pos_y, float width, float height, float tex_center_pos_x, float tex_center_pos_y, float tex_width, float tex_height, unsigned TU_tex);
}; };
class UniformColoredTextureRectShader class UniformColoredTextureRectShader
@ -650,26 +650,26 @@ public:
class ColoredTextureRectShader class ColoredTextureRectShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position, attrib_texcoord, attrib_color; static GLuint attrib_position, attrib_texcoord, attrib_color;
static GLuint uniform_tex, uniform_center, uniform_size, uniform_texcenter, uniform_texsize; static GLuint uniform_tex, uniform_center, uniform_size, uniform_texcenter, uniform_texsize;
static GLuint colorvbo; static GLuint colorvbo;
static GLuint vao; static GLuint vao;
static void init(); static void init();
static void setUniforms(float center_pos_x, float center_pos_y, float width, float height, float tex_center_pos_x, float tex_center_pos_y, float tex_width, float tex_height, unsigned TU_tex); static void setUniforms(float center_pos_x, float center_pos_y, float width, float height, float tex_center_pos_x, float tex_center_pos_y, float tex_width, float tex_height, unsigned TU_tex);
}; };
class ColoredRectShader class ColoredRectShader
{ {
public: public:
static GLuint Program; static GLuint Program;
static GLuint attrib_position; static GLuint attrib_position;
static GLuint uniform_center, uniform_size, uniform_color; static GLuint uniform_center, uniform_size, uniform_color;
static GLuint vao; static GLuint vao;
static void init(); static void init();
static void setUniforms(float center_pos_x, float center_pos_y, float width, float height, const video::SColor &color); static void setUniforms(float center_pos_x, float center_pos_y, float width, float height, const video::SColor &color);
}; };
} }
@ -690,7 +690,7 @@ public:
ACT(ES_GAUSSIAN3V) \ ACT(ES_GAUSSIAN3V) \
ACT(ES_MIPVIZ) \ ACT(ES_MIPVIZ) \
ACT(ES_COLORIZE) \ ACT(ES_COLORIZE) \
ACT(ES_OBJECT_UNLIT) \ ACT(ES_OBJECT_UNLIT) \
ACT(ES_OBJECTPASS) \ ACT(ES_OBJECTPASS) \
ACT(ES_OBJECTPASS_REF) \ ACT(ES_OBJECTPASS_REF) \
ACT(ES_SUNLIGHT) \ ACT(ES_SUNLIGHT) \

40
src/graphics/stkanimatedmesh.cpp
View File

@ -16,7 +16,7 @@ const core::vector3df& rotation,
const core::vector3df& scale) : const core::vector3df& scale) :
CAnimatedMeshSceneNode(mesh, parent, mgr, id, position, rotation, scale) CAnimatedMeshSceneNode(mesh, parent, mgr, id, position, rotation, scale)
{ {
firstTime = true; firstTime = true;
} }
void STKAnimatedMesh::cleanGLMeshes() void STKAnimatedMesh::cleanGLMeshes()
@ -45,13 +45,13 @@ void STKAnimatedMesh::cleanGLMeshes()
void STKAnimatedMesh::setMesh(scene::IAnimatedMesh* mesh) void STKAnimatedMesh::setMesh(scene::IAnimatedMesh* mesh)
{ {
firstTime = true; firstTime = true;
GLmeshes.clear(); GLmeshes.clear();
for (unsigned i = 0; i < FPSM_COUNT; i++) for (unsigned i = 0; i < FPSM_COUNT; i++)
GeometricMesh[i].clear(); GeometricMesh[i].clear();
for (unsigned i = 0; i < SM_COUNT; i++) for (unsigned i = 0; i < SM_COUNT; i++)
ShadedMesh[i].clear(); ShadedMesh[i].clear();
CAnimatedMeshSceneNode::setMesh(mesh); CAnimatedMeshSceneNode::setMesh(mesh);
} }
void STKAnimatedMesh::drawSolidPass1(const GLMesh &mesh, GeometricMaterial type) void STKAnimatedMesh::drawSolidPass1(const GLMesh &mesh, GeometricMaterial type)
@ -97,26 +97,26 @@ void STKAnimatedMesh::drawSolidPass2(const GLMesh &mesh, ShadedMaterial type)
void STKAnimatedMesh::render() void STKAnimatedMesh::render()
{ {
video::IVideoDriver* driver = SceneManager->getVideoDriver(); video::IVideoDriver* driver = SceneManager->getVideoDriver();
bool isTransparentPass = bool isTransparentPass =
SceneManager->getSceneNodeRenderPass() == scene::ESNRP_TRANSPARENT; SceneManager->getSceneNodeRenderPass() == scene::ESNRP_TRANSPARENT;
++PassCount; ++PassCount;
scene::IMesh* m = getMeshForCurrentFrame(); scene::IMesh* m = getMeshForCurrentFrame();
if (m) if (m)
{ {
Box = m->getBoundingBox(); Box = m->getBoundingBox();
} }
else else
{ {
Log::error("animated mesh", "Animated Mesh returned no mesh to render."); Log::error("animated mesh", "Animated Mesh returned no mesh to render.");
return; return;
} }
driver->setTransform(video::ETS_WORLD, AbsoluteTransformation); driver->setTransform(video::ETS_WORLD, AbsoluteTransformation);
if (firstTime) if (firstTime)
{ {
@ -157,7 +157,7 @@ void STKAnimatedMesh::render()
} }
} }
} }
firstTime = false; firstTime = false;
for (u32 i = 0; i<m->getMeshBufferCount(); ++i) for (u32 i = 0; i<m->getMeshBufferCount(); ++i)
{ {

4
src/graphics/stkanimatedmesh.hpp
View File

@ -10,11 +10,11 @@
class STKAnimatedMesh : public irr::scene::CAnimatedMeshSceneNode class STKAnimatedMesh : public irr::scene::CAnimatedMeshSceneNode
{ {
protected: protected:
bool firstTime; bool firstTime;
std::vector<GLMesh *> GeometricMesh[FPSM_COUNT]; std::vector<GLMesh *> GeometricMesh[FPSM_COUNT];
std::vector<GLMesh *> ShadedMesh[SM_COUNT]; std::vector<GLMesh *> ShadedMesh[SM_COUNT];
std::vector<GLMesh *> TransparentMesh[TM_COUNT]; std::vector<GLMesh *> TransparentMesh[TM_COUNT];
std::vector<GLMesh> GLmeshes; std::vector<GLMesh> GLmeshes;
core::matrix4 ModelViewProjectionMatrix, TransposeInverseModelView; core::matrix4 ModelViewProjectionMatrix, TransposeInverseModelView;
void drawSolidPass1(const GLMesh &mesh, GeometricMaterial type); void drawSolidPass1(const GLMesh &mesh, GeometricMaterial type);
void drawSolidPass2(const GLMesh &mesh, ShadedMaterial type); void drawSolidPass2(const GLMesh &mesh, ShadedMaterial type);

40
src/graphics/stkbillboard.cpp
View File

@ -9,36 +9,36 @@ static GLuint billboardvao = 0;
static void createbillboardvao() static void createbillboardvao()
{ {
glGenVertexArrays(1, &billboardvao); glGenVertexArrays(1, &billboardvao);
glBindVertexArray(billboardvao); glBindVertexArray(billboardvao);
glBindBuffer(GL_ARRAY_BUFFER, SharedObject::billboardvbo); glBindBuffer(GL_ARRAY_BUFFER, SharedObject::billboardvbo);
glEnableVertexAttribArray(MeshShader::BillboardShader::attrib_corner); glEnableVertexAttribArray(MeshShader::BillboardShader::attrib_corner);
glEnableVertexAttribArray(MeshShader::BillboardShader::attrib_texcoord); glEnableVertexAttribArray(MeshShader::BillboardShader::attrib_texcoord);
glVertexAttribPointer(MeshShader::BillboardShader::attrib_corner, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 0); glVertexAttribPointer(MeshShader::BillboardShader::attrib_corner, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 0);
glVertexAttribPointer(MeshShader::BillboardShader::attrib_texcoord, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (GLvoid*) (2 * sizeof(float))); glVertexAttribPointer(MeshShader::BillboardShader::attrib_texcoord, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (GLvoid*) (2 * sizeof(float)));
glBindVertexArray(0); glBindVertexArray(0);
} }
STKBillboard::STKBillboard(irr::scene::ISceneNode* parent, irr::scene::ISceneManager* mgr, irr::s32 id, STKBillboard::STKBillboard(irr::scene::ISceneNode* parent, irr::scene::ISceneManager* mgr, irr::s32 id,
const irr::core::vector3df& position, const irr::core::dimension2d<irr::f32>& size, const irr::core::vector3df& position, const irr::core::dimension2d<irr::f32>& size,
irr::video::SColor colorTop, irr::video::SColor colorBottom) : irr::video::SColor colorTop, irr::video::SColor colorBottom) :
CBillboardSceneNode(parent, mgr, id, position, size, colorTop, colorBottom), IBillboardSceneNode(parent, mgr, id, position) CBillboardSceneNode(parent, mgr, id, position, size, colorTop, colorBottom), IBillboardSceneNode(parent, mgr, id, position)
{ {
if (!billboardvao) if (!billboardvao)
createbillboardvao(); createbillboardvao();
} }
void STKBillboard::render() void STKBillboard::render()
{ {
if (irr_driver->getPhase() != TRANSPARENT_PASS) if (irr_driver->getPhase() != TRANSPARENT_PASS)
return; return;
core::vector3df pos = getAbsolutePosition(); core::vector3df pos = getAbsolutePosition();
glBindVertexArray(billboardvao); glBindVertexArray(billboardvao);
GLuint texid = getTextureGLuint(Material.getTexture(0)); GLuint texid = getTextureGLuint(Material.getTexture(0));
setTexture(0, texid, GL_LINEAR, GL_LINEAR); setTexture(0, texid, GL_LINEAR, GL_LINEAR);
glUseProgram(MeshShader::BillboardShader::Program); glUseProgram(MeshShader::BillboardShader::Program);
MeshShader::BillboardShader::setUniforms(irr_driver->getViewMatrix(), irr_driver->getProjMatrix(), pos, Size, 0); MeshShader::BillboardShader::setUniforms(irr_driver->getViewMatrix(), irr_driver->getProjMatrix(), pos, Size, 0);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0); glBindVertexArray(0);
return; return;
} }

10
src/graphics/stkbillboard.hpp
View File

@ -8,12 +8,12 @@
class STKBillboard : public irr::scene::CBillboardSceneNode class STKBillboard : public irr::scene::CBillboardSceneNode
{ {
public: public:
STKBillboard(irr::scene::ISceneNode* parent, irr::scene::ISceneManager* mgr, irr::s32 id, STKBillboard(irr::scene::ISceneNode* parent, irr::scene::ISceneManager* mgr, irr::s32 id,
const irr::core::vector3df& position, const irr::core::dimension2d<irr::f32>& size, const irr::core::vector3df& position, const irr::core::dimension2d<irr::f32>& size,
irr::video::SColor colorTop = irr::video::SColor(0xFFFFFFFF), irr::video::SColor colorTop = irr::video::SColor(0xFFFFFFFF),
irr::video::SColor colorBottom = irr::video::SColor(0xFFFFFFFF)); irr::video::SColor colorBottom = irr::video::SColor(0xFFFFFFFF));
virtual void render(); virtual void render();
}; };
#endif #endif

486
src/graphics/stkmesh.cpp
View File

@ -57,153 +57,153 @@ GLuint createVAO(GLuint vbo, GLuint idx, GLuint attrib_position, GLuint attrib_t
{ {
if (attrib_position == -1) if (attrib_position == -1)
return 0; return 0;
GLuint vao; GLuint vao;
glGenVertexArrays(1, &vao); glGenVertexArrays(1, &vao);
glBindVertexArray(vao); glBindVertexArray(vao);
glBindBuffer(GL_ARRAY_BUFFER, vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo);
glEnableVertexAttribArray(attrib_position); glEnableVertexAttribArray(attrib_position);
if ((GLint)attrib_texcoord != -1) if ((GLint)attrib_texcoord != -1)
glEnableVertexAttribArray(attrib_texcoord); glEnableVertexAttribArray(attrib_texcoord);
if ((GLint)attrib_second_texcoord != -1) if ((GLint)attrib_second_texcoord != -1)
glEnableVertexAttribArray(attrib_second_texcoord); glEnableVertexAttribArray(attrib_second_texcoord);
if ((GLint)attrib_normal != -1) if ((GLint)attrib_normal != -1)
glEnableVertexAttribArray(attrib_normal); glEnableVertexAttribArray(attrib_normal);
if ((GLint)attrib_tangent != -1) if ((GLint)attrib_tangent != -1)
glEnableVertexAttribArray(attrib_tangent); glEnableVertexAttribArray(attrib_tangent);
if ((GLint)attrib_bitangent != -1) if ((GLint)attrib_bitangent != -1)
glEnableVertexAttribArray(attrib_bitangent); glEnableVertexAttribArray(attrib_bitangent);
if ((GLint)attrib_color != -1) if ((GLint)attrib_color != -1)
glEnableVertexAttribArray(attrib_color); glEnableVertexAttribArray(attrib_color);
glVertexAttribPointer(attrib_position, 3, GL_FLOAT, GL_FALSE, stride, 0); glVertexAttribPointer(attrib_position, 3, GL_FLOAT, GL_FALSE, stride, 0);
if ((GLint)attrib_texcoord != -1) if ((GLint)attrib_texcoord != -1)
glVertexAttribPointer(attrib_texcoord, 2, GL_FLOAT, GL_FALSE, stride, (GLvoid*) 28); glVertexAttribPointer(attrib_texcoord, 2, GL_FLOAT, GL_FALSE, stride, (GLvoid*) 28);
if ((GLint)attrib_second_texcoord != -1) if ((GLint)attrib_second_texcoord != -1)
{ {
if (stride < 44) if (stride < 44)
Log::error("material", "Second texcoords not present in VBO"); Log::error("material", "Second texcoords not present in VBO");
glVertexAttribPointer(attrib_second_texcoord, 2, GL_FLOAT, GL_FALSE, stride, (GLvoid*) 36); glVertexAttribPointer(attrib_second_texcoord, 2, GL_FLOAT, GL_FALSE, stride, (GLvoid*) 36);
} }
if ((GLint)attrib_normal != -1) if ((GLint)attrib_normal != -1)
glVertexAttribPointer(attrib_normal, 3, GL_FLOAT, GL_FALSE, stride, (GLvoid*) 12); glVertexAttribPointer(attrib_normal, 3, GL_FLOAT, GL_FALSE, stride, (GLvoid*) 12);
if ((GLint)attrib_tangent != -1) if ((GLint)attrib_tangent != -1)
{ {
if (stride < 48) if (stride < 48)
Log::error("material", "Tangents not present in VBO"); Log::error("material", "Tangents not present in VBO");
glVertexAttribPointer(attrib_tangent, 3, GL_FLOAT, GL_FALSE, stride, (GLvoid*)36); glVertexAttribPointer(attrib_tangent, 3, GL_FLOAT, GL_FALSE, stride, (GLvoid*)36);
} }
if ((GLint)attrib_bitangent != -1) if ((GLint)attrib_bitangent != -1)
{ {
if (stride < 60) if (stride < 60)
Log::error("material", "Bitangents not present in VBO"); Log::error("material", "Bitangents not present in VBO");
glVertexAttribPointer(attrib_bitangent, 3, GL_FLOAT, GL_FALSE, stride, (GLvoid*)48); glVertexAttribPointer(attrib_bitangent, 3, GL_FLOAT, GL_FALSE, stride, (GLvoid*)48);
} }
if ((GLint)attrib_color != -1) if ((GLint)attrib_color != -1)
glVertexAttribPointer(attrib_color, 4, GL_UNSIGNED_BYTE, GL_TRUE, stride, (GLvoid*)24); glVertexAttribPointer(attrib_color, 4, GL_UNSIGNED_BYTE, GL_TRUE, stride, (GLvoid*)24);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, idx); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, idx);
glBindVertexArray(0); glBindVertexArray(0);
return vao; return vao;
} }
GLMesh allocateMeshBuffer(scene::IMeshBuffer* mb) GLMesh allocateMeshBuffer(scene::IMeshBuffer* mb)
{ {
GLMesh result = {}; GLMesh result = {};
if (!mb) if (!mb)
return result; return result;
glBindVertexArray(0); glBindVertexArray(0);
glGenBuffers(1, &(result.vertex_buffer)); glGenBuffers(1, &(result.vertex_buffer));
glGenBuffers(1, &(result.index_buffer)); glGenBuffers(1, &(result.index_buffer));
glBindBuffer(GL_ARRAY_BUFFER, result.vertex_buffer); glBindBuffer(GL_ARRAY_BUFFER, result.vertex_buffer);
const void* vertices = mb->getVertices(); const void* vertices = mb->getVertices();
const u32 vertexCount = mb->getVertexCount(); const u32 vertexCount = mb->getVertexCount();
const irr::video::E_VERTEX_TYPE vType = mb->getVertexType(); const irr::video::E_VERTEX_TYPE vType = mb->getVertexType();
result.Stride = getVertexPitchFromType(vType); result.Stride = getVertexPitchFromType(vType);
const c8* vbuf = static_cast<const c8*>(vertices); const c8* vbuf = static_cast<const c8*>(vertices);
glBufferData(GL_ARRAY_BUFFER, vertexCount * result.Stride, vbuf, GL_STATIC_DRAW); glBufferData(GL_ARRAY_BUFFER, vertexCount * result.Stride, vbuf, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, result.index_buffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, result.index_buffer);
const void* indices = mb->getIndices(); const void* indices = mb->getIndices();
u32 indexCount = mb->getIndexCount(); u32 indexCount = mb->getIndexCount();
GLenum indexSize; GLenum indexSize;
switch (mb->getIndexType()) switch (mb->getIndexType())
{ {
case irr::video::EIT_16BIT: case irr::video::EIT_16BIT:
{ {
indexSize = sizeof(u16); indexSize = sizeof(u16);
result.IndexType = GL_UNSIGNED_SHORT; result.IndexType = GL_UNSIGNED_SHORT;
break; break;
} }
case irr::video::EIT_32BIT: case irr::video::EIT_32BIT:
{ {
indexSize = sizeof(u32); indexSize = sizeof(u32);
result.IndexType = GL_UNSIGNED_INT; result.IndexType = GL_UNSIGNED_INT;
break; break;
} }
default: default:
{ {
assert(0 && "Wrong index size"); assert(0 && "Wrong index size");
} }
} }
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexCount * indexSize, indices, GL_STATIC_DRAW); glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexCount * indexSize, indices, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
result.IndexCount = mb->getIndexCount(); result.IndexCount = mb->getIndexCount();
switch (mb->getPrimitiveType()) switch (mb->getPrimitiveType())
{ {
case scene::EPT_POINTS: case scene::EPT_POINTS:
result.PrimitiveType = GL_POINTS; result.PrimitiveType = GL_POINTS;
break;
case scene::EPT_TRIANGLE_STRIP:
result.PrimitiveType = GL_TRIANGLE_STRIP;
break;
case scene::EPT_TRIANGLE_FAN:
result.PrimitiveType = GL_TRIANGLE_FAN;
break;
case scene::EPT_LINES:
result.PrimitiveType = GL_LINES;
break; break;
case scene::EPT_TRIANGLE_STRIP: case scene::EPT_TRIANGLES:
result.PrimitiveType = GL_TRIANGLE_STRIP; result.PrimitiveType = GL_TRIANGLES;
break; break;
case scene::EPT_TRIANGLE_FAN: case scene::EPT_POINT_SPRITES:
result.PrimitiveType = GL_TRIANGLE_FAN; case scene::EPT_LINE_LOOP:
break; case scene::EPT_POLYGON:
case scene::EPT_LINES: case scene::EPT_LINE_STRIP:
result.PrimitiveType = GL_LINES; case scene::EPT_QUAD_STRIP:
break; case scene::EPT_QUADS:
case scene::EPT_TRIANGLES: assert(0 && "Unsupported primitive type");
result.PrimitiveType = GL_TRIANGLES; }
break; ITexture *tex;
case scene::EPT_POINT_SPRITES: for (unsigned i = 0; i < 6; i++)
case scene::EPT_LINE_LOOP: {
case scene::EPT_POLYGON: tex = mb->getMaterial().getTexture(i);
case scene::EPT_LINE_STRIP: if (tex)
case scene::EPT_QUAD_STRIP: result.textures[i] = getTextureGLuint(tex);
case scene::EPT_QUADS: else
assert(0 && "Unsupported primitive type"); result.textures[i] = 0;
} }
ITexture *tex;
for (unsigned i = 0; i < 6; i++)
{
tex = mb->getMaterial().getTexture(i);
if (tex)
result.textures[i] = getTextureGLuint(tex);
else
result.textures[i] = 0;
}
result.TextureMatrix = 0; result.TextureMatrix = 0;
return result; return result;
} }
void computeMVP(core::matrix4 &ModelViewProjectionMatrix) void computeMVP(core::matrix4 &ModelViewProjectionMatrix)
{ {
ModelViewProjectionMatrix = irr_driver->getVideoDriver()->getTransform(video::ETS_PROJECTION); ModelViewProjectionMatrix = irr_driver->getVideoDriver()->getTransform(video::ETS_PROJECTION);
ModelViewProjectionMatrix *= irr_driver->getVideoDriver()->getTransform(video::ETS_VIEW); ModelViewProjectionMatrix *= irr_driver->getVideoDriver()->getTransform(video::ETS_VIEW);
ModelViewProjectionMatrix *= irr_driver->getVideoDriver()->getTransform(video::ETS_WORLD); ModelViewProjectionMatrix *= irr_driver->getVideoDriver()->getTransform(video::ETS_WORLD);
} }
void computeTIMV(core::matrix4 &TransposeInverseModelView) void computeTIMV(core::matrix4 &TransposeInverseModelView)
{ {
TransposeInverseModelView = irr_driver->getVideoDriver()->getTransform(video::ETS_VIEW); TransposeInverseModelView = irr_driver->getVideoDriver()->getTransform(video::ETS_VIEW);
TransposeInverseModelView *= irr_driver->getVideoDriver()->getTransform(video::ETS_WORLD); TransposeInverseModelView *= irr_driver->getVideoDriver()->getTransform(video::ETS_WORLD);
TransposeInverseModelView.makeInverse(); TransposeInverseModelView.makeInverse();
TransposeInverseModelView = TransposeInverseModelView.getTransposed(); TransposeInverseModelView = TransposeInverseModelView.getTransposed();
} }
void drawObjectPass1(const GLMesh &mesh, const core::matrix4 & ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView) void drawObjectPass1(const GLMesh &mesh, const core::matrix4 & ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView)
@ -240,34 +240,34 @@ void drawObjectRefPass1(const GLMesh &mesh, const core::matrix4 & ModelViewProje
void drawGrassPass1(const GLMesh &mesh, const core::matrix4 & ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView, core::vector3df windDir) void drawGrassPass1(const GLMesh &mesh, const core::matrix4 & ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView, core::vector3df windDir)
{ {
irr_driver->IncreaseObjectCount(); irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType; GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType; GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount; size_t count = mesh.IndexCount;
setTexture(0, mesh.textures[0], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true); setTexture(0, mesh.textures[0], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
MeshShader::GrassPass1Shader::setUniforms(ModelViewProjectionMatrix, TransposeInverseModelView, windDir, 0); MeshShader::GrassPass1Shader::setUniforms(ModelViewProjectionMatrix, TransposeInverseModelView, windDir, 0);
assert(mesh.vao_first_pass); assert(mesh.vao_first_pass);
glBindVertexArray(mesh.vao_first_pass); glBindVertexArray(mesh.vao_first_pass);
glDrawElements(ptype, count, itype, 0); glDrawElements(ptype, count, itype, 0);
} }
void drawNormalPass(const GLMesh &mesh, const core::matrix4 & ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView) void drawNormalPass(const GLMesh &mesh, const core::matrix4 & ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView)
{ {
irr_driver->IncreaseObjectCount(); irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType; GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType; GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount; size_t count = mesh.IndexCount;
assert(mesh.textures[1]); assert(mesh.textures[1]);
setTexture(0, mesh.textures[1], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true); setTexture(0, mesh.textures[1], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
MeshShader::NormalMapShader::setUniforms(ModelViewProjectionMatrix, TransposeInverseModelView, 0); MeshShader::NormalMapShader::setUniforms(ModelViewProjectionMatrix, TransposeInverseModelView, 0);
assert(mesh.vao_first_pass); assert(mesh.vao_first_pass);
glBindVertexArray(mesh.vao_first_pass); glBindVertexArray(mesh.vao_first_pass);
glDrawElements(ptype, count, itype, 0); glDrawElements(ptype, count, itype, 0);
} }
void drawSphereMap(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView) void drawSphereMap(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView)
@ -437,27 +437,27 @@ void drawCaustics(const GLMesh &mesh, const core::matrix4 & ModelViewProjectionM
void drawGrassPass2(const GLMesh &mesh, const core::matrix4 & ModelViewProjectionMatrix, core::vector3df windDir) void drawGrassPass2(const GLMesh &mesh, const core::matrix4 & ModelViewProjectionMatrix, core::vector3df windDir)
{ {
irr_driver->IncreaseObjectCount(); irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType; GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType; GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount; size_t count = mesh.IndexCount;
setTexture(MeshShader::GrassPass2Shader::TU_Albedo, mesh.textures[0], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true); setTexture(MeshShader::GrassPass2Shader::TU_Albedo, mesh.textures[0], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
if (irr_driver->getLightViz()) if (irr_driver->getLightViz())
{ {
GLint swizzleMask[] = {GL_ONE, GL_ONE, GL_ONE, GL_ALPHA}; GLint swizzleMask[] = {GL_ONE, GL_ONE, GL_ONE, GL_ALPHA};
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask); glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
} }
else else
{ {
GLint swizzleMask[] = {GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA}; GLint swizzleMask[] = {GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA};
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask); glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
} }
MeshShader::GrassPass2Shader::setUniforms(ModelViewProjectionMatrix, windDir); MeshShader::GrassPass2Shader::setUniforms(ModelViewProjectionMatrix, windDir);
assert(mesh.vao_second_pass); assert(mesh.vao_second_pass);
glBindVertexArray(mesh.vao_second_pass); glBindVertexArray(mesh.vao_second_pass);
glDrawElements(ptype, count, itype, 0); glDrawElements(ptype, count, itype, 0);
} }
void drawUntexturedObject(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix) void drawUntexturedObject(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix)
@ -477,53 +477,53 @@ void drawUntexturedObject(const GLMesh &mesh, const core::matrix4 &ModelViewProj
void drawObjectRimLimit(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView, const core::matrix4 &TextureMatrix) void drawObjectRimLimit(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TransposeInverseModelView, const core::matrix4 &TextureMatrix)
{ {
irr_driver->IncreaseObjectCount(); irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType; GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType; GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount; size_t count = mesh.IndexCount;
setTexture(MeshShader::ObjectRimLimitShader::TU_Albedo, mesh.textures[0], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true); setTexture(MeshShader::ObjectRimLimitShader::TU_Albedo, mesh.textures[0], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
if (irr_driver->getLightViz()) if (irr_driver->getLightViz())
{ {
GLint swizzleMask[] = { GL_ONE, GL_ONE, GL_ONE, GL_ALPHA }; GLint swizzleMask[] = { GL_ONE, GL_ONE, GL_ONE, GL_ALPHA };
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask); glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
} }
else else
{ {
GLint swizzleMask[] = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA }; GLint swizzleMask[] = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA };
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask); glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
} }
MeshShader::ObjectRimLimitShader::setUniforms(ModelViewProjectionMatrix, TransposeInverseModelView, TextureMatrix); MeshShader::ObjectRimLimitShader::setUniforms(ModelViewProjectionMatrix, TransposeInverseModelView, TextureMatrix);
assert(mesh.vao_second_pass); assert(mesh.vao_second_pass);
glBindVertexArray(mesh.vao_second_pass); glBindVertexArray(mesh.vao_second_pass);
glDrawElements(ptype, count, itype, 0); glDrawElements(ptype, count, itype, 0);
} }
void drawObjectUnlit(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix) void drawObjectUnlit(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix)
{ {
irr_driver->IncreaseObjectCount(); irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType; GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType; GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount; size_t count = mesh.IndexCount;
setTexture(MeshShader::ObjectUnlitShader::TU_tex, mesh.textures[0], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true); setTexture(MeshShader::ObjectUnlitShader::TU_tex, mesh.textures[0], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
if (irr_driver->getLightViz()) if (irr_driver->getLightViz())
{ {
GLint swizzleMask[] = { GL_ONE, GL_ONE, GL_ONE, GL_ALPHA }; GLint swizzleMask[] = { GL_ONE, GL_ONE, GL_ONE, GL_ALPHA };
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask); glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
} }
else else
{ {
GLint swizzleMask[] = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA }; GLint swizzleMask[] = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA };
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask); glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
} }
MeshShader::ObjectUnlitShader::setUniforms(ModelViewProjectionMatrix); MeshShader::ObjectUnlitShader::setUniforms(ModelViewProjectionMatrix);
assert(mesh.vao_second_pass); assert(mesh.vao_second_pass);
glBindVertexArray(mesh.vao_second_pass); glBindVertexArray(mesh.vao_second_pass);
glDrawElements(ptype, count, itype, 0); glDrawElements(ptype, count, itype, 0);
} }
void drawDetailledObjectPass2(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix) void drawDetailledObjectPass2(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix)
@ -557,43 +557,43 @@ void drawDetailledObjectPass2(const GLMesh &mesh, const core::matrix4 &ModelView
void drawObjectPass2(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TextureMatrix) void drawObjectPass2(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TextureMatrix)
{ {
irr_driver->IncreaseObjectCount(); irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType; GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType; GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount; size_t count = mesh.IndexCount;
setTexture(MeshShader::ObjectPass2Shader::TU_Albedo, mesh.textures[0], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true); setTexture(MeshShader::ObjectPass2Shader::TU_Albedo, mesh.textures[0], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
if (irr_driver->getLightViz()) if (irr_driver->getLightViz())
{ {
GLint swizzleMask[] = { GL_ONE, GL_ONE, GL_ONE, GL_ALPHA }; GLint swizzleMask[] = { GL_ONE, GL_ONE, GL_ONE, GL_ALPHA };
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask); glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
} }
else else
{ {
GLint swizzleMask[] = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA }; GLint swizzleMask[] = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA };
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask); glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
} }
MeshShader::ObjectPass2Shader::setUniforms(ModelViewProjectionMatrix, TextureMatrix); MeshShader::ObjectPass2Shader::setUniforms(ModelViewProjectionMatrix, TextureMatrix);
assert(mesh.vao_second_pass); assert(mesh.vao_second_pass);
glBindVertexArray(mesh.vao_second_pass); glBindVertexArray(mesh.vao_second_pass);
glDrawElements(ptype, count, itype, 0); glDrawElements(ptype, count, itype, 0);
} }
void drawTransparentObject(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TextureMatrix) void drawTransparentObject(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TextureMatrix)
{ {
irr_driver->IncreaseObjectCount(); irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType; GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType; GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount; size_t count = mesh.IndexCount;
setTexture(0, mesh.textures[0], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true); setTexture(0, mesh.textures[0], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
MeshShader::TransparentShader::setUniforms(ModelViewProjectionMatrix, TextureMatrix, 0); MeshShader::TransparentShader::setUniforms(ModelViewProjectionMatrix, TextureMatrix, 0);
assert(mesh.vao_first_pass); assert(mesh.vao_first_pass);
glBindVertexArray(mesh.vao_first_pass); glBindVertexArray(mesh.vao_first_pass);
glDrawElements(ptype, count, itype, 0); glDrawElements(ptype, count, itype, 0);
} }
void drawTransparentFogObject(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TextureMatrix) void drawTransparentFogObject(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix, const core::matrix4 &TextureMatrix)
@ -630,20 +630,20 @@ void drawTransparentFogObject(const GLMesh &mesh, const core::matrix4 &ModelView
void drawBubble(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix) void drawBubble(const GLMesh &mesh, const core::matrix4 &ModelViewProjectionMatrix)
{ {
irr_driver->IncreaseObjectCount(); irr_driver->IncreaseObjectCount();
const float time = irr_driver->getDevice()->getTimer()->getTime() / 1000.0f; const float time = irr_driver->getDevice()->getTimer()->getTime() / 1000.0f;
float transparency = 1.; float transparency = 1.;
GLenum ptype = mesh.PrimitiveType; GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType; GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount; size_t count = mesh.IndexCount;
setTexture(0, mesh.textures[0], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true); setTexture(0, mesh.textures[0], GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
MeshShader::BubbleShader::setUniforms(ModelViewProjectionMatrix, 0, time, transparency); MeshShader::BubbleShader::setUniforms(ModelViewProjectionMatrix, 0, time, transparency);
assert(mesh.vao_first_pass); assert(mesh.vao_first_pass);
glBindVertexArray(mesh.vao_first_pass); glBindVertexArray(mesh.vao_first_pass);
glDrawElements(ptype, count, itype, 0); glDrawElements(ptype, count, itype, 0);
} }
void drawShadowRef(const GLMesh &mesh) void drawShadowRef(const GLMesh &mesh)
@ -692,41 +692,41 @@ void drawShadow(const GLMesh &mesh)
bool isObject(video::E_MATERIAL_TYPE type) bool isObject(video::E_MATERIAL_TYPE type)
{ {
if (type == irr_driver->getShader(ES_OBJECTPASS)) if (type == irr_driver->getShader(ES_OBJECTPASS))
return true; return true;
if (type == irr_driver->getShader(ES_OBJECTPASS_REF)) if (type == irr_driver->getShader(ES_OBJECTPASS_REF))
return true; return true;
if (type == irr_driver->getShader(ES_OBJECTPASS_RIMLIT)) if (type == irr_driver->getShader(ES_OBJECTPASS_RIMLIT))
return true; return true;
if (type == irr_driver->getShader(ES_NORMAL_MAP)) if (type == irr_driver->getShader(ES_NORMAL_MAP))
return true; return true;
if (type == irr_driver->getShader(ES_SPHERE_MAP)) if (type == irr_driver->getShader(ES_SPHERE_MAP))
return true; return true;
if (type == irr_driver->getShader(ES_SPLATTING)) if (type == irr_driver->getShader(ES_SPLATTING))
return true; return true;
if (type == irr_driver->getShader(ES_GRASS)) if (type == irr_driver->getShader(ES_GRASS))
return true; return true;
if (type == irr_driver->getShader(ES_GRASS_REF)) if (type == irr_driver->getShader(ES_GRASS_REF))
return true; return true;
if (type == irr_driver->getShader(ES_BUBBLES)) if (type == irr_driver->getShader(ES_BUBBLES))
return true; return true;
if (type == irr_driver->getShader(ES_OBJECT_UNLIT)) if (type == irr_driver->getShader(ES_OBJECT_UNLIT))
return true; return true;
if (type == irr_driver->getShader(ES_CAUSTICS)) if (type == irr_driver->getShader(ES_CAUSTICS))
return true; return true;
if (type == video::EMT_TRANSPARENT_ALPHA_CHANNEL) if (type == video::EMT_TRANSPARENT_ALPHA_CHANNEL)
return true; return true;
if (type == video::EMT_ONETEXTURE_BLEND) if (type == video::EMT_ONETEXTURE_BLEND)
return true; return true;
if (type == video::EMT_TRANSPARENT_ADD_COLOR) if (type == video::EMT_TRANSPARENT_ADD_COLOR)
return true; return true;
if (type == video::EMT_SOLID) if (type == video::EMT_SOLID)
return true; return true;
if (type == video::EMT_LIGHTMAP_LIGHTING) if (type == video::EMT_LIGHTMAP_LIGHTING)
return true; return true;
if (type == video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF) if (type == video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF)
return true; return true;
return false; return false;
} }
void initvaostate(GLMesh &mesh, GeometricMaterial GeoMat, ShadedMaterial ShadedMat) void initvaostate(GLMesh &mesh, GeometricMaterial GeoMat, ShadedMaterial ShadedMat)

22
src/graphics/stkmesh.hpp
View File

@ -40,19 +40,19 @@ enum TransparentMaterial
}; };
struct GLMesh { struct GLMesh {
GLuint vao_first_pass; GLuint vao_first_pass;
GLuint vao_second_pass; GLuint vao_second_pass;
GLuint vao_glow_pass; GLuint vao_glow_pass;
GLuint vao_displace_pass; GLuint vao_displace_pass;
GLuint vao_displace_mask_pass; GLuint vao_displace_mask_pass;
GLuint vao_shadow_pass; GLuint vao_shadow_pass;
GLuint vertex_buffer; GLuint vertex_buffer;
GLuint index_buffer; GLuint index_buffer;
GLuint textures[6]; GLuint textures[6];
GLenum PrimitiveType; GLenum PrimitiveType;
GLenum IndexType; GLenum IndexType;
size_t IndexCount; size_t IndexCount;
size_t Stride; size_t Stride;
core::matrix4 TextureMatrix; core::matrix4 TextureMatrix;
}; };

10
src/graphics/wind.hpp
View File

@ -24,14 +24,14 @@ using core::vector3df;
class Wind class Wind
{ {
public: public:
Wind(); Wind();
vector3df getWind() const; vector3df getWind() const;
void update(); void update();
private: private:
vector3df m_wind; vector3df m_wind;
float m_seed; float m_seed;
}; };
#endif #endif

6
src/guiengine/skin.cpp
View File

@ -2097,7 +2097,7 @@ void Skin::draw3DSunkenPane (IGUIElement *element, video::SColor bgcolor,
core::recti innerArea = borderArea; core::recti innerArea = borderArea;
innerArea.UpperLeftCorner += position2d< s32 >( 3, 3 ); innerArea.UpperLeftCorner += position2d< s32 >( 3, 3 );
innerArea.LowerRightCorner -= position2d< s32 >( 3, 3 ); innerArea.LowerRightCorner -= position2d< s32 >( 3, 3 );
GL32_draw2DRectangle(focused ? bg_color_focused : bg_color, innerArea); GL32_draw2DRectangle(focused ? bg_color_focused : bg_color, innerArea);
return; return;
} }
else if (type == WTYPE_LIST) else if (type == WTYPE_LIST)
@ -2161,7 +2161,7 @@ void Skin::drawBGFadeColor()
SColor color = SkinConfig::m_colors["dialog_background::neutral"]; SColor color = SkinConfig::m_colors["dialog_background::neutral"];
if (m_dialog_size < 1.0f) if (m_dialog_size < 1.0f)
color.setAlpha( (unsigned int)(color.getAlpha()*m_dialog_size )); color.setAlpha( (unsigned int)(color.getAlpha()*m_dialog_size ));
GL32_draw2DRectangle(color, GL32_draw2DRectangle(color,
core::recti(position2d< s32 >(0,0), core::recti(position2d< s32 >(0,0),
GUIEngine::getDriver()->getCurrentRenderTargetSize()) ); GUIEngine::getDriver()->getCurrentRenderTargetSize()) );
} // drawBGFadeColor } // drawBGFadeColor
@ -2211,7 +2211,7 @@ void Skin::draw3DMenuPane (IGUIElement *element, const core::recti &rect,
const core::recti *clip) const core::recti *clip)
{ {
SColor color = SColor(150, 96, 74, 196); SColor color = SColor(150, 96, 74, 196);
GL32_draw2DRectangle(color, rect); GL32_draw2DRectangle(color, rect);
} // draw3DMenuPane } // draw3DMenuPane
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------

212
src/guiengine/widgets/CGUIEditBox.h
View File

@ -16,155 +16,155 @@
using namespace irr; using namespace irr;
using namespace gui; using namespace gui;
class CGUIEditBox : public IGUIEditBox class CGUIEditBox : public IGUIEditBox
{ {
public: public:
LEAK_CHECK() LEAK_CHECK()
//! constructor //! constructor
CGUIEditBox(const wchar_t* text, bool border, IGUIEnvironment* environment, CGUIEditBox(const wchar_t* text, bool border, IGUIEnvironment* environment,
IGUIElement* parent, s32 id, const core::rect<s32>& rectangle, bool is_rtl); IGUIElement* parent, s32 id, const core::rect<s32>& rectangle, bool is_rtl);
//! destructor //! destructor
virtual ~CGUIEditBox(); virtual ~CGUIEditBox();
//! Sets another skin independent font. //! Sets another skin independent font.
virtual void setOverrideFont(IGUIFont* font=0); virtual void setOverrideFont(IGUIFont* font=0);
//! Sets another color for the text. //! Sets another color for the text.
virtual void setOverrideColor(video::SColor color); virtual void setOverrideColor(video::SColor color);
//! Gets the override color //! Gets the override color
virtual video::SColor getOverrideColor() const; virtual video::SColor getOverrideColor() const;
//! Sets if the text should use the overide color or the //! Sets if the text should use the overide color or the
//! color in the gui skin. //! color in the gui skin.
virtual void enableOverrideColor(bool enable); virtual void enableOverrideColor(bool enable);
//! Checks if an override color is enabled //! Checks if an override color is enabled
/** \return true if the override color is enabled, false otherwise */ /** \return true if the override color is enabled, false otherwise */
virtual bool isOverrideColorEnabled(void) const; virtual bool isOverrideColorEnabled(void) const;
//! Turns the border on or off //! Turns the border on or off
virtual void setDrawBorder(bool border); virtual void setDrawBorder(bool border);
//! Enables or disables word wrap for using the edit box as multiline text editor. //! Enables or disables word wrap for using the edit box as multiline text editor.
virtual void setWordWrap(bool enable); virtual void setWordWrap(bool enable);
//! Checks if word wrap is enabled //! Checks if word wrap is enabled
//! \return true if word wrap is enabled, false otherwise //! \return true if word wrap is enabled, false otherwise
virtual bool isWordWrapEnabled() const; virtual bool isWordWrapEnabled() const;
//! Enables or disables newlines. //! Enables or disables newlines.
/** \param enable: If set to true, the EGET_EDITBOX_ENTER event will not be fired, /** \param enable: If set to true, the EGET_EDITBOX_ENTER event will not be fired,
instead a newline character will be inserted. */ instead a newline character will be inserted. */
virtual void setMultiLine(bool enable); virtual void setMultiLine(bool enable);
//! Checks if multi line editing is enabled //! Checks if multi line editing is enabled
//! \return true if mult-line is enabled, false otherwise //! \return true if mult-line is enabled, false otherwise
virtual bool isMultiLineEnabled() const; virtual bool isMultiLineEnabled() const;
//! Enables or disables automatic scrolling with cursor position //! Enables or disables automatic scrolling with cursor position
//! \param enable: If set to true, the text will move around with the cursor position //! \param enable: If set to true, the text will move around with the cursor position
virtual void setAutoScroll(bool enable); virtual void setAutoScroll(bool enable);
//! Checks to see if automatic scrolling is enabled //! Checks to see if automatic scrolling is enabled
//! \return true if automatic scrolling is enabled, false if not //! \return true if automatic scrolling is enabled, false if not
virtual bool isAutoScrollEnabled() const; virtual bool isAutoScrollEnabled() const;
//! Gets the size area of the text in the edit box //! Gets the size area of the text in the edit box
//! \return Returns the size in pixels of the text //! \return Returns the size in pixels of the text
virtual core::dimension2du getTextDimension(); virtual core::dimension2du getTextDimension();
//! Sets text justification //! Sets text justification
virtual void setTextAlignment(EGUI_ALIGNMENT horizontal, EGUI_ALIGNMENT vertical); virtual void setTextAlignment(EGUI_ALIGNMENT horizontal, EGUI_ALIGNMENT vertical);
//! called if an event happened. //! called if an event happened.
virtual bool OnEvent(const SEvent& event); virtual bool OnEvent(const SEvent& event);
//! draws the element and its children //! draws the element and its children
virtual void draw(); virtual void draw();
//! Sets the new caption of this element. //! Sets the new caption of this element.
virtual void setText(const wchar_t* text); virtual void setText(const wchar_t* text);
//! Sets the maximum amount of characters which may be entered in the box. //! Sets the maximum amount of characters which may be entered in the box.
//! \param max: Maximum amount of characters. If 0, the character amount is //! \param max: Maximum amount of characters. If 0, the character amount is
//! infinity. //! infinity.
virtual void setMax(u32 max); virtual void setMax(u32 max);
//! Returns maximum amount of characters, previously set by setMax(); //! Returns maximum amount of characters, previously set by setMax();
virtual u32 getMax() const; virtual u32 getMax() const;
//! Sets whether the edit box is a password box. Setting this to true will //! Sets whether the edit box is a password box. Setting this to true will
/** disable MultiLine, WordWrap and the ability to copy with ctrl+c or ctrl+x /** disable MultiLine, WordWrap and the ability to copy with ctrl+c or ctrl+x
\param passwordBox: true to enable password, false to disable \param passwordBox: true to enable password, false to disable
\param passwordChar: the character that is displayed instead of letters */ \param passwordChar: the character that is displayed instead of letters */
virtual void setPasswordBox(bool passwordBox, wchar_t passwordChar = L'*'); virtual void setPasswordBox(bool passwordBox, wchar_t passwordChar = L'*');
//! Returns true if the edit box is currently a password box. //! Returns true if the edit box is currently a password box.
virtual bool isPasswordBox() const; virtual bool isPasswordBox() const;
//! Updates the absolute position, splits text if required //! Updates the absolute position, splits text if required
virtual void updateAbsolutePosition(); virtual void updateAbsolutePosition();
//! Writes attributes of the element. //! Writes attributes of the element.
virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const; virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const;
//! Reads attributes of the element //! Reads attributes of the element
virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options); virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options);
virtual irr::gui::IGUIFont* getOverrideFont() const { return NULL; } virtual irr::gui::IGUIFont* getOverrideFont() const { return NULL; }
virtual irr::gui::IGUIFont* getActiveFont() const { return NULL; } virtual irr::gui::IGUIFont* getActiveFont() const { return NULL; }
virtual void setDrawBackground(bool) { } virtual void setDrawBackground(bool) { }
protected: protected:
//! Breaks the single text line. //! Breaks the single text line.
void breakText(); void breakText();
//! sets the area of the given line //! sets the area of the given line
void setTextRect(s32 line); void setTextRect(s32 line);
//! returns the line number that the cursor is on //! returns the line number that the cursor is on
s32 getLineFromPos(s32 pos); s32 getLineFromPos(s32 pos);
//! adds a letter to the edit box //! adds a letter to the edit box
void inputChar(wchar_t c); void inputChar(wchar_t c);
//! calculates the current scroll position //! calculates the current scroll position
void calculateScrollPos(); void calculateScrollPos();
//! send some gui event to parent //! send some gui event to parent
void sendGuiEvent(EGUI_EVENT_TYPE type); void sendGuiEvent(EGUI_EVENT_TYPE type);
//! set text markers //! set text markers
void setTextMarkers(s32 begin, s32 end); void setTextMarkers(s32 begin, s32 end);
bool processKey(const SEvent& event); bool processKey(const SEvent& event);
bool processMouse(const SEvent& event); bool processMouse(const SEvent& event);
s32 getCursorPos(s32 x, s32 y); s32 getCursorPos(s32 x, s32 y);
bool MouseMarking; bool MouseMarking;
bool Border; bool Border;
bool OverrideColorEnabled; bool OverrideColorEnabled;
s32 MarkBegin; s32 MarkBegin;
s32 MarkEnd; s32 MarkEnd;
video::SColor OverrideColor; video::SColor OverrideColor;
gui::IGUIFont *OverrideFont, *LastBreakFont; gui::IGUIFont *OverrideFont, *LastBreakFont;
IOSOperator* Operator; IOSOperator* Operator;
StkTime::TimeType BlinkStartTime; StkTime::TimeType BlinkStartTime;
s32 CursorPos; s32 CursorPos;
s32 HScrollPos, VScrollPos; // scroll position in characters s32 HScrollPos, VScrollPos; // scroll position in characters
u32 Max; u32 Max;
bool m_rtl; bool m_rtl;
bool WordWrap, MultiLine, AutoScroll, PasswordBox; bool WordWrap, MultiLine, AutoScroll, PasswordBox;
wchar_t PasswordChar; wchar_t PasswordChar;
EGUI_ALIGNMENT HAlign, VAlign; EGUI_ALIGNMENT HAlign, VAlign;
core::array< core::stringw > BrokenText; core::array< core::stringw > BrokenText;
core::array< s32 > BrokenTextPositions; core::array< s32 > BrokenTextPositions;
core::rect<s32> CurrentTextRect, FrameRect; // temporary values core::rect<s32> CurrentTextRect, FrameRect; // temporary values
}; };

646
src/guiengine/widgets/CGUISTKListBox.cpp
View File

@ -21,59 +21,59 @@ namespace gui
//! constructor //! constructor
CGUISTKListBox::CGUISTKListBox(IGUIEnvironment* environment, IGUIElement* parent, CGUISTKListBox::CGUISTKListBox(IGUIEnvironment* environment, IGUIElement* parent,
s32 id, core::rect<s32> rectangle, bool clip, s32 id, core::rect<s32> rectangle, bool clip,
bool drawBack, bool moveOverSelect) bool drawBack, bool moveOverSelect)
: IGUIElement(EGUIET_LIST_BOX, environment, parent, id, rectangle), Selected(-1), : IGUIElement(EGUIET_LIST_BOX, environment, parent, id, rectangle), Selected(-1),
ItemHeight(0),ItemHeightOverride(0), ItemHeight(0),ItemHeightOverride(0),
TotalItemHeight(0), ItemsIconWidth(0), Font(0), IconBank(0), TotalItemHeight(0), ItemsIconWidth(0), Font(0), IconBank(0),
ScrollBar(0), selectTime(0), LastKeyTime(0), Selecting(false), DrawBack(drawBack), ScrollBar(0), selectTime(0), LastKeyTime(0), Selecting(false), DrawBack(drawBack),
MoveOverSelect(moveOverSelect), AutoScroll(true), HighlightWhenNotFocused(true) MoveOverSelect(moveOverSelect), AutoScroll(true), HighlightWhenNotFocused(true)
{ {
#ifdef _DEBUG #ifdef _DEBUG
setDebugName("CGUISTKListBox"); setDebugName("CGUISTKListBox");
#endif #endif
IGUISkin* skin = Environment->getSkin(); IGUISkin* skin = Environment->getSkin();
const s32 s = skin->getSize(EGDS_SCROLLBAR_SIZE); const s32 s = skin->getSize(EGDS_SCROLLBAR_SIZE);
ScrollBar = Environment->addScrollBar(false, ScrollBar = Environment->addScrollBar(false,
core::rect<s32>(RelativeRect.getWidth() - s, 0, core::rect<s32>(RelativeRect.getWidth() - s, 0,
RelativeRect.getWidth(), RelativeRect.getHeight()), this, -1); RelativeRect.getWidth(), RelativeRect.getHeight()), this, -1);
ScrollBar->grab(); ScrollBar->grab();
ScrollBar->setSubElement(true); ScrollBar->setSubElement(true);
ScrollBar->setTabStop(false); ScrollBar->setTabStop(false);
ScrollBar->setAlignment(EGUIA_LOWERRIGHT, EGUIA_LOWERRIGHT, EGUIA_UPPERLEFT, EGUIA_LOWERRIGHT); ScrollBar->setAlignment(EGUIA_LOWERRIGHT, EGUIA_LOWERRIGHT, EGUIA_UPPERLEFT, EGUIA_LOWERRIGHT);
ScrollBar->setVisible(false); ScrollBar->setVisible(false);
ScrollBar->setPos(0); ScrollBar->setPos(0);
setNotClipped(!clip); setNotClipped(!clip);
// this element can be tabbed to // this element can be tabbed to
setTabStop(true); setTabStop(true);
setTabOrder(-1); setTabOrder(-1);
updateAbsolutePosition(); updateAbsolutePosition();
} }
//! destructor //! destructor
CGUISTKListBox::~CGUISTKListBox() CGUISTKListBox::~CGUISTKListBox()
{ {
if (ScrollBar) if (ScrollBar)
ScrollBar->drop(); ScrollBar->drop();
if (Font) if (Font)
Font->drop(); Font->drop();
if (IconBank) if (IconBank)
IconBank->drop(); IconBank->drop();
} }
//! returns amount of list items //! returns amount of list items
u32 CGUISTKListBox::getItemCount() const u32 CGUISTKListBox::getItemCount() const
{ {
return Items.size(); return Items.size();
} }
@ -84,7 +84,7 @@ const wchar_t* CGUISTKListBox::getCellText(u32 row_num, u32 col_num) const
return 0; return 0;
if ( col_num >= Items[row_num].m_contents.size() ) if ( col_num >= Items[row_num].m_contents.size() )
return 0; return 0;
return Items[row_num].m_contents[col_num].m_text.c_str(); return Items[row_num].m_contents[col_num].m_text.c_str();
} }
CGUISTKListBox::ListItem CGUISTKListBox::getItem(u32 id) const CGUISTKListBox::ListItem CGUISTKListBox::getItem(u32 id) const
@ -105,109 +105,109 @@ s32 CGUISTKListBox::getIcon(u32 row_num, u32 col_num) const
void CGUISTKListBox::removeItem(u32 id) void CGUISTKListBox::removeItem(u32 id)
{ {
if (id >= Items.size()) if (id >= Items.size())
return; return;
if ((u32)Selected==id) if ((u32)Selected==id)
{ {
Selected = -1; Selected = -1;
} }
else if ((u32)Selected > id) else if ((u32)Selected > id)
{ {
Selected -= 1; Selected -= 1;
selectTime = (u32)StkTime::getTimeSinceEpoch(); selectTime = (u32)StkTime::getTimeSinceEpoch();
} }
Items.erase(id); Items.erase(id);
recalculateItemHeight(); recalculateItemHeight();
} }
s32 CGUISTKListBox::getItemAt(s32 xpos, s32 ypos) const s32 CGUISTKListBox::getItemAt(s32 xpos, s32 ypos) const
{ {
if ( xpos < AbsoluteRect.UpperLeftCorner.X || xpos >= AbsoluteRect.LowerRightCorner.X if ( xpos < AbsoluteRect.UpperLeftCorner.X || xpos >= AbsoluteRect.LowerRightCorner.X
|| ypos < AbsoluteRect.UpperLeftCorner.Y || ypos >= AbsoluteRect.LowerRightCorner.Y || ypos < AbsoluteRect.UpperLeftCorner.Y || ypos >= AbsoluteRect.LowerRightCorner.Y
) )
return -1; return -1;
if ( ItemHeight == 0 ) if ( ItemHeight == 0 )
return -1; return -1;
s32 item = ((ypos - AbsoluteRect.UpperLeftCorner.Y - 1) + ScrollBar->getPos()) / ItemHeight; s32 item = ((ypos - AbsoluteRect.UpperLeftCorner.Y - 1) + ScrollBar->getPos()) / ItemHeight;
if ( item < 0 || item >= (s32)Items.size()) if ( item < 0 || item >= (s32)Items.size())
return -1; return -1;
return item; return item;
} }
//! clears the list //! clears the list
void CGUISTKListBox::clear() void CGUISTKListBox::clear()
{ {
Items.clear(); Items.clear();
ItemsIconWidth = 0; ItemsIconWidth = 0;
Selected = -1; Selected = -1;
if (ScrollBar) if (ScrollBar)
ScrollBar->setPos(0); ScrollBar->setPos(0);
recalculateItemHeight(); recalculateItemHeight();
} }
void CGUISTKListBox::recalculateItemHeight() void CGUISTKListBox::recalculateItemHeight()
{ {
IGUISkin* skin = Environment->getSkin(); IGUISkin* skin = Environment->getSkin();
if (Font != skin->getFont()) if (Font != skin->getFont())
{ {
if (Font) if (Font)
Font->drop(); Font->drop();
Font = skin->getFont(); Font = skin->getFont();
if ( 0 == ItemHeightOverride ) if ( 0 == ItemHeightOverride )
ItemHeight = 0; ItemHeight = 0;
if (Font) if (Font)
{ {
if ( 0 == ItemHeightOverride ) if ( 0 == ItemHeightOverride )
ItemHeight = Font->getDimension(L"A").Height + 4; ItemHeight = Font->getDimension(L"A").Height + 4;
Font->grab(); Font->grab();
} }
} }
TotalItemHeight = ItemHeight * Items.size(); TotalItemHeight = ItemHeight * Items.size();
ScrollBar->setMax( core::max_(0, TotalItemHeight - AbsoluteRect.getHeight()) ); ScrollBar->setMax( core::max_(0, TotalItemHeight - AbsoluteRect.getHeight()) );
s32 minItemHeight = ItemHeight > 0 ? ItemHeight : 1; s32 minItemHeight = ItemHeight > 0 ? ItemHeight : 1;
ScrollBar->setSmallStep ( minItemHeight ); ScrollBar->setSmallStep ( minItemHeight );
ScrollBar->setLargeStep ( 2*minItemHeight ); ScrollBar->setLargeStep ( 2*minItemHeight );
if ( TotalItemHeight <= AbsoluteRect.getHeight() ) if ( TotalItemHeight <= AbsoluteRect.getHeight() )
ScrollBar->setVisible(false); ScrollBar->setVisible(false);
else else
ScrollBar->setVisible(true); ScrollBar->setVisible(true);
} }
//! returns id of selected item. returns -1 if no item is selected. //! returns id of selected item. returns -1 if no item is selected.
s32 CGUISTKListBox::getSelected() const s32 CGUISTKListBox::getSelected() const
{ {
return Selected; return Selected;
} }
//! sets the selected item. Set this to -1 if no item should be selected //! sets the selected item. Set this to -1 if no item should be selected
void CGUISTKListBox::setSelected(s32 id) void CGUISTKListBox::setSelected(s32 id)
{ {
if ((u32)id>=Items.size()) if ((u32)id>=Items.size())
Selected = -1; Selected = -1;
else else
Selected = id; Selected = id;
selectTime = (u32)StkTime::getTimeSinceEpoch(); selectTime = (u32)StkTime::getTimeSinceEpoch();
recalculateScrollPos(); recalculateScrollPos();
} }
s32 CGUISTKListBox::getRowByCellText(const wchar_t * text) s32 CGUISTKListBox::getRowByCellText(const wchar_t * text)
@ -249,184 +249,184 @@ s32 CGUISTKListBox::getRowByInternalName(const std::string & text) const
//! called if an event happened. //! called if an event happened.
bool CGUISTKListBox::OnEvent(const SEvent& event) bool CGUISTKListBox::OnEvent(const SEvent& event)
{ {
if (isEnabled()) if (isEnabled())
{ {
switch(event.EventType) switch(event.EventType)
{ {
case EET_KEY_INPUT_EVENT: case EET_KEY_INPUT_EVENT:
if (event.KeyInput.PressedDown && if (event.KeyInput.PressedDown &&
(event.KeyInput.Key == KEY_DOWN || (event.KeyInput.Key == KEY_DOWN ||
event.KeyInput.Key == KEY_UP || event.KeyInput.Key == KEY_UP ||
event.KeyInput.Key == KEY_HOME || event.KeyInput.Key == KEY_HOME ||
event.KeyInput.Key == KEY_END || event.KeyInput.Key == KEY_END ||
event.KeyInput.Key == KEY_NEXT || event.KeyInput.Key == KEY_NEXT ||
event.KeyInput.Key == KEY_PRIOR ) ) event.KeyInput.Key == KEY_PRIOR ) )
{ {
s32 oldSelected = Selected; s32 oldSelected = Selected;
switch (event.KeyInput.Key) switch (event.KeyInput.Key)
{ {
case KEY_DOWN: case KEY_DOWN:
Selected += 1; Selected += 1;
break; break;
case KEY_UP: case KEY_UP:
Selected -= 1; Selected -= 1;
break; break;
case KEY_HOME: case KEY_HOME:
Selected = 0; Selected = 0;
break; break;
case KEY_END: case KEY_END:
Selected = (s32)Items.size()-1; Selected = (s32)Items.size()-1;
break; break;
case KEY_NEXT: case KEY_NEXT:
Selected += AbsoluteRect.getHeight() / ItemHeight; Selected += AbsoluteRect.getHeight() / ItemHeight;
break; break;
case KEY_PRIOR: case KEY_PRIOR:
Selected -= AbsoluteRect.getHeight() / ItemHeight; Selected -= AbsoluteRect.getHeight() / ItemHeight;
break; break;
default: default:
break; break;
} }
if (Selected >= (s32)Items.size()) if (Selected >= (s32)Items.size())
Selected = Items.size() - 1; Selected = Items.size() - 1;
else else
if (Selected<0) if (Selected<0)
Selected = 0; Selected = 0;
recalculateScrollPos(); recalculateScrollPos();
// post the news // post the news
if (oldSelected != Selected && Parent && !Selecting && !MoveOverSelect) if (oldSelected != Selected && Parent && !Selecting && !MoveOverSelect)
{ {
SEvent e; SEvent e;
e.EventType = EET_GUI_EVENT; e.EventType = EET_GUI_EVENT;
e.GUIEvent.Caller = this; e.GUIEvent.Caller = this;
e.GUIEvent.Element = 0; e.GUIEvent.Element = 0;
e.GUIEvent.EventType = EGET_LISTBOX_CHANGED; e.GUIEvent.EventType = EGET_LISTBOX_CHANGED;
Parent->OnEvent(e); Parent->OnEvent(e);
} }
return true; return true;
} }
else else
if (!event.KeyInput.PressedDown && ( event.KeyInput.Key == KEY_RETURN || event.KeyInput.Key == KEY_SPACE ) ) if (!event.KeyInput.PressedDown && ( event.KeyInput.Key == KEY_RETURN || event.KeyInput.Key == KEY_SPACE ) )
{ {
if (Parent) if (Parent)
{ {
SEvent e; SEvent e;
e.EventType = EET_GUI_EVENT; e.EventType = EET_GUI_EVENT;
e.GUIEvent.Caller = this; e.GUIEvent.Caller = this;
e.GUIEvent.Element = 0; e.GUIEvent.Element = 0;
e.GUIEvent.EventType = EGET_LISTBOX_SELECTED_AGAIN; e.GUIEvent.EventType = EGET_LISTBOX_SELECTED_AGAIN;
Parent->OnEvent(e); Parent->OnEvent(e);
} }
return true; return true;
} }
break; break;
case EET_GUI_EVENT: case EET_GUI_EVENT:
switch(event.GUIEvent.EventType) switch(event.GUIEvent.EventType)
{ {
case gui::EGET_SCROLL_BAR_CHANGED: case gui::EGET_SCROLL_BAR_CHANGED:
if (event.GUIEvent.Caller == ScrollBar) if (event.GUIEvent.Caller == ScrollBar)
return true; return true;
break; break;
case gui::EGET_ELEMENT_FOCUS_LOST: case gui::EGET_ELEMENT_FOCUS_LOST:
{ {
if (event.GUIEvent.Caller == this) if (event.GUIEvent.Caller == this)
Selecting = false; Selecting = false;
break; break;
} }
default: default:
break; break;
} }
break; break;
case EET_MOUSE_INPUT_EVENT: case EET_MOUSE_INPUT_EVENT:
{ {
core::position2d<s32> p(event.MouseInput.X, event.MouseInput.Y); core::position2d<s32> p(event.MouseInput.X, event.MouseInput.Y);
switch(event.MouseInput.Event) switch(event.MouseInput.Event)
{ {
case EMIE_MOUSE_WHEEL: case EMIE_MOUSE_WHEEL:
ScrollBar->setPos(ScrollBar->getPos() + (event.MouseInput.Wheel < 0 ? -1 : 1)*-ItemHeight/2); ScrollBar->setPos(ScrollBar->getPos() + (event.MouseInput.Wheel < 0 ? -1 : 1)*-ItemHeight/2);
return true; return true;
case EMIE_LMOUSE_PRESSED_DOWN: case EMIE_LMOUSE_PRESSED_DOWN:
{ {
Selecting = true; Selecting = true;
return true; return true;
} }
case EMIE_LMOUSE_LEFT_UP: case EMIE_LMOUSE_LEFT_UP:
{ {
Selecting = false; Selecting = false;
if (isPointInside(p)) if (isPointInside(p))
selectNew(event.MouseInput.Y); selectNew(event.MouseInput.Y);
return true; return true;
} }
case EMIE_MOUSE_MOVED: case EMIE_MOUSE_MOVED:
if (Selecting || MoveOverSelect) if (Selecting || MoveOverSelect)
{ {
if (isPointInside(p)) if (isPointInside(p))
{ {
selectNew(event.MouseInput.Y, true); selectNew(event.MouseInput.Y, true);
return true; return true;
} }
} }
default: default:
break; break;
} }
} }
break; break;
case EET_LOG_TEXT_EVENT: case EET_LOG_TEXT_EVENT:
case EET_USER_EVENT: case EET_USER_EVENT:
case EET_JOYSTICK_INPUT_EVENT: case EET_JOYSTICK_INPUT_EVENT:
case EGUIET_FORCE_32_BIT: case EGUIET_FORCE_32_BIT:
break; break;
} }
} }
return IGUIElement::OnEvent(event); return IGUIElement::OnEvent(event);
} }
void CGUISTKListBox::selectNew(s32 ypos, bool onlyHover) void CGUISTKListBox::selectNew(s32 ypos, bool onlyHover)
{ {
u32 now = (u32)StkTime::getTimeSinceEpoch(); u32 now = (u32)StkTime::getTimeSinceEpoch();
s32 oldSelected = Selected; s32 oldSelected = Selected;
Selected = getItemAt(AbsoluteRect.UpperLeftCorner.X, ypos); Selected = getItemAt(AbsoluteRect.UpperLeftCorner.X, ypos);
if (Selected<0 && !Items.empty()) if (Selected<0 && !Items.empty())
Selected = 0; Selected = 0;
recalculateScrollPos(); recalculateScrollPos();
gui::EGUI_EVENT_TYPE eventType = (Selected == oldSelected && now < selectTime + 500) ? EGET_LISTBOX_SELECTED_AGAIN : EGET_LISTBOX_CHANGED; gui::EGUI_EVENT_TYPE eventType = (Selected == oldSelected && now < selectTime + 500) ? EGET_LISTBOX_SELECTED_AGAIN : EGET_LISTBOX_CHANGED;
selectTime = now; selectTime = now;
// post the news // post the news
if (Parent && !onlyHover) if (Parent && !onlyHover)
{ {
SEvent event; SEvent event;
event.EventType = EET_GUI_EVENT; event.EventType = EET_GUI_EVENT;
event.GUIEvent.Caller = this; event.GUIEvent.Caller = this;
event.GUIEvent.Element = 0; event.GUIEvent.Element = 0;
event.GUIEvent.EventType = eventType; event.GUIEvent.EventType = eventType;
Parent->OnEvent(event); Parent->OnEvent(event);
} }
} }
//! Update the position and size of the listbox, and update the scrollbar //! Update the position and size of the listbox, and update the scrollbar
void CGUISTKListBox::updateAbsolutePosition() void CGUISTKListBox::updateAbsolutePosition()
{ {
IGUIElement::updateAbsolutePosition(); IGUIElement::updateAbsolutePosition();
recalculateItemHeight(); recalculateItemHeight();
} }
@ -563,10 +563,10 @@ void CGUISTKListBox::draw()
//! adds an list item with an icon //! adds an list item with an icon
u32 CGUISTKListBox::addItem(const ListItem & item) u32 CGUISTKListBox::addItem(const ListItem & item)
{ {
Items.push_back(item); Items.push_back(item);
recalculateItemHeight(); recalculateItemHeight();
recalculateIconWidth(); recalculateIconWidth();
return Items.size() - 1; return Items.size() - 1;
} }
@ -574,44 +574,44 @@ void CGUISTKListBox::setSpriteBank(IGUISpriteBank* bank)
{ {
if ( bank == IconBank ) if ( bank == IconBank )
return; return;
if (IconBank) if (IconBank)
IconBank->drop(); IconBank->drop();
IconBank = bank; IconBank = bank;
if (IconBank) if (IconBank)
IconBank->grab(); IconBank->grab();
} }
void CGUISTKListBox::recalculateScrollPos() void CGUISTKListBox::recalculateScrollPos()
{ {
if (!AutoScroll) if (!AutoScroll)
return; return;
const s32 selPos = (Selected == -1 ? TotalItemHeight : Selected * ItemHeight) - ScrollBar->getPos(); const s32 selPos = (Selected == -1 ? TotalItemHeight : Selected * ItemHeight) - ScrollBar->getPos();
if (selPos < 0) if (selPos < 0)
{ {
ScrollBar->setPos(ScrollBar->getPos() + selPos); ScrollBar->setPos(ScrollBar->getPos() + selPos);
} }
else else
if (selPos > AbsoluteRect.getHeight() - ItemHeight) if (selPos > AbsoluteRect.getHeight() - ItemHeight)
{ {
ScrollBar->setPos(ScrollBar->getPos() + selPos - AbsoluteRect.getHeight() + ItemHeight); ScrollBar->setPos(ScrollBar->getPos() + selPos - AbsoluteRect.getHeight() + ItemHeight);
} }
} }
void CGUISTKListBox::setAutoScrollEnabled(bool scroll) void CGUISTKListBox::setAutoScrollEnabled(bool scroll)
{ {
AutoScroll = scroll; AutoScroll = scroll;
} }
bool CGUISTKListBox::isAutoScrollEnabled() const bool CGUISTKListBox::isAutoScrollEnabled() const
{ {
_IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX; _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
return AutoScroll; return AutoScroll;
} }
void CGUISTKListBox::recalculateIconWidth() void CGUISTKListBox::recalculateIconWidth()
@ -619,128 +619,128 @@ void CGUISTKListBox::recalculateIconWidth()
for(int x = 0; x < (int)Items.getLast().m_contents.size(); ++x) for(int x = 0; x < (int)Items.getLast().m_contents.size(); ++x)
{ {
s32 icon = Items.getLast().m_contents[x].m_icon; s32 icon = Items.getLast().m_contents[x].m_icon;
if (IconBank && icon > -1 && if (IconBank && icon > -1 &&
IconBank->getSprites().size() > (u32)icon && IconBank->getSprites().size() > (u32)icon &&
IconBank->getSprites()[(u32)icon].Frames.size()) IconBank->getSprites()[(u32)icon].Frames.size())
{ {
u32 rno = IconBank->getSprites()[(u32)icon].Frames[0].rectNumber; u32 rno = IconBank->getSprites()[(u32)icon].Frames[0].rectNumber;
if (IconBank->getPositions().size() > rno) if (IconBank->getPositions().size() > rno)
{ {
const s32 w = IconBank->getPositions()[rno].getWidth(); const s32 w = IconBank->getPositions()[rno].getWidth();
if (w > ItemsIconWidth) if (w > ItemsIconWidth)
ItemsIconWidth = w; ItemsIconWidth = w;
} }
} }
} }
} }
void CGUISTKListBox::setCell(u32 row_num, u32 col_num, const wchar_t* text, s32 icon) void CGUISTKListBox::setCell(u32 row_num, u32 col_num, const wchar_t* text, s32 icon)
{ {
if ( row_num >= Items.size() ) if ( row_num >= Items.size() )
return; return;
if ( col_num >= Items[row_num].m_contents.size() ) if ( col_num >= Items[row_num].m_contents.size() )
return; return;
Items[row_num].m_contents[col_num].m_text = text; Items[row_num].m_contents[col_num].m_text = text;
Items[row_num].m_contents[col_num].m_icon = icon; Items[row_num].m_contents[col_num].m_icon = icon;
recalculateItemHeight(); recalculateItemHeight();
recalculateIconWidth(); recalculateIconWidth();
} }
void CGUISTKListBox::swapItems(u32 index1, u32 index2) void CGUISTKListBox::swapItems(u32 index1, u32 index2)
{ {
if ( index1 >= Items.size() || index2 >= Items.size() ) if ( index1 >= Items.size() || index2 >= Items.size() )
return; return;
ListItem dummmy = Items[index1]; ListItem dummmy = Items[index1];
Items[index1] = Items[index2]; Items[index1] = Items[index2];
Items[index2] = dummmy; Items[index2] = dummmy;
} }
void CGUISTKListBox::setItemOverrideColor(u32 index, video::SColor color) void CGUISTKListBox::setItemOverrideColor(u32 index, video::SColor color)
{ {
for ( u32 c=0; c < EGUI_LBC_COUNT; ++c ) for ( u32 c=0; c < EGUI_LBC_COUNT; ++c )
{ {
Items[index].OverrideColors[c].Use = true; Items[index].OverrideColors[c].Use = true;
Items[index].OverrideColors[c].Color = color; Items[index].OverrideColors[c].Color = color;
} }
} }
void CGUISTKListBox::setItemOverrideColor(u32 index, EGUI_LISTBOX_COLOR colorType, video::SColor color) void CGUISTKListBox::setItemOverrideColor(u32 index, EGUI_LISTBOX_COLOR colorType, video::SColor color)
{ {
if ( index >= Items.size() || colorType < 0 || colorType >= EGUI_LBC_COUNT ) if ( index >= Items.size() || colorType < 0 || colorType >= EGUI_LBC_COUNT )
return; return;
Items[index].OverrideColors[colorType].Use = true; Items[index].OverrideColors[colorType].Use = true;
Items[index].OverrideColors[colorType].Color = color; Items[index].OverrideColors[colorType].Color = color;
} }
void CGUISTKListBox::clearItemOverrideColor(u32 index) void CGUISTKListBox::clearItemOverrideColor(u32 index)
{ {
for (u32 c=0; c < (u32)EGUI_LBC_COUNT; ++c ) for (u32 c=0; c < (u32)EGUI_LBC_COUNT; ++c )
{ {
Items[index].OverrideColors[c].Use = false; Items[index].OverrideColors[c].Use = false;
} }
} }
void CGUISTKListBox::clearItemOverrideColor(u32 index, EGUI_LISTBOX_COLOR colorType) void CGUISTKListBox::clearItemOverrideColor(u32 index, EGUI_LISTBOX_COLOR colorType)
{ {
if ( index >= Items.size() || colorType < 0 || colorType >= EGUI_LBC_COUNT ) if ( index >= Items.size() || colorType < 0 || colorType >= EGUI_LBC_COUNT )
return; return;
Items[index].OverrideColors[colorType].Use = false; Items[index].OverrideColors[colorType].Use = false;
} }
bool CGUISTKListBox::hasItemOverrideColor(u32 index, EGUI_LISTBOX_COLOR colorType) const bool CGUISTKListBox::hasItemOverrideColor(u32 index, EGUI_LISTBOX_COLOR colorType) const
{ {
if ( index >= Items.size() || colorType < 0 || colorType >= EGUI_LBC_COUNT ) if ( index >= Items.size() || colorType < 0 || colorType >= EGUI_LBC_COUNT )
return false; return false;
return Items[index].OverrideColors[colorType].Use; return Items[index].OverrideColors[colorType].Use;
} }
video::SColor CGUISTKListBox::getItemOverrideColor(u32 index, EGUI_LISTBOX_COLOR colorType) const video::SColor CGUISTKListBox::getItemOverrideColor(u32 index, EGUI_LISTBOX_COLOR colorType) const
{ {
if ( (u32)index >= Items.size() || colorType < 0 || colorType >= EGUI_LBC_COUNT ) if ( (u32)index >= Items.size() || colorType < 0 || colorType >= EGUI_LBC_COUNT )
return video::SColor(); return video::SColor();
return Items[index].OverrideColors[colorType].Color; return Items[index].OverrideColors[colorType].Color;
} }
video::SColor CGUISTKListBox::getItemDefaultColor(EGUI_LISTBOX_COLOR colorType) const video::SColor CGUISTKListBox::getItemDefaultColor(EGUI_LISTBOX_COLOR colorType) const
{ {
IGUISkin* skin = Environment->getSkin(); IGUISkin* skin = Environment->getSkin();
if ( !skin ) if ( !skin )
return video::SColor(); return video::SColor();
switch ( colorType ) switch ( colorType )
{ {
case EGUI_LBC_TEXT: case EGUI_LBC_TEXT:
return skin->getColor(EGDC_BUTTON_TEXT); return skin->getColor(EGDC_BUTTON_TEXT);
case EGUI_LBC_TEXT_HIGHLIGHT: case EGUI_LBC_TEXT_HIGHLIGHT:
return skin->getColor(EGDC_HIGH_LIGHT_TEXT); return skin->getColor(EGDC_HIGH_LIGHT_TEXT);
case EGUI_LBC_ICON: case EGUI_LBC_ICON:
return skin->getColor(EGDC_ICON); return skin->getColor(EGDC_ICON);
case EGUI_LBC_ICON_HIGHLIGHT: case EGUI_LBC_ICON_HIGHLIGHT:
return skin->getColor(EGDC_ICON_HIGH_LIGHT); return skin->getColor(EGDC_ICON_HIGH_LIGHT);
default: default:
return video::SColor(); return video::SColor();
} }
} }
//! set global itemHeight //! set global itemHeight
void CGUISTKListBox::setItemHeight( s32 height ) void CGUISTKListBox::setItemHeight( s32 height )
{ {
ItemHeight = height; ItemHeight = height;
ItemHeightOverride = 1; ItemHeightOverride = 1;
} }

14
src/guiengine/widgets/CGUISTKListBox.h
View File

@ -17,12 +17,12 @@ namespace irr
{ {
namespace gui namespace gui
{ {
class IGUIFont; class IGUIFont;
class IGUIScrollBar; class IGUIScrollBar;
class CGUISTKListBox : public IGUIElement class CGUISTKListBox : public IGUIElement
{ {
public: public:
struct ListItem struct ListItem
{ {
@ -163,7 +163,7 @@ namespace irr
//! Sets whether to draw the background //! Sets whether to draw the background
virtual void setDrawBackground(bool draw); virtual void setDrawBackground(bool draw);
private: private:
void recalculateItemHeight(); void recalculateItemHeight();
void selectNew(s32 ypos, bool onlyHover=false); void selectNew(s32 ypos, bool onlyHover=false);
@ -189,7 +189,7 @@ namespace irr
bool MoveOverSelect; bool MoveOverSelect;
bool AutoScroll; bool AutoScroll;
bool HighlightWhenNotFocused; bool HighlightWhenNotFocused;
}; };
} // end namespace gui } // end namespace gui

10
src/guiengine/widgets/spinner_widget.cpp
View File

@ -62,17 +62,17 @@ void SpinnerWidget::add()
if (min_s.size() > 0) if (min_s.size() > 0)
{ {
if (!StringUtils::parseString<int>(min_s, &m_min)) if (!StringUtils::parseString<int>(min_s, &m_min))
{ {
Log::warn("invalid value for spinner widget minimum value : %s", min_s.c_str()); Log::warn("invalid value for spinner widget minimum value : %s", min_s.c_str());
} }
} }
if (max_s.size() > 0) if (max_s.size() > 0)
{ {
if (!StringUtils::parseString<int>(max_s, &m_max)) if (!StringUtils::parseString<int>(max_s, &m_max))
{ {
Log::warn("invalid value for spinner widget maximum value : %s", max_s.c_str()); Log::warn("invalid value for spinner widget maximum value : %s", max_s.c_str());
} }
} }

2
src/guiengine/widgets/spinner_widget.hpp
View File

@ -109,7 +109,7 @@ namespace GUIEngine
void addLabel(irr::core::stringw label); void addLabel(irr::core::stringw label);
void clearLabels(); void clearLabels();
// next four functions are for background colour behind playername in multikart screen selection // next four functions are for background colour behind playername in multikart screen selection
void setUseBackgroundColor() {m_use_background_color=true; } void setUseBackgroundColor() {m_use_background_color=true; }
bool getUseBackgroundColor() {return m_use_background_color; } bool getUseBackgroundColor() {return m_use_background_color; }
void setSpinnerWidgetPlayerID(int playerID) {m_spinner_widget_player_id=playerID;} void setSpinnerWidgetPlayerID(int playerID) {m_spinner_widget_player_id=playerID;}

12
src/input/input_manager.cpp
View File

@ -481,13 +481,13 @@ void InputManager::dispatchInput(Input::InputType type, int deviceID,
m_mode == INPUT_SENSE_GAMEPAD) m_mode == INPUT_SENSE_GAMEPAD)
{ {
// Do not pick disabled gamepads for input sensing // Do not pick disabled gamepads for input sensing
if (type == Input::IT_STICKBUTTON || type == Input::IT_STICKMOTION) if (type == Input::IT_STICKBUTTON || type == Input::IT_STICKMOTION)
{ {
GamePadDevice *gPad = m_device_manager->getGamePadFromIrrID(deviceID); GamePadDevice *gPad = m_device_manager->getGamePadFromIrrID(deviceID);
DeviceConfig *conf = gPad->getConfiguration(); DeviceConfig *conf = gPad->getConfiguration();
if (!conf->isEnabled()) if (!conf->isEnabled())
return; return;
} }
inputSensing(type, deviceID, button, axisDirection, value); inputSensing(type, deviceID, button, axisDirection, value);
return; return;

2
src/karts/kart.cpp
View File

@ -2595,7 +2595,7 @@ void Kart::setOnScreenText(const wchar_t *text)
// FIXME: Titlefont is the only font guaranteed to be loaded if STK // FIXME: Titlefont is the only font guaranteed to be loaded if STK
// is started without splash screen (since "Loading" is shown even in this // is started without splash screen (since "Loading" is shown even in this
// case). A smaller font would be better // case). A smaller font would be better
// TODO: Add support in the engine for BillboardText or find a replacement // TODO: Add support in the engine for BillboardText or find a replacement
/*scene::ISceneManager* sm = irr_driver->getSceneManager(); /*scene::ISceneManager* sm = irr_driver->getSceneManager();
sm->addBillboardTextSceneNode(GUIEngine::getFont() ? GUIEngine::getFont() sm->addBillboardTextSceneNode(GUIEngine::getFont() ? GUIEngine::getFont()
: GUIEngine::getTitleFont(), : GUIEngine::getTitleFont(),

2
src/modes/world.cpp
View File

@ -483,7 +483,7 @@ void World::terminateRace()
mode_name, 1); mode_name, 1);
} }
} }
} // for i < kart_amount } // for i < kart_amount
} // if (achiev) } // if (achiev)
Achievement *win = PlayerManager::getCurrentAchievementsStatus()->getAchievement(AchievementInfo::ACHIEVE_UNSTOPPABLE); Achievement *win = PlayerManager::getCurrentAchievementsStatus()->getAchievement(AchievementInfo::ACHIEVE_UNSTOPPABLE);

28
src/network/stk_host.cpp
View File

@ -121,10 +121,10 @@ void STKHost::setupServer(uint32_t address, uint16_t port, int peer_count,
addr->port = port; addr->port = port;
#ifdef WIN32/* #ifdef WIN32/*
addr->host = 0; addr->host = 0;
addr->host += ((unsigned int)(192)<<0); // 192.168.0.11 addr->host += ((unsigned int)(192)<<0); // 192.168.0.11
addr->host += ((unsigned int)(168)<<8); // 192.168.0.11 addr->host += ((unsigned int)(168)<<8); // 192.168.0.11
addr->host += ((unsigned int)(11)<<24); // 192.168.0.11*/ addr->host += ((unsigned int)(11)<<24); // 192.168.0.11*/
#endif #endif
m_host = enet_host_create(addr, peer_count, channel_limit, m_host = enet_host_create(addr, peer_count, channel_limit,
@ -235,10 +235,10 @@ uint8_t* STKHost::receiveRawPacket(TransportAddress* sender)
len = recvfrom(m_host->socket, (char*)buffer, 2048, 0, (struct sockaddr*)(&addr), &from_len); len = recvfrom(m_host->socket, (char*)buffer, 2048, 0, (struct sockaddr*)(&addr), &from_len);
StkTime::sleep(1); // wait 1 millisecond between two checks StkTime::sleep(1); // wait 1 millisecond between two checks
} }
if (len == SOCKET_ERROR) if (len == SOCKET_ERROR)
{ {
Log::error("STKHost", "Problem with the socket. Please contact the dev team."); Log::error("STKHost", "Problem with the socket. Please contact the dev team.");
} }
// we received the data // we received the data
sender->ip = ntohl((uint32_t)(addr.sin_addr.s_addr)); sender->ip = ntohl((uint32_t)(addr.sin_addr.s_addr));
sender->port = ntohs(addr.sin_port); sender->port = ntohs(addr.sin_port);
@ -272,8 +272,8 @@ uint8_t* STKHost::receiveRawPacket(TransportAddress sender, int max_tries)
while(len < 0 || addr.sin_addr.s_addr == sender.ip) while(len < 0 || addr.sin_addr.s_addr == sender.ip)
{ {
i++; i++;
if (len>=0) if (len>=0)
{ {
Log::info("STKHost", "Message received but the ip address didn't match the expected one."); Log::info("STKHost", "Message received but the ip address didn't match the expected one.");
} }
len = recvfrom(m_host->socket, (char*)buffer, 2048, 0, (struct sockaddr*)(&addr), &from_len); len = recvfrom(m_host->socket, (char*)buffer, 2048, 0, (struct sockaddr*)(&addr), &from_len);
@ -281,10 +281,10 @@ uint8_t* STKHost::receiveRawPacket(TransportAddress sender, int max_tries)
if (i >= max_tries && max_tries != -1) if (i >= max_tries && max_tries != -1)
{ {
Log::verbose("STKHost", "No answer from the server on %u.%u.%u.%u:%u", (m_host->address.host&0xff), Log::verbose("STKHost", "No answer from the server on %u.%u.%u.%u:%u", (m_host->address.host&0xff),
(m_host->address.host>>8&0xff), (m_host->address.host>>8&0xff),
(m_host->address.host>>16&0xff), (m_host->address.host>>16&0xff),
(m_host->address.host>>24&0xff), (m_host->address.host>>24&0xff),
(m_host->address.port)); (m_host->address.port));
return NULL; return NULL;
} }
} }

4
src/tracks/track.cpp
View File

@ -969,7 +969,7 @@ bool Track::loadMainTrack(const XMLNode &root)
assert(GUIEngine::getHighresDigitFont() != NULL); assert(GUIEngine::getHighresDigitFont() != NULL);
// TODO: Add support in the engine for BillboardText or find a replacement // TODO: Add support in the engine for BillboardText or find a replacement
/* scene::ISceneManager* sm = irr_driver->getSceneManager(); /* scene::ISceneManager* sm = irr_driver->getSceneManager();
scene::ISceneNode* sn = scene::ISceneNode* sn =
sm->addBillboardTextSceneNode(GUIEngine::getHighresDigitFont(), sm->addBillboardTextSceneNode(GUIEngine::getHighresDigitFont(),
@ -1581,7 +1581,7 @@ void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
// Sky dome and boxes support // Sky dome and boxes support
// -------------------------- // --------------------------
irr_driver->suppressSkyBox(); irr_driver->suppressSkyBox();
if(m_sky_type==SKY_DOME && m_sky_textures.size() > 0) if(m_sky_type==SKY_DOME && m_sky_textures.size() > 0)
{ {
scene::ISceneNode *node = irr_driver->addSkyDome(m_sky_textures[0], scene::ISceneNode *node = irr_driver->addSkyDome(m_sky_textures[0],

12
src/tracks/track_object_presentation.cpp
View File

@ -188,9 +188,9 @@ TrackObjectPresentationMesh::TrackObjectPresentationMesh(const XMLNode& xml_node
bool animated = skeletal_animation && (UserConfigParams::m_graphical_effects || bool animated = skeletal_animation && (UserConfigParams::m_graphical_effects ||
World::getWorld()->getIdent() == IDENT_CUTSCENE); World::getWorld()->getIdent() == IDENT_CUTSCENE);
bool displacing = false; bool displacing = false;
xml_node.get("displacing", &displacing); xml_node.get("displacing", &displacing);
animated &= !displacing; animated &= !displacing;
if (animated) if (animated)
{ {
@ -256,10 +256,10 @@ void TrackObjectPresentationMesh::init(const XMLNode* xml_node, scene::ISceneNod
bool animated = skeletal_animation && (UserConfigParams::m_graphical_effects || bool animated = skeletal_animation && (UserConfigParams::m_graphical_effects ||
World::getWorld()->getIdent() == IDENT_CUTSCENE); World::getWorld()->getIdent() == IDENT_CUTSCENE);
bool displacing = false; bool displacing = false;
if(xml_node) if(xml_node)
xml_node->get("displacing", &displacing); xml_node->get("displacing", &displacing);
animated &= !displacing; animated &= !displacing;
m_mesh->grab(); m_mesh->grab();
irr_driver->grabAllTextures(m_mesh); irr_driver->grabAllTextures(m_mesh);

56
src/utils/debug.cpp
View File

@ -96,31 +96,31 @@ void addPowerup(PowerupManager::PowerupType powerup)
void addAttachment(Attachment::AttachmentType type) void addAttachment(Attachment::AttachmentType type)
{ {
World* world = World::getWorld(); World* world = World::getWorld();
if (world == NULL) return; if (world == NULL) return;
for(unsigned int i = 0; i < world->getNumKarts(); i++) for(unsigned int i = 0; i < world->getNumKarts(); i++)
{ {
AbstractKart *kart = world->getKart(i); AbstractKart *kart = world->getKart(i);
if (kart->getController()->isPlayerController()) { if (kart->getController()->isPlayerController()) {
if (type == Attachment::ATTACH_ANVIL) if (type == Attachment::ATTACH_ANVIL)
{ {
kart->getAttachment() kart->getAttachment()
->set(type, stk_config->m_anvil_time); ->set(type, stk_config->m_anvil_time);
kart->adjustSpeed(stk_config->m_anvil_speed_factor); kart->adjustSpeed(stk_config->m_anvil_speed_factor);
kart->updateWeight(); kart->updateWeight();
} }
else if (type == Attachment::ATTACH_PARACHUTE) else if (type == Attachment::ATTACH_PARACHUTE)
{ {
kart->getAttachment() kart->getAttachment()
->set(type, stk_config->m_parachute_time); ->set(type, stk_config->m_parachute_time);
} }
else if (type == Attachment::ATTACH_BOMB) else if (type == Attachment::ATTACH_BOMB)
{ {
kart->getAttachment() kart->getAttachment()
->set(type, stk_config->m_bomb_time); ->set(type, stk_config->m_bomb_time);
} }
} }
} }
} }
@ -369,15 +369,15 @@ bool onEvent(const SEvent &event)
} }
else if (cmdID == DEBUG_ATTACHMENT_ANVIL) else if (cmdID == DEBUG_ATTACHMENT_ANVIL)
{ {
addAttachment(Attachment::ATTACH_ANVIL); addAttachment(Attachment::ATTACH_ANVIL);
} }
else if (cmdID == DEBUG_ATTACHMENT_BOMB) else if (cmdID == DEBUG_ATTACHMENT_BOMB)
{ {
addAttachment(Attachment::ATTACH_BOMB); addAttachment(Attachment::ATTACH_BOMB);
} }
else if (cmdID == DEBUG_ATTACHMENT_PARACHUTE) else if (cmdID == DEBUG_ATTACHMENT_PARACHUTE)
{ {
addAttachment(Attachment::ATTACH_PARACHUTE); addAttachment(Attachment::ATTACH_PARACHUTE);
} }
else if (cmdID == DEBUG_TOGGLE_GUI) else if (cmdID == DEBUG_TOGGLE_GUI)
{ {

142
src/utils/helpers.cpp
View File

@ -76,99 +76,99 @@ THE SOFTWARE.
*/ */
static inline float mod289(float x) { static inline float mod289(float x) {
// return x - floorf(x * (1.0 / 289.0)) * 289.0; // return x - floorf(x * (1.0 / 289.0)) * 289.0;
return fmodf(x, 289); return fmodf(x, 289);
} }
static inline float permute(float x) { static inline float permute(float x) {
return mod289(((x*34.0f)+1.0f)*x); return mod289(((x*34.0f)+1.0f)*x);
} }
// Vectorized 2d simplex noise. // Vectorized 2d simplex noise.
float noise2d(float v1, float v2) { float noise2d(float v1, float v2) {
const float C[] = { const float C[] = {
0.211324865405187f, 0.211324865405187f,
0.366025403784439f, 0.366025403784439f,
-0.577350269189626f, -0.577350269189626f,
0.024390243902439f }; 0.024390243902439f };
// First corner // First corner
float i[2]; float i[2];
i[0] = floorf(v1 + v1*C[1] + v2*C[1]); i[0] = floorf(v1 + v1*C[1] + v2*C[1]);
i[1] = floorf(v2 + v1*C[1] + v2*C[1]); i[1] = floorf(v2 + v1*C[1] + v2*C[1]);
float x0[2]; float x0[2];
x0[0] = v1 - i[0] + i[0]*C[0] + i[1]*C[0]; x0[0] = v1 - i[0] + i[0]*C[0] + i[1]*C[0];
x0[1] = v2 - i[1] + i[0]*C[0] + i[1]*C[0]; x0[1] = v2 - i[1] + i[0]*C[0] + i[1]*C[0];
// Other corners // Other corners
float i1[2]; float i1[2];
if (x0[0] > x0[1]) { if (x0[0] > x0[1]) {
i1[0] = 1; i1[0] = 1;
i1[1] = 0; i1[1] = 0;
} else { } else {
i1[0] = 0; i1[0] = 0;
i1[1] = 1; i1[1] = 1;
} }
float x12[4]; float x12[4];
x12[0] = x0[0] + C[0] - i1[0]; x12[0] = x0[0] + C[0] - i1[0];
x12[1] = x0[1] + C[0] - i1[1]; x12[1] = x0[1] + C[0] - i1[1];
x12[2] = x0[0] + C[2]; x12[2] = x0[0] + C[2];
x12[3] = x0[1] + C[2]; x12[3] = x0[1] + C[2];
// Permutations // Permutations
i[0] = mod289(i[0]); i[0] = mod289(i[0]);
i[1] = mod289(i[1]); i[1] = mod289(i[1]);
float p[3]; float p[3];
p[0] = permute(permute(i[1]) + i[0]); p[0] = permute(permute(i[1]) + i[0]);
p[1] = permute(permute(i[1] + i1[1]) + i[0] + i1[0]); p[1] = permute(permute(i[1] + i1[1]) + i[0] + i1[0]);
p[2] = permute(permute(i[1] + 1) + i[0] + 1); p[2] = permute(permute(i[1] + 1) + i[0] + 1);
float m[3]; float m[3];
m[0] = std::max<float>(0.5f - x0[0]*x0[0] - x0[1]*x0[1], 0); m[0] = std::max<float>(0.5f - x0[0]*x0[0] - x0[1]*x0[1], 0);
m[1] = std::max<float>(0.5f - x12[0]*x12[0] - x12[1]*x12[1], 0); m[1] = std::max<float>(0.5f - x12[0]*x12[0] - x12[1]*x12[1], 0);
m[2] = std::max<float>(0.5f - x12[2]*x12[2] - x12[3]*x12[3], 0); m[2] = std::max<float>(0.5f - x12[2]*x12[2] - x12[3]*x12[3], 0);
m[0] = m[0] * m[0] * m[0] * m[0]; m[0] = m[0] * m[0] * m[0] * m[0];
m[1] = m[1] * m[1] * m[1] * m[1]; m[1] = m[1] * m[1] * m[1] * m[1];
m[2] = m[2] * m[2] * m[2] * m[2]; m[2] = m[2] * m[2] * m[2] * m[2];
// Gradients // Gradients
float tmp; float tmp;
float x[3]; float x[3];
x[0] = 2 * modff(p[0] * C[3], &tmp) - 1; x[0] = 2 * modff(p[0] * C[3], &tmp) - 1;
x[1] = 2 * modff(p[1] * C[3], &tmp) - 1; x[1] = 2 * modff(p[1] * C[3], &tmp) - 1;
x[2] = 2 * modff(p[2] * C[3], &tmp) - 1; x[2] = 2 * modff(p[2] * C[3], &tmp) - 1;
float h[3]; float h[3];
h[0] = fabsf(x[0]) - 0.5f; h[0] = fabsf(x[0]) - 0.5f;
h[1] = fabsf(x[1]) - 0.5f; h[1] = fabsf(x[1]) - 0.5f;
h[2] = fabsf(x[2]) - 0.5f; h[2] = fabsf(x[2]) - 0.5f;
float ox[3]; float ox[3];
ox[0] = floorf(x[0] + 0.5f); ox[0] = floorf(x[0] + 0.5f);
ox[1] = floorf(x[1] + 0.5f); ox[1] = floorf(x[1] + 0.5f);
ox[2] = floorf(x[2] + 0.5f); ox[2] = floorf(x[2] + 0.5f);
float a0[3]; float a0[3];
a0[0] = x[0] - ox[0]; a0[0] = x[0] - ox[0];
a0[1] = x[1] - ox[1]; a0[1] = x[1] - ox[1];
a0[2] = x[2] - ox[2]; a0[2] = x[2] - ox[2];
// Normalize // Normalize
m[0] *= 1.79284291400159f - 0.85373472095314f * (a0[0]*a0[0] + h[0]*h[0]); m[0] *= 1.79284291400159f - 0.85373472095314f * (a0[0]*a0[0] + h[0]*h[0]);
m[1] *= 1.79284291400159f - 0.85373472095314f * (a0[1]*a0[1] + h[1]*h[1]); m[1] *= 1.79284291400159f - 0.85373472095314f * (a0[1]*a0[1] + h[1]*h[1]);
m[2] *= 1.79284291400159f - 0.85373472095314f * (a0[2]*a0[2] + h[2]*h[2]); m[2] *= 1.79284291400159f - 0.85373472095314f * (a0[2]*a0[2] + h[2]*h[2]);
// Compute final value // Compute final value
float g[3]; float g[3];
g[0] = a0[0] * x0[0] + h[0] * x0[1]; g[0] = a0[0] * x0[0] + h[0] * x0[1];
g[1] = a0[1] * x12[0] + h[1] * x12[1]; g[1] = a0[1] * x12[0] + h[1] * x12[1];
g[2] = a0[2] * x12[2] + h[2] * x12[3]; g[2] = a0[2] * x12[2] + h[2] * x12[3];
return 130 * (m[0] * g[0] + m[1] * g[1] + m[2] * g[2]); return 130 * (m[0] * g[0] + m[1] * g[1] + m[2] * g[2]);
} }

2
src/utils/utf8/core.h
View File

@ -341,7 +341,7 @@ namespace internal
); );
} }
//Deprecated in release 2.3 //Deprecated in release 2.3
template <typename octet_iterator> template <typename octet_iterator>
inline bool is_bom (octet_iterator it) inline bool is_bom (octet_iterator it)
{ {