Sign in to follow this  
graveyard filla

OpenGL how to do modulation to simulate lighting effects ???

Recommended Posts

hi, im working on a 2D RPG w / C++ , SDL, and OpenGL. anyway, i was talking to a friend of mine whos making an RPG w / d3d. in it, he has some really cool lighting effects. basically, each tile, sprite, etc, has a darkness value. there is no real "light", he just blends everything with a dark color to make things that arent as dark appear lit. basically, he makes his character / tile quad blended with a dark color to make it appear darker then it really is. i dont think this will work by just using glColor4f(), since once i bind a texture to a quad, the color no longer matters (except the alpha). i was thinking i could draw a black quad over everything and blend it, but this seems very expensive and too much work to do. surely there must be a way to blend a color with a textured quad? thanks for any help!!

Share this post


Link to post
Share on other sites
Have you actually tried using it? I see no reason why it shouldn't work. I may be missing your point, but it seems simple enough.

glBindTexture (GL_TEXTURE_2D, textureId);
glBegin (GL_QUADS);
glColor3f (0.5f, 0.5f, 0.5f);
glTexCoord2f (...
glVertex3f (...

Share this post


Link to post
Share on other sites
>>i dont think this will work by just using glColor4f(), since once i bind a texture to a quad, the color no longer matters (except the alpha).<<

yes it does, if lighting is disabled and texenv is set to get MODULATE

Share this post


Link to post
Share on other sites
i think he means -
void glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE )
glTexEnvi specifies how your textures are combined with colors in the frame buffer. GL_MODULATE allows your texture colors to be multiplied by the existing pixel color, and not replace them.
hope that helps.

<edit> the other two modes are
GL_BLEND - the texture color is multiplied by the pixel color and is combined with a constant color
GL_DECAL - the texture color replaces the pixel color

Share this post


Link to post
Share on other sites
*sheepish grin* i would be more help if i read the next sentence -
Quote:

taken from Opengl Game Programming
The default value for glTexEnvi() is GL_MODULATE

i'm pretty sure you have to call the function in order for that to be true, though. someone correct me if i'm wrong.

Share this post


Link to post
Share on other sites
Quote:
Original post by stormrunner
i think he means -
void glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE )
glTexEnvi specifies how your textures are combined with colors in the frame buffer. GL_MODULATE allows your texture colors to be multiplied by the existing pixel color, and not replace them.
hope that helps.

<edit> the other two modes are
GL_BLEND - the texture color is multiplied by the pixel color and is combined with a constant color
GL_DECAL - the texture color replaces the pixel color


It's not true that glTexEnvi specifies how your textures are combined with colors in the frame buffer - it would be blending and glBlendFunc and glEnable/Disable(GL_BLEND). Tex env specifies how during particular pass color's from different sources(textures,diffuse,specular etc) are mixed withing texture units - that's all. Only the output value is blended into frame buffer

Share this post


Link to post
Share on other sites
Quote:
It's not true that glTexEnvi specifies how your textures are combined with colors in the frame buffer

my only defense is that that is specifically what "the book" said - word for word.
Quote:

taken from Opengl Game Programming - pg. 242 section Texture Functions
The target parameter must be equal to GL_TEXTURE_ENV. You must also set the pname parameter equal to GL_TEXTURE_ENV_MODE, which tells OpenGL that you will be specifying how textures are going to be combined with colors in the frame buffer.

Share this post


Link to post
Share on other sites
Quote:
Original post by stormrunner
Quote:
It's not true that glTexEnvi specifies how your textures are combined with colors in the frame buffer

my only defense is that that is specifically what "the book" said - word for word.
Quote:

taken from Opengl Game Programming - pg. 242 section Texture Functions
The target parameter must be equal to GL_TEXTURE_ENV. You must also set the pname parameter equal to GL_TEXTURE_ENV_MODE, which tells OpenGL that you will be specifying how textures are going to be combined with colors in the frame buffer.


Quote:
from MSDN
glTexEnvf, glTexEnvi, glTexEnvfv, glTexEnviv
These functions set texture environment parameters.

void glTexEnvf(
GLenum target,
GLenum pname,
GLfloat param
);

void glTexEnvi(
GLenum target,
GLenum pname,
GLint param
);
Parameters
target
A texture environment. Must be GL_TEXTURE_ENV.
pname
The symbolic name of a single valued–texture environment parameter. Must be GL_TEXTURE_ENV_MODE.
param
A single symbolic constant, one of GL_MODULATE, GL_DECAL, GL_BLEND, or GL_REPLACE.
void glTexEnvfv(
GLenum target,
GLenum pname,
const GLfloat *params
);

void glTexEnviv(
GLenum target,
GLenum pname,
const GLint *params
);
Parameters
target
A texture environment. Must be GL_TEXTURE_ENV.
pname
The symbolic name of a texture environment parameter. Accepted values are GL_TEXTURE_ENV_MODE and GL_TEXTURE_ENV_COLOR.
params
A pointer to an array of parameters: either a single symbolic constant or an RGBA color.
Remarks
A texture environment specifies how texture values are interpreted when a fragment is textured. The target parameter must be GL_TEXTURE_ENV. The pname parameter can be either GL_TEXTURE_ENV_MODE or GL_TEXTURE_ENV_COLOR.

If pname is GL_TEXTURE_ENV_MODE, then params is (or points to) the symbolic name of a texture function. Three texture functions are defined: GL_MODULATE, GL_DECAL, and GL_BLEND.

A texture function acts on the fragment to be textured using the texture image value that applies to the fragment (see glTexParameter) and produces an RGBA color for that fragment. The following table shows how the RGBA color is produced for each of the three texture functions that can be chosen. C is a triple of color values (RGB) and A is the associated alpha value. RGBA values extracted from a texture image are in the range [0,1]. The subscript f refers to the incoming fragment, the subscript t to the texture image, the subscript c to the texture environment color, and subscript v indicates a value produced by the texture function.

A texture image can have up to four components per texture element (see glTexImage1D and glTexImage2D). In a one-component image, Lt indicates that single component. A two-component image uses Lt and At. A three-component image has only a color value, Ct. A four-component image has both a color value Ct and an alpha value At.


Besides, I'm using it;)

Share this post


Link to post
Share on other sites
cheers - you win the doc war. but if your only point is that that one assumption is wrong, perhaps it'd be beneficial to the OP to explain how in conjunction with glTexEnvi (or without ?)
Quote:
It's not true that glTexEnvi specifies how your textures are combined with colors in the frame buffer - it would be blending and glBlendFunc and glEnable/Disable(GL_BLEND).

is relevant and would be used.

Share this post


Link to post
Share on other sites
ok, im a little confused now. what was the dispute about? and what do i have to do to get the effect i want?


"It's not true that glTexEnvi specifies how your textures are combined with colors in the frame buffer - it would be blending and glBlendFunc and glEnable/Disable(GL_BLEND). Tex env specifies how during particular pass color's from different sources(textures,diffuse,specular etc) are mixed withing texture units - that's all. Only the output value is blended into frame buffer"

im just a little confused... so glTexEnvi is what i want to use to get the modulation effect (IE blend the actual color of the quad with the texture).... so then what does blendFunc have to do with it then? and was i correct about how to disable it? just send the function DECAL to go back to normal? thanks again for your guys help!

Share this post


Link to post
Share on other sites
*sheepish grin* don't worry, we were just being anal about the details. i paid no attention to detail and made a general statement that ignored those details/got them completely wrong.
tomek_zielinski's point that
Quote:
Tex env specifies how during particular pass color's from different sources(textures,diffuse,specular etc) are mixed withing texture units

was correct.
you can use glTexEnvi without blending being enabled provided you aren't trying to blend two textures over each other (multi-texturing). neither tomek_zielinski's msdn doc nor my book mentioned needing GL_BLEND for regular tasks, so i'm assuming you don't. someone correct me if thats wrong.
Quote:
just send the function DECAL to go back to normal?

Quote:
taken from Opengl Game Programming
The default value for glTexEnvi() is GL_MODULATE

normal = default. the "normal" value is GL_MODULATE.
just for reference, you can specify a different glTexEnvi() for each texture.

[Edited by - stormrunner on August 4, 2004 7:37:19 PM]

Share this post


Link to post
Share on other sites
hmm.. im just a little confused still.. sorry if you think im stupid.

so its not a state then? i would specify it for each texture? cuz the docs that ive found show no where to specify the texture. im guessing once you call the function, any primitives drawn after that will follow the rules the function called, untill i call the function again with different parameters??

also, if the default is MODULATION, how come when i draw a quad with a texture and color, i only see the texture?

thanks again for all your help!

Share this post


Link to post
Share on other sites
Quote:
im guessing once you call the function, any primitives drawn after that will follow the rules the function called, untill i call the function again with different parameters

precisely, its just like most other opengl functions. its effects (as far as i can tell) are activated once you call it, but the glTexEnvi call is only valid between the glEnable(GL_TEXTURE_2D) and the subsequent glDisable call, just like the functions beneath blending and lighting. sorry if that wasn't clear. opengl doesn't presume to know what you want - so even though the default is GL_MODULATE, you have to let it know to activate that, or change it to something else, otherwise it won't happen. i suppose your original supposition was "technically" correct - that the "global" opengl default is GL_DECAL, until you call glTexEnvi or use a blending function.
Quote:
cuz the docs that ive found show no where to specify the texture

examples of using glTexEnvi can be found here for multi-texturing (don't know if that helps) here, and here. check them out - each shows a different way( in application) to use the function (i think, i didn't read them through), although the last one is probably the clearest use of it.

<edit> deleted redundant link
<edit> "using" the function as in loading textures with it

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  

  • Announcements

  • Forum Statistics

    • Total Topics
      628354
    • Total Posts
      2982243
  • Similar Content

    • By test opty
      Hi all,
       
      I'm starting OpenGL using a tut on the Web. But at this point I would like to know the primitives needed for creating a window using OpenGL. So on Windows and using MS VS 2017, what is the simplest code required to render a window with the title of "First Rectangle", please?
       
       
    • By DejayHextrix
      Hi, New here. 
      I need some help. My fiance and I like to play this mobile game online that goes by real time. Her and I are always working but when we have free time we like to play this game. We don't always got time throughout the day to Queue Buildings, troops, Upgrades....etc.... 
      I was told to look into DLL Injection and OpenGL/DirectX Hooking. Is this true? Is this what I need to learn? 
      How do I read the Android files, or modify the files, or get the in-game tags/variables for the game I want? 
      Any assistance on this would be most appreciated. I been everywhere and seems no one knows or is to lazy to help me out. It would be nice to have assistance for once. I don't know what I need to learn. 
      So links of topics I need to learn within the comment section would be SOOOOO.....Helpful. Anything to just get me started. 
      Thanks, 
      Dejay Hextrix 
    • By mellinoe
      Hi all,
      First time poster here, although I've been reading posts here for quite a while. This place has been invaluable for learning graphics programming -- thanks for a great resource!
      Right now, I'm working on a graphics abstraction layer for .NET which supports D3D11, Vulkan, and OpenGL at the moment. I have implemented most of my planned features already, and things are working well. Some remaining features that I am planning are Compute Shaders, and some flavor of read-write shader resources. At the moment, my shaders can just get simple read-only access to a uniform (or constant) buffer, a texture, or a sampler. Unfortunately, I'm having a tough time grasping the distinctions between all of the different kinds of read-write resources that are available. In D3D alone, there seem to be 5 or 6 different kinds of resources with similar but different characteristics. On top of that, I get the impression that some of them are more or less "obsoleted" by the newer kinds, and don't have much of a place in modern code. There seem to be a few pivots:
      The data source/destination (buffer or texture) Read-write or read-only Structured or unstructured (?) Ordered vs unordered (?) These are just my observations based on a lot of MSDN and OpenGL doc reading. For my library, I'm not interested in exposing every possibility to the user -- just trying to find a good "middle-ground" that can be represented cleanly across API's which is good enough for common scenarios.
      Can anyone give a sort of "overview" of the different options, and perhaps compare/contrast the concepts between Direct3D, OpenGL, and Vulkan? I'd also be very interested in hearing how other folks have abstracted these concepts in their libraries.
    • By aejt
      I recently started getting into graphics programming (2nd try, first try was many years ago) and I'm working on a 3d rendering engine which I hope to be able to make a 3D game with sooner or later. I have plenty of C++ experience, but not a lot when it comes to graphics, and while it's definitely going much better this time, I'm having trouble figuring out how assets are usually handled by engines.
      I'm not having trouble with handling the GPU resources, but more so with how the resources should be defined and used in the system (materials, models, etc).
      This is my plan now, I've implemented most of it except for the XML parts and factories and those are the ones I'm not sure of at all:
      I have these classes:
      For GPU resources:
      Geometry: holds and manages everything needed to render a geometry: VAO, VBO, EBO. Texture: holds and manages a texture which is loaded into the GPU. Shader: holds and manages a shader which is loaded into the GPU. For assets relying on GPU resources:
      Material: holds a shader resource, multiple texture resources, as well as uniform settings. Mesh: holds a geometry and a material. Model: holds multiple meshes, possibly in a tree structure to more easily support skinning later on? For handling GPU resources:
      ResourceCache<T>: T can be any resource loaded into the GPU. It owns these resources and only hands out handles to them on request (currently string identifiers are used when requesting handles, but all resources are stored in a vector and each handle only contains resource's index in that vector) Resource<T>: The handles given out from ResourceCache. The handles are reference counted and to get the underlying resource you simply deference like with pointers (*handle).  
      And my plan is to define everything into these XML documents to abstract away files:
      Resources.xml for ref-counted GPU resources (geometry, shaders, textures) Resources are assigned names/ids and resource files, and possibly some attributes (what vertex attributes does this geometry have? what vertex attributes does this shader expect? what uniforms does this shader use? and so on) Are reference counted using ResourceCache<T> Assets.xml for assets using the GPU resources (materials, meshes, models) Assets are not reference counted, but they hold handles to ref-counted resources. References the resources defined in Resources.xml by names/ids. The XMLs are loaded into some structure in memory which is then used for loading the resources/assets using factory classes:
      Factory classes for resources:
      For example, a texture factory could contain the texture definitions from the XML containing data about textures in the game, as well as a cache containing all loaded textures. This means it has mappings from each name/id to a file and when asked to load a texture with a name/id, it can look up its path and use a "BinaryLoader" to either load the file and create the resource directly, or asynchronously load the file's data into a queue which then can be read from later to create the resources synchronously in the GL context. These factories only return handles.
      Factory classes for assets:
      Much like for resources, these classes contain the definitions for the assets they can load. For example, with the definition the MaterialFactory will know which shader, textures and possibly uniform a certain material has, and with the help of TextureFactory and ShaderFactory, it can retrieve handles to the resources it needs (Shader + Textures), setup itself from XML data (uniform values), and return a created instance of requested material. These factories return actual instances, not handles (but the instances contain handles).
       
       
      Is this a good or commonly used approach? Is this going to bite me in the ass later on? Are there other more preferable approaches? Is this outside of the scope of a 3d renderer and should be on the engine side? I'd love to receive and kind of advice or suggestions!
      Thanks!
    • By nedondev
      I 'm learning how to create game by using opengl with c/c++ coding, so here is my fist game. In video description also have game contain in Dropbox. May be I will make it better in future.
      Thanks.
  • Popular Now