• Advertisement
Sign in to follow this  

Unity BSPv38 - Quake 2 BSP loader lightmap problem

This topic is 2370 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

Hey guys! I'm trying to write a quake 2 BSP loader, and everything works completely fine except for my lightmap...where I've come to a complete halt, much like this poor person: http://www.gamedev.net/community/forums/topic.asp?topic_id=17243 Is anyone floating around here thats run into the same problem? Half my lightmaps look good the other half of surfaces seem warped and retarded - like I've got the wrong dimensions or something. The general color of the lightmaps seem correct But I've followed http://www.flipcode.com/archives/Quake_2_BSP_File_Format.shtml and snooped around heaps, but I've only found people with the same problem, not solutions =( Here are comparison screenies: Here quake 2 screenshot with console command gl_lightmap 1: http://img523.imageshack.us/my.php?image=lightmap2.jpg Here is my engine's futil attempt at rendering the lightmap: (with tex filter turned off): http://img523.imageshack.us/my.php?image=lightmap1.jpg Also, it would be of great help if someone can point me to where quake 2 source stores each face's lightmap width/height, as I can just output that and compare. I've been digging through this q2source and keep getting lost o.O

Share this post


Link to post
Share on other sites
Advertisement
make sure you're using bilinear filtering on the lightmap textures, in opengl i think the functions are

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);

Share this post


Link to post
Share on other sites
yes i can easily put bilinear filtering on,

except it still looks "wrong" for some reason - my texture width/height calculations seem off, but I've followed that guide EXACTLY.

I also don't understand the part about lightmap being max 16x16...I'm getting lightmaps that are much larger than 16x16 from the exact formula he has given on the site, the web page contradicts itself o.O

Thanks,
HyperNewbie

Share this post


Link to post
Share on other sites
Anyway, from looking at other people's projects and randomly modifying random bits of bitsy code, I somehow managed to get the formula right.

The formula for texture width and height are wrong, and the website has no mention of how lightmap texture coordinates are calculated.

I'll post my findings here, just in case anyone comes across this page on google with the exact same problem I ran into:

This info is for BSPv38, in other words Quake 2 BSP files, regarding lightmaps and loading and rendering them properly. I used openGL to do the rendering.

Getting lightmap dimensions:

Face structure gives the lightmap offset, but for some crazy reason, does not give the lightmap dimensions: you must calculate them yourself by going through every vertex, calculating their texture map U V co-ordinates and do stuff to them.

So, first, you go through every vertex of the face, and calculate their UV co-ordinates (use the formulae on the website http://www.flipcode.com/archives/Quake_2_BSP_File_Format.shtml).

u = x * u_axis.x + y * u_axis.y + z * u_axis.z + u_offset
v = x * v_axis.x + y * v_axis.y + z * v_axis.z + v_offset

Then, you get the results in two floats, u and v. FLOOR u and FLOOR v into two integers, floor_u and floor_v. Then, you check floor_u and floor_v against max_u and max_v and min_u and min_v (4 of them all integers), to get the maximum and minimum floor_u and floor_v variables seen so far. DO NOT GET MAXIMUM/MINIMUM u and v. We need maximum/minimum floor_u and floor_v.

Then, you divide the min_u and max_u and min_v and max_v variables by 16, in FLOAT. If you are using C++, this means you will need to specifically typecast those 4 ints into float before dividing by 16.

Then, you floor the two min_ variables and ceil the two max_ variables, get the difference between the two, add 1, and typecast the result back to an int.

Here is my little bit of C++ code that does this step:

_minU = (float)floor((float)(minU / 16.0));
_maxU = (float)ceil((float)(maxU / 16.0));
_minV = (float)floor((float)(minV / 16.0));
_maxV = (float)ceil((float)(maxV / 16.0));
LIGHTMAPW = (int)(_maxU - _minU + 1);
LIGHTMAPH = (int)(_maxV - _minV + 1);

Getting lightmap texture co-ordinates:
This will generate a texture co-ordinate that's in the range 0.0 to 1.0, for opengl glTexCoord2f usage.

Let's say we need to get the texture co-ordinates for a vertex.

we first calculate the u and v for the texture map, the formula given above.
Then, we get LIGHTMAPW and LIGHTMAPH , also given above
We also need the minU and minV and maxU and maxV from above, the max/min floor_u and floor_v for all vertexes.

Then, simply follow this formula:

float MidPolyU = (minU + maxU) / 2.0;
float MidPolyV = (minV + maxV) / 2.0;
float MidTexU = LIGHTMAPW / 2.0;
float MidTexV = LIGHTMAPH / 2.0;
float lightmap_u = MidTexU + (u - MidPolyU) / 16.0;
float lightmap_v = MidTexV + (v - MidPolyV) / 16.0;
glTexCoord2f(lightmap_u/LIGHTMAPW ,lightmap_v/LIGHTMAPH );

As you can see, we get the co-ordinates and make them relative to the middle of the texture. Or something like that.

Hopefully this will solve the problems for people who are trying to load quake2's BSP files and get stuck at trying to load the lightmaps, because nowhere on the face of the internet is there such a documentation of this and quake 2 source code takes a while to excavate into.

Check six,
HyperNewbie

Share this post


Link to post
Share on other sites
I know the topic is too old.
But I want to make the answer clear for others, because I spent a lot of time determining the source of wierd/broken/rainbow lightmaps.
So here is how to read lightmaps from quake 2 bsp file.
The next code is a bit simplified and there is no lightmap baking into one single texture here.
Only per-face generation of lightmaps just to be clear of all texture coordinate/dimensions calculations.

1. Just get all the data into memory:
int lightmapDataLength = header.lump[LUMP_LIGHTMAPS].length; // /sizeof(unsigned char);
unsigned char lightmapData = new unsigned char[lightmapDataLength];
fseek(file, header.lump[LUMP_LIGHTMAPS].offset, SEEK_SET); // LUMP_LIGHTMAPS is 7
fread(lightmapData, sizeof(unsigned char), lightmapDataLength, file);

Alternatively you can also seek for each lightmap while iterating through bsp faces. Current lightmap for current face would be located at header.lump[LUMP_LIGHTMAPS].offset + currentFace.lightmap_offset

2. Yes, to get lightmap dimensions you must process all faces and get those damn floored min/max of UVs.
First of all you must init the face data like this:
faces[f].fminUV.x = 999999;
faces[f].fminUV.y = 999999;
faces[f].fmaxUV.x = -99999;
faces[f].fmaxUV.y = -99999;

Then, you calculate the texture coordinates exactly like it's written on all q2bsp specs:
faces[f].texcoords[i*2 + j].x = verts[idx].x * texinfo->u_axis.x + verts[idx].y * texinfo->u_axis.y + verts[idx].z * texinfo->u_axis.z + texinfo->u_offset;
faces[f].texcoords[i*2 + j].y = verts[idx].x * texinfo->v_axis.x + verts[idx].y * texinfo->v_axis.y + verts[idx].z * texinfo->v_axis.z + texinfo->v_offset;

And only after that you compute min/max values while iterating through faces:

faces[f].fminUV.x = min(floor(faces[f].texcoords[i*2 + j].x), faces[f].fminUV.x);
faces[f].fminUV.y = min(floor(faces[f].texcoords[i*2 + j].y), faces[f].fminUV.y);
faces[f].fmaxUV.x = max(floor(faces[f].texcoords[i*2 + j].x), faces[f].fmaxUV.x);
faces[f].fmaxUV.y = max(floor(faces[f].texcoords[i*2 + j].y), faces[f].fmaxUV.y);


3. Now you're ready to get lightmap dimensions:
int lightMapWidth = ceil(faces[f].fmaxUV.x/16) - floor(faces[f].fminUV.x/16) +1;
int lightMapHeight = ceil(faces[f].fmaxUV.y/16) - floor(faces[f].fminUV.y/16) +1;


4. Now the important part which is still never indicated by anybody, with a little exceptions.
First of all if you choose to offset into lightmap data array directly, like:
unsigned char *lm_data = &lightmapData[face->lightmap_offset];
And then pass rgb data into opengl you MUST specify alignment!
glPixelStorei(GL_PACK_ALIGNMENT,1);
glPixelStorei(GL_UNPACK_ALIGNMENT,1);
glTexImage2D(GL_TEXTURE_2D, 0, 3, lightMapWidth, lightMapHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, lm_data);

Without this all the people get lightmaps which are diagonaly projected or a lot of rainbow colors.
This deceives most developers and they think like: damn the calculations are wrong, there is something wrong with pointers/data/uvs/etc BUT ITS THE DAMN ALIGNMENT (blame Carmack for all this shit!)
The alternative way to read the data is to read it as rgb and add fourth component with value 255 and upload into rgba texture, like this:
static unsigned char lm_data[32*32*4] = {0};
fseek(file, header.lump[LUMP_LIGHTMAPS].offset + face->lightmap_offset, SEEK_SET);
for(int y = 0; y<lightMapHeight; y++) {
for(int x = 0; x<lightMapWidth; x++) {
unsigned char rgba[4];
fread(rgba, sizeof(unsigned char), 3, file); // read rgb
rgba[3] = 255; // set the 4th component to 255
memcpy(&lm_data[x*4+(y*4)*lightMapWidth], rgba, sizeof(unsigned char)*4); // write as rgba
}
}
glTexImage2D(GL_TEXTURE_2D, 0, 4, lightMapWidth, lightMapHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, lm_data);

And don't forget the clamping:
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);


5. Rendering (resulting texture coordinates generation):
u = face->texcoords[j].x;
v = face->texcoords[j].y;
u -= face->fminUV.x;
v -= face->fminUV.y;
u /= (face->fmaxUV.x - face->fminUV.x);
v /= (face->fmaxUV.y - face->fminUV.y);
glTexCoord2f(u, v);
glVertex3fv(&face->vertices[j].x);


The result... well not totally but almost identical.
quake2vscustom.th.jpg

Share this post


Link to post
Share on other sites
The other alternative is to study the GPL Quake 2 source code and see how that does it (by packing lightmap textures into a 128x128 atlas and adjusting texcoords to match so that alignment isn't actually a problem).

Share this post


Link to post
Share on other sites

The other alternative is to study the GPL Quake 2 source code and see how that does it (by packing lightmap textures into a 128x128 atlas and adjusting texcoords to match so that alignment isn't actually a problem).

2010-09-24-09-13-15142648791.jpg

srsly, did you try that yourself?
Why there's a tons of broken specs and such a clever person like you still didn't post any explanation anywhere so people won't be having problems?
Study what?...
A lot of non-commented retarded code with thousands of hax and funny comments like '// sigh' or '// stupid quake bug' where static lightmapping mixed with dynamic one with wrapped functions of memory allocation and also complicated with atlasing and hardware specific routines and around 80kb of code (gl_rsurf.c, gl_light.c, gl_model.c) just for this? LOL

Everyone knows that it does pack into atlas. But the alignment is an actual problem ANYWAY even if you will use atlas.
Why? Well, just try to upload lightmaps into your atlas having everything in GL_RGB (hell isn't obvious to use rgb when it's stored in rgb lol) format with TexSubImage and you'll get nice rainbows.
So there is a choice: you either store it in GL_RGBA filling dump alpha channel with 255 or using glPixelStorei with GL_RGB.
It's not because lightmaps are not in atlas, it's because of how the data is stored in binary bsp file...

That's it and no need to 'study' any code where obvious things wrapped around thousand data structures.
I showed per-face texturing just because it's lot easier to understand. After this you can easily make atlas or whatever you want.

Share this post


Link to post
Share on other sites
sly, did you try that yourself?


As it happens, I did.

Yes - there is deep ugliness in there, but yes - if you want to work with Quake 2 formats then it is the definitive reference. Please note that I'm not sayig "copy/paste this code". What I'm saying is "if you want to know how lightmaps are supposed to work in the Quake 2 engine, this is the place to go".

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement
  • Advertisement
  • Popular Tags

  • Advertisement
  • Popular Now

  • Similar Content

    • By 3dmodelerguy
      So I am building a turn based rogue-like (think CDDA). The game is going to have a very large map (up to 1000's x 1000's) however to alleviate most of that I obviously can't render everything so there will just be render a certain radius around the player and just load in and out data as the player moves.
      The next major system I am prototyping is making interactive tiles destructible and pretty much everything will be destructible besides basic landscape (cars, doors, windows, structures, etc. will be destructible)
      While I am only rendering a certain amount of tiles around the player, I want to keep the amount of colliders active at one time to be as small as possible for performance and currently the tilemap tool I use automatically merges colliders together.
      So instead of creating a separate colliders for each of these tiles and having the destructible behavior tied to that object (which my tilemap tool would allow me to do) I was thinking that I would store an array of all the X and Y locations for the interactive tilemap layer and let the tilemap manage the colliders. 
      Then when I hit a collider on the interactive tilemap layer, instead of of getting the behavior for how to deal with the destruction for that tile from that game object, I would pull it from the array I mentioned earlier based on the tile I attempt to interact with which I already have.
      Does this sound like a good approach? Any other recommendations would be welcomed.
    • By NDraskovic
      Hey guys,
      I have a really weird problem. I'm trying to get some data from a REST service. I'm using the following code:
       
      private void GetTheScores() { UnityWebRequest GetCommand = UnityWebRequest.Get(url); UnityWebRequestAsyncOperation operation = GetCommand.SendWebRequest(); if (!operation.webRequest.isNetworkError) { ResultsContainer rez = JsonUtility.FromJson<ResultsContainer>(operation.webRequest.downloadHandler.text); Debug.Log("Text: " + operation.webRequest.downloadHandler.text); } } The problem is that when I'm in Unity's editor, the request doesn't return anything (operation.webRequest.downloadHandler.text is empty, the Debug.Log command just prints "Text: "), but when I enter the debug mode and insert a breakpoint on that line, then it returns the text properly. Does anyone have an idea why is this happening?
      The real problem I'm trying to solve is that when I receive the text, I can't get the data from the JSON. The markup is really simple:
      [{"id":1,"name":"Player1"},{"id":2,"name":"Player2"}] and I have an object that should accept that data:
      [System.Serializable] public class ResultScript { public int id; public string name; } There is also a class that should accept the array of these objects (which the JSON is returning):
      [System.Serializable] public class ResultsContainer { public ResultScript[] results; } But when I run the code (in the debug mode, to get any result) I get an error: ArgumentException: JSON must represent an object type. I've googled it but none of the proposed solutions work for me.
      Also (regardless if I'm in the debug mode or not) when I try to do some string operations like removing or adding characters to the GET result, the functions return an empty string as a result
      Can you help me with any of these problems?
      Thank you
    • By nihitori
      The Emotional Music Vol. I pack focuses on beautiful and esoteric orchestral music, capable of creating truly emotive and intimate moods. It features detailed chamber strings, cello and piano as the main instruments, resulting in a subtle and elegant sound never before heard in video game royalty-free music assets.

      The pack includes 5 original tracks, as well as a total of 47 loops based on these tracks (long loops for simple use and short loops for custom / complex music layering).

      Unity Asset Store link: https://www.assetstore.unity3d.com/en/#!/content/107032
      Unreal Engine Marketplace link: https://www.unrealengine.com/marketplace/emotional-music-vol-i

      A 15 seconds preview of each main track is available on Soundcloud:
       
    • By RoKabium Games
      Another one of our new UI for #screenshotsaturday. This is the inventory screen for showing what animal fossils you have collected so far. #gamedev #indiedev #sama
    • By eldwin11929
      We're looking for programmers for our project.
      Our project is being made in Unity
      Requirements:
      -Skills in Unity
      -C#
      -Javascript
      -Node.js
      We're looking for programmers who can perform a variety of functions on our project.
      Project is a top-down hack-and-slash pvp dungeon-crawler like game. Game is entirely multiplayer based, using randomized dungeons, and a unique combat system with emphasis on gameplay.
      We have a GDD to work off of, and a Lead Programmer you would work under.
      Assignments may include:
      -Creating new scripts of varying degrees specific to the project (mostly server-side, but sometimes client-side)
      -Assembling already created monsters/characters with existing or non-existing code.
      -Creating VFX
      -Assembling already created environment models
      If interested, please contact: eldwin11929@yahoo.com
      This project is unpaid, but with royalties.
       
      ---
      Additional Project Info:
      Summary:
      Bassetune Reapers is a Player-verus-Player, competitive dungeon crawler. This basically takes on aspects of dungeon crawling, but with a more aggressive setting. Players will have the option to play as the "dungeon-crawlers" (called the 'Knights', or "Knight Class", in-game) or as the "dungeon" itself (literally called the 'Bosses', or "Boss Class", in-game). What this means is that players can choose to play as the people invading the dungeon, or as the dungeon-holders themselves.
      Key Features:
      -Intense, fast-paced combat
      -Multiple skills, weapons, and ways to play the game
      -Tons of different Bosses, Minibosses, creatures and traps to utilize throughout the dungeon
      -Multiple unique environments
      -Interesting, detailed lore behind both the game and world
      -Intricate RPG system
      -Ladder and ranking system
      -Lots of customization for both classes s of customization for both classes
  • Advertisement