• Advertisement
  • Popular Tags

  • Popular Now

  • Advertisement
  • Similar Content

    • By lxjk
      Hi guys,
      There are many ways to do light culling in tile-based shading. I've been playing with this idea for a while, and just want to throw it out there.
      Because tile frustums are general small compared to light radius, I tried using cone test to reduce false positives introduced by commonly used sphere-frustum test.
      On top of that, I use distance to camera rather than depth for near/far test (aka. sliced by spheres).
      This method can be naturally extended to clustered light culling as well.
      The following image shows the general ideas

       
      Performance-wise I get around 15% improvement over sphere-frustum test. You can also see how a single light performs as the following: from left to right (1) standard rendering of a point light; then tiles passed the test of (2) sphere-frustum test; (3) cone test; (4) spherical-sliced cone test
       

       
      I put the details in my blog post (https://lxjk.github.io/2018/03/25/Improve-Tile-based-Light-Culling-with-Spherical-sliced-Cone.html), GLSL source code included!
       
      Eric
    • By Fadey Duh
      Good evening everyone!

      I was wondering if there is something equivalent of  GL_NV_blend_equation_advanced for AMD?
      Basically I'm trying to find more compatible version of it.

      Thank you!
    • By Jens Eckervogt
      Hello guys, 
       
      Please tell me! 
      How do I know? Why does wavefront not show for me?
      I already checked I have non errors yet.
      using OpenTK; using System.Collections.Generic; using System.IO; using System.Text; namespace Tutorial_08.net.sourceskyboxer { public class WaveFrontLoader { private static List<Vector3> inPositions; private static List<Vector2> inTexcoords; private static List<Vector3> inNormals; private static List<float> positions; private static List<float> texcoords; private static List<int> indices; public static RawModel LoadObjModel(string filename, Loader loader) { inPositions = new List<Vector3>(); inTexcoords = new List<Vector2>(); inNormals = new List<Vector3>(); positions = new List<float>(); texcoords = new List<float>(); indices = new List<int>(); int nextIdx = 0; using (var reader = new StreamReader(File.Open("Contents/" + filename + ".obj", FileMode.Open), Encoding.UTF8)) { string line = reader.ReadLine(); int i = reader.Read(); while (true) { string[] currentLine = line.Split(); if (currentLine[0] == "v") { Vector3 pos = new Vector3(float.Parse(currentLine[1]), float.Parse(currentLine[2]), float.Parse(currentLine[3])); inPositions.Add(pos); if (currentLine[1] == "t") { Vector2 tex = new Vector2(float.Parse(currentLine[1]), float.Parse(currentLine[2])); inTexcoords.Add(tex); } if (currentLine[1] == "n") { Vector3 nom = new Vector3(float.Parse(currentLine[1]), float.Parse(currentLine[2]), float.Parse(currentLine[3])); inNormals.Add(nom); } } if (currentLine[0] == "f") { Vector3 pos = inPositions[0]; positions.Add(pos.X); positions.Add(pos.Y); positions.Add(pos.Z); Vector2 tc = inTexcoords[0]; texcoords.Add(tc.X); texcoords.Add(tc.Y); indices.Add(nextIdx); ++nextIdx; } reader.Close(); return loader.loadToVAO(positions.ToArray(), texcoords.ToArray(), indices.ToArray()); } } } } } And It have tried other method but it can't show for me.  I am mad now. Because any OpenTK developers won't help me.
      Please help me how do I fix.

      And my download (mega.nz) should it is original but I tried no success...
      - Add blend source and png file here I have tried tried,.....  
       
      PS: Why is our community not active? I wait very longer. Stop to lie me!
      Thanks !
    • By codelyoko373
      I wasn't sure if this would be the right place for a topic like this so sorry if it isn't.
      I'm currently working on a project for Uni using FreeGLUT to make a simple solar system simulation. I've got to the point where I've implemented all the planets and have used a Scene Graph to link them all together. The issue I'm having with now though is basically the planets and moons orbit correctly at their own orbit speeds.
      I'm not really experienced with using matrices for stuff like this so It's likely why I can't figure out how exactly to get it working. This is where I'm applying the transformation matrices, as well as pushing and popping them. This is within the Render function that every planet including the sun and moons will have and run.
      if (tag != "Sun") { glRotatef(orbitAngle, orbitRotation.X, orbitRotation.Y, orbitRotation.Z); } glPushMatrix(); glTranslatef(position.X, position.Y, position.Z); glRotatef(rotationAngle, rotation.X, rotation.Y, rotation.Z); glScalef(scale.X, scale.Y, scale.Z); glDrawElements(GL_TRIANGLES, mesh->indiceCount, GL_UNSIGNED_SHORT, mesh->indices); if (tag != "Sun") { glPopMatrix(); } The "If(tag != "Sun")" parts are my attempts are getting the planets to orbit correctly though it likely isn't the way I'm meant to be doing it. So I was wondering if someone would be able to help me? As I really don't have an idea on what I would do to get it working. Using the if statement is truthfully the closest I've got to it working but there are still weird effects like the planets orbiting faster then they should depending on the number of planets actually be updated/rendered.
    • By Jens Eckervogt
      Hello everyone, 
      I have problem with texture
      using System; using OpenTK; using OpenTK.Input; using OpenTK.Graphics; using OpenTK.Graphics.OpenGL4; using System.Drawing; using System.Reflection; namespace Tutorial_05 { class Game : GameWindow { private static int WIDTH = 1200; private static int HEIGHT = 720; private static KeyboardState keyState; private int vaoID; private int vboID; private int iboID; private Vector3[] vertices = { new Vector3(-0.5f, 0.5f, 0.0f), // V0 new Vector3(-0.5f, -0.5f, 0.0f), // V1 new Vector3(0.5f, -0.5f, 0.0f), // V2 new Vector3(0.5f, 0.5f, 0.0f) // V3 }; private Vector2[] texcoords = { new Vector2(0, 0), new Vector2(0, 1), new Vector2(1, 1), new Vector2(1, 0) }; private int[] indices = { 0, 1, 3, 3, 1, 2 }; private string vertsrc = @"#version 450 core in vec3 position; in vec2 textureCoords; out vec2 pass_textureCoords; void main(void) { gl_Position = vec4(position, 1.0); pass_textureCoords = textureCoords; }"; private string fragsrc = @"#version 450 core in vec2 pass_textureCoords; out vec4 out_color; uniform sampler2D textureSampler; void main(void) { out_color = texture(textureSampler, pass_textureCoords); }"; private int programID; private int vertexShaderID; private int fragmentShaderID; private int textureID; private Bitmap texsrc; public Game() : base(WIDTH, HEIGHT, GraphicsMode.Default, "Tutorial 05 - Texturing", GameWindowFlags.Default, DisplayDevice.Default, 4, 5, GraphicsContextFlags.Default) { } protected override void OnLoad(EventArgs e) { base.OnLoad(e); CursorVisible = true; GL.GenVertexArrays(1, out vaoID); GL.BindVertexArray(vaoID); GL.GenBuffers(1, out vboID); GL.BindBuffer(BufferTarget.ArrayBuffer, vboID); GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(vertices.Length * Vector3.SizeInBytes), vertices, BufferUsageHint.StaticDraw); GL.GenBuffers(1, out iboID); GL.BindBuffer(BufferTarget.ElementArrayBuffer, iboID); GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(indices.Length * sizeof(int)), indices, BufferUsageHint.StaticDraw); vertexShaderID = GL.CreateShader(ShaderType.VertexShader); GL.ShaderSource(vertexShaderID, vertsrc); GL.CompileShader(vertexShaderID); fragmentShaderID = GL.CreateShader(ShaderType.FragmentShader); GL.ShaderSource(fragmentShaderID, fragsrc); GL.CompileShader(fragmentShaderID); programID = GL.CreateProgram(); GL.AttachShader(programID, vertexShaderID); GL.AttachShader(programID, fragmentShaderID); GL.LinkProgram(programID); // Loading texture from embedded resource texsrc = new Bitmap(Assembly.GetEntryAssembly().GetManifestResourceStream("Tutorial_05.example.png")); textureID = GL.GenTexture(); GL.BindTexture(TextureTarget.Texture2D, textureID); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)All.Linear); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)All.Linear); GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, texsrc.Width, texsrc.Height, 0, PixelFormat.Bgra, PixelType.UnsignedByte, IntPtr.Zero); System.Drawing.Imaging.BitmapData bitmap_data = texsrc.LockBits(new Rectangle(0, 0, texsrc.Width, texsrc.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppRgb); GL.TexSubImage2D(TextureTarget.Texture2D, 0, 0, 0, texsrc.Width, texsrc.Height, PixelFormat.Bgra, PixelType.UnsignedByte, bitmap_data.Scan0); texsrc.UnlockBits(bitmap_data); GL.Enable(EnableCap.Texture2D); GL.BufferData(BufferTarget.TextureBuffer, (IntPtr)(texcoords.Length * Vector2.SizeInBytes), texcoords, BufferUsageHint.StaticDraw); GL.BindAttribLocation(programID, 0, "position"); GL.BindAttribLocation(programID, 1, "textureCoords"); } protected override void OnResize(EventArgs e) { base.OnResize(e); GL.Viewport(0, 0, ClientRectangle.Width, ClientRectangle.Height); } protected override void OnUpdateFrame(FrameEventArgs e) { base.OnUpdateFrame(e); keyState = Keyboard.GetState(); if (keyState.IsKeyDown(Key.Escape)) { Exit(); } } protected override void OnRenderFrame(FrameEventArgs e) { base.OnRenderFrame(e); // Prepare for background GL.Clear(ClearBufferMask.ColorBufferBit); GL.ClearColor(Color4.Red); // Draw traingles GL.EnableVertexAttribArray(0); GL.EnableVertexAttribArray(1); GL.BindVertexArray(vaoID); GL.UseProgram(programID); GL.BindBuffer(BufferTarget.ArrayBuffer, vboID); GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, 0, IntPtr.Zero); GL.ActiveTexture(TextureUnit.Texture0); GL.BindTexture(TextureTarget.Texture3D, textureID); GL.BindBuffer(BufferTarget.ElementArrayBuffer, iboID); GL.DrawElements(BeginMode.Triangles, indices.Length, DrawElementsType.UnsignedInt, 0); GL.DisableVertexAttribArray(0); GL.DisableVertexAttribArray(1); SwapBuffers(); } protected override void OnClosed(EventArgs e) { base.OnClosed(e); GL.DeleteVertexArray(vaoID); GL.DeleteBuffer(vboID); } } } I can not remember where do I add GL.Uniform2();
  • Advertisement
  • Advertisement
Sign in to follow this  

OpenGL directx vs openGl

Recommended Posts

i know there are a lot of topics in internet about which one is better or in which field which one is better, but i dont know the exact answer. i think these questions are mostly about exprience. and i want to know your exprience.

 

1) i read an article about valve engineers. it said opengl is faster than directx even on windows. is that true?

 

2) its said in directx programmer has more controll rather than opengl.

 

3) which one give better visuals about sahders or technology they use? is it make difference or that is all the same and depend only on programmer that work on them? what about built in effects, particles, lightening,...

4)as I searched in internet, there is no much difference between them, so why Microsoft introduced directx when there was opengl? or why is still developing it? a developer can use opengl for all platforms and forget pain of using a single platform api.

5) I see in engines like unity or unreal that says dx11 version or... it seems using new directx gives more important features. what are those features that can only be used on windows or xbox? are they just for editor or for last output game?

6) what is given in every update of those api,s? for example what is difference of dx10 and dx11? is this about new tools and functions or math or something else? so when in a graphic card is written it supports dx11 what does it mean?

thank you for helping

Edited by moeen k

Share this post


Link to post
Share on other sites
Advertisement

4)as I searched in internet, there is no much difference between them, so why Microsoft introduced directx when there was opengl? or why is still developing it? a developer can use opengl for all platforms and forget pain of using a single platform api.

I'm not the DX guy any more since changing to OpenGL in the early 2006's but OpenGL was intentially introduced as a graphics state machine a time when Microsoft was on the go for assimilating anything to force people using Windows and only Windows but that is an other story to tell. As far as I have read through the history of GL/DX, it was that GL was not made for high performance realtime graphics rather than be used as replacement for IrisGL from the Silicon Workstations in 1992. Its performance and capabilities were something of crappy and Microsoft decided itself to set a team for developing a counter product called Game SDK and later Direct X includign Direct 3D from version 3.0.

OpenGL itself was less standartised so anyone could develop its own extensions and platform/hardware specific functions for it. This and the lack of support on the early Microsoft Windows systems made developers go for Direct X instead even on the fact that Windows was the onlyx OS on Intel Computers that were much cheaper than Apples Macintosh.

OpenGL 2.0 got the shading model but also has had its fixed function pipeline when its legacy functions got depricated in version 3  and removed from 3.3 GL. When CX rises through its versions 7, 8 and 9 GL was fighting with its standards and extensions. In version 4.0 you have feeled 100 times more dynamic bound functions than core functions to use where DX takes this all for you into a code standard API.

 

1) i read an article about valve engineers. it said opengl is faster than directx even on windows. is that true?

Have read the same article but that anyways depends on hardware, what programs run in the background and how is the application coded. Using a wrapper library providing an avarage API for both may have one or the other be a bit faster

2) its said in directx programmer has more controll rather than opengl.

From my research this was true. When DX introduced command buffers for rendering OpenGL still seperates some management tasks from the user but Vulkan and DX 12 are now similar in there capabilities

3) which one give better visuals about sahders or technology they use? is it make difference or that is all the same and depend only on programmer that work on them? what about built in effects, particles, lightening

I think because of the history of both, DX hase more tutorials and books when some informations on GL are hard to find but on the other hand GL is a totally open standard when Microsoft dosent need to publish DX informations that go beyond how you use it

6) what is given in every update of those api,s? for example what is difference of dx10 and dx11? is this about new tools and functions or math or something else? so when in a graphic card is written it supports dx11 what does it mean?

Graphics cards are like CPUs, you need to know how to talkt to them on the software level. On newer DX versions may be new capabilities introduced that may for example be the command buffer. DX is like GL mostly a hardware driver talking to the GPU, managing memory and whatever so a graphics card that isnt DX11 ready may not understand and fail up to critically crash when instructions go wrong

Share this post


Link to post
Share on other sites

4) Win95 and WinNT both had their own graphics teams - one backed GL and one made their own API, and neither shared, so Windows ended up with both!


This is exactly what I understand the reason to have been from reading Alex St John's blog (http://www.alexstjohn.com/WP/2013/01/09/direct3d-vs-opengl/):

When Eric Engstrom approached the NT team about providing us with an OpenGL library to add 3D support to DirectX 2.0 we were turned down. The Windows NT team did not want Windows 95 to be competitive with Windows NT for professional graphics.


Summary is: Microsoft wanted to break into the professional graphics workstation market with Windows NT and they needed OpenGL in order to do that. So it was very much in Microsoft's best interest - strategically, financially, etc - to have solid OpenGL support.
Their consumer division also needed a 3D API (the first versions of DirectX didn't have a 3D API) but the NT team didn't wish to share, so the consumer team ended up buying up RenderMorphics and basing the first version of Direct3D on their Reality Lab API.
If two divisions of the same company not cooperating in this manner seems surprising, remember: this is Microsoft. If you've ever dealt with them in a professional capacity you'll know that this is exactly how they work.
If you look back at the history of the so-called "API war" all the evidence either supports or - at worst - doesn't contradict this version of events, so it certainly seems credible enough.
Some specific examples.
The first version of Windows 95 didn't have OpenGL; Windows NT 4 didn't have Direct3D.
Microsoft's positioning of OpenGL as a "CAD API" and Direct3D as a "games API".
Microsoft's maneuvering with the OpenGL MCD vs ICD driver model.
It can be popular in some quarters to make claims such as "Microsoft tried to kill OpenGL because they wanted a monopoly over 3D APIs" but the sequence of events as they happened just don't really support that.
-------
Finally, the statement that "a developer can use OpenGL on all platforms" just isn't true anyway. A developer cannot use OpenGL on the major console platforms. A developer can use OpenGL ES on Android (and ES doesn't support all OpenGL features so it's not the same API). OpenGL is a second-class citizen on Apple platforms. So the cross-platform advantage of using OpenGL just isn't actually there.

Share this post


Link to post
Share on other sites

Don't let GL's "portability" argument fool you.

I have to respectfully disagree here.  Every device with a GPU supports OpenGL.  DX is only supported on Windows and XBox.  OpenGL wins portability by a country mile.  Sure, different platforms and different manufacturers implement OpenGL differently, but I've been able to port my OpenGL engine between Objective-C, C#, Java, and Javascript/HTML5 in about a day per platform.

Otherwise, as you noted, they are the same.  For me, it comes down to this : If you are developing only for Windows platforms you should use DX.  Otherwise, you pretty much HAVE to use OpenGL.

Share this post


Link to post
Share on other sites

I have to respectfully disagree here.  Every device with a GPU supports OpenGL.

 

Be very careful. Several people who post on this forum actually have worked with major console devkits and on AAA titles - they have actual hands-on experience of which APIs are used and know what they're talking about.  Others are well-known and well-respected industry figures.  So when one of these people says "not every device supports OpenGL" - they're probably right.

Share this post


Link to post
Share on other sites

 

Every device with a GPU supports OpenGL.

PS4s contain a GPU, but doesn't support OpenGL natively.

 

its psgl but its said basically its some modification of opengl. portability is most obvois difference of dx and opengl. my question was mostly based on performance, quality and ease of use.

Share this post


Link to post
Share on other sites

its psgl but its said basically its some modification of opengl. portability is most obvois difference of dx and opengl. my question was mostly based on performance, quality and ease of use.


PSGL existed on PS3 only (its not on PS4) and was a sub-ES 1.0 (or maybe 1.1) implementation that was a wrapper built on top of it's native API but which nobody used because it's performance and functionality were dreadful.

That's basically where the "PS supports OpenGL" mythology came from.

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

Sign in to follow this  

  • Advertisement