mirror of
https://github.com/kevinbentley/Descent3.git
synced 2026-04-14 05:00:03 -04:00
Move internal level editor into main tree
This commit is contained in:
Louis Gombert
917
editor/HTexture.cpp
Normal file
917
editor/HTexture.cpp
Normal file
@@ -0,0 +1,917 @@
|
||||
/*
|
||||
* Descent 3
|
||||
* Copyright (C) 2024 Parallax Software
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
--- HISTORICAL COMMENTS FOLLOW ---
|
||||
|
||||
* $Logfile: /DescentIII/Main/editor/HTexture.cpp $
|
||||
* $Revision: 1.1.1.1 $
|
||||
* $Date: 2003-08-26 03:57:38 $
|
||||
* $Author: kevinb $
|
||||
*
|
||||
* HTexture implementation
|
||||
*
|
||||
* $Log: not supported by cvs2svn $
|
||||
*
|
||||
* 37 12/27/99 8:26a Gwar
|
||||
*
|
||||
* 36 8/30/99 12:55p Gwar
|
||||
* added a parameter to HTexturePropagateToFace to not change the texture
|
||||
* of the target face
|
||||
*
|
||||
* 35 7/30/99 1:19p Gwar
|
||||
* don't set World_changed in NEWEDITOR
|
||||
*
|
||||
* 34 7/24/99 5:25a Gwar
|
||||
* NEWEDITOR changes to HTextureApplyToRoomFace
|
||||
*
|
||||
* 33 7/04/99 4:56p Gwar
|
||||
* changes for texture management in NEWEDITOR
|
||||
*
|
||||
* 32 5/19/99 12:19a Gwar
|
||||
* #define Curroomp, Curface, etc as members of prim struct in NEWEDITOR
|
||||
* -- this allows the main room frame and level window to share these
|
||||
* variables and makes them non-global (i.e. no more sync problem between
|
||||
* world and room views)
|
||||
*
|
||||
* 31 5/03/99 2:06a Gwar
|
||||
* added HTexture.cpp to project
|
||||
*
|
||||
* 30 1/20/99 10:50a Jason
|
||||
* added new terrain
|
||||
*
|
||||
* 29 10/21/98 1:27p Jason
|
||||
* fixed texture u2,v2 sliding problems
|
||||
*
|
||||
* 28 8/16/98 4:24p Matt
|
||||
* When copying UVs from one face to another, only copy u & v, and not
|
||||
* other fields in the uv structure.
|
||||
*
|
||||
* 27 8/15/98 5:04p Matt
|
||||
* Added code to copy a texture & UVs from one face to another
|
||||
*
|
||||
* 26 6/15/98 4:00p Jason
|
||||
* replaced monochromatic polymodel lighting with rgb lighting
|
||||
*
|
||||
* 25 4/16/98 10:42a Matt
|
||||
* Made texture propagation work across rooms.
|
||||
*
|
||||
* 24 4/02/98 12:23p Jason
|
||||
* trimmed some fat from our structures
|
||||
*
|
||||
* 23 9/23/97 12:20p Jason
|
||||
* fixed bug where rotating a texture would cause alphas and u2,v2s to
|
||||
* become corrupt
|
||||
*
|
||||
* 22 9/17/97 1:36p Samir
|
||||
* Fixed some new prototypes.
|
||||
*
|
||||
* 21 9/17/97 11:57a Matt
|
||||
* Ripped out segment code
|
||||
*
|
||||
* 19 8/21/97 6:01p Matt
|
||||
* Use groovy new FindSharedEdge() function
|
||||
*
|
||||
* 18 8/13/97 9:52a Matt
|
||||
* Combined slide left/right/up/down into one function, and the same with
|
||||
* rotate left/right
|
||||
*
|
||||
* 17 8/07/97 5:06p Jason
|
||||
* added new tiling system for terrain
|
||||
*
|
||||
* 16 8/07/97 3:19p Jason
|
||||
* replaced old terrain tmap system with new one
|
||||
*
|
||||
* 15 8/01/97 4:53p Jason
|
||||
* made a more general PropagateTextureToFace function call
|
||||
*
|
||||
* 14 7/22/97 7:08p Matt
|
||||
* Cleaned up D3EditState, moving some vars in and some out, and renaming
|
||||
* and changing a few others
|
||||
*
|
||||
* 13 7/18/97 7:38p Jason
|
||||
* finished room/terrain texture modifications
|
||||
*
|
||||
* 12 7/16/97 6:31p Jason
|
||||
* changed defaut texture uvs for terrain
|
||||
*
|
||||
* 15 6/24/97 12:41p Jason
|
||||
* checked in for safety
|
||||
*
|
||||
* 14 6/18/97 11:14a Mark
|
||||
* FROM JASON:Fixed dumb terrain rotational bug
|
||||
*
|
||||
* 13 6/17/97 4:16p Jason
|
||||
* added some terrain features
|
||||
*
|
||||
* 12 6/17/97 11:35a Jason
|
||||
* checked in for safety
|
||||
*
|
||||
* 11 6/06/97 4:57p Jason
|
||||
* more nifty megacell/tmap2 features
|
||||
*
|
||||
* 10 6/04/97 1:32p Matt
|
||||
* Changed Side_to_verts[] and Side_opposite[] to be arrays of ints, which
|
||||
* should be faster than bytes.
|
||||
*
|
||||
* 9 5/30/97 3:32p Samir
|
||||
* When rotating textures, lighting preserved
|
||||
*
|
||||
* 8 5/02/97 7:21p Matt
|
||||
* Added code to rotate tmap2's
|
||||
*
|
||||
* 7 4/17/97 4:03p Samir
|
||||
* Apply Tmap 1 and Tmap2 implemented, but no Tmap2 rendering is occurring
|
||||
* yet.
|
||||
*
|
||||
* 6 3/31/97 5:58p Matt
|
||||
* Revamped mine update flags
|
||||
*
|
||||
* 5 3/31/97 3:50p Samir
|
||||
* Set default texture uvs should work for side not whole segment.
|
||||
*
|
||||
* 4 2/26/97 6:40p Samir
|
||||
* changed g3s_uvl to g3UVL
|
||||
*
|
||||
* 3 2/26/97 3:59p Samir
|
||||
* Most scaling, rotating, sliding and flipping work.
|
||||
*
|
||||
* 2 2/20/97 11:59a Samir
|
||||
* Fixed bugs
|
||||
*
|
||||
* 1 2/20/97 11:50a Samir
|
||||
*
|
||||
* $NoKeywords: $
|
||||
*/
|
||||
|
||||
|
||||
#include "HTexture.h"
|
||||
|
||||
#ifndef NEWEDITOR
|
||||
#include "d3edit.h"
|
||||
#endif
|
||||
|
||||
#include "roomuvs.h"
|
||||
#include "gametexture.h"
|
||||
#include "terrain.h"
|
||||
#include "room.h"
|
||||
#include "descent.h"
|
||||
#include "erooms.h"
|
||||
|
||||
#define HTEX_CALIB_VAL ((float)(1.0/128.0))
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// internal function prototypes
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
void HTextureRoomStretch(room *rp, int facenum, int edge, int direction);
|
||||
void HTextureRotUVPoint(g3UVL *uvrot, float *rotmat, roomUVL *uv, g3UVL *uvcenter);
|
||||
void HTextureCreate2DRotMat(float *rotmat, angle ang);
|
||||
void HTextureRotUVTerrainPoint(g3UVL *uvrot, float *rotmat, g3UVL *uv, g3UVL *uvcenter);
|
||||
void GetUVLForRoomPoint (int roomnum,int facenum,int vertnum,roomUVL *uvl);
|
||||
int HTextureGetTopVertexForFace (int roomnum,int facenum);
|
||||
int HTextureGetBottomVertexForFace (int roomnum,int facenum);
|
||||
int HTextureGetLeftVertexForFace (int roomnum,int facenum);
|
||||
int HTextureGetRightVertexForFace (int roomnum,int facenum);
|
||||
void HTextureRotUVPointsOnRoomFace(room *roomp, int facenum, float *rotmat, g3UVL *uvcenter);
|
||||
void HTextureComputeUVRoomFaceCenter(g3UVL *uvcenter, room *roomp, int facenum);
|
||||
void HTextureTerrainStretch( int edge, int direction);
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Functions to manipulate textures within the mine, through segments
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
//Apply the specified texture to the specified room:face
|
||||
void HTextureApplyToRoomFace(room *rp,int facenum,int tnum)
|
||||
{
|
||||
ASSERT (rp->used);
|
||||
|
||||
#ifdef NEWEDITOR
|
||||
if (tnum == -1)
|
||||
return;
|
||||
if (rp->faces[facenum].tmap>=0)
|
||||
SwitchTexture(rp,rp->faces[facenum].tmap,tnum);
|
||||
#endif
|
||||
|
||||
rp->faces[facenum].tmap=tnum;
|
||||
}
|
||||
|
||||
//Copy texture from current face to adjacent face, tiling the UV coordinates
|
||||
//Parameters: destrp,destface - room:face that the propagate is based on
|
||||
// srcrp,srcface - room:face that is changed
|
||||
//Return: 1 if success, 0 if faces not adjacent
|
||||
int HTexturePropagateToFace(room *destrp,int destface,room *srcrp,int srcface,bool tex)
|
||||
{
|
||||
face *dfp = &destrp->faces[destface];
|
||||
face *sfp = &srcrp->faces[srcface];
|
||||
int v0,v1;
|
||||
|
||||
//Get shared edge
|
||||
if (destrp != srcrp) { //Faces in different rooms
|
||||
if (! FindSharedEdgeAcrossRooms(destrp,destface,srcrp,srcface,&v0,&v1))
|
||||
return 0;
|
||||
}
|
||||
else { //Faces in same room
|
||||
if (! FindSharedEdge(dfp,sfp,&v0,&v1))
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (tex)
|
||||
{
|
||||
#ifdef NEWEDITOR
|
||||
SwitchTexture(destrp,dfp->tmap,sfp->tmap);
|
||||
#endif
|
||||
|
||||
//Copy texture from Curface
|
||||
dfp->tmap = sfp->tmap;
|
||||
}
|
||||
|
||||
//Assign uvs from shared edge to rest of verts in face
|
||||
AssignUVsToFace(destrp, destface, &sfp->face_uvls[(v1+1)%sfp->num_verts], &sfp->face_uvls[v1], v0, (v0+1)%dfp->num_verts);
|
||||
|
||||
//Success
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
//Copy texture UVs from one face to another
|
||||
//Parameters: destrp,destface - room:face that is changed
|
||||
// srcrp,srcface - room:face to copy from
|
||||
// offset - vert 0 on source is assigned to vert offset on dest
|
||||
//Return: 1 if success, 0 if faces don't have the same number of verts
|
||||
int HTextureCopyUVsToFace(room *destrp,int destface,room *srcrp,int srcface,int offset)
|
||||
{
|
||||
face *dfp = &destrp->faces[destface];
|
||||
face *sfp = &srcrp->faces[srcface];
|
||||
|
||||
//Make sure faces have the same number of vertices
|
||||
if (dfp->num_verts != sfp->num_verts)
|
||||
return 0;
|
||||
|
||||
//Copy UV values
|
||||
for (int i=0;i<dfp->num_verts;i++) {
|
||||
dfp->face_uvls[(i+offset)%dfp->num_verts].u = sfp->face_uvls[i].u;
|
||||
dfp->face_uvls[(i+offset)%dfp->num_verts].v = sfp->face_uvls[i].v;
|
||||
}
|
||||
|
||||
//Success!
|
||||
#ifndef NEWEDITOR
|
||||
World_changed = 1;
|
||||
#endif
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
// texture flipping
|
||||
|
||||
void HTextureFlipX()
|
||||
{
|
||||
int i;
|
||||
|
||||
if (Editor_view_mode==VM_TERRAIN)
|
||||
{
|
||||
//terrain_segment oldseg;
|
||||
|
||||
for (i=0;i<TERRAIN_DEPTH*TERRAIN_WIDTH;i++)
|
||||
{
|
||||
if (TerrainSelected[i])
|
||||
{
|
||||
/*oldseg=Terrain_seg[i];
|
||||
Terrain_seg[i].u[0]=oldseg.u[1];
|
||||
Terrain_seg[i].u[1]=oldseg.u[0];
|
||||
Terrain_seg[i].u[2]=oldseg.u[3];
|
||||
Terrain_seg[i].u[3]=oldseg.u[2];
|
||||
|
||||
Terrain_seg[i].v[0]=oldseg.v[1];
|
||||
Terrain_seg[i].v[1]=oldseg.v[0];
|
||||
Terrain_seg[i].v[2]=oldseg.v[3];
|
||||
Terrain_seg[i].v[3]=oldseg.v[2];*/
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
ASSERT (Curroomp->used);
|
||||
|
||||
for (int i=0;i<Curroomp->faces[Curface].num_verts;i++)
|
||||
Curroomp->faces[Curface].face_uvls[i].u=1-Curroomp->faces[Curface].face_uvls[i].u;
|
||||
}
|
||||
|
||||
#ifndef NEWEDITOR
|
||||
World_changed = 1;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
void HTextureFlipY()
|
||||
{
|
||||
int i;
|
||||
|
||||
if (Editor_view_mode==VM_TERRAIN)
|
||||
{
|
||||
terrain_segment oldseg;
|
||||
|
||||
for (i=0;i<TERRAIN_DEPTH*TERRAIN_WIDTH;i++)
|
||||
{
|
||||
if (TerrainSelected[i])
|
||||
{
|
||||
oldseg=Terrain_seg[i];
|
||||
/*Terrain_seg[i].v[0]=oldseg.v[3];
|
||||
Terrain_seg[i].v[1]=oldseg.v[2];
|
||||
Terrain_seg[i].v[2]=oldseg.v[1];
|
||||
Terrain_seg[i].v[3]=oldseg.v[0];
|
||||
|
||||
Terrain_seg[i].u[0]=oldseg.u[3];
|
||||
Terrain_seg[i].u[1]=oldseg.u[2];
|
||||
Terrain_seg[i].u[2]=oldseg.u[1];
|
||||
Terrain_seg[i].u[3]=oldseg.u[0];*/
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
ASSERT (Curroomp->used);
|
||||
|
||||
for (int i=0;i<Curroomp->faces[Curface].num_verts;i++)
|
||||
Curroomp->faces[Curface].face_uvls[i].v=1-Curroomp->faces[Curface].face_uvls[i].v;
|
||||
}
|
||||
|
||||
#ifndef NEWEDITOR
|
||||
World_changed = 1;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
void HTextureSlide(room *rp, int facenum, float right, float up)
|
||||
{
|
||||
ASSERT(rp != NULL);
|
||||
ASSERT(rp->used);
|
||||
|
||||
if (Editor_view_mode==VM_TERRAIN)
|
||||
{
|
||||
/*int i;
|
||||
for (i=0;i<TERRAIN_DEPTH*TERRAIN_WIDTH;i++)
|
||||
{
|
||||
if (TerrainSelected[i])
|
||||
{
|
||||
for (int t=0;t<4;t++)
|
||||
{
|
||||
float val=Terrain_UV_lookup[Terrain_seg[i].u[t]];
|
||||
|
||||
val+=(1.0/32.0);
|
||||
|
||||
Terrain_seg[i].u[t]=TerrainLookupUV(val);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
*/
|
||||
return;
|
||||
|
||||
}
|
||||
else { //mine
|
||||
for (int i=0;i<rp->faces[facenum].num_verts;i++) {
|
||||
rp->faces[facenum].face_uvls[i].u -= right / 128.0f;
|
||||
rp->faces[facenum].face_uvls[i].v += up / 128.0f;
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef NEWEDITOR
|
||||
World_changed = 1;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
void HTextureRotate(room *roomp, int facenum, angle ang)
|
||||
{
|
||||
g3UVL uvcenter;
|
||||
float rotmat[4];
|
||||
|
||||
HTextureCreate2DRotMat(rotmat, ang);
|
||||
|
||||
if (Editor_view_mode==VM_TERRAIN && ang==0x4000)
|
||||
{
|
||||
for (int i=0;i<TERRAIN_WIDTH*TERRAIN_DEPTH;i++)
|
||||
{
|
||||
if (TerrainSelected[i])
|
||||
{
|
||||
/*int f=(Terrain_seg[i].rotation_factor&0x0F);
|
||||
f++;
|
||||
f%=4;
|
||||
|
||||
Terrain_seg[i].rotation_factor&=0xF0;
|
||||
Terrain_seg[i].rotation_factor|=(f);*/
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
else
|
||||
{
|
||||
HTextureComputeUVRoomFaceCenter(&uvcenter, roomp, facenum);
|
||||
HTextureRotUVPointsOnRoomFace(roomp, facenum, rotmat, &uvcenter);
|
||||
|
||||
}
|
||||
|
||||
#ifndef NEWEDITOR
|
||||
World_changed = 1;
|
||||
#endif
|
||||
}
|
||||
|
||||
void HTextureStretchMore(room *rp, int face, int edge)
|
||||
{
|
||||
if (Editor_view_mode==VM_TERRAIN)
|
||||
{
|
||||
HTextureTerrainStretch(edge, 1*D3EditState.texscale);
|
||||
}
|
||||
else {
|
||||
HTextureRoomStretch(rp, face, edge, 1*D3EditState.texscale);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void HTextureStretchLess(room *rp, int face, int edge)
|
||||
{
|
||||
if (Editor_view_mode==VM_TERRAIN)
|
||||
{
|
||||
HTextureTerrainStretch(edge, (-1*D3EditState.texscale));
|
||||
}
|
||||
else
|
||||
{
|
||||
HTextureRoomStretch(rp, face, edge, (-1*D3EditState.texscale));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void HTextureSetDefault(room *rp, int face)
|
||||
{
|
||||
if (Editor_view_mode==VM_TERRAIN)
|
||||
{
|
||||
for (int i=0;i<TERRAIN_WIDTH*TERRAIN_DEPTH;i++)
|
||||
{
|
||||
if (TerrainSelected[i])
|
||||
{
|
||||
int index=Terrain_seg[i].texseg_index;
|
||||
Terrain_tex_seg[index].rotation=0;
|
||||
|
||||
}
|
||||
}
|
||||
World_changed = 1;
|
||||
}
|
||||
else if (Editor_view_mode==VM_ROOM)
|
||||
{
|
||||
//@@Stretch_scale_x = (float)1.0;
|
||||
//@@Stretch_scale_y = (float)1.0;
|
||||
|
||||
for (int i=0;i<rp->faces[face].num_verts;i++)
|
||||
{
|
||||
float saveu2=rp->faces[face].face_uvls[i].u2;
|
||||
float savev2=rp->faces[face].face_uvls[i].v2;
|
||||
|
||||
GetUVLForRoomPoint (ROOMNUM(rp),face,i,&rp->faces[face].face_uvls[i]);
|
||||
|
||||
rp->faces[face].face_uvls[i].u2=saveu2;
|
||||
rp->faces[face].face_uvls[i].v2=savev2;
|
||||
}
|
||||
}
|
||||
else {
|
||||
//@@Stretch_scale_x = (float)1.0;
|
||||
//@@Stretch_scale_y = (float)1.0;
|
||||
|
||||
for (int i=0;i<rp->faces[face].num_verts;i++)
|
||||
{
|
||||
float saveu2=rp->faces[face].face_uvls[i].u2;
|
||||
float savev2=rp->faces[face].face_uvls[i].v2;
|
||||
|
||||
GetUVLForRoomPoint (ROOMNUM(rp),face,i,&rp->faces[face].face_uvls[i]);
|
||||
|
||||
rp->faces[face].face_uvls[i].u2=saveu2;
|
||||
rp->faces[face].face_uvls[i].v2=savev2;
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef NEWEDITOR
|
||||
World_changed = 1;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
void HTextureNextEdge()
|
||||
{
|
||||
Curedge++;
|
||||
|
||||
if (Editor_view_mode==VM_TERRAIN)
|
||||
{
|
||||
if (Curedge >= 4)
|
||||
Curedge = 0;
|
||||
}
|
||||
else //mine
|
||||
{
|
||||
if (Curedge >= Curroomp->faces[Curface].num_verts)
|
||||
Curedge = 0;
|
||||
}
|
||||
|
||||
State_changed = 1;
|
||||
}
|
||||
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// functions used by HTexture operations
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
// direction = -1 or 1 depending on direction
|
||||
// Stretches all vertices towards or away from a given edge
|
||||
// Depending on the geometry of the face, this can cause distortions
|
||||
void HTextureRoomStretch(room *rp, int facenum, int edge, int direction)
|
||||
{
|
||||
int next_edge=(edge+1)%rp->faces[facenum].num_verts;
|
||||
|
||||
// find deltas
|
||||
float du=rp->faces[facenum].face_uvls[next_edge].u-rp->faces[facenum].face_uvls[edge].u;
|
||||
float dv=rp->faces[facenum].face_uvls[next_edge].v-rp->faces[facenum].face_uvls[edge].v;
|
||||
|
||||
// rotate delta's 90 degrees
|
||||
float nu=-dv;
|
||||
float nv=du;
|
||||
|
||||
// Find a magnitude to shift by
|
||||
float mag=sqrt ((nv*nv) + (nu*nu));
|
||||
nv/=mag;
|
||||
nu/=mag;
|
||||
|
||||
nv/=64.0;
|
||||
nu/=64.0;
|
||||
|
||||
|
||||
// Apply to all verts except for our edge
|
||||
for (int i=0;i<rp->faces[facenum].num_verts;i++)
|
||||
{
|
||||
if (i==edge || i==next_edge)
|
||||
continue;
|
||||
|
||||
rp->faces[facenum].face_uvls[i].v-=(nv * direction);
|
||||
rp->faces[facenum].face_uvls[i].u-=(nu * direction);
|
||||
}
|
||||
|
||||
#ifndef NEWEDITOR
|
||||
World_changed = 1;
|
||||
#endif
|
||||
}
|
||||
|
||||
void HTextureTerrainStretch( int edge, int direction)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i=0;i<TERRAIN_WIDTH*TERRAIN_DEPTH;i++)
|
||||
{
|
||||
if (TerrainSelected[i])
|
||||
{
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef NEWEDITOR
|
||||
World_changed = 1;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
void HTextureComputeUVRoomFaceCenter(g3UVL *uvcenter, room *roomp, int facenum)
|
||||
{
|
||||
int i;
|
||||
face *facep = &roomp->faces[facenum];
|
||||
|
||||
uvcenter->u = 0;
|
||||
uvcenter->v = 0;
|
||||
|
||||
for (i=0; i<facep->num_verts; i++)
|
||||
{
|
||||
uvcenter->u += facep->face_uvls[i].u;
|
||||
uvcenter->v += facep->face_uvls[i].v;
|
||||
}
|
||||
|
||||
uvcenter->u /= i;
|
||||
uvcenter->v /= i;
|
||||
}
|
||||
|
||||
void HTextureRotUVPoint(g3UVL *uvrot, float *rotmat, roomUVL *uv, g3UVL *uvcenter)
|
||||
{
|
||||
uvrot->u = ((uv->u - uvcenter->u)*rotmat[0]) + ((uv->v - uvcenter->v)*rotmat[1]) + uvcenter->u;
|
||||
uvrot->v = ((uv->u - uvcenter->u)*rotmat[2]) + ((uv->v - uvcenter->v)*rotmat[3]) + uvcenter->v;
|
||||
}
|
||||
|
||||
|
||||
void HTextureRotUVPointsOnRoomFace(room *roomp, int facenum, float *rotmat, g3UVL *uvcenter)
|
||||
{
|
||||
int v;
|
||||
face *facep = &roomp->faces[facenum];
|
||||
g3UVL tuv;
|
||||
|
||||
for (v=0; v<facep->num_verts; v++) {
|
||||
HTextureRotUVPoint(&tuv, rotmat, &facep->face_uvls[v], uvcenter);
|
||||
facep->face_uvls[v].u = tuv.u;
|
||||
facep->face_uvls[v].v = tuv.v;
|
||||
}
|
||||
}
|
||||
|
||||
void HTextureCreate2DRotMat(float *rotmat, angle ang)
|
||||
{
|
||||
float sinang, cosang;
|
||||
|
||||
sinang = FixSin(ang);
|
||||
cosang = FixCos(ang);
|
||||
|
||||
rotmat[0] = cosang;
|
||||
rotmat[1] = sinang;
|
||||
rotmat[2] = -sinang;
|
||||
rotmat[3] = cosang;
|
||||
}
|
||||
|
||||
void HTextureRotUVTerrainPoint(g3UVL *uvrot, float *rotmat, g3UVL *uv, g3UVL *uvcenter)
|
||||
{
|
||||
uvrot->u = ((uv->u - uvcenter->u)*rotmat[0]) + ((uv->v - uvcenter->v)*rotmat[1]) + uvcenter->u;
|
||||
uvrot->v = ((uv->u - uvcenter->u)*rotmat[2]) + ((uv->v - uvcenter->v)*rotmat[3]) + uvcenter->v;
|
||||
}
|
||||
|
||||
|
||||
// returns the index in the face_verts array for the leftmost point on this face
|
||||
int HTextureGetLeftVertexForFace (int roomnum,int facenum)
|
||||
{
|
||||
matrix face_matrix,trans_matrix;
|
||||
vector fvec;
|
||||
vector avg_vert;
|
||||
vector verts[MAX_VERTS_PER_FACE];
|
||||
|
||||
ASSERT (Rooms[roomnum].used);
|
||||
ASSERT (Rooms[roomnum].faces[facenum].num_verts>=3);
|
||||
|
||||
// find the center point of this face
|
||||
vm_MakeZero (&avg_vert);
|
||||
for (int i=0;i<Rooms[roomnum].faces[facenum].num_verts;i++)
|
||||
avg_vert+=Rooms[roomnum].verts[Rooms[roomnum].faces[facenum].face_verts[i]];
|
||||
|
||||
avg_vert/=i;
|
||||
|
||||
// Make the orientation matrix
|
||||
fvec=Rooms[roomnum].faces[facenum].normal;
|
||||
|
||||
vm_VectorToMatrix(&face_matrix,&fvec,NULL,NULL);
|
||||
// Make the transformation matrix
|
||||
|
||||
angvec avec;
|
||||
vm_ExtractAnglesFromMatrix(&avec,&face_matrix);
|
||||
vm_AnglesToMatrix (&trans_matrix,avec.p,avec.h,avec.b);
|
||||
|
||||
// Rotate all the points
|
||||
for (i=0;i<Rooms[roomnum].faces[facenum].num_verts;i++)
|
||||
{
|
||||
vector vert=Rooms[roomnum].verts[Rooms[roomnum].faces[facenum].face_verts[i]];
|
||||
vector rot_vert;
|
||||
|
||||
vert-=avg_vert;
|
||||
vm_MatrixMulVector (&rot_vert,&vert,&trans_matrix);
|
||||
|
||||
verts[i]=rot_vert;
|
||||
}
|
||||
|
||||
// Find left most point
|
||||
int leftmost_point=-1;
|
||||
float leftmost_x=900000.00f; // a big number
|
||||
|
||||
for (i=0;i<Rooms[roomnum].faces[facenum].num_verts;i++)
|
||||
{
|
||||
if (verts[i].x<leftmost_x)
|
||||
{
|
||||
leftmost_point=i;
|
||||
leftmost_x=verts[i].x;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
ASSERT (leftmost_point!=-1);
|
||||
return leftmost_point;
|
||||
|
||||
}
|
||||
|
||||
// returns the index in the face_verts array for the topmost point on this face
|
||||
int HTextureGetTopVertexForFace (int roomnum,int facenum)
|
||||
{
|
||||
matrix face_matrix,trans_matrix;
|
||||
vector fvec;
|
||||
vector avg_vert;
|
||||
vector verts[MAX_VERTS_PER_FACE];
|
||||
|
||||
ASSERT (Rooms[roomnum].used);
|
||||
ASSERT (Rooms[roomnum].faces[facenum].num_verts>=3);
|
||||
|
||||
// find the center point of this face
|
||||
vm_MakeZero (&avg_vert);
|
||||
for (int i=0;i<Rooms[roomnum].faces[facenum].num_verts;i++)
|
||||
avg_vert+=Rooms[roomnum].verts[Rooms[roomnum].faces[facenum].face_verts[i]];
|
||||
|
||||
avg_vert/=i;
|
||||
|
||||
// Make the orientation matrix
|
||||
fvec=Rooms[roomnum].faces[facenum].normal;
|
||||
|
||||
vm_VectorToMatrix(&face_matrix,&fvec,NULL,NULL);
|
||||
// Make the transformation matrix
|
||||
|
||||
angvec avec;
|
||||
vm_ExtractAnglesFromMatrix(&avec,&face_matrix);
|
||||
vm_AnglesToMatrix (&trans_matrix,avec.p,avec.h,avec.b);
|
||||
|
||||
// Rotate all the points
|
||||
for (i=0;i<Rooms[roomnum].faces[facenum].num_verts;i++)
|
||||
{
|
||||
vector vert=Rooms[roomnum].verts[Rooms[roomnum].faces[facenum].face_verts[i]];
|
||||
vector rot_vert;
|
||||
|
||||
vert-=avg_vert;
|
||||
vm_MatrixMulVector (&rot_vert,&vert,&trans_matrix);
|
||||
|
||||
verts[i]=rot_vert;
|
||||
}
|
||||
|
||||
// Find top most point
|
||||
int topmost_point=-1;
|
||||
float topmost_y=-900000.0f; // a big number
|
||||
|
||||
for (i=0;i<Rooms[roomnum].faces[facenum].num_verts;i++)
|
||||
{
|
||||
if (verts[i].y>topmost_y)
|
||||
{
|
||||
topmost_point=i;
|
||||
topmost_y=verts[i].y;
|
||||
}
|
||||
}
|
||||
|
||||
ASSERT (topmost_point!=-1);
|
||||
|
||||
return topmost_point;
|
||||
|
||||
}
|
||||
|
||||
// returns the index in the face_verts array for the rightmost point on this face
|
||||
int HTextureGetRightVertexForFace (int roomnum,int facenum)
|
||||
{
|
||||
matrix face_matrix,trans_matrix;
|
||||
vector fvec;
|
||||
vector avg_vert;
|
||||
vector verts[MAX_VERTS_PER_FACE];
|
||||
|
||||
ASSERT (Rooms[roomnum].used);
|
||||
ASSERT (Rooms[roomnum].faces[facenum].num_verts>=3);
|
||||
|
||||
// find the center point of this face
|
||||
vm_MakeZero (&avg_vert);
|
||||
for (int i=0;i<Rooms[roomnum].faces[facenum].num_verts;i++)
|
||||
avg_vert+=Rooms[roomnum].verts[Rooms[roomnum].faces[facenum].face_verts[i]];
|
||||
|
||||
avg_vert/=i;
|
||||
|
||||
// Make the orientation matrix
|
||||
fvec=Rooms[roomnum].faces[facenum].normal;
|
||||
|
||||
vm_VectorToMatrix(&face_matrix,&fvec,NULL,NULL);
|
||||
// Make the transformation matrix
|
||||
|
||||
angvec avec;
|
||||
vm_ExtractAnglesFromMatrix(&avec,&face_matrix);
|
||||
vm_AnglesToMatrix (&trans_matrix,avec.p,avec.h,avec.b);
|
||||
|
||||
// Rotate all the points
|
||||
for (i=0;i<Rooms[roomnum].faces[facenum].num_verts;i++)
|
||||
{
|
||||
vector vert=Rooms[roomnum].verts[Rooms[roomnum].faces[facenum].face_verts[i]];
|
||||
vector rot_vert;
|
||||
|
||||
vert-=avg_vert;
|
||||
vm_MatrixMulVector (&rot_vert,&vert,&trans_matrix);
|
||||
|
||||
verts[i]=rot_vert;
|
||||
}
|
||||
|
||||
// Find right most point
|
||||
int rightmost_point=-1;
|
||||
float rightmost_x=-900000.00f; // a big number
|
||||
|
||||
for (i=0;i<Rooms[roomnum].faces[facenum].num_verts;i++)
|
||||
{
|
||||
if (verts[i].x>rightmost_x)
|
||||
{
|
||||
rightmost_point=i;
|
||||
rightmost_x=verts[i].x;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
ASSERT (rightmost_point!=-1);
|
||||
return rightmost_point;
|
||||
|
||||
}
|
||||
|
||||
// returns the index in the face_verts array for the most point on this face
|
||||
int HTextureGetBottomVertexForFace (int roomnum,int facenum)
|
||||
{
|
||||
matrix face_matrix,trans_matrix;
|
||||
vector fvec;
|
||||
vector avg_vert;
|
||||
vector verts[MAX_VERTS_PER_FACE];
|
||||
|
||||
ASSERT (Rooms[roomnum].used);
|
||||
ASSERT (Rooms[roomnum].faces[facenum].num_verts>=3);
|
||||
|
||||
// find the center point of this face
|
||||
vm_MakeZero (&avg_vert);
|
||||
for (int i=0;i<Rooms[roomnum].faces[facenum].num_verts;i++)
|
||||
avg_vert+=Rooms[roomnum].verts[Rooms[roomnum].faces[facenum].face_verts[i]];
|
||||
|
||||
avg_vert/=i;
|
||||
|
||||
// Make the orientation matrix
|
||||
fvec=Rooms[roomnum].faces[facenum].normal;
|
||||
|
||||
vm_VectorToMatrix(&face_matrix,&fvec,NULL,NULL);
|
||||
// Make the transformation matrix
|
||||
|
||||
angvec avec;
|
||||
vm_ExtractAnglesFromMatrix(&avec,&face_matrix);
|
||||
vm_AnglesToMatrix (&trans_matrix,avec.p,avec.h,avec.b);
|
||||
|
||||
// Rotate all the points
|
||||
for (i=0;i<Rooms[roomnum].faces[facenum].num_verts;i++)
|
||||
{
|
||||
vector vert=Rooms[roomnum].verts[Rooms[roomnum].faces[facenum].face_verts[i]];
|
||||
vector rot_vert;
|
||||
|
||||
vert-=avg_vert;
|
||||
vm_MatrixMulVector (&rot_vert,&vert,&trans_matrix);
|
||||
|
||||
verts[i]=rot_vert;
|
||||
}
|
||||
|
||||
// Find bottom most point
|
||||
int bottommost_point=-1;
|
||||
float bottommost_y=900000.0f; // a big number
|
||||
|
||||
for (i=0;i<Rooms[roomnum].faces[facenum].num_verts;i++)
|
||||
{
|
||||
if (verts[i].y<bottommost_y)
|
||||
{
|
||||
bottommost_point=i;
|
||||
bottommost_y=verts[i].y;
|
||||
}
|
||||
}
|
||||
|
||||
ASSERT (bottommost_point!=-1);
|
||||
|
||||
return bottommost_point;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*void HTextureGetBoxUVLForFace (room *rp,facenum)
|
||||
{
|
||||
int l,r,t,b;
|
||||
vector lpoint,rpoint,tpoint,bpoint;
|
||||
g3UVL luvl,ruvl,tuvl,buvl,xchange,ychange;
|
||||
|
||||
b=HTextureGetBottomVertexForFace (roomnum,facenum);
|
||||
t=HTextureGetTopVertexForFace (roomnum,facenum);
|
||||
l=HTextureGetLeftVertexForFace (roomnum,facenum);
|
||||
r=HTextureGetRightVertexForFace (roomnum,facenum);
|
||||
|
||||
lpoint=rp->verts[rp->faces[facenum].face_verts[l]];
|
||||
rpoint=rp->verts[rp->faces[facenum].face_verts[r]];
|
||||
tpoint=rp->verts[rp->faces[facenum].face_verts[t]];
|
||||
bpoint=rp->verts[rp->faces[facenum].face_verts[b]];
|
||||
|
||||
luvl=rp->faces[facenum].face_uvls[l];
|
||||
ruvl=rp->faces[facenum].face_uvls[r];
|
||||
tuvl=rp->faces[facenum].face_uvls[t];
|
||||
buvl=rp->faces[facenum].face_uvls[b];
|
||||
|
||||
xchange.u=ruvl.u-luvl.u;
|
||||
xchange.v=ruvl.v-luvl.v;
|
||||
|
||||
ychange=buvl.u-tuvl.u;
|
||||
ychange=buvl.v-tuvl.v;
|
||||
|
||||
}*/
|
||||
|
||||
|
||||
Reference in New Issue
Block a user