Implement instanced groundcover
Andrei Kortunov
5 years ago
parent
f917037ead
commit
14cf0ce1dc
@ -0,0 +1,264 @@
|
||||
#include "groundcover.hpp"
|
||||
|
||||
#include <osg/Geometry>
|
||||
#include <osg/VertexAttribDivisor>
|
||||
|
||||
#include <components/esm/esmreader.hpp>
|
||||
|
||||
#include "apps/openmw/mwworld/esmstore.hpp"
|
||||
#include "apps/openmw/mwbase/environment.hpp"
|
||||
#include "apps/openmw/mwbase/world.hpp"
|
||||
|
||||
#include "vismask.hpp"
|
||||
|
||||
namespace MWRender
|
||||
{
|
||||
void GroundcoverUpdater::setWindSpeed(float windSpeed)
|
||||
{
|
||||
mWindSpeed = windSpeed;
|
||||
}
|
||||
|
||||
void GroundcoverUpdater::setPlayerPos(osg::Vec3f playerPos)
|
||||
{
|
||||
mPlayerPos = playerPos;
|
||||
}
|
||||
|
||||
void GroundcoverUpdater::setDefaults(osg::StateSet *stateset)
|
||||
{
|
||||
osg::ref_ptr<osg::Uniform> windUniform = new osg::Uniform("windSpeed", 0.0f);
|
||||
stateset->addUniform(windUniform.get());
|
||||
|
||||
osg::ref_ptr<osg::Uniform> playerPosUniform = new osg::Uniform("playerPos", osg::Vec3f(0.f, 0.f, 0.f));
|
||||
stateset->addUniform(playerPosUniform.get());
|
||||
}
|
||||
|
||||
void GroundcoverUpdater::apply(osg::StateSet *stateset, osg::NodeVisitor *nv)
|
||||
{
|
||||
osg::ref_ptr<osg::Uniform> windUniform = stateset->getUniform("windSpeed");
|
||||
if (windUniform != nullptr)
|
||||
windUniform->set(mWindSpeed);
|
||||
|
||||
osg::ref_ptr<osg::Uniform> playerPosUniform = stateset->getUniform("playerPos");
|
||||
if (playerPosUniform != nullptr)
|
||||
playerPosUniform->set(mPlayerPos);
|
||||
}
|
||||
|
||||
class InstancingVisitor : public osg::NodeVisitor
|
||||
{
|
||||
public:
|
||||
InstancingVisitor(std::vector<Groundcover::GroundcoverEntry>& instances, osg::Vec3f& chunkPosition)
|
||||
: osg::NodeVisitor(TRAVERSE_ALL_CHILDREN)
|
||||
, mInstances(instances)
|
||||
, mChunkPosition(chunkPosition)
|
||||
{
|
||||
}
|
||||
|
||||
void apply(osg::Node& node) override
|
||||
{
|
||||
osg::ref_ptr<osg::StateSet> ss = node.getStateSet();
|
||||
if (ss != nullptr)
|
||||
{
|
||||
removeAlpha(ss);
|
||||
}
|
||||
|
||||
traverse(node);
|
||||
}
|
||||
|
||||
void apply(osg::Geometry& geom) override
|
||||
{
|
||||
for (unsigned int i = 0; i < geom.getNumPrimitiveSets(); ++i)
|
||||
{
|
||||
geom.getPrimitiveSet(i)->setNumInstances(mInstances.size());
|
||||
}
|
||||
|
||||
osg::ref_ptr<osg::Vec4Array> transforms = new osg::Vec4Array(mInstances.size());
|
||||
osg::BoundingBox box;
|
||||
float radius = geom.getBoundingBox().radius();
|
||||
for (unsigned int i = 0; i < transforms->getNumElements(); i++)
|
||||
{
|
||||
osg::Vec3f pos(mInstances[i].mPos.asVec3());
|
||||
osg::Vec3f relativePos = pos - mChunkPosition;
|
||||
(*transforms)[i] = osg::Vec4f(relativePos, mInstances[i].mScale);
|
||||
|
||||
// Use an additional margin due to groundcover animation
|
||||
float instanceRadius = radius * mInstances[i].mScale * 1.1f;
|
||||
osg::BoundingSphere instanceBounds(relativePos, instanceRadius);
|
||||
box.expandBy(instanceBounds);
|
||||
}
|
||||
|
||||
geom.setInitialBound(box);
|
||||
|
||||
osg::ref_ptr<osg::Vec3Array> rotations = new osg::Vec3Array(mInstances.size());
|
||||
for (unsigned int i = 0; i < rotations->getNumElements(); i++)
|
||||
{
|
||||
(*rotations)[i] = mInstances[i].mPos.asRotationVec3();
|
||||
}
|
||||
|
||||
geom.setVertexAttribArray(6, transforms.get(), osg::Array::BIND_PER_VERTEX);
|
||||
geom.setVertexAttribArray(7, rotations.get(), osg::Array::BIND_PER_VERTEX);
|
||||
|
||||
osg::ref_ptr<osg::StateSet> ss = geom.getOrCreateStateSet();
|
||||
ss->setAttribute(new osg::VertexAttribDivisor(6, 1));
|
||||
ss->setAttribute(new osg::VertexAttribDivisor(7, 1));
|
||||
|
||||
removeAlpha(ss);
|
||||
|
||||
traverse(geom);
|
||||
}
|
||||
private:
|
||||
std::vector<Groundcover::GroundcoverEntry> mInstances;
|
||||
osg::Vec3f mChunkPosition;
|
||||
|
||||
void removeAlpha(osg::StateSet* stateset)
|
||||
{
|
||||
// MGE uses default alpha settings for groundcover, so we can not rely on alpha properties
|
||||
stateset->removeAttribute(osg::StateAttribute::ALPHAFUNC);
|
||||
stateset->removeMode(GL_ALPHA_TEST);
|
||||
stateset->removeAttribute(osg::StateAttribute::BLENDFUNC);
|
||||
stateset->removeMode(GL_BLEND);
|
||||
stateset->setRenderBinToInherit();
|
||||
}
|
||||
};
|
||||
|
||||
class DensityCalculator
|
||||
{
|
||||
public:
|
||||
DensityCalculator(float density)
|
||||
: mDensity(density)
|
||||
{
|
||||
}
|
||||
|
||||
bool isInstanceEnabled()
|
||||
{
|
||||
if (mDensity >= 1.f) return true;
|
||||
|
||||
mCurrentGroundcover += mDensity;
|
||||
if (mCurrentGroundcover < 1.f) return false;
|
||||
|
||||
mCurrentGroundcover -= 1.f;
|
||||
|
||||
return true;
|
||||
}
|
||||
void reset() { mCurrentGroundcover = 0.f; }
|
||||
|
||||
private:
|
||||
float mCurrentGroundcover = 0.f;
|
||||
float mDensity = 0.f;
|
||||
};
|
||||
|
||||
inline bool isInChunkBorders(ESM::CellRef& ref, osg::Vec2f& minBound, osg::Vec2f& maxBound)
|
||||
{
|
||||
osg::Vec2f size = maxBound - minBound;
|
||||
if (size.x() >=1 && size.y() >=1) return true;
|
||||
|
||||
osg::Vec3f pos = ref.mPos.asVec3();
|
||||
osg::Vec3f cellPos = pos / ESM::Land::REAL_SIZE;
|
||||
if ((minBound.x() > std::floor(minBound.x()) && cellPos.x() < minBound.x()) || (minBound.y() > std::floor(minBound.y()) && cellPos.y() < minBound.y())
|
||||
|| (maxBound.x() < std::ceil(maxBound.x()) && cellPos.x() >= maxBound.x()) || (minBound.y() < std::ceil(maxBound.y()) && cellPos.y() >= maxBound.y()))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
osg::ref_ptr<osg::Node> Groundcover::getChunk(float size, const osg::Vec2f& center, unsigned char lod, unsigned int lodFlags, bool activeGrid, const osg::Vec3f& viewPoint, bool compile)
|
||||
{
|
||||
ChunkId id = std::make_tuple(center, size, activeGrid);
|
||||
|
||||
osg::ref_ptr<osg::Object> obj = mCache->getRefFromObjectCache(id);
|
||||
if (obj)
|
||||
return obj->asNode();
|
||||
else
|
||||
{
|
||||
InstanceMap instances;
|
||||
collectInstances(instances, size, center);
|
||||
osg::ref_ptr<osg::Node> node = createChunk(instances, center);
|
||||
mCache->addEntryToObjectCache(id, node.get());
|
||||
return node;
|
||||
}
|
||||
}
|
||||
|
||||
Groundcover::Groundcover(Resource::SceneManager* sceneManager, float density)
|
||||
: GenericResourceManager<ChunkId>(nullptr)
|
||||
, mSceneManager(sceneManager)
|
||||
, mDensity(density)
|
||||
{
|
||||
}
|
||||
|
||||
void Groundcover::collectInstances(InstanceMap& instances, float size, const osg::Vec2f& center)
|
||||
{
|
||||
const MWWorld::ESMStore& store = MWBase::Environment::get().getWorld()->getStore();
|
||||
osg::Vec2f minBound = (center - osg::Vec2f(size/2.f, size/2.f));
|
||||
osg::Vec2f maxBound = (center + osg::Vec2f(size/2.f, size/2.f));
|
||||
DensityCalculator calculator(mDensity);
|
||||
std::vector<ESM::ESMReader> esm;
|
||||
osg::Vec2i startCell = osg::Vec2i(std::floor(center.x() - size/2.f), std::floor(center.y() - size/2.f));
|
||||
for (int cellX = startCell.x(); cellX < startCell.x() + size; ++cellX)
|
||||
{
|
||||
for (int cellY = startCell.y(); cellY < startCell.y() + size; ++cellY)
|
||||
{
|
||||
const ESM::Cell* cell = store.get<ESM::Cell>().searchStatic(cellX, cellY);
|
||||
if (!cell) continue;
|
||||
|
||||
calculator.reset();
|
||||
for (size_t i=0; i<cell->mContextList.size(); ++i)
|
||||
{
|
||||
unsigned int index = cell->mContextList.at(i).index;
|
||||
if (esm.size() <= index)
|
||||
esm.resize(index+1);
|
||||
cell->restore(esm[index], i);
|
||||
ESM::CellRef ref;
|
||||
ref.mRefNum.mContentFile = ESM::RefNum::RefNum_NoContentFile;
|
||||
bool deleted = false;
|
||||
while(cell->getNextRef(esm[index], ref, deleted))
|
||||
{
|
||||
if (deleted) continue;
|
||||
Misc::StringUtils::lowerCaseInPlace(ref.mRefID);
|
||||
std::string model;
|
||||
if (!store.isGroundcover(ref.mRefID, model)) continue;
|
||||
if (model.empty()) continue;
|
||||
|
||||
if (!calculator.isInstanceEnabled()) continue;
|
||||
if (!isInChunkBorders(ref, minBound, maxBound)) continue;
|
||||
|
||||
model = "meshes/" + model;
|
||||
instances[model].emplace_back(ref, model);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
osg::ref_ptr<osg::Node> Groundcover::createChunk(InstanceMap& instances, const osg::Vec2f& center)
|
||||
{
|
||||
osg::ref_ptr<osg::Group> group = new osg::Group;
|
||||
osg::Vec3f worldCenter = osg::Vec3f(center.x(), center.y(), 0)*ESM::Land::REAL_SIZE;
|
||||
for (auto& pair : instances)
|
||||
{
|
||||
const osg::Node* temp = mSceneManager->getTemplate(pair.first);
|
||||
osg::ref_ptr<osg::Node> node = static_cast<osg::Node*>(temp->clone(osg::CopyOp::DEEP_COPY_ALL&(~osg::CopyOp::DEEP_COPY_TEXTURES)));
|
||||
|
||||
// Keep link to original mesh to keep it in cache
|
||||
group->getOrCreateUserDataContainer()->addUserObject(new Resource::TemplateRef(temp));
|
||||
|
||||
InstancingVisitor visitor(pair.second, worldCenter);
|
||||
node->accept(visitor);
|
||||
group->addChild(node);
|
||||
}
|
||||
|
||||
group->getBound();
|
||||
group->setNodeMask(Mask_Groundcover);
|
||||
mSceneManager->recreateShaders(group, "groundcover", false, true);
|
||||
|
||||
return group;
|
||||
}
|
||||
|
||||
unsigned int Groundcover::getNodeMask()
|
||||
{
|
||||
return Mask_Groundcover;
|
||||
}
|
||||
|
||||
void Groundcover::reportStats(unsigned int frameNumber, osg::Stats *stats) const
|
||||
{
|
||||
stats->setAttribute(frameNumber, "Groundcover Chunk", mCache->getCacheSize());
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,69 @@
|
||||
#ifndef OPENMW_MWRENDER_GROUNDCOVER_H
|
||||
#define OPENMW_MWRENDER_GROUNDCOVER_H
|
||||
|
||||
#include <components/terrain/quadtreeworld.hpp>
|
||||
#include <components/resource/scenemanager.hpp>
|
||||
#include <components/sceneutil/statesetupdater.hpp>
|
||||
#include <components/esm/loadcell.hpp>
|
||||
|
||||
namespace MWRender
|
||||
{
|
||||
class GroundcoverUpdater : public SceneUtil::StateSetUpdater
|
||||
{
|
||||
public:
|
||||
GroundcoverUpdater()
|
||||
: mWindSpeed(0.f)
|
||||
, mPlayerPos(osg::Vec3f())
|
||||
{
|
||||
}
|
||||
|
||||
void setWindSpeed(float windSpeed);
|
||||
void setPlayerPos(osg::Vec3f playerPos);
|
||||
|
||||
protected:
|
||||
void setDefaults(osg::StateSet *stateset) override;
|
||||
void apply(osg::StateSet *stateset, osg::NodeVisitor *nv) override;
|
||||
|
||||
private:
|
||||
float mWindSpeed;
|
||||
osg::Vec3f mPlayerPos;
|
||||
};
|
||||
|
||||
typedef std::tuple<osg::Vec2f, float, bool> ChunkId; // Center, Size, ActiveGrid
|
||||
class Groundcover : public Resource::GenericResourceManager<ChunkId>, public Terrain::QuadTreeWorld::ChunkManager
|
||||
{
|
||||
public:
|
||||
Groundcover(Resource::SceneManager* sceneManager, float density);
|
||||
~Groundcover() = default;
|
||||
|
||||
osg::ref_ptr<osg::Node> getChunk(float size, const osg::Vec2f& center, unsigned char lod, unsigned int lodFlags, bool activeGrid, const osg::Vec3f& viewPoint, bool compile) override;
|
||||
|
||||
unsigned int getNodeMask() override;
|
||||
|
||||
void reportStats(unsigned int frameNumber, osg::Stats* stats) const override;
|
||||
|
||||
struct GroundcoverEntry
|
||||
{
|
||||
ESM::Position mPos;
|
||||
float mScale;
|
||||
std::string mModel;
|
||||
|
||||
GroundcoverEntry(const ESM::CellRef& ref, const std::string& model)
|
||||
{
|
||||
mPos = ref.mPos;
|
||||
mScale = ref.mScale;
|
||||
mModel = model;
|
||||
}
|
||||
};
|
||||
|
||||
private:
|
||||
Resource::SceneManager* mSceneManager;
|
||||
float mDensity;
|
||||
|
||||
typedef std::map<std::string, std::vector<GroundcoverEntry>> InstanceMap;
|
||||
osg::ref_ptr<osg::Node> createChunk(InstanceMap& instances, const osg::Vec2f& center);
|
||||
void collectInstances(InstanceMap& instances, float size, const osg::Vec2f& center);
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,68 @@
|
||||
Groundcover Settings
|
||||
####################
|
||||
|
||||
enabled
|
||||
-------
|
||||
|
||||
:Type: boolean
|
||||
:Range: True/False
|
||||
:Default: False
|
||||
|
||||
Allows the engine to use groundcover.
|
||||
Groundcover objects are static objects which come from ESP files, registered via
|
||||
"groundcover" entries from openmw.cfg rather than "content" ones.
|
||||
We assume that groundcover objects have no collisions, can not be moved or interacted with,
|
||||
so we can merge them to pages and animate them indifferently from distance from player.
|
||||
|
||||
This setting can only be configured by editing the settings configuration file.
|
||||
|
||||
fade start
|
||||
----------
|
||||
|
||||
:Type: floating point
|
||||
:Range: 0.0 to 1.0
|
||||
:Default: 0.85
|
||||
|
||||
Determines on which distance from player groundcover fading starts.
|
||||
Does not work for meshes which textures do not have transparency (e.g. rocks).
|
||||
|
||||
This setting can only be configured by editing the settings configuration file.
|
||||
|
||||
density
|
||||
-------
|
||||
|
||||
:Type: floating point
|
||||
:Range: 0.0 (0%) to 1.0 (100%)
|
||||
:Default: 1.0
|
||||
|
||||
Determines how many groundcover instances from content files
|
||||
are used in the game. Can affect performance a lot.
|
||||
|
||||
This setting can only be configured by editing the settings configuration file.
|
||||
|
||||
distance
|
||||
--------
|
||||
|
||||
:Type: integer
|
||||
:Range: > 0
|
||||
:Default: 1
|
||||
|
||||
Determines on which distance in cells grass pages are rendered.
|
||||
Default 1 value means 3x3 cells area (active grid).
|
||||
May affect performance a lot.
|
||||
|
||||
This setting can only be configured by editing the settings configuration file.
|
||||
|
||||
min chunk size
|
||||
--------------
|
||||
|
||||
:Type: floating point
|
||||
:Range: 0.125, 0.25, 0.5, 1.0
|
||||
:Default: 0.5
|
||||
|
||||
Determines a minimum size of groundcover chunks in cells. For example, with 0.5 value
|
||||
chunks near player will have size 4096x4096 game units. Larger chunks reduce CPU usage
|
||||
(Draw and Cull bars), but can increase GPU usage (GPU bar) since culling becomes less efficient.
|
||||
Smaller values do an opposite.
|
||||
|
||||
This setting can only be configured by editing the settings configuration file.
|
||||
@ -0,0 +1,93 @@
|
||||
#version 120
|
||||
|
||||
#define GROUNDCOVER
|
||||
|
||||
#if @diffuseMap
|
||||
uniform sampler2D diffuseMap;
|
||||
varying vec2 diffuseMapUV;
|
||||
#endif
|
||||
|
||||
#if @normalMap
|
||||
uniform sampler2D normalMap;
|
||||
varying vec2 normalMapUV;
|
||||
varying vec4 passTangent;
|
||||
#endif
|
||||
|
||||
// Other shaders respect forcePPL, but legacy groundcover mods were designed to work with vertex lighting.
|
||||
// They may do not look as intended with per-pixel lighting, so ignore this setting for now.
|
||||
#define PER_PIXEL_LIGHTING @normalMap
|
||||
|
||||
varying float euclideanDepth;
|
||||
varying float linearDepth;
|
||||
|
||||
#if PER_PIXEL_LIGHTING
|
||||
varying vec3 passViewPos;
|
||||
varying vec3 passNormal;
|
||||
#else
|
||||
centroid varying vec3 passLighting;
|
||||
centroid varying vec3 shadowDiffuseLighting;
|
||||
#endif
|
||||
|
||||
#include "shadows_fragment.glsl"
|
||||
#include "lighting.glsl"
|
||||
|
||||
float calc_coverage(float a, float alpha_ref, float falloff_rate)
|
||||
{
|
||||
return clamp(falloff_rate * (a - alpha_ref) + alpha_ref, 0.0, 1.0);
|
||||
}
|
||||
|
||||
void main()
|
||||
{
|
||||
#if @normalMap
|
||||
vec4 normalTex = texture2D(normalMap, normalMapUV);
|
||||
|
||||
vec3 normalizedNormal = normalize(passNormal);
|
||||
vec3 normalizedTangent = normalize(passTangent.xyz);
|
||||
vec3 binormal = cross(normalizedTangent, normalizedNormal) * passTangent.w;
|
||||
mat3 tbnTranspose = mat3(normalizedTangent, binormal, normalizedNormal);
|
||||
|
||||
vec3 viewNormal = gl_NormalMatrix * normalize(tbnTranspose * (normalTex.xyz * 2.0 - 1.0));
|
||||
#endif
|
||||
|
||||
#if (!@normalMap && @forcePPL && false)
|
||||
vec3 viewNormal = gl_NormalMatrix * normalize(passNormal);
|
||||
#endif
|
||||
|
||||
#if @diffuseMap
|
||||
gl_FragData[0] = texture2D(diffuseMap, diffuseMapUV);
|
||||
#else
|
||||
gl_FragData[0] = vec4(1.0);
|
||||
#endif
|
||||
|
||||
gl_FragData[0].a = calc_coverage(gl_FragData[0].a, 128.0/255.0, 4.0);
|
||||
|
||||
float shadowing = unshadowedLightRatio(linearDepth);
|
||||
if (euclideanDepth > @groundcoverFadeStart)
|
||||
gl_FragData[0].a *= 1.0-smoothstep(@groundcoverFadeStart, @groundcoverFadeEnd, euclideanDepth);
|
||||
|
||||
vec3 lighting;
|
||||
#if !PER_PIXEL_LIGHTING
|
||||
lighting = passLighting + shadowDiffuseLighting * shadowing;
|
||||
#else
|
||||
vec3 diffuseLight, ambientLight;
|
||||
doLighting(passViewPos, normalize(viewNormal), shadowing, diffuseLight, ambientLight);
|
||||
lighting = diffuseLight + ambientLight;
|
||||
#endif
|
||||
|
||||
#if @clamp
|
||||
lighting = clamp(lighting, vec3(0.0), vec3(1.0));
|
||||
#else
|
||||
lighting = max(lighting, 0.0);
|
||||
#endif
|
||||
|
||||
gl_FragData[0].xyz *= lighting;
|
||||
|
||||
#if @radialFog
|
||||
float fogValue = clamp((euclideanDepth - gl_Fog.start) * gl_Fog.scale, 0.0, 1.0);
|
||||
#else
|
||||
float fogValue = clamp((linearDepth - gl_Fog.start) * gl_Fog.scale, 0.0, 1.0);
|
||||
#endif
|
||||
gl_FragData[0].xyz = mix(gl_FragData[0].xyz, gl_Fog.color.xyz, fogValue);
|
||||
|
||||
applyShadowDebugOverlay();
|
||||
}
|
||||
@ -0,0 +1,143 @@
|
||||
#version 120
|
||||
|
||||
#define GROUNDCOVER
|
||||
|
||||
attribute vec4 aOffset;
|
||||
attribute vec3 aRotation;
|
||||
|
||||
#if @diffuseMap
|
||||
varying vec2 diffuseMapUV;
|
||||
#endif
|
||||
|
||||
#if @normalMap
|
||||
varying vec2 normalMapUV;
|
||||
varying vec4 passTangent;
|
||||
#endif
|
||||
|
||||
// Other shaders respect forcePPL, but legacy groundcover mods were designed to work with vertex lighting.
|
||||
// They may do not look as intended with per-pixel lighting, so ignore this setting for now.
|
||||
#define PER_PIXEL_LIGHTING @normalMap
|
||||
|
||||
varying float euclideanDepth;
|
||||
varying float linearDepth;
|
||||
|
||||
#if PER_PIXEL_LIGHTING
|
||||
varying vec3 passViewPos;
|
||||
varying vec3 passNormal;
|
||||
#else
|
||||
centroid varying vec3 passLighting;
|
||||
centroid varying vec3 shadowDiffuseLighting;
|
||||
#endif
|
||||
|
||||
#include "shadows_vertex.glsl"
|
||||
#include "lighting.glsl"
|
||||
|
||||
uniform float osg_SimulationTime;
|
||||
uniform mat4 osg_ViewMatrixInverse;
|
||||
uniform mat4 osg_ViewMatrix;
|
||||
uniform float windSpeed;
|
||||
uniform vec3 playerPos;
|
||||
|
||||
vec2 groundcoverDisplacement(in vec3 worldpos, float h)
|
||||
{
|
||||
vec2 windDirection = vec2(1.0);
|
||||
vec3 footPos = playerPos;
|
||||
vec3 windVec = vec3(windSpeed * windDirection, 1.0);
|
||||
|
||||
float v = length(windVec);
|
||||
vec2 displace = vec2(2.0 * windVec + 0.1);
|
||||
vec2 harmonics = vec2(0.0);
|
||||
|
||||
harmonics += vec2((1.0 - 0.10*v) * sin(1.0*osg_SimulationTime + worldpos.xy / 1100.0));
|
||||
harmonics += vec2((1.0 - 0.04*v) * cos(2.0*osg_SimulationTime + worldpos.xy / 750.0));
|
||||
harmonics += vec2((1.0 + 0.14*v) * sin(3.0*osg_SimulationTime + worldpos.xy / 500.0));
|
||||
harmonics += vec2((1.0 + 0.28*v) * sin(5.0*osg_SimulationTime + worldpos.xy / 200.0));
|
||||
|
||||
// FIXME: stomping function does not work well in MGE:
|
||||
// 1. It does not take in account Z coordinate, so it works even when player levitates.
|
||||
// 2. It works more-or-less well only for grass meshes, but not for other types of plants.
|
||||
// So disable this function for now, until we find a better one.
|
||||
vec2 stomp = vec2(0.0);
|
||||
//float d = length(worldpos.xy - footPos.xy);
|
||||
//if (d < 150.0 && d > 0.0)
|
||||
//{
|
||||
// stomp = (60.0 / d - 0.4) * (worldpos.xy - footPos.xy);
|
||||
//}
|
||||
|
||||
return clamp(0.02 * h, 0.0, 1.0) * (harmonics * displace + stomp);
|
||||
}
|
||||
|
||||
mat4 rotation(in vec3 angle)
|
||||
{
|
||||
float sin_x = sin(angle.x);
|
||||
float cos_x = cos(angle.x);
|
||||
float sin_y = sin(angle.y);
|
||||
float cos_y = cos(angle.y);
|
||||
float sin_z = sin(angle.z);
|
||||
float cos_z = cos(angle.z);
|
||||
|
||||
return mat4(
|
||||
cos_z*cos_y+sin_x*sin_y*sin_z, -sin_z*cos_x, cos_z*sin_y+sin_z*sin_x*cos_y, 0.0,
|
||||
sin_z*cos_y+cos_z*sin_x*sin_y, cos_z*cos_x, sin_z*sin_y-cos_z*sin_x*cos_y, 0.0,
|
||||
-sin_y*cos_x, sin_x, cos_x*cos_y, 0.0,
|
||||
0.0, 0.0, 0.0, 1.0);
|
||||
}
|
||||
|
||||
mat3 rotation3(in mat4 rot4)
|
||||
{
|
||||
return mat3(
|
||||
rot4[0].xyz,
|
||||
rot4[1].xyz,
|
||||
rot4[2].xyz);
|
||||
}
|
||||
|
||||
void main(void)
|
||||
{
|
||||
vec3 position = aOffset.xyz;
|
||||
float scale = aOffset.w;
|
||||
|
||||
mat4 rotation = rotation(aRotation);
|
||||
vec4 displacedVertex = rotation * scale * gl_Vertex;
|
||||
|
||||
displacedVertex = vec4(displacedVertex.xyz + position, 1.0);
|
||||
|
||||
vec4 worldPos = osg_ViewMatrixInverse * gl_ModelViewMatrix * displacedVertex;
|
||||
worldPos.xy += groundcoverDisplacement(worldPos.xyz, gl_Vertex.z);
|
||||
vec4 viewPos = osg_ViewMatrix * worldPos;
|
||||
|
||||
gl_ClipVertex = viewPos;
|
||||
euclideanDepth = length(viewPos.xyz);
|
||||
|
||||
if (length(gl_ModelViewMatrix * vec4(position, 1.0)) > @groundcoverFadeEnd)
|
||||
gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
|
||||
else
|
||||
gl_Position = gl_ProjectionMatrix * viewPos;
|
||||
|
||||
linearDepth = gl_Position.z;
|
||||
|
||||
#if (!PER_PIXEL_LIGHTING || @shadows_enabled)
|
||||
vec3 viewNormal = normalize((gl_NormalMatrix * rotation3(rotation) * gl_Normal).xyz);
|
||||
#endif
|
||||
|
||||
#if @diffuseMap
|
||||
diffuseMapUV = (gl_TextureMatrix[@diffuseMapUV] * gl_MultiTexCoord@diffuseMapUV).xy;
|
||||
#endif
|
||||
|
||||
#if @normalMap
|
||||
normalMapUV = (gl_TextureMatrix[@normalMapUV] * gl_MultiTexCoord@normalMapUV).xy;
|
||||
passTangent = gl_MultiTexCoord7.xyzw * rotation;
|
||||
#endif
|
||||
|
||||
#if PER_PIXEL_LIGHTING
|
||||
passViewPos = viewPos.xyz;
|
||||
passNormal = rotation3(rotation) * gl_Normal.xyz;
|
||||
#else
|
||||
vec3 diffuseLight, ambientLight;
|
||||
doLighting(viewPos.xyz, viewNormal, diffuseLight, ambientLight, shadowDiffuseLighting);
|
||||
passLighting = diffuseLight + ambientLight;
|
||||
#endif
|
||||
|
||||
#if (@shadows_enabled)
|
||||
setupShadowCoords(viewPos, viewNormal);
|
||||
#endif
|
||||
}
|
||||
Loading…
Reference in New Issue