fly/flightgear
1
0
Fork 0
Code Activity

Remove unused files

Browse source
This commit is contained in:
Fernando García Liñán 2020-11-17 19:42:52 +01:00
parent b41bc317dd
commit 78a89b3507
2 changed files with 0 additions and 439 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

335
src/Viewer/renderingpipeline.cxx
View file

@ -1,335 +0,0 @@
// renderingpipeline.cxx -- description of the cameras needed by the Rembrandt renderer
//
// Written by Curtis Olson, started May 1997.
// This file contains parts of main.cxx prior to october 2004
//
// Copyright (C) 1997 - 2012 Curtis L. Olson - http://www.flightgear.org/~curt
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#ifdef HAVE_WINDOWS_H
# include <windows.h>
#endif
#include <boost/lexical_cast.hpp>
#include <osg/GL>
#include <osg/FrameBufferObject> // For texture formats
#include <simgear/debug/logstream.hxx>
#include <simgear/scene/util/SGReaderWriterOptions.hxx>
#include <simgear/scene/model/modellib.hxx>
#include <simgear/scene/material/EffectBuilder.hxx>
#include <simgear/scene/material/EffectCullVisitor.hxx>
#include <simgear/props/props_io.hxx>
#include <simgear/structure/exception.hxx>
#include <simgear/math/SGMath.hxx>
#include "renderingpipeline.hxx"
#include "CameraGroup.hxx"
#include <Main/globals.hxx>
#include "renderer.hxx"
namespace flightgear {
FGRenderingPipeline* makeRenderingPipeline(const std::string& name,
const simgear::SGReaderWriterOptions* options)
{
std::string fileName = "Effects/" + name;
fileName += ".xml";
std::string absFileName
= simgear::SGModelLib::findDataFile(fileName, options);
if (absFileName.empty()) {
SG_LOG(SG_INPUT, SG_ALERT, "can't find \"" << fileName << "\"");
return 0;
}
SGPropertyNode_ptr effectProps = new SGPropertyNode();
try {
readProperties(absFileName, effectProps.ptr(), 0, true);
}
catch (sg_io_exception& e) {
SG_LOG(SG_INPUT, SG_ALERT, "error reading \"" << absFileName << "\": "
<< e.getFormattedMessage());
return 0;
}
osg::ref_ptr<FGRenderingPipeline> pipeline = new FGRenderingPipeline;
std::vector<SGPropertyNode_ptr> buffers = effectProps->getChildren("buffer");
for (int i = 0; i < (int)buffers.size(); ++i) {
pipeline->buffers.push_back(new FGRenderingPipeline::Buffer(buffers[i]));
}
std::vector<SGPropertyNode_ptr> stages = effectProps->getChildren("stage");
for (int i = 0; i < (int)stages.size(); ++i) {
pipeline->stages.push_back(new FGRenderingPipeline::Stage(stages[i]));
}
return pipeline.release();
}
}
void
FGRenderingPipeline::Conditionable::parseCondition(SGPropertyNode* prop)
{
const SGPropertyNode* predProp = prop->getChild("condition");
if (!predProp) {
setAlwaysValid(true);
} else {
setAlwaysValid(false);
try {
flightgear::PipelinePredParser parser;
SGExpressionb* validExp = dynamic_cast<SGExpressionb*>(parser.read(predProp->getChild(0)));
if (validExp)
setValidExpression(validExp);
else
throw simgear::expression::ParseError("pipeline condition is not a boolean expression");
}
catch (simgear::expression::ParseError& except)
{
SG_LOG(SG_INPUT, SG_ALERT,
"parsing pipeline condition " << except.getMessage());
setAlwaysValid(false);
}
}
}
void FGRenderingPipeline::Conditionable::setValidExpression(SGExpressionb* exp)
{
_validExpression = exp;
}
bool FGRenderingPipeline::Conditionable::valid()
{
return _alwaysValid || _validExpression->getValue();
}
template<typename T>
void findAttrOrHex(const simgear::effect::EffectPropertyMap<T>& pMap,
const SGPropertyNode* prop,
T& result)
{
try {
simgear::findAttr(pMap, prop, result);
} catch (simgear::effect::BuilderException&) {
std::string val = prop->getStringValue();
try {
result = boost::lexical_cast<T>(val);
} catch (boost::bad_lexical_cast &) {
throw simgear::effect::BuilderException(std::string("findAttrOrHex: could not find attribute ")
+ std::string(val));
}
}
}
const SGPropertyNode* getPropertyNode(const SGPropertyNode* prop)
{
if (!prop)
return 0;
if (prop->nChildren() > 0) {
const SGPropertyNode* propertyProp = prop->getChild("property");
if (!propertyProp)
return prop;
return globals->get_props()->getNode(propertyProp->getStringValue());
}
return prop;
}
const SGPropertyNode* getPropertyChild(const SGPropertyNode* prop,
const char* name)
{
const SGPropertyNode* child = prop->getChild(name);
if (!child)
return 0;
else
return getPropertyNode(child);
}
simgear::effect::EffectNameValue<GLint> internalFormatInit[] =
{
{ "rgb8", GL_RGB8 },
{ "rgba8", GL_RGBA8 },
{ "rgb16", GL_RGB16 },
{ "rgba16", GL_RGBA16 },
{ "rg16", 0x822C },
{ "depth-component24", GL_DEPTH_COMPONENT24 },
{ "depth-component32", GL_DEPTH_COMPONENT32 }
};
simgear::effect::EffectPropertyMap<GLint> internalFormats(internalFormatInit);
simgear::effect::EffectNameValue<GLenum> sourceFormatInit[] =
{
{ "rg", 0x8227 },
{ "rgb", GL_RGB },
{ "rgba", GL_RGBA },
{ "depth-component", GL_DEPTH_COMPONENT }
};
simgear::effect::EffectPropertyMap<GLenum> sourceFormats(sourceFormatInit);
simgear::effect::EffectNameValue<GLenum> sourceTypeInit[] =
{
{ "unsigned-byte", GL_UNSIGNED_BYTE },
{ "unsigned-short", GL_UNSIGNED_SHORT },
{ "unsigned-int", GL_UNSIGNED_INT },
{ "float", GL_FLOAT }
};
simgear::effect::EffectPropertyMap<GLenum> sourceTypes(sourceTypeInit);
simgear::effect::EffectNameValue<GLenum> wrapModesInit[] =
{
{"clamp", GL_CLAMP},
{"clamp-to-border", GL_CLAMP_TO_BORDER_ARB},
{"clamp-to-edge", GL_CLAMP_TO_EDGE},
{"mirror", GL_MIRRORED_REPEAT_IBM},
{"repeat", GL_REPEAT}
};
simgear::effect::EffectPropertyMap<GLenum> wrapModes(wrapModesInit);
FGRenderingPipeline::Buffer::Buffer(SGPropertyNode* prop)
{
SGPropertyNode_ptr nameProp = prop->getChild("name");
if (!nameProp.valid()) {
throw sg_exception("Buffer name is mandatory");
}
internalFormat = GL_RGBA8;
sourceFormat = GL_RGBA;
sourceType = GL_UNSIGNED_BYTE;
wrapMode = GL_CLAMP_TO_BORDER_ARB;
name = nameProp->getStringValue();
SGPropertyNode* internalFormatProp = prop->getChild("internal-format");
if (internalFormatProp)
findAttrOrHex(internalFormats, internalFormatProp, internalFormat);
SGPropertyNode* sourceFormatProp = prop->getChild("source-format");
if (sourceFormatProp)
findAttrOrHex(sourceFormats, sourceFormatProp, sourceFormat);
SGPropertyNode* sourceTypeProp = prop->getChild("source-type");
if (sourceTypeProp)
findAttrOrHex(sourceTypes, sourceTypeProp, sourceType);
SGPropertyNode* wrapModeProp = prop->getChild("wrap-mode");
if (wrapModeProp)
findAttrOrHex(wrapModes, wrapModeProp, wrapMode);
SGConstPropertyNode_ptr widthProp = getPropertyChild(prop, "width");
if (!widthProp.valid())
width = -1;
else if (widthProp->getStringValue() == std::string("screen"))
width = -1;
else {
width = widthProp->getIntValue();
}
SGConstPropertyNode_ptr heightProp = getPropertyChild(prop, "height");
if (!heightProp.valid())
height = -1;
else if (heightProp->getStringValue() == std::string("screen"))
height = -1;
else
height = heightProp->getIntValue();
scaleFactor = prop->getFloatValue("scale-factor", 1.f);
shadowComparison = prop->getBoolValue("shadow-comparison", false);
parseCondition(prop);
}
simgear::effect::EffectNameValue<osg::Camera::BufferComponent> componentsInit[] =
{
{"depth", osg::Camera::DEPTH_BUFFER},
{"stencil", osg::Camera::STENCIL_BUFFER},
{"packed-depth-stencil", osg::Camera::PACKED_DEPTH_STENCIL_BUFFER},
{"color0", osg::Camera::COLOR_BUFFER0},
{"color1", osg::Camera::COLOR_BUFFER1},
{"color2", osg::Camera::COLOR_BUFFER2},
{"color3", osg::Camera::COLOR_BUFFER3}
};
simgear::effect::EffectPropertyMap<osg::Camera::BufferComponent> components(componentsInit);
FGRenderingPipeline::Pass::Pass(SGPropertyNode* prop)
{
SGPropertyNode_ptr nameProp = prop->getChild("name");
if (!nameProp.valid()) {
throw sg_exception("Pass name is mandatory");
}
name = nameProp->getStringValue();
SGPropertyNode_ptr typeProp = prop->getChild("type");
if (!typeProp.valid()) {
type = nameProp->getStringValue();
} else {
type = typeProp->getStringValue();
}
orderNum = prop->getIntValue("order-num", -1);
effect = prop->getStringValue("effect", "");
debugProperty = prop->getStringValue("debug-property", "");
parseCondition(prop);
}
FGRenderingPipeline::Stage::Stage(SGPropertyNode* prop) : Pass(prop)
{
needsDuDv = prop->getBoolValue("needs-du-dv", false);
scaleFactor = prop->getFloatValue("scale-factor", 1.f);
std::vector<SGPropertyNode_ptr> attachments = prop->getChildren("attachment");
for (int i = 0; i < (int)attachments.size(); ++i) {
this->attachments.push_back(new FGRenderingPipeline::Attachment(attachments[i]));
}
std::vector<SGPropertyNode_ptr> passes = prop->getChildren("pass");
for (int i = 0; i < (int)passes.size(); ++i) {
this->passes.push_back(new FGRenderingPipeline::Pass(passes[i]));
}
}
FGRenderingPipeline::Attachment::Attachment(SGPropertyNode* prop)
{
simgear::findAttr(components, prop->getChild("component"), component);
SGPropertyNode_ptr bufferProp = prop->getChild("buffer");
if (!bufferProp.valid()) {
throw sg_exception("Attachment buffer is mandatory");
}
buffer = bufferProp->getStringValue();
parseCondition(prop);
}
FGRenderingPipeline::FGRenderingPipeline()
{
}
class FGStageCameraCullCallback : public osg::NodeCallback {
public:
FGStageCameraCullCallback(FGRenderingPipeline::Stage* s, flightgear::CameraInfo* i) : stage(s), info(i) {}
virtual void operator()( osg::Node *n, osg::NodeVisitor *nv) {
simgear::EffectCullVisitor* cv = dynamic_cast<simgear::EffectCullVisitor*>(nv);
osg::Camera* camera = static_cast<osg::Camera*>(n);
cv->clearBufferList();
for (flightgear::RenderBufferMap::iterator ii = info->buffers.begin(); ii != info->buffers.end(); ++ii) {
cv->addBuffer(ii->first, ii->second.texture );
}
if ( !info->getRenderStageInfo(stage->name).fullscreen )
info->setMatrices( camera );
cv->traverse( *camera );
}
private:
osg::ref_ptr<FGRenderingPipeline::Stage> stage;
flightgear::CameraInfo* info;
};

104
src/Viewer/renderingpipeline.hxx
View file

@ -1,104 +0,0 @@
#ifndef __FG_RENDERINGPIPELINE_HXX
#define __FG_RENDERINGPIPELINE_HXX 1
#include <osg/ref_ptr>
#include <osg/Camera>
#include <string>
#include <simgear/structure/SGExpression.hxx>
namespace simgear
{
class SGReaderWriterOptions;
}
namespace flightgear
{
struct CameraInfo;
class CameraGroup;
}
class FGRenderingPipeline;
namespace flightgear {
FGRenderingPipeline* makeRenderingPipeline(const std::string& name,
const simgear::SGReaderWriterOptions* options);
}
class FGRenderingPipeline : public osg::Referenced {
public:
class Conditionable : public osg::Referenced {
public:
Conditionable() : _alwaysValid(true) {}
void parseCondition(SGPropertyNode* prop);
bool getAlwaysValid() const { return _alwaysValid; }
void setAlwaysValid(bool val) { _alwaysValid = val; }
void setValidExpression(SGExpressionb* exp);
bool valid();
protected:
bool _alwaysValid;
SGSharedPtr<SGExpressionb> _validExpression;
};
struct Buffer : public Conditionable {
Buffer(SGPropertyNode* prop);
std::string name;
GLint internalFormat;
GLenum sourceFormat;
GLenum sourceType;
int width;
int height;
float scaleFactor;
GLenum wrapMode;
bool shadowComparison;
//GLenum shadowTextureMode;
//osg::Vec4 borderColor;
};
struct Pass : public Conditionable {
Pass(SGPropertyNode* prop);
std::string name;
std::string type;
int orderNum;
std::string effect;
std::string debugProperty;
};
struct Attachment : public Conditionable {
Attachment(SGPropertyNode* prop);
Attachment(osg::Camera::BufferComponent c, const std::string& b ) : component(c), buffer(b) {}
osg::Camera::BufferComponent component;
std::string buffer;
};
typedef std::vector<osg::ref_ptr<Attachment> > AttachmentList;
struct Stage : public Pass {
Stage(SGPropertyNode* prop);
bool needsDuDv;
float scaleFactor;
std::vector<osg::ref_ptr<Pass> > passes;
AttachmentList attachments;
};
FGRenderingPipeline();
std::vector<osg::ref_ptr<Buffer> > buffers;
std::vector<osg::ref_ptr<Stage> > stages;
int MaximumTextureSize;
friend FGRenderingPipeline* flightgear::makeRenderingPipeline(const std::string& name,
const simgear::SGReaderWriterOptions* options);
};
namespace flightgear {
class PipelinePredParser : public simgear::expression::ExpressionParser
{
public:
protected:
};
}
#endif