Descent3/legacy/editor/RoomUVs.cpp

/*
* 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/RoomUVs.cpp $
 * $Revision: 1.1.1.1 $
 * $Date: 2003-08-26 03:57:38 $
 * $Author: kevinb $
 *
 * Code to deal with texturing rooms
 *
 * $Log: not supported by cvs2svn $
 * 
 * 9     9/30/99 6:35p Matt
 * Added code to scale the UVs of a texture based on the size of the
 * texture when the texture is applied to a face.  This will cause the
 * applied texture to have the make 3D texel size at the old texture.
 * 
 * 8     4/25/99 2:38p Gwar
 * brought in HRoom.cpp and RoomUVs.cpp, and several misc game functions
 * were added to globals.cpp to make it possible
 * 
 * 7     10/21/98 1:27p Jason
 * fixed texture u2,v2 sliding problems
 * 
 * 6     10/07/98 3:19p Matt
 * Cleaned up and fixed Mike's old texture UV calculation code.  Who ever
 * told that boy  he could do 3D?
 * 
 * 5     4/02/98 12:23p Jason
 * trimmed some fat from our structures
 * 
 * 4     12/23/97 1:33p Samir
 * Added pserror.h
 * 
 * 3     9/17/97 11:57a Matt
 * Ripped out segment code
 * 
 * 2     7/18/97 7:38p Jason
 * finished room/terrain texture modifications
 *
 * $NoKeywords: $
 */

#include "RoomUVs.h"

#ifndef NEWEDITOR
#include "d3edit.h"
#else
#include "..\neweditor\globals.h"
#endif

#include "pserror.h"

//returns the magnatude of the 2d vector <a,b>
static float zhypot(float a,float b)
{
	return sqrt(a*a + b*b);
}

//	Given u,v coordinates at two vertices, assign u,v coordinates to the other vertices on a face.
//	va, vb = face-relative vertex indices corresponding to uva, uvb.  Ie, they are always in 0..num_verts_in_face
void AssignUVsToFace(room *rp, int facenum, roomUVL *uva, roomUVL *uvb, int va, int vb)
{
	face		*fp = &rp->faces[facenum];
	int		nv = fp->num_verts;
	int		vlo,vhi;
	vector	fvec,rvec,tvec;
	roomUVL	ruvmag,fuvmag,uvlo,uvhi;
	float		fmag,mag01;
	int		i;
	
	float saveu2[MAX_VERTS_PER_FACE],savev2[MAX_VERTS_PER_FACE];
	for (i=0;i<fp->num_verts;i++)
	{
		saveu2[i]=fp->face_uvls[i].u2;
		savev2[i]=fp->face_uvls[i].v2;
	}

	ASSERT( (va<nv) && (vb<nv) );
	ASSERT((abs(va - vb) == 1) || (abs(va - vb) == nv-1));		// make sure the verticies specify an edge

	// We want vlo precedes vhi, ie vlo < vhi, or vlo = num_verts, vhi = 0
	if (va == ((vb + 1) % nv)) {		// va = vb + 1
		vlo = vb;
		vhi = va;
		uvlo = *uvb;
		uvhi = *uva;
	} else {
		vlo = va;
		vhi = vb;
		uvlo = *uva;
		uvhi = *uvb;
	}

	ASSERT(((vlo+1) % nv) == vhi);	// If we are on an edge, then uvhi is one more than uvlo (mod num_verts)
	fp->face_uvls[vlo] = uvlo;
	fp->face_uvls[vhi] = uvhi;

	// Now we have vlo precedes vhi, compute vertices ((vhi+1) % nv) and ((vhi+2) % nv)

	// Assign u,v scale to a unit length right vector.
	fmag = zhypot(uvhi.v - uvlo.v,uvhi.u - uvlo.u);
	if (fmag < 0.001) {
		//mprintf((0,"Warning: fmag = %7.3f, using approximate u,v values\n",f2fl(fmag)));
		ruvmag.u = 256.0;
		ruvmag.v = 256.0;
		fuvmag.u = 256.0;
		fuvmag.v = 256.0;
	} else {
		ruvmag.u = uvhi.v - uvlo.v;
		ruvmag.v = uvlo.u - uvhi.u;

		fuvmag.u = uvhi.u - uvlo.u;
		fuvmag.v = uvhi.v - uvlo.v;
	}

	//Get pointers to our verts
	vector *vv0 = &rp->verts[fp->face_verts[vlo]],
			 *vv1 = &rp->verts[fp->face_verts[vhi]];

	//Get forward vector from our edge
	fvec = *vv1 - *vv0;
	mag01 = vm_NormalizeVector(&fvec);

	//Check for bad vector
	if (mag01 < 0.001 ) {
		OutrageMessageBox("U, V bogosity in room #%i, probably on face #%i.  CLEAN UP YOUR MESS!", ROOMNUM(rp), facenum);
		return;
	}

	//Get right vector from the cross product of the forward vec with the surface normal
	rvec = fvec ^ fp->normal;

	//Normalize uv values
	ruvmag.u /= mag01;
	ruvmag.v /= mag01;
	fuvmag.u /= mag01;
	fuvmag.v /= mag01;

	//Compute UVs for each point
	for (i=1;i<nv-1;i++) {
  		int fv = (vhi+i)%nv;					//vert index in face
  		int rv = fp->face_verts[fv];		//vert index in room

		//Get the vector for this edge
  		tvec = rp->verts[rv] - *vv0;

		//Project the current edge onto our forward & right vectors
		float rproj = tvec * rvec,
				fproj = tvec * fvec;

		//Compute and assign UV values
  		fp->face_uvls[fv].u = uvlo.u + (ruvmag.u * rproj) + (fuvmag.u * fproj);
  		fp->face_uvls[fv].v = uvlo.v + (ruvmag.v * rproj) + (fuvmag.v * fproj);
  	}

}

// Stretches the UVS of a face 
void StretchRoomUVs(room *rp, int facenum, int edge)
{
	roomUVL	uv0,uv1;
	int		v0, v1;
	face *fp=&rp->faces[facenum];

	int i;
	float saveu2[MAX_VERTS_PER_FACE],savev2[MAX_VERTS_PER_FACE];
	for (i=0;i<fp->num_verts;i++)
	{
		saveu2[i]=fp->face_uvls[i].u2;
		savev2[i]=fp->face_uvls[i].v2;
	}

	v0 = edge;
	v1 = (v0 + 1) % rp->faces[facenum].num_verts;

	uv0 = rp->faces[facenum].face_uvls[v0];		//copy uv AND l
	uv1 = rp->faces[facenum].face_uvls[v1];

	AssignUVsToFace(rp, facenum, &uv0, &uv1, v0, v1);

	for (i=0;i<fp->num_verts;i++)
	{
		fp->face_uvls[i].u2=saveu2[i];
		fp->face_uvls[i].v2=savev2[i];
	}

}

//Scale all the UV values in a face from the center point (as defined by averaging the u & v values)
void ScaleFaceUVs(room *rp,int facenum,float scale)
{
	face *fp=&rp->faces[facenum];

	int i;
	float midu=0,midv=0;

	for (i=0;i<fp->num_verts;i++) {
		midu += fp->face_uvls[i].u;
		midv += fp->face_uvls[i].v;
	}

	midu /= fp->num_verts;
	midv /= fp->num_verts;

	for (i=0;i<fp->num_verts;i++)
	{
		fp->face_uvls[i].u = midu + (fp->face_uvls[i].u - midu) * scale;
		fp->face_uvls[i].v = midv + (fp->face_uvls[i].v - midv) * scale;
	}

	World_changed=1;
}