culling

I have been grappling with the Hartmann/Gribbs method of extracting the Frustum planes for some time now, with little success. I want to build a camera view-frustum to cull my scene. I am working with column-major matrices in a right-handed coordinate system. (OpenGL style - I'm using C# and Playstation Mobile, but the math should be the same) I want to get my planes in World-Space, so I build my frustum from the View-Projection Matrix (that's projectionMatrix * viewMatrix). The view Matrix is the inverse of the camera's World-Transform. The problem is; regardless of what I tweak, I can't seem

I'm currently working with upgrading and restructuring an OpenGL render engine. The engine is used for visualising large scenes of architectural data (buildings with interior), and the amount of objects can become rather large. As is the case with any building, there is a lot of occluded objects within walls, and you naturally only see the objects that are in the same room as you, or the exterior if you are on the outside. This leaves a large number of objects that should be occluded through occlusion culling and frustum culling. At the same time there is a lot of repetative geometry that can

In back face culling you may either use the face normals to see if the face is pointing away from the camera of you may do some technique with if the triangle is drawn clock wise or counter clock wise. I am confused about this technique with the clockwise. It seems like with this method, the ordering of the vertex data that gets sent to the graphics card decides whether it is facing towards or away from the camera. I don't see how this makes sense because the camera can be looking in any direction, it's as if the vertex data would have to change based on the camera position and that is

In my first libgdx 3D game i now switched from createBox to createRect , to create only the visible faces (if a wall is on the left side of another wall, its right face is not visible...). I am creating 4 models: frontFace backFace rightFace leftFace They are almost drawn how they actually should. But there is one big issue: The side faces are only visible if i look in the positive z-Direction . If i look the other side (negative z-Direction ), they don't draw. The front and back faces only draw, if i look to them in negative x-Direction . Has this something to do with the normals? I have set

From the docs : The default renderer does not do any CPU-side viewport clipping nor occlusion detection. If something is not supposed to be visible, it should not be shown. Use Item::visible: false for items that should not be drawn. The primary reason for not adding such logic is that it adds additional cost which would also hurt applications that took care in behaving well. So is there a trick to do it easily, without implementing it myself? Note that in my case the items that are outside the visible area are there because they are in a ScrollView and they are not scrolled-to. The reason I