Issue is caused by scaling for power of 2 dimensions and mipmapping that happens through GLU. It looks like the library cannot handle float colour values above 1.0 correctly. Since we are close to release I will just clamp the srgb result for now even though it will result in a small performance loss for 16 bit textures only.
I tried a few things before that, glGenerateMipmaps + no scaling (supported for 2.0 GL hardware and up), or using our own scaling instead of glu among them which worked very nicely and gave a speedup too. However, since we are close to release and there may be issues with GPU mipmap generation, see:
http://www.gamedev.net/topic/495747-another-glgeneratemipmap-question/
(old discussion but better be sure than sorry)
I went for the most compatible solution. Maybe after release this can be tested if other devs agree.
- Fixed memory lead in Carve_getIntersectedOperandMeshes
- Union manifolds only if they intersects second operand, leave manifolds
which doesn't intersect second operand as-is.
Unioning of intersecting manifold tried to perform as little union operations
as possible, but there were some not totally correct assumption which lead to
cases when unioning of manifolds of some mesh might be happened when one of
mesh sets already had got intersecting manifolds.
This commit corrects this incorrect behavior.
Discovered this when was looking into #30175: Boolean Difference causes 2.62 RC1 crash.
[#30059] Shape Keys is gone in Blender if you use Add Object Actuator in BGE
[#30024] Segmentation fault after addObject when using shape keys
[#28683] segfault in shapekey conversion code when running a game (YF, level home) twice
Issue was caused by merging triangles into quads policy which used to think
triangulation of non-planar/non-concave quads happens by 1-3 diagonal which
isn't actually correct in some OpenGL implementations.
Added check for non-concave faces when merging triangles. It will work fine if
original faces are flat. In case if original faces aren't flat this check might
fail and triangulate face when it's not actually needed or merge triangles in
a way which leads to OpenGL artifacts.
* Exploded faces that were meant to be hidden were still created with invalid vertices (0,0,0,0).
* In normal cases this went unnoticed, but for example edge split modifier crashed when it encountered these faces.
Issue was caused by making and loading editMesh in drop_named_image_invoke,
which lead to freeing/changing pointers used by CustomData layers. Some of
this pointers might be used by DerivedMesh, so we need to update DerivedMesh
after loading EditMesh.
Issues was caused by operator props "presets" which was reusing name of property
on every run of OBJECT_OT_game_property_new. This run into conflict with how text
property is determining -- it's stupid name comparsion which worked unexpectable
after adding and removing text property.
Solved by using empty (default) name for game_property_new when crating game property.
* Hair particle rotations weren't calculated properly for particle locations along a path and the "particle on path" calculations were not correct in many other ways too.
* Now the particle's location along a path is interpolated directly from the cached paths if it exist. These paths are always correctly calculated.
* Paths are now cached if a particle instance modifier using the particle system with the path option exists.
Problem was in how file selector is called by the effect_strip_add operator invoke. WM_operator_filesel() is not suited, as it directly calls exec if filepath is already set, and sequencer_generic_invoke_xy__internal() will set that path unless otherwise told. So using rather the same way to do as the one used by the other "strip_add" operators...
for after 2.62 I would like to try if using doubles would help to increase the precision here.
Also now that the mipmap patch is reverted we may want to look at this problem from a different perspective.
RES could be calculated taking the object size in relation to the camera (i.e. size and distance, ignoring rotation).
That may solve both problems of wrong resolution and lack of smoothness.
For the time being users still need to use object.resolution to fine tune the rendered text.
