KevinLeap

Thanks LepreKhaun, I was unsure myself about where to put this entry when I started. But I thought that the most technical part would be the scripting so I chose here. It wasn't clear to me if the building and texturing forum would have people who understood the complexity of the script to accomplish this. I'll look into the buildersbrewery to see what I can find. Thanks again for the help

Thanks, I'll investigate your suggestions. Making things simpler and more obvious is my goal so I can then move on to making my enhancements.. I appreciate the support here.

Thanks for the additional info. You were probably not far wrong when it comes to my expertise and experience, however I have been a life long software developer and this language seems to be a close match to Java and JavaScript with some very interesting additions so with false confidence, I thought I should be able to just open up the code and fix it. However I am brand new to SL scripting and even newer at understanding the environment and data structures that SL uses and this code seems to be much more complex than I had imagined. I came on this problem when I was trying to build a simple wall with a door and found that making the textures align was more difficult than I anticipated. I bought some scripts to help with alignment (you put the scripts into the contents of the prims and link them together and then typically type "/1 align" to cause the script to make the texture align with the primary prim). I found that the alignment was not being performed reliably and searched for a solution. I found this open source code that looks like it should do what I want, but I find it doesn't seem to adjust the offsets for the textures so that they all line up. I decided that I should be able to understand the code and figure out what was needed to accomplish this. When I opened up the code, I found it to be amazingly complex for what sounds like a simple task. Full of face selection, scaling, cut calculations and rotation translations. Obviously this is open source so whatever additions I put into it will also carry the original copyright info. I am looking for a reference document that might describe how textures are stored, and how the rotations fit into the scheme. Once I have that, I can either adjust OpenAlign or write my own alignment script. Thank you //// OpenAlign 1.1// Second Life Texture Alignment Script// Copyright 2008 Edward L. Platt// SL: Phil Tracy// E-mail: <elplatt@alum.mit.edu>//// 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/>.////////////////////////////////////////////////////////////////////////// //// GLOBAL VARIABLES //// // Script name in inventorystring SCRIPT_NAME = "OpenAlign"; // Channel to listen oninteger LISTEN_CHANNEL = 1; // 1 for debug mode, 0 otherwiseinteger DEBUG = 0; // Properties of rootvector rootSize; // Sizevector rootPos; // Positioninteger rootFaceCount; // Number of faceslist rootTexScaleList; // Texture scales (width0,height0,width1...)vector rootCut; // Cut //// GLOBAL FUNCTIONS //// // Joins string elements from a list with spaces// Calculate the modulus of a / bfloat mod(float a, float b) { return a/b - llFloor(a/b);} // Broadcast a message on LISTEN_CHANNELbroadcast(string message) { if (DEBUG) { llSay(0, message); } llSay(LISTEN_CHANNEL, message);} // Get the position, width, and height of the cut faceslist getCutParams(float cutBegin, float cutEnd, rotation q) { integer beginQuad; // Quadrant cut begins in integer endQuad; // Quadrant cut ends in vector size; // Size of this object vector pos; // Position of this object vector beginPos; // Begin face position vector endPos; // End face position vector beginSize; // Size of begin face vector endSize; // Size of end face float angle; // Angle of the face (radians) // Get size size = llList2Vector(llGetPrimitiveParams([PRIM_SIZE]),0); // Calculate beginning face parameters angle = cutBegin * TWO_PI - PI*3.0/4.0; float x; float y; // Calculate the dimensions of the beginning face without scaling if (cutBegin < 0.25) { y = -0.5; x = y / llTan(angle); } else if (cutBegin >= 0.5 && cutBegin < 0.75) { y = 0.5; x = y / llTan(angle); } else if (cutBegin >= 0.25 && cutBegin < 0.5) { x = 0.5; y = x * llTan(angle); } else { x = -0.5; y = x * llTan(angle); } // Calculate the width of the beginning face with scaling beginSize.x = llSqrt(size.x*size.x * x*x + size.y*size.y * y*y); // Set the height of the beginning face beginSize.y = size.z; // Calculate beginning face position beginPos = <x*size.x/2.0, y*size.y/2.0, 0>; beginPos = beginPos * q; // Calculate end face parameters angle = cutEnd * TWO_PI - PI*3.0/4.0; // Calculate the dimensions of the end face without scaling if (cutEnd < 0.25) { y = -0.5; x = y / llTan(angle); } else if (cutEnd >= 0.5 && cutEnd < 0.75) { y = 0.5; x = y / llTan(angle); } else if (cutEnd >= 0.25 && cutEnd < 0.5) { x = 0.5; y = x * llTan(angle); } else { x = -0.5; y = x * llTan(angle); } // Calculate the width of the end face with scaling endSize.x = llSqrt(size.x*size.x * x*x + size.y*size.y * y*y); // Set the height of the end face endSize.y = size.z; // Calculate beginning face position endPos = <x*size.x/2.0, y*size.y/2.0, 0>; endPos = endPos * q; return [beginPos, beginSize, endPos, endSize];} // Get face list from rotationlist getFaceList(rotation q) { vector rot; // Rotation in Euler coordinates list faces; // Indices of faces list newFaces; // Temporary indices of faces integer zRot; // Number of 90 degree Z rotations integer yRot; // Number of 90 degree Y rotations integer xRot; // Number of 90 degree X rotations // Get Euler coordinates rot = llRot2Euler(q); // Initialize faces faces = [0, 1, 2, 3, 4, 5]; // Permute faces according to rotations in Z, Y, X order // Adjust ranges zRot = (integer)llRound(rot.z / PI_BY_TWO); yRot = (integer)llRound(rot.y / PI_BY_TWO); xRot = (integer)llRound(rot.x / PI_BY_TWO); while (zRot < 0) { zRot += 4; } while (yRot < 0) { yRot += 4; } while (xRot < 0) { xRot += 4; } // Permute faces for Z rotation while (zRot > 0) { newFaces = []; newFaces += llList2Integer(faces, 0); newFaces += llList2Integer(faces, 4); newFaces += llList2Integer(faces, 1); newFaces += llList2Integer(faces, 2); newFaces += llList2Integer(faces, 3); newFaces += llList2Integer(faces, 5); faces = newFaces; zRot--; } // Permute faces for Y rotation while (yRot > 0) { newFaces = []; newFaces += llList2Integer(faces, 4); newFaces += llList2Integer(faces, 1); newFaces += llList2Integer(faces, 0); newFaces += llList2Integer(faces, 3); newFaces += llList2Integer(faces, 5); newFaces += llList2Integer(faces, 2); faces = newFaces; yRot--; } // Permute faces for X rotation while (xRot > 0) { newFaces = []; newFaces += llList2Integer(faces, 3); newFaces += llList2Integer(faces, 0); newFaces += llList2Integer(faces, 2); newFaces += llList2Integer(faces, 5); newFaces += llList2Integer(faces, 4); newFaces += llList2Integer(faces, 1); faces = newFaces; xRot--; } return faces;} // Return the object face index of the specified global face// Faces are specified as "+x", "-y", "cutBegin", "cutEnd", etc.integer getFace(string face, vector cut, rotation q) { // Variables representing whether a face is present // 1 is present, 0 is not, except for zp=0 which is always present integer xp = 1; // +x integer xm = 1; // -x integer yp = 1; // +y integer ym = 1; // -y integer zp = 0; // +z integer zm = 1; // -z integer cb = 1; // cut begin integer ce = 1; // cut end list faces; // List mapping global faces to object faces string mappedFace; // Local face, after global face rotated list faceOrder; // The order of the faces // Set face order faceOrder = ["+z", "-y", "+x", "+y", "-x", "-z", "cutBegin", "cutEnd"]; // Get face mapping faces = getFaceList(q); // Map face if (face == "+z") { mappedFace = llList2String(faceOrder, llList2Integer(faces, 0)); } else if (face == "-y") { mappedFace = llList2String(faceOrder, llList2Integer(faces, 1)); } else if (face == "+x") { mappedFace = llList2String(faceOrder, llList2Integer(faces, 2)); } else if (face == "+y") { mappedFace = llList2String(faceOrder, llList2Integer(faces, 3)); } else if (face == "-x") { mappedFace = llList2String(faceOrder, llList2Integer(faces, 4)); } else if (face == "-z") { mappedFace = llList2String(faceOrder, llList2Integer(faces, 5)); } else { mappedFace = face; } // Determine which faces have been cut away if (cut.x >= 0.25) { ym = 0; } if (cut.x >= 0.5 || cut.y <= 0.25) { xp = 0; } if (cut.x >= 0.75 || cut.y <= 0.5) { yp = 0; } if (cut.y <= 0.75) { xm = 0; } if (cut.x == 0 && cut.y == 1) { cb = 0; ce = 0; } // Return face index, -1 if cut away if (mappedFace == "+x") { if (xp == 0) { return -1; } return zp+ym+xp; } else if (mappedFace == "-x") { if (xm == 0) { return -1; } return zp+ym+xp+yp+xm; } else if (mappedFace == "+y") { if (yp == 0) { return -1; } return zp+ym+xp+yp; } else if (mappedFace == "-y") { if (yp == 0) { return -1; } return zp+ym; } else if (mappedFace == "+z") { return zp; } else if (mappedFace == "-z") { return zp+ym+xp+yp+xm+zm; } else if (mappedFace == "cutBegin") { if (cb == 0) { return -1; } return zp+ym+xp+yp+xm+zm+cb; } else if (mappedFace == "cutEnd") { if (ce == 0) { return -1; } return zp+ym+xp+yp+xm+zm+cb+ce; } // This should never happen return -1;} // Get local size from global size and rotationvector getSize(vector size, rotation q) { list faceList; // Mapping from global to local faces vector newSize; // Size of <x, y, z> local dimensions integer face; // Temporary face index // Get face mapping faceList = getFaceList(q); // Get local face for global x dimension face = llList2Integer(faceList, 2); if (face == 2 || face == 4) { newSize.x = size.x; } if (face == 1 || face == 3) { newSize.x = size.y; } if (face == 0 || face == 5) { newSize.x = size.z; } // Get local face for global y dimension face = llList2Integer(faceList, 3); if (face == 2 || face == 4) { newSize.y = size.x; } if (face == 1 || face == 3) { newSize.y = size.y; } if (face == 0 || face == 5) { newSize.y = size.z; } // Get local face for global y dimension face = llList2Integer(faceList, 0); if (face == 2 || face == 4) { newSize.z = size.x; } if (face == 1 || face == 3) { newSize.z = size.y; } if (face == 0 || face == 5) { newSize.z = size.z; } return newSize;} // Initiates the entire alignment processalign() { if (llGetLinkNumber() == 1) { // This is the root object, tell the other objects // about our position and texture scaling integer faceCount; // Number of faces vector texScale; // Texture scaling list texScaleList; // List of texture scales for each face list params; // Primitive params vector cut; // Cut // Get object parameters cut = llList2Vector(llGetPrimitiveParams([PRIM_TYPE]),2); faceCount = llGetNumberOfSides(); // Broadcast root parameters broadcast("faceCount " + (string)faceCount); integer i; for (i = 0; i < faceCount; i++) { texScale = llGetTextureScale(i); broadcast("texScale " + (string)texScale.x + " " + (string)texScale.y); } broadcast("size " + llList2String(llGetPrimitiveParams([PRIM_SIZE]),0)); broadcast("cut " + (string)cut); // Tell children to finish alignment broadcast("finish"); } else { // Child object, reset root parameters rootFaceCount = 0; rootTexScaleList = []; }} // Finish alignment by changing this object's propertiesfinish() { vector size; // Size vector globalSize; // Size in global coordiantes vector pos; // Position rotation rot; // Rotation vector posOffset; // Offset between this object and root object float rootTexScaleW; // Texture scale of root object (width) float rootTexScaleH; // Texture scale of root object (height) vector cut; // Cut begin and end (in x and y) list cutParams; // Cut parameters list rootCutParams; // Root cut params rotation rootRot; // Root rotation vector rootGlobalSize; // Root size in global coordinates vector cutBeginPos; // Cut begin face position vector cutBeginSize; // Cut begin face size (<width, height, 0>) vector cutEndPos; // Cut end face position vector cutEndSize; // Cut end face size (<width, height, 0>) vector rootCutBeginPos; // Root cut begin face position vector rootCutBeginSize; // Root cut begin face size (<width, height, 0>) vector rootCutEndPos; // Root cut end face position vector rootCutEndSize; // Root cut end face size (<width, height, 0>) integer face; // Current face index integer rootFace; // Current root face index float widthOff; // Texture W offset float heightOff; // Texture H offset float tileSize; float texScaleW; float texScaleH; vector beginNormal; // Beginning cut face normal vector endNormal; // End cut face normal vector rootBeginNormal; // Beginning cut face normal for root object vector rootEndNormal; // End cut face normal for root object vector cutOffset; // Offset between two cut faces vector cutPlaneOffset; // Offset in plane of face // Exit if we are the root object if (llGetLinkNumber() == 1) { return; } // Get this object's properties posOffset = llGetLocalPos(); pos = llGetPos(); size = llList2Vector(llGetPrimitiveParams([PRIM_SIZE]),0); cut = llList2Vector(llGetPrimitiveParams([PRIM_TYPE]),2); rot = llGetRot(); globalSize = getSize(size, rot); rootPos = llGetRootPosition(); rootRot = llGetRootRotation(); rootGlobalSize = getSize(rootSize, rootRot); // Calculate this object's cut parameters cutParams = getCutParams(cut.x, cut.y, rot); cutBeginPos = pos + llList2Vector(cutParams,0); cutBeginSize = llList2Vector(cutParams,1); cutEndPos = pos + llList2Vector(cutParams,2); cutEndSize = llList2Vector(cutParams,3); // Calculate root cut parameters rootCutParams = getCutParams(rootCut.x, rootCut.y, rootRot); rootCutBeginPos = rootPos + llList2Vector(rootCutParams,0); rootCutBeginSize = llList2Vector(rootCutParams,1); rootCutEndPos = rootPos + llList2Vector(rootCutParams,2); rootCutEndSize = llList2Vector(rootCutParams,3); // Calculate normals using cross product (%) beginNormal = llVecNorm((cutBeginPos - pos) % <0,0,cutBeginSize.y>/2.0); endNormal = llVecNorm((cutEndPos - pos) % <0,0,-cutEndSize.y/2.0>); rootBeginNormal = llVecNorm((rootCutBeginPos - rootPos) % <0,0,rootCutBeginSize.y>/2.0); rootEndNormal = llVecNorm((rootCutEndPos - rootPos) % <0,0,-rootCutEndSize.y>/2.0); // Align -X axis faces face = getFace("-x", cut, rot); rootFace = getFace("-x", rootCut, rootRot); if (face != -1 && rootFace != -1) { rootTexScaleW = llList2Float(rootTexScaleList, rootFace*2); rootTexScaleH = llList2Float(rootTexScaleList, rootFace*2+1); tileSize = rootGlobalSize.y / rootTexScaleW; texScaleW = rootTexScaleW * globalSize.y / rootGlobalSize.y; widthOff = mod(-posOffset.y, tileSize); tileSize = rootGlobalSize.z / rootTexScaleH; texScaleH = rootTexScaleH * globalSize.z / rootGlobalSize.z; heightOff = mod(posOffset.z, tileSize); llOffsetTexture(widthOff, heightOff, face); llScaleTexture(texScaleW, texScaleH, face); } // Align +X axis faces face = getFace("+x", cut, rot); rootFace = getFace("+x", rootCut, rootRot); if (face != -1 && rootFace != -1) { rootTexScaleW = llList2Float(rootTexScaleList, rootFace*2); rootTexScaleH = llList2Float(rootTexScaleList, rootFace*2+1); tileSize = rootGlobalSize.y / rootTexScaleW; texScaleW = rootTexScaleW * globalSize.y / rootGlobalSize.y; widthOff = mod(posOffset.y, tileSize); tileSize = rootGlobalSize.z / rootTexScaleH; texScaleH = rootTexScaleH * globalSize.z / rootGlobalSize.z; heightOff = mod(posOffset.z, tileSize); llOffsetTexture(widthOff, heightOff, face); llScaleTexture(texScaleW, texScaleH, face); } // Align -Y axis faces face = getFace("-y", cut, rot); rootFace = getFace("-y", rootCut, rootRot); if (face != -1 && rootFace != -1) { rootTexScaleW = llList2Float(rootTexScaleList, rootFace*2); rootTexScaleH = llList2Float(rootTexScaleList, rootFace*2+1); tileSize = rootGlobalSize.x / rootTexScaleW; texScaleW = rootTexScaleW * globalSize.x / rootGlobalSize.x; widthOff = mod(posOffset.x, tileSize); tileSize = rootGlobalSize.z / rootTexScaleH; texScaleH = rootTexScaleH * globalSize.z / rootGlobalSize.z; heightOff = mod(posOffset.z, tileSize); llOffsetTexture(widthOff, heightOff, face); llScaleTexture(texScaleW, texScaleH, face); } // Align +Y axis faces face = getFace("+y", cut, rot); rootFace = getFace("+y", rootCut, rootRot); if (face != -1 && rootFace != -1) { rootTexScaleW = llList2Float(rootTexScaleList, rootFace*2); rootTexScaleH = llList2Float(rootTexScaleList, rootFace*2+1); tileSize = rootGlobalSize.x / rootTexScaleW; texScaleW = rootTexScaleW * globalSize.x / rootGlobalSize.x; widthOff = mod(-posOffset.x, tileSize); tileSize = rootGlobalSize.z / rootTexScaleH; texScaleH = rootTexScaleH * globalSize.z / rootGlobalSize.z; heightOff = mod(posOffset.z, tileSize); llOffsetTexture(widthOff, heightOff, face); llScaleTexture(texScaleW, texScaleH, face); } // Align -Z axis faces face = getFace("-z", cut, rot); rootFace = getFace("-z", rootCut, rootRot); if (face != -1 && rootFace != -1) { rootTexScaleW = llList2Float(rootTexScaleList, rootFace*2); rootTexScaleH = llList2Float(rootTexScaleList, rootFace*2+1); tileSize = rootGlobalSize.x / rootTexScaleW; texScaleW = rootTexScaleW * globalSize.x / rootGlobalSize.x; widthOff = mod(posOffset.x, tileSize); tileSize = rootGlobalSize.y / rootTexScaleH; texScaleH = rootTexScaleH * globalSize.y / rootGlobalSize.y; heightOff = mod(-posOffset.y, tileSize); llOffsetTexture(widthOff, heightOff, face); llScaleTexture(texScaleW, texScaleH, face); } // Align +Z axis faces face = getFace("+z", cut, rot); rootFace = getFace("+z", rootCut, rootRot); if (face != -1 && rootFace != -1) { rootTexScaleW = llList2Float(rootTexScaleList, rootFace*2); rootTexScaleH = llList2Float(rootTexScaleList, rootFace*2+1); tileSize = rootGlobalSize.x / rootTexScaleW; texScaleW = rootTexScaleW * globalSize.x / rootGlobalSize.x; widthOff = mod(posOffset.x, tileSize); tileSize = rootGlobalSize.y / rootTexScaleH; texScaleH = rootTexScaleH * globalSize.y / rootGlobalSize.y; heightOff = mod(posOffset.y, tileSize); llOffsetTexture(widthOff, heightOff, face); llScaleTexture(texScaleW, texScaleH, face); } // Align cut beginning face = getFace("cutBegin", cut, rot); if (face != -1 && rootFace != -1) { // Compare to root cut begin face rootFace = getFace("cutBegin", rootCut, rootRot); cutOffset = cutBeginPos - rootCutBeginPos; if (rootFace != -1 && llFabs(beginNormal * rootBeginNormal) > 0.9999) { // Calculate W and H offset for face cutPlaneOffset.y = cutOffset.z; cutPlaneOffset.x = llVecMag(cutOffset - <0,0,cutOffset.z>); if (((cutOffset - <0,0,cutOffset.z>) % rootBeginNormal) * <0,0,1> > 0) { cutPlaneOffset.x = cutPlaneOffset.x * -1; } rootTexScaleW = llList2Float(rootTexScaleList, rootFace*2); rootTexScaleH = llList2Float(rootTexScaleList, rootFace*2+1); tileSize = rootCutBeginSize.x / rootTexScaleW; texScaleW = rootTexScaleW * cutBeginSize.x / rootCutBeginSize.x; widthOff = mod(cutPlaneOffset.x, tileSize); tileSize = rootCutBeginSize.y / rootTexScaleH; texScaleH = rootTexScaleH * cutBeginSize.y / rootCutBeginSize.y; heightOff = mod(cutPlaneOffset.y, tileSize); llOffsetTexture(widthOff, heightOff, face); llScaleTexture(texScaleW, texScaleH, face); } // Compare to root cut end face rootFace = getFace("cutEnd", rootCut, rootRot); cutOffset = cutBeginPos - rootCutEndPos; if (rootFace != -1 && llFabs(beginNormal * rootEndNormal) > 0.9999) { // Calculate W and H offset for face cutPlaneOffset.y = cutOffset.z; cutPlaneOffset.x = llVecMag(cutOffset - <0,0,cutOffset.z>); if (((cutOffset - <0,0,cutOffset.z>) % rootEndNormal) * <0,0,1> > 0) { cutPlaneOffset.x = cutPlaneOffset.x * -1; } rootTexScaleW = llList2Float(rootTexScaleList, rootFace*2); rootTexScaleH = llList2Float(rootTexScaleList, rootFace*2+1); tileSize = rootCutEndSize.x / rootTexScaleW; texScaleW = rootTexScaleW * cutBeginSize.x / rootCutEndSize.x; widthOff = mod(cutPlaneOffset.x, tileSize); tileSize = rootCutEndSize.y / rootTexScaleH; texScaleH = rootTexScaleH * cutBeginSize.y / rootCutEndSize.y; heightOff = mod(cutPlaneOffset.y, tileSize); llOffsetTexture(widthOff, heightOff, face); llScaleTexture(texScaleW, texScaleH, face); } } // Align cut end face = getFace("cutEnd", cut, rot); if (face != -1) { // Compare to root cut begin face rootFace = getFace("cutBegin", rootCut, rootRot); cutOffset = cutEndPos - rootCutBeginPos; if (rootFace != -1 && llFabs(endNormal * rootBeginNormal) > 0.9999) { // Calculate W and H offset for face cutPlaneOffset.y = cutOffset.z; cutPlaneOffset.x = llVecMag(cutOffset - <0,0,cutOffset.z>); if (((cutOffset - <0,0,cutOffset.z>) % rootBeginNormal) * <0,0,1> > 0) { cutPlaneOffset.x = cutPlaneOffset.x * -1; } rootTexScaleW = llList2Float(rootTexScaleList, rootFace*2); rootTexScaleH = llList2Float(rootTexScaleList, rootFace*2+1); tileSize = rootCutBeginSize.x / rootTexScaleW; texScaleW = rootTexScaleW * cutEndSize.x / rootCutBeginSize.x; widthOff = mod(cutPlaneOffset.x, tileSize); tileSize = rootCutBeginSize.y / rootTexScaleH; texScaleH = rootTexScaleH * cutEndSize.y / rootCutBeginSize.y; heightOff = mod(cutPlaneOffset.y, tileSize); llOffsetTexture(widthOff, heightOff, face); llScaleTexture(texScaleW, texScaleH, face); } // Compare to root cut end face rootFace = getFace("cutEnd", rootCut, rootRot); cutOffset = cutEndPos - rootCutEndPos; if (rootFace != -1 && llFabs(endNormal * rootEndNormal) > 0.9999) { // Calculate W and H offset for face cutPlaneOffset.y = cutOffset.z; cutPlaneOffset.x = llVecMag(cutOffset - <0,0,cutOffset.z>); if (((cutOffset - <0,0,cutOffset.z>) % rootEndNormal) * <0,0,1> > 0) { cutPlaneOffset.x = cutPlaneOffset.x * -1; } rootTexScaleW = llList2Float(rootTexScaleList, rootFace*2); rootTexScaleH = llList2Float(rootTexScaleList, rootFace*2+1); tileSize = rootCutEndSize.x / rootTexScaleW; texScaleW = rootTexScaleW * cutEndSize.x / rootCutEndSize.x; widthOff = mod(cutPlaneOffset.x, tileSize); tileSize = rootCutEndSize.y / rootTexScaleH; texScaleH = rootTexScaleH * cutEndSize.y / rootCutEndSize.y; heightOff = mod(cutPlaneOffset.y, tileSize); llOffsetTexture(widthOff, heightOff, face); llScaleTexture(texScaleW, texScaleH, face); } }} // Remove the script from this objectremove() { llSay(0, "Removing OpenAlign script by Phil Tracy"); llRemoveInventory(SCRIPT_NAME);} //// DEFAULT STATE SCRIPT ////default{ // Initialize state state_entry() { // Set up a listener on LISTEN_CHANNEL llListen(LISTEN_CHANNEL,"",NULL_KEY,""); } // Called when there is a message on LISTEN_CHANNEL listen(integer channel, string name, key id, string message) { // Make sure we're on the right channel if (channel != LISTEN_CHANNEL) { return; } // Split message into the first word and the rest integer space = llSubStringIndex(message, " "); string cmd; string rest; if (space != -1) { cmd = llGetSubString(message, 0, space - 1); rest = llGetSubString(message, space + 1, -1); } else { cmd = message; } // Read and execute commands for children if (llGetLinkNumber() != 1) { if (cmd == "texScale") { space = llSubStringIndex(rest, " "); rootTexScaleList += (float)llGetSubString(rest, 0, space - 1); rootTexScaleList += (float)llGetSubString(rest, space + 1, -1); } else if (cmd == "align") { align(); } else if (cmd == "faceCount") { rootFaceCount = (integer)rest; } else if (cmd == "size") { rootSize = (vector)rest; } else if (cmd == "finish") { finish(); } else if (cmd == "cut") { rootCut = (vector)rest; } } // All objects handle these commands if (cmd == "align") { align(); } else if (cmd == "remove") { remove(); } }}

Thanks, for the info, but I'm talking about how to understand the programatic aspect of doing this... The script I am reading talks about Euler coordinates and converting from global rotations to local rotations. I want to find a reference that describes how this information is kept so that I have half a chance to understand the script I am working with. The OpenAlign script tries to make secondary prims match the texture mapping of the primary prim. It seems to do this ok, but does not adjust the offsets on the textures correctly to match the horizonatl or vertical distance of the prim from the primary. Reading the script, it seems to do some things as though by magic making it very difficult to understand where I can make adjustments to the code to add in the behavior I want. Some reference documentation on how the prim faces are stored might enable me to understand this better. I may be asking a question that is so far over my head that I cannot pose it correctly. Thank you.

I am new at scripting and am trying to learn how to develop scripts to assist building. I am studying the OpenAlign script by Edward L. Platt and find that I am super confused by some of the operations it performs when translating from rotations to faces to textures. Is there any reference that explains how prims information is accessed, or the meta model used to record this information? Any assistance or suggestions would be appreciated. Thank you