Skip to main content

I believe that prior art for this would be Prior art for this would appear to be OpenGL. Any version of OpenGL. Yes, even OpenGL 1.0, published in 1994. Let's take these in order:

  • object placement means for placing a predetermined object in the virtual space;

Yes, OpenGL can be used to do that.

  • transparency degree setting means for, in accordance with a distance specified between (1) the predetermined object placed in the virtual space, and (2) a viewpoint position based on the position of a virtual camera used for virtually shooting the virtual space, setting the degree of transparency of a part or the entirety of the predetermined object such that the longer the distance is, the higher the degree of transparency is; (emphasis added)

Even ignoring shader-based techniques, OpenGL's fixed-function fog is perfectly capable of this. It's simply a matter of setting the fog color alpha to a value other than 1 and turning on blending.

The code would look something like this:

glFogi(GL_FOG_MODE, GL_LINEAR);
glFogf(GL_FOG_START, 0.8f);
glFogf(GL_FOG_END, 1.0f);
GLfloat fogColor[4] = {0.0f, 0.0f, 0.0f, 0.0f};
glFogfv(GL_FOG_COLOR, fogColor);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); //Pre-multiplied transparency

This will fade the object based on the distance from the virtual camera in the virtual space. The degree of transparency of part of the object will indeed be such that "the longer the distance is, the higher the degree of transparency".

This code would work on OpenGL 1.0 (PDF). Obviously, shaders could do the same thing, but having it as an explicit feature of the API makes this more relevant as prior art. These six lines, written in 1994, do what Nintendo is claiming to patent.

  • image generation means for generating an image for a right eye and an image for a left eye by shooting the virtual space with a right virtual camera and a left virtual camera, respectively, so that the predetermined object, which is included in each of the image for a right eye and the image for a left eye, has the degree of transparency set by the transparency degree setting means; and

  • display control means for displaying the image for a right eye and the image for a left eye generated by the image generation means, on the display apparatus.

OpenGL has supported stereoscopic rendering from day one. Every version of OpenGL has had separate back and front buffers for left and right eyes (GL_BACK_LEFT, GL_FRONT_LEFT, GL_BACK_RIGHT, GL_FRONT_RIGHT).

Generally speaking, only professional hardware exposes stereoscopic rendering through OpenGL. But the API can do it.

I believe that prior art for this would be Prior art for this would appear to be OpenGL. Any version of OpenGL. Yes, even OpenGL 1.0, published in 1994. Let's take these in order:

  • object placement means for placing a predetermined object in the virtual space;

Yes, OpenGL can be used to do that.

  • transparency degree setting means for, in accordance with a distance specified between (1) the predetermined object placed in the virtual space, and (2) a viewpoint position based on the position of a virtual camera used for virtually shooting the virtual space, setting the degree of transparency of a part or the entirety of the predetermined object such that the longer the distance is, the higher the degree of transparency is; (emphasis added)

Even ignoring shader-based techniques, OpenGL's fixed-function fog is perfectly capable of this. It's simply a matter of setting the fog color alpha to a value other than 1 and turning on blending.

The code would look something like this:

glFogi(GL_FOG_MODE, GL_LINEAR);
glFogf(GL_FOG_START, 0.8f);
glFogf(GL_FOG_END, 1.0f);
GLfloat fogColor[4] = {0.0f, 0.0f, 0.0f, 0.0f};
glFogfv(GL_FOG_COLOR, fogColor);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); //Pre-multiplied transparency

This will fade the object based on the distance from the virtual camera in the virtual space. The degree of transparency of part of the object will indeed be such that "the longer the distance is, the higher the degree of transparency".

This code would work on OpenGL 1.0 (PDF). Obviously, shaders could do the same thing, but having it as an explicit feature of the API makes this more relevant as prior art. These six lines, written in 1994, do what Nintendo is claiming to patent.

  • image generation means for generating an image for a right eye and an image for a left eye by shooting the virtual space with a right virtual camera and a left virtual camera, respectively, so that the predetermined object, which is included in each of the image for a right eye and the image for a left eye, has the degree of transparency set by the transparency degree setting means; and

  • display control means for displaying the image for a right eye and the image for a left eye generated by the image generation means, on the display apparatus.

OpenGL has supported stereoscopic rendering from day one. Every version of OpenGL has had separate back and front buffers for left and right eyes (GL_BACK_LEFT, GL_FRONT_LEFT, GL_BACK_RIGHT, GL_FRONT_RIGHT).

Generally speaking, only professional hardware exposes stereoscopic rendering through OpenGL. But the API can do it.

Prior art for this would appear to be OpenGL. Any version of OpenGL. Yes, even OpenGL 1.0, published in 1994. Let's take these in order:

  • object placement means for placing a predetermined object in the virtual space;

Yes, OpenGL can be used to do that.

  • transparency degree setting means for, in accordance with a distance specified between (1) the predetermined object placed in the virtual space, and (2) a viewpoint position based on the position of a virtual camera used for virtually shooting the virtual space, setting the degree of transparency of a part or the entirety of the predetermined object such that the longer the distance is, the higher the degree of transparency is; (emphasis added)

Even ignoring shader-based techniques, OpenGL's fixed-function fog is perfectly capable of this. It's simply a matter of setting the fog color alpha to a value other than 1 and turning on blending.

The code would look something like this:

glFogi(GL_FOG_MODE, GL_LINEAR);
glFogf(GL_FOG_START, 0.8f);
glFogf(GL_FOG_END, 1.0f);
GLfloat fogColor[4] = {0.0f, 0.0f, 0.0f, 0.0f};
glFogfv(GL_FOG_COLOR, fogColor);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); //Pre-multiplied transparency

This will fade the object based on the distance from the virtual camera in the virtual space. The degree of transparency of part of the object will indeed be such that "the longer the distance is, the higher the degree of transparency".

This code would work on OpenGL 1.0 (PDF). Obviously, shaders could do the same thing, but having it as an explicit feature of the API makes this more relevant as prior art. These six lines, written in 1994, do what Nintendo is claiming to patent.

  • image generation means for generating an image for a right eye and an image for a left eye by shooting the virtual space with a right virtual camera and a left virtual camera, respectively, so that the predetermined object, which is included in each of the image for a right eye and the image for a left eye, has the degree of transparency set by the transparency degree setting means; and

  • display control means for displaying the image for a right eye and the image for a left eye generated by the image generation means, on the display apparatus.

OpenGL has supported stereoscopic rendering from day one. Every version of OpenGL has had separate back and front buffers for left and right eyes (GL_BACK_LEFT, GL_FRONT_LEFT, GL_BACK_RIGHT, GL_FRONT_RIGHT).

Generally speaking, only professional hardware exposes stereoscopic rendering through OpenGL. But the API can do it.

Source Link

I believe that prior art for this would be Prior art for this would appear to be OpenGL. Any version of OpenGL. Yes, even OpenGL 1.0, published in 1994. Let's take these in order:

  • object placement means for placing a predetermined object in the virtual space;

Yes, OpenGL can be used to do that.

  • transparency degree setting means for, in accordance with a distance specified between (1) the predetermined object placed in the virtual space, and (2) a viewpoint position based on the position of a virtual camera used for virtually shooting the virtual space, setting the degree of transparency of a part or the entirety of the predetermined object such that the longer the distance is, the higher the degree of transparency is; (emphasis added)

Even ignoring shader-based techniques, OpenGL's fixed-function fog is perfectly capable of this. It's simply a matter of setting the fog color alpha to a value other than 1 and turning on blending.

The code would look something like this:

glFogi(GL_FOG_MODE, GL_LINEAR);
glFogf(GL_FOG_START, 0.8f);
glFogf(GL_FOG_END, 1.0f);
GLfloat fogColor[4] = {0.0f, 0.0f, 0.0f, 0.0f};
glFogfv(GL_FOG_COLOR, fogColor);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); //Pre-multiplied transparency

This will fade the object based on the distance from the virtual camera in the virtual space. The degree of transparency of part of the object will indeed be such that "the longer the distance is, the higher the degree of transparency".

This code would work on OpenGL 1.0 (PDF). Obviously, shaders could do the same thing, but having it as an explicit feature of the API makes this more relevant as prior art. These six lines, written in 1994, do what Nintendo is claiming to patent.

  • image generation means for generating an image for a right eye and an image for a left eye by shooting the virtual space with a right virtual camera and a left virtual camera, respectively, so that the predetermined object, which is included in each of the image for a right eye and the image for a left eye, has the degree of transparency set by the transparency degree setting means; and

  • display control means for displaying the image for a right eye and the image for a left eye generated by the image generation means, on the display apparatus.

OpenGL has supported stereoscopic rendering from day one. Every version of OpenGL has had separate back and front buffers for left and right eyes (GL_BACK_LEFT, GL_FRONT_LEFT, GL_BACK_RIGHT, GL_FRONT_RIGHT).

Generally speaking, only professional hardware exposes stereoscopic rendering through OpenGL. But the API can do it.