It would look something like this:

http://rhulha.github.io/goojs/visual-test/goo/addons/ammopack/Ammo-vehicle-vtest.html

Hi

Does GooCreate still exist?

If so, what are the plans with its' source code? As far as I understand, there is the engine here but not the editor.

Cheers
M

Hello Adrian, Rikard, and contributors,

I'd like your opinion:

If we have a node in a 3D scene, and it has many descendants (a sub tree), what should happen when we apply opacity with a value less than 1 to it?

1. It, and all of it's children should become transparent, multiplying opacities down the scene graph.
2. It's content should become transparent but not that of its descendants.
3. Same as (1), but the whole object should be flattened into a plane.

The reason I want your opinion is because the new specs for CSS 3D (css-transforms) state here that the answer is (3).

To see what I mean, view these two examples in Chrome 53 or higher:

• https://jsfiddle.net/trusktr/ymonmo70/16
• https://jsfiddle.net/trusktr/ymonmo70/17

The second example has opacity applied to the node that contains all the sub-nodes which compose the car. The opacity, according to spec, flattens the car into a plane (turns it into paper!).

I'm asking various 3D engine authors for opinions of what the correct or most expected behavior should be.

All the best,
~ Joe

The Tweens are updated by the StateMachineSystem. Should it really be like this? Removing fsmpack.js will stop tweens :P

Solution: keep track of the local time in the actions, and use the tweening functions directly. This may sound tedious but I think it can reduce the amount of code.

Description of the problem

It's difficult and complex these days to mix WebGL libraries together, to draw things using different libraries in the same webgl context. (examples of difficulties: mrdoob/three.js#8147, pixijs/pixijs#3230, pixijs/pixijs#3345, pixijs/pixijs#1366, pixijs/pixijs#298, jonobr1/two.js#233)

For example, suppose we would like to render Three, Babylon, and Pixi objects into the same WebGL context, in the same 3D space.

It is currently very difficult to do this because each WebGL library manages state of the context in their own ways, and these private internals often change and break solutions that people come up with because there's no standard way to do it.

Pixi.js v4 goes through efforts to make Pixi compatible with Three.js, so that it can render in a Three scene, but this is obviously fragile.

Solution

Enter Regl to the party.

Maybe if the foundations for each library (Three, Babylon, Pixi, Two, etc) were built on Regl, we'd have a common way of rendering to a single context.

Regl makes an abstraction just on top of raw WebGL for managing WebGL state. It doesn't render for you all the things that Three.js can, it only provides the minimal foundation for working with raw WebGL in a stateful way that is easy to manage.

It seems that libraries like Three, Babylon, PlayCanvas, Pixi, Two, etc, could benefit from using a standardized way for managing WebGL state, which would make it easy to combine renderings from any of these libraries into the same WebGL context.

What are your thoughts on refactoring the foundation of Goo to use Regl for managing WebGL state? Does Regl offer enough flexibility for Goo to do what it needs to do on top of Regl?

So glTF has hit 1.0

https://www.khronos.org/news/press/khronos-finalizes-gltf-1.0-specification

It's made with WebGL engines in mind, so, is there any place for it on the Turbulenz Goo Engine roadmap?

Just noticed this: http://code.gooengine.com/0.15.33/visual-test/goo/timelinepack/TimelineComponentHandler/TimelineComponentHandler-vtest.html

Reported by bunzaga.

Any ideas regarding this old demo: https://create.goocreate.com/edit/db361deed21f4ad8b5630ffb11d79fc4.scene I tried changing it to use onTriggerStay, but it still does the same thing. It behaves like something in the physics engine crashes, and just stops responding to the cubes over time.

Basically, if you move the camera so the smaller cubes are inside of the sphere, then hold down the left mouse button, the cubes should be picked up and try to stay in the center of the sphere. When you let go of the left mouse, they should drop like normal. If you continuously pick them up and drag them around, suddenly they just stop reacting to the trigger events.

https://c1.goote.ch/db361deed21f4ad8b5630ffb11d79fc4.scene Here is the demo, so you don't need to open and build, etc.

Here's a little (unlisted) video to help: https://youtu.be/91xojYiY67g

The HTML component rounds the transform position when "move with transform" is enabled. This causes flickering when moving objects or the camera around.

Tried to run this on my phone and the music ended long before the animation. Something capping the tpf? https://c1.goote.ch/43872e37fa8a4e7ea31b8d48de06b6db.scene/

I don't think it is in my code because it can also bee seen at http://potemkin.se/solar/system.html

url in image: https://c1.goote.ch/379f2eb9aee7402fbd44650393419d83.scene/

Currently, Matrix3x3.prototype.fromAngles takes three separate parameters: x, y, z. It would be nice if there was an additional function, or added functionality to the current 'fromAngles', to accept a Vector3 Object as well:

var rot = new goo.Matrix3x3();
entity.transformComponent.transform.rotation.toAngles(rot); // notice a Vector3 passed in here...
rot.y += ctx.world.tpf;
// this would be nice!
entity.transformComponent.transform.rotation.fromAngleVector(rot); // we pass in the Vector3 here as well.

Currently, we have to pass in each part of the Vector3:
entity.transformComponent.transform.rotation.fromAngles(rot[0]. rot[1], rot[2]);