Merge /u/fgarlin/simgear/ branch next into next

https://sourceforge.net/p/flightgear/simgear/merge-requests/70/
This commit is contained in:
James Turner 2019-12-24 19:47:25 +00:00
commit 3aa567b672
6 changed files with 140 additions and 16 deletions

View File

@ -53,9 +53,6 @@ class Technique;
class Effect;
class SGReaderWriterOptions;
using namespace osg;
using namespace std;
/**
* Object to be initialized at some point after an effect -- and its
* containing effect geode -- are hooked into the scene graph. Some
@ -179,9 +176,9 @@ void mergePropertyTrees(SGPropertyNode* resultNode,
class UniformFactoryImpl {
public:
ref_ptr<Uniform> getUniform( Effect * effect,
osg::ref_ptr<osg::Uniform> getUniform( Effect * effect,
const string & name,
Uniform::Type uniformType,
osg::Uniform::Type uniformType,
SGConstPropertyNode_ptr valProp,
const SGReaderWriterOptions* options );
void updateListeners( SGPropertyNode* propRoot );
@ -194,9 +191,9 @@ private:
SGMutex _mutex;
typedef boost::tuple<std::string, Uniform::Type, std::string, std::string> UniformCacheKey;
typedef boost::tuple<ref_ptr<Uniform>, SGPropertyChangeListener*> UniformCacheValue;
std::map<UniformCacheKey,ref_ptr<Uniform> > uniformCache;
typedef boost::tuple<std::string, osg::Uniform::Type, std::string, std::string> UniformCacheKey;
typedef boost::tuple<osg::ref_ptr<osg::Uniform>, SGPropertyChangeListener*> UniformCacheValue;
std::map<UniformCacheKey,osg::ref_ptr<osg::Uniform> > uniformCache;
typedef std::queue<DeferredPropertyListener*> DeferredListenerList;
DeferredListenerList deferredListenerList;

View File

@ -356,7 +356,7 @@ namespace
{
TextureBuilder::Registrar install1D("1d", new TexBuilder<Texture1D>("1d"));
TextureBuilder::Registrar install2D("2d", new TexBuilder<Texture2D>("2d"));
TextureBuilder::Registrar install3D("3d", new TexBuilder<Texture3D>("3d"));
//TextureBuilder::Registrar install3D("3d", new TexBuilder<Texture3D>("3d"));
}
class WhiteTextureBuilder : public TextureBuilder
@ -776,6 +776,96 @@ namespace {
TextureBuilder::Registrar installCubeMap("cubemap", new CubeMapBuilder);
}
class Texture3DBuilder : public TextureBuilder
{
public:
Texture* build(Effect* effect, Pass* pass, const SGPropertyNode*,
const SGReaderWriterOptions* options);
protected:
typedef map<TexTuple, observer_ptr<Texture3D> > TexMap;
TexMap texMap;
};
Texture* Texture3DBuilder::build(Effect* effect, Pass* pass,
const SGPropertyNode* props,
const SGReaderWriterOptions* options)
{
TexTuple attrs = makeTexTuple(effect, props, options, "3d");
typename TexMap::iterator itr = texMap.find(attrs);
ref_ptr<Texture3D> tex;
if ((itr != texMap.end())&&
(itr->second.lock(tex)))
{
return tex.release();
}
tex = new Texture3D;
const string& imageName = attrs.get<0>();
if (imageName.empty())
return NULL;
osgDB::ReaderWriter::ReadResult result;
// load texture for effect
SGReaderWriterOptions::LoadOriginHint origLOH = options->getLoadOriginHint();
if(attrs.get<8>() == ImageInternalFormat::Normalized)
options->setLoadOriginHint(SGReaderWriterOptions::LoadOriginHint::ORIGIN_EFFECTS_NORMALIZED);
else
options->setLoadOriginHint(SGReaderWriterOptions::LoadOriginHint::ORIGIN_EFFECTS);
#if OSG_VERSION_LESS_THAN(3,4,2)
result = osgDB::readImageFile(imageName, options);
#else
result = osgDB::readRefImageFile(imageName, options);
#endif
options->setLoadOriginHint(origLOH);
osg::ref_ptr<osg::Image> image;
if (result.success())
image = result.getImage();
if (image.valid())
{
osg::ref_ptr<osg::Image> image3d = new osg::Image;
int size = image->t();
int depth = image->s() / image->t();
image3d->allocateImage(size, size, depth,
image->getPixelFormat(), image->getDataType());
for (int i = 0; i < depth; ++i) {
osg::ref_ptr<osg::Image> subimage = new osg::Image;
subimage->allocateImage(size, size, 1,
image->getPixelFormat(), image->getDataType());
copySubImage(image, size * i, 0, size, size, subimage.get(), 0, 0);
image3d->copySubImage(0, 0, i, subimage.get());
}
image3d->setInternalTextureFormat(image->getInternalTextureFormat());
image3d = computeMipmap(image3d.get(), attrs.get<7>());
tex->setImage(image3d.get());
} else {
SG_LOG(SG_INPUT, SG_ALERT, "failed to load effect texture file " << imageName);
return NULL;
}
tex->setFilter(Texture::MIN_FILTER, attrs.get<1>());
tex->setFilter(Texture::MAG_FILTER, attrs.get<2>());
tex->setWrap(Texture::WRAP_S, attrs.get<3>());
tex->setWrap(Texture::WRAP_T, attrs.get<4>());
tex->setWrap(Texture::WRAP_R, attrs.get<5>());
if (itr == texMap.end())
texMap.insert(make_pair(attrs, tex));
else
itr->second = tex; // update existing, but empty observer
return tex.release();
}
namespace {
TextureBuilder::Registrar install3D("3d", new Texture3DBuilder);
}
EffectNameValue<TexEnvCombine::CombineParam> combineParamInit[] =
{
{"replace", TexEnvCombine::REPLACE},

View File

@ -123,7 +123,11 @@ SGLight::appendLight(const SGPropertyNode *configNode,
}
osg::ShapeDrawable *debug_drawable = new osg::ShapeDrawable(debug_shape);
debug_drawable->setColor(osg::Vec4(1.0, 0.0, 0.0, 1.0));
debug_drawable->setColor(
osg::Vec4(configNode->getFloatValue("debug-color/r", 1.0f),
configNode->getFloatValue("debug-color/g", 0.0f),
configNode->getFloatValue("debug-color/b", 0.0f),
configNode->getFloatValue("debug-color/a", 1.0f)));
osg::Geode *debug_geode = new osg::Geode;
debug_geode->addDrawable(debug_drawable);

View File

@ -28,10 +28,20 @@
#include <simgear/scene/material/EffectCullVisitor.hxx>
#include <simgear/scene/util/SGReaderWriterOptions.hxx>
#include <simgear/scene/util/RenderConstants.hxx>
#include <simgear/scene/util/SGUpdateVisitor.hxx>
#include <simgear/structure/exception.hxx>
#include "CompositorUtil.hxx"
class LightDirectionCallback : public osg::Uniform::Callback {
public:
virtual void operator()(osg::Uniform *uniform, osg::NodeVisitor *nv) {
SGUpdateVisitor *uv = dynamic_cast<SGUpdateVisitor *>(nv);
uniform->set(toOsg(uv->getLightDirection()));
}
};
namespace simgear {
namespace compositor {
@ -113,10 +123,16 @@ Compositor::Compositor(osg::View *view,
new osg::Uniform("fg_ViewMatrixInverse", osg::Matrixf()),
new osg::Uniform("fg_ProjectionMatrix", osg::Matrixf()),
new osg::Uniform("fg_ProjectionMatrixInverse", osg::Matrixf()),
new osg::Uniform("fg_PrevViewMatrix", osg::Matrixf()),
new osg::Uniform("fg_PrevViewMatrixInverse", osg::Matrixf()),
new osg::Uniform("fg_PrevProjectionMatrix", osg::Matrixf()),
new osg::Uniform("fg_PrevProjectionMatrixInverse", osg::Matrixf()),
new osg::Uniform("fg_CameraPositionCart", osg::Vec3f()),
new osg::Uniform("fg_CameraPositionGeod", osg::Vec3f())
new osg::Uniform("fg_CameraPositionGeod", osg::Vec3f()),
new osg::Uniform("fg_LightDirection", osg::Vec3f())
}
{
_uniforms[LIGHT_DIRECTION]->setUpdateCallback(new LightDirectionCallback);
}
Compositor::~Compositor()
@ -149,6 +165,18 @@ Compositor::update(const osg::Matrix &view_matrix,
SGGeod camera_pos_geod = SGGeod::fromCart(
SGVec3d(camera_pos.x(), camera_pos.y(), camera_pos.z()));
osg::Matrixf prev_view_matrix, prev_view_matrix_inv;
_uniforms[VIEW_MATRIX]->get(prev_view_matrix);
_uniforms[VIEW_MATRIX_INV]->get(prev_view_matrix_inv);
osg::Matrixf prev_proj_matrix, prev_proj_matrix_inv;
_uniforms[PROJECTION_MATRIX]->get(prev_proj_matrix);
_uniforms[PROJECTION_MATRIX_INV]->get(prev_proj_matrix_inv);
_uniforms[PREV_VIEW_MATRIX]->set(prev_view_matrix);
_uniforms[PREV_VIEW_MATRIX_INV]->set(prev_view_matrix_inv);
_uniforms[PREV_PROJECTION_MATRIX]->set(prev_proj_matrix);
_uniforms[PREV_PROJECTION_MATRIX_INV]->set(prev_proj_matrix_inv);
for (int i = 0; i < TOTAL_BUILTIN_UNIFORMS; ++i) {
osg::ref_ptr<osg::Uniform> u = _uniforms[i];
switch (i) {

View File

@ -51,8 +51,13 @@ public:
VIEW_MATRIX_INV,
PROJECTION_MATRIX,
PROJECTION_MATRIX_INV,
PREV_VIEW_MATRIX,
PREV_VIEW_MATRIX_INV,
PREV_PROJECTION_MATRIX,
PREV_PROJECTION_MATRIX_INV,
CAMERA_POSITION_CART,
CAMERA_POSITION_GEOD,
LIGHT_DIRECTION,
TOTAL_BUILTIN_UNIFORMS
};

View File

@ -89,7 +89,7 @@ PassBuilder::build(Compositor *compositor, const SGPropertyNode *root,
pass->type = root->getStringValue("type");
pass->effect_scheme = root->getStringValue("effect-scheme");
osg::Camera *camera = new Camera;
osg::Camera *camera = new osg::Camera;
pass->camera = camera;
camera->setName(pass->name);
@ -107,8 +107,8 @@ PassBuilder::build(Compositor *compositor, const SGPropertyNode *root,
camera->setComputeNearFarMode(osg::CullSettings::DO_NOT_COMPUTE_NEAR_FAR);
// XXX: Should we make this configurable?
camera->setCullingMode(CullSettings::SMALL_FEATURE_CULLING
| CullSettings::VIEW_FRUSTUM_CULLING);
camera->setCullingMode(osg::CullSettings::SMALL_FEATURE_CULLING
| osg::CullSettings::VIEW_FRUSTUM_CULLING);
osg::Node::NodeMask cull_mask =
std::stoul(root->getStringValue("cull-mask", "0xffffffff"), nullptr, 0);
@ -639,8 +639,8 @@ public:
protected:
// Given a projection matrix, return a new one with the same frustum
// sides and new near / far values.
void makeNewProjMat(Matrixd& oldProj, double znear,
double zfar, Matrixd& projection) {
void makeNewProjMat(osg::Matrixd& oldProj, double znear,
double zfar, osg::Matrixd& projection) {
projection = oldProj;
// Slightly inflate the near & far planes to avoid objects at the
// extremes being clipped out.