It may intuitively feel upside down, but the current behaviour actually matches base.mouseWatcherNode, so this is probably the most consistent thing to do.
We need third-party extensions that link with the Panda3D libraries to continue to work when shipping them with the optimized libraries that deploy-ng uses. To do this, we need the optimized build not to omit symbols that these extensions might depend on.
This should especially help with trimesh generation performance, which previously formatted a complete description of the trimesh to the debug output even if it was disabled.
The _render_stages and _render_ff_stages cannot simply be copied, because they contain pointer references to the previous TextureAttrib. Never copy them, and always mark _sort_seq as stale.
This fixes a test failure in replace_texture.
This is particularly the case when requesting a core-only profile (gl-version 3 2) where luminance textures are deprecated.
There is apparently no way to emulate them with swizzles (as we do with luminance textures), so we'll have to duplicate the channels out.
Fixes#693
These should be protected by an is_debug() check so that they can be optimized out properly in a release build. Setting check-debug-notify-protect in Config.prc can be used to track down cases of missed checks.
A task returning DS_interrupt would only interrupt the current task chain, not the entire task manager. This meant that other tasks might get run with an exception state set, causing the exception state to get stomped on or the Python interpreter to complain.
Fixes#692
This is meant to be used alongside gl-version to request a "forward compatible" OpenGL 3.0 or 3.1 context, which removes support for deprecated features such as the fixed-function pipeline.
Any kind of skipping is supported on any kind of stream, actually, but some uses may require reopening the file and skipping some number of bytes, so a warning will be displayed in some cases.
I figure this feature is particularly interesting for .wav files since they are (1) often used for short samples, where skipping bytes is not really a big deal, and (2) aren't inherently compressed so would benefit particularly from zlib compression.
This isn't working properly at the moment, since the state gets set for the *next* object, causing significant artifacts. I wasn't entirely sure whether to restore the "proper" behavior or not, since applications may be relying on one or the other behavior, but enabling this feature for shaders is a minefield and it's a lot better to just tell people to use p3d_ColorScale instead.
Rather than xforming after the fact, which does not work properly for boxes, we need to apply the transform to the vertices around which the box is generated.
Fixes#506
- DisplayInformation now gives the list of display modes returned by XRRGetScreenResources if RandR 1.2 is supported, which is apparently more reliable than the previous XRRSizes/XRRRates approach.
- Switching fullscreen on X11 to the current resolution on the CRTC that the monitor is on will make the window cover the CRTC properly, rather than forcing the window to have an origin of (0, 0).
- Passing in the pipe's display width/height is commonly done to go fullscreen at native res, but this may not correspond to a real display resolution. It now detects when this is done, and interprets this as "go fullscreen at the native resolution on the current CRTC".
Fixes#575
Checks if the value of Config.prc for `depth-bits` is `1` and sets it
manually to 24.
This prevents getting a 16 bit depth buffer on macos
Intended to address #501Closes#551
This is not intended to be used just yet in 1.10, but already added in preparation for changes on master to support #546. I'm just allowing Panda to parse the syntax ahead of time to reduce potential .egg incompatiblities.
If too many shadow-casting lights are active, too many TEXCOORD varyings will be used and a shader compilation error will be displayed. Instead, Panda will now just do the calculation in the fragment shader if not enough varyings are available. It's slower, but better than crashing.
* In C++ reference, only pick up classes defined in .h file
* Add a few excludes to C++ reference that aren't public API
* On class index pages, reduce number of columns
* Add @since for some methods/classes that are new in 1.10.0
* Fix/improve a few docstrings here and there
Apparently eof() in older versions of libc++ returns true if the last character has just been read, whereas the proper behavior is only to return true when attempting to read past the end of the stream. Since failbit is reliably set in all cases when reading past the length of the stream, we should only trust the result of eof() if fail() also returns true.
Specifically, this happens if you have a custom ShaderGenerator that assigns shader inputs via the ShaderAttrib. If two objects then both have the auto-shader turned on, and the shader generator generates ShaderAttribs with the same shaders but different inputs, the inputs will not be updated properly for one of the objects.
When Steam runs, it mutes all input from the Steam Controller and instead registers a virtual gamepad that obeys the Big Picture controller remapping. We want to make sure to pick that one, since the "real" Steam Controller doesn't report any events while the virtual device is active. So we carefully consider the "real" Steam Controller "inactive" if the presence of the virtual device is detected, until the virtual device is disconnected (ie. when Steam is closed) or if it turns out that it is generating events after all, in which case it gets automatically reactivated.
This is a bit of a hack, maybe there is a cleaner way of doing this.
This is needed to handle cases where XInput is being emulated, such as when running via Steam with the Steam Controller active. Steam's shim does not send out WM_INPUT_DEVICE_CHANGE events.
Adds ability to register "obsolete" names for certain types under older .bam versions, so that we are still able to write out old .bam files.
Fixes#347
This, in combination with ebef9f3de8, makes it easier to catch issues in code that is accidentally letting get temporary TransformState objects get destroyed. It does not affect release builds.
In older BAM files (version <= 6.42), _fixed_depth will have an uncertain value after loading, leading to incorrect transform calculations, which cause rendering issues (see issue #474)
Shaders without #version line (which are supposed to indicate GLSL 1.10) will be interpreted differently by different drivers, so this is almost certainly a mistake. In the future, we can forbid this altogether or insert #version 110 automatically.
This makes it possible to use BillboardEffect to specify a fixed distance to the camera, in order to keep them at a fixed apparent size.
This also enables serialization to .bam of the reference NodePaths of BillboardEffect and CompassEffect.
c18abad8c3 added a call that resets the m_isInContact flag, so this resets it, for better or worse. We may want to revisit whether #349 was indeed the right fix to #250.
Fixes#453
Officially, in core profile OpenGL 3.2+, calling it with a value higher than 1.0 is an error, but many vendors seem to let us. Apple's implementation does not. It appears that checking the maximum line width is a way to deal with this.
Fixes#466
Functions get_point_a() and get_point_b() appear to return the top of the cylinder section of the tube, not the tip of the endcap, making subtracting the radius unnecessary.
Even a brief error message in the assertion is infinitely more useful to a user who is not at home in the source code, especially for assertions that may reasonably be triggered by honest user mistakes.
It's not really reasonable to expect a user to find every occurrence of a cached resource that might be using an open stream and remove it or crash otherwise.
This is fixed by keeping the multifile stream open as long as any substreams are still pointing to it, using a simplified reference counting (care is taken not to fully make StreamWrapper reference-counted, since it's not in express and existing uses should not be broken).
Fixes#449
Also see #428
Having depth test disabled is the default OpenGL state, and callbacks may quite reasonably expect to see the default state. Kivy seems to expect this, for one.
This is necessary for GLSL 1.30 which deprecates gl_FragData but does not yet support layout(location=) specifiers
Also fix some function pointer checks for pre-GL 3.0
Fixes#455
Previously, all draw calls would be grouped under "Primitive Setup", rather than under the appropriate bin collector. This commit fixes that and adds a few other useful collectors as well.
This is an optimization, which will skip begin_frame/end_frame for a buffer that isn't going to have anything rendered to it. Affects the RenderPipeline.
This changes includes so that local includes are consistently
#include "localFile.h"
while system and third-party includes are consistently
#include <systemFile.h>
This commit mostly converts the former to the latter; the two
exceptions are in android_main.cxx and fmodAudioSound.h, where
the reverse was necessary.
Although these aren't used outside of libpanda(express), they
are used by their neighboring component libraries, which means
they should be exported so that this works correctly when the
metalibs feature is disabled.
* Previously it only looked for the resolved path, but sounds are not stored with resolved path in the cache (possibly a different bug?)
* It only uncached samples, not streams
Fixes#428
This is for consistency with fbbc5bb9e6 which introduced the
same `#undef Configure` in dxgsg9. This prevents dtool's own
Configure() macro from conflicting with the declaration of
D3D9's Configure function in d3d9.h.
This is done by only writing out a #line when the first non-whitespace line is encountered; any blank lines before that are trimmed. This cuts down the size of the preprocessed shaders for a large project with many shader includes, such as the RenderPipeline.
This method of checking for pnhpast.dll was actually for
DirectX 8.1 (see a16fe56c7) and its presence in the DX9 code
is largely due to the copy-and-paste nature of how the DX9
GSG was created from the DX8 code.
This file isn't compiled, and I'm pretty sure never has been
compiled. The dependence on "config_wdxdisplay9.h" (which has
never existed) and absence of any commits that address its
functionality reinforce the idea that this is actually just
dead code.
This seems like an artifact copied over from the DX8 code,
that nobody cared enough to get working or delete.
Since this still takes a long time to build, even with the previous change, it would be better for one CPU to chew on this in the background while the rest of the build continues.
This applies to building with MSVC and Eigen specifically. Apparently, fetch_specified_part is taking up most of the compile time here. I have no idea why these changes in particular make it faster, but they just do.
This is a method for getting the animated vertex data that will keep working even if GeomVertexData::animate_vertices() gets deprecated due to #421 being fixed.
Credit for missing includes to @treamology in Git commit
16cfac4829
CGTableCount removed; modern macOS seems to call this
a uint32_t instead. I can find no reference to CGTableCount
in any documentation, and the (very old) source code I dig
up just typedefs it anyway.
- display: GraphicsWindowProc should have a virtual destructor,
as it's meant to be subclassed.
- express: set_matrix_view helper should always fail an assert
when 'size' is wrong, even on release builds.
- express: Fix filename capitalization on some #includes.
They're normally Windows-only, where case doesn't
matter, but it's better to be consistent.
- gobj: Fix typo.
- particlesystem: Remove BaseParticle::_last_position.
Last position is tracked by PhysicsObject now.
- windisplay: Heed warnings about casting bool to (PVOID).
Also, per MSDN docs, SPI_SETMOUSETRAILS uses the
uiParam argument and ignores pvParam, so pass the
_saved_mouse_trails value in that way.
The no-arguments get_text() and set_text() will now return Unicode strings in Python 3, but passing in an encoding will make them return/take bytes objects.
In Python 2, they all take regular strings, but Unicode is also accepted by the no-argument get_text() and set_text().
In the future we probably want to remove most of this interface for Python users, to whom all this is unnecessary since it duplicates functionality already in the standard library.
- T_off now actually properly disables vertex colours
- T_vertex is now the default, to preserve the previous behaviour
- ShaderGenerator behavior is now the same as in the FFP
- tests are updated to verify new behavior
- tests now properly use vertex colours, previously they accidentally only used flat colors
- With color-scale-via-lighting off and no color scale, color is no longer munged
- p3d_Color in GLSL shaders is now properly set to white instead of black with T_off mode
- In DX9 shaders will now sample white color for absent or disabled vertex color
Fixes#401
Also see #371
- Rename "controls" terminology for analog inputs to "axes"
- Change some naming of accessors
- Unexpose methods where they are available as properties
- Add serial_number field
- Put battery levels under a "battery" field
This reimplements the spinlock on top of std::atomic_flag, which is guaranteed to be lockless. It also inserts the PAUSE (REP NOP) instruction which is strongly recommended to be placed in busy-wait loops by Intel.
This also includes a recursive spinlock implementation.
The spinlock implementation is disabled by default, but can be enabled by adding the --override MUTEX_SPINLOCK=1 flag to makepanda.
This is done using a Python extension function, which also happens to make the call more efficient as this avoids an extra copy. The C++ version still returns std::string as there is still a lot of C++ code that relies on that.
Fixes#297
This might have only been an issue in some drivers (not sure, spec is a bit vague here).
Apparently we need to call glMaterial *after* the color material setting has been disabled for it to stick.
Fixes#369
This setting causes asserts when modifying certain material flags after they are assigned to a node, in case a shader has been generated that uses the materials, which cannot efficiently detect whether the material has changed. However, we already sort of have a (inefficient, but effective) solution for this in TextureStage (see #178) that we could just apply here as well: changing the material attributes after such a shader has been generated could call GraphicsStateGuardianBase::mark_rehash_generated_shaders().
In the future, we should replace the material model with one that does not require shader regeneration for such seemingly trivial property changes.
Fixes#370
Currently, the WeakPointerTo comparison operators compare the raw pointers, but this is not useful as it may cause a false equality if one weak pointer in the comparison is expired and points to memory that has since been reused.
Instead, we can define a comparison based on the control block pointer, which exists since the new weak pointer implementation in 0bb81a43c9. This is implemented in the owner_before method, matching C++11 std::weak_ptr semantics.
I would now recommend deprecating most comparison operators of WeakPointerTo or redefining them to make more sense, ie. comparing equal if they (once) referred to the same object and not if they simply point to the same memory address. This has not yet been done, though code that uses the comparison operators has been fixed in this commit.
Overloads of std::owner_less have been provided for creating a map or set with Weak(Const)PointerTo keys.
Some drivers would report the wrong internal format. But it's silly that we query the internal format anyway, since buffer textures have a fixed sized internal format.
This is inefficient because it induces an unnecessary ref()/unref() pair when we just need to move the pointer out of the function. Thanks to 23128e4695, we can now move between related pointer types, making the .p() hack unnecessary.
This makes it possible to implicitly convert a PT of a derived type to a (C)PT of a base type, without needing to first convert it to a regular pointer. This also applies to moves, which are now more efficient due to the lack of need for ref/unref pair even if the pointer type is not exactly the same.
I'm not sure why they were ifdeffed out, but they should certainly be available so that it is possible to compare WeakPointerTo in a thread-safe manner.
This restores the old behaviour from before 29a08932ea, which makes in_window true during pointer capture (ie. click-and-drag) even if the cursor leaves the window.
X11 behaviour is already not to adjust in_window.
Fixes#363
Problem is that WGL is strict about binding context in different thread while it is still bound in another thread. Either way we need to make sure the draw thread is not rendering, so if you call get_screenshot() from a thread other than the draw thread, it uses the GraphicsEngine to wait until the draw thread is idle and then asks it to do the get_screenshot().
Fixes#360
Parenting a BulletVehicle's wheels to the chassis-BulletRigidBodyNode now works as expected. Previously doing this would make the wheels appear to be positioned one frame ahead of the chassis, because the wheel's position were synced before the chassis' position.
For more information see issue #250.
Closes#349
Bullet automatically interpolate most bodies for us (for example the "chassis"
of a BulletVehicle), but BulletVehicle-wheels must be manually interpolated by
calling 'updateWheelTransform()'. Otherwise they will slowly rubber-band
between their intended position and a position one frame ahead in time.
For more information see issue #250.
This problem occurs when movePointer is used to reset the mouse back to the center every frame, a very common way to implement mouselook on Windows (which has no relative mouse mode). Any movement between the last event loop run and the call to movePointer is destroyed, resulting in quite choppy mouselook in most implementations.
The solution is for getPointer to always return the latest mouse cursor position. This goes a long way but is not 100% perfect; see the discussion in #359 for other solutions.
Fixes#359
I think there was some confusion about how set_aux_rgba (and friends) worked; it seems the original intent was to toggle each individual buffer whereas it is actually interpreted as a count of how many of these buffers should be enabled. We should try to clarify the API and/or replace it with something better as soon as possible.
The assert is being triggered because the window is already being removed in open_windows. It does not really matter if it returns false anyway, as long as the window is removed one way or another.
This is useful because these types are created at static init time, and giving them a constexpr constructor and trivial destructor lets them be created during constant initialization, which helps to prevent static init ordering issues.
This was a regression in 0bb81a43c9 which was not keeping an edge case in mind if a weak pointer is locked during object destruction. This issue was fixed by 525a05ea2b1d00a1db901f883f1755943aeff33c, but that is not enough since it causes CharacterJointEffect::get_character() to return null now, so we need a separate method to check if a CharacterJointEffect belongs to a given character. This is more efficient, too.
Fixes#330
This came up in #330; the Character destructor caused something to call lock() on a weak pointer to that character, which would induce a ref() and unref() pair, but since the refcount was 0, this would call the destructor and thereby create infinite recursion.
I considered instead calling mark_deleted() inside unref() so that the callbacks get to run before the object is actually deleted, and was_deleted() will become true as soon as unref() reaches 0. However, this would require grabbing the lock in unref() to be fully thread-safe, since we would need to bring the refcount to 0 and mark the object as deleted in one atomic operation, so this would be an unacceptable general performance penalty.
Instead, WeakPointerTo::lock() now atomically increments the reference count if it is not already zero, and returns null otherwise. This should be safe because the object cannot be deleted while the WeakReferenceList lock is held.
Newer versions of FFmpeg deprecate returning 0 to indicate
EOF, and instead request use of AVERROR_EOF.
The oldest supported versions of FFmpeg/libav will treat any
error code the same as returning 0.
Fixes#315
This comes up when building with DEBUG_THREADS; there is a PipelineCycler created at static init time, and the type tracking in Pipeline won't work properly if the CData's parent's TypeHandle has not yet been initialized.
There is a bug in clang versions before 3.2 (including the one shipped with Xcode) that makes it give a "conflicting types" compile error when there is a static constexpr function defined outside the class. The way to work around this is either to remove one of the "static" or "constexpr" keywords, or to simply put the definition inline.
See: https://stackoverflow.com/a/17494592/2135754
I would try and upgrade Xcode to version 5 to see if the problem is fixed, but the buildbot still runs OS X Lion (10.7) and the last version of Xcode that works on Lion is 4.6.3, so it seems easier to just apply these workarounds for now.
This renames acquire/release to lock/unlock in order to be compatible with std::lock_guard and std::unique_lock (which will eventually replace the *MutexHolder classes). It will also allow us to typedef MutexImpl to std::mutex later on.
To access a WeakPointerTo in a thread-safe way, use something like this:
if (auto ptr = weak_ptr.lock()) {
..use ptr as regular PointerTo
}
The new implementation no longer needs a reference to be stored to all weak pointers on the WeakReferenceList; a mere count of weak pointers is sufficient. Therefore, callbacks theoretically no longer require a WeakPointerTo to be constructed.
The WeakPointerTo class is not actually atomic; it could be made so, but I don't believe it's worth it at this time.
We don't guarantee a specific order in this case, especially because they can be run in either order if there is more than one thread, but it is still useful to have a defined order for single-threaded task chains. To that end, tasks
are now run in the order in which they were added to taskMgr.add (in absence of any other ordering constraints).
Fixes#309
- Release the global lock during the user tick callback
and allow interactions with bullet world
- Acquire the lock again after the callback
Signed-off-by: deflected <deflected@users.noreply.github.com>
rdb
LD
Thaumaturge
Mitchell Stokes
Sebastian Hoffmann
Rishabh Tewari
Sam Edwards
tc
Donny Lawrence
Derzsi Dániel
loblao
Younguk Kim
David Staer
Brian Lach
loblao
TLOPOOperations
deflected
David Carlsson