Samsung, one of the world's most popular gaming monitor brands, has announced its first glasses-free three-dimensional gaming monitor, the Odyssey 3D. The monitor was first teased at CES 2024 earlier this year and revealed at the ongoing Gamescom 2024 event in Cologne, Germany. The monitor uses eye-tracking technology to convert 2D visuals into 3D.

Odyssey 3D is a glasses-free 3D gaming monitor with 4K resolution and 165Hz refresh rate

The Odyssey 3D is the first 3D monitor in Samsung's gaming monitor lineup. It comes in two sizes: 27-inch and 37-inch. It uses a flat 4K QLED panel (probably a VA panel) with a 165Hz variable refresh rate, AMD FreeSync Premium, and 1ms response time. Samsung hasn't revealed its brightness figures yet.

The monitor tracks the user's eyes in 3D space using two cameras, while Samsung's view-mapping technology adjusts the image in real time to offer a clear three-dimensional effect. Then, it uses a lenticular lens attached to the front of the panel to display two slightly different images, one for the left eye and the other for the right eye, thus creating a 3D effect.

Samsung previously claimed that you could play VR games on this monitor. It can even convert regular 2D content into 3D. If you don't want the 3D effect at all times, like when doing office work, you can switch to the monitor's 2D mode.

The Odyssey 3D has two HDMI 2.1 ports, one DisplayPort 1.4, and a height-adjustable stand (with tilt adjustments). This monitor won the ‘Best Of Innovation' award at CES 2024 in Las Vegas, USA, earlier this year.

Samsung hasn't announced the pricing or availability of the Odyssey 3D gaming monitor yet, but we expect it to become available before the end of this year. The South Korean firm has maintained its lead in the global gaming monitor market for the past five years continuously. It had a 20.6% value share in the first quarter of this year.

Jeong Hoon, Vice President of Samsung Electronics’ Visual Display Business Division, said, “We are excited to present a glasses-free 3D gaming monitor that is differentiated from existing displays at Gamescom, the world’s largest gaming show. We will continue to lead the premium gaming monitor market through the development of various new technologies.“

The post Odyssey 3D is Samsung’s first glasses-free 3D gaming monitor appeared first on SamMobile.

I am using URP and would like to have 2D and 3D objects in the scene affected by lights.

This is not supported by Unity, however the docs said that one can use "Camera Stacking" for this exact case.

While interoperability between the respective Lights and Renderers may be developed in the future, currently a combination of 2D and 3D Lights and 2D and 3D Renderers in a single Scene can be achieved by using the camera stacking technique.

It does not work. I added two cameras first - base, second - overlay. Both with 3d renderer. Then added overlay camera to stack in base camera, then switched it's renderer to 2d renderer. Here is the message i get:

Only cameras with compatible renderer types can be stacked. The camera: Camera_1 are using the renderer Renderer2D, but the base camera: Camera are using UniversalRenderer. Will skip rendering

One option I have is to use 3D lights only.

Yes, if you have followed our development a bit, that might be a bit of a surprise. But we have been asked why we don't call this release 1.0, and the majority of us developers discussed this and decided that indeed this release is a major milestone that deserves the big 1.0 number.

Yes, if you have followed our development a bit, that might be a bit of a surprise. But we have been asked why we don't call this release 1.0, and the majority of us developers discussed this and decided that indeed this release is a major milestone that deserves the big 1.0 number.

I am trying to understand the camera API (applicable to perspective camera ONLY) of LiBGDX.

It really does not make sense that you can call rotate and translate on many different properties of the camera. I would like to know what is the difference between them?

Here is the list of rotate and translate methods that act on the LibGDX camera:

1. camera.translate() , camera.rotate()
2. camera.view.translate() , camera.view.rotate()
3. camera.position.traMul(Matrix4 m) , camera.position.rotate()
4. camera.direction.traMul(Matrix4 m) , camera.direction.rotate()

To my understanding, the camera.view is the actual Frustrum of the camera what can be seen on the screen! What is the difference of rotating(translating) the camera's direction, as compared to rotation(translation) of the camera's view?

What about I just translate or rotate the camera and NOT the view of the camera OR the direction OR the position of the camera? What effect will that have?

I have read the documentation and its really lacking in helping us understand! Please someone to help demystified these camera concepts!

My camera starts in the position I expect. However, after some time it drifts far away from the red modelinstance! How to keep it position right behind the red modelinstance without drifting far away!

Here is how I initially set up my camera:

    //initial set up of my camera:

 Gdx.input.setCursorCatched(true);
    Gdx.input.setCursorPosition(Gdx.graphics.getWidth() / 2, Gdx.graphics.getHeight() / 2);

    camera = new PerspectiveCamera(67, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());

 camera.position.set(10f,12f,17.5f);
   
    camera.lookAt(10f,0,10f);        

    camera.up.set(new Vector3(10f,0,10f).Y);
    camera.near = 0.1f;
    camera.far = 300f;     

    camera.update();

Here is how I translate my red model instance: AFTER PRESSING W KEY

BoundingBox bbox0091 = new BoundingBox();
                    ThreeDWithMultipleScreensGame.gameMainPlayerReference.calculateBoundingBox(bbox0091);
                    bbox0091.mul(ThreeDWithMultipleScreensGame.gameMainPlayerReference.transform);
                    Vector3 centerV= new Vector3();
                    bbox0091.getCenter(centerV);

 vecyr.set(0,0,0); //clearing vecyr... important
                    mat4_.set(ThreeDWithMultipleScreensGame.gameMainPlayerReference.transform);
                    vecyr.z-=deltatime*LevelOneScreen.playerSpeed;

                    if(Float.compare(Math.abs(centerV.x-10f),0.001f)>0)
                    vecyr.x-=deltatime*centerV.x;
                   
                    mat4_.translate(vecyr);
                    ThreeDWithMultipleScreensGame.gameMainPlayerReference.transform.set(mat4_);
                    ThreeDWithMultipleScreensGame.gameMainPlayerReference.calculateTransforms();
                    ThreeDWithMultipleScreensGame.gameMainPlayerReference.transform.getTranslation(ThreeDWithMultipleScreensGame.playerCurrentPosition);

Here is how I update my camera hoping that it will follow right behind my red model instance:

camera.up.set(0,1,0);
                 
                    Vector3 tmpVector=new Vector3();
                    camera.position.add(tmpVector.set(camera.direction).scl(deltatime*LevelOneScreen.playerSpeed).x,0,
                            tmpVector.set(camera.direction).scl(deltatime*LevelOneScreen.playerSpeed).z);  
                    camera.lookAt(centerV.x,0,centerV.z-7.5f);
                    camera.update();

Here is the picture that show the drifting effect I am talking about:

Notice how the black line gets longer after some time of rotating and translating the red modelinstance How to fix this problem so camera stays always right behind the red model instance?

The following code rotates my modelinstance about its centerpoint y-axis. HOWEVER, when I move the modelinstance foward the rotation gets all wrong! I am not sure what is happening. I need for the rotation to work the same always NOT just before I start moving the modelinstance foward!

Here how I apply my rotation after pressing the D key:

BoundingBox bbox = new BoundingBox();
                    ThreeDWithMultipleScreensGame.gameMainPlayerReference.calculateBoundingBox(bbox);
                    bbox.mul(/*node_.globalTransform*/ThreeDWithMultipleScreensGame.gameMainPlayerReference.transform);
                    Vector3 centerVector_ = new Vector3();
                    bbox.getCenter(centerVector_);

                    Gdx.app.log("okcenter","here: " + centerVector_.toString());


                    if(true){

                        Matrix4 m4 = new Matrix4();
                        m4.set(ThreeDWithMultipleScreensGame.gameMainPlayerReference.transform);
                        //m4.translate(10,0,10).rotate(0,1,0,-20f*LevelOneScreen.playerRotationSpeed*deltatime).translate(-10,0,-10);
                        m4.translate(centerVector_).rotate(0,1,0,-20f*LevelOneScreen.playerRotationSpeed*deltatime).translate(-1f*centerVector_.x,-1f*centerVector_.y,-1f*centerVector_.z);
                        Gdx.app.log("multiply","we have: " + centerVector_.cpy().scl(-1f).toString());
                        ThreeDWithMultipleScreensGame.gameMainPlayerReference.transform.set(m4);
                        ThreeDWithMultipleScreensGame.gameMainPlayerReference.calculateTransforms();

                    }

And, here is how I translate my modelinstance foward:

vecyr.set(0,0,0); //clearing vecyr... important
                    mat4_.set(ThreeDWithMultipleScreensGame.gameMainPlayerReference.transform);
                    vecyr.z-=deltatime*LevelOneScreen.playerSpeed;
                    mat4_.translate(vecyr);
                    ThreeDWithMultipleScreensGame.gameMainPlayerReference.transform.set(mat4_);
                    ThreeDWithMultipleScreensGame.gameMainPlayerReference.calculateTransforms();
                    ThreeDWithMultipleScreensGame.gameMainPlayerReference.transform.getTranslation(ThreeDWithMultipleScreensGame.playerCurrentPosition);


camera.position.add(vecyr);
                    
camera.lookAt(10f,0,ThreeDWithMultipleScreensGame.playerCurrentPosition.z-7.5f);
                    camera.update();

Why does the rotation only work before I start moving my modelinstance foward?

I am trying to rotate the node of a modelinstance as follows:

Note: the node and modelinstance are rotating BUT not about their own center Y axis!

 Node node_ = myModelInstance.getNode("boxy", true);

                    BoundingBox bbox = new BoundingBox();
                    myModelInstance.calculateBoundingBox(bbox);
                    bbox.mul(node_.globalTransform/*myModelInstance.transform*/);
                    Vector3 centerVector_ = new Vector3();
                    bbox.getCenter(centerVector_);

                    if (true) {
                        try {
                           
                            if (node_ != null) {
                                
                                Gdx.app.log("information", "Before rotation: " + node_.localTransform.toString());

                                // Extract the local Y-axis and create a rotation matrix
                                //Vector3 yAxis = new Vector3(0, centerVector_.Y, 0);

                                float rotationAngle = MathUtils.degreesToRadians * 45;
                                       
                                Gdx.app.log("information", "Rotation angle: " + rotationAngle);


                                // Set rotation matrix based on the Y-axis and angle
                                rotationMatrix.setToRotation(centerVector_.Y/*yAxis*/, rotationAngle);

                                // Log the rotation matrix
                                Gdx.app.log("information", "Rotation matrix: " + rotationMatrix.toString());

                                // Apply the rotation to the node's local transform
                                node_.globalTransform/*localTransform*/.mulLeft(rotationMatrix);
                               // node_.globalTransform.getRotation(new Quaternion(),true);
                                node_.calculateLocalTransform();

                                //myModelInstance.transform.set(node.localTransform);

                               // myModelInstance.transform.set(node.localTransform.mulLeft(rotationMatrix));


                                // Log the local transform after applying rotation
                                Gdx.app.log("information", "After rotation: " + node_.localTransform.toString());

                                // Recalculate the transforms to update the hierarchy
                                //myModelInstance.calculateTransforms();

                                Gdx.app.log("error44", "Rotation applied successfully.");
                            } else {
                                Gdx.app.log("error44", "Node 'boxy' not found.");
                            }
                        } catch (Exception e) {
                            e.printStackTrace();
                            Gdx.app.log("error44", "Exception: " + e.toString());
                        }
                    }

I need the modelinstance and its node to rotate about the Y axis of the centerpoint of the modelinstance! How to do this??

Here is a picture of the redbox modelinstance that is supposed to rotate in place about its own y axis.. we can say the normal to the top face!

So confused about how rotation works based on local y axis of modelinstance:

This how I create the modelinstance:

 //create a red box:
            ModelBuilder mBuilder = new ModelBuilder();
            mBuilder.begin();
            Material mat = new Material();
            mat.set(PBRColorAttribute.createBaseColorFactor(Color.RED));
            MeshPartBuilder mpartbuilder = mBuilder.part("boxy", GL20.GL_TRIANGLES, VertexAttributes.Usage.Position|VertexAttributes.Usage.Normal,mat);
            BoxShapeBuilder.build(mpartbuilder,10f,0,10f,2f,2f,5f);
            ModelInstance mInstance = new ModelInstance(mBuilder.end());

From code above I can see that modelinstance center is at 10f, 0, 10f.

I create the camera as such: viewing down on the modelinstance:

camera = new PerspectiveCamera(67, Gdx.graphics.getWidth(), 
Gdx.graphics.getHeight());
camera.position.set(10f,10f,17.5f);
camera.lookAt(10f,0,10f);  //so its looking at the center of 
modelinstance

//so, the up is the Y value of the center point of the modelinstance!
// I did also try:  Vector3.Y 
camera.up.set(new Vector3(10f,0,10f).Y); 
    camera.near = 0.1f;
    camera.far = 300f;

camera.update();

I also try to rotate the modelinstance as such:

if(Gdx.input.isKeyPressed(Input.Keys.B)){

        if(true) {
            camera.lookAt(10f,0f,10f);
            Gdx.app.log("rotating", "see");
            Matrix4 mat41 = new Matrix4();
            mat41.set(ThreeDWithMultipleScreensGame.gameMainPlayerReference.transform);
            //mat41.rotate(new Vector3(10f,0,10f),new Vector3(0,1f,0));
            mat41.rotate(camera.up.Y, 10f * delta);
            //mat41.setToRotation()
            ThreeDWithMultipleScreensGame.gameMainPlayerReference.transform.set(mat41);
            ThreeDWithMultipleScreensGame.gameMainPlayerReference.transform.getTranslation(ThreeDWithMultipleScreensGame.playerCurrentPosition);

            camera.update();
           
        }

        if(false)
        try{
            ThreeDWithMultipleScreensGame.gameMainPlayerReference.transform.rotate(new Vector3(10f,0,10f).Y,20f);
            camera.lookAt(10f,0,10f);
            camera.update();
        } catch (Exception e) {
            e.printStackTrace();
            Gdx.app.log("the_error","see: " + e.toString());
        }
    }

Both ways of rotating make the modelinstance rotate NOT about its center! It follows the path of an imaginary circle that is centered who knows where!

Yes, if you have followed our development a bit, that might be a bit of a surprise. But we have been asked why we don't call this release 1.0, and the majority of us developers discussed this and decided that indeed this release is a major milestone that deserves the big 1.0 number.

in dota 2 and warcraft 3 u can even place the camera horizontally on the ground and the movement still accurately knows where u clicked, how is this possible?

my understanding is the normalized screen coords go from [-1,1] in both x and y directions and usually there's a perspective matrix which is to make things appear like they have depth by making vanishing points and a view matrix to move the camera and/or rotate it.

So i am trying to create a daylight cycle, where it switches between two panoramic images. The change happens slowly one over 2 minutes and the other over 3. During this the fog and light changes color but the image of the sky just slowly fades from one image to another. I would like for the skybox color to change too using the tint option. But how do i do this in my code so that the tint of the sky will match the color of the light and fog? This is in unity 3d btw using C# if that wasn't already obvious.

The code:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class TimeManager : MonoBehaviour
{
    [SerializeField] private Texture2D skyboxNight;
    [SerializeField] private Texture2D skyboxDay;

    [SerializeField] private Gradient graddientNightToDay;
    [SerializeField] private Gradient graddientDayToNight;

    [SerializeField] private Light globalLight;

    public int minutes;

    public int Minutes
    { get { return minutes; } set { minutes = value; OnMinutesChange(value); } }

    public int hours = 5;

    public int Hours
    { get { return hours; } set { hours = value; OnHoursChange(value); } }

    private int days;

    public int Days
    { get { return days; } set { days = value; } }

    private float tempSecond;

    public void Update()
    {
        tempSecond += Time.deltaTime;

        if (tempSecond >= 1)
        {
            Minutes += 1;
            tempSecond = 0;
        }
    }

    private void OnMinutesChange(int value)
    {
        globalLight.transform.Rotate(Vector3.up, (1f / (1440f / 4f)) * 360f, Space.World);
        if (value >= 60)
        {
            Hours++;
            minutes = 0;
        }
        if (Hours >= 24)
        {
            Hours = 0;
            Days++;
        }
    }

    private void OnHoursChange(int value)
    {
        if (Hours >= 24)
        {
            Hours = 0;
            Days++;
        }
        if (value == 6)
        {
            StartCoroutine(LerpSkybox(skyboxNight, skyboxDay, 120f));
            StartCoroutine(LerpLight(graddientNightToDay, 120f));
        }
        else if (value == 18)
        {
            StartCoroutine(LerpSkybox(skyboxDay, skyboxNight, 240f));
            StartCoroutine(LerpLight(graddientDayToNight, 240f));
        }
    }

    private IEnumerator LerpSkybox(Texture2D a, Texture2D b, float time)
    {
        RenderSettings.skybox.SetTexture("_Texture1", a);
        RenderSettings.skybox.SetTexture("_Texture2", b);
        RenderSettings.skybox.SetFloat("_Blend", 0);
        for (float i = 0; i < time; i += Time.deltaTime)
        {
            RenderSettings.skybox.SetFloat("_Blend", i / time);
            yield return null;
        }
        RenderSettings.skybox.SetTexture("_Texture1", b);
    }

    private IEnumerator LerpLight(Gradient lightGradient, float time)
    {
        for (float i = 0; i < time; i += Time.deltaTime)
        {
            globalLight.color = lightGradient.Evaluate(i / time);
            RenderSettings.fogColor = globalLight.color;
            yield return null;
        }
    }
}  ```

I have a Script Component named Start inside a GameObject named StartSpawn and I am trying to run a function from Start when the target is found but Unity/Visual Studio is not detecting the Start script component. I even tried restarting both Unity and Visual Studio to only worsen the problem. When I opened both programs again and inspecting the code, the code I added was deleted and the script DefaultTrackableEventHandler.cs was back to its original code. Btw, the function I'm calling to Instantiates a Prefab.

Here's the code inside the DefaultTrackableEventHandler.cs:

protected virtual void OnTrackingFound()
{
    if (mTrackableBehaviour)
    {
        var rendererComponents = mTrackableBehaviour.GetComponentsInChildren<Renderer>(true);
        var colliderComponents = mTrackableBehaviour.GetComponentsInChildren<Collider>(true);
        var canvasComponents = mTrackableBehaviour.GetComponentsInChildren<Canvas>(true);
        //test
        Start summoner = GetComponentInChildren<Start>();

        // Enable rendering:
        foreach (var component in rendererComponents)
            component.enabled = true;

        // Enable colliders:
        foreach (var component in colliderComponents)
            component.enabled = true;

        // Enable canvas':
        foreach (var component in canvasComponents)
            component.enabled = true;

        //test spawn
        summoner.OnAppear();
    }
}

Enlarge (credit: Aurich Lawson | Id | GDC)

John Romero remembers the moment he realized what the future of gaming would look like.

In late 1991, Romero and his colleagues at id Software had just released Catacomb 3-D, a crude-looking, EGA-colored first-person shooter that was nonetheless revolutionary compared to other first-person games of the time. "When we started making our 3D games, the only 3D games out there were nothing like ours," Romero told Ars in a recent interview. "They were lockstep, going through a maze, do a 90-degree turn, that kind of thing."

Despite Catacomb 3-D's technological advances in first-person perspective, though, Romero remembers the team at id followed its release by going to work on the next entry in the long-running Commander Keen series of 2D platform games. But as that process moved forward, Romero told Ars that something didn't feel right.

Read 20 remaining paragraphs | Comments

Yes, if you have followed our development a bit, that might be a bit of a surprise. But we have been asked why we don't call this release 1.0, and the majority of us developers discussed this and decided that indeed this release is a major milestone that deserves the big 1.0 number.

I am trying to write a 3d Renderer in C using SDL and cgml but my shading seems to be not working correctly. When rendering the teapot I get seams and when I want to render a cube I get a bright white line between my triangles. I am pretty sure that I calculate my normals correctly but I can show that code too if necessary. All my math functions like v3_normalise / cam_perspective should be correct too because they are just aliases for cgml functions.

static void _draw_triangle(SDL_Renderer* renderer, int x1, int y1, int x2, int y2, int x3, int y3) {
    SDL_RenderLine(renderer, x1, y1, x2, y2);
    SDL_RenderLine(renderer, x2, y2, x3, y3);
    SDL_RenderLine(renderer, x3, y3, x1, y1);
}

static int32_t _compare_triangles(const void* a, const void* b) {
    triangle_t* triangle_a = (triangle_t*)a;
    triangle_t* triangle_b = (triangle_t*)b;

    float z1 = (triangle_a->vertices[0].z + triangle_a->vertices[1].z + triangle_a->vertices[2].z) / 3.0f;
    float z2 = (triangle_b->vertices[0].z + triangle_b->vertices[1].z + triangle_b->vertices[2].z) / 3.0f;

    float comparison = z2 - z1;
    if (comparison < 0.0f) return 1;
    if (comparison > 0.0f) return -1;
    return 0;
}

static void _render_triangles_mesh(SDL_Renderer* renderer, triangle_t* triangles_to_render, size_t num_triangles_to_render) {
    SDL_SetRenderDrawColor(renderer, 0xFF, 0, 0xFF, 0xFF);  // set color to pink

    for (size_t j = 0; j < num_triangles_to_render; j++) {
        triangle_t triangle = dynamic_array_at(triangles_to_render, j);

        _draw_triangle(
            renderer,
            triangle.vertices[0].x, triangle.vertices[0].y, 
            triangle.vertices[1].x, triangle.vertices[1].y,
            triangle.vertices[2].x, triangle.vertices[2].y
        );
    }
}

static v3i _calc_vertex_color(v3 normal, v3 light_direction) {
    float intensity = glm_max(0.1f, v3_dot(normal, light_direction)) * 1.5f;
    v3i color = v3i_of((int32_t)glm_clamp(255.0f * intensity, 0.0f, 255.0f));

    return color;
}

static void _render_triangles_filled(SDL_Renderer* renderer, triangle_t* triangles_to_render, size_t num_triangles_to_render, v3* vertex_normals, v3 light_direction) {
    /* convert to SDL_Vertex triangles and add to vertices to render */
    SDL_Vertex vertices[num_triangles_to_render * 3];

    for (size_t i = 0; i < num_triangles_to_render; i++) {
        triangle_t triangle = dynamic_array_at(triangles_to_render, i);

        for (size_t j = 0; j < 3; j++) {
            v3i color = _calc_vertex_color(vertex_normals[triangle.indices[j]], light_direction);

            /* add vertex to SDL vertices */
            SDL_Vertex vertex = {
                .position = {triangle.vertices[j].x, triangle.vertices[j].y}, 
                .color = {color.r, color.g, color.b, 0xFF}
            };
            vertices[i * 3 + j] = vertex;
        }
    }
        
    /* render triangles */
    SDL_RenderGeometry(renderer, NULL, vertices, num_triangles_to_render * 3, NULL, 0); 
}

int32_t render(state_t* state, mesh_t* mesh, v3 object_offset) {
    static float alpha = 0;
    alpha += 0.6f * state->time.delta_sec;

    m4 rotation_matrix = glms_euler_xyz(v3_of(0.0f, alpha, 0.0f)); // glms_euler_xyz(v3_of(alpha * 0.5f, 0.0f, alpha));
    m4 translation_matrix = glms_translate_make(object_offset);
    m4 world_matrix = m4_mul(translation_matrix, rotation_matrix);

    v3 up = v3_of(0.0f, 1.0f, 0.0f);
    v3 target = v3_add(state->engine.camera.position, state->engine.camera.direction);
    m4 camera_matrix = cam_lookat(state->engine.camera.position, target, up);
    m4 view_matrix = glms_inv_tr(camera_matrix);
    
    triangle_t* triangles_to_render = dynamic_array_create(triangle_t);

    for (size_t i = 0; i < mesh->num_triangles; i++) {
        triangle_t triangle = dynamic_array_at(mesh->triangles, i);
        triangle_t triangle_transformed, triangle_projected, triangle_viewed;

        /* rotate and translate triangle */
        triangle_transformed = triangle;
        triangle_transformed.vertices[0] = m4_mulv(world_matrix, triangle.vertices[0]);
        triangle_transformed.vertices[1] = m4_mulv(world_matrix, triangle.vertices[1]);
        triangle_transformed.vertices[2] = m4_mulv(world_matrix, triangle.vertices[2]);
    
        /* world space to camera space */
        triangle_viewed = triangle_transformed;
        triangle_viewed.vertices[0] = m4_mulv(view_matrix, triangle_transformed.vertices[0]);
        triangle_viewed.vertices[1] = m4_mulv(view_matrix, triangle_transformed.vertices[1]);
        triangle_viewed.vertices[2] = m4_mulv(view_matrix, triangle_transformed.vertices[2]);

        /* 3d to 2d */
        triangle_projected = triangle_viewed;
        triangle_projected.vertices[0] = m4_mulv(state->engine.projection_matrix, triangle_viewed.vertices[0]);
        triangle_projected.vertices[1] = m4_mulv(state->engine.projection_matrix, triangle_viewed.vertices[1]);
        triangle_projected.vertices[2] = m4_mulv(state->engine.projection_matrix, triangle_viewed.vertices[2]);
        triangle_projected.vertices[0] = v4_divs(triangle_projected.vertices[0], triangle_projected.vertices[0].w);
        triangle_projected.vertices[1] = v4_divs(triangle_projected.vertices[1], triangle_projected.vertices[1].w);
        triangle_projected.vertices[2] = v4_divs(triangle_projected.vertices[2], triangle_projected.vertices[2].w);

        /* backface culling using winding order */
        v3 line1 = v3_sub(v3_from(triangle_projected.vertices[1]), v3_from(triangle_projected.vertices[0]));
        v3 line2 = v3_sub(v3_from(triangle_projected.vertices[2]), v3_from(triangle_projected.vertices[0]));
        float sign = line1.x * line2.y - line2.x * line1.y;
        if (sign > 0.0f) continue;
        
        /* scale into view */
        triangle_projected.vertices[0].x = map(triangle_projected.vertices[0].x, -1.0f, 1.0f, 0, WIDTH);
        triangle_projected.vertices[0].y = map(triangle_projected.vertices[0].y, -1.0f, 1.0f, 0, HEIGHT);
        triangle_projected.vertices[1].x = map(triangle_projected.vertices[1].x, -1.0f, 1.0f, 0, WIDTH);
        triangle_projected.vertices[1].y = map(triangle_projected.vertices[1].y, -1.0f, 1.0f, 0, HEIGHT);
        triangle_projected.vertices[2].x = map(triangle_projected.vertices[2].x, -1.0f, 1.0f, 0, WIDTH);
        triangle_projected.vertices[2].y = map(triangle_projected.vertices[2].y, -1.0f, 1.0f, 0, HEIGHT);
        
        /* add triangle to list */
        dynamic_array_append(triangles_to_render, triangle_projected);
    }

    /* transform vertex normals */
    v3* transformed_normals = malloc(sizeof(v3) * mesh->num_vertices);
    m3 normal_matrix = m3_inv(m4_pick3t(world_matrix));
    
    for (size_t i = 0; i < mesh->num_vertices; i++) {
        v3 normal = dynamic_array_at(mesh->vertex_normals, i);
        v3 normal_transformed = v3_normalize(m3_mulv(normal_matrix, normal));
        transformed_normals[i] = normal_transformed;
    }

    /* sort triangles back to front */
    size_t num_triangles_to_render = dynamic_array_get_length(triangles_to_render);
    qsort(triangles_to_render, num_triangles_to_render, sizeof(triangle_t), _compare_triangles);

    /* draw triangles */
    #ifdef DEBUG
        _render_triangles_mesh(state->renderer, triangles_to_render, num_triangles_to_render);
    #else
        _render_triangles_filled(state->renderer, triangles_to_render, num_triangles_to_render, transformed_normals, state->engine.light.direction);
    #endif
    
    /* cleanup */
    free(transformed_normals);
    dynamic_array_destroy(triangles_to_render);

    return state->retval;
}

EDIT: Image of the normals

I made a concave house model. When I import it to Unreal Engine it generates a simple box collision that covers the full mesh. I need a collision that only covers the walls. How can I generate one or edit the collision? (I'm using Maya.)

Yes, if you have followed our development a bit, that might be a bit of a surprise. But we have been asked why we don't call this release 1.0, and the majority of us developers discussed this and decided that indeed this release is a major milestone that deserves the big 1.0 number.

GameFromScratch.com
Reblium – Unreal Engine Power 3D Character Creator

Today we are looking at Reblium, a new 3D character creator powered by Unreal Engine similar to MetaHuman, but working entirely on your local PC. If you have ever created a character in a video game you have an idea of how to use Reblium. Right now it is in […]

The post Reblium – Unreal Engine Power 3D Character Creator appeared first on GameFromScratch.com.

GameFromScratch.com
25 Game Engines in 25 Minutes

Today we are going to take a look at 25 different game engines in 25 minutes (ok, 28 minutes…). The only criteria to show up on this list is the engine is primarily 3D and has a world or level editor. If there is interest we may do a similar […]

The post 25 Game Engines in 25 Minutes appeared first on GameFromScratch.com.

I was wondering (as I could not find any implementation online), if anyone here would have an idea of how to create an octree as a struct and not a class.

The problem is that Octrees are usually recursive, and structs cannot have auto-inheritance.

So, the code:

public struct MyOctree
{
    public MyNode RootNode;
}

public struct MyNode
{
    public MyNode[] SubNodes;
}

would cause a cyclic reference error (nodes contain nodes).

I'm trying to implement such a structure for GPU usage, and any Nullable data (e.g. a class) throw a not-supported exception on the GPU initializer.

Thanks.

Yes, if you have followed our development a bit, that might be a bit of a surprise. But we have been asked why we don't call this release 1.0, and the majority of us developers discussed this and decided that indeed this release is a major milestone that deserves the big 1.0 number.

Five of the Best is a weekly series for supporters of Eurogamer. It's a series that highlights some of the features in games that are often overlooked. It's also about having your say, so don't be shy, use the comments below and join in!

Oh and if you want to read more, you can - you can find our entire Five of the Best archive elsewhere on the site.

We're well aware of our human capabilities, so games often deliver fantasies about going beyond them. We play characters with extraordinary acrobatic abilities, or with incredible strength or martial prowess, and sometimes, we play as characters who have powers we could never have. Mixed within this is the fantasy of becoming something completely different and changing entirely from a human into something else, and that's what I want to get at here. Ever since Altered Beast, and probably for far longer, we've had games that allowed us to change shapes and access new abilities as we play. We've even had games take us to inorganic places, with mech suits and more. Shape changes can be the ultimate power-up. The question is, which are the best?

Read more

Yes, if you have followed our development a bit, that might be a bit of a surprise. But we have been asked why we don't call this release 1.0, and the majority of us developers discussed this and decided that indeed this release is a major milestone that deserves the big 1.0 number.

I know how to move a point in a direction in 2D space it's like this:

pointX += sin(angle) * movementSpeed;
pointY += cos(angle) * movementSpeed;

How do I do the same in 3D space assuming the angle variable is replaced with pitch, yaw, and roll variables and the addition of a pointZ variable?

Yes, if you have followed our development a bit, that might be a bit of a surprise. But we have been asked why we don't call this release 1.0, and the majority of us developers discussed this and decided that indeed this release is a major milestone that deserves the big 1.0 number.

GameFromScratch.com
e-on VUE, PlantFactory and PlantCatalog Now FREE

The e-on software developed VUE, PlantFactory and PlantCatalog CG applications have just been made completely free. VUE is an application for creating virtual worlds and landscapes similar to Gaea or Terragen, while PlantFactory is more akin to SpeedTree. Owner Bentley Systems have decided to cease development on these applications and […]

The post e-on VUE, PlantFactory and PlantCatalog Now FREE appeared first on GameFromScratch.com.

GameFromScratch.com
The Base Mesh 2.0

Today we are revisiting The Base Mesh 2.0, a resource we first featured back in 2022. In that earlier feature, TheBaseMesh.com featured over 250 high quality low polygon UV unwrapped meshes that are game ready or well prepared for sculpting. In the two years since that collection has grown almost […]

The post The Base Mesh 2.0 appeared first on GameFromScratch.com.

Yes, if you have followed our development a bit, that might be a bit of a surprise. But we have been asked why we don't call this release 1.0, and the majority of us developers discussed this and decided that indeed this release is a major milestone that deserves the big 1.0 number.