Don't resolve the empty file name, which would result in the fgdata
directory path (instead of a path to a file). Eventually this resulted in
a segfault, partly due to a bug in "osgDB::readImageFile", which reports
"success" when given a directory (instead of a file) path, though it
doesn't return a valid image object.
Since the message should help people doing textures to
provide texture files that run everywhere, do not omit
the messages just because the build platform did not
know these.
Print a descriptive warning on images that are given
in a texture format that do only work in presence of an
extension that might not be there at runtime.
Cut trailing separators when converting from string to sgpath.
Also, SGPath::fix does NOT replace ":". It only replaces "\" with "/",
so the "i!=1" check for Windows made no sense (rule #9: never believe
a source code comment).
This fixes a problem with fonts no longer being correctly
loaded as a side effect of the spt meta object loader.
The readObject slot is obviously being called for several
unrelated file extensions. To make sure the search continues,
osgDB::ReaderWriter::ReadResult::FILE_NOT_HANDLED needs to
be returned in this case.
Sound resources were eaten up when a sample could not be loaded.
Restores sound for aircraft attempting to use stereo files for sound effects.
However, when loading fails, sound code still tries to load the same file
again and again (always resulting in the same "stereo files not supported"
error), which slows down simulation.
Determine name of library installation directory, i.e. "lib" vs "lib64",
which differs between all Debian-based vs all other Linux distros.
See cmake bug #11964, http://cmake.org/gitweb?p=cmake.git;a=commit;h=126c993d
Also provide a script for older (<=2.8.4) cmake
Add method that schedules a ProxyNode to do
just deferred model loading instead of full scenery paging.
Add support for ProxyNodes to CheckSceneryVisitor.
Use PagedLOD instead of our own derived method.
Keep Nasal parser from crashing when "=" function misses a left-hand
element, i.e. when parsing "sin(=)".
(Or do people writing such terrible syntax deserve a crash? ;-) ).
Implement sleeping to an absolute timestamp
as well as sleeping for a relative time in
SGtimeStamp.
The reason for including this into SGTimeStamp
is that the timestamps internals are required to
do accurate sleeps to and absolute timestamp
for the posix timer implementation.
- Wrap 3D clouds (e.g. Global Weather) on the surface of a sphere rather than on a plane. Cloud altitude no-longer increases with distance from the start position
- Fix altitude of individual clouds, which where being places approx 1/2 the sprite height too high. Note that this means sprite positions in the cloud are the center of the cloud rather than the bottom.
- Improve LOD radii, which were far too large.
For all source directories outside of simgear/scene,
which really depends very hard on osg, avoid using osg
classes. This should reenable the use of some basic and
scenegraph independent parts of simgear without the
the need for osg.
Reimplement the threading stuff using either pthreads
or win32 threads. These simple classes should help us
to stay osg independent for simgears core classes.
This implements a function for the quaternion implementation
that computes the angular velocity that matches an explicit euler
step that propagates from a starting quaternion orientation to a
destination quaternion orientation.
Use standard path resolver when searching for includes. Includes like
<foo include="/Aircraft/Instruments/myfile.xml">
are now also supported - no need for
<foo include="../../../Aircraft/Instruments/myfile.xml">.
New feature for <condition> elements:
An (optional) element <precision> allows for fuzzy equals checks
example:
<condition>
<equals>
<property>/foo</property>
<value type="double">0.0</value>
<precision>0.1</precision>
</equals>
</condition>
This condition evaluates as true if /foo is within [-0.05..0.05]
(both inclusive)
The precision tag works for int, long, float and double propeties.
It has no meaning for bool properties. For string properties,
precision sets the length of the strings to compare.
1) Default values for [min|max]_[cloud|sprite]_[width|height] changed to be
more logical.
2) Cloud bounding box expanded slightly to ensure they aren't over-culled
3) Cloud location now defines the _base_ of the cloud.
4) Sprites that would extend below the bottom of the cloud are now shifted
upwards to ensure no cloud appears below the base.
File dialogs never showed ".." directories for navigation, since these were
filtered by the "INCLUDE_HIDDEN" option. Only the "NO_DOT_OR_DOTDOT"
option should be used for filtering - otherwise it's impossible to show
the "."/".." directories while all other files are still hidden.
Added missing CMake defines for SVN_CLIENT.
Don't detect libsvn without APR.
When installed, enable libsvn support by default (same as for automake).
When enabled, provide libsvn include dir to libtsync.
gitignore temporary CMake files
version.h is generated by the build system for official builds of
FlightGear. To avoid complicating the life of regular developers,
especially on Windows, we set HAVE_VERSION_H if version.h is generated.
If that define is not set, we include this file instead, which provides
placeholder values instead.
Changing and reverting the locale isn't thread-safe. Instead, setup the
environment to ensure the active locale sticks to default "C" locale at
any time.
Whenever resolving a (relative) path to an absolute path with
'findDataFile', check if the result is empty and report original
(relative) path as missing. Otherwise no or a meaningless message is
issued ("File '' not found.").
Ignore errors due to missing (ocean-)scenery data on SVN server.
For now, only refresh scenery tiles when ocean is replaced by actual
scenery data after download.
Change magic Nasal reftag to encode a quiet NaN (qNaN) instead of a
signaling NaN (sNaN), since sNaNs cannot pass cleanly through an FPU
(an sNaN is always converted to a qNaN, even by simple FPU load/store
instructions). gcc 4.5.x uses float load/store operations more
aggressively to move our 64bit Nasal variables (naRef) around.
Signed-off-by: Andy Ross
Due to fingertrouble, I removed the check for _step == 0 which
this patch re-adds.
Also, make this function look more like a template by not using
0.0 - constants.
msdn article 737550 states that "the preferred method is to call the
bind function to associate a socket with a local IP address and then
join the multicast group. Although this order of operations is not
mandatory, it is strongly recommended".
Since binding to the multicast address seems to fail, let's try binding
to INADDR_ANY and joint thereafter.
This class and their source files visual_enviro.[h|c]xx were
unused since OSG transition. It's only functionality was to
keep a variable for the enable-state of rendering of precipitation.
This has now been moved to SGPrecipitation.
Stuart Buchanan:
Improvements to the global 3D clouds system
- clouds now move with the wind
- bug causing cloud coverage to be less than it should have been fixed
- support for adding 3D clouds with an fg_command.
(https://gitorious.org/fg/flightgear/merge_requests/1554)
It's bad when tied properties are not untied before removing the tied property list.
We could try to "untie" the properties in the destructor - but that usually
caused weird mem access errors, since the tied properties will access
a no longer existing object (the very object whose destruction called the
TiedPropertyList destructor...). => so just add a warning and a nagging trap :)
Clearing the cache was disabled to avoid scenery reloading on sim resets,
which is now avoided elsewhere (in FG).
Cache cleaning is now needed to support new option for complete scenery
reloading.
SGMisc<T>::normalizePeriodic(min,max,value) returned zero for
all values less than min.
Example:
A call of normalizePeriodic(0,twopi(),-pi()) returned zero
where the correct value would be 3*pi().
Set OVERRIDE and PROTECTED attributes on pick animation state
attributes. Set up attributes and add a colorMode uniform so that the
default shader will take color and alpha values from the
material. Also, add a DotOsg writer method for ConditionNode.
The property path cache was making very little difference in practice
and made the eventual goal of having the property tree be thread safe
for readers more difficult to attain.
The evaluation of the condition is moved to a ConditionNode and
separated from the animation of values via properties. Previously the
conditional application of static values was broken.
When a sample's state constantly is "changed" (because sth. keeps updating the
sample in each update loop), then SGSampleGroup::update never ever checked if
the sample had already stopped playing by itself.
The attached patch reorders the last two conditions. It now first checks if a
sample has already stopped playing, before checking if there's sth to update.
vertex-program-two-sided is an extra parameter written by the code
that creates effects from state sets generated by the ac3d loader. The
objective of this work is to support a workaround for broken
gl_FrontFacing on some Macintosh machines.
Alex Perry: Adds a new pick animation capability which parallels the existing
"action" for a named object. Specifying "vncaction" and a transform
from model space will enable all mouse clicks on that object to be
delivered directly to the OSG image. Currently, the readers for VNC
and PDF files yield interactive images; more are likely to be added
over time.
http://files.goneabitbursar.com/fg/alut-osx-universal.zip
for testing purposes; autoconf integration and an official home for the
framework will follow once this approach has been tested and confirmed as
sane by other Mac developers!
Allow to declare sets of textures that can be used as parameters for effects. Syntax is:
<texture-set>
<texture>Terrain/city1.png</texture>
<texture n="2">Terrain/city1-relief-light.png</texture>
</texture-set>
<texture-set>
<texture>Terrain/city2.png</texture>
<texture n="2">Terrain/city2-relief-light.png</texture>
</texture-set>
These patches fixes minor bug in addition to providing --with-openal-framework and --with-cocoa-framework.
Now you can use your own version of OpenAL.framework for selecting various audio output device.
Plus, you can build FG/SG on Snow Leopard with cocoa configuration.
Changed include of SGQuat.hxx to SGMath.hxx in
sound/sample_openal.cxx; somehow this happened in a merge commit when
the sound branch was merged to next.
Normal geometry has a default effect; geometry with no default effect
is unlikely to look correct with no state set applied. This fixes the
problem of clouds being displayed as multi-colored rectangles when
shader effects are turned off.
This bug was the cause of the huge memory consumption / death reported at some places:
the BVH data on "raw" .ac models (random objects) was dropped on the floor.
Implement equality test and hash for for property trees. In an
Effect, make a hash table of Effects that inherit from it keyed on
their unmerged property tree. Using that, makeEffect() should return a
single Effect for given property tree description. Animations may
change that in the future...
Basically working, at last. Among other things, create effects in
models loaded directly from .ac files; this can happen, for example,
with the random models from the materials library.
Profiling startup with the new effects code exposed some performance
gotchas. The objective is to reduce allocation of std::string
temporaries, especially when looking up node path names. Also, I
changed some paths to initialize strings with strings instead of char *;
this causes less allocation, at least with glibc. Also, eliminate
the old version of find_node and its helper functions by writing the
template version of find_node_aux to handle an explicit index
parameter.
Also, add const char[] as an internal property type
This doesn't actually add a new type to the property system, but allows using
character arrays as arguments to certain templates.
groups not being activated (and sample loading using OpenAL/ALUT functions to
be scheduled before OpenAL was initilialized).
fix alutInit counter
remove left over static declaration fro SGSoundMgr::load
Improvements to the cloudsystem:
- A new xml format
- Texture indexing based on the position of the sprite in the cloud
mass, allowing more control over the texture set.
- Improved fog and shading
- Better sprite distribution
- A more natural distribution of clouds, so no more obvious grids.
Patches for configure.ac and Makefile.am files in FG/SG so Mac developers can build these in a unix way.
These also enables Mac developers to choose either PLIB framework or PLIB static libs.
Move dynamic casts to EffectGeode into the findMaterial method.
Modified Files:
simgear/scene/material/matlib.cxx
simgear/scene/material/matlib.hxx
simgear/scene/model/BoundingVolumeBuildVisitor.hxx
Make sure floating point constants do not introduce useless upcasts.
Remove now unused and not really usefull method.
Modified Files:
simgear/math/SGQuat.hxx
The (random) dimensions of a large number of trees is stored in an
array shared by all the tree geodes. The coordinates of the origin of
each tree are replicated in an another array. This allows an entire
block of trees to be rendered with a few OpenGL calls, instead of one
function call per tree.
As shown at LinuxTag, with modifications from Tim Moore: the base
landmass texture is mixed with the steepness and snow effects. Till's
new syntax for textures in effect files was also added. syntax for
textures. Also, syntax for accessing internal textures, such as Till's
3D noise texture, was added.
Several bugs in the effect inheritance algorithm were fixed.
The material code constructs a property list from its input parameters.
Enable dumping of Pass and Technique objects to a file.
Default effect now uses texture node instead of texture0
Polymorphic additions to expressions: Add an expression base class
with a method for dynamically determining the type of an expression.
Add variables, predicates and boolian expressions.
Support for parsing trees of expressions
An SGRawBase class has been added as a base class to the SGRawValue
hierarchy so that SGPropertyValue functions don't necessarily need to
know the type of the value stored in the node.
A new SGRawValueContainer class stores properties that shouldn't be
stored in the node itself. PropertyTraits indicates if a type is
stored in the property node or externally.
Add getValue and SetValue template member functions to SGPropertyNode.
Read and write new extended properties.
Rearrange props.hxx a bit so that the template magic actually works.
Split out extended raw value virtual functions into a seperate base class.
SGRawExtended is chosen as a base class of SGRawValue for extended property
types.
Change most uses of the SGPropertyNode _value union to use static_cast.
Move SGPropertyNode::Type out of the class into simgear::props namespace. Add
a PropertyTraits class so that templates can calculate the property type tag
based on a C++ type.
In destructor, delete _value.val if it is not 0 (and the property is not
aliased).
Extend SGAtomic with atomic exchange and add.
Import updates from the original implementation of that in OpenFDM.
Modified Files:
Makefile.am SGAtomic.cxx SGAtomic.hxx SGReferenced.hxx
SGSharedPtr.hxx
Added Files:
SGWeakPtr.hxx SGWeakReferenced.hxx
Make sg_throwable inherit from std::exception.
change exception objects to contain C strings: exception objects should not
include objects, like std::string, whose copy constructor could throw.
Move call of SGModelData::modelLoaded directly into the xml reader.
Modified Files:
simgear/scene/model/SGPagedLOD.cxx
simgear/scene/model/modellib.hxx
simgear/scene/model/modellib.cxx
simgear/scene/model/SGReaderWriterXML.cxx
Should make the Nasal code for some xml models work again.
Modified Files:
simgear/scene/model/SGPagedLOD.cxx
simgear/scene/model/SGReaderWriterXML.cxx
simgear/scene/model/modellib.cxx
simgear/scene/model/modellib.hxx
support cartesian waypoints and compute distance off a cartesian route.
Add a helper to access the total route distance.
Should not cause any visible functionality change.
for the modelLoaded call. MAy be this needs to be revisited, but in any
case better than constant zero.
Modified Files:
simgear/scene/model/SGPagedLOD.cxx
simgear/scene/model/modellib.cxx
(this frees the xml property loader from keeping track of the number of
nodes with the same name that have already been added to the property
tree).
* make some small code cleanups at the core of the property tree.
- turn four #include paths from the "foo" form to <foo>
The quotes form is normally only used for headers with path relative
to the including file's path, though the standard doesn't strictly
mandate this. This is consistent with the rest of sg, it makes the
code's intent clearer and helps to find headers. (And it's a few
milliseconds faster, too.)
This patch changes the shader so the diffuse light element is applied based on the co-linearity of the light vector and the viewing vector. I think this makes sense, as the tree textures don't represent a surface themselves.
set_bucket computed false left border, if the span was greater than 1, longitudes were less than zero
and longitudes were within SG_EPSILON on a full degree. Example: -179.0, +87.5 returned -176, 87
but should return -180, 87.
Discovered by Brian Schack
... I (Mathias Froehlich), believe that it is more performant (for the GPU) to
build the biggest indexed sets possible at the expense of tight culling.
I (Mathias Froehlich) also know that the CPU is more performant on smaller chunks
building the old flat groundcache on such tiles. :)
So this code *was* to balance these two contrary requirements to some degree.
Now we have optimized datastructures for drawing and differently optimized
datastructures for intersection tests.
Modified Files:
simgear/scene/tgdb/obj.cxx
This way the bounding boxes for this geometry is slightly smaller.
Helps ground intersection stuff to avoid the ocean triangles earlier.
Modified Files:
simgear/scene/tgdb/SGOceanTile.cxx
Refactor common code in the BoundingVolumeBuildVisitor.hxx.
Modified Files:
simgear/scene/model/BoundingVolumeBuildVisitor.hxx
simgear/scene/model/ModelRegistry.cxx
simgear/scene/model/ModelRegistry.hxx
Have a more general timestamp implementation.
Very useful for higher accuracy timings.
Modified Files:
simgear/structure/subsystem_mgr.cxx
simgear/structure/subsystem_mgr.hxx
simgear/timing/testtimestamp.cxx simgear/timing/timestamp.cxx
simgear/timing/timestamp.hxx
Add an id field to identify BVHMotionTransforms.
Provide a factory for ids.
Use that to identify velocity data.
Track the lowermost id in the visitors.
Modified Files:
simgear/scene/bvh/BVHLineSegmentVisitor.cxx
simgear/scene/bvh/BVHLineSegmentVisitor.hxx
simgear/scene/bvh/BVHMotionTransform.cxx
simgear/scene/bvh/BVHMotionTransform.hxx
simgear/scene/bvh/BVHNearestPointVisitor.hxx
simgear/scene/bvh/BVHNode.cxx simgear/scene/bvh/BVHNode.hxx
simgear/scene/util/SGSceneUserData.cxx
simgear/scene/util/SGSceneUserData.hxx
Remove that from the transforms.
Modified Files:
simgear/scene/model/placement.hxx
simgear/scene/model/placementtrans.cxx
simgear/scene/model/placementtrans.hxx
1. by using center/x-m and axis/[xyz]
2. by using axis/[xyz]1-m and axis/[xyz]2-m
The translate animation only supports method 1. and here comes a patch that
enables method 2 for this animations, too.
element to the io.stat() array, which has been sitting around on my
box for a while and doesn't seem to have broken anything." -- Andy
(forward port from nasal/cvs)
This can chew up large amounts of memory for questionable gains. We do
let the tree model geometry be in a display list if OSG chooses to put
it there.
Various renaming and cleanup. Save some memory by reverting
ShaderGeometry's base class back to osg::Drawable.
pun intended) that I'm touching the time library.
Brian Schack reported that the traffic scheduler messes up the timestamps
of the atlas network output. As it turns out, the c library functions
asctime, and gmtime use a static copy of the tm struct to do the internal
formatting. Our linux port of the SGTime class, incidentally, also stored
it's master time stamp in this very same struct. Thus, formatting an
arbitrary time value, would have the unwanted side effect of time travel.
Usually, this would go unnoticed, because the actual time parameters would
be updated before any damage could be done. But unwanted side effects, as
in Brian's example could occur.
On the MSVC port this appears to not have been a problem. Since that port
used a copy of the tm struct to store it's master time stamps. Since the
MSVC code also compiles cleanly on linux, it seems to be the way to go to
use that approach. In addition, it also removes some conditional compile
directives.
I've only run a short test, but didn't see any undesirable side effects.
This reverts back in the direction of Yon's original patch: the model is
drawn within ShaderGeometry::drawImplementation. This saves a lot of memory
over the previous approach of creating a PrimitiveSet for each model.
Attached is yet another 3D clouds patch, to fix the following:
1) The 3D clouds were not modified by the cloud coverage, due to some problems with osg::Switch
2) METAR changes to cloud coverage were not obeyed.
3) Making changes via the Cloud dialog had no effect unless 3D clouds were toggled.
4) Cloud cover was too sparse.
5) 3D Stratus clouds caused performance issues on some hardware (fixed by removing 3D stratus from cloudlayers.xml - it will now be a 2D layer).
- Removes the cloud type re-use code - I think they aren't worth the graphical artefacts that they cause in light of Tim's improvements
- Changes the transparency of the clouds. Previously, the clouds were transparent at 0m distance, opaque at 200m, then gradually more transparent to the fog limits. This meant they were generally quite transparent. Now, they are opaque from 200m to 15km, then become transparent at 20km. A side effect of this is that the current textures could probably benefit from being made slightly transparent to improve the blending of the sprites against each other.
- Replaces simple shader attributes with vectors (this was missed out of the last patch by mistake)
- Includes Yon's Fog update code (Thanks!)
- Fixes a bug since 1.0 where --enable-real-weather-fetch stopped the other weather scenarios from working.
This provides the following enhancements & bug fixes
- Fix the chequer-board bug.
- Add proper cloud coverage function - so scattered clouds are now truly scattered.
- Add real-time control for visibility range.
- Use a limited set of clouds rather than generating a completely new Geode for each cloud. This saves sorting and display time.
- Add controls to Rendering dialog to allow fine-tuning of the number of sprites, cloud visibility and the number of different types of cloud.
- Add some variance to the sort back-off to avoid all clouds being sorted at the same time.
- Pack attributes into vectors for performance
- Re-order the cloud type determination code so that if a cloud layer could either be stratus or cumulus, cumulus is used.
- Lowered the cloud level in the standard cloud configuration slightly so a cumulus layer is generated rather than stratus.
These last two mean that you should see some 3D cumuli if disabling real weather fetch.
My thanks to Yon Uriarte for his help with performance work.
Attached is another clouds patch. This does the following:
1) Puts the 3D clouds in a cloud rendering bin, to reduce the transparent edge problem. Viewing 3d clouds against a 2D layer _above_ it now blends correctly. There is still a problem when viewing a layer below the 3d clouds, and I'm not sure if/how I'll manage to solve that. Thanks to Tim for pointing me at the correct code (again).
2) Performance improvement by calculating the Bounding box when the cloud is generated rather than ever time it is requested.
> Something has changed in the environment manager which means that clouds
> generateion is now inconsistent. I'm still tracking it down, as my recent
> changes shouldn't have affected this.
Well, the cause was a bug in my code, but it didn't expose itself until we moved
to multiple cameras. The attached patch fixes the problem.
I've also put in a new heuristic to improve the frame-rate. Clouds that are already sorted
are likely to still be sorted in subsequent frames. Therefore I've put in a back-off
mechanism for the bubble-sort pass. This should mean that if you stay completely
stationary, once the clouds become sorted they will eventually only perform a
bubble sort pass every 128 frames.
> Warning: detected OpenGL error 'valeur non valide' after RenderBin::draw(,)
Fixed in the patch below. For some reason the shader didn't like index 16 being used...
The patch also fixes the chequer-board effect that was causing very sparse cloud cover.
Attached is a small patch for 3D clouds.
It provide the following:
1) Proper spherical distribution of sprites (previously they were distributed cylindrically - whoops)
2) Better shading, so the bottom of the cloud is darker than the top.
3) Fixed a couple of texture sizing bugs.
Attached is a small fix for the sorting in CloudShaderGeometry.cxx.
I think the sorting problem stems from the osg idiosyncracy
to store transposed matrices...so the intuitive
osg::Vec4f p = vm * osg::Vec4f(_cloudsprites[i]->position.osg(), 1.0f);
needs to be replaced with...
osg::Vec4f p = vm.preMult(osg::Vec4f(_cloudsprites[i]->position.osg(), 1.0f);
The patch also optimizes the distance calculation - it evaluates the distances
in model space instead of eye space, which reduces computation to a dot-
product instead of a matrix multiplication.
It fixes the following issues (to a greater or lesser extent):
1) Performance. Quad trees used to improve culling, and the sprites are placed on the surface of a sphere rather than
randomly throughout the cloud, requiring fewer textures. This saves about 5-10fps on my machine.
2) Disabled 3D clouds have no performance impact. Previously they were still in the scenegraph. Now they are removed.
3) Clouds are now loaded on start-up, and don't require the scenario to be changed, they also work with METAR.
4) The cloud field is shifted as you travel. There's a small bug in that the clouds "jump" as you reach the edge of the field.
5) Iterative sorting of sprites. This doesn't appear to solve the alpha blending problem completely, but may help a bit.
so hopefully not too much breaks). New syntax features:
1. Call-by-name function arguments. You can specify a hash literal in
place of ordered function arguments, and it will become the local
variable namespace for the called function, making functions with many
arguments more readable. Ex:
view_manager.lookat(heading:180, pitch:20, roll:0, x:X0, y:Y0, z:Z0,
time:now, fov:55);
Declared arguments are checked and defaulted as would be expected:
it's an error if you fail to pass a value for an undefaulted argument,
missing default arguments get assigned, and any rest parameter
(e.g. "func(a,b=2,rest...){}") will be assigned with an empty vector.
2. Vector slicing. Vectors (lists) can now be created from others
using an ordered list of indexes and ranges. For example:
var v1 = ["a","b","c","d","e"]
var v2 = v1[3,2]; # == ["d","c"];
var v3 = v1[1:3]; # i.e. range from 1 to 3: ["b","c","d"];
var v4 = v1[1:]; # no value means "to the end": ["b","c","d","e"]
var i = 2;
var v5 = v1[i]; # runtime expressions are fine: ["c"]
var v6 = v1[-2,-1]; # negative indexes are relative to end: ["d","e"]
The range values can be computed at runtime (e.g. i=1; v5=v1[i:]).
Negative indices work the same way the do with the vector functions
(-1 is the last element, -2 is 2nd to last, etc...).
3. Multi-assignment expressions. You can assign more than one
variable (or lvalue) at a time by putting them in a parenthesized
list:
(var a, var b) = (1, 2);
var (a, b) = (1, 2); # Shorthand for (var a, var b)
(var a, v[0], obj.field) = (1,2,3) # Any assignable lvalue works
var color = [1, 1, 0.5];
var (r, g, b) = color; # works with runtime vectors too
This eliminates jitter and other rendering problems.
For the moment this is dependent on an osg fix.
Also, don't read wind properties from FlightGear; provide a mechanism
for fg to set the wind.
It is not safe to call this function from the database pager thread;
in any event, state sets and textures created in the database pager
will get passed through the SharedStateManager anyway.
- this exposed a bizarre issue on Mac where dragging in <AGL/agl.h> in
extensions.hxx was pulling in all of Carbon to the global namespace
- very scary. As a result, I now need to explicitly include CoreFoundation
in fg_init.cxx.
- change SG_USING_STD(x) to using std::x
Issues:
- the logic for X11 and Win32 in RenderTexture and extensions is tortured,
please see if you agree I got all the ifdefs correct.
the MSVC and MipsPro warning stuff).
As a result of this patch, simgear/sg_traits.h can be deleted. So can SGCMath.h,
but I'll do that separately.
There is one more 'mechanical' change to come - getting rid of SG_USING_STD(X),
but I want to keep that separate from everything else. (There's another mechnica
l change, replacing <math.h> with <cmath> and so on *everywhere*, but one step a
t a time)
PLETE_FUNCTIONAL from SimGear and FlightGear.
As a result, SG_HAVE_STD_INCLUDES is now *always* set, so I will get the boring
fixes for that done, but separately. I'm still auditing the other things in comp
ilers.h - there's a lot that can die now BORLAND is gone.
<iostream> sucks in expensive initialization of the standard streams
and isn't appropriate in a header file. Use <istream> and <ostream>
instead.
using declarations should never appear at global scope in a header
file; source files get to decide what they want to use in their
namespace.
"tim recently noticed the database pager was repeatedly loading and unloading
the same objects. he also tracked down the problem to missing bounding sphere
information in osgDB::PagedLOD. this is a simplicistic approach to fix this:
SGPagedLOD will now remember whatever value it sees for getBound() after
loading a child. this patch will make database pager run much calmer."
It turns out that the database pager causes the texture image to be
unloaded after it is applied, so the image and its file name may not
be available for doing the livery substitution. Ask a work around we
set the name of the texture to its file name.
Also, add a NodeAndDrawableVisitor that descends into osg::Drawable.
That motivation for this is that it's a bad idea to modify state sets
that the osgDB::SharedStateManager might be keeping.
this is a small (-1/+3) patch to fix pick animations on scenery objects.
since picking apparently doesn't care for polygon offsets, the objects
got into the picklist in the wrong way. now, no matter if the "highlight
group" or the "normal group" gets hit first, the callback will fire.
Add more points to the dome, giving it a dome shape rather than a
dunce cap shape.
Represent as OpenGL DrawElements instead of as triangle strips.
Only calculate have the sky colors and reflect those across the dome.
The change to set the light group node mask to LIGHTS_BITS caused
VASI/PAPI lights to not be displayed during the day. This patch fixes
that and optimizes VASI creation a bit.
Comments from Till:
I started the project at the end of february with a simple idea: move all
3d-model loading to the DatabasePager-thread. my first attempts looked
promising, though they were a little too optimistic (or naive?). the patch
has evolved a lot since.
currently it does the following things:
1. revive SGModelLib, move functions for xml-model-loading there
2. replace all calls to sgLoad3dModel with calls to either
SGModelLib::loadModel() or SGModelLib::loadPagedModel()
almost all models will be loaded by the DatabasePager. the few exceptions are:
your own plane, shared models in scenery, random objects, AIBallistic models.
3. simplify mode-loading functions (avoid passing around fg_root)
4. avoid supurious MatrixTransform nodes in loaded models
5. fix some memory leaks
- make one-shot sounds subject to volume and pitch control (To get
constant volume/pitch during the whole lifetime, just *configure*
the sound that way.)
Reindent everything to Stroustrup style and make member variable style
consistent.
Remove unused header files.
SGPrecipitation is now a subclass of osg::Referenced.
Initialize snow and ice intensity to 0 directly. The methods that set
the intensities change the value slowly and so don't work when the
initial value is garbage.
The QuadTreeBuilder class was completely revamped as a templated class
to support flexible creation of scene graph quad trees, and a major
bug was fixed as well. Now it actually generates quadtrees instead of
some weird striped thing.
One StateSet is shared among all the "forests." The trees are drawn
after normal terrain objects to minimize some of the transparency
related artifacts.
Lighting was implemented in the ShaderGeometry shader (for both
polygon sides). Ambient-diffuse values for trees are hard-coded in
TreeBin.cxx.
DotOsg wrappers were added for ShaderGeometry so it can be output in
the scene graph dump.
In addition to Stuart's changes, there's an independent quad tree
builder class for constructing loose quad trees from scene graph nodes.
Stuart also implemented changes to the random number generator suggested by
Andy Ross.
Move point lights to render bin 8, clouds to render bin 9. Turn on
AlphaFunc for cloud layers.
Create a StateAttributeFactory object to create and share common state
objects.
Do away with the switch in each terrain tile for the ground lights. They are
turned on by node masks now.
Share state sets among all the light nodes and manage the fog values through a
"GroundLightManager" instead of having separate state sets and callback
functions for each group in each tile.
Create the local path in the right order in OptionsPusher. When
OptionsPusher is used, put it inside a new code block so the order of
destruction with respect to the mutex on reader functions id clear.
Add #include <algorithm> to top of ModelRegistry.cxx.
Change include syntax in PathOptions.cxx
The OSG reader plugins overwrite the path list passed in options with the local
directory of the file being read, forcing you to set the path list in
the Registry. I think this a bug, but in the meantime here's a workaround.
To set a path when loading model files, use an osg ReaderWriter::Options object.
Put locks in ModelRegistry::readNode and ModelRegistry::readImage to avoid
conflicts when files are loaded from both the pager and the main thread.
For the alpha-test animation, use an OVERRIDE attribute on the state
set of the top level node instead of copying drawables and state sets
throughout the model.
As a temporary hack in the blend animation, don't use display lists in
the cloned drawables.
These changes are aimed at cutting down the number of display lists
that the pager needs to compile.
In a big effort to improve use of the object cache, provide a
ModelRegistryCallback template class with different policies for
substitution, caching, optimization, etc.
Change SGTexDataVarianceVistor to make StateSets static too.
Move SGReadFileCallback and all its help classes into a new
ModelRegistry class that also provides an interface to add custom
callbacks for specific file extensions. SGReaderWriterBTG uses that to
keep any further processing from being done on .btg files. Various
namespace-releated cleanup was done on this code too.
Use only one shared StateSet to control GL_NORMALIZE. This removes
thousands of state sets from the scene graph.
Fix a typo that was causing two copies of groundLights0 to be added to
each tile.
When loading terrain, use DrawElementsUShort where possible.
Don't chunk unconnected triangles in the terrain into seperate
Geometry sets; make the sets as big as possible.
- Added a SampleStatistic class (from the old deprecated libg++) library.
- Make time statistics and printing conditionable
- Added an interface function to switch time stamp collection and printing
on and off from the application (defaults to off).
used short's extensively to represent counts of objects (number of points,
number of texture coordinates, number of traingle strips, etc.) and we used
shorts to index into larger structures. But this capped many of our structure
sizes to a maximum of 32768.
By switching to unsigned shorts in the future, we can double the maximum
object/index counts without losing anything. This was a pretty major
oversight in our original specification.
I have bumped up the native object file version from 6 to 7 and added code
in the reader to maintain full backwards compatibilty with version 6
scenery files (i.e. the current 0.9.10 scenery release.)
Curt.
* on cygwin, isnan is declared in ieeepf.h
* CYGWIN is a special case in that it is windows based, but sometimes
folows unix conventions. SGAtomic compilation failed on an illegal
volatile type cast without the additional __CYGWIN__ define check.
This fix removes obnoxious visuals (texture jumping) when a cloud
layer is moved due to a metar update or, more significantly, when
switching from metar to a scenario. Also, I switched to using a TexMat
to displace the cloud texture in order to avoid writing the texture
array every frame.
Put the ocean tile state set in osg::Geometry, not the osg::Geode, so that
is readily available during intersection testing and can be used to find the
corresponding SGMaterial.
Problem reported by grtux (gh.robin@laposte.net)
On 8/31/07, K. Hoercher <wbhoer@gmail.com> wrote:
> > Some notes:
> > - I found that in order to make the example from model-howto.html work
> > ( starting at "To make a texture replaceable at runtime") one has to
> > specify a valid (i.e. loadable) <texture> in the material animation.
The cause seems to be the condition in SGMaterialAnimation.cxx l.277
ignoring any texture update by the UpdateCallback (only there
<texture-prop> is looked at) without an already existing stateSet.
That in turn will not be created with a <texture-prop> alone l. 379ff.
Unless I overlooked some compelling reason contradicting, I'd like to
suggest allowing for a stateSet to be created for those situations
too. I think that would match the behaviour of animation.cxx
(PRE_OSG_PLIB_20061029) and is imho the more expected and also
documented one.
An apron around the tile hides cracks with coastal tiles.
The VectorArrayAdapter, which lives in the simgear namespace, is a useful
utility class for treating vectors as 2D arrays.
projects/VC7.1/SimGear.vcproj projects/VC8/SimGear.vcproj
simgear/math/Makefile.am simgear/math/SGGeoc.hxx
simgear/math/SGGeodesy.cxx simgear/math/SGGeodesy.hxx
simgear/math/polar3d.hxx simgear/math/sg_geodesy.hxx
simgear/math/sg_types.hxx
Removed Files:
simgear/math/polar3d.cxx simgear/math/sg_geodesy.cxx
simgear/math/sg_memory.h:
Remove sg_memory.h It is unused anyway and should not be required
in a c++ world. Move distance course functions to the SG* type
system. Move the implementation into SGGeodesy.cxx. Remove some of
the old Point3D Based sg* functions that are already unused.
The original code forced a dependency in SimGear back to something that is
defined globaly in FlightGear, not a great strategy for a library with some
"general purpose" intentions.
Print $CC and $CXX using the proper configure.ac mechanism
Author: Hans Ulrich Niedermann <hun@n-dimensional.de>
Signed-off-by: Tim Moore <timoore@redhat.com>
determine dependencies.
As in subdirectory foo/bar, $(top_builddir)/foo/bar is defined to be the
current directory, this does not cause any regressions.
From Hans Ulrich Niedermann (hun@n-dimensional.de)
mf: this patch is meant to be removed as soon as OpenAL got fixed. (The
OpenAL developers acknowleged the bug and announced that it'll get
fixed.) For removal try
$ cd simgear/sound
$ cvs diff -rAFTER_OPENAL_DOPPLER_WORKAROUND -rBEFORE_OPENAL_DOPPLER_WORKAROUND|patch
shouldn't be affected -- marker beep, ATIS messages, etc.)
mf: this is the first part of the original patch. It is supposed to contain
fixes that are not caused by OpenAL bugs, and thus aren't meant to be
reverted later. The second part will contain a temprary workaround for
OpenAL bugs. Unfortunately, I had to do the split myself as the contributor
refused to do it.
containing slashes, colons and all sorts of evil characters. In Nasal
this could be done via props.globals.getChild("1!@#$//[]{}", 0, 1).setValue(0);
The cause is that getChild() hands the given name directly over to an
alternative SGPropertyNode ("convenience") constructor which sets the
name without any checks.
- unify exception messages: first character is lower case
that interdependencies between sg libs are generally unwelcome, but
sg_exception is a rather basic part, and it's already used by xml, props,
scene, sound and, of course, structure. Since props and xml are core
libs, we can assume that sg_exceptions are available. (OK'ed by Curt)
simgear/scene/material/mat.cxx simgear/scene/material/mat.hxx
simgear/scene/util/SGSceneFeatures.cxx
simgear/scene/util/SGSceneFeatures.hxx:
Olaf Flebbe: Make use of SGSceneFeatues for anisotropic filtering,
clean up.
simgear/scene/model/model.cxx
simgear/scene/util/SGSceneFeatures.cxx
simgear/scene/util/SGSceneFeatures.hxx:
Make sure textures are shared. Do not rely on a graphics
context to be available on model loading.
FlightGear doesn't use. Also includes a performance fix for the
call() builtin that should help Melchior, who was measuring lower
performance for the props.Node() interface than the getprop/setprop
API.
a much more important feature than they were two years or something ago, and
it's helpful for debugging and exploration to get this important node property
shown in property tree dumps or in the property browser (verbose mode).
in with readProperties() would not look the same, because element indices
of '0' were even dropped when a node has a "secret" value *and* children
- introduce "omit-node" modifier attribute for the "include" attribute.
This inserts the given file in place of the including node, while the
node is dropped. This is desirable for multiple includes (which can't
be done by multiply using the "include" attribute, as this isn't valid
XML spec syntax)
- fix bug that messed up leg distances after inserting and deleting waypoints
not at the end of the route
- move add_waypoint() and delete_waypoint from hxx to cxx
- beef up routetest
So toss a runtime error ("floating point error") when any of the math
library functions produce a non-finite value. Note that these are not
the only locations that can do that (simply dividing by zero will
produce an Inf), but it's still proper behavior.
Nasal now supports calls to "subcontexts" and errors can be thrown
across them, leading to complete stack traces when call() is used,
instead of the truncated ones we now see.
Vectors can now be concatenated using the ~ operator that used to work
only for strings.
Better runtime error messages in general due to a fancier
naRuntimeError() implementation
A big data size shrink on 64 bit systems; the size of a naRef dropped
by a factor of two.
"Braceless code blocks" have been added to the parser, so you can
write expressions like "if(a) b();" just like in C. Note that there's
still a parser bug in there that fails when you nest a braced block
within a braceless one.
Character constants that appear in Nasal source code can now be
literal multibyte UTF8 characters (this was always supported for
string literals, but character constants were forced to be a single
byte).
New modules: "bits", "thread", "utf8" and (gulp...) "io". The bits
library might be useful to FlightGear, the utf8 one probably not as
Plib does not support wide character text rendering. The thread
library will work fine for spawning threads to do Nasal stuff, but
obviously contact with the rest of FlightGear must be
hand-synchronized as FlightGear isn't threadsafe. The io library is
no doubt the most useful, as it exposes all the basic stdio.h
facilities; it's also frighteningly dangerous when combined with
networked code...
that had been told that this node is linking to them
mf: remove old erase-by-key methods; they are now unused and always were
problematic, so they won't be used in the future either
- remove bad code from hash_table::bucket::erase(const char *) that was
introduced with the last patch. (This function isn't used anywhere and
is scheduled for removal. Leaving it in for now as a reference.)
- remove leaves first in remove_from_path_caches()
- cosmetics: indentation, one trailing space, variable name change, comment
(Sorrry for mixing that with actual code, but I think it's easy to see.)
"""
- make every node maintain list of properties that link to it
- add functions to erase node by address from hash bucket/entry in their
path caches, so that all references can be removed
- if a node is removed, it (and all children, grandchildren, ...) calls
all linked properties to remove them from their path-cache
This fixes problems with the aerotow over multiplayer and maybe some
other problems, where nodes are queried by name.
"""
ephemeris.cxx ephemeris.hxx stardata.cxx:
one must not do changes just before checkin,
one most not do changes just before checkin,
[ last message repeated 100 times ]
Makefile.am SGMathTest.cxx SGQuat.hxx SGVec3.hxx
Added Files:
SGBox.hxx SGGeometry.hxx SGGeometryFwd.hxx SGGeometryTest.cxx
SGIntersect.hxx SGLineSegment.hxx SGPlane.hxx SGRay.hxx
SGSphere.hxx SGTriangle.hxx:
Small updates to the vector code, new geometry and collision
classes for use with a bv tree to speed up collission tests.
Also included is a rought unit test for the collissions.
simgear/math/interpolater.cxx simgear/math/interpolater.hxx
simgear/props/condition.cxx simgear/props/condition.hxx
simgear/scene/model/animation.cxx
simgear/scene/model/animation.hxx: Optimize interpolation table
lookup by using a std::map.
simgear/scene/material/mat.cxx
simgear/scene/material/matlib.cxx simgear/scene/sky/cloud.cxx
simgear/scene/sky/dome.cxx simgear/scene/sky/moon.cxx
simgear/scene/sky/oursun.cxx simgear/scene/sky/sphere.cxx
simgear/scene/sky/stars.cxx simgear/scene/tgdb/apt_signs.cxx
simgear/scene/tgdb/leaf.cxx simgear/scene/tgdb/leaf.hxx
simgear/scene/tgdb/obj.cxx simgear/scene/tgdb/pt_lights.cxx
simgear/scene/util/SGDebugDrawCallback.hxx
simgear/screen/Makefile.am: Use color arrays for every geode.
Just use osg::Material instead of osg::Material and the associated
mode.
simgear/screen/extensions.cxx simgear/screen/extensions.hxx: Avoid
the assumption that with glx-1.4 glXGetProcAddress is available -
use dlsym to get that function.
simgear/scene/model/Makefile.am
simgear/scene/model/animation.cxx
simgear/scene/model/animation.hxx
simgear/scene/model/modellib.cxx
simgear/scene/model/modellib.hxx
Removed Files:
simgear/scene/model/personality.cxx
simgear/scene/model/personality.hxx:
Updates to the animation system.
Personality can be implemented easier now
<model>
<path>some/model.xml</path>
<condition>
<property>model/switch</property>
</condition>
</model>
Of course, one could add "select" animations for all <object-name> in the
<model>, but this is tedious and can hardly be done e.g. for all
objects in all instruments in $FG_ROOT/Aircraft/Instruments-3d/ etc.
The feature will be used in the bo105, so that civilian variants can
have a HSI instrument, where military variants have a TACAN etc.
- // the current item each time. Is
- // that OK?
No, it is not OK. This messes up the vector and confuses the iterator.
And it leads to crashes. Better read the vector in reverse order.
("In member function 'T SGPersonalityParameter<T>::shuffle()':
28: error: there are no arguments to 'sg_random' that depend on a template
parameter, so a declaration of 'sg_random' must be available")
Fix bug with break/continue inside of a foreach or forindex: Don't pop
the vector/index inside OP_EACH, do it at the end of the loop.
In the process, discovered and fixed a scary corruption issue with
continue; it never really worked right, although simple usage was
likely to get away without crashing. Both the continue's OP_BREAK and
the cleanup code at the end of a loop would pop the "mark" stack,
leading to an underflow. Introduced an OP_CONTINUE which adjusts
stack but doesn't change markTop
Re-inline the PUSH macro. This thing is called all over the place
from the inner loop. If the problem is intra-expression side effects,
then just use another expression in the macro.
Return an empty vector when requesting zero-length subvec, not nil
Have call() return the call stack in the error vector; see docs on
plausible.org/nasal or ask Andy about this feature.
Default closure()'s level argument to zero, not nil
Add an optional "file name" argument to compile()
simgear/scene/material/mat.cxx simgear/scene/material/mat.hxx
simgear/scene/material/matlib.cxx
simgear/scene/material/matlib.hxx simgear/scene/tgdb/leaf.cxx
simgear/scene/tgdb/obj.cxx
Attach userdata to groundtile scenegraph leafs that contains
a SGMaterial reference to the material of that leaf.
Add (physical) material properties to the material definitions.
Plug a memory leak with GlyphSigns.
specify the same texture in the "foo.lighted" and "foo.unlighted" material
entry. This also allows to drop the state cloning and thereby solves the
most urgent apt_signs.cxx TODO. :-)
states from material.xml (separate <material> entries for now)
- clone state less often: not once per sign element, but once per material
switch (TODO: clone only once per material)
got plib's lowres red-white chequer-board pattern along with an error
message, and not ours ... which is much prettier, but also bigger.
(Should we downscale it?)
- add commands @size, @material, @light
- make "BlackSign" texture default
- make @B, @R, @L, @Y open close their frames automatically (this can be
avoided by setting the @material manually)
- add number variants for those 4 sign commands: @Y2, @B5, etc (according
to the spec; defaulting to the respective biggest panel size, i.e. @B = @B3)
(detailed description will be added to $FG_ROOT/Docs/)
uninitialized data bug in naHash_cget(). When the hashcode field of
naStr was introduced, I forgot to set it in this function, which
creates a temporary naStr on the stack.
but contain <glyph> entries with <name>, <left> and <right>. The latter two
describe where in the texture a letter or symbol begins and where it ends.
(range 0-1). <xscale> defines a horizontal scaling factor.
from provided node
"* minor redundant gl call in DrawCone2 optimized away (twice per frame)
* corrected the glRotatef() order in drawRain even further (a less
obvious mistake than before, which is noticed by looking skywards and wiggling
the mouse in the view direction change mode)
* all the "magic numbers" used in the rain rendering code have been
provided a default (based on the old hardcoded value) in a form of a
define, and a meaningfully named static member in SGEnviro"
subvec() to mean "the whole vector". Melchior showed a use case
(removal of the first element from a vector) where getting a
zero-length subvector is actually desired. And since I can't come up
with a good reason for why the "feature" was there in the first place,
out it goes...
inspect the string pointers. It also failed to properly sort strings
where one is a prefix of the other. It looks to me like I just never
finished this, and it ended up in CVS because it just happened to
compile...
(We are currently getting a lot of aborts in the condition code when
running MP. I don't expect this to fix it, but a bug is a bug.)
(reviewed by Fred, who also fixed *my* bugs :-)
Add MAC OS X Render Texture support:
Most texture modes seem to work on my Powerbook, but I don't have a wide array
of machines to test it on otherwise.
If you have problems, please let me know and I'll see if I can help track down
the source of the bug. I'd love to keep working on it if time permits (I use
RenderTexture in a few other projects), so I'll keep you informed if there are
any changes that I make for the better.
add abstract class SGModelData. If a pointer to such a class is handed over
to sgLoad3DModel, then its modelLoaded() method is called with path, property
node and branch. And then it's added to the scene graph so that it's
destroyed when the model branch is removed from the graph.
modellib.[ch]xx:
only cache objects when asked to. This is the case for OBJECT_SHARED
and random objects (like before), but no longer for OBJECT_STATIC.
These are now removed from the graph when they are "out of sight". This
prevents accumulation of static models, and makes destroying model data
possible (e.g. removing Nasal modules)
matmodel.cxx:
set cache flag for random objects (same behavior as before)
- don't unlock an already unlocked mutex (Someone wanted to be on
the safe side with this, but the result is undefined and makes
pthread_mutex_destroy fail. Reference: manpage for
pthread_mutexattr_gettype/The Open Group[1]: "Attempting to
unlock a mutex of this type which is not locked results in
undefined behaviour.")
- re-enabled all subsystem destructors again (this has been disabled
because fgfs hung on exit, due to the mutex destroy failure from
above.)
Reference:
http://www.opengroup.org/onlinepubs/007908799/xsh/pthread_mutexattr_gettype.html
- new FSF address
- removed a few hundred trailing spaces
- fixed a few $Id$ lines
- copied two license headers from *.hxx files to their respective
*.cxx counterparts
- added two test aps to .cvsignore
- don't unlock an already unlocked mutex (Someone wanted to be on
the safe side with this, but the result is undefined and makes
pthread_mutex_destroy fail. Reference: manpage for
pthread_mutexattr_gettype/The Open Group[1]: "Attempting to
unlock a mutex of this type which is not locked results in
undefined behaviour.")
- re-enabled all subsystem destructors again (this has been disabled
because fgfs hung on exit, due to the mutex destroy failure)
This patch makes use of the vectors now available in simgear with that past
patch. And using that it simplyfies the carrier code somehow.
- Small additional factory's to the quaternion code are done in the simgear
part. Also more explicit unit names in the factory functions.
- The flightgear part makes use of them and simplyfies some computations
especially in the carrier code.
- The data part fixes the coordinate frames I used for the park positions in
the carrier to match the usual ones. I believed that I had done so, but it
was definitly different. Also there are more parking positions avaliable now.
- change SG back to FG (this was accidently changed in three wrong
places when I prepared the file for SG)
- correct length for the proxy id detection
- set (guessed) deposit depth < 1mm correctly
- set deposit type string
- formatting
This patch fixes the sound of 737, Concorde and others, if fgfs
was compiled with newer gcc versions (e.g. gcc 4.0.2). These compilers
implement the c++ standard more strictly, and thus don't guarantee
that c-style casted pointers to different data types really point
to the same address. This is only guaranteed for union members.
The patch adds a vector lib I have put together during the last time,
it is just handy and interfaces well with s(s)g*. Together with some small
modifications this will later also interface well with OpenSceneGraphs
vectors/matrices. Using this vector kernel is targeted to have a handy
matrix/vector lib available and to provide a scenegraph independent vector
type for use with a small scenegraph wrapper aimed for a smooth transition to
openscenegraph.
That vector code also includes an improoved geodetic conversion routine I
have found some time ago published in the 'journal of geodesy' which avoids
iterative computations for that purpose.
Also the geodetic position class is more typesafe and unitsafe than the
Point3D currently is.
That part is relatively old and in use in my local trees for several months
now.
This patch makesFlightGear at least compile on MSVC. I hope I have removed
reference of my other local changes. DSP and DSW files are included for
reference. They have been reconstructed with am2dsp.pl. I had to introduce a
change to am2dsp because of the need of filenames with embedded spaces. (Yuck)
The major direction is to remove clutter like the _USE_MATH_DEFINES and
have it on the compiler command line sice there is no central include
file. You will have to put it on the command line for your locale
Project files, if it not there, already. I added the
_CRT_SECURE_NO_DEPRECATE define for 2005, since it does no harm to other
VC version.
Third Party Libs like plib, OpenALSDK, freeglut, pthreads-win32, zlib
are unpacked as is side by side. Only change put the includes of OpenAL
into include/AL rather directly into include.
Fix the current buggy rain orientation behaviour for the views attached to the
aircraft (while still inheriting bugs with the views attached to anything else).
add optional arg to SGPropertyNode::addChangeListener that triggers
the listener function call initially. This is useful for cases where
a freshly installed listener wants to treat the current property
value as changed from 'unknown' to the actual value right away.
Examples can be found in the Nasal incarnation setlistener(),
where we have for example this (in $FG_ROOT/Nasal/gui.nas):
INIT = func {
...
setlistener("/sim/rendering/fps-display", fpsDisplay);
if (getprop("/sim/rendering/fps-display")) {
fgcommand("dialog-show", props.Node.new({"dialog-name": "fps"}));
}
}
That is: we first attach a listener that cares for changes to the FPS
display switch, but then we have to manually open the dialog initially.
That's a duplication of code and could be as simple as this
(INIT part only):
INIT = func {
...
setlistener("/sim/rendering/fps-display", fpsDisplay, 1);
}
That is: the optional third arg makes fpsDisplay be called initially,
and then again with every write action. My first solution was in the
Nasal code only, but Andy (rightfully) says that this should rather
be in sg.
Incorporating the shared ptr code:
- All scenegraph references from SimGear
- SGMaterial which already had a reference counter uses now that common
infrastructure.
- SGMatModel is now counted.
- SGSoundSample from SimGear
- And the corresponding change for the sound samples in flightgear which fixes
a latent crash if FGBeacon would evern be deleted.
This patch fixes this SimGear compile error on x86_64 Fedora Development with gcc-4.1:
placement.hxx:49: error: extra qualification ‘SGModelPlacement::’ on member ‘init’
Add the basic infrastructure for a reference counter class.
Adding it now (without using it) enables Mathias and others to
prepare some memory reduction code.
Fix a problem where the directory being created is made relative when in fact
it's absolute. It also tightens things a bit on the Windows side.
Erik:
Make the section that splits up the directory in a lists of parent directories
a standalone function.
The create_dir was totally broken. No function was used at the right place
except mkdir. This patch now create directories without segfaulting.
Erik:
This was my bad, I've been using a really slow computer for the last ten months
and recompiling SimGear with a change to the properties code takes ages, so
once in a while I apply something not entirely tested. This is one really bad
example which shouldn't have happened. Thanks to Frederic for fixing it.
* in some cases more specific sg exception types were used in place
of the more generic one, e.g., sg_io_exception instead of sg_exception
when the context of the error was an IO error
* in some cases, the error message was made more specific
* minor style fix for exception rethrowing --- using throw; whenever
a re-throw is made; sometimes optimizing away the exception symbol name
in the catch handler at all
* more specific catch handlers added in some places -- e.g.,
an sg_io_exception caught ahead of sg_exception
to pop themselves down while the simulator is paused.
The problem was with the "real time" queue in the event manager,
causing the third argument of Nasal's settimer() (a flag for "sim
time") to be ignored. Inverts the default sense of the argument, as
there are lots of uses of settimer() in the current code, almost none
of which want to use real time.
Note this fix introduces a header file incompatibility in SimGear --
be sure to update.
* Use "const string&" rather than "string" in function calls when appropriate.
* Use "const Point3D&" instead of "Pint3D" in function calls when appropriate.
* Improved course calculation in calc_gc_course_dist()
* Safer thread handling code.
Vassilii Khachaturov:
Dont use "const Point3D&" for return types unless you're absolutely sure.
Erik Hofman:
* Use SGD_(2)PI(_[24]) as defined in simgear/constants.h rather than
calculating it by hand every time.
The attached patch makes remove_child() available as removeChild(pos, keep).
That's consistent with getChild. Only renamed remove_child to removeChild and
added a check for validity of the pos argument.
removeChildren() will be used in input.cxx, and a lot in the upcoming
dynamic new_gui dialogs, which are aiming at replacing the hard-coded
dialogs. I'll discuss them on the list once the infrastructure is
in place. (The <hide> gui property was one part of it.)
I have corrected a few bugs with the owner draw gauge, weather radar code and heat-haze effect.
- shadanim.cxx :
the heat/haze effect was showing artifacts when using a screen resolution >
1024 pixels.
This one, removes some virtual qualifiers at a private member class of
SGPropertyNode. These virtual qualifiers are really useless and stop the
compiler from inlineing these functions. I gain a single frame with my
favourite aircraft per second!
I have done a valgrind run in flightgear. Just start it up and close it at the
fist change I had about half an hour later.
property-leak.diff:
A leak in the property system which I could even notice in top.
texture-leak.diff:
minor one, but fixed is fixed ...
Correct the bug in the translate animation where the offset was part of the
multiplication. It now behaves like all other animations:
out = (prop * factor) + offset
I feel strongly that the existing is wrong and must be corrected - it is non-op
if the offset is zero as I have found to my cost! It is just a typo I expect.
The diff also provides non-op default values for the scale animation.
I've also included Harald's latest eye-candy animation which allows us to
have a very smart heat-haze for exhausts. They have been tested by me and
others on Linux and Cygwin. You might like to upload these - I have a
revised Hunter ready to go as soon as they are uploaded.
*appears* to work correctly on all systems to which I have access
(i386 linux/win32, x86_64 linux, powerpc OS X, Sparc Solaris 10), but
not all systems are capable of running fgfs. Beyond that, multiple
threading bugs were fixed, and the naCall() API changed slightly to
support named function arguments.
NOTE: this introduces a change in the external API, and therefore this
change *must* be compiled against current FlightGear code.
After much trial and tribulation, Harald came up with a fix for the bug
which has been plaguing Cygwin for a couple of weeks now.
It's only a couple of lines. I've tested it exhaustively, and it seems to
cure the problem of Cygwin failing to start.
There was a patch from Manuel Masing a few months ago which cleaned up
SGLocation's way depending on input values. That means that with that patch
SGLocation does no longer have calls with unneeded input arguments.
I took his patch and integrated that into flightgear and made maximum use of
that changes.
just a few split out patches from my zoo of local work ...
The patch to simgear-glxproc.diff changes dlopen to not open a specific library.
If it is used with a NULL argument, we just get a handle to the current running
binary including all loaded libraries. This has the advantage that we do not
rely on the name of libGL on the specific platform.
Also a user can link with his own different named libGL or with a static libGL.a
Then the render texture again ...
glxQueryVersion turns out to return the minimum of the client libraries glx
version and the servers glx version. *All* Xorg servers return 1.2 here.
So we never get the glxPBuffer functions which are the only ones working with
ati's drivers ...
Reverted back to checking the required functions and just use them if they are
there. Still prefering the glx standard variants since they work on ati's
drivers ...
- model.cxx :
load the 2.5D panels before the animations so that the panels can be used in
animations his solve the problem of 2.5D panels visible outside of the
aircraft (one can add a null animation to put the panel at the top of the
aircraft graph so it is drawn first) and this adds the possibility to have
billboarded/popup panels.
- newcloud.cxx :
removed 'this' pointer cast for amd64 compiler.
Changes
=======
- shadowvolume.cxx, renderer.cxx :
- reduced the polygon offset a bit to eliminate some artifact ;
- changed again the cleanup code for objects inside a tile because it could crash on rare occasion ;
- the culling of shadow casters has been rewritten to traverse the scene graph, it should be
a bit faster when there is a lot of objects ;
- the range selector was not correctly handled, sometimes the wrong LOD was casting shadows.
- added the option to display aircraft's transparent objects after the shadows, this will
reduce the problem of shadows being hidden by the transparent object (propeller disk,
rotor, etc). A side effect is that aircraft's transparent objects won't receive shadows
anymore. This is usually a good thing except when the aircraft use a 'transparent'
texture where it should not. A transparent texture in the plib context is a texture
with an alpha channel or a material with alpha <= 0.99.
- model.cxx, animation.cxx, shadowvolume.cxx :
- added an optional <condition> under the <noshadow> animation
- tower.cxx
- correct a rare bug where all occurences of the aircraft are not deleted from the
departure list causing a crash in FGTower::CheckDepartureList function.
Melchior has found another bug, I tried to skip some computation for a few
frames but that introduced some bad rendering bug with the aircraft moving
parts.
I corrected that and reduced a bit the cpu usage for ground objects.
- shadow volume vertex are now shared, using DrawElements instead of repeated
calls to glVertex, this can improve performance on some systems.
- added a rendering path that use the alpha channel instead of the stencill
buffer.
- releasing memory when tiles objects are destroyed
- objects sub parts will not cast shadows if their name begins with "noshadow"
or if they are in a <noshadow> animation
- bbcache.cxx :
don't ask for a 32 bits context when the primary context is only 16 bits
- RenderTexture.cpp :
corrected a crash when asking for a second rendering context
on win32 and extensions not being supported
- model.cxx, animation.cxx :
added a <noshadow> animation, added an animation type needed by the shadow
code.
- check for isTied() and refcount has to be made *before* we go into
recursion, so as to pertain subtrees of refcounted nodes, even if there
are no refcounted/tied nodes *in* this tree
- return value inverted, because it's more logical to say
removeChildren() == true --> everything removed; false --> failed
- further cleanup
- introduce removeChildren() and removeChildren(name) to remove all children
or all with a given name
- let removeChild() and removeChildren() also remove child trees, and let them
return a "dirty" boolean that indicates if one or more subnodes had to be
kept because of refcounting (removeChild returned a SGPropertyNode_ptr before)
- make alias/unalias increase/decrease the refcounter
- don't remove refcounted or tied nodes
This patch makes the SGPropertyNode_ptr actually useful. Until today, they did
proper refcounting (except for aliases), but no other part did check this counter.
But SGPropertyNode_ptr aren't only useful for the first time, they are now
highly recommended for every place that relies on a node address, and wants
to "lock" it (so that removeChild(ren) will never try to remove them). This
is not guaranteed for SGPropertyNode* (and never was). Of course, that's not
an imminent problem, as only four places currently use removeChild(ren) and
these are careful to only remove their own data.
Changes
=======
New volumetric shadows for FlightGear.
There is now two new checkboxes in the rendering dialog to enable/disable shadows
for the user aircraft and for static scenery objects (ie those defined in the .stg files).
AI and random objects are not handled for the moment.
known bugs
==========
- ghost objects
This is the more elegant solution that Andy had proposed in a response
to my RFC on Nasal initialization code in joystick configuration files.
As Nasal is initialized last (for good reason), subsystem can currently
not use it for initializing. postinit() is called on all subsystems
after all have been initialized.
Changes
=======
- changed the rotation of sprites, they don't rotate strangely when we
approach them now
- corrected the strange movement of clouds when banking quickly
- it no more rain above cloud layers
- add a radar echo container used by the weather radar instrument
patches; my private version has rewritten both of these functions
(ironically fixing these bugs in the process) to handle negative
offsets meaning "from the end".
Turn the material animation's <transparency> property into a group, with
members <alpha-prop>/<alpha>, <offset-prop>/<offset>, <factor-prop>/<factor>,
<min>, and <max>. The "material" animation can now fully replace "blend" and
"alpha-test" (--> <threshold>) animations, with enhanced possibilities:
The "material" animation can be used for one or more explicit objects (like
"blend"), but also for all objects that share one material (<global>), which
avoids problems with objects being forced together into one tree. Also, an
object doesn't have to be semitransparent or textured with a semitransparent
texture to make blending work. Unlike the "blend" animation, the "material"
animation also makes fully opaque and untextured objects transparent. (This
fixes the bo105's formerly semi-transparent rotor.)
Erik:
The blend animation and alpha-test animation are depreciated as of now.
Currently, the material animation sets glColorMaterial(GL_AMBIENT_AND_DIFFUSE)
for all material properties. This breaks emission-only (e.g. cockpit lighting
for the p51d) or specular-only animation. ==> set glColorMaterial only where
it is really required.
Changes
=======
- correct the transparency probleme when old 3d clouds were enabled
(rendering context with an alpha channel)
- changed rain cone orientation, it can now be viewed from helicopter or chase
view (still not tower view)
- clouds are a bit more yellow/red at dawn/dusk
- weather data is now correctly propagated to the interpolator, this correct
visibility, wind, etc
- the 'metar' weather scenario now immedialty reuse the real metar data
- real metar no more overwrite custom weather scenario
This is another update for the cloud code, a lot of lines but this time I have started to add the doxygen doc.
Misc
====
- corrected a bug when RTT is not available, the current rendering context was
altered
- if RTT is not available then 3d clouds are not drawn at all
- impostors lighting is now recomputed when the sun changes position
- distant objects are no more seen in front of clouds
- blending of distant clouds is a bit better now
- litle optimization of code (uses a less cpu time)
- use layer wind speed and direction (no more hardcoded wind)
- fov is no more hardcoded
Changes
=======
- clouds (cu only) are dissipating/reforming (experimental)
- compute a turbulence factor that depends on surrounding clouds and type of
clouds (experimental)
- clouds shapes are defined in cloudlayers.xml
- type of clouds present in a layer is also defined in cloudlayers.xml
- cloud layers are generated from metar and other misc. data (in progress)
- added a rain effect around the viewer (enabled in the rendering dialog and
when the metar property says so)
- added a lightning effect (enabled in the rendering dialog) : cb clouds spawn
new lightnings
- added a dialog to select from different weather source : metar/property,
a 'fair weather' environment and a 'thunderstorm' environment.
Vivian pointed out that a redefined Ctrl-U key binding didn't work
correctly. I found out that this is, because the definition in
$FG_ROOT/keyboard.xml sets <value type="bool"> for binding[1],
and ... [better sit down first!] ... and assigning <value type="double">
in a *-set.xml file doesn't *really* set "double" as new type!
Instead, the boolean is kept, and a double sqeezed into it. In other
words: once tainted as bool, you can throw all doubles in the universe
on a property node, and all it will accept is 0 and 1. Without warning!
BTW: I changed the patch: I was overly cautious: clear_value() does already
care for ties and for setting NONE, so we just need to make that public as
clearValue(), and use that. Makes the patch a bit more verbose, though. :-/
This is a minor bug fix for sgBucketDiff().
If you crossed the bucket size boundary, the answer for dx could be wrong.
E.g.
going from 0:0, 21:7 to 0:7, 21:7 would give you dx = 7 (correct)
but going from 0:0, 21:7 to 0:3, 22:0 would give you dx = 6 (instead of 7)
Previously it differenced the center longitudes of the buckets. When you
cross a boundary, the center point of the larger bucket now lies on the edge of the smaller bucket.
The result was a dx with an integer + 1/2 bucket, which rint() was rounding to the nearest even int.
This function only seems to be used in TerraGear.
I have done a patch to eliminate the jitter of 3D-objects near the viewpoint
(for example 3D cockpit objects).
The problem is the roundoff accuracy of the float values used in the
scenegraph together with the transforms of the eyepoint relative to the
scenery center.
The solution will be to move the scenery center near the view point.
This way floats relative accuracy is enough to show a stable picture.
To get that right I have introduced a transform node for the scenegraph which
is responsible for that shift and uses double values as long as possible.
The scenery subsystem now has a list of all those transforms required to place
objects in the world and will tell all those transforms that the scenery
center has changed when the set_scenery_center() of the scenery subsystem is
called.
The problem was not solvable by SGModelPlacement and SGLocation, since not all
objects, especially the scenery, are placed using these classes.
The first approach was to have the scenery center exactly at the eyepoint.
This works well for the cockpit.
But then the ground jitters a bit below the aircraft. With our default views
you can't see that, but that F-18 has a camera view below the left engine
intake with the nose gear and the ground in its field of view, here I could
see that.
Having the scenery center constant will still have this roundoff problems, but
like it is now too, the roundoff error here is exactly the same in each
frame, so you will not notice any jitter.
The real solution is now to keep the scenery center constant as long as it is
in a ball of 30m radius around the view point. If the scenery center is
outside this ball, just put it at the view point.
As a sideeffect of now beeing able to switch the scenery center in the whole
scenegraph with one function call, I was able to remove a one half of a
problem when switching views, where the scenery center was far off for one or
two frames past switching from one view to the next. Also included is a fix
to the other half of this problem, where the view position was not yet copied
into a view when it is switched (at least under glut). This was responsible
for the 'Error: ...' messages of the cloud subsystem when views were
switched.
have done a patch to eliminate the jitter of 3D-objects near the viewpoint
(for example 3D cockpit objects).
The problem is the roundoff accuracy of the float values used in the
scenegraph together with the transforms of the eyepoint relative to the
scenery center.
The solution will be to move the scenery center near the view point.
This way floats relative accuracy is enough to show a stable picture.
To get that right I have introduced a transform node for the scenegraph which
is responsible for that shift and uses double values as long as possible.
The scenery subsystem now has a list of all those transforms required to place
objects in the world and will tell all those transforms that the scenery
center has changed when the set_scenery_center() of the scenery subsystem is
called.
The problem was not solvable by SGModelPlacement and SGLocation, since not all
objects, especially the scenery, are placed using these classes.
The first approach was to have the scenery center exactly at the eyepoint.
This works well for the cockpit.
But then the ground jitters a bit below the aircraft. With our default views
you can't see that, but that F-18 has a camera view below the left engine
intake with the nose gear and the ground in its field of view, here I could
see that.
Having the scenery center constant will still have this roundoff problems, but
like it is now too, the roundoff error here is exactly the same in each
frame, so you will not notice any jitter.
The real solution is now to keep the scenery center constant as long as it is
in a ball of 30m radius around the view point. If the scenery center is
outside this ball, just put it at the view point.
As a sideeffect of now beeing able to switch the scenery center in the whole
scenegraph with one function call, I was able to remove a one half of a
problem when switching views, where the scenery center was far off for one or
two frames past switching from one view to the next. Also included is a fix
to the other half of this problem, where the view position was not yet copied
into a view when it is switched (at least under glut). This was responsible
for the 'Error: ...' messages of the cloud subsystem when views were
switched.
Changes
=======
- corrected some strange behavior when playing with the render dialog options
- the density slider is now working : if you are fps limited and still want to see clouds in
the distance you should play with that
- added the choice for texture resolution, its more comprehensible now (before it was
wrongly allways choosing 64x64 textures)
- changed the initial texture size : you now have 64 texture of 64x64, this uses 1Mo of
texture memory (before it was 20 texture of 256x256, that took more memory and there was
not enought impostors)
- sun vector is now right so the lighting is a bit better
- removed useless sort and light computations for impostors, this should save a lot of cpu
- blending of distant cloud is more accurate now
- clouds are now positioned correctly, they don't try to escape you anymore
- no more red/white boxes around cloud
- textures are now filtered (no more big pixels)
known bugs
==========
- distant objects are seen in front of clouds
- new and updated sources for the new volumetric clouds
- 2 new textures for the clouds
- an update to the render dialog to enable/disable and change a few parameters
for the new clouds
foreach, except that the variable gets the index instead of the list
element. Should be useful, and took almost no code to implement.
Support for operator/assignment syntax: +=, -=, *=, /= and ~= now do
what you think they should.
Library support for a bind() function (see the docs Andy is still
writing), allowing runtime modifications to function lexical
environments.
that the column math goes wacky when lgalloced is allowed to be
zero.
Augment the find() function to take a starting index.
Fix strc() to use a default index of zero.
Fix parser precedence of TOK_MINUS, so that "a-b-1" means (a-b)-1 and
not a-(b-1).
Re-organisation: <diffuse>, <ambient>, <emission>, <specular> are
now groups with members <red>, <green>, <blue>, <factor>, <offset>,
and their <*-prop> forms. Additionally, there's an option <property-base>
that can be used to set a path that is prepended to all <*-prop> paths.
It defaults to an empty string. Rationale: see model-howto.html.
here is the promised material animation. It looks a bit longish, but that
wasn't avoidable -- there are simply too many parameters to consider. I tried
hard, though, to make the animation fast by only doing the necessary stuff.
It doesn't affect the frame rate here with my test model. The animation is
heavily based on Jim's "material-emission" animation.
* implementation of the "material" animation (this required to make the
texture path available) + documentation update ($FG_ROOT/Docs/)
* fix some more return values (texture animations, and select) for the
shadow problem (and some in anticipation of other problems :-)
* fix compiler warning
the cause for the disappearing shadows is, that SimGear doesn't tell plib
to call the pre-traversal-callback function on culled objects. These calls,
however, are necessary to execute the transform animation that does, for
example, translate a shadow back into the frustum! Curretnly, the callback
is only executed, and the shadow only magically pops up again, when the object
enters the frustum because the view has changed significantly.
The plib documentation does only talk about TRUE and FALSE for possible
return values from the pre-traversal-callback. But src/ssgEntity.cxx reads
like this:
int ssgEntity::preTravTests ( int *test_needed, int which )
...
int result = (*preTravCB)(this,which) ;
if ( result == 0 ) return FALSE ;
if ( result == 2 ) *test_needed = 0 ;
...
So the return value needs to be 2 to bypass the cull test for pretraversal,
and get the pretraversal in any case. I only changed the return values in
four animations: scale, rotate, translate, and range, because these are
the most likely to move an object out of the frustum. It's not necessary
for blend/alpha/texture manipulation etc. Of course, this is a bit more work
for plib, but the performance will probably not be affected, because:
* these four animations are mainly used for the aircraft model (the spin
and billboard (trees!) animations are not affected)
* the number of extra nodes to process is quite low
* a part of the time spent for the extra nodes to be processed, was before
used for workarounds that are now not necessary any more
I didn't observe a frame rate drop, at least.
code generation of constant objects to use real identity and not Nasal
equality, so (e.g.) the constants 1 (number) and "1.0" (string) do not
get turned into the same object in the generated code.
This patch adds support to the model animation system for modifying emissive
states on the fly so that it is possible to make "lights" appear to dimm.
This is an example of a configuration entry which should explain how it is used:
<animation>
<type>material-emission</type>
<object-name>Face</object-name>
<property>/controls/lighting/instruments-norm</property>
<emiss-red>1.0</emiss-red>
<emiss-green>0.8</emiss-green>
<emiss-blue>0.5</emiss-blue>
</animation>
Note the color entries are the emissive colors when the "property" value is
1.0. They are useful for tinting the light. The "property" itself must be
float or double and is clamped to values between 0 ~ 1.0 inclusively. The
"property" value is multiplied against the colors to get the actual material
properties. Thus property value 0.0 = darkest, and 1.0 = brightest.
If alcOpenDevice( NULL ) is NULL, then context is never assigned a
value, and it's pointless to ask for it in the next "if". But as the
ALCcontext that context points to doesn't seem to be fully defined
(OpenAL bug), valgrind still complains ...
Erik Hofman:
Extend this some further and define context=0 otherwise and check for
context != 0 before using it.
Trying to find the bug in tower.cxx (that crashes fgfs quite frequently
for me!), I'm playing with valgrind again. Until I'm in the ATC subsystem
there will be some other bugs and nitpicking along the way.
valgrind doesn't like that imgage->tmp is once allocated with new and
once with new[], sometimes with malloc() (via map), and sometimes freed
with delete (not delete[]!) and sometimes with free(). With simple types
such as GLubyte this shouldn't really make a difference, but anyway.
Also, I promised that I'd send patches for "if (foo) delete foo;" as
I'm making other changes to concerned files. texture.cxx is one with a
few occurrences thereof. (Remember: C++ explicitly allows to delete
null-pointers, so this check is redundant, and hence not tolerated in
other projects, such as KDE. Doesn't have to impress us, of course. :-)
Also, fixes 4 signed/unsigned warnings (gcc 3.3.4)
The error properly belongs to the enclosing scope, not the called
(non-)function. This bug was fixed a few months back in my private
tree, but Melchior just discovered that the new Concorde scripts
tickle it. I really need to re-synchronize SimGear with my own Nasal
tree...
this is the animation code that do randomisation of the spin animation. The XML tags are modified to support the syntax below :
<use-personality type="bool">true</use-personality>
<factor>
<random>
<min>1.8</min>
<max>2.2</max>
</random>
</factor>
<starting-pos-deg>
<random>
<min>0</min>
<max>360</max>
</random>
</starting-pos-deg>
instead of usual :
<factor>1.42</factor>
<starting-deg-pos>42.0</starting-deg-pos>
1. Remove the dependency on alut which (on certein platforms) might pose
some restrictuons on commercial use.
2. Create a sound source just prior to playing the sound and destroy it
again when the sound has stopped. This should greatly reduce the
error reports from Windows users.
The following patches to SimGear & FlightGear ...
- create an FGMetar abstraction layer, whose purpose is:
* provide defaults for unset values
* interpolate/randomize data (GREATER_THAN)
* derive additional values (time, age, snow cover)
* consider minimum identifier (CAVOK, mil. color codes)
- add rain/hail/snow/snowcover support on the METAR side
- add max age of METAR data handling (currently set to
- add support for an external METAR cache proxy server
- add CAVOK handling
- set missing year/month in regular METAR messages
- fix a small bug in metar.cxx (wrong return value)
- In sky.cxx blend low density cloud layers (few/scattered) into nothing (but
don't touch visibility distance) as we approach them so we can fly through
clean.
- For high density cloud layers (broken/overcast) we do not fade the layers
out, but we fade visibility to nearly nothing as we approach the layer.
capability to slowly fade a cloud layer in or out.
We use this effect in combination with lowering visibility as we approach
a cloud layer to hide the fact that it is simply a 2d textured polygon being
drawn across the sky.
cloud layer (i.e. <50% coverage). This is a quick hack rather than a
proper fix, but it will at least make it possible to get above a
scattered layer VFR.
It comes to me that the bulk of all problem reports, especially from Windows users, have it's cause in an obsolete sound driver. These messages should direct them to the right solution before complaining.
My recent fix for the load/save fgfs.sav feature was a bit too ambitious.
While aliases lead to abortion before, I tried to copy them properly,
although this wasn't a requirement. Unfortunately, this seems to have
worked for absolute aliases only, not for relative ones, and hence broke
several panel instruments. The attached patch backs most of the previous
patch out again, and goes a simpler route: just ignore aliases.
fgLoadFlight() loads a property file ("fgfs.sav") to a new property tree,
and then copies that over to the main tree. copyProperties() didn't know
how to handle type SGPropertyNode::ALIAS and hence threw an exception that
made fgfs abort.
The attached patch adds support for ALIAS to copyProperties(): aliased
nodes are created in the target tree if necessary, and then linked like in
the source tree. It seemed useful to add an optional argument to
props.[ch]xx/getType() that would indeed return the property type "ALIAS"
for aliased nodes, and not the type of the node that it refers to. The patch
also fixes a bug in writeNode() that caused extra lines after alias entries.
If there's resistance to the change to getType() (David?) I can easily use
isAlias(). This just makes copyProperties() a tad uglier, but I can live with
it. It's useful for scanning a tree, though, if an alias node can be treated
exactly like all other nodes, without automatic redirection.
At last I've found the reason why fgfs crashed routinely for me. When I still
used KDE's artsdsp (preloads lib with OSS replacement functions) I saw
this crash only occasionally. After letting OpenAl communicate with artsd
directly (by means of ~/.openalrc setting), I got the crash always when
I left fgfs.
This bug may also have crashed fgfs when running with sound daemons other than
aRts.
but it doesn't. Trying the apple approach to fixing isnan results in an
infinite loop (making me wonder what happens on OSX?) This is an alternative
approach to checking isnan() on freebsd ...
I've added two new debug log types for the instrumentation and systems. They
used to use the autopilot debug log, because I couldn't figure out how to
make new log types. Well, now I have figured it out. ;-)
This is a patch to make display list usage optional. They are on by default.
Use --prop:/sim/rendering/use-display-list=false to use immediate mode.
There is also a change in exception handling in main.cxx and bootstrap.cxx
I'm working on a route manager in the GPS module. So I've added a name
parameter to the waypoint class in Simgear. I use the existing ID parameter
to store the ID, for example KLAX, and the name parameter to store the name,
San Francisco Intl.
I just discovered this : state() is not valid when _level==0,
because it is doing:
{ return _state_stack[_state_stack.size() - 1]; }
and is returning a wrong index fetch ( 0 - 1 ) == -1
Moreover, st is not used when _level==0 so the line can be moved
to a safer place.
I have 3 issues that are fixed by this set of patches.
1. In extensions.cxx
#else if !defined( WIN32 ) must be changed by
#elif !defined( WIN32 ) because the text after #else
seems to be ignored
2. banner is not available on windows, only cygwin
3. ANSI escape sequences are not interpreted on the
windows console. We just have garbage that is hard
to read.
Under rare circumstances we could encounter a non-cooperative external fdm
that could trigger this condition. This patch catches the problem and returns
rather than letting FG get killed.
Do state sorting by material before adding primitives
in the tile branch. I thought I could see a bit of
improvement in framerate but it is not the case on my setup.
I don't see a degradation though
I am still experimenting with the
code. Here is so far the best I could achieve. The
dark aspect of clouds at dusk or dawn is far better
than the problems of transparency of the previous
version.
Melchior spotted a problem where we can crash an airplane into the
beacon's beam. The patch below enable to mask out a branch from HOT
traversal, whatever the animation.
The beacon.xml file is also included. It has a
<enable-hot type="bool">false</enable-hot> in a halo branch
I was not very happy with the size of the halo, so
I created a new animation to control it. Now we can
control the scale value with the distance from the
viewer to the object. The towers are now beginning to
look good. They might need some tuning though. If
you want to play, locate in radio-*.xml this code :
<animation>
<type>dist-scale</type>
<object-name>RedLight.2</object-name>
<interpolation>
<entry><ind>0</ind><dep>0.1</dep></entry>
<entry><ind>500</ind><dep>0.3</dep></entry>
<entry><ind>16000</ind><dep>3</dep></entry>
</interpolation>
</animation>
You get the idea ? ind is the distance, dep is the
resulting scale value.
The medium tower appears brighter than the tall one,
because the lights are closer to each other. Maybe
they need a smaller scale factor at distance. Feel
free to modify these values if you find a better
setup.
About the code : I renamed flash to custtrans because the
ssg branch is now less specialized. It needs a callback
to compute the so called 'custom transformation'. It can
be used for the SGFlashAnimation and the new
SGDistScaleAnimation. So please cvs remove flash.[ch]xx and
add custtrans.[ch]xx. I also undo some of the code I send
you yesterday that was totally useless. It is replaced by
something simpler and that works.
There is also a patch to matmodel.cxx. This is not related
and was something I forgot. Its purpose is to set the
alpha test on material billboard models that are likely to
be trees to lessen a transparency weird effect with clouds.
I modified the included animation.cxx to have a randomly displaced
time origin, to break the unison. And the flashing period is also
random as you noticed. I also put all the flashing light of the pole
in the same animation so they flash in the same rhythm.
Fix a memory leak, and brownian animation, if not motion.
I have 2 new files : personality.[ch]xx . They store the personality
data that would be deleted when the object is destroyed, instead
of staying in the animation maps. I also manage the current animation
step better and the towers are not flashing randomly now.
Makefile.am is updated.
modellib.cxx :
Add a branch between the model and its transformation to add
a unique identifier for the model. I called it "personality
branch" and it maintains a "current_object" in SGAnimation.
Animations specifically written to support it ( currently only
the timed animation ) can add a degree of variety among the
occurrences of the same model that would look otherwise cloned.
flash.[ch]xx :
Better compute the view vector. The flash is now syncronized with
its axis even at the edge of the screen.
animation.[ch]xx :
Lots of changes :
- add a condition to 'rotate', 'spin', 'translate' and 'range'.
When a condition is specified *and* it evaluates to false, the
animation becomes a no-op. Possible usage : no rotation during
daylight, LOD range variable along the day, ...
- use different durations for each branch in the timed animation.
Enable the use of multiple <branch-duration-sec>, one for each
<object-name> specified. Usage : strobes with flash light.
- allow randomization of the <branch-duration-sec>, by using
<random><min>_min_value_</min><max>_max_value_</max></random>.
The value computed once is between _min_value_ and _max_value_.
- implement model personality in timed animation. If
<use-personality type="bool">true</use-personality> is specified,
a different set of duration is created for every model in the
scenegraph using this animation. Best if used with randomization.
When using strobes where the population of the same object is
dense, it avoids the "cheasy" clone effect.
this patch introduce a new kind of animation and ssg branch.
I called them flash animation, because they help me to
enhance the look of the rotating beacon and possible future
lighthouse. It computes the cosine of the angle between an
arbitrary axis, transformed by the current modelview matrix,
and the view direction. No trig involved, just a dot/scalar
product.
The computed value can be modified by three parameters,
power, factor and offset, according to the formulae :
value = factor * pow( cosine, power ) + offset.
It is clamped between a minimum and a maximum.
This value is then used as the scale factor of a matrix
transformation applied to the children of the SGFlash
branch.
The xml syntax, with default values, is :
<animation>
<type>flash</type>
<object-name>HaloObject</object-name>
<center>
<x-m>0</x-m>
<y-m>0</y-m>
<z-m>0</z-m>
</center>
<axis>
<x>0</x>
<y>0</y>
<z>1</z>
</axis>
<power>1</power>
<factor>1</factor>
<offset>0</offset>
<min>0</min>
<max>1</max>
<two-sides>false</two-sides>
</animation>
a MinGW target:
Link against alut.dll in addition to openal32.dll.
Remove some preprocessor defines from compiler.h that were
confusing the mingw and/or libstdc++ headers (I put the _isnan
one back in the only file it was used).
Hack a broken sleep() call into the OpenAL sample programs so
that they will compile (but not work) in a non-POSIX environment.
Change the header file ordering in sample_openal.hxx to get
around some really weird interactions between MinGW's windows.h
and the gcc iostream header.
This allows us to "place" cockpit sounds. For example, we can make left
engine sound come out of the left speaker, right engine out the right
speaker, etc.
sound manager. The interface was simplified and cleaned up a bit, and I
haven't back ported these changes to the plib sound wrappers ... we could
I suppose if someone really had a problem, but I haven't seen anything so
far that would indicate the extra effort is worth it.
gcc 3.4 has changed the rules for unqualified template name lookup. This
affects SGQueue.hxx. The changes I've made are backwards compatible with
earlier gcc versions. Everything else compiles pretty much okay except for a
few warnings. The resultant executable seems a bit faster too.
This is a new patch that allow to define a different
texture for top and bottom of clouds. It uses the
overcast_top.rgb you made for me last time.
What the patch do is to install a ssgStateSelector
instead of a ssgSimpleState for each layer.
The SGCloudLayer::draw method is modified to accept
a boolean that will select the proper state: 0/false
for bottom, 1/true for top.
Then, in SGSky::drawUpperClouds and SGSky::drawLowerClouds,
SGCloudLayer::draw is called with false and true because
we see the bottom of upper clouds and the top of
lower clouds.
Only overcast has 2 textures, the other types share the
same state for top and bottom, but that could be modified
in SGCloudLayer::rebuild.
put all leaf is a seperated branch so that it is
possible to use a pretrav callback to cull out
terrain without culling out light or dynamic
objects. It appears that plib is not calling the
pretrav callback for leaves.
add an optional parameter that would be called to
build the aircraft panel, so that flightgear's
model_panel no longer duplicate code.
add a pretrav callback to models so that we can
filter out models when calling ssgCullAndDraw on
the global scene.
sgSetModelFilter( true ) means that we want to draw
the models. Use false to cull them out.
popped off the stack in a situation where it could be garbage
collected. I believe this is the source of the spurious "non-object
have no members" bug that has been reported.
The message 'Alert: catching up on tile delete queue'
comes from the fact that 48 tiles are scheduled and
added to the cache at startup before the plane location
is initialized. My proposed patch is to initialize
SGLocation with an invalid position and detect this
fact before scheduling tiles. I prefer to do that
rather than testing for lon and lat being 0,0 because
it is a valid position and someone could want to fly
near Accra.
This patch is for windows only. It hides the console window
until there is a message to print. It only support SG_LOG,
that I think is the right way to display something in FG.
points are too close together, this routine can return a course of "nan"
but the distance is valid. Someday someone who understands the math should
rewrite the gc_calc_course_dist() routine so it is more robust, but for now
it's easiest to simply check for a nan result and code around the limitation.
Here are some updates for the metar class:
- support for empty visibility group
- support for 4-alnum IACO ids (rather than only 4-alpha)
- better diagnosis in exception messages
- check for 404 http response
- replace last constant by constants.h definition
uninitialized by naNum(). If it happened to be constructing it on the
stack in a location previously occupied by a real reference, it would
generate a corrupt naRef.
So as you passed through the target glide slope from low to high it would
be colored: red -> white -> small range of transition to red -> white.
Now it goes the right way so you get: red -> smooth transition to -> white.
You can tell you are getting high if you see the bottom vasi start to turn
pink ... etc. etc. hopefully just like in real life.
The attached patch adds a new animation class, called SGAlphaTestAnimation, to enable alpha test in 3D models.
This will remove many artefact caused by painting order of translucent models, and I need it for an upcoming model. In addition, I added a min-factor and a max-factor to the range animation to modulate min-m, min-property, max-m or max-property.
There are constructors for sg_io_exception that don't initialize the
location. In this case getFormattedMessage does still output an extra
line with " at" followed by ... nothing. Looks silly.
There's another problem with sg_socket.cxx: the timeout value is
hardcoded as 0. This is appropriate for servers as they continuously
poll the socket and never want to wait for clients. But clients
*do* want to wait a few seconds for a server response.
> When a c172 is on one machine, I only got segfault on an animation
> not found. This animation is named ControlsGroup and I guess
> that one object name referenced in this null animation no
> longer exist in the .ac model. I say that because the
> preceding one is analogous and works.
>
> So I would say the multiplayer works, except when there is a c172.
It seems that this animation refers to 'PanelInstruments' that is
a panel outside the model, so, when loaded with SGModelLib::load_model
the object is not found in the model and there is a non tested
read access through a null pointer in sgMakeAnimation.
This patch is there to correct a problem that prevent to load static objects when specifying a relative fg-root or a different, relative, fg-scenery. It appears that there is a mix between fg-root, fg-scenery and PLIB's model-dir.
It has been reported on the list that users are not able to see the buildings, especially those running the win32 builds because they run 'runfgfs.bat' that set FG_ROOT=./DATA.
I decided not to use model-dir because it just add confusion and to build a valid path earlier.
This patch was inspired by Norman. Otherwise there is a segfault on Linux because the global variable tries to access OGL before a valid context is initialized.
- SkyContext.[ch]pp needs to query the window size, but apparently doesn't
do anything with it. We can hard wire a size and the cloud code seems to
behave fine.
- SkyLight.[ch]pp depends on glut_shapes so I copied over the code so it
can access those routines locally. (The routines that are used are
simply combining calls to libGLU.a
Note that SSG and OpenGL use different representations
of Matrices.
1) SSG is row major and OpenGL is column major
2) SSG uses a Z is up whereas conventionally OpenGL uses
Z is pointing into the screen
ie this just requires swapping the Y and the Z axis < columns >
and negating the new Y column
3) Now since SSG eventually calls OpenGL SSG must do this
for us behind the scenes or else things just wouldn't work
so inorder to get Clouds3D to render in the proper location
we should just need to use the Matrix that SSG uses for a Camera
Matrix and pass this directly to the Clouds3D Camers
Fixed texture translation so step and scroll values work with interpolation tables as well. Moved step/scroll calculation to utility function to improve code readability.
This update adds the ability to do multiple texture transforms (Steve B. thinks supporting them at the plib level would be inefficient, which is probably true).
Removed units (e.g. "_m") from texture translation property and variable names since the texture translation values are dimensionless.
Added the ability to specify a scroll factor for stepped texture animation that needs to scroll smoothly when approaching the step interval (e.g. odometer movement).
- Added documentation for SGCloudLayer
- Updated the SGSky interface a bit to make it more sensible, flexible,
and generic. This requires a code tweak on the FlightGear side as well.
the dimensions provided.) We draw the sky dome before everything else
and draw it with depth buffer off so it really doesn't matter, but it just
makes a little more sense this way.
Updated a few doxygen comments.
1. Added support for defining arbitrary rotation axes using (x1,y1,z1), (x2,y2,z2). The center is calculated automatically (midpoint on line) or you may specify an alternate "center" using the current scheme. This makes it about 100 times easier to animate flaps, ailerons, etc.
2. Added support for plib's ssgTexTrans. This will allow more sophisticated 3D instrument features by allowing the texture mapping itself to be animated. Included function for "texrotate" and "textranslate". They configure the same as the geometry, except the arbitrary axis definition is not necessary (textures are flat).
the API and I don't believe we'd have any hope of running at any kind of
reasonable frame rates on a non-hardware-3d accelerated box these days anyway.
to const/no-const variants of the prop->getNode() method, the 2nd bool
argument was getting promoted to an int so it would match a method with
a const SGPropertyNode * as the first argument. But that made
it match the wrong version of prop->getNode() and things were failing.
Yikes! This is one I could have stared at for days to figure out so I'm
glad I caught on to the problem. :-)
- Split out the condition code from fgfs/src/Main/fg_props and put it
in it's own source file in simgear/props/
- Created a scene subdirectory for scenery, model, and material property
related code.
- Moved location.[ch]xx into simgear/scene/model/
- The location and condition code had dependencies on flightgear's global
state (all the globals-> stuff, the flightgear property tree, etc.) SimGear
code can't depend on it so that data has to be passed as parameters to the
functions/methods/constructors.
I am trying to compile tabbed_values.cxx and found that it requires
assert.h to compile with MSVC (on Linux, it must be included indirectly).
There is a patch below
Could the file(), dir(), base() and extension() functions be made const member
functions. As it stands they cannot be applied to const reference/pointer
values which limits their usefulness.
Curt:
Yes.
- added a new class in simgear/misc, SGTabbedValues, which parses a
null-terminated string of data separated by tabs into fields, and
supports safe conversion into various other datatypes.
Some more cmall changes to the SimGear header files and removed the
SG_HAVE_NATIVE_SGI_COMPILERS dependancies from FlightGear.
I've added a seperate JSBSim patch for the JSBSim source tree.
This patch adds some more functionality to the header files and removes
*all* dependencies on SG_HAVE_NATIVE_SGI_COMPILERS in the SimGear code!
[dpm: I had to add some additional SG_USING_STD declarations to make
it compile]
This patch adds some missing default ISO C++ headers to SimGear,
especially usefull for Irix/MipsPro. To the best of my knowledge this
only affects the Irix/MipsPro compiler combination although it might be
usefull for others as well.
This patch does not yet remove any compiler specific code, but that
would be my next task. The powerfull macros as defined in the compiler.h
file allowed me to split it up into multiple patches.
I've had to hack Simgear's configure.ac quite a bit [for Mac OS X],
using the Plib one as a reference.
The basic construct (a big switch statement based on the target
type) is nice, I think, since it moves lots of IRIX / cygwin / OS-X
specialties out of the way cleanly. Much more re-factoring of the
current tests in configure is possible if people are able to test.
To compile the development CVS version of FlightGear(0.9.0) i had to
apply some small changes to SimGear and FlightGear.
The changes need probably some additional ifdefs for other platforms but
since my linux-hd crashed i can't verify that.
Attached is the new, improved SkyCloud.cpp. Tested on west coast @ KSFO and
east @ KJFK. Don't have any southern hemisphere or other airports to test
against, but you might give it a go and see what happens
Probably a good idea to add some user options to set cloud altitude, startup
position, etc, but for now this should suffice.
- Removed some old cruft.
- Removed some support for older versions of automake which technically was
correct, but caused the newer automakes to squawk warnings during an
initial sanity check (which isn't done very intelligently.)
NOTE: this fix is technically not correct for older version of automake.
These older version use the variable "INCLUDES" internally and could have
them already set to an important value. That is why we were appending
our values to them. However, newer versions of automake don't set this
value themselves so it is an error to append to a non-existant variable.
We seem to "get away" with overwriting the value on older versions of
automake, but if you have problems, consider upgrading to at least
automake-1.5.
2. I changed Simgear's autogen.sh so it is quieter, and errors out if
autoheader or autoconf fails. It puts all error output in autogen.err, and
deletes it if nothing errored out. The patch is in (sg.autogen.sh.patch.gz)
This patch applies to flightgear, too. If someone doesn't like what I did
here, please speak up! I really believe that this patch will help cause
less confusion among people new to compiling flightgear.
Here are some changes that gave me a significant frame rate increase of about 10 fps with random objects disabled. The interesting thing is that these changes aren't in the main loop but are in tile loader. My guess is that I've reduced the memory footprint just enough to reduce CPU cache misses, though I have no hard evidence of this.
Initially I modified all SGBinObject member functions to pass/return by reference instead of by-value. This gives little or no speed up but allows for some optimizations in fgBinObjLoad(). It is these changes that reduce the number of memory allocations. Needless copying of vectors, and vectors of vectors, can be very memory intensive, especially if they are large.
Anyway I would be interested to see if you get similar results. I would emphasize that the frame rate increase only occurs with random objects disabled. I lose about 10-15 fps on my GF2MX 32MB with random objects, probably a fill-rate limitation or texture memory thing.
not honoured after the first call. This isn't all that efficient, and
the return type probably should change to string eventually, but this
fix avoids changing the headers for now.
result, so after the first call for any node, it simply tests and
returns a pointer. This also fixes the problem of buffer conflicts
with make_string.
Added SGPropertyNode::hasChild(const char * name, int index = 0) to
provide a syntactically-cleaner way to test for the existence of a
child node, i.e.
for (int i = 0; i < 9; i++) {
if (node->hasChild("foo", i))
foo[i] = node->getChild("foo", i)->getDoubleValue();
}
While investigating, I found that SGPropertyNode::getPath returns a
(char *) pointer to the character data of a string on its stack,
i.e. to undefined memory after it returns. I remember someone was
changing strings to char* for efficiency. Perhaps this bug was
introduced then. I'll include a patch for it with my eventual patch
for the above, unless someone beats me to it. I don't think it
affects any existing callers: they all want a string anyway.
Initialise a "possibly uninitialised" variable (which was already
functionally correct).
[Note from DPM: this patch will be blown away if we ever update to a
newer version of Expat.]
Remove a hack that originally worked around a buffer overflow
elsewhere in the file. The buffer overflow was fixed long ago, but
the hack was not removed.
I have modified the SGPropertyNode interface to support node removal
and address the issues you mention yesterday.
I added the SGPropertyNode_ptr class that is a smart pointer that
increment and decrement a counter in SGPropertyNode. The _children
vector is changed to a vector<SGPropertyNode_ptr> in order for the
node to hold a reference to its children. I also added a
_removedChildren vector of the same type. When removeChild is called
with the keep parameter set to true, the reference is removed from
_children and inserted in _removedChildren, and the attribute REMOVED
is set. When getChild is called with create set to true, the _children
vector is searched, then the _removedChildren and then a new node is
created. If a resurrected node is returned, the REMOVED bit is cleared.
The static const int LAST_USED_ATTRIBUTE is also added.
The footprint of this patch is light. SGPropertyNode is one int
longer in size, SGPropertyNode_ptr is one pointer large without
virtual functions. Some functions can be inlined if your current
policy change.
The FlightGear patch is to take account the change in the getChildren
function that now returns a vector<SGPropertyNode_ptr>. If the
removeChild functionnality is to be added in FlightGear, all those
SGPropertyNode * floating around should be changed to
SGPropertyNode_ptr.
Here's a first cut at SGSocket reimplemented using plib.net. I've
maintained the same TCP server behaviour, that is only one client
connection at a time. I don't think it is possible within the current
framework to handle simultaneous clients.
I've also added two simple test programs, tcp_client and tcp_server.
Here is a total rewrite of the strutils package. I've reimplemented the
trimleft(), trimright() and trim() functions as lstrip(), rstrip() and
strip() respectively. Additionally I've added a split() function that
behaves like its perl/python equivalent. Just the thing for splitting
comma separated option strings or space separated telnet commands and
arguments. I've also enclosed the whole thing in a namespace
simgear::strutils. Since I seem to be the only one who uses these
functions, SimGear and FlightGear compile without change.
PS It is no coincidence that the new function names bear an uncanny
resemblance to the python functions of the same name.
Tbis is a first patch in a series to clean up SimGear by removing
warning messages. Most of them are straight forwared, but in pops.hxx
the compile complaints about "type qualifier is meaningless on return
type". I think it's up to you to decide if you want that part applied.
A const char * is not supposed to change and cannot be deleted. So
here is a patch that remove unnecessary const from props.hxx and
props.cxx. There also is the addition of a friend directive because
nested classes do not receive special privileges and cannot access
private members of the outer class.
are things that are needed, but that many systems already have packages
available to install, and many users may have versions of these already
installed to support other projects. So rather than build and install by
default with the main SimGear build/install, these are kept separate so that
those users that don't have them already installed can build and install
them separately.
of actually using them in the flightgear event manager.
- Now that we have several add on libs we are bundling with simgear (but
not automatically built as part of the simgear build) I have moved them
to their own subdirectory (src-libs).
This module works mostly with char* and allocates memory with
strdup ... delete doesn't go well with malloc(). The transition
to string only would be nice, but some class interfaces return
char*, so it was more natural to just drop the deletes.
Here is a patch that fixes a little problem in dome.cxx: The fog_color
is created in a sgVec3 (227) but then handed over to ::repaint(), which
expects a sgVec4 (282). Then (343) center_color (although defined as
sgVec4) is only initialized with 3 values, but later (441) assigned to
'slot' via sgCopyVec4.
at several places material was copied to "buffer" using strncpy
without adding a closing '\0'. This again lead to access to non
initialized memory and potentially (and actually at least in one
case) to feeding garbage to atof(). In case the following garbage
happened to start with digits, we would get funny time
values. :-)
I just added the obligatory "buffer[n] = 0", which doesn't
really look professional now. Maybe we should use the string
class or define a helper function that strncopies =and= adds
a trailing zero?
The last hunk fixes another buglet, that wasn't dangerous
at all, but caused an error message. The loop that should cut
the string at hash marks ('#') did neither stop at such, nor at
string ends. It always scanned the whole 256 character long
buffer and accessed uninitialized memory. valgrind doesn't
like that. I dropped the 256 counter, because fgets =does=
add the closing zero. It is safe to scan until we either
get the zero or the hash mark.
interface instead of string. This will result in a lot more
efficiency later, once I add in a simple hash table for caching
lookups, since it will avoid creating a lot of temporary string
objects. The major considerations for users will be that they cannot
use
node->getName() == "foo";
any more, and will have to use c_str() when setting a string value
from a C++ string.
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
Zlib Advisory 2002-03-11
zlib Compression Library Corrupts malloc Data Structures via Double Free
Original release date: March 11, 2002
Last revised: March 11, 2002
Source: This advisory is based on a CERT advisory written
by Jeffrey P. Lanza http://www.kb.cert.org/vuls/id/368819
Systems Affected
* Any software that is linked against zlib 1.1.3 or earlier
* Any data compression library derived from zlib 1.1.3 or earlier
Overview
There is a vulnerability in the zlib shared library that may introduce
vulnerabilities into any program that includes zlib. This
vulnerability has been assigned a CVE name of CAN-2002-0059
http://cve.mitre.org/cgi-bin/cvename.cgi?name=CAN-2002-0059
I. Description
There is a vulnerability in the decompression algorithm used by the
popular zlib compression library. If an attacker is able to pass a
specially-crafted block of invalid compressed data to a program that
includes zlib, the program's attempt to decompress the crafted data
can cause the zlib routines to corrupt the internal data structures
maintained by malloc.
The vulnerability results from a programming error that causes
segments of dynamically allocated memory to be released more than once
(aka. "double-freed"). Specifically, when inftrees.c:huft_build()
encounters the crafted data, it returns an unexpected Z_MEM_ERROR to
inftrees.c:inflate_trees_dynamic(). When a subsequent call is made to
infblock.c:inflate_blocks(), the inflate_blocks function tries to free
an internal data structure a second time.
Because this vulnerability interferes with the proper allocation and
de-allocation of dynamic memory, it may be possible for an attacker to
influence the operation of programs that include zlib. In most
circumstances, this influence will be limited to denial of service or
information leakage, but it is theoretically possible for an attacker
to insert arbitrary code into a running program. This code would be
executed with the permissions of the vulnerable program.
II. Impact
This vulnerability may introduce vulnerabilities into any program that
includes the affected library. Depending upon how and where the zlib
routines are called from the given program, the resulting
vulnerability may have one or more of the following impacts: denial of
service, information leakage, or execution of arbitrary code.
III. Solution
Upgrade your version of zlib
The maintainers of zlib have released version 1.1.4 to address this
vulnerability. Any software that is linked against or derived from an
earlier version of zlib should be upgraded immediately. The latest
version of zlib is available at http://www.zlib.org
The md5 sums of the source archives are:
abc405d0bdd3ee22782d7aa20e440f08 zlib-1.1.4.tar.gz
ea16358be41384870acbdc372f9db152 zlib-1.1.4.tar.bz2
IV. Acknowledgments
Thanks to Owen Taylor and Mark Cox of Redhat, Inc. for the
reporting and research of this vulnerability.
This document is available from
http://www.gzip.org/zlib/advisory-2002-03-11.txt
The public PGP key of zlib author Jean-loup Gailly is available from
http://www.gzip.org/zlib/jloup.asc
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.0.6 (GNU/Linux)
Comment: For info see http://www.gnupg.org
iD8DBQE8jSR02aJ9JQGWcacRAuDEAKCWdrRkWeJV9lYU5z8NN56s3m8eKACglR4m
42KDUGHuftBkwACTMCnZLEo=
=3yLS
-----END PGP SIGNATURE-----
For each major primative type: points, triangles, fans, and strips, you
can specify an index list of vertices, normals, colors, and texture
coordinates. You can skip any of these you like to save on space.
Note that the work for this has only been done in the file format reader
and writer. The FlightGear loader for instance still needs to have
support for this built in.
This is is one more small step towards runway lighting.
*all* properties to be written, rather than just the ones flagged as
archivable. Tony Peden requested this feature to make it easier for
people to document properties.
The useDefault argument for the SGPropertyNode::tie(...) methods will
invoke the setter only when there is already a property value defined;
previously, the setter was always invoked, with a default value if
necessary.
time calculations for an alternate calendar time (i.e. if the application
is being driven from an external source of data.)
Fix a bug in sg_binobj.cxx which disrupted the 'broken down time' globally
for the entire application.
1. Nodes cache previous relative paths so that they do not have to
parse the paths each time.
2. There are new getNode() methods that include indices, so that users
do not have to sprintf to a buffer to iterate through indexed nodes.
developer will need to build and install these separately if they
don't have packages already installed by their system. See
README.metakit and README.zlib for more details.
As a convenience, pristine tarballs of the metakit and zlib source
code trees are included with the simgear distribution (and cvs.)
developer will need to build and install these separately if they don't
have packages already installed by their system. See README.metakit and
README.zlib for more details.
As a convenience, pristine tarballs of the metakit and zlib source code
trees are included with the simgear distribution (and cvs.)
- automake-1.4 sets default values for INCLUDES which we can't
overwrite.
- automake-1.5 renames this to DEFAULT_INCLUDES and leaves INCLUDES
open for the developer to use.
Thus for automake-1.4 we are forced to 'append' to INCLUDES and in
automake-1.5 we can just set the value to whatever we like.
Unfortunately, the behaviors of the two versions are mutually
incompatible.
The solution I am committing now works for both versions but
automake-1.5 generates a lot of spurious warning messages that are
annoying, but not fatal.
TRACE_READ - log a message whenever the property is read.
TRACE_WRITE - log a message whenever the property is written.
The second one works only when the property value is changed through
the property manager; tied variables and accessors are not polled for
value changes because of the performance hit.
These methods end up invoking private methods
SGPropertyNode::trace_read and SGPropertyNode::trace_write. By
setting breakpoints on these methods inside a debugger, it is possible
to debug property access and find what parts of a program are reading
or writing specific property values by doing a backtrace.
In the XML property files, users can use the attributes 'trace-read'
and 'trace-write' to control tracing; the value should be 'y' to
enable tracing or 'n' to disable it (the default).
model math blows up, the lat/lon could be nan. Thus updateLocal() could
potentially called with nan arguments if FlightGear is reiniting from a
blown up state. This is a bug in FlightGear, but I've added a simple
check to catch this so updateLocal() is robust if called under these
circumstances.
I can't find anything that addresses this in Stroustrup, but I also don't
see them doing this in any of their examples. So I have rewritten this
instance to use default arguments to accomplish the same thing. I imagine
there are other instances of this same sort of thing in other classes to
be fixed at a later date.
- changed return type of readXML from bool to void (uses an exception
to report problems now)
- removed XMLVisitor::error callback
- declared new readXML function that uses a path rather than a stream
- modified existing readXML function to take an optional path parameter
- implemented new readXML function with path instead of stream
- modified existing readXML function to use optional path parameter
- modified readXML to throw exceptions rather than returning a bool
value on error
file-name variant to invoke new readXML function
- readProperties and writeProperties will now throw exceptions if there
are file I/O problems
- replace error messages with exceptions
- tunnel sg_io_exception through from nested property read, since
the C-based Expat code cannot handle exceptions
- modified to write out non-archivable parents if they have an
archivable descendant (i.e. archive="n" no longer kills a whole
subbranch); this makes sense now that archive defaults to "n".
- don't save the flags -- let the program handle them itself
- produce slightly less verbose output; omit n="0" in elements
- renamed UNKNOWN to UNSPECIED and setUnknownValue to
setUnspecifiedValue
- modified routines to use 'read', 'write', and 'archive' attribute
for access-mode attributes (only if non-default; they all default to
'y')
- modified write routine to honour ARCHIVE attribute (won't write
subtree if ARCHIVE is not set)
the class
- renamed UNKNOWN to UNSPECIED and setUnknownValue to
setUnspecifiedValue
- added access-mode attributes
- added methods for setting and querying access-mode attributes
unaliased first
- renamed UNKNOWN to UNSPECIED and setUnknownValue to
setUnspecifiedValue
- modified get*Value and set*Value methods to respect READ and WRITE
attributes
copies of their arguments
- modified prototype for command functions -- they now take a pointer
to a pointer of an SGCommandState object (which they will normally
subclass) so that they can cache state between invocations
- commented out convenience execute methods until they're actually
needed
- changed return type of SGPropertyNode::getType methods from
SGValue::Type to SGPropertyNode::Type
- made SGPropertyNode::getValue and SGPropertyNode::hasValue private
so that applications cannot get at SGValue instances (SGValue is
slated for removal)
flightgear, especially when this occurs in a simgear .hxx file. This is
now expressly forbidden, and will cause problems anyways because we now
changed the name to <simgear_config.h> which isn't installed, so you can't
include it in an installed header file.
mutex that unlocks the mutex when the SGGuard object goes out of scope.
The SGxxxQueue<T> template family factor out the common behaviour we
need for passing data between threads.
1. Fixed a bug reported by Curt for one of the getChild methods.
2. Cleaned up some of the error reporting, and require PropertyList as
the root element name. Also uncluttered the XML output a little
(removed type="unknown").
3. Added a new Long type (i.e. setLongValue, getLongValue, etc.), as
requested by Curt aeons ago.
4. Added aliases, so that a property's value can directly reflect the
value of another property.
5. Added a generalized inclusion facility, with parameters (panel
writers should love this one).
magnetic variation for a specific location and date without running an
update cycle (I use this for setting up VOR default offsets in some
FlightGear patches).
2. [CRITICAL] Fixed some null-pointer bugs in simgear/misc/props.cxx.
Added '--with-cxx=COMPILER[:flags]' to ./configure in order to set the
compiler and flags. If this option is omitted then the default compiler
is assumed (ie the current behaviour). This duplicates the effect of
passing CC, CFLAGS, CXX and CXXFLAGS on the command line to configure
and make.
SimGear/simgear/compiler.h
Initial support for KAI C++ on linux.
SimGear/simgear/ephemeris/celestialBody.[ch]xx
Removed extraneous semicolons.
SimGear/simgear/io/sg_file.cxx
MSVC tidy up.
being careful to manually call getState()->apply() before the glPushAttrib()
so that the ssg state handling mechanism doesn't get derailed accidentally.
it is only built if it doesn't already exist on the user's platform.
gdbm is a set of database routines that use extendible hashing and works
similar to the standard UNIX dbm routines. This guarantees the availability
of gdbm to any application that uses SimGear.
Classic space vs time seemed worth it in that we get a ~3 fold speedup
for ~5% space increase here. Also pow() is an expensive Fortran to C
translation in just about all the old government code I see :))
Here's a few changes I made to fg-0.58 this weekend. Included are the
following features:
- Sun and moon have a halo
- The moon has a light vector, moon_angle, etc. etc. so that we can have
some moonlight during the night.
- Lot's of small changes tweakes, including some stuff Norman Vine sent
me earlier.
- The new classes in libmisc.tgz define a stream interface into zlib.
I've put these in a new directory, Lib/Misc. Feel free to rename it
to something more appropriate. However you'll have to change the
include directives in all the other files. Additionally you'll have
add the library to Lib/Makefile.am and Simulator/Main/Makefile.am.
The StopWatch class in Lib/Misc requires a HAVE_GETRUSAGE autoconf
test so I've included the required changes in config.tgz.
There are a fair few changes to Simulator/Objects as I've moved
things around. Loading tiles is quicker but thats not where the delay
is. Tile loading takes a few tenths of a second per file on a P200
but it seems to be the post-processing that leads to a noticeable
blip in framerate. I suppose its time to start profiling to see where
the delays are.
I've included a brief description of each archives contents.
Lib/Misc/
zfstream.cxx
zfstream.hxx
C++ stream interface into zlib.
Taken from zlib-1.1.3/contrib/iostream/.
Minor mods for STL compatibility.
There's no copyright associated with these so I assume they're
covered by zlib's.
fgstream.cxx
fgstream.hxx
FlightGear input stream using gz_ifstream. Tries to open the
given filename. If that fails then filename is examined and a
".gz" suffix is removed or appended and that file is opened.
stopwatch.hxx
A simple timer for benchmarking. Not used in production code.
Taken from the Blitz++ project. Covered by GPL.
strutils.cxx
strutils.hxx
Some simple string manipulation routines.
Simulator/Airports/
Load airports database using fgstream.
Changed fgAIRPORTS to use set<> instead of map<>.
Added bool fgAIRPORTS::search() as a neater way doing the lookup.
Returns true if found.
Simulator/Astro/
Modified fgStarsInit() to load stars database using fgstream.
Simulator/Objects/
Modified fgObjLoad() to use fgstream.
Modified fgMATERIAL_MGR::load_lib() to use fgstream.
Many changes to fgMATERIAL.
Some changes to fgFRAGMENT but I forget what!
- use strings for fg_root and airport_id and added methods to return
them as strings,
- inlined all access methods,
- made the parsing functions private methods,
- deleted some unused functions.
- propogated some of these changes out a bit further.
Solaris' CC. Fixed a bug in fg_debug.c with how the fgPrintf() wrapper
passed arguments along to the real printf(). Also incorporated HUD changes
by Michele America.
Ported Steve's Audio library first to OpenBSD and IRIX and
after that also to Win32
David Megginson <david@megginson.com>
SimGear property manager/registry
Tim Moore
Ported the (chrome) "shader" animation to OSG, and helped with porting
the "material" animation.
Curt Olson http://www.flightgear.org/~curt/
Curt is responsible for overall project and source code management.
He has his hands in many of the areas.
Petter Reinholdtsen <pere@games.no>
Incorporated the Gnu automake/autoconf system (with libtool).
This should streamline and standardize the build process for all
Unix-like platforms. It should have little effect on IDE type
environments since these don't use the Unix make system.
Paul Schlyter <pausch@saaf.se>
Mr. Schlyter provided Durk Talsma with all the information
he needed to write the astro code. Mr. S. is also willing
to answer astro-related questions whenever one needs to.
http://welcome.to/pausch
Durk Talsma <d.talsma@chello.nl>
Accurate Sun, Moon, and Planets.
Sun changes color based on position in sky.
Moon has correct phase and blends well into the sky.
Planets are correctly positioned and have proper magnitude.
Added time zone support in the SGTime class.
Help with time functions, gui, and other misc stuff.
http://people.a2000.nl/dtals
Mark Vallevand <Mark.Vallevand@UNISYS.com>
Contributed some METAR parsing code.
Contributed some win32 screen printing routines.
Gary R. Van Sickle <tiberius@braemarinc.com>
Contributed some initial GameGLUT support and other fixes.
Has done some interesting preliminary work on a binary file format
http://www.woodsoup.org/projs/ORKiD/fgfs.htm
Has set up a 'Cygwin Tips' site that has been very helpful to many
people in getting a Cygwin Unix-on-Windows build environment set up
so they can build FG effectively.
http://www.woodsoup.org/projs/ORKiD/cygwin.htm
Norman Vine <nhv@yahoo.com>
Provided more than uncountable URL's to the "FlightGear Community".
Many performance optimizations throughout the code.
Lots of windoze related contributions.
Contributed wgs84 distance and course routines.
Contributed a great circle route autopilot mode based on wgs84 routines.
Ed Williams <Ed_Williams@compuserve.com>
Contributed magnetic variation code (impliments Nima WMM 2000)
We've also borrowed from Ed's wonderful aviation formulary at various
times as well.
http://www.best.com/~williams/index.html
Jean-Claude Wippler <jcw@equi4.com>
Author of MetaKit - a portable, embeddible database with a portable
data file format. This software is not GPL'd but the author is kindly
allowing us to bundle MetaKit with our code. MetaKit has a liberal
X/MIT-style license. Please see the following URL for more info:
http://www.equi4.com/metakit
WoodSoup Project http://www.woodsoup.org
Provided computing resources and services so that the Flight Gear
project could have real home. This includes, web services,
ftp services, shell accounts, email lists, dns services, etc.
Robert Allan Zeh <raz@cmg.FCNBD.COM>
Helped me tremendously in figuring out the Cygnus win32 compiler and
how to link with .dll's. With out him the first runable win32
version of FG would have been impossible.
NOTE:
----
THIS DOCUMENT WAS INITIALLY WRITTEN BY
Curt L. Olson <http://www.flightgear.org/~curt>
05 Jul 2000 Removed non-SimGear entries (CLO)
08 Mar 2000 CONTENTS RESEARCHED AND UPDATED by
Oliver Delise <delise@mail.isis.de>
Some files were not shown because too many files have changed in this diff
Show More
Reference in New Issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
ThorstenB