PM/DYTSrouce
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

modiyf osg renderer

Browse Source
This commit is contained in:
jiegeaiai 2025-02-22 23:16:54 +08:00
parent 1eb2e44f26
commit a4969a8aba
20 changed files with 731 additions and 991 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
doc/dyt修改.txt
View File

@ -10,7 +10,7 @@
a、保留窗口2的Report Table （解决）
b、窗口2中的Report Table, 可以拖动变成dock模式添加到其他的窗口中
c、有缩放属性的控件，鼠标都显示为双箭头 （解决）
d、所有的窗口表头可以采用拖动的形式调整列的位置
d、所有的窗口表头可以采用拖动的形式调整列的位置 （解决）
4.需要连续用到的操作、功能类似的放到一个大界面。这些不知道具体怎么分就需要讨论细分一下比如：
功能控制一样的：窗口管理和ui设置都是控制界面的放到同一个栏目

441
src/effects/ConeWave.cpp
View File

@ -1,5 +1,5 @@
#include "effects/ConeWave.h"
/*
#include <osg/BlendFunc>
#include <osg/Material>
#include <osg/Texture2D>
@ -13,6 +13,43 @@
#include <osg/Depth>
#include <osgEarth/Registry>
class WaveSurfaceCallback : public osg::NodeCallback {
public:
WaveSurfaceCallback() : timeElapsed(0.0f) {}
virtual void operator()(osg::Node* node, osg::NodeVisitor* nv) {
timeElapsed += (nv->getFrameStamp()->getSimulationTime() - SimulationTime);
// 获取并更新geometry的顶点
osg::Geode* geode = dynamic_cast<osg::Geode*>(node);
if (geode) {
osg::Geometry* geometry = dynamic_cast<osg::Geometry*>(geode->getDrawable(0));
if (geometry) {
osg::Vec3Array* vertices = dynamic_cast<osg::Vec3Array*>(geometry->getVertexArray());
if (vertices) {
// 更新顶点位置来模拟波动
float amplitude = 2.0f;
float frequency = 1.0f;
for (unsigned int i = 0; i < vertices->size(); ++i) {
osg::Vec3f& vertex = (*vertices)[i];
vertex.z() = amplitude * sin(frequency * (vertex.x() + timeElapsed));
}
geometry->setVertexArray(vertices);
geometry->dirtyBound(); // 更新几何体边界
}
}
}
// 继续遍历场景图
traverse(node, nv);
SimulationTime = nv->getFrameStamp()->getSimulationTime();
}
private:
float timeElapsed;
double SimulationTime;
};
ConeWave::ConeWave() {
osgEarth::Registry::shaderGenerator().run(this);
@ -44,7 +81,7 @@ void ConeWave::SetHeight(float height) {
if (cone_) {
cone_->setHeight(height_);
}
coneDrawable_->build();
// coneDrawable_->build();
}
void ConeWave::SetRadius(float radius) {
@ -52,7 +89,7 @@ void ConeWave::SetRadius(float radius) {
if (cone_) {
cone_->setRadius(radius);
}
coneDrawable_->build();
// coneDrawable_->build();
}
void ConeWave::SetBaseColor(const osg::Vec4& color) {
@ -77,20 +114,66 @@ void ConeWave::SetLevelHeight(float height) {
}
void ConeWave::CreateTexturedCone(osg::Geode* geode) {
cone_ = new osg::Cone(osg::Vec3(0, 0, 0.), radius_, height_);
osg::TessellationHints* tesselate = new osg::TessellationHints;
tesselate->setCreateBottom(false);
tesselate->setCreateBackFace(false);
coneDrawable_ = new osg::ShapeDrawable(cone_, tesselate);
geode->addDrawable(coneDrawable_);
//coneDrawable_->setColor(baseColor_);
//osg::StateSet* ss = coneDrawable_->getOrCreateStateSet();
////stateset->setRenderBinDetails(120, "OSGEARTH_SCREEN_SPACE_LAYOUT_BIN");
//ss->setRenderBinDetails(120, "RenderBin");
//osg::ref_ptr<osg::BlendFunc> bf = new osg::BlendFunc();
//ss->setAttributeAndModes(bf, osg::StateAttribute::ON);
//ss->setMode(GL_CULL_FACE, osg::StateAttribute::ON);
//return;
// cone_ = new osg::Cone(osg::Vec3(0, 0, 0.), radius_, height_);
// osg::TessellationHints* tesselate = new osg::TessellationHints;
// tesselate->setCreateBottom(false);
// tesselate->setCreateBackFace(false);
// coneDrawable_ = new osg::ShapeDrawable(cone_, tesselate);
// geode->addDrawable(coneDrawable_);
// coneDrawable_->setColor(baseColor_);
// osg::StateSet* ss = coneDrawable_->getOrCreateStateSet();
// //stateset->setRenderBinDetails(120, "OSGEARTH_SCREEN_SPACE_LAYOUT_BIN");
// ss->setRenderBinDetails(120, "RenderBin");
// osg::ref_ptr<osg::BlendFunc> bf = new osg::BlendFunc();
// ss->setAttributeAndModes(bf, osg::StateAttribute::ON);
// ss->setMode(GL_CULL_FACE, osg::StateAttribute::ON);
osg::ref_ptr<osg::Geometry> geometry = new osg::Geometry();
// 创建顶点数组
osg::ref_ptr<osg::Vec3Array> vertices = new osg::Vec3Array;
int rows = 20, cols=20;
for (unsigned int i = 0; i < rows; ++i) {
for (unsigned int j = 0; j < cols; ++j) {
// 坐标
float x = (float)i / (rows - 1) * 100;
float y = (float)j / (cols - 1) * 100;
vertices->push_back(osg::Vec3f(x, y, 0.0f));
}
}
geometry->setVertexArray(vertices);
// 生成索引来连接顶点
osg::ref_ptr<osg::DrawElementsUShort> indices = new osg::DrawElementsUShort(osg::PrimitiveSet::QUADS);
for (unsigned int i = 0; i < rows - 1; ++i) {
for (unsigned int j = 0; j < cols - 1; ++j) {
unsigned short bottomLeft = i * cols + j;
unsigned short bottomRight = bottomLeft + 1;
unsigned short topLeft = (i + 1) * cols + j;
unsigned short topRight = topLeft + 1;
indices->push_back(bottomLeft);
indices->push_back(bottomRight);
indices->push_back(topRight);
indices->push_back(topLeft);
}
}
geometry->addPrimitiveSet(indices);
// 创建表面颜色
osg::ref_ptr<osg::Vec4Array> colors = new osg::Vec4Array;
colors->push_back(osg::Vec4(0.0f, 0.0f, 1.0f, 1.0f)); // 蓝色
geometry->setColorArray(colors);
geometry->setColorBinding(osg::Geometry::BIND_OVERALL);
// 添加geometry到geode
geode->addDrawable(geometry);
geode->setUpdateCallback(new WaveSurfaceCallback());
return;
static const char* vertSource = {
"#version 330\n"
@ -132,27 +215,309 @@ void ConeWave::CreateTexturedCone(osg::Geode* geode) {
fragmentShader->setShaderSource(fragSource);
osg::StateSet* stateset = coneDrawable_->getOrCreateStateSet();
//stateset->setRenderBinDetails(120, "OSGEARTH_SCREEN_SPACE_LAYOUT_BIN");
stateset->setRenderBinDetails(120, "RenderBin");
osg::ref_ptr<osg::BlendFunc> blendFunc = new osg::BlendFunc();
stateset->setAttributeAndModes(blendFunc, osg::StateAttribute::ON);
osg::ref_ptr<osg::Program> program = new osg::Program();
program->addShader(vertexShader);
program->addShader(fragmentShader);
//VirtualProgram* vp = VirtualProgram::getOrCreate(outlineSS);
//vp->setFunction("VS", VS, ShaderComp::LOCATION_VERTEX_CLIP);
//vp->setFunction("FS", FS, ShaderComp::LOCATION_FRAGMENT_COLORING);
//outline->addChild(node);
// osg::ref_ptr<osg::Material> mat = new osg::Material;
// //设置正面散射颜色
// mat->setDiffuse(osg::Material::FRONT, osg::Vec4(1.0, 0.0, 0.0, 0.3));//1.0, 0.0, 0.0, 0.3
// //设置正面镜面颜色
// mat->setSpecular(osg::Material::FRONT, osg::Vec4(1.0, 0.0, 0.0, 0.3));//1.0, 0.0, 0.0, 0.3
//
// geode->getOrCreateStateSet()->setAttribute(mat);
stateset->setMode(GL_BLEND, osg::StateAttribute::ON);
stateset->setMode(GL_RESCALE_NORMAL, osg::StateAttribute::ON);
// stateset->setMode(GL_DEPTH_TEST, osg::StateAttribute::ON);
stateset->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
baseColorUniform_ = new osg::Uniform("baseColor", baseColor_);
stateset->setMode(GL_CULL_FACE, osg::StateAttribute::ON);
stateset->addUniform(baseColorUniform_);
stateset->setAttributeAndModes(program, osg::StateAttribute::ON);
stateset->setAttributeAndModes(new osg::Depth(osg::Depth::LESS, 0.0, 1.0, false));
//设置渲染顺序 仿真模型被波束遮盖 ,1000000-指的是若有1000000个Node 则此节点最后一个被渲染
// //stateset->setRenderBinDetails(120, "OSGEARTH_SCREEN_SPACE_LAYOUT_BIN");
stateset->setRenderBinDetails(10, "RenderBin");
// osg::ref_ptr<osg::BlendFunc> blendFunc = new osg::BlendFunc();
// stateset->setAttributeAndModes(blendFunc, osg::StateAttribute::ON);
// osg::ref_ptr<osg::Program> program = new osg::Program();
// program->addShader(vertexShader);
// program->addShader(fragmentShader);
//
// baseColorUniform_ = new osg::Uniform("baseColor", baseColor_);
// stateset->setMode(GL_CULL_FACE, osg::StateAttribute::ON);
// stateset->addUniform(baseColorUniform_);
// // stateset->setAttributeAndModes(program, osg::StateAttribute::ON);
// // stateset->setAttributeAndModes(new osg::Depth(osg::Depth::LESS, 0.0, 1.0, false));
//
// levelCountUniform_ = new osg::Uniform("num", float(levelCount_));
// levelHeightUniform_ = new osg::Uniform("height", levelHeight_);
levelCountUniform_ = new osg::Uniform("num", float(levelCount_));
levelHeightUniform_ = new osg::Uniform("height", levelHeight_);
stateset->addUniform(levelCountUniform_);
stateset->addUniform(levelHeightUniform_.get());
// stateset->addUniform(levelCountUniform_);
// stateset->addUniform(levelHeightUniform_.get());
}
*/
#include <osg/Geode>
#include <osg/Geometry>
#include <osg/Material>
#include <osgFX/Outline>
#include <osgFX/Scribe>
#include <osg/MatrixTransform>
#include <osgEarth/Ellipsoid>
#include "scene/SceneContent.h"
class WaveBeamConeCallBack : public osg::NodeCallback {
public:
WaveBeamConeCallBack();
~WaveBeamConeCallBack();
virtual void operator() (osg::Node *node, osg::NodeVisitor *nv);
public:
double m_latitude;
double m_longitude;
double m_height;
bool m_ifDynamic;
double m_angle;
double m_length;
osg::Vec4 m_color;
osg::Vec4 m_lineColor;
double m_lineWidth;
osg::ref_ptr<osg::Geode> m_geode;
osg::ref_ptr<osg::Geometry> m_geom;
osg::ref_ptr<osg::Vec4Array> m_colorArray;
osg::ref_ptr<osg::Vec3Array> m_pointVector;
osg::ref_ptr<osgFX::Scribe> m_nodeFX;
};
WaveBeamConeCallBack::WaveBeamConeCallBack() {
m_latitude = 0.0;
m_longitude = 0.0;
m_height = -6371000;
m_ifDynamic = false;
m_angle = 20.0;
m_length = 100000;
m_color = osg::Vec4(1, 0, 0, 0.5);
m_lineColor = osg::Vec4(1.0, 0.0, 0.0, 1.0);
m_lineWidth = 1.0;
}
WaveBeamConeCallBack::~WaveBeamConeCallBack() {
}
void WaveBeamConeCallBack::operator()(osg::Node *node, osg::NodeVisitor *nv) {
if (m_ifDynamic == false)
return;
//std::cout << "WaveBeamConeCallBack info=" << m_latitude << "," << m_longitude << "," << m_height << std::endl;
osg::MatrixTransform* mtCone = dynamic_cast<osg::MatrixTransform*>(node);
if (mtCone != NULL) {
osg::MatrixTransform* mtR = dynamic_cast<osg::MatrixTransform*>(mtCone->getParent(0));
osg::MatrixTransform* mt = dynamic_cast<osg::MatrixTransform*>(mtR->getParent(0));
//osg::Matrix m = osg::computeWorldToLocal(mtCone->getParentalNodePaths().at(0));
osg::Matrix m = osg::Matrix::inverse(mt->getMatrix()*mtR->getMatrix());
osg::Matrix mTarget;
double x, y, z;
osg::EllipsoidModel em;
em.convertLatLongHeightToXYZ(osg::DegreesToRadians(m_latitude),
osg::DegreesToRadians(m_longitude),
m_height, x, y, z);
mTarget.setTrans(x, y, z);
osg::Matrix mConeRate = osg::Matrix::rotate(osg::Vec3d(0, 1, 0), (mTarget*m).getTrans());
mtCone->setMatrix(mConeRate);//mTarget*m
//更改cone的形状----------------------------------------
double length = (mTarget*m).getTrans().length();
double angle = osg::DegreesToRadians(m_angle);
double radius = std::tan(angle*0.5) * length;
int splitCount = 20;
double angleStep = osg::PI * 2.0 / splitCount;
//侧面
for (int i = 1; i <= splitCount + 1; i++) {
double tempAngle = (i - 1)*angleStep;
osg::Vec3 pos(radius * cos(tempAngle), length, radius * sin(tempAngle) + 3);
m_pointVector->at(i) = pos;
}
m_pointVector->at(splitCount + 2) = osg::Vec3(0, length, 0);
//底面
for (int i = splitCount + 3; i <= splitCount + 3 + splitCount; i++) {
double tempAngle = (i - splitCount - 3) *angleStep;
osg::Vec3 pos(radius * cos(tempAngle), length, radius * sin(tempAngle) + 3);
m_pointVector->at(i) = pos;
}
m_geom->dirtyBound();
m_geom->dirtyDisplayList();
}
}
ConeWave::ConeWave() {
}
ConeWave::~ConeWave() {
}
void ConeWave::clearSelf() {
}
void ConeWave::Render(double dt)
{
}
void ConeWave::createWaveBeamCone(osg::MatrixTransform* node, double angle, double length,
osg::Vec4 color, osg::Vec4 lineColor, double lineWidth) {
double angleD = osg::DegreesToRadians(angle);
double radius = std::tan(angleD*0.5) * length;
int splitCount = 20;
double angleStep = osg::PI * 2.0 / splitCount;
osg::ref_ptr<osg::Geode> geode = new osg::Geode();
osg::ref_ptr<osg::Geometry> geom = new osg::Geometry;
osg::ref_ptr<osg::Vec3Array> vertex = new osg::Vec3Array;
osg::ref_ptr<osg::Vec3Array> normal = new osg::Vec3Array;
osg::ref_ptr<osg::DrawElementsUInt> drawElemUInt = new osg::DrawElementsUInt(GL_TRIANGLE_FAN);
osg::ref_ptr<osg::DrawElementsUInt> drawElemUInt2 = new osg::DrawElementsUInt(GL_TRIANGLE_FAN);
geom->setVertexArray(vertex);
geom->setNormalArray(normal);
geode->addDrawable(geom);
vertex->push_back(osg::Vec3(0, 0, 0));
drawElemUInt->push_back(0);
normal->push_back(osg::Vec3(0, -1, 0));
//侧面
for (int i = 0; i <= splitCount; i++) {
double tempAngle = i*angleStep;
osg::Vec3 pos(radius * cos(tempAngle), length, radius * sin(tempAngle) + 3);
vertex->push_back(osg::Vec3(pos));
pos.normalize();
normal->push_back(pos);
drawElemUInt->push_back(i + 1);
}
//底面
int indexBegin = vertex->size();
vertex->push_back(osg::Vec3(0, length, 0));
drawElemUInt2->push_back(indexBegin);
normal->push_back(osg::Vec3(0, 1, 0));
for (int i = 0; i <= splitCount; i++) {
double tempAngle = i*angleStep;
osg::Vec3 pos(radius * cos(tempAngle), length, radius * sin(tempAngle) + 3);
vertex->push_back(osg::Vec3(pos));
normal->push_back(osg::Vec3(0, 1, 0));
drawElemUInt2->push_back(indexBegin + i + 1);
}
geom->setNormalBinding(osg::Geometry::BIND_PER_VERTEX);
geom->addPrimitiveSet(drawElemUInt);
geom->addPrimitiveSet(drawElemUInt2);
//创建材质对象
osg::ref_ptr<osg::Material> mat = new osg::Material;
//设置正面散射颜色
mat->setDiffuse(osg::Material::FRONT, osg::Vec4(1.0, 1.0, 0.0, 0.3));//1.0, 0.0, 0.0, 0.3
//设置正面镜面颜色
mat->setSpecular(osg::Material::FRONT, osg::Vec4(1.0, 0.0, 0.0, 0.3));//1.0, 0.0, 0.0, 0.3
geode->getOrCreateStateSet()->setAttribute(mat.get());
geode->getOrCreateStateSet()->setMode(GL_RESCALE_NORMAL, osg::StateAttribute::ON);
//设置透明效果
geode->getOrCreateStateSet()->setMode(GL_BLEND, osg::StateAttribute::ON);
geode->getOrCreateStateSet()->setMode(GL_DEPTH_TEST, osg::StateAttribute::ON);
geode->getOrCreateStateSet()->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
//设置渲染顺序 仿真模型被波束遮盖 ,1000000-指的是若有1000000个Node 则此节点最后一个被渲染
geode->getOrCreateStateSet()->setRenderBinDetails(12, "RenderBin");
osg::ref_ptr<osg::MatrixTransform> mtCone = new osg::MatrixTransform;
// mtCone->addChild(nodeFX);
//给callback中赋值
WaveBeamConeCallBack* coneCallBack = new WaveBeamConeCallBack;
coneCallBack->m_angle = angle;
coneCallBack->m_length = length;
coneCallBack->m_color = color;
coneCallBack->m_lineColor = lineColor;
coneCallBack->m_lineWidth = lineWidth;
coneCallBack->m_geode = geode;
coneCallBack->m_geom = geom;
coneCallBack->m_pointVector = vertex;
//添加到模型中
// osg::MatrixTransform* mtR = dynamic_cast<osg::MatrixTransform*>(node->getChild(0));
// osg::MatrixTransform* mtS = dynamic_cast<osg::MatrixTransform*>(mtR->getChild(0));
// mtR->addChild(mtCone);
_waveBeamCone = mtCone;
}
void ConeWave::changeWaveBeamConeTarget(double latitude, double longitude, double height, bool ifDynamic) {
WaveBeamConeCallBack* coneCallBack = dynamic_cast<WaveBeamConeCallBack*>(_waveBeamCone->getUpdateCallback());
if (coneCallBack != NULL) {
coneCallBack->m_ifDynamic = ifDynamic;
coneCallBack->m_latitude = latitude;
coneCallBack->m_longitude = longitude;
coneCallBack->m_height = height;
if (ifDynamic == false) {
osg::MatrixTransform* mtCone = _waveBeamCone;
osg::MatrixTransform* mtR = dynamic_cast<osg::MatrixTransform*>(mtCone->getParent(0));
osg::MatrixTransform* mt = dynamic_cast<osg::MatrixTransform*>(mtR->getParent(0));
//osg::Matrix m = osg::computeWorldToLocal(mtCone->getParentalNodePaths().at(0));
osg::Matrix m = osg::Matrix::inverse(mt->getMatrix()*mtR->getMatrix());
osg::Matrix mTarget;
double x, y, z;
osg::EllipsoidModel em;
em.convertLatLongHeightToXYZ(osg::DegreesToRadians(latitude),
osg::DegreesToRadians(longitude),
height, x, y, z);
mTarget.setTrans(x, y, z);
osg::Matrix mConeRate = osg::Matrix::rotate(osg::Vec3d(0, 1, 0), (mTarget*m).getTrans());
mtCone->setMatrix(mConeRate);
}
}
}
void ConeWave::changeWaveBeamConeAppearance( osg::Vec4 color, osg::Vec4 lineColor, double lineWidth) {
WaveBeamConeCallBack* coneCallBack = dynamic_cast<WaveBeamConeCallBack*>(_waveBeamCone->getUpdateCallback());
if (coneCallBack != NULL) {
coneCallBack->m_color = color;
coneCallBack->m_lineColor = lineColor;
coneCallBack->m_lineWidth = lineWidth;
//创建材质对象
osg::ref_ptr<osg::Material> mat = new osg::Material;
//设置正面散射颜色
mat->setDiffuse(osg::Material::FRONT, color);//1.0, 0.0, 0.0, 0.3
//设置正面镜面颜色
mat->setSpecular(osg::Material::FRONT, color);//1.0, 0.0, 0.0, 0.3
coneCallBack->m_geode->getOrCreateStateSet()->setAttribute(mat.get());
if (lineWidth < 0.1) {
_waveBeamCone->addChild(coneCallBack->m_geode);
_waveBeamCone->removeChild(coneCallBack->m_nodeFX);
} else {
_waveBeamCone->removeChild(coneCallBack->m_geode);
_waveBeamCone->addChild(coneCallBack->m_nodeFX);
coneCallBack->m_nodeFX->setWireframeColor(lineColor);
coneCallBack->m_nodeFX->setWireframeLineWidth(lineWidth);
}
}
}

35
src/effects/ConeWave.h
View File

@ -1,5 +1,5 @@
#pragma once
/*
#include <osg/Matrix>
#include <osg/Array>
#include <osg/Geometry>
@ -62,3 +62,36 @@ private:
float radius_{ 10.0f };
};
*/
#pragma once
#include <osg/Node>
#include <osg/Geode>
#include <osg/MatrixTransform>
#include "viewer/UpdateRenderStd.h"
//三维实体的圆锥波束
class ConeWave : public osg::Geode
, public UpdateRenderStd {
public:
ConeWave();
~ConeWave();
void clearSelf() ;
void Render(double dt) override;
void createWaveBeamCone(osg::MatrixTransform* node,double angle, double length, osg::Vec4 color, osg::Vec4 lineColor, double lineWidth);
void changeWaveBeamConeTarget(/*osg::MatrixTransform* mt,*/ double latitude, double longitude, double height, bool ifDynamic);
void changeWaveBeamConeAppearance(osg::Vec4 color, osg::Vec4 lineColor, double lineWidth);
osg::ref_ptr<osg::MatrixTransform> getWaveBeamCone() {
return _waveBeamCone;
}
private:
osg::ref_ptr<osg::MatrixTransform> _waveBeamCone;
};

38
src/entities/ConeWaveComponent.cpp
View File

@ -13,8 +13,8 @@
ConeWaveComponent::ConeWaveComponent(SceneComponent* parent)
: SceneComponent(parent) {
coneWave_ = new ConeWave();
coneWave_->InitGeode();
// coneWave_ = new ConeWave();
// coneWave_->InitGeode();
colorMap_[1] = osg::Vec4(1.0f, 1.0f, 1.0f, 1.0f);
colorMap_[2] = osg::Vec4(1.0f, 1.0f, 1.0f, 1.0f);
@ -22,7 +22,7 @@ ConeWaveComponent::ConeWaveComponent(SceneComponent* parent)
}
ConeWaveComponent::~ConeWaveComponent() {
coneWave_->Destory();
// coneWave_->Destory();
}
std::string ConeWaveComponent::GetTypeName() {
@ -84,46 +84,48 @@ void ConeWaveComponent::Update(double dt) {
}
void ConeWaveComponent::SetHeight(float height) {
coneWave_->SetHeight(height);
if (nullptr != mt_) {
mt_->setMatrix(osg::Matrix::translate(osg::Vec3(0.0f, 0.0f, -coneWave_->GetHeght() * 0.75f)));
}
// coneWave_->SetHeight(height);
// if (nullptr != mt_) {
// mt_->setMatrix(osg::Matrix::translate(osg::Vec3(0.0f, 0.0f, -coneWave_->GetHeght() * 0.75f)));
// }
}
float ConeWaveComponent::GetHeight() const {
return coneWave_->GetHeght();
return 0;// coneWave_->GetHeght();
}
void ConeWaveComponent::SetRadius(float radius) {
coneWave_->SetRadius(radius);
// coneWave_->SetRadius(radius);
}
float ConeWaveComponent::GetRadius() const {
return coneWave_->GetRadius();
return 0;// return coneWave_->GetRadius();
}
void ConeWaveComponent::SetLevelCount(int count) {
coneWave_->SetLevelCount(count);
// coneWave_->SetLevelCount(count);
}
float ConeWaveComponent::GetLevelCount() const {
return coneWave_->GetLevelCount();
return 0; // return coneWave_->GetLevelCount();
}
void ConeWaveComponent::SetLevelHeight(float height) {
coneWave_->SetLevelHeight(height);
// coneWave_->SetLevelHeight(height);
}
float ConeWaveComponent::GetLevelHeight() const {
return coneWave_->GetLevelHeihgt();
// return coneWave_->GetLevelHeihgt();
return 0.0f;
}
void ConeWaveComponent::SetBaseColor(const osg::Vec4& color) {
coneWave_->SetBaseColor(color);
// coneWave_->SetBaseColor(color);
}
const osg::Vec4 ConeWaveComponent::GetBaseColor() const {
return coneWave_->GetBaseColor();
// return coneWave_->GetBaseColor();
return osg::Vec4();
}
void ConeWaveComponent::SetColor1(const osg::Vec4& color) {
@ -170,7 +172,7 @@ void ConeWaveComponent::AddToRender() {
void ConeWaveComponent::Initialize() {
mt_ = new osg::MatrixTransform;
mt_->addChild(coneWave_);
mt_->setMatrix(osg::Matrix::translate(osg::Vec3(0.0f, 0.0f, -coneWave_->GetHeght() * 0.75f)));
// mt_->setMatrix(osg::Matrix::translate(osg::Vec3(0.0f, 0.0f, -coneWave_->GetHeght() * 0.75f)));
}
void ConeWaveComponent::UpdateEvent() {
@ -198,7 +200,7 @@ void ConeWaveComponent::UpdateEvent() {
}
osg::Vec4& color = colorMap_[currentStatus_];
coneWave_->SetBaseColor(color);
// coneWave_->SetBaseColor(color);
coneWave_->setNodeMask(0xff);

13
src/scene/OEScene.cpp
View File

@ -21,6 +21,8 @@
#include "viewer/OsgCameraManipulator.h"
#include "scene/ScaleBarHandler.h"
#include "effects/ConeWave.h"
const osgEarth::SpatialReference* g_srs_{ nullptr };
@ -93,6 +95,17 @@ void OEScene::AttachView(OsgView* view) {
logarithmicDepthBuffer_->install(view->GetView()->getCamera());
ConeWave* coneWave = new ConeWave;
osgEarth::GeoTransform *geo = new osgEarth::GeoTransform;
entityRoot_->addChild(geo);
osgEarth::GeoPoint pos(g_srs_, 120.000000,25.000000,600.000000);
geo->setPosition(pos);
coneWave->createWaveBeamCone(geo, 45, 6000, osg::Vec4(1.0, 0.0, 0.0, 0.3),
osg::Vec4(1.0, 1.0, 0.0, 0.3), 30);
osg::MatrixTransform* mt =coneWave->getWaveBeamCone();
geo->addChild(mt);
}
void OEScene::DetachView(OsgView* view) {

4
src/scene/ui/OESceneUI.cpp
View File

@ -28,9 +28,9 @@ void OESceneUI::InitUI(OsgViewUI* ui) {
}
compositeWidgetManager_ = new CompositeWidgetManager();
//compositeWidgetManager_->AttachViewUI(ui);
compositeWidgetManager_->AttachViewUI(ui);
zoomManager_ = new ZoomManager();
//zoomManager_->AttachViewUI(ui);
zoomManager_->AttachViewUI(ui);
queryElevationWidget_ = new QueryElevationWidget(oeScene_);
queryElevationWidget_->AttachViewUI(ui);

18
src/translations/Dyt_zh_CN.ts
View File

@ -1770,22 +1770,4 @@
<translation>保存空间目录</translation>
</message>
</context>
<context>
<name>osgQOpenGLWidget</name>
<message>
<location filename="../viewer/osgQOpenGLWidget.cpp" line="104"/>
<source>Screen %1</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../viewer/osgQOpenGLWidget.cpp" line="114"/>
<source>Choose fullscreen target screen</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../viewer/osgQOpenGLWidget.cpp" line="114"/>
<source>Screen</source>
<translation type="unfinished"></translation>
</message>
</context>
</TS>

12
src/ui/MainWindow.cpp
View File

@ -204,6 +204,7 @@ void MainWindow::InitDockLayout() {
QString strTabName = mapTab.value("Name").toString();
QMainWindow* mainWindow_ = new QMainWindow;
connect(mainWindow_, &QMainWindow::tabifiedDockWidgetActivated, this, &MainWindow::OnTabifiedDockWidgetActivated);
QVariantList listDocArea = mapTab.value("Widget").toList();
@ -329,6 +330,17 @@ void MainWindow::AddDockArea(const QString& strArea) {
resizeDocks(listAdd, listSpliter, orient);
}
void MainWindow::OnTabifiedDockWidgetActivated(QDockWidget* dockWidget) {
if (dockWidget) {
QMainWindow* mainWindow = qobject_cast<QMainWindow*>(dockWidget->parentWidget());
if (mainWindow) {
mainWindow->removeDockWidget(dockWidget);
}
// tabWidget_->setCurrentWidget(dockWidget->parentWidget());
}
}
void MainWindow::slotShowUISetting() {
pSettingUI->show();
}

2
src/ui/MainWindow.h
View File

@ -47,7 +47,7 @@ private:
void AddDockArea(const QString& strArea);
protected:
void OnTabifiedDockWidgetActivated(QDockWidget* dockWidget);
private:
Ui::MainWindow* ui;

417
src/viewer/OSGRenderer.cpp
View File

@ -15,8 +15,6 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include "viewer/OSGRenderer.h"
#include "viewer/osgQOpenGLWindow.h"
#include "viewer/osgQOpenGLWidget.h"
//#include <osgQOpenGL/CullVisitorEx>
//#include <osgQOpenGL/GraphicsWindowEx>
@ -115,398 +113,147 @@ namespace
static QtKeyboardMap s_QtKeyboardMap;
} // namespace
OSGRenderer::OSGRenderer(QObject* parent)
: QObject(parent), osgViewer::Viewer()
OSGRenderer::OSGRenderer(QObject *parent)
: QObject(parent)
, m_osgInitialized(false)
, m_windowScale(1.f)
, m_continuousUpdate(true)
{
// QObject::connect(QCoreApplication::instance(), &QCoreApplication::aboutToQuit,
// [this]()
// {
// _applicationAboutToQuit = true;
// killTimer(_timerId);
// _timerId = 0;
// });
}
OSGRenderer::OSGRenderer(osg::ArgumentParser* arguments, QObject* parent)
: QObject(parent), osgViewer::Viewer(*arguments)
void OSGRenderer::render()
{
// QObject::connect(QCoreApplication::instance(), &QCoreApplication::aboutToQuit,
// [this]()
// {
// _applicationAboutToQuit = true;
// killTimer(_timerId);
// _timerId = 0;
// });
}
OSGRenderer::~OSGRenderer()
{
}
void OSGRenderer::update()
{
osgQOpenGLWindow* osgWidgetRendered = dynamic_cast<osgQOpenGLWindow*>(parent());
if(osgWidgetRendered != nullptr)
{
osgWidgetRendered->_osgWantsToRenderFrame = true;
osgWidgetRendered->update();
}
else
{
osgQOpenGLWidget* osgWidget = dynamic_cast<osgQOpenGLWidget*>(parent());
osgWidget->_osgWantsToRenderFrame = true;
osgWidget->update();
}
if (m_osgViewer.getSceneData())
m_osgViewer.frame();
if (m_continuousUpdate)
update();
}
void OSGRenderer::resize(int windowWidth, int windowHeight, float windowScale)
{
if(!m_osgInitialized)
if (!m_osgInitialized)
return;
m_windowScale = windowScale;
/* _camera->setViewport(new osg::Viewport(0, 0, windowWidth * windowScale,
windowHeight * windowScale));*/
m_osgWinEmb->resized(0, 0,
windowWidth * windowScale,
windowHeight * windowScale);
m_osgWinEmb->getEventQueue()->windowResize(0, 0,
windowWidth * windowScale,
windowHeight * windowScale);
update();
m_osgViewer.getCamera()->setViewport(new osg::Viewport(0, 0, windowWidth * windowScale,
windowHeight * windowScale));
m_osgWinEmb->resized(0, 0, windowWidth * windowScale, windowHeight * windowScale);
m_osgWinEmb->getEventQueue()->windowResize( 0, 0, windowWidth * windowScale,
windowHeight * windowScale );
}
void OSGRenderer::setupOSG(int windowWidth, int windowHeight, float windowScale)
{
m_osgInitialized = true;
m_windowScale = windowScale;
m_osgWinEmb = new osgViewer::GraphicsWindowEmbedded(0, 0,
windowWidth * windowScale, windowHeight * windowScale);
//m_osgWinEmb = new osgViewer::GraphicsWindowEmbedded(0, 0, windowWidth * windowScale, windowHeight * windowScale);
m_osgWinEmb = new osgViewer::GraphicsWindowEmbedded(0, 0, windowWidth * windowScale, windowHeight * windowScale);
// make sure the event queue has the correct window rectangle size and input range
m_osgWinEmb->getEventQueue()->syncWindowRectangleWithGraphicsContext();
_camera->setViewport(new osg::Viewport(0, 0, windowWidth * windowScale,
windowHeight * windowScale));
_camera->setGraphicsContext(m_osgWinEmb.get());
// disable key event (default is Escape key) that the viewer checks on each
// frame to see
// if the viewer's done flag should be set to signal end of viewers main
// loop.
setKeyEventSetsDone(0);
setReleaseContextAtEndOfFrameHint(false);
setThreadingModel(osgViewer::Viewer::SingleThreaded);
m_osgViewer.getCamera()->setViewport(new osg::Viewport(0, 0, windowWidth * windowScale, windowHeight * windowScale));
m_osgViewer.getCamera()->setGraphicsContext(m_osgWinEmb.get());
m_osgViewer.getCamera()->setClearColor(osg::Vec4(1., 1., 1., 1.));
m_osgViewer.setThreadingModel(osgViewer::Viewer::SingleThreaded);
osgViewer::Viewer::Windows windows;
getWindows(windows);
_timerId = startTimer(10, Qt::PreciseTimer);
_lastFrameStartTime.setStartTick(0);
m_osgViewer.getWindows(windows);
for(osgViewer::Viewer::Windows::iterator itr = windows.begin(); itr != windows.end(); ++itr)
{
(*itr)->getState()->setUseModelViewAndProjectionUniforms(true);
(*itr)->getState()->setUseVertexAttributeAliasing(true);
}
}
void OSGRenderer::setKeyboardModifiers(QInputEvent* event)
void OSGRenderer::setKeyboardModifiers( QInputEvent* event ) const
{
unsigned int modkey = event->modifiers() & (Qt::ShiftModifier |
Qt::ControlModifier |
Qt::AltModifier);
int modkey = event->modifiers() & (Qt::ShiftModifier | Qt::ControlModifier | Qt::AltModifier);
unsigned int mask = 0;
if(modkey & Qt::ShiftModifier) mask |= osgGA::GUIEventAdapter::MODKEY_SHIFT;
if(modkey & Qt::ControlModifier) mask |= osgGA::GUIEventAdapter::MODKEY_CTRL;
if(modkey & Qt::AltModifier) mask |= osgGA::GUIEventAdapter::MODKEY_ALT;
m_osgWinEmb->getEventQueue()->getCurrentEventState()->setModKeyMask(mask);
if ( modkey & Qt::ShiftModifier ) mask |= osgGA::GUIEventAdapter::MODKEY_SHIFT;
if ( modkey & Qt::ControlModifier ) mask |= osgGA::GUIEventAdapter::MODKEY_CTRL;
if ( modkey & Qt::AltModifier ) mask |= osgGA::GUIEventAdapter::MODKEY_ALT;
m_osgWinEmb->getEventQueue()->getCurrentEventState()->setModKeyMask( mask );
}
void OSGRenderer::keyPressEvent(QKeyEvent* event)
void OSGRenderer::keyPressEvent( QKeyEvent* event )
{
setKeyboardModifiers(event);
int value = s_QtKeyboardMap.remapKey(event);
m_osgWinEmb->getEventQueue()->keyPress(value);
setKeyboardModifiers( event );
int value = s_QtKeyboardMap.remapKey( event );
m_osgWinEmb->getEventQueue()->keyPress( value );
}
void OSGRenderer::keyReleaseEvent(QKeyEvent* event)
void OSGRenderer::keyReleaseEvent( QKeyEvent* event )
{
if(event->isAutoRepeat())
if( event->isAutoRepeat() )
{
event->ignore();
}
else
{
setKeyboardModifiers(event);
int value = s_QtKeyboardMap.remapKey(event);
m_osgWinEmb->getEventQueue()->keyRelease(value);
setKeyboardModifiers( event );
int value = s_QtKeyboardMap.remapKey( event );
m_osgWinEmb->getEventQueue()->keyRelease( value );
}
}
void OSGRenderer::mousePressEvent(QMouseEvent* event)
void OSGRenderer::mousePressEvent( QMouseEvent* event )
{
int button = 0;
switch(event->button())
switch ( event->button() )
{
case Qt::LeftButton:
button = 1;
break;
case Qt::MidButton:
button = 2;
break;
case Qt::RightButton:
button = 3;
break;
case Qt::NoButton:
button = 0;
break;
default:
button = 0;
break;
case Qt::LeftButton: button = 1; break;
case Qt::MidButton: button = 2; break;
case Qt::RightButton: button = 3; break;
case Qt::NoButton: button = 0; break;
default: button = 0; break;
}
setKeyboardModifiers(event);
m_osgWinEmb->getEventQueue()->mouseButtonPress(event->x() * m_windowScale,
event->y() * m_windowScale, button);
setKeyboardModifiers( event );
m_osgWinEmb->getEventQueue()->mouseButtonPress( event->x() * m_windowScale, event->y() * m_windowScale, button );
}
void OSGRenderer::mouseReleaseEvent(QMouseEvent* event)
void OSGRenderer::mouseReleaseEvent( QMouseEvent* event )
{
int button = 0;
switch(event->button())
switch ( event->button() )
{
case Qt::LeftButton:
button = 1;
break;
case Qt::MidButton:
button = 2;
break;
case Qt::RightButton:
button = 3;
break;
case Qt::NoButton:
button = 0;
break;
default:
button = 0;
break;
case Qt::LeftButton: button = 1; break;
case Qt::MidButton: button = 2; break;
case Qt::RightButton: button = 3; break;
case Qt::NoButton: button = 0; break;
default: button = 0; break;
}
setKeyboardModifiers(event);
m_osgWinEmb->getEventQueue()->mouseButtonRelease(event->x() * m_windowScale,
event->y() * m_windowScale, button);
setKeyboardModifiers( event );
m_osgWinEmb->getEventQueue()->mouseButtonRelease( event->x() * m_windowScale,
event->y() * m_windowScale, button );
}
void OSGRenderer::mouseDoubleClickEvent(QMouseEvent* event)
void OSGRenderer::mouseDoubleClickEvent( QMouseEvent* event )
{
int button = 0;
switch(event->button())
switch ( event->button() )
{
case Qt::LeftButton:
button = 1;
break;
case Qt::MidButton:
button = 2;
break;
case Qt::RightButton:
button = 3;
break;
case Qt::NoButton:
button = 0;
break;
default:
button = 0;
break;
case Qt::LeftButton: button = 1; break;
case Qt::MidButton: button = 2; break;
case Qt::RightButton: button = 3; break;
case Qt::NoButton: button = 0; break;
default: button = 0; break;
}
setKeyboardModifiers(event);
m_osgWinEmb->getEventQueue()->mouseDoubleButtonPress(event->x() * m_windowScale,
event->y() * m_windowScale, button);
setKeyboardModifiers( event );
m_osgWinEmb->getEventQueue()->mouseDoubleButtonPress( event->x() * m_windowScale, event->y() * m_windowScale, button );
}
void OSGRenderer::mouseMoveEvent(QMouseEvent* event)
void OSGRenderer::mouseMoveEvent( QMouseEvent* event )
{
setKeyboardModifiers(event);
m_osgWinEmb->getEventQueue()->mouseMotion(event->x() * m_windowScale,
event->y() * m_windowScale);
setKeyboardModifiers( event );
m_osgWinEmb->getEventQueue()->mouseMotion( event->x() * m_windowScale, event->y() * m_windowScale );
}
void OSGRenderer::wheelEvent(QWheelEvent* event)
void OSGRenderer::wheelEvent( QWheelEvent* event )
{
setKeyboardModifiers(event);
m_osgWinEmb->getEventQueue()->mouseMotion(event->x() * m_windowScale,
event->y() * m_windowScale);
setKeyboardModifiers( event );
m_osgWinEmb->getEventQueue()->mouseScroll(
event->orientation() == Qt::Vertical ?
(event->delta() > 0 ? osgGA::GUIEventAdapter::SCROLL_UP :
osgGA::GUIEventAdapter::SCROLL_DOWN) :
(event->delta() > 0 ? osgGA::GUIEventAdapter::SCROLL_LEFT :
osgGA::GUIEventAdapter::SCROLL_RIGHT));
}
bool OSGRenderer::checkEvents()
{
// check events from any attached sources
for(Devices::iterator eitr = _eventSources.begin();
eitr != _eventSources.end();
++eitr)
{
osgGA::Device* es = eitr->get();
if(es->getCapabilities() & osgGA::Device::RECEIVE_EVENTS)
{
if(es->checkEvents())
return true;
}
}
// get events from all windows attached to Viewer.
Windows windows;
getWindows(windows);
for(Windows::iterator witr = windows.begin();
witr != windows.end();
++witr)
{
if((*witr)->checkEvents())
return true;
}
return false;
}
bool OSGRenderer::checkNeedToDoFrame()
{
// check if any event handler has prompted a redraw
if(_requestRedraw)
return true;
if(_requestContinousUpdate)
return true;
// check if the view needs to update the scene graph
// this check if camera has update callback and if scene requires to update scene graph
if(requiresUpdateSceneGraph())
return true;
// check if the database pager needs to update the scene
if(getDatabasePager()->requiresUpdateSceneGraph())
return true;
// check if the image pager needs to update the scene
if(getImagePager()->requiresUpdateSceneGraph())
return true;
// check if the scene needs to be redrawn
if(requiresRedraw())
return true;
// check if events are available and need processing
if(checkEvents())
return true;
// and check again if any event handler has prompted a redraw
if(_requestRedraw)
return true;
if(_requestContinousUpdate)
return true;
return false;
}
// called from ViewerWidget paintGL() method
void OSGRenderer::frame(double simulationTime)
{
// limit the frame rate
if(getRunMaxFrameRate() > 0.0)
{
double dt = _lastFrameStartTime.time_s();
double minFrameTime = 1.0 / getRunMaxFrameRate();
if(dt < minFrameTime)
QThread::usleep(static_cast<unsigned int>(1000000.0 * (minFrameTime - dt)));
}
// avoid excessive CPU loading when no frame is required in ON_DEMAND mode
if(getRunFrameScheme() == osgViewer::ViewerBase::ON_DEMAND)
{
double dt = _lastFrameStartTime.time_s();
if(dt < 0.01)
OpenThreads::Thread::microSleep(static_cast<unsigned int>(1000000.0 *
(0.01 - dt)));
}
// record start frame time
_lastFrameStartTime.setStartTick();
// make frame
#if 1
osgViewer::Viewer::frame(simulationTime);
#else
if(_done) return;
// OSG_NOTICE<<std::endl<<"CompositeViewer::frame()"<<std::endl<<std::endl;
if(_firstFrame)
{
viewerInit();
if(!isRealized())
{
realize();
}
_firstFrame = false;
}
advance(simulationTime);
eventTraversal();
updateTraversal();
// renderingTraversals();
#endif
}
void OSGRenderer::requestRedraw()
{
osgViewer::Viewer::requestRedraw();
}
void OSGRenderer::timerEvent(QTimerEvent* /*event*/)
{
// application is about to quit, just return
if(_applicationAboutToQuit)
{
return;
}
// ask ViewerWidget to update 3D view
if(getRunFrameScheme() != osgViewer::ViewerBase::ON_DEMAND ||
checkNeedToDoFrame())
{
update();
}
event->orientation() == Qt::Vertical ?
(event->delta()>0 ? osgGA::GUIEventAdapter::SCROLL_UP : osgGA::GUIEventAdapter::SCROLL_DOWN) :
(event->delta()>0 ? osgGA::GUIEventAdapter::SCROLL_LEFT : osgGA::GUIEventAdapter::SCROLL_RIGHT) );
}

73
src/viewer/OSGRenderer.h
View File

@ -25,71 +25,42 @@ class QInputEvent;
class QKeyEvent;
class QMouseEvent;
class QWheelEvent;
namespace eveBIM
{
class ViewerWidget;
}
class OSGRenderer : public QObject, public osgViewer::Viewer
{
bool m_osgInitialized {false};
osg::ref_ptr<osgViewer::GraphicsWindow> m_osgWinEmb;
float m_windowScale {1.0f};
bool m_continuousUpdate {true};
int _timerId{0};
osg::Timer _lastFrameStartTime;
bool _applicationAboutToQuit {false};
bool _osgWantsToRenderFrame{true};
Q_OBJECT
friend class eveBIM::ViewerWidget;
class OSGRenderer : public QObject {
public:
explicit OSGRenderer(QObject* parent = nullptr);
explicit OSGRenderer(osg::ArgumentParser* arguments, QObject* parent = nullptr);
~OSGRenderer() override;
~OSGRenderer() override = default;
bool continuousUpdate() const
{
return m_continuousUpdate;
}
void setContinuousUpdate(bool continuousUpdate)
{
m_continuousUpdate = continuousUpdate;
}
osgViewer::Viewer *viewer() { return &m_osgViewer; }
virtual void keyPressEvent(QKeyEvent* event);
virtual void keyReleaseEvent(QKeyEvent* event);
virtual void mousePressEvent(QMouseEvent* event);
virtual void mouseReleaseEvent(QMouseEvent* event);
virtual void mouseDoubleClickEvent(QMouseEvent* event);
virtual void mouseMoveEvent(QMouseEvent* event);
virtual void wheelEvent(QWheelEvent* event);
bool continuousUpdate() const { return m_continuousUpdate; }
void setContinuousUpdate(bool continuousUpdate) { m_continuousUpdate = continuousUpdate; }
virtual void keyPressEvent( QKeyEvent* event );
virtual void keyReleaseEvent( QKeyEvent* event );
virtual void mousePressEvent( QMouseEvent* event );
virtual void mouseReleaseEvent( QMouseEvent* event );
virtual void mouseDoubleClickEvent( QMouseEvent* event );
virtual void mouseMoveEvent( QMouseEvent* event );
virtual void wheelEvent( QWheelEvent* event );
virtual void update() {}
virtual void render();
virtual void resize(int windowWidth, int windowHeight, float windowScale);
void setupOSG(int windowWidth, int windowHeight, float windowScale);
// overrided from osgViewer::Viewer
virtual bool checkNeedToDoFrame() override;
// overrided from osgViewer::ViewerBase
void frame(double simulationTime = USE_REFERENCE_TIME) override;
// overrided from osgViewer::Viewer
void requestRedraw() override;
// overrided from osgViewer::Viewer
bool checkEvents() override;
void update();
protected:
void setKeyboardModifiers( QInputEvent* event ) const;
protected:
void timerEvent(QTimerEvent* event) override;
void setKeyboardModifiers(QInputEvent* event);
bool m_osgInitialized;
osg::ref_ptr<osgViewer::GraphicsWindowEmbedded> m_osgWinEmb;
osgViewer::Viewer m_osgViewer;
float m_windowScale;
bool m_continuousUpdate;
};

14
src/viewer/OSGRendererImpl.cpp Normal file
View File

@ -0,0 +1,14 @@
#include "viewer/OSGRendererImpl.h"
#include "OsgWidget.h"
OSGRendererImpl::OSGRendererImpl(QObject* parent)
: OSGRenderer(parent) {}
void OSGRendererImpl::update() {
OSGRenderer::update();
if (nullptr != widget_) {
widget_->update();
}
}

20
src/viewer/OSGRendererImpl.h Normal file
View File

@ -0,0 +1,20 @@
#pragma once
#include "viewer/OSGRenderer.h"
class OsgWidget;
class OSGRendererImpl : public OSGRenderer {
public:
explicit OSGRendererImpl(QObject *parent = 0);
~OSGRendererImpl() override = default;
void setup(OsgWidget* w) {
widget_ = w;
}
void update() override;
private:
OsgWidget* widget_{nullptr};
};

9
src/viewer/OsgViewer.cpp
View File

@ -17,13 +17,16 @@ template<> OsgViewer* Singleton<OsgViewer>::instance_ = nullptr;
constexpr QEvent::Type sOsgViewUpdateEvent{ QEvent::Type(QEvent::User + 1) };
OsgViewer::OsgViewer(QObject* parent) noexcept
: QObject(parent)
, compositeViewer_(new osgViewer::CompositeViewer) {
: QObject(parent) {
LOG_INFO("actor, self={}", fmt::ptr(this));
compositeViewer_->setKeyEventSetsDone(0);
//compositeViewer_->getDatabasePager()->setUnrefImageDataAfterApplyPolicy(true, false);
osgEarth::initialize();
compositeViewer_ = new osgViewer::CompositeViewer;
compositeViewer_->setReleaseContextAtEndOfFrameHint(false);
compositeViewer_->setKeyEventSetsDone(0);
osgDB::Registry::instance()->getObjectWrapperManager()->findWrapper("osg::Image");
// compositeViewer_->getDatabasePager()->setUnrefImageDataAfterApplyPolicy( true, false );
compositeViewer_->setThreadingModel(osgViewer::ViewerBase::ThreadingModel::SingleThreaded);
}

71
src/viewer/OsgWidget.cpp Normal file
View File

@ -0,0 +1,71 @@
#include "viewer/OsgWidget.h"
#include <QApplication>
#include <QWindow>
#include <QScreen>
#include "viewer/OSGRendererImpl.h"
OsgWidget::OsgWidget(QWidget* parent)
: QOpenGLWidget(parent)
, renderer_(nullptr)
{
}
void OsgWidget::initializeGL()
{
renderer_ = new OSGRendererImpl(this);
renderer_->setup(this);
QScreen *screen = windowHandle() && windowHandle()->screen() ? windowHandle()->screen() : qApp->screens().front();
renderer_->setupOSG(width(), height(), screen->devicePixelRatio());
emit initialized();
}
void OsgWidget::resizeGL(int w, int h)
{
QScreen *screen = windowHandle() && windowHandle()->screen() ? windowHandle()->screen() : qApp->screens().front();
renderer_->resize(w, h, screen->devicePixelRatio());
}
void OsgWidget::paintGL()
{
renderer_->render();
}
void OsgWidget::keyPressEvent(QKeyEvent *event)
{
renderer_->keyPressEvent(event);
}
void OsgWidget::keyReleaseEvent(QKeyEvent *event)
{
renderer_->keyReleaseEvent(event);
}
void OsgWidget::mousePressEvent(QMouseEvent *event)
{
renderer_->mousePressEvent(event);
}
void OsgWidget::mouseReleaseEvent(QMouseEvent *event)
{
renderer_->mouseReleaseEvent(event);
}
void OsgWidget::mouseDoubleClickEvent(QMouseEvent *event)
{
renderer_->mouseDoubleClickEvent(event);
}
void OsgWidget::mouseMoveEvent(QMouseEvent *event)
{
renderer_->mouseMoveEvent(event);
}
void OsgWidget::wheelEvent(QWheelEvent *event)
{
renderer_->wheelEvent(event);
}

30
src/viewer/OsgWidget.h Normal file
View File

@ -0,0 +1,30 @@
#pragma once
#include <QOpenGLWidget>
class OSGRendererImpl;
class OsgWidget : public QOpenGLWidget {
Q_OBJECT
public:
OsgWidget(QWidget *parent = nullptr);
signals:
void initialized();
protected:
void initializeGL() override;
void resizeGL(int w, int h) override;
void paintGL() override;
void keyPressEvent( QKeyEvent* event ) override;
void keyReleaseEvent( QKeyEvent* event ) override;
void mousePressEvent( QMouseEvent* event ) override;
void mouseReleaseEvent( QMouseEvent* event ) override;
void mouseDoubleClickEvent( QMouseEvent* event ) override;
void mouseMoveEvent( QMouseEvent* event ) override;
void wheelEvent( QWheelEvent* event ) override;
private:
OSGRendererImpl *renderer_;
};

223
src/viewer/osgQOpenGLWidget.cpp
View File

@ -1,223 +0,0 @@
#include "viewer/osgQOpenGLWidget.h"
#include "viewer/OSGRenderer.h"
#include <osgViewer/Viewer>
#include <osg/GL>
#include <QApplication>
#include <QKeyEvent>
#include <QInputDialog>
#include <QLayout>
#include <QMainWindow>
#include <QScreen>
#include <QWindow>
osgQOpenGLWidget::osgQOpenGLWidget(QWidget* parent)
: QOpenGLWidget(parent)
{
}
osgQOpenGLWidget::osgQOpenGLWidget(osg::ArgumentParser* arguments,
QWidget* parent) :
QOpenGLWidget(parent),
_arguments(arguments)
{
}
osgQOpenGLWidget::~osgQOpenGLWidget()
{
}
osgViewer::Viewer* osgQOpenGLWidget::getOsgViewer()
{
return m_renderer;
}
OpenThreads::ReadWriteMutex* osgQOpenGLWidget::mutex()
{
return &_osgMutex;
}
void osgQOpenGLWidget::initializeGL()
{
// Initializes OpenGL function resolution for the current context.
initializeOpenGLFunctions();
createRenderer();
emit initialized();
}
void osgQOpenGLWidget::resizeGL(int w, int h)
{
Q_ASSERT(m_renderer);
QScreen* screen = windowHandle()
&& windowHandle()->screen() ? windowHandle()->screen() :
qApp->screens().front();
m_renderer->resize(w, h, screen->devicePixelRatio());
}
void osgQOpenGLWidget::paintGL()
{
OpenThreads::ScopedReadLock locker(_osgMutex);
if (_isFirstFrame) {
_isFirstFrame = false;
m_renderer->getCamera()->getGraphicsContext()->setDefaultFboId(defaultFramebufferObject());
}
m_renderer->frame();
}
void osgQOpenGLWidget::keyPressEvent(QKeyEvent* event)
{
Q_ASSERT(m_renderer);
if(event->key() == Qt::Key_F)
{
static QSize g;
static QMargins sMargins;
if(parent() && parent()->isWidgetType())
{
QMainWindow* _mainwindow = dynamic_cast<QMainWindow*>(parent());
if(_mainwindow)
{
g = size();
if(layout())
sMargins = layout()->contentsMargins();
bool ok = true;
// select screen
if(qApp->screens().size() > 1)
{
QMap<QString, QScreen*> screens;
int screenNumber = 0;
for(QScreen* screen : qApp->screens())
{
QString name = screen->name();
if(name.isEmpty())
{
name = tr("Screen %1").arg(screenNumber);
}
name += " (" + QString::number(screen->size().width()) + "x" + QString::number(
screen->size().height()) + ")";
screens[name] = screen;
++screenNumber;
}
QString selected = QInputDialog::getItem(this,
tr("Choose fullscreen target screen"), tr("Screen"), screens.keys(), 0, false,
&ok);
if(ok && !selected.isEmpty())
{
context()->setScreen(screens[selected]);
move(screens[selected]->geometry().x(), screens[selected]->geometry().y());
resize(screens[selected]->geometry().width(),
screens[selected]->geometry().height());
}
}
if(ok)
{
// in fullscreen mode, a thiner (1px) border around
// viewer widget
if(layout())
layout()->setContentsMargins(1, 1, 1, 1);
setParent(0);
showFullScreen();
}
}
}
else
{
showNormal();
setMinimumSize(g);
QMainWindow* _mainwindow = dynamic_cast<QMainWindow*>(parent());
if(_mainwindow){
_mainwindow->setCentralWidget(this);
}
if(layout())
layout()->setContentsMargins(sMargins);
qApp->processEvents();
setMinimumSize(QSize(1, 1));
}
}
else // not 'F' key
{
// forward event to renderer
m_renderer->keyPressEvent(event);
}
}
void osgQOpenGLWidget::keyReleaseEvent(QKeyEvent* event)
{
Q_ASSERT(m_renderer);
// forward event to renderer
m_renderer->keyReleaseEvent(event);
}
void osgQOpenGLWidget::mousePressEvent(QMouseEvent* event)
{
Q_ASSERT(m_renderer);
// forward event to renderer
m_renderer->mousePressEvent(event);
}
void osgQOpenGLWidget::mouseReleaseEvent(QMouseEvent* event)
{
Q_ASSERT(m_renderer);
// forward event to renderer
m_renderer->mouseReleaseEvent(event);
}
void osgQOpenGLWidget::mouseDoubleClickEvent(QMouseEvent* event)
{
Q_ASSERT(m_renderer);
// forward event to renderer
m_renderer->mouseDoubleClickEvent(event);
}
void osgQOpenGLWidget::mouseMoveEvent(QMouseEvent* event)
{
Q_ASSERT(m_renderer);
// forward event to renderer
m_renderer->mouseMoveEvent(event);
}
void osgQOpenGLWidget::wheelEvent(QWheelEvent* event)
{
Q_ASSERT(m_renderer);
// forward event to renderer
m_renderer->wheelEvent(event);
}
void osgQOpenGLWidget::setDefaultDisplaySettings()
{
osg::DisplaySettings* ds = osg::DisplaySettings::instance().get();
ds->setNvOptimusEnablement(1);
ds->setStereo(false);
}
void osgQOpenGLWidget::createRenderer()
{
// call this before creating a View...
setDefaultDisplaySettings();
if (!_arguments) {
m_renderer = new OSGRenderer(this);
} else {
m_renderer = new OSGRenderer(_arguments, this);
}
QScreen* screen = windowHandle()
&& windowHandle()->screen() ? windowHandle()->screen() :
qApp->screens().front();
m_renderer->setupOSG(width(), height(), screen->devicePixelRatio());
}

88
src/viewer/osgQOpenGLWidget.h
View File

@ -1,88 +0,0 @@
#ifndef OSGQOPENGLWIDGET_H
#define OSGQOPENGLWIDGET_H
#ifdef __APPLE__
# define __glext_h_
# include <QtGui/qopengl.h>
# undef __glext_h_
# include <QtGui/qopenglext.h>
#endif
#include <OpenThreads/ReadWriteMutex>
#ifdef WIN32
//#define __gl_h_
#include <osg/GL>
#endif
#include <osg/ArgumentParser>
#include <QOpenGLWidget>
#include <QOpenGLFunctions>
#include <QReadWriteLock>
class OSGRenderer;
namespace osgViewer
{
class Viewer;
}
class osgQOpenGLWidget : public QOpenGLWidget,
protected QOpenGLFunctions
{
Q_OBJECT
protected:
OSGRenderer* m_renderer {nullptr};
bool _osgWantsToRenderFrame{true};
OpenThreads::ReadWriteMutex _osgMutex;
osg::ArgumentParser* _arguments {nullptr};
bool _isFirstFrame {true};
friend class OSGRenderer;
public:
osgQOpenGLWidget(QWidget* parent = nullptr);
osgQOpenGLWidget(osg::ArgumentParser* arguments, QWidget* parent = nullptr);
virtual ~osgQOpenGLWidget();
/** Get osgViewer View */
virtual osgViewer::Viewer* getOsgViewer();
//! get mutex
virtual OpenThreads::ReadWriteMutex* mutex();
//! override this to change default size or aspect ratio
QSize sizeHint() const override { return QSize(640,480); }
signals:
void initialized();
protected:
//! call createRender. If overloaded, this method must send initialized signal at end
void initializeGL() override;
void resizeGL(int w, int h) override;
//! lock scene graph and call osgViewer::frame()
void paintGL() override;
//! called before creating renderer
virtual void setDefaultDisplaySettings();
void keyPressEvent(QKeyEvent* event) override;
void keyReleaseEvent(QKeyEvent* event) override;
void mousePressEvent(QMouseEvent* event) override;
void mouseReleaseEvent(QMouseEvent* event) override;
void mouseDoubleClickEvent(QMouseEvent* event) override;
void mouseMoveEvent(QMouseEvent* event) override;
void wheelEvent(QWheelEvent* event) override;
void createRenderer();
private:
};
#endif // OSGQOPENGLWIDGET_H

126
src/viewer/osgQOpenGLWindow.cpp
View File

@ -1,126 +0,0 @@
#include "viewer/osgQOpenGLWindow.h"
#include "viewer/OSGRenderer.h"
#include <osgViewer/Viewer>
#include <osg/GL>
#include <QApplication>
#include <QKeyEvent>
#include <QInputDialog>
#include <QLayout>
#include <QMainWindow>
#include <QScreen>
#include <QWindow>
osgQOpenGLWindow::osgQOpenGLWindow(QWidget* parent)
: QOpenGLWindow(QOpenGLWindow::NoPartialUpdate, nullptr)
{
_widget = QWidget::createWindowContainer(this);
}
osgQOpenGLWindow::~osgQOpenGLWindow()
{
}
osgViewer::Viewer* osgQOpenGLWindow::getOsgViewer()
{
return m_renderer;
}
OpenThreads::ReadWriteMutex* osgQOpenGLWindow::mutex()
{
return &_osgMutex;
}
void osgQOpenGLWindow::initializeGL()
{
// Initializes OpenGL function resolution for the current context.
initializeOpenGLFunctions();
createRenderer();
emit initialized();
}
void osgQOpenGLWindow::resizeGL(int w, int h)
{
Q_ASSERT(m_renderer);
double pixelRatio = screen()->devicePixelRatio();
m_renderer->resize(w, h, pixelRatio);
}
void osgQOpenGLWindow::paintGL()
{
OpenThreads::ScopedReadLock locker(_osgMutex);
if (_isFirstFrame) {
_isFirstFrame = false;
m_renderer->getCamera()->getGraphicsContext()->setDefaultFboId(defaultFramebufferObject());
}
m_renderer->frame();
}
void osgQOpenGLWindow::keyPressEvent(QKeyEvent* event)
{
Q_ASSERT(m_renderer);
// forward event to renderer
m_renderer->keyPressEvent(event);
}
void osgQOpenGLWindow::keyReleaseEvent(QKeyEvent* event)
{
Q_ASSERT(m_renderer);
// forward event to renderer
m_renderer->keyReleaseEvent(event);
}
void osgQOpenGLWindow::mousePressEvent(QMouseEvent* event)
{
Q_ASSERT(m_renderer);
// forward event to renderer
m_renderer->mousePressEvent(event);
}
void osgQOpenGLWindow::mouseReleaseEvent(QMouseEvent* event)
{
Q_ASSERT(m_renderer);
// forward event to renderer
m_renderer->mouseReleaseEvent(event);
}
void osgQOpenGLWindow::mouseDoubleClickEvent(QMouseEvent* event)
{
Q_ASSERT(m_renderer);
// forward event to renderer
m_renderer->mouseDoubleClickEvent(event);
}
void osgQOpenGLWindow::mouseMoveEvent(QMouseEvent* event)
{
Q_ASSERT(m_renderer);
// forward event to renderer
m_renderer->mouseMoveEvent(event);
}
void osgQOpenGLWindow::wheelEvent(QWheelEvent* event)
{
Q_ASSERT(m_renderer);
// forward event to renderer
m_renderer->wheelEvent(event);
}
void osgQOpenGLWindow::setDefaultDisplaySettings()
{
osg::DisplaySettings* ds = osg::DisplaySettings::instance().get();
ds->setNvOptimusEnablement(1);
ds->setStereo(false);
}
void osgQOpenGLWindow::createRenderer()
{
// call this before creating a View...
setDefaultDisplaySettings();
m_renderer = new OSGRenderer(this);
double pixelRatio = screen()->devicePixelRatio();
m_renderer->setupOSG(width(), height(), pixelRatio);
}

86
src/viewer/osgQOpenGLWindow.h
View File

@ -1,86 +0,0 @@
#ifndef OSGQOPENGLWINDOW_H
#define OSGQOPENGLWINDOW_H
#ifdef __APPLE__
# define __glext_h_
# include <QtGui/qopengl.h>
# undef __glext_h_
# include <QtGui/qopenglext.h>
#endif
#include <OpenThreads/ReadWriteMutex>
#ifdef WIN32
//#define __gl_h_
#include <osg/GL>
#endif
#include <QOpenGLWindow>
#include <QOpenGLFunctions>
#include <QReadWriteLock>
class OSGRenderer;
class QWidget;
namespace osgViewer
{
class Viewer;
}
class osgQOpenGLWindow : public QOpenGLWindow,
protected QOpenGLFunctions
{
Q_OBJECT
protected:
OSGRenderer* m_renderer {nullptr};
bool _osgWantsToRenderFrame{true};
OpenThreads::ReadWriteMutex _osgMutex;
bool _isFirstFrame {true};
friend class OSGRenderer;
QWidget* _widget = nullptr;
public:
osgQOpenGLWindow(QWidget* parent = nullptr);
virtual ~osgQOpenGLWindow();
/** Get osgViewer View */
virtual osgViewer::Viewer* getOsgViewer();
//! get mutex
virtual OpenThreads::ReadWriteMutex* mutex();
QWidget* asWidget()
{
return _widget;
}
signals:
void initialized();
protected:
//! call createRender. If overloaded, this method must send initialized signal at end
void initializeGL() override;
void resizeGL(int w, int h) override;
//! lock scene graph and call osgViewer::frame()
void paintGL() override;
//! called before creating renderer
virtual void setDefaultDisplaySettings();
void keyPressEvent(QKeyEvent* event) override;
void keyReleaseEvent(QKeyEvent* event) override;
void mousePressEvent(QMouseEvent* event) override;
void mouseReleaseEvent(QMouseEvent* event) override;
void mouseDoubleClickEvent(QMouseEvent* event) override;
void mouseMoveEvent(QMouseEvent* event) override;
void wheelEvent(QWheelEvent* event) override;
void createRenderer();
};
#endif // OSGQOPENGLWINDOW_H